From f4a5093718c8a945213c5a50e44406dd2fdc71b6 Mon Sep 17 00:00:00 2001 From: Glam0rgan <49109723+Glam0rgan@users.noreply.github.com> Date: Fri, 13 Oct 2023 21:53:53 +0800 Subject: [PATCH 1/6] Initial commit --- README.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..191c190 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# memblock \ No newline at end of file From 5c0cf69b72e59615f30c3043f019b0926de837de Mon Sep 17 00:00:00 2001 From: Glam0rgan <49109723+Glam0rgan@users.noreply.github.com> Date: Fri, 13 Oct 2023 21:55:41 +0800 Subject: [PATCH 2/6] Update README.md --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 191c190..b6cfdd4 100644 --- a/README.md +++ b/README.md @@ -1 +1,2 @@ -# memblock \ No newline at end of file +# memblock +memblock for toy_kernel From 21496a80cd684ee74c58a16f6feb52e43cc2a533 Mon Sep 17 00:00:00 2001 From: Glamorgan <1742771620@qq.com> Date: Fri, 13 Oct 2023 22:26:05 +0800 Subject: [PATCH 3/6] fix bug --- Makefile | 135 ++ include/acpi.h | 33 + include/asm.h | 21 + include/console.h | 0 include/defs.h | 24 + include/memblock.h | 36 + include/memlayout.h | 22 + include/mmu.h | 121 ++ include/param.h | 12 + include/proc.h | 14 + include/spinlock.h | 0 include/syscall.h | 2 + include/traps.h | 0 include/types.h | 30 + include/types32.h | 16 + include/vm.h | 0 include/x86.h | 184 +++ kernel/acpi.c | 86 ++ kernel/bootasm.S | 110 ++ kernel/bootmain.c | 118 ++ kernel/console.c | 203 +++ kernel/entry64.S | 173 +++ kernel/kernel64.ld | 65 + kernel/main.c | 10 + kernel/memblock.c | 285 ++++ kernel/physical_memory.c | 72 + kernel/proc.c | 10 + kernel/slab/mem.h | 27 + kernel/slab/memory.h | 146 ++ kernel/slab/slab.c | 393 +++++ kernel/string.c | 85 ++ kernel/syscall.c | 22 + kernel/trap.c | 16 + kernel/trapasm.S | 44 + kernel/vm.c | 77 + kobj/console.d | 4 + kobj/console.o | Bin 0 -> 12488 bytes kobj/entry64.o | Bin 0 -> 3080 bytes kobj/main.d | 2 + kobj/main.o | Bin 0 -> 4016 bytes kobj/memblock.d | 2 + kobj/memblock.o | Bin 0 -> 21016 bytes kobj/string.d | 1 + kobj/string.o | Bin 0 -> 8224 bytes kobj/vm.d | 2 + kobj/vm.o | Bin 0 -> 6800 bytes out/bootasm.o | Bin 0 -> 996 bytes out/bootblock | Bin 0 -> 512 bytes out/bootblock.asm | 230 +++ out/bootblock.o | Bin 0 -> 1732 bytes out/bootmain.o | Bin 0 -> 1424 bytes out/kernel.asm | 3023 ++++++++++++++++++++++++++++++++++++++ out/kernel.elf | Bin 0 -> 32840 bytes out/kernel.sym | 71 + tools/dot-bochsrc | 738 ++++++++++ tools/gdbinit.tmpl | 27 + tools/gdbutil | 291 ++++ tools/mkfs.c | 298 ++++ tools/printpcs | 14 + tools/sign.pl | 19 + tools/sleep1.p | 134 ++ tools/spinp | 16 + tools/vectors.pl | 47 + tools/vectors64.pl | 27 + xv6.img | Bin 0 -> 5120000 bytes 65 files changed, 7538 insertions(+) create mode 100644 Makefile create mode 100644 include/acpi.h create mode 100644 include/asm.h create mode 100644 include/console.h create mode 100644 include/defs.h create mode 100644 include/memblock.h create mode 100644 include/memlayout.h create mode 100644 include/mmu.h create mode 100644 include/param.h create mode 100644 include/proc.h create mode 100644 include/spinlock.h create mode 100644 include/syscall.h create mode 100644 include/traps.h create mode 100644 include/types.h create mode 100644 include/types32.h create mode 100644 include/vm.h create mode 100644 include/x86.h create mode 100644 kernel/acpi.c create mode 100644 kernel/bootasm.S create mode 100644 kernel/bootmain.c create mode 100644 kernel/console.c create mode 100644 kernel/entry64.S create mode 100644 kernel/kernel64.ld create mode 100644 kernel/main.c create mode 100644 kernel/memblock.c create mode 100644 kernel/physical_memory.c create mode 100644 kernel/proc.c create mode 100644 kernel/slab/mem.h create mode 100644 kernel/slab/memory.h create mode 100644 kernel/slab/slab.c create mode 100644 kernel/string.c create mode 100644 kernel/syscall.c create mode 100644 kernel/trap.c create mode 100644 kernel/trapasm.S create mode 100644 kernel/vm.c create mode 100644 kobj/console.d create mode 100644 kobj/console.o create mode 100644 kobj/entry64.o create mode 100644 kobj/main.d create mode 100644 kobj/main.o create mode 100644 kobj/memblock.d create mode 100644 kobj/memblock.o create mode 100644 kobj/string.d create mode 100644 kobj/string.o create mode 100644 kobj/vm.d create mode 100644 kobj/vm.o create mode 100644 out/bootasm.o create mode 100644 out/bootblock create mode 100644 out/bootblock.asm create mode 100644 out/bootblock.o create mode 100644 out/bootmain.o create mode 100644 out/kernel.asm create mode 100644 out/kernel.elf create mode 100644 out/kernel.sym create mode 100644 tools/dot-bochsrc create mode 100644 tools/gdbinit.tmpl create mode 100644 tools/gdbutil create mode 100644 tools/mkfs.c create mode 100644 tools/printpcs create mode 100644 tools/sign.pl create mode 100644 tools/sleep1.p create mode 100644 tools/spinp create mode 100644 tools/vectors.pl create mode 100644 tools/vectors64.pl create mode 100644 xv6.img diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..54046e8 --- /dev/null +++ b/Makefile @@ -0,0 +1,135 @@ +-include local.mk + +X64 ?= yes + +ifeq ("$(X64)","yes") +BITS = 64 +XOBJS = kobj/vm64.o +XFLAGS = -m64 -DX64 -mcmodel=kernel -mtls-direct-seg-refs -mno-red-zone +LDFLAGS = -m elf_x86_64 +QEMU ?= qemu-system-x86_64 +else +XFLAGS = -m32 +LDFLAGS = -m elf_i386 +QEMU ?= qemu-system-i386 +endif + +OPT ?= -O0 + +OBJS := \ + kobj/console.o\ + kobj/main.o\ + kobj/string.o\ + kobj/vm.o\ + kobj/memblock.o\ + +ifneq ("$(MEMFS)","") +# build filesystem image in to kernel and use memory-ide-device +# instead of mounting the filesystem on ide1 +OBJS := $(filter-out kobj/ide.o,$(OBJS)) kobj/memide.o +endif + +# Cross-compiling (e.g., on Mac OS X) +#TOOLPREFIX = i386-jos-elf- + +# Using native tools (e.g., on X86 Linux) +#TOOLPREFIX = + +CC = $(TOOLPREFIX)gcc +AS = $(TOOLPREFIX)gas +LD = $(TOOLPREFIX)ld +OBJCOPY = $(TOOLPREFIX)objcopy +OBJDUMP = $(TOOLPREFIX)objdump +CFLAGS = -fno-pic -static -fno-builtin -fno-strict-aliasing -Wall -MD -ggdb -fno-omit-frame-pointer +CFLAGS += -ffreestanding -fno-common -nostdlib -Iinclude -gdwarf-2 $(XFLAGS) $(OPT) +CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector) +ASFLAGS = -fno-pic -gdwarf-2 -Wa,-divide -Iinclude $(XFLAGS) + +xv6.img: out/bootblock out/kernel.elf + dd if=/dev/zero of=xv6.img count=10000 + dd if=out/bootblock of=xv6.img conv=notrunc + dd if=out/kernel.elf of=xv6.img seek=1 conv=notrunc + +xv6memfs.img: out/bootblock out/kernelmemfs.elf + dd if=/dev/zero of=xv6memfs.img count=10000 + dd if=out/bootblock of=xv6memfs.img conv=notrunc + dd if=out/kernelmemfs.elf of=xv6memfs.img seek=1 conv=notrunc + +# kernel object files +kobj/%.o: kernel/%.c + @mkdir -p kobj + $(CC) $(CFLAGS) -c -o $@ $< + +kobj/%.o: kernel/%.S + @mkdir -p kobj + $(CC) $(ASFLAGS) -c -o $@ $< + +out/bootblock: kernel/bootasm.S kernel/bootmain.c + @mkdir -p out + $(CC) -fno-builtin -fno-pic -m32 -nostdinc -Iinclude -O -o out/bootmain.o -c kernel/bootmain.c + $(CC) -fno-builtin -fno-pic -m32 -nostdinc -Iinclude -o out/bootasm.o -c kernel/bootasm.S + $(LD) -m elf_i386 -N -e start -Ttext 0x7C00 -o out/bootblock.o out/bootasm.o out/bootmain.o + $(OBJDUMP) -S out/bootblock.o > out/bootblock.asm + $(OBJCOPY) -S -O binary -j .text out/bootblock.o out/bootblock + tools/sign.pl out/bootblock + +ENTRYCODE = kobj/entry$(BITS).o +LINKSCRIPT = kernel/kernel$(BITS).ld +out/kernel.elf: $(OBJS) $(ENTRYCODE) $(LINKSCRIPT) + $(LD) $(LDFLAGS) -T $(LINKSCRIPT) -o out/kernel.elf $(ENTRYCODE) $(OBJS) -b binary + $(OBJDUMP) -S out/kernel.elf > out/kernel.asm + $(OBJDUMP) -t out/kernel.elf | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > out/kernel.sym + +MKVECTORS = tools/vectors$(BITS).pl +kernel/vectors.S: $(MKVECTORS) + perl $(MKVECTORS) > kernel/vectors.S + +# 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: uobj/%.o + +-include */*.d + +clean: + rm -rf out fs uobj kobj + rm -f kernel/vectors.S xv6.img xv6memfs.img fs.img .gdbinit + +# run in emulators + +bochs : fs.img xv6.img + if [ ! -e .bochsrc ]; then ln -s tools/dot-bochsrc .bochsrc; fi + bochs -q + +# try to generate a unique GDB port +GDBPORT = $(shell expr `id -u` % 5000 + 25000) +# QEMU's gdb stub command line changed in 0.11 +QEMUGDB = $(shell if $(QEMU) -help | grep -q '^-gdb'; \ + then echo "-gdb tcp::$(GDBPORT)"; \ + else echo "-s -p $(GDBPORT)"; fi) +ifndef CPUS +CPUS := 2 +endif +QEMUOPTS = -net none -hda xv6.img -smp $(CPUS) -m 512 $(QEMUEXTRA) + +qemu: xv6.img + $(QEMU) -serial mon:stdio $(QEMUOPTS) + +qemu-memfs: xv6memfs.img + $(QEMU) xv6memfs.img -smp $(CPUS) + +qemu-nox: fs.img xv6.img + $(QEMU) -nographic $(QEMUOPTS) + +.gdbinit: tools/gdbinit.tmpl + sed "s/localhost:1234/localhost:$(GDBPORT)/" < $^ > $@ + +qemu-gdb: fs.img xv6.img .gdbinit + @echo "*** Now run 'gdb'." 1>&2 + $(QEMU) -serial mon:stdio $(QEMUOPTS) -S $(QEMUGDB) + +qemu-nox-gdb: fs.img xv6.img .gdbinit + @echo "*** Now run 'gdb'." 1>&2 + $(QEMU) -nographic $(QEMUOPTS) -S $(QEMUGDB) + diff --git a/include/acpi.h b/include/acpi.h new file mode 100644 index 0000000..ab61db2 --- /dev/null +++ b/include/acpi.h @@ -0,0 +1,33 @@ +// https://uefi.org/htmlspecs/ACPI_Spec_6_4_html/index.html# +// 5.2.5.3 +#define SIG_RDSP "RSD PTR " +struct acpi_rdsp { + u8 signature[8]; + u8 checksum; + u8 oem_id[6]; + u8 revision; + u32 rsdt_phys_addr; + u32 length; + u64 xsdt_phys_addr; + u8 extended_checksum; + u8 reserved[3]; +} __attribute__((__packed__)); + +// 5.2.6 +struct acpi_desc_header { + u8 signature[4]; + u32 length; + u8 revision; + u8 checksum; + u8 oem_id[6]; + u8 oem_table_id[8]; + u32 oem_revision; + u8 creator_id[4]; + u32 creator_revision; +} __attribute__((__packed__)); + +// 5.2.8 +struct acpi_xsdt{ + struct acpi_desc_header header; + u64 entry[0]; +} __attribute__((__packed__)); \ No newline at end of file diff --git a/include/asm.h b/include/asm.h new file mode 100644 index 0000000..68210d7 --- /dev/null +++ b/include/asm.h @@ -0,0 +1,21 @@ +// +// assembler macros to create x86 segments +// + +#define SEG_NULLASM \ + .word 0, 0; \ + .byte 0, 0, 0, 0 + +// The 0xC0 means the limit is in 4096-byte units +// and (for executable segments) 32-bit mode. +#define SEG_ASM(type,base,lim) \ + .word (((lim) >> 12) & 0xffff), ((base) & 0xffff); \ + .byte (((base) >> 16) & 0xff), (0x90 | (type)), \ + (0xC0 | (((lim) >> 28) & 0xf)), (((base) >> 24) & 0xff) + +#define STA_X 0x8 // Executable segment +#define STA_E 0x4 // Expand down (non-executable segments) +#define STA_C 0x4 // Conforming code segment (executable only) +#define STA_W 0x2 // Writeable (non-executable segments) +#define STA_R 0x2 // Readable (executable segments) +#define STA_A 0x1 // Accessed diff --git a/include/console.h b/include/console.h new file mode 100644 index 0000000..e69de29 diff --git a/include/defs.h b/include/defs.h new file mode 100644 index 0000000..ca42538 --- /dev/null +++ b/include/defs.h @@ -0,0 +1,24 @@ +struct list_head; +struct proc; + +// console.c +void cprintf(char* fmt, ...); +void panic(char* s); + +// memblock.c + +void memblock_init(void); +u64 memblock_alloc(u64 size, u64 align); + +// proc.c +//void test(void); + +// string.c +int memcmp(const void*, const void*, u32); +void* memmove(void*, const void*, u32); +void* memset(void*, int, u32); +char* safestrcpy(char*, const char*, int); +int strlen(const char*); +int strncmp(const char*, const char*, u32); +char* strncpy(char*, const char*, int); + diff --git a/include/memblock.h b/include/memblock.h new file mode 100644 index 0000000..7c7792d --- /dev/null +++ b/include/memblock.h @@ -0,0 +1,36 @@ +#define ULLONG_MAX (~0ULL) + +#define MEMBLOCK_ALLOC_ACCESSIBLE 0 + +struct memblock_region{ + u64 base; + u64 size; + //enum memblock_flags flags; +}; + +struct memblock_type{ + u64 cnt; + u64 max; + u64 total_size; + struct memblock_region* regions; + char* name; +}; + +struct memblock{ + struct memblock_type memory; + struct memblock_type reserved; +}memblock; + +#define for_each_free_mem_range_reserve(i, p_start, p_end) \ + for_each_mem_range_rev(i, &memblock.memory, &memblock.reserved, p_start, p_end) + +#define for_each_mem_range_rev(i, type_a, type_b, p_start, p_end) \ + for (i = (u64)ULLONG_MAX, __next_mem_range_rev(&i, type_a, type_b, p_start, p_end); \ + i != (u64)ULLONG_MAX; __next_mem_range_rev(&i, type_a, type_b, p_start, p_end)) + +#define for_each_memblock_type(i, memblock_type, rgn) \ + for (i = 0, rgn = &memblock_type->regions[0]; \ + i < memblock_type->cnt; \ + i++, rgn = &memblock_type->regions[i]) + +#define ULLONG_MAX (~0ULL) diff --git a/include/memlayout.h b/include/memlayout.h new file mode 100644 index 0000000..c203e8c --- /dev/null +++ b/include/memlayout.h @@ -0,0 +1,22 @@ + +#define EXTMEM 0x100000 // Start of extended memory + +#define KERNBASE 0xFFFFFFFF80000000 // First kernel address +#define DEVBASE 0xFFFFFFFF40000000 // First device virtual address +#define ARDSOFFSET 0x8000 // ARDS offset + +#define KERNLINK (KERNBASE+EXTMEM) // Address where kernel is linked + +#ifndef __ASSEMBLER__ + +static inline u64 v2p(void *a) { return ((u64) (a)) - ((u64)KERNBASE); } +static inline void *p2v(u64 a) { return (void *) ((a) + ((u64)KERNBASE)); } + +#endif + +#define V2P(a) (((uintp) (a)) - KERNBASE) +#define P2V(a) (((void *) (a)) + KERNBASE) +#define IO2V(a) (((void *) (a)) + DEVBASE - DEVSPACE) + +#define V2P_WO(x) ((x) - KERNBASE) // same as V2P, but without casts +#define P2V_WO(x) ((x) + KERNBASE) // same as V2P, but without casts diff --git a/include/mmu.h b/include/mmu.h new file mode 100644 index 0000000..ed7357a --- /dev/null +++ b/include/mmu.h @@ -0,0 +1,121 @@ +// A virtual address 'va' has a five-part structute as follow +// +--------10------+--------10------+--------10------+-------10-------+---------12----------+ +// | Page-Map | Page Directory | Page Directory | Page Table | Offset within Page | +// | Level-4 Index | Pointer Index | Index | Index | | +// +----------------+----------------+----------------+----------------+---------------------+ +// \--- PML4X(va) --/ \--- PDPTX(va) --/ \--- PDX(va) --/ \--- PTX(va) --/ + +// Page Directory Pointer Index +#define PML4X(va) (((u64)(va) >> PML4XSHIFT ) & PXMASK) +#define PDPTX(va) (((u64)(va) >> PDPTXSHIFT ) & PXMASK) +#define PDX(va) (((u64)(va) >> PDXSHIFT ) & PXMASK) +#define PTX(va) (((u64)(va) >> PTXSHIFT ) & PXMASK) + +// Page directory and page table constants. +#define PGSIZE 4096 // bytes a page + +#define PTXSHIFT 12 // offset of PTX in a linear address +#define PDXSHIFT 21 // offset of PDX in a linear address +#define PDPTXSHIFT 30 // offset of PDPX in a linear address +#define PML4XSHIFT 39 // offset of PML4 in a linear address + +#define PXMASK 0x1FF + +#define ALIGN(x,a) (((x) + (a) -1) & ~(a-1)) +#define ALIGN_DOWN(x,a) ((x) & ~(a-1)) + +// Page entry flags +#define PTE_P 0x001 // Present +#define PTE_W 0x002 // Read/write +#define PTE_U 0x004 // User/supervisor +#define PTE_PWT 0x008 // Write-Through +#define PTE_PCD 0x010 // Cache-Disable +#define PTE_A 0x020 // Accessed +#define PTE_D 0x040 // Dirty +#define PTE_PS 0x080 // Page Size +#define PTE_MBZ 0x180 // Bits must be zero + +// Control Register flags +#define CR0_PE 0x00000001 // Protection Enable +#define CR0_MP 0x00000002 // Monitor coProcessor +#define CR0_EM 0x00000004 // Emulation +#define CR0_TS 0x00000008 // Task Switched +#define CR0_ET 0x00000010 // Extension Type +#define CR0_NE 0x00000020 // Numeric Errror +#define CR0_WP 0x00010000 // Write Protect +#define CR0_AM 0x00040000 // Alignment Mask +#define CR0_NW 0x20000000 // Not Writethrough +#define CR0_CD 0x40000000 // Cache Disable +#define CR0_PG 0x80000000 // Paging + +#define CR4_PSE 0x00000010 // Page size extension + +#define SEG_KCODE 1 // kernel code +#define SEG_KDATA 2 // kernel data+stack +#define SEG_KCPU 3 // kernel per-cpu data +#define SEG_UCODE 4 // user code +#define SEG_UDATA 5 // user data+stack +#define SEG_TSS 6 // this process's task state + +#define BUUDY_TYPES 12 +#define NULL ((void* )0) + +#ifndef __ASSEMBLER__ + +struct MEMORY_E820{ + int nr_map; + struct{ + u64 addr; + u64 len; + u32 type; + }__attribute__((packed)) map[32]; +}; + +// Segment Descriptor +struct segdesc { + u32 lim_15_0 : 16; // Low bits of segment limit + u32 base_15_0 : 16; // Low bits of segment base address + u32 base_23_16 : 8; // Middle bits of segment base address + u32 type : 4; // Segment type (see STS_ constants) + u32 s : 1; // 0 = system, 1 = application + u32 dpl : 2; // Descriptor Privilege Level + u32 p : 1; // Present + u32 lim_19_16 : 4; // High bits of segment limit + u32 avl : 1; // Unused (available for software use) + u32 rsv1 : 1; // Reserved + u32 db : 1; // 0 = 16-bit segment, 1 = 32-bit segment + u32 g : 1; // Granularity: limit scaled by 4K when set + u32 base_31_24 : 8; // High bits of segment base address +}; + +// Normal segment +#define SEG(type, base, lim, dpl) (struct segdesc) \ +{ ((lim) >> 12) & 0xffff, (uint)(base) & 0xffff, \ + ((uintp)(base) >> 16) & 0xff, type, 1, dpl, 1, \ + (uintp)(lim) >> 28, 0, 0, 1, 1, (uintp)(base) >> 24 } +#define SEG16(type, base, lim, dpl) (struct segdesc) \ +{ (lim) & 0xffff, (uintp)(base) & 0xffff, \ + ((uintp)(base) >> 16) & 0xff, type, 1, dpl, 1, \ + (uintp)(lim) >> 16, 0, 0, 1, 0, (uintp)(base) >> 24 } + +struct list_head{ + struct list_head *next, *prev; +}; + +struct free_area{ + //struct list_head free_list; + u64 nr_free; +}; + +//struct zone{ +// struct free_area free_area[BUUDY_TYPES]; + +//}zone1; + +struct page{ + //struct list_head lru; + u64 vaddr; + u64 paddr; +}__attribute__((packed)); + +#endif diff --git a/include/param.h b/include/param.h new file mode 100644 index 0000000..b6f6f46 --- /dev/null +++ b/include/param.h @@ -0,0 +1,12 @@ +#define NPROC 64 // maximum number of processes +#define KSTACKSIZE 4096 // size of per-process kernel stack +#define NCPU 8 // maximum number of CPUs +#define NOFILE 16 // open files per process +#define NFILE 100 // open files per system +#define NBUF 10 // size of disk block cache +#define NINODE 50 // maximum number of active i-nodes +#define NDEV 10 // maximum major device number +#define ROOTDEV 1 // device number of file system root disk +#define MAXARG 32 // max exec arguments +#define LOGSIZE 10 // max data sectors in on-disk log + diff --git a/include/proc.h b/include/proc.h new file mode 100644 index 0000000..e4cea06 --- /dev/null +++ b/include/proc.h @@ -0,0 +1,14 @@ +enum procstate { UNUSED, EMBRYO, SLEEPING, RUNNING, ZOMBIE}; + +struct proc{ + u64 size; + u64* pgdir; + u8* kstack; + enum procstate state; + volatile int pid; + struct proc *parent; + struct trapframe* tf; + struct context* context; + int killed; + char name[16]; +}; diff --git a/include/spinlock.h b/include/spinlock.h new file mode 100644 index 0000000..e69de29 diff --git a/include/syscall.h b/include/syscall.h new file mode 100644 index 0000000..1e75354 --- /dev/null +++ b/include/syscall.h @@ -0,0 +1,2 @@ +// System call numbers +#define SYS_test 1 \ No newline at end of file diff --git a/include/traps.h b/include/traps.h new file mode 100644 index 0000000..e69de29 diff --git a/include/types.h b/include/types.h new file mode 100644 index 0000000..fd10c5a --- /dev/null +++ b/include/types.h @@ -0,0 +1,30 @@ +typedef char i8; +typedef short i16; +typedef int i32; +typedef long long i64; + +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned int u32; +typedef unsigned long long u64; + +typedef float f32; +typedef double f64; + +typedef u8 byte; + +typedef u64 uintp; + +typedef u64 pde_t; + +#define min(x,y) ({ \ + typeof(x) _x = (x); \ + typeof(y) _y = (y); \ + (void) (&_x == &_y); \ + _x < _y ? _x : _y; }) + +#define max(x,y) ({ \ + typeof(x) _x = (x); \ + typeof(y) _y = (y); \ + (void) (&_x == &_y); \ + _x > _y ? _x : _y; }) diff --git a/include/types32.h b/include/types32.h new file mode 100644 index 0000000..7d06f4a --- /dev/null +++ b/include/types32.h @@ -0,0 +1,16 @@ +typedef char i8; +typedef short i16; +typedef int i32; +typedef long long i64; + +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned int u32; +typedef unsigned long long u64; + +typedef float f32; +typedef double f64; + +typedef u8 byte; + +typedef u32 pde_t; diff --git a/include/vm.h b/include/vm.h new file mode 100644 index 0000000..e69de29 diff --git a/include/x86.h b/include/x86.h new file mode 100644 index 0000000..a59a69c --- /dev/null +++ b/include/x86.h @@ -0,0 +1,184 @@ +// Routines to let C code use special x86 instructions. + +static inline u8 +inb(u16 port) +{ + u8 data; + + asm volatile("in %1,%0" : "=a" (data) : "d" (port)); + return data; +} + +static inline void +insl(int port, void *addr, int cnt) +{ + asm volatile("cld; rep insl" : + "=D" (addr), "=c" (cnt) : + "d" (port), "0" (addr), "1" (cnt) : + "memory", "cc"); +} + +static inline void +outb(u16 port, u8 data) +{ + asm volatile("out %0,%1" : : "a" (data), "d" (port)); +} + +static inline void +outw(u16 port, u16 data) +{ + asm volatile("out %0,%1" : : "a" (data), "d" (port)); +} + +static inline void +outsl(int port, const void *addr, int cnt) +{ + asm volatile("cld; rep outsl" : + "=S" (addr), "=c" (cnt) : + "d" (port), "0" (addr), "1" (cnt) : + "cc"); +} + +static inline void +stosb(void *addr, int data, int cnt) +{ + asm volatile("cld; rep stosb" : + "=D" (addr), "=c" (cnt) : + "0" (addr), "1" (cnt), "a" (data) : + "memory", "cc"); +} + +static inline void +stosl(void *addr, int data, int cnt) +{ + asm volatile("cld; rep stosl" : + "=D" (addr), "=c" (cnt) : + "0" (addr), "1" (cnt), "a" (data) : + "memory", "cc"); +} + +struct segdesc; + +static inline void +lgdt(struct segdesc *p, int size) +{ + volatile u16 pd[5]; + + pd[0] = size-1; + pd[1] = (u64)p; + pd[2] = (u64)p >> 16; + pd[3] = (u64)p >> 32; + pd[4] = (u64)p >> 48; + asm volatile("lgdt (%0)" : : "r" (pd)); +} + +struct gatedesc; + +static inline void +lidt(struct gatedesc *p, int size) +{ + volatile u16 pd[5]; + + pd[0] = size-1; + pd[1] = (u64)p; + pd[2] = (u64)p >> 16; + pd[3] = (u64)p >> 32; + pd[4] = (u64)p >> 48; +} + +static inline void +ltr(u16 sel) +{ + asm volatile("ltr %0" : : "r" (sel)); +} + +static inline u64 +readeflags(void) +{ + u64 eflags; + asm volatile("pushf; pop %0" : "=r" (eflags)); + return eflags; +} + +static inline void +loadgs(u16 v) +{ + asm volatile("movw %0, %%gs" : : "r" (v)); +} + +static inline void +cli(void) +{ + asm volatile("cli"); +} + +static inline void +sti(void) +{ + asm volatile("sti"); +} + +static inline void +hlt(void) +{ + asm volatile("hlt"); +} + +static inline u32 +xchg(volatile u32 *addr, u64 newval) +{ + u64 result; + + // The + in "+m" denotes a read-modify-write operand. + asm volatile("lock; xchgq %0, %1" : + "+m" (*addr), "=a" (result) : + "1" (newval) : + "cc"); + return result; +} + +static inline u64 +rcr2(void) +{ + u64 val; + asm volatile("mov %%cr2,%0" : "=r" (val)); + return val; +} + +static inline void +lcr3(u64 val) +{ + asm volatile("mov %0,%%cr3" : : "r" (val)); +} + +//PAGEBREAK: 36 +// Layout of the trap frame built on the stack by the +// hardware and by trapasm.S, and passed to trap(). +// lie about some register names in 64bit mode to avoid +// clunky ifdefs in proc.c and trap.c. +struct trapframe { + u64 eax; // rax + u64 rbx; + u64 rcx; + u64 rdx; + u64 rbp; + u64 rsi; + u64 rdi; + u64 r8; + u64 r9; + u64 r10; + u64 r11; + u64 r12; + u64 r13; + u64 r14; + u64 r15; + + u64 trapno; + u64 err; + + u64 rip; // rip + u64 cs; + u64 eflags; // rflags + u64 rsp; // rsp + u64 ds; // ss +}; diff --git a/kernel/acpi.c b/kernel/acpi.c new file mode 100644 index 0000000..bdf7f47 --- /dev/null +++ b/kernel/acpi.c @@ -0,0 +1,86 @@ +#include "acpi.h" + +static struct acpi_rsdp* search_rdsp(u64 base, u64 len){ + u8* p; + for(p = p2v(base); len >= sizeof(struct acpi_rsdp); len -= 4, p -= 4){ + if(memcmp(p, SIG_RSDP, 8) == 0){ + u32 sum, i; + for(sum = 0, i = 0; i < 20; i++){ + sum += p[i]; + } + if((sum & 0xff) == 0) + return (struct acpi_rsdp *) p; + } + } + return (struct acpi_rsdp*) 0; +} + +static struct acpi_rsdp* find_rdsp(void){ + struct acpi_rsdp* rsdp; + phys_addr pa; + pa = *((u16*) P2V(0x40E)) << 4; + if(pa && (rspd = search_rdsp(pa, 1024))){ + return rsdp; + } + return search_rdsp(0xE0000, 0x20000); +} + +static struct acpi_rsdp* find_rdsp_uefi(void){ + return (struct acpi_rsdp*) 0; +} + +static bool acpi_config_smp(struct acpi_madt* madt){ + u32 lapic_addr = madt->lapic_phys_addr; + u32 nioapic = 0; + u8 *ptr, *end; + + ptr = madt->interrupt_controller_structure; + end = ptr + madt->header.length - sizeof(struct acpi_madt); + + while(ptr < end){ + u32 len; + if((end - ptr) < 2) + break; + len = ptr[1]; + if((end - ptr) < len) + break; + switch(p[0]){ + case TYPE_LAPIC: { + struct madt_lapic *lapic = (void*) ptr; + if(len < sizeof(*lapic)) + break; + if(!(lapic->flags & APIC_LAPIC_ENABLED)) + break; + cpus[ncpu].id = ncpu; + cpus[ncpu].apicid = lapic->apic_id; + ncpu++; + break; + } + case TYPE_IOAPIC: { + struct madt_ioapic *ioapic = (void*) ptr; + if (len < sizeof(*ioapic)) + break; + ioapicid = ioapic->id; + nioapic++; + break; + } + } + p += len; + } +} + +bool acpi_init(void){ + struct acpi_rsdp* rdsp; + struct acpi_xsdt* xsdt; + u32 count,i; + + rdsp = find_rdsp(); + xsdt = p2v(rdsp->xsdt_phys_addr); + count = (xsdt->header.length - sizeof(*xsdt)) / 8; + for(i = 0; i < count ; i++){ + struct acpi_desc_header *hdr = p2v(xsdt->entry[n]); + if(memcmp(hdr->signature, SIG_MADT, 4)){ + madt = (void*) hdr; + } + } +} \ No newline at end of file diff --git a/kernel/bootasm.S b/kernel/bootasm.S new file mode 100644 index 0000000..2c79882 --- /dev/null +++ b/kernel/bootasm.S @@ -0,0 +1,110 @@ +#include "asm.h" +#include "memlayout.h" +#include "mmu.h" + +# Start the first CPU: switch to 32-bit protected mode, jump into C. +# The BIOS loads this code from the first sector of the hard disk into +# memory at physical address 0x7c00 and starts executing in real mode +# with %cs=0 %ip=7c00. +.set SMAP, 0x534d4150 + +.code16 # Assemble for 16-bit mode +.globl start +start: + + cli # BIOS enabled interrupts; disable + + # Zero data segment registers DS, ES, and SS. + xorw %ax,%ax # Set %ax to zero + movw %ax,%ds # -> Data Segment + movw %ax,%es # -> Extra Segment + movw %ax,%ss # -> Stack Segment + + # Physical address line A20 is tied to zero so that the first PCs + # with 2 MB would run software that assumed 1 MB. Undo that. +seta20.1: + inb $0x64,%al # Wait for not busy + testb $0x2,%al + jnz seta20.1 + + movb $0xd1,%al # 0xd1 -> port 0x64 + outb %al,$0x64 + +seta20.2: + inb $0x64,%al # Wait for not busy + testb $0x2,%al + jnz seta20.2 + + movb $0xdf,%al # 0xdf -> port 0x60 + outb %al,$0x60 + +probe_memory: + movl $0, 0x8000 + xorl %ebx, %ebx + movw $0x8004, %di +start_probe: + movl $0xE820, %eax + movl $20, %ecx + movl $SMAP, %edx + int $0x15 + jnc cont + movw $12345, 0x8000 + jmp finish_probe +cont: + addw $20, %di + incl 0x8000 + cmpl $0, %ebx + jnz start_probe + +finish_probe: + + # Switch from real to protected mode. Use a bootstrap GDT that makes + # virtual addresses map directly to physical addresses so that the + # effective memory map doesn't change during the transition. + lgdt gdtdesc + movl %cr0, %eax + orl $CR0_PE, %eax + movl %eax, %cr0 + +//PAGEBREAK! + # Complete transition to 32-bit protected mode by using long jmp + # to reload %cs and %eip. The segment descriptors are set up with no + # translation, so that the mapping is still the identity mapping. + ljmp $(SEG_KCODE<<3), $start32 + +.code32 # Tell assembler to generate 32-bit code now. +start32: + # Set up the protected-mode data segment registers + movw $(SEG_KDATA<<3), %ax # Our data segment selector + movw %ax, %ds # -> DS: Data Segment + movw %ax, %es # -> ES: Extra Segment + movw %ax, %ss # -> SS: Stack Segment + movw $0, %ax # Zero segments not ready for use + movw %ax, %fs # -> FS + movw %ax, %gs # -> GS + + # Set up the stack pointer and call into C. + movl $start, %esp + call bootmain + + # If bootmain returns (it shouldn't), trigger a Bochs + # breakpoint if running under Bochs, then loop. + movw $0x8a00, %ax # 0x8a00 -> port 0x8a00 + movw %ax, %dx + outw %ax, %dx + movw $0x8ae0, %ax # 0x8ae0 -> port 0x8a00 + outw %ax, %dx +spin: + jmp spin + +# Bootstrap GDT +.p2align 2 # force 4 byte alignment +gdt: + SEG_NULLASM # null seg + SEG_ASM(STA_X|STA_R, 0x0, 0xffffffff) # code seg + SEG_ASM(STA_W, 0x0, 0xffffffff) # data seg + +gdtdesc: + .word (gdtdesc - gdt - 1) # sizeof(gdt) - 1 + .long gdt # address gdt + diff --git a/kernel/bootmain.c b/kernel/bootmain.c new file mode 100644 index 0000000..64d999a --- /dev/null +++ b/kernel/bootmain.c @@ -0,0 +1,118 @@ +// Boot loader. +// +// Part of the boot sector, along with bootasm.S, which calls bootmain(). +// bootasm.S has put the processor into protected 32-bit mode. +// bootmain() loads a multiboot kernel image from the disk starting at +// sector 1 and then jumps to the kernel entry routine. + +#include "types.h" +#include "x86.h" +#include "memlayout.h" + +#define SECTSIZE 512 + +struct mbheader { + u32 magic; + u32 flags; + u32 checksum; + u32 header_addr; + u32 load_addr; + u32 load_end_addr; + u32 bss_end_addr; + u32 entry_addr; +}; + +void readseg(u8*, u32, u32); + +void +bootmain(void) +{ + struct mbheader *hdr; + void (*entry)(void); + u32 *x; + u32 n; + + x = (u32*) 0x10000; // scratch space + + // multiboot header must be in the first 8192 bytes + readseg((u8*)x, 8192, 0); + + for (n = 0; n < 8192/4; n++) + if (x[n] == 0x1BADB002) + if ((x[n] + x[n+1] + x[n+2]) == 0) + goto found_it; + + // failure + return; + +found_it: + hdr = (struct mbheader *) (x + n); + + if (!(hdr->flags & 0x10000)) + return; // does not have load_* fields, cannot proceed + if (hdr->load_addr > hdr->header_addr) + return; // invalid; + if (hdr->load_end_addr < hdr->load_addr) + return; // no idea how much to load + + readseg((u8*) hdr->load_addr, + (hdr->load_end_addr - hdr->load_addr), + (n * 4) - (hdr->header_addr - hdr->load_addr)); + + if (hdr->bss_end_addr > hdr->load_end_addr) + stosb((void*) hdr->load_end_addr, 0, + hdr->bss_end_addr - hdr->load_end_addr); + + // Call the entry point from the multiboot header. + // Does not return! + entry = (void(*)(void))(hdr->entry_addr); + entry(); +} + +void +waitdisk(void) +{ + // Wait for disk ready. + while((inb(0x1F7) & 0xC0) != 0x40) + ; +} + +// Read a single sector at offset into dst. +void +readsect(void *dst, u32 offset) +{ + // Issue command. + waitdisk(); + outb(0x1F2, 1); // count = 1 + outb(0x1F3, offset); + outb(0x1F4, offset >> 8); + outb(0x1F5, offset >> 16); + outb(0x1F6, (offset >> 24) | 0xE0); + outb(0x1F7, 0x20); // cmd 0x20 - read sectors + + // Read data. + waitdisk(); + insl(0x1F0, dst, SECTSIZE/4); +} + +// Read 'count' bytes at 'offset' from kernel into physical address 'pa'. +// Might copy more than asked. +void +readseg(u8* pa, u32 count, u32 offset) +{ + u8* epa; + + epa = pa + count; + + // Round down to sector boundary. + pa -= offset % SECTSIZE; + + // Translate from bytes to sectors; kernel starts at sector 1. + offset = (offset / SECTSIZE) + 1; + + // If this is too slow, we could read lots of sectors at a time. + // We'd write more to memory than asked, but it doesn't matter -- + // we load in increasing order. + for(; pa < epa; pa += SECTSIZE, offset++) + readsect(pa, offset); +} diff --git a/kernel/console.c b/kernel/console.c new file mode 100644 index 0000000..6fafc39 --- /dev/null +++ b/kernel/console.c @@ -0,0 +1,203 @@ +// Console input and output. +// Input is from the keyboard or serial port. +// Output is written to the screen and serial port. + +#include + +#include "types.h" +#include "defs.h" +#include "param.h" +#include "traps.h" +#include "memlayout.h" +#include "mmu.h" +#include "proc.h" +#include "x86.h" + +static void consputc(int); + +static int panicked = 0; + +/*static struct { + struct spinlock lock; + int locking; +} cons;*/ + +static char digits[] = "0123456789abcdef"; + +static void +printptr(uintp x) { + int i; + for (i = 0; i < (sizeof(uintp) * 2); i++, x <<= 4) + consputc(digits[x >> (sizeof(uintp) * 8 - 4)]); +} + +static void +printint(int xx, int base, int sign) +{ + char buf[16]; + int i; + u32 x; + + if(sign && (sign = xx < 0)) + x = -xx; + else + x = xx; + + i = 0; + do{ + buf[i++] = digits[x % base]; + }while((x /= base) != 0); + + if(sign) + buf[i++] = '-'; + + while(--i >= 0) + consputc(buf[i]); +} +//PAGEBREAK: 50 + +static void printlong(u64 xx, int base, int sign){ + static char digits[] = "0123456789abcdef"; + char buf[16]; + int i; + u64 x; + + if(sign && (sign = xx < 0)) + x = -xx; + else + x = xx; + + i = 0; + do{ + buf[i++] = digits[x % base]; + }while((x /= base) != 0); + + if(sign) + buf[i++] = '-'; + + while(--i >= 0) + consputc(buf[i]); +} + +// Print to the console. only understands %d, %x, %p, %s. +void +cprintf(char *fmt, ...) +{ + va_list ap; + int i, c; //locking; + char *s; + + va_start(ap, fmt); + + //locking = cons.locking; + //if(locking) + // acquire(&cons.lock); + + if (fmt == 0) + panic("null fmt"); + + for(i = 0; (c = fmt[i] & 0xff) != 0; i++){ + if(c != '%'){ + consputc(c); + continue; + } + c = fmt[++i] & 0xff; + if(c == 0) + break; + switch(c){ + case 'd': + printint(va_arg(ap, int), 10, 1); + break; + case 'x': + printint(va_arg(ap, int), 16, 0); + break; + case 'l': + printlong(va_arg(ap, u64), 16, 0); + break; + case 'p': + printptr(va_arg(ap, uintp)); + break; + case 's': + if((s = va_arg(ap, char*)) == 0) + s = "(null)"; + for(; *s; s++) + consputc(*s); + break; + case '%': + consputc('%'); + break; + default: + // Print unknown % sequence to draw attention. + consputc('%'); + consputc(c); + break; + } + } + + //if(locking) + // release(&cons.lock); +} + +void +panic(char *s) +{ + //int i; + //u64 pcs[10]; + + cli(); + //cons.locking = 0; + //cprintf("cpu%d: panic: ", cpu->id); + cprintf(s); + cprintf("\n"); + //getcallerpcs(&s, pcs); + //for(i=0; i<10; i++) + // cprintf(" %p", pcs[i]); + panicked = 1; // freeze other CPU + for(;;) + ; +} + +//PAGEBREAK: 50 +#define BACKSPACE 0x100 +#define CRTPORT 0x3d4 +static u16 *crt = (u16*)P2V(0xb8000); // CGA memory + +static void +cgaputc(int c) +{ + int pos; + + // Cursor position: col + 80*row. + outb(CRTPORT, 14); + pos = inb(CRTPORT+1) << 8; + outb(CRTPORT, 15); + pos |= inb(CRTPORT+1); + + if(c == '\n') + pos += 80 - pos%80; + else if(c == BACKSPACE){ + if(pos > 0) --pos; + } else + crt[pos++] = (c&0xff) | 0x0700; // black on white + + if((pos/80) >= 24){ // Scroll up. + memmove(crt, crt+80, sizeof(crt[0])*23*80); + pos -= 80; + memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos)); + } + + outb(CRTPORT, 14); + outb(CRTPORT+1, pos>>8); + outb(CRTPORT, 15); + outb(CRTPORT+1, pos); + crt[pos] = ' ' | 0x0700; +} + +void +consputc(int c) +{ + cgaputc(c); +} + +#define C(x) ((x)-'@') // Control-x + diff --git a/kernel/entry64.S b/kernel/entry64.S new file mode 100644 index 0000000..b1cca90 --- /dev/null +++ b/kernel/entry64.S @@ -0,0 +1,173 @@ +/* entry64.S + * + * Copyright (c) 2013 Brian Swetland + * + * 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. + * + */ + +#define mboot_magic 0x1badb002 +#define mboot_flags 0x00010000 + +.code32 +.global mboot_header +.global mboot_entry + +mboot_header: + .long mboot_magic + .long mboot_flags + .long (-mboot_magic -mboot_flags) # checksum + .long mboot_load_addr # header_addr + .long mboot_load_addr + .long mboot_load_end + .long mboot_bss_end + .long mboot_entry_addr + +mboot_entry: + +# zero 4 pages for our bootstrap page tables + xor %eax, %eax + mov $0x1000, %edi + mov $0x5000, %ecx + rep stosb + +# P4ML[0] -> 0x2000 (PDPT-A) + mov $(0x2000 | 3), %eax + mov %eax, 0x1000 + +# P4ML[511] -> 0x3000 (PDPT-B) + mov $(0x3000 | 3), %eax + mov %eax, 0x1FF8 + +# PDPT-A[0] -> 0x4000 (PD) + mov $(0x4000 | 3), %eax + mov %eax, 0x2000 + +# PDPT-B[510] -> 0x4000 (PD) + mov $(0x4000 | 3), %eax + mov %eax, 0x3FF0 + +# PD[0..511] -> 0..1022MB + mov $0x83, %eax + mov $0x4000, %ebx + mov $512, %ecx +ptbl_loop: + mov %eax, (%ebx) + add $0x200000, %eax + add $0x8, %ebx + dec %ecx + jnz ptbl_loop + +# Clear ebx for initial processor boot. +# When secondary processors boot, they'll call through +# entry32mp (from entryother), but with a nonzero ebx. +# We'll reuse these bootstrap pagetables and GDT. + xor %ebx, %ebx + +.global entry32mp +entry32mp: +# CR3 -> 0x1000 (P4ML) + mov $0x1000, %eax + mov %eax, %cr3 + + lgdt (gdtr64 - mboot_header + mboot_load_addr) + +# Enable PAE - CR4.PAE=1 + mov %cr4, %eax + bts $5, %eax + mov %eax, %cr4 + +# enable long mode - EFER.LME=1 + mov $0xc0000080, %ecx + rdmsr + bts $8, %eax + wrmsr + +# enable paging + mov %cr0, %eax + bts $31, %eax + mov %eax, %cr0 + +# shift to 64bit segment + ljmp $8,$(entry64low - mboot_header + mboot_load_addr) + +.align 16 +gdtr64: + .word gdt64_end - gdt64_begin - 1; + .quad gdt64_begin - mboot_header + mboot_load_addr + +.align 16 +gdt64_begin: + .long 0x00000000 # 0: null desc + .long 0x00000000 + .long 0x00000000 # 1: Code, R/X, Nonconforming + .long 0x00209800 + .long 0x00000000 # 2: Data, R/W, Expand Down + .long 0x00009000 +gdt64_end: + +.align 16 +.code64 +entry64low: + movq $entry64high, %rax + jmp *%rax + +.global _start +_start: +entry64high: + +# ensure data segment registers are sane + xor %rax, %rax + mov %ax, %ss + mov %ax, %ds + mov %ax, %es + mov %ax, %fs + mov %ax, %gs + +# check to see if we're booting a secondary core + test %ebx, %ebx + jnz entry64mp + +# setup initial stack + mov $0xFFFFFFFF80010000, %rax + mov %rax, %rsp + +# enter main() + jmp main + +.global __deadloop +__deadloop: +# we should never return here... + jmp . + +entry64mp: +# obtain kstack from data block before entryother + mov $0x7000, %rax + mov -16(%rax), %rsp + +.global wrmsr +wrmsr: + mov %rdi, %rcx # arg0 -> msrnum + mov %rsi, %rax # val.low -> eax + shr $32, %rsi + mov %rsi, %rdx # val.high -> edx + wrmsr + retq + diff --git a/kernel/kernel64.ld b/kernel/kernel64.ld new file mode 100644 index 0000000..143beed --- /dev/null +++ b/kernel/kernel64.ld @@ -0,0 +1,65 @@ +/* Simple linker script for the JOS kernel. + See the GNU ld 'info' manual ("info ld") to learn the syntax. */ + +/* OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386") */ +OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64") +OUTPUT_ARCH(i386:x86-64) +ENTRY(_start) + +mboot_load_addr = 0x00100000; + +SECTIONS +{ + /* Link the kernel at this address: "." means the current address */ + /* Must be equal to KERNLINK */ + . = 0xFFFFFFFF80100000; + + PROVIDE(begin = .); + + .text : AT(mboot_load_addr) { + *(.text .rela.text .stub .text.* .gnu.linkonce.t.*) + } + + PROVIDE(etext = .); /* Define the 'etext' symbol to this value */ + + .rodata : { + *(.rodata .rodata.* .gnu.linkonce.r.*) + } + + /* Adjust the address for the data segment to the next page */ + . = ALIGN(0x1000); + + /* Conventionally, Unix linkers provide pseudo-symbols + * etext, edata, and end, at the end of the text, data, and bss. + * For the kernel mapping, we need the address at the beginning + * of the data section, but that's not one of the conventional + * symbols, because the convention started before there was a + * read-only rodata section between text and data. */ + PROVIDE(data = .); + + /* The data segment */ + .data : { + *(.data) + } + + . = ALIGN(0x1000); + + PROVIDE(edata = .); + + .bss : { + *(.bss) + *(COMMON) + } + + . = ALIGN(0x1000); + + PROVIDE(end = .); + + /DISCARD/ : { + *(.eh_frame .rela.eh_frame .note.GNU-stack) + } +} + +mboot_load_end = mboot_load_addr + (edata - begin); +mboot_bss_end = mboot_load_addr + (end - begin); +mboot_entry_addr = mboot_load_addr + (mboot_entry - begin); diff --git a/kernel/main.c b/kernel/main.c new file mode 100644 index 0000000..e1ab3ef --- /dev/null +++ b/kernel/main.c @@ -0,0 +1,10 @@ +#include "types.h" +#include "defs.h" +#include "mmu.h" +#include "memlayout.h" +#include "proc.h" + +int main(void){ + memblock_init(); + panic("ok"); +} diff --git a/kernel/memblock.c b/kernel/memblock.c new file mode 100644 index 0000000..945b978 --- /dev/null +++ b/kernel/memblock.c @@ -0,0 +1,285 @@ +#include "types.h" +#include "memblock.h" +#include "memlayout.h" +#include "mmu.h" +#include "defs.h" + +#define clamp(val, lo, hi) min( (typeof(val))(max(val, lo)),hi) + +// Insert a region to the regions list +int memblock_insert_region(struct memblock_type *type, int idx, u64 base, u64 size){ + struct memblock_region* rgn = &type->regions[idx]; + memmove(rgn + 1, rgn, (type->cnt -idx)* sizeof(*rgn)); + rgn->base = base; + rgn->size = size; + + type->cnt++; + type->total_size+=size; +} + +// Merge the adjacent and continuous regions +int memblock_merge_regions(struct memblock_type *type){ + int i = 0; + + while(i < type->cnt -1){ + struct memblock_region* this = &type->regions[i]; + struct memblock_region* next = &type->regions[i+1]; + + if(this->base + this->size != next->base){ + i++; + continue; + } + + this->size += next->size; + memmove(next, next + 1, (type->cnt -(i+2) * sizeof(*next))); + } +} + +void memblock_remove_region(struct memblock_type* type, u64 i){ + type->total_size -= type->regions[i].size; + memmove(&type->regions[i], &type->regions[i+1], + type->cnt - (i + 1) * sizeof( type->regions[i] )); + type->cnt--; + + if(type->cnt == 0){ + type->cnt = 1; + type->regions[0].base = 0; + type->regions[0].size = 0; + } +} + +// The entry is sorted in default +int memblock_add_regions(struct memblock_type *type,u64 base,u64 size){ + int insert = 0; + u64 obase = base; + u64 end = base + size; + int idx, nr_new; + struct memblock_region* rgn; + + if(!size)return 0; + + if(type->regions[0].size == 0){ + type->regions[0].base = base; + type->regions[0].size = size; + type->total_size = size; + return 0; + } + repeat: + base = obase; + nr_new = 0; + for_each_memblock_type(idx, type, rgn){ + u64 rbase = rgn->base; + u64 rend = rbase + rgn->size; + + if(rbase >= end) + break; + if(rend <= base) + continue; + if(rbase > base){ + nr_new++; + if(insert) + memblock_insert_region(type, idx++, base, rbase-base); + } + base = min(rend, end); + } + + if(base < end){ + nr_new++; + if(insert) + memblock_insert_region(type, idx, base, end-base); + } + + if(!nr_new) + return 0; + + if(!insert){ + if(type->cnt + nr_new > type->max) + //panic(); + insert = 1; + goto repeat; + } + else{ + memblock_merge_regions(type); + return 0; + } +} + +int memblock_add(u64 base, u64 size){ + return memblock_add_regions(&memblock.memory, base, size); +} + +int memblock_reserve(u64 base, u64 size){ + return memblock_add_regions(&memblock.reserved, base, size); +} + +void __next_mem_range_rev(u64* idx, struct memblock_type* type_a, struct memblock_type* type_b, u64 *out_start, u64 *out_end){ + int idx_a = *idx & 0xffffffff; + int idx_b = *idx >> 32; + + if (*idx == (u64)ULLONG_MAX){ + idx_a = type_a->cnt-1; + idx_b = type_b->cnt; + } + + for(; idx_a >= 0; idx_a--){ + struct memblock_region* m = &type_a->regions[idx_a]; + + u64 m_start = m->base; + u64 m_end = m->base + m->size; + + for(; idx_b >= 0; idx_b--){ + struct memblock_region* r; + u64 r_start; + u64 r_end; + + r = &type_b->regions[idx_b]; + r_start = idx_b ? r[-1].base + r[-1].size : 0; + r_end = idx_b < type_b->cnt ? r->base : ULLONG_MAX; + + if(r_end <= m_start) + break; + if(m_end > r_start){ + *out_start = max(m_start, r_start); + *out_end = min(m_end, r_end); + + if(m_start >= r_start) + idx_a--; + else + idx_b--; + *idx = (u32)idx_a | (u64)idx_b << 32; + return; + } + } + } + *idx = ULLONG_MAX; +} + +u64 __memblock_find_range_top_down(u64 start, u64 end, u64 size, u64 align){ + u64 this_start, this_end, cand; + u64 i; + + for_each_free_mem_range_reserve(i, &this_start, &this_end){ + this_start = clamp(this_start, start, end); + this_end = clamp(this_end, start, end); + + // The data is unsigned, so need to judge + if(this_end < size) + continue; + + //cand = round_down(this_end - size, align); + cand = 1; + if(cand >= this_start) + return cand; + } + + return 0; +} + +u64 memblock_find_in_range(u64 size, u64 align, u64 start, u64 end){ + start = max(start, PGSIZE); + end = max(start, end); + + return __memblock_find_range_top_down(start, end, size, align); +} + +static u64 memblock_alloc_range(u64 size, u64 align, u64 start, u64 end){ + u64 found; + + found = memblock_find_in_range(size, align, start, end); + if(found && !memblock_reserve(found,size)){ + //kmemleak_alloc_phys(found, size, 0, 0); + return found; + } + return 0; +} + +u64 __memblock_alloc_base(u64 size, u64 align, u64 max_addr){ + return memblock_alloc_range(size, align, 0, max_addr); +} + +u64 memblock_alloc_base(u64 size, u64 align, u64 max_addr){ + u64 alloc; + + alloc = __memblock_alloc_base(size, align, max_addr); + + if (alloc == 0) + //panic(); + return alloc; +} + +u64 memblock_alloc(u64 size, u64 align){ + return memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE); +} + +int memblock_isolate_range(struct memblock_type* type, u64 base, u64 size, int *start_rgn, int *end_rgn){ + u64 end = base + size; + int idx; + struct memblock_region* rgn; + + *start_rgn = *end_rgn = 0; + + if(!size) + return 0; + + for_each_memblock_type(idx, type, rgn){ + + u64 rbase = rgn->base; + u64 rend = rbase + rgn->size; + + if(rbase >= end) + break; + if(rend <= base) + continue; + + if (rbase < base){ + rgn->base = base; + rgn->size -= base - rbase; + type->total_size -= base - rbase; + memblock_insert_region(type, idx, rbase, base - rbase); + } + else if(rend > end){ + rgn->base = end; + rgn->size -= end - rbase; + type->total_size -= end - rbase; + memblock_insert_region(type, idx--, rbase, end - rbase); + } else{ + if (!*end_rgn) + *start_rgn = idx; + *end_rgn = idx + 1; + } + } +} + +int memblock_remove_range(struct memblock_type* type, u64 base, u64 size){ + int start_rgn, end_rgn; + int i,ret; + + ret = memblock_isolate_range(type, base, size, &start_rgn, &end_rgn); + if(ret) + return ret; + + for(i = end_rgn - 1; i >= start_rgn; i--) + memblock_remove_region(type, i); +} + +int memblock_free(u64 base, u64 size){ + u64 end = base + size -1; + + //kmemleak_free_part_phys(base, size); + return memblock_remove_range(&memblock.reserved, base, size); +} + +void memblock_init(){ + struct MEMORY_E820* ARDS = (struct MEMORY_E820*)(KERNBASE+ARDSOFFSET); + u32 mem_tot = 0; + for(int i=0; i < 32; i++){ + if(ARDS->map[i].type < 1 || ARDS->map[i].type > 4) break; + mem_tot += ARDS->map[i].len; + cprintf("%l %l %x\n", ARDS->map[i].addr, ARDS->map[i].addr+ARDS->map[i].len, ARDS->map[i].type); + if(ARDS->map[i].type == 1){ + memblock_add(ARDS->map[i].addr, ARDS->map[i].len); + //cprintf("%x %x\n", ARDS->map[i].addr, ARDS->map[i].len); + } + } + cprintf("%dMB\n",mem_tot/1048576 + 1); +} diff --git a/kernel/physical_memory.c b/kernel/physical_memory.c new file mode 100644 index 0000000..1c3c198 --- /dev/null +++ b/kernel/physical_memory.c @@ -0,0 +1,72 @@ +#include "mmu.h" + +void add_list(int order, struct list_head* list); +void delete_list(struct list_head* list); + +static inline u64 find_buddy_pfn(u64 page_pfn, int order){ + return page_pfn ^ (1 << order); +} +void expand_buudy(int order, int order_now, struct list_head* list){ + while(order != order_now){ + // get pages_ + struct page* right_pages = (struct page*)list; + add_list(order_now - 1, list + (1U << (order_now - 1))); + order_now --; + } +} + +void add_list(int order,struct list_head* list){ + list->pre = &zone1.free_area[order].free_list; + list->nex = zone1.free_area[order].free_list->nex; + list->nex->pre = list; + zone1.free_area[order].free_list->nex = list; +} + +void delete_list(struct list_head* list){ + list->pre->nex = list->nex; + list->nex->pre = list->pre; + list->pre = NULL; + list->nex = NULL; +} + +struct page* buddy_allocate(int order){ + if(order > 11) return 0; + + struct page* rt_page; + + int nr_pages = 1U << order; + found: + if(zone1.free_area[order].nr_free != 0){ + zone1.free_area[order].nr_free--; + rt_page = (struct page*) &(zone1.free_area[order].free_list->nex); + delete_list(&zone1.free_area[order].free_list->nex); + return rt_page; // return pages + } + for(int i = order+1; i <= 11; ++i){ + if(zone1.free_area[i].nr_free!=0){ + zone1.free_area[i].nr_free--; + expand_buudy(order, i, &zone1.free_area[order].free_list->nex); + delete_list(&zone1.free_area[order].free_list->nex); + goto found; + } + } + + return 0; +} + +static inline int page_is_buddy(){ + +} + +void free_buddy(struct page* pages,int pfn, int order, struct list_head* list){ + + u64 buddy_pfn = find_buddy_pfn(pfn,order); + while(order < BUDDY_TYPES - 1){ + + } +} + +void init_buddy(){ + +} + diff --git a/kernel/proc.c b/kernel/proc.c new file mode 100644 index 0000000..6f8a9b3 --- /dev/null +++ b/kernel/proc.c @@ -0,0 +1,10 @@ +#include "proc.h" +#include "defs.h" +#include "x86.h" +#include "types.h" +#include "memlayout.h" +#include "mmu.h" + +void test(){ + panic("test!!!"); +} \ No newline at end of file diff --git a/kernel/slab/mem.h b/kernel/slab/mem.h new file mode 100644 index 0000000..978b6d2 --- /dev/null +++ b/kernel/slab/mem.h @@ -0,0 +1,27 @@ +struct Slab_cache{ + u64 size; + u64 total_using; + u64 total_free; + struct Slab* cache_pool; + struct Slab* cache_dma_pool; + void* (* constructor)(void* Vaddr,u64 arg); + void* (* destructor)(void* Vaddr,u64 arg); +}; + +struct Slab{ + struct List_head list; + struct Page* page; + + u64 using_count; + u64 free_count; + + void* vaddr; + u64 map_length; + u64 map_count; + u64* color_map; +}; + +struct mem_manager{ + +}; + diff --git a/kernel/slab/memory.h b/kernel/slab/memory.h new file mode 100644 index 0000000..e902789 --- /dev/null +++ b/kernel/slab/memory.h @@ -0,0 +1,146 @@ +#ifndef MEMORY_H +#define MEMORY_H + +#define PAGE_2M_SHIFT 21 +#define PAGE_2M_SIZE (1UL << PAGE_2M_SHIFT) +#define PAGE_4K_SIZE (1UL << PAGE_4K_SHIFT) +#define PAGE_2M_MASK (~(PAGE_2M_SIZE - 1)) +#define PAGE_4K_MASK (~(PAGE_4K_SIZE - 1)) +#define PAGE_OFFSET ((unsigned long)BASE) + +#define AREABASE 0xffff800000000000 +#define MAPBASE 0xffff800000000200 +#define TABLE3BASE 0x12000 +#define AREASIZE 10 + +int AREANUM; + +struct MEMORY_E820{ + unsigned long addr; + unsigned long len; + unsigned int type; +}__attribute__((packed)); + +struct PAGE{ + unsigned long virtual_addr; + unsigned long physical_addr; + unsigned long attr; +}; + +struct SLAB{ + struct PAGE* page; + unsigned long free_count; + unsigned long used_count; + unsigned long map_len; + unsigned char* bitmap; + struct SLAB* prev, *next; +}; + +struct SLAB_CACHE{ + struct SLAB* cache_pool; + unsigned long free_slab; + unsigned long used_slab; + int size; +}Slab_cache[16]; + +struct AREA{ + unsigned long physical_addr; + unsigned long virtual_addr; + unsigned long free_page; + unsigned long end; +}; + +struct MEMORY_MGR{ + struct AREA *area[AREASIZE]; + struct PAGE* pages; + unsigned long free_page; + unsigned long used_page; + unsigned char* bitmap; + unsigned long kernel_start; + unsigned long kernel_end; + int map_len; + int total_page; + int total_slab; +}memory_manager; + + +void InitMemory(); +unsigned long kmalloc(int size); +void kfree(unsigned long addr); + + +struct PTABLE1{ + struct PTABLE2* next; +}__attribute__((packed)); +struct PTABLE2{ + unsigned long* physical_addr; +}__attribute__((packed)); + + + + + + + + + +#define PAGE_2M_ALIGN(addr) (((unsigned long)(addr) + PAGE_2M_SIZE - 1) &\ + PAGE_2M_MASK) + +// 虚拟地址与物理地址的相互转换 +#define Virt_To_Phy(addr) ((unsigned long)(addr) - PAGE_OFFSET) +#define Phy_To_Virt(addr) ((unsigned long)((unsigned long)(addr) + \ +PAGE_OFFSET)) + +////页表属性 +// bit 63 Execution Disable: +#define PAGE_XD (unsigned long)0x1000000000000000 +// bit 12 Page Attribute Table +#define PAGE_PAT (unsigned long)0x1000 +// bit 8 Global Page:1,global;0,part +#define PAGE_Global (unsigned long)0x0100 +// bit 7 Page Size:1,big page;0,small page; +#define PAGE_PS (unsigned long)0x0080 +// bit 6 Dirty:1,dirty;0,clean; +#define PAGE_Dirty (unsigned long)0x0040 +// bit 5 Accessed:1,visited;0,unvisited; +#define PAGE_Accessed (unsigned long)0x0020 +// bit 4 Page Level Cache Disable +#define PAGE_PCD (unsigned long)0x0010 +// bit 3 Page Level Write Through +#define PAGE_PWT (unsigned long)0x0008 +// bit 2 User Supervisor:1,user and supervisor;0,supervisor; +#define PAGE_U_S (unsigned long)0x0004 +// bit 1 Read Write:1,read and write;0,read; +#define PAGE_R_W (unsigned long)0x0002 +// bit 0 Present:1,present;0,no present; +#define PAGE_Present (unsigned long)0x0001 + +//1,0 +#define PAGE_KERNEL_GDT (PAGE_R_W | PAGE_Present) +//1,0 +#define PAGE_KERNEL_DIR (PAGE_R_W | PAGE_Present) +//7,1,0 +#define PAGE_KERNEL_PAGE (PAGE_PS | PAGE_R_W | PAGE_Present) +//2,1,0 +#define PAGE_USER_DIR (PAGE_U_S | PAGE_R_W | PAGE_Present) +//7,2,1,0 +#define PAGE_USER_PAGE (PAGE_PS | PAGE_U_S | PAGE_R_W | PAGE_Present) + + + + + + + + + + + + + + + + + +#endif \ No newline at end of file diff --git a/kernel/slab/slab.c b/kernel/slab/slab.c new file mode 100644 index 0000000..f96a025 --- /dev/null +++ b/kernel/slab/slab.c @@ -0,0 +1,393 @@ +#include "memory.h" +#include "io.h" +#include "lib.h" + +extern char _text; +extern char _etext; +extern char _edata; +extern char _end; + +void search_memory(); +void init_pages(); +void free_page(struct Page*); +struct Page* alloc_page(u64 attr); +struct Page* use_page(int n, u64 attr); + +void init_slab(); +u64 alloc_slab(int i, int size); +struct Slab* create_slab(int size); + +void append_slab(struct Slab* slab, int size); +void delete_slab(struct Slab* slab, int size); + +void init_page_table(); + +void InitMemory(){ + search_memory(); + + init_pages(); + init_slab(); + init_page_table(); +} + +void init_pages(){ + unsigned char* bit_start = memory_manager.bitmap; + struct Page* page = (struct PAGE*)(bit_start + memory_manager.map_len); + memory_manager.pages = page; + u64 i; + //cprintf("bit_start at %ux\n", (u64)bit_start); + + memset(memory_manager.bitmap, 0, memory_manager.map_len); + for (i = 0; i * PAGE_2M_SIZE < Virt_To_Phy(memory_manager.kernel_end); i++){ + use_page(i, PAGE_KERNEL_PAGE); + } + //cprintf("free page start at num %d\n", i); + + u64 pre = i; + for (i = 0; i < AREANUM; i++){ + if (memory_manager.area[i]->free_page <= 0) + continue; + u64 start = memory_manager.area[i]->physical_addr; + u64 idx = start / PAGE_2M_SIZE; + + if (idx < pre) + continue; + for( ; pre < idx; pre++){ + //,cprintf("set %ld\n", pre); + use_page(pre, PAGE_KERNEL_PAGE); + } + for( ; idx <= memory_manager.area[i]->free_page; idx++){ + memory_manager.pages[idx].physical_addr = idx * PAGE_2M_SIZE; + memory_manager.pages[idx].virtual_addr = Phy_To_Virt(memory_manager.pages[idx].physical_addr); + memory_manager.pages[idx].attr = 0; + } + pre = memory_manager.area[i]->end & PAGE_2M_MASK; + } + use_page(5, PAGE_KERNEL_PAGE); + use_page(6, PAGE_KERNEL_PAGE); + use_page(7, PAGE_KERNEL_PAGE); + //cprintf("page end at %ux\n", &memory_manager.pages[memory_manager.free_page]); +} + +void search_memory(){ + AREANUM = 0; + struct MEMORY_E820* p = 0; + struct AREA* area = (struct AREA*)AREABASE; + memory_manager.kernel_start = (u64) &_text; + memory_manager.kernel_end = (u64) &_end; + u64 end = 0; + int i; + p = (struct MEMORY_E820*)0xffff800000007c00; // wait for change the address + for(i = 0; i < 32; i++){ + //cprintf("address: %ux\tlength: %ux\ttype: %ux\n", p->addr, p->len, p->type); + if(p->type == 1){ + area->physical_addr = PAGE_2M_ALIGN(p->addr); + area->virtual_addr = Phy_To_Virt(area->physical_addr); + area->free_page = (p->len + PAGE_2M_ALIGN(p->addr) - p->addr) / PAGE_2M_SIZE; + area->end = p->addr + p->len; + + //cprintf"Area start at physic: %ux, virtual: %ux, free: %ux, total_page: %d\n", + //area->physical_addr, area->virtual_addr, area->free_page, area->free_page); + + memory_manager.area[AREANUM++] = area; + if(end < p->addr + p->len) + end = p->addr + p->len; + } + else if(p->type > 4 || p->type < 1) + break; + p++; + area++; + } + + // cprintf("area end at %ux\n", area); + memory_manager.map_len = (memory_manager.total_page + 63) / 8; + memory_manager.bitmap = (u8 *)MAPBASE; + memory_manager.pages = (struct PAGE*)(MAPBASE + memory_manager.map_len); + memory_manager.total_page = end / PAGE_2M_SIZE; + memory_manager.free_page = memory_manager.total_page; + //cprintf("total memory is %uldMB\n", end / 1024 / 1024); +} + +struct PAGE* use_page(int n, u64 attr){ + if(n >= memory_manager.total_page){ + //cprintf("%d is out of page num\n", n); + return 0; + } + if(memory_manager.bitmap[n / 8] & (u8)(1 << (n % 8))){ + //cprintf("page %d is using\n", n); + return 0; + } + + memory_manager.pages[n].attr = attr; + memory_manager.bitmap[n / 8] |= (u8)(1 << (n % 8)); + + //cprintf("use page %d, start at %ux bitmap %ux\n", n, memory_manager.pages[n].virtual_addr, + // memory_manager.bitmap[n / 8]); + return &memory_manager.pages[n]; +} + +struct PAGE* alloc_page(u64 attr){ + if(memory_manager.free_page <= 0){ + //cprintf("No free page\n"); + return 0; + } + + int i; + for(i = 0;i < memory_manager.map_len; i++){ + if(memory_manager.bitmap[i] >= (u8)(~0)) + continue; + int j; + for(j = 0;j < 8; j++){ + // printf("%ud i:%d j:%d\n", (unsigned int)(memory_manager.bitmap[i] & (1 << j)), i, j); + if(!(memory_manager.bitmap[i] & (u8)(1 << j))){ + memory_manager.used_page++; + memory_manager.free_page--; + return use_page(i * 8 + j, attr); + } + } + } + //cprintf("alloc failed\n"); + return 0; +} + +void free_page(struct PAGE* page){ + if(page == 0){ + //cprintf("Page is null\n"); + return; + } + + int i; + for(i = 0;i < memory_manager.total_page; i++){ + if(&memory_manager.pages[i] == page){ + memory_manager.bitmap[i / 8] &= (~(u8)(1 << (i % 8))); + // cprintf("Free page %d at %ux\n", i, page->virtual_addr); + return; + } + } + + //cprintf("free page fail\n"); +} + +void init_slab(){ + int i, size = 32; + for(i = 0;i < 16; i++){ + Slab_cache[i].size = size; + Slab_cache[i].free_slab = 0; + Slab_cache[i].used_slab = 0; + Slab_cache[i].cache_pool = 0; + size *= 2; + } +} + +// Alloc pages from slab cache pool +u64 kmalloc(int size){ + int i, level = 32; + for(i = 0;i < 16; i++){ + if(level >= size){ + // cprintf("addr at %ux\n", tmp); + return alloc_slab(i, level); + } + level *= 2; + } + //cprintf("size too large %ux\n", size); + return 0; +} + +// +u64 alloc_slab(int i, int size){ + struct SLAB* slab = Slab_cache[i].cache_pool; + + while(slab != 0 && slab->free_count <= 0){ + slab = slab->next; + } + if(slab == 0){ + slab = create_slab(size); + } + if(slab == 0) + return 0; + + int total = slab->free_count + slab->used_count; + for(i = 0;i < total;i++){ + if (slab->bitmap[i / 8] == (u8)(~0)) + continue; + + if(!(slab->bitmap[i / 8] & (1 << (i % 8)))){ + slab->free_count--; + slab->used_count++; + slab->bitmap[i / 8] |= (u8)(1 << (i % 8)); + // cprintf("addr at %ux\n", (u64)slab->page->virtual_addr + i * size); + return (u64)slab->page->physical_addr + i * size; + } + } + + //cprintf("alloc slab error\n"); + return 0; +} + +struct SLAB* create_slab(int size){ + struct PAGE* page = alloc_page(PAGE_KERNEL_PAGE); + struct SLAB* slab = 0; + if (page == 0) + return 0; + + switch (size){ + case 32: + case 64: + case 128: + case 256: + case 512: + slab = (struct SLAB *)page->virtual_addr; + slab->page = page; + slab->bitmap = (u8 *)(page->virtual_addr + sizeof(struct SLAB)); + slab->free_count = (u64)PAGE_2M_SIZE / size; + slab->map_len = slab->free_count / 8; + slab->used_count = (slab->map_len + size - 1 + sizeof(struct SLAB)) / size; + slab->free_count -= slab->used_count; + + // cprintf("slab used_count %d, map_len %d\n", slab->used_count, slab->map_len); + memset(slab->bitmap, 0, slab->map_len); + int i; + for(i = 0;i < slab->used_count; i++){ + slab->bitmap[i / 8] |= (u8)(1 << (i % 8)); + } + slab->next = 0; + // cprintf("slab at %ux\n", slab->page->virtual_addr); + + break; + + case 1024: //1KB + case 2048: + case 4096: //4KB + case 8192: + case 16384: + case 32768: + case 65536: + case 131072: //128KB + case 262144: + case 524288: + case 1048576: //1MB + slab = (struct SLAB *)kmalloc(sizeof(struct SLAB)); + if (slab == 0){ + //cprintf("create slab fail\n"); + return 0; + } + slab->map_len = slab->free_count / 8; + slab->bitmap = (u8*)kmalloc(slab->map_len); + slab->page = page; + slab->free_count = (u64)PAGE_2M_SIZE / size; + slab->used_count = 0; + + memset(slab->bitmap, 0, slab->map_len); + + break; + + default: + //cprintf("size error %d\n", size); + break; + } + append_slab(slab, size); + + return slab; +} + +void append_slab(struct SLAB* slab, int size){ + int i; + int level = 32; + for(i = 0;i < 16; i++){ + if(level == size) + break; + level *= 2; + } + if(i == 16){ + //cprintf("end of slab size error %d\n", size); + return; + } + + struct SLAB* tail = Slab_cache[i].cache_pool; + if(tail == 0){ + Slab_cache[i].cache_pool = slab; + return; + } + + while(tail->next != 0){ + tail = tail->next; + } + tail->next = slab; + slab->prev = tail; + Slab_cache[i].free_slab++; +} + +void delete_slab(struct SLAB* slab, int size){ + if(slab->prev == 0) + return; + + slab->prev->next = slab->next; + slab->next->prev = slab->prev; + + switch(size){ + case 32: + case 64: + case 128: + case 256: + case 512: + free_page(slab->page); + break; + + default: + kfree((u64)slab); + break; + } +} + +void kfree(u64 addr){ + u64 pagebase = addr & PAGE_2M_MASK; + int i; + + for(i = 0; i < 16; i++){ + // Cprintf("search slab\n"); + struct SLAB * slab = Slab_cache[i].cache_pool; + + while(slab != NULL){ + if(slab->page->virtual_addr == pagebase){ + // cprintf("find at %d\n", i); + int idx = (addr - pagebase) / Slab_cache[i].size; + slab->bitmap[idx / 8] &= (unsigned char)(~(1 << idx)); + slab->free_count++; + slab->used_count--; + + if(slab->used_count == 0 && slab->free_count * 3 / 2 <= Slab_cache[i].free_slab + && Slab_cache[i].cache_pool != slab){ + delete_slab(slab, Slab_cache[i].size); + } + + return; + } + slab = slab->next; + } + } + + //cprintf("free error\n"); +} + +void init_page_table(){ + struct PTABLE1 * page_table1 = Phy_To_Virt(Get_CR3()); + struct PTABLE2 * page_table2; + page_table1 += 16 * 16; + + if (page_table1->next != 0) + page_table2 = (struct PTABLE2*)Phy_To_Virt(page_table1->next); + + u64* addr = Phy_To_Virt(TABLE3BASE); + struct Page* page = memory_manager.pages; + int i; + //cprintf("start\n"); + + for(i = 0; i < memory_manager.total_page; i++){ + if(addr[i] != 0) + continue; + addr[i] = (page[i].physical_addr & (~0xfffUL)) | PAGE_KERNEL_PAGE; + } + + flush_tlb(); + //cprintf("\nfinish table\n"); +} \ No newline at end of file diff --git a/kernel/string.c b/kernel/string.c new file mode 100644 index 0000000..c1b4d5c --- /dev/null +++ b/kernel/string.c @@ -0,0 +1,85 @@ +#include "types.h" +#include "x86.h" + +//assign c to dst - dst+n +void* memset(void *dst, i32 c, u32 n){ + if ((u64)dst%4 == 0 && n%4 == 0){ + c &= 0xFF; + stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4); + }else + stosb(dst, c, n); + return dst; +} + +//compare v1 with v2 return v1 - v2 +int memcmp(const void* v1, const void* v2, u32 n){ + const u8 *s1, *s2; + + s1 = v1; + s2 = v2; + while(n-- > 0){ + if(*s1 != *s2) + return *s1 - *s2; + s1++, s2++; + } + + return 0; +} + +//copy n chars from src to dst +void* memmove(void* dst, const void* src, u32 n){ + const char* s; + char* d; + + s = src; + d = dst; + if(s d){ + s+=n; + d+=n; + while(n-- > 0) + *--d = * --s; + } + else + while(n-- < 0) + *d++ = *s++; +} +//compare string +int strncmp(const char* p, const char* q, u32 n){ + while(n > 0 && *p && *p == *q) + n--, p++, q++; + if(n == 0) + return 0; + return (u8)*p - (u8)*q; +} + +//copy string most n char +char* strncpy(char* s, const char* t, i32 n){ + char* os; + + os = s; + while(n-- > 0 && (*s++ = *t++) != 0) + ; + while(n-- > 0) + *s++ = 0; + return os; +} + +//get the length of string +int strlen(const char* s){ + int n; + for(n = 0; s[n]; n++) + ; + return n; +} + +char* safestrcpy(char* s, const char* t, i32 n){ + char *os; + + os = s; + if(n <= 0) + return os; + while(--n > 0 && (*s++ = *t++) != 0) + ; + *s = 0; + return os; +} diff --git a/kernel/syscall.c b/kernel/syscall.c new file mode 100644 index 0000000..398a2f1 --- /dev/null +++ b/kernel/syscall.c @@ -0,0 +1,22 @@ +#include "syscall.h" +#include "proc.h" +#include "defs.h" +#include "types.h" + +extern int sys_test(void); + +static int (*syscall[])(void) = { + [SYS_test] sys_test, +}; + +void syscall(void){ + int num; + + num = myproc()->tf->rax; + if(num > 0 && num < NELEM(syscalls) && syscalls[num]){ + proc->tf->rax = syscalls[num](); + } + else{ + + } +} \ No newline at end of file diff --git a/kernel/trap.c b/kernel/trap.c new file mode 100644 index 0000000..0d71580 --- /dev/null +++ b/kernel/trap.c @@ -0,0 +1,16 @@ +#include "types.h" +#include "x86.h" +#include "trap.h" +#include "proc.h" + +void trap(struct trapframe* tf){ + if(tf->trapno == T_SYSCALL){ + if(myproc()->killed) + exit(); + myproc()->tf = tf; + syscall(); + if(myproc()->killed) + exit(); + return; + } +} \ No newline at end of file diff --git a/kernel/trapasm.S b/kernel/trapasm.S new file mode 100644 index 0000000..fab3c1e --- /dev/null +++ b/kernel/trapasm.S @@ -0,0 +1,44 @@ + +# vectors.S sends all traps here. +.global alltraps +alltraps: + # Build trap frame. + push r15 + push r14 + push r13 + push r12 + push r11 + push r10 + push r9 + push r8 + push rdi + push rsi + push rbp + push rdx + push rcx + push rbx + push rax + + mov rdi, rsp # frame in arg1 + call trap + +.global trapret +trapret: + pop rax + pop rbx + pop rcx + pop rdx + pop rbp + pop rsi + pop rdi + pop r8 + pop r9 + pop r10 + pop r11 + pop r12 + pop r13 + pop r14 + pop r15 + + add rsp, 16 + iretq diff --git a/kernel/vm.c b/kernel/vm.c new file mode 100644 index 0000000..f5c6812 --- /dev/null +++ b/kernel/vm.c @@ -0,0 +1,77 @@ +#include "types.h" +#include "defs.h" +#include "mmu.h" +#include "memlayout.h" + +// Return the address of the PTE in pml4 +// that corresponds to virtual address va. If alloc!=0, +// create any required page table pages. +static u64* page_walk(u64* root,const void* va,int alloc){ + + u64 *pml4e, *pdpte, *pde, *pte; + + // Page map level 4 index + pml4e = &root[PML4X(va)]; + + if(!(*pml4e & PTE_P)){ + if(!alloc || (pml4e = (u64*)memblock_alloc(PGSIZE, PGSIZE)) == 0) + return 0; + memset(pml4e, 0, PGSIZE); + root[PML4X(va)] = v2p(pml4e) | PTE_P | PTE_W | PTE_U; + } + + // Page directory pointer index + pdpte = &pdpte[PDPTX(va)]; + + if(!(*pdpte & PTE_P)){ + if(!alloc || (pdpte = (u64*)memblock_alloc(PGSIZE, PGSIZE)) == 0) + return 0; + memset(pdpte, 0, PGSIZE); + pml4e[PDPTX(va)] = v2p(pdpte) | PTE_P | PTE_W | PTE_U; + } + + // Page directory index + pde = &pde[PDX(va)]; + + if(!(*pde & PTE_P)){ + if(!alloc || (pde = (u64*)memblock_alloc(PGSIZE, PGSIZE)) == 0) + return 0; + memset(pde, 0, PGSIZE); + pdpte[PDX(va)] = v2p(pde) | PTE_P | PTE_W | PTE_U; + } + + // Page table index + pte = &pte[PTX(va)]; + + if(!(*pte & PTE_P)){ + if(!alloc || (pte = (u64*)memblock_alloc(PGSIZE, PGSIZE)) == 0) + return 0; + memset(pte, 0, PGSIZE); + pde[PTX(va)] = v2p(pte) | PTE_P | PTE_W | PTE_U; + } + + return pte; +} + +// Create PTEs for virtual addresses starting at va that refer to +// physical addresses starting at pa. va and size might not +// be page-aligned. +static int mamppages(u64* pml4, void* va, u64 size, u64 pa, int perm){ + char *first, *last; + u64* pte; + + first = (char*)ALIGN_DOWN(((u64)va), ((u64)PGSIZE)); + last = (char*)ALIGN_DOWN(((u64)va), ((u64)PGSIZE)); + while(1){ + if(pte = page_walk(pml4, first, 1) == 0) + return -1; + if(*pte & PTE_P) + panic("remap"); + *pte = pa | perm | PTE_P; + if(first == last) + break; + first += PGSIZE; + pa += PGSIZE; + } + return 0; +} diff --git a/kobj/console.d b/kobj/console.d new file mode 100644 index 0000000..b6a4b38 --- /dev/null +++ b/kobj/console.d @@ -0,0 +1,4 @@ +kobj/console.o: kernel/console.c \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h include/types.h \ + include/defs.h include/param.h include/traps.h include/memlayout.h \ + include/mmu.h include/proc.h include/x86.h diff --git a/kobj/console.o b/kobj/console.o new file mode 100644 index 0000000000000000000000000000000000000000..a919a060168c02a9e9249f4bd6755294b993f808 GIT binary patch literal 12488 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 M|3BwUg=Dq=ABP-~SpWb4 literal 0 HcmV?d00001 diff --git a/kobj/entry64.o b/kobj/entry64.o new file mode 100644 index 0000000000000000000000000000000000000000..962af61e919579ebcddf7bdecfecba96f0a1efc2 GIT binary patch literal 3080 zcmbVOU5Fc16h4!2Yu4J#Ze4$%%8rXxk(x<%<04|ZQPifaRAo_&BI$(8CW}dCnM_<4 zgsxPr9FkW24yp;a6h(ev^Pzfa0g8cZ=P>i{0Jg z!@0TA@wNQoLdjXoqB5rv&l;Vl@(xPY$#xdrneCj)=NI!%!oX}#U?>?d zi8=pYj16NFCJsy*hYd4zB=uAv;wL!vIg~a!~jNY-;#ng%33RA%*W~IISV= z_rB24YfhL3h`kWOfSVb`fP+KoW5S&=W@MT$9yu|~g!oEC4JOinl_-7;V^8z;@L>-rl=+HRzx_vG1I8)l+D*m`u&&vwGPs3p~tTf6E z-(Q7VH4Nr+e9#*H8X@z!ve&9AtK!vGT1=>~)aqMgJvKfh2c!a;FFh>r`pB~`TX^mqhxuFw#`*rT6@g-NOoATK zaIW3s8lF~ue4O#qJZe0UZm%~(w}Lthq^`3ScnvoldhdsjuDYQMY1~ba7HHM0bZX_s zO3T{^thAPWB#TD3QVG2G_BFeK+p2jOLozUr8ujff8@p01dEOkUpbV}r<6H;!@go9g z4-^rW<)AH5VzE9T0 zHmEjYqNcM>YWZItwl$6x+pZ$3j8!9*3%jN@+o~0|3C+d|RwHdpgEe9r9Mkpe@fpi{ zAFNe;i1C^W&xyjc6HLXbtcj|19PJ~>64s3M$kd*CWoqBlj5TXb!y@g6MZJC!AXp}e zu)HzPIyG6DI#xekKU#lm@`*`n4-~G7v%to8Lj(#Fo)~t5)(k^u_h6Z&@eiLYcT0Bx z)@O^&q9Y*dmK4}D%ll{#wzx3O@&kQrlidgr;&C01>adAp`i>;L2)rT|;b~caP3?lG zK0VM!eUAHTcrwE^? zs1095foR2vpNlwAZAU+PDvR1mh7KN$z7ll&v~cP}XwN!Hnma>KS9Y6m60EO9D#}He z^qR5M>lE{yq$}s!vENP7wy);%WNWQh(OP3r3DXX$=_L&+p>*b%RcEtZMlaW_gSdag76J=MWNY?;yhA?lI4&hcl|i>vj{q=J(6yeyRFpk zN_QiHmCF?HRw`wd`zq|a1xdG?^z-<^y1S7kIV?Oue?Qw&K_^XA(#zbQ+Kg1_=05Zk zw$p+{;2y+&*5RN?rwUpnU5GQw%g3C#)n-rSJ?fj==xMca<PF#uzTIJ{7*~%SDxx%W83bMt<-ss8R0PZ;gK%rJrFC)-b^(rk zGzmw>D4Z`d-cB)mi;9~{iFn2MPIkiI-?t0moOQtXU17-G_y9tGw6Q;T3Ul!21F^qz z#BpywAP6*5FkQ3!Iypc4Um?Hyh~pdVk0X%x8#wpt0O6QNe_u#HSi-UH7o;CH@av?X zHt?@VKWE?#($5?C^Q6CG;GdB08~FXCcMP2GNn+qB=@$(A6zP`@oKM_G1|E|Bxq)wy zevP=<|8ESO`~Phz51$Q$SjP8)XNZZqc>!lZ&4oES<{oAoAW=o1F_gU?mMSiB7xr* z-Q zeV(g`A(_6LfQ_nui|TV7tdC!5v;XfW&Qzpqin{%iHicl^Iay6 zWBw@^SuXosqxdq0vg!LJVEFx`<)VwGuPNRkof+?+^&22yPBZ>zia)}R#Lf8c07us) zvNNmE507&HXTiwvjE|~~Irx7nhc=AA8!)9AkC=JK0TOd`|MsI&B1+ds@OR3nc!$>i LQ{S@?%=mu*)MS9v literal 0 HcmV?d00001 diff --git a/kobj/memblock.d b/kobj/memblock.d new file mode 100644 index 0000000..b286fec --- /dev/null +++ b/kobj/memblock.d @@ -0,0 +1,2 @@ +kobj/memblock.o: kernel/memblock.c include/types.h include/memblock.h \ + include/memlayout.h include/mmu.h include/defs.h diff --git a/kobj/memblock.o b/kobj/memblock.o new file mode 100644 index 0000000000000000000000000000000000000000..68b245ff4516afef05688667fb42a8a773ae0961 GIT binary patch literal 21016 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 literal 0 HcmV?d00001 diff --git a/kobj/vm.d b/kobj/vm.d new file mode 100644 index 0000000..5d51e59 --- /dev/null +++ b/kobj/vm.d @@ -0,0 +1,2 @@ +kobj/vm.o: kernel/vm.c include/types.h include/defs.h include/mmu.h \ + include/memlayout.h diff --git a/kobj/vm.o b/kobj/vm.o new file mode 100644 index 0000000000000000000000000000000000000000..57c27ecff76e06b376d94f6f23d68c1b60f52e08 GIT binary patch literal 6800 zcmbtYZ)_Y#6`$Sn`0jjX`)nsp+Jy9qnz)7BId)9a{H>edcH^dhM6sG6sI$J?^BuXn zJ@$6(I1rM?YUwFzNkl|ifzn6_AwdL{kWgew>(J7qQC0Z^L;=27CnH4p;-xd4WD%Qz{w8~$# z$-jrR%CQCQ)WE_NjGfSwnRnj&N9($O(P%%6-q0$}Ol9a@Fq+XW&vmU|gf!XHkzYty{)vVHu~Deok``8h)S1X%0BeRXP0`CX9}C zIn5!bjWtdymvNe3#wqIOGz+2OCpZ;uw|29@X_h%bckMnLM6bGpW|7bjZdHpET}Ehb z38C2~o9+p*>9oqwRju;q^cO1wuR*REZ9SWZnBHEiX|TeN;_kaKh5KKtyocGhV)kdJ zThC6n{%Tr#37ouw+QCb(p%y=U3LI+7U`MqpS8z|cTkjO4dr6B7OvBbvw90Q?(@G4w z1#QQ`yuDI;W?%s~EcDaZzkd`$o_4G9&YPA|&`azqu(9DEw2=E&MqT+f4^?Tz5mn{b z1sZs+XfrkBYN`_Q#)8;2IGcM}Ak>)xS#2O_OCJk_*N!0+av`;$0gcrVbuP$V9u19c zit-Z}Y{Ul(h7$1fC^mGoDKntCk4BUlci`hGc(8DYj3RBy*Fjh2aR?>%!J0r~>W-*_ zF7=vn8uCYQMBT9lW%Y~}9n(SU!c^*+ej4n?pn)@&jz>#4y3JExJx;?9VuHY#i^rRx zXX?%{&O<$uCAG~{54DtRgQ>ehUZw*uQH0*y4#h^!_W9;?VYPkjPdZG@<;v9aC~Q=%PiWo1gJD^VSOpYaNn z1-(sK-_j8Yw5(}qQ`(gnY#;R=7K!Wz2&zLOY@CKp*e%;5J0ja6`#KooN#%iPpv42a zqC2AsfQ_8tSg;iWpb%PWw6DW63*$JHFsal6?1L@SuJkv4e~%j}!kHM`*P%kOqX1OX zBhU<6mC}0_EdVUBXx#wwjX@GZyP_h=xjpz2eb;-d*jegTHXai4xf&J|@__&r5bDFm zVnRMx#m3#2%d_yFcam}!^%!5spRHjrA-`D7ITjPL;E2BDvaEC8MnKU<$nNXvVKE`! zL7vE8$bw_N_#0h+bXuBP%$dSfySE{EfISAfqI}%a3{Uq`0jQEIrt%K#-@}GgH1doU zj6zCl4Ovcf+BkWcVG}-Q=y<4e}O;^H=z)&_Uib#lzQm?@hjPkhk~q zHt-+hq5YrAe>M0=rg+nJzWFBagsA^({>>u)U0(iGb@F#s{kw1S75}Th!&iWR zc#4Ov^TbWwKFFIM;L0QXq0PKKG{?i|dD|mAbe^~D=l6ze9=(XnVB#T%1G(VNgS_?E zyz?|~0>$Bx3p_N*gMlL_pXN>XaOI$?!n%3O)a@=ysgUn8aKT3MX6o>;o`;T=^kOc> zGC8Ykvyx#ImkNa}&sKN3&%s7HnQXizZ0v#8IBc8wZE!^)*V)vZ)^*OB|TBrxFUXnF*m>2cl4 zBzohC$01V&+)HSR!iba0+qt5rlx+xMC-i(yFXy1vu7z31*@=v$7mP&7gqau?;2Fy> z%C=riSItsppS?p;8&2&e+3y_im5hJ2c`HZHMZX=y6=N=i9x#$xVIt5$qiucs|A8hnEy6Hy#Aj zh|$r?#Gf6?(JwLONK9E14Z7dRwP1rkZ0;<4Pxx+KIfqk?nY6D<+qe*2ew zxIg||KHP7gppTUtf5?aX?b~Ui<7Lsks6&r!72y~Mt1tMAmB#(!|1yh}LmXp8h+iAX z*aYrrjIAU=;6Ei@+zrs3D7zzf)40IJJ>WjVF%JGj+eCth|9jH6O87^l4@meQN#8Hw zL!>_`;ST8;3BN-6goN)V{e*Zu`bOBK*Koxw|$il$9?iV8bRxmaPeP4PfB>gGiNCY?;_li@J7u+m7!85zx4}v^RpU`>2S3r-x;tXF+_y)r1_$QRH zmt}xPG~4dRhuB+inBfdi8s?6{A2M zDGt^Txybb!1Wb+z5W7VmSMfe0hE29TPzOW11)6wVa*$M(y^a5BA}YR%7!#Z9p8~Aj z{7djZD%gZS&L7VfdH&x5OpXZ<)5!3eG$^TT9Bk|5zd-rLKE?caX3F`W2Ml8ho*=rd z9mzu5b({4UJiZ4u_52^F0~+_YzX?ClX?7k|jT=krBT_Wv(bK+{10 literal 0 HcmV?d00001 diff --git a/out/bootasm.o b/out/bootasm.o new file mode 100644 index 0000000000000000000000000000000000000000..1c8b2c3f824c4fc7523608b12fa70d4d4ff000d8 GIT binary patch literal 996 zcma)5J7^S96g{(vx)x?vTt6UU5CQ>Z*5v5N9*<+{OKbnHMot0&8Qy zDQpC>w6L@YvIfD$CN>fU3&A2=NLUOQZKF7zJD<&1h+cSe&bjZr_wM`5!o~4RhG8HM z0|VGmz>`$ib0&aMq_GFv#g6yU>v-=zTTfGS+t1!_SP@&_xS>{eV^Pei`03T)qG}KK z$Y10nvobk0G4=MKn-;E~%}}U-xfIUl6`ec(jH9AFSap9!EWY2idvoU8)RS z-&q{6w?D){hWtQ6A0a=M&?Drh61qr!Iib&zUrp!>t-# z2V_}&`43GoH8C~`*VbmKkT1rhgjuIqwx{cMz3I%u)uyATgA`_(4GmRoRNYFHxoK(3 zc4tD@=@Q)8Y6DD$36z^nT{oG+H7=Lq0ahYhAR7CCyTsHG@LaSUaNeD-YqLz$PKcG5 zId(0t?K>KI%hV?FW!L3^|BK_a$@Fq(67ptO0v3J-BYu=9cX~e3<9y?zs|H~)-=yxImzC}&y=o(mD^Ny-(ZmpeybD>wmpvAdA7^|9>Dg>pTOP zo^+l;oM8@7+ph173=D6Y9~`i8DE)CbJh(eXMc~Er|NsB*0E#p0`UE83?fMKPJ8!(} zym9aa$F46RArMnw*H;)*qWQ#wUEe^w9SR_AAVc51SO7GpyGDg)X9Gy=15oVG=iKP{ z!{K3IYr0ERBs%Xi*Qkheeo*}nl+`?Z@EvFKF-FV#W#VDMFYyd}DwMSvDq9xUV0JlJ_0Xc5RKtNsVeyuJWphpqwu)tuW% literal 0 HcmV?d00001 diff --git a/out/bootblock.asm b/out/bootblock.asm new file mode 100644 index 0000000..a49f66c --- /dev/null +++ b/out/bootblock.asm @@ -0,0 +1,230 @@ + +out/bootblock.o: file format elf32-i386 + + +Disassembly of section .text: + +00007c00 : + 7c00: fa cli + 7c01: 31 c0 xor %eax,%eax + 7c03: 8e d8 mov %eax,%ds + 7c05: 8e c0 mov %eax,%es + 7c07: 8e d0 mov %eax,%ss + +00007c09 : + 7c09: e4 64 in $0x64,%al + 7c0b: a8 02 test $0x2,%al + 7c0d: 75 fa jne 7c09 + 7c0f: b0 d1 mov $0xd1,%al + 7c11: e6 64 out %al,$0x64 + +00007c13 : + 7c13: e4 64 in $0x64,%al + 7c15: a8 02 test $0x2,%al + 7c17: 75 fa jne 7c13 + 7c19: b0 df mov $0xdf,%al + 7c1b: e6 60 out %al,$0x60 + +00007c1d : + 7c1d: 66 c7 06 00 80 movw $0x8000,(%esi) + 7c22: 00 00 add %al,(%eax) + 7c24: 00 00 add %al,(%eax) + 7c26: 66 31 db xor %bx,%bx + 7c29: bf .byte 0xbf + 7c2a: 04 80 add $0x80,%al + +00007c2c : + 7c2c: 66 b8 20 e8 mov $0xe820,%ax + 7c30: 00 00 add %al,(%eax) + 7c32: 66 b9 14 00 mov $0x14,%cx + 7c36: 00 00 add %al,(%eax) + 7c38: 66 ba 50 41 mov $0x4150,%dx + 7c3c: 4d dec %ebp + 7c3d: 53 push %ebx + 7c3e: cd 15 int $0x15 + 7c40: 73 08 jae 7c4a + 7c42: c7 06 00 80 39 30 movl $0x30398000,(%esi) + 7c48: eb 0e jmp 7c58 + +00007c4a : + 7c4a: 83 c7 14 add $0x14,%edi + 7c4d: 66 ff 06 incw (%esi) + 7c50: 00 80 66 83 fb 00 add %al,0xfb8366(%eax) + 7c56: 75 d4 jne 7c2c + +00007c58 : + 7c58: 0f 01 16 lgdtl (%esi) + 7c5b: b4 7c mov $0x7c,%ah + 7c5d: 0f 20 c0 mov %cr0,%eax + 7c60: 66 83 c8 01 or $0x1,%ax + 7c64: 0f 22 c0 mov %eax,%cr0 + 7c67: ea .byte 0xea + 7c68: 6c insb (%dx),%es:(%edi) + 7c69: 7c 08 jl 7c73 + ... + +00007c6c : + 7c6c: 66 b8 10 00 mov $0x10,%ax + 7c70: 8e d8 mov %eax,%ds + 7c72: 8e c0 mov %eax,%es + 7c74: 8e d0 mov %eax,%ss + 7c76: 66 b8 00 00 mov $0x0,%ax + 7c7a: 8e e0 mov %eax,%fs + 7c7c: 8e e8 mov %eax,%gs + 7c7e: bc 00 7c 00 00 mov $0x7c00,%esp + 7c83: e8 e5 00 00 00 call 7d6d + 7c88: 66 b8 00 8a mov $0x8a00,%ax + 7c8c: 66 89 c2 mov %ax,%dx + 7c8f: 66 ef out %ax,(%dx) + 7c91: 66 b8 e0 8a mov $0x8ae0,%ax + 7c95: 66 ef out %ax,(%dx) + +00007c97 : + 7c97: eb fe jmp 7c97 + 7c99: 8d 76 00 lea 0x0(%esi),%esi + +00007c9c : + ... + 7ca4: ff (bad) + 7ca5: ff 00 incl (%eax) + 7ca7: 00 00 add %al,(%eax) + 7ca9: 9a cf 00 ff ff 00 00 lcall $0x0,$0xffff00cf + 7cb0: 00 .byte 0x0 + 7cb1: 92 xchg %eax,%edx + 7cb2: cf iret + ... + +00007cb4 : + 7cb4: 17 pop %ss + 7cb5: 00 .byte 0x0 + 7cb6: 9c pushf + 7cb7: 7c 00 jl 7cb9 + ... + +00007cba : + 7cba: ba f7 01 00 00 mov $0x1f7,%edx + 7cbf: ec in (%dx),%al + 7cc0: 83 e0 c0 and $0xffffffc0,%eax + 7cc3: 3c 40 cmp $0x40,%al + 7cc5: 75 f8 jne 7cbf + 7cc7: c3 ret + +00007cc8 : + 7cc8: 57 push %edi + 7cc9: 53 push %ebx + 7cca: 8b 5c 24 10 mov 0x10(%esp),%ebx + 7cce: e8 e7 ff ff ff call 7cba + 7cd3: b8 01 00 00 00 mov $0x1,%eax + 7cd8: ba f2 01 00 00 mov $0x1f2,%edx + 7cdd: ee out %al,(%dx) + 7cde: ba f3 01 00 00 mov $0x1f3,%edx + 7ce3: 89 d8 mov %ebx,%eax + 7ce5: ee out %al,(%dx) + 7ce6: 89 d8 mov %ebx,%eax + 7ce8: c1 e8 08 shr $0x8,%eax + 7ceb: ba f4 01 00 00 mov $0x1f4,%edx + 7cf0: ee out %al,(%dx) + 7cf1: 89 d8 mov %ebx,%eax + 7cf3: c1 e8 10 shr $0x10,%eax + 7cf6: ba f5 01 00 00 mov $0x1f5,%edx + 7cfb: ee out %al,(%dx) + 7cfc: 89 d8 mov %ebx,%eax + 7cfe: c1 e8 18 shr $0x18,%eax + 7d01: 83 c8 e0 or $0xffffffe0,%eax + 7d04: ba f6 01 00 00 mov $0x1f6,%edx + 7d09: ee out %al,(%dx) + 7d0a: b8 20 00 00 00 mov $0x20,%eax + 7d0f: ba f7 01 00 00 mov $0x1f7,%edx + 7d14: ee out %al,(%dx) + 7d15: e8 a0 ff ff ff call 7cba + 7d1a: 8b 7c 24 0c mov 0xc(%esp),%edi + 7d1e: b9 80 00 00 00 mov $0x80,%ecx + 7d23: ba f0 01 00 00 mov $0x1f0,%edx + 7d28: fc cld + 7d29: f3 6d rep insl (%dx),%es:(%edi) + 7d2b: 5b pop %ebx + 7d2c: 5f pop %edi + 7d2d: c3 ret + +00007d2e : + 7d2e: 57 push %edi + 7d2f: 56 push %esi + 7d30: 53 push %ebx + 7d31: 8b 5c 24 10 mov 0x10(%esp),%ebx + 7d35: 8b 74 24 18 mov 0x18(%esp),%esi + 7d39: 89 df mov %ebx,%edi + 7d3b: 03 7c 24 14 add 0x14(%esp),%edi + 7d3f: 89 f0 mov %esi,%eax + 7d41: 25 ff 01 00 00 and $0x1ff,%eax + 7d46: 29 c3 sub %eax,%ebx + 7d48: c1 ee 09 shr $0x9,%esi + 7d4b: 83 c6 01 add $0x1,%esi + 7d4e: 39 df cmp %ebx,%edi + 7d50: 76 17 jbe 7d69 + 7d52: 56 push %esi + 7d53: 53 push %ebx + 7d54: e8 6f ff ff ff call 7cc8 + 7d59: 81 c3 00 02 00 00 add $0x200,%ebx + 7d5f: 83 c6 01 add $0x1,%esi + 7d62: 83 c4 08 add $0x8,%esp + 7d65: 39 df cmp %ebx,%edi + 7d67: 77 e9 ja 7d52 + 7d69: 5b pop %ebx + 7d6a: 5e pop %esi + 7d6b: 5f pop %edi + 7d6c: c3 ret + +00007d6d : + 7d6d: 57 push %edi + 7d6e: 56 push %esi + 7d6f: 53 push %ebx + 7d70: 6a 00 push $0x0 + 7d72: 68 00 20 00 00 push $0x2000 + 7d77: 68 00 00 01 00 push $0x10000 + 7d7c: e8 ad ff ff ff call 7d2e + 7d81: 83 c4 0c add $0xc,%esp + 7d84: b8 00 00 01 00 mov $0x10000,%eax + 7d89: eb 0a jmp 7d95 + 7d8b: 83 c0 04 add $0x4,%eax + 7d8e: 3d 00 20 01 00 cmp $0x12000,%eax + 7d93: 74 35 je 7dca + 7d95: 8d 88 00 00 ff ff lea -0x10000(%eax),%ecx + 7d9b: 89 c3 mov %eax,%ebx + 7d9d: 81 38 02 b0 ad 1b cmpl $0x1badb002,(%eax) + 7da3: 75 e6 jne 7d8b + 7da5: 8b 50 08 mov 0x8(%eax),%edx + 7da8: 03 50 04 add 0x4(%eax),%edx + 7dab: 81 fa fe 4f 52 e4 cmp $0xe4524ffe,%edx + 7db1: 75 d8 jne 7d8b + 7db3: f6 40 06 01 testb $0x1,0x6(%eax) + 7db7: 74 11 je 7dca + 7db9: 8b 40 10 mov 0x10(%eax),%eax + 7dbc: 8b 53 0c mov 0xc(%ebx),%edx + 7dbf: 39 d0 cmp %edx,%eax + 7dc1: 77 07 ja 7dca + 7dc3: 8b 73 14 mov 0x14(%ebx),%esi + 7dc6: 39 f0 cmp %esi,%eax + 7dc8: 76 04 jbe 7dce + 7dca: 5b pop %ebx + 7dcb: 5e pop %esi + 7dcc: 5f pop %edi + 7dcd: c3 ret + 7dce: 01 c1 add %eax,%ecx + 7dd0: 29 d1 sub %edx,%ecx + 7dd2: 51 push %ecx + 7dd3: 29 c6 sub %eax,%esi + 7dd5: 56 push %esi + 7dd6: 50 push %eax + 7dd7: e8 52 ff ff ff call 7d2e + 7ddc: 8b 4b 18 mov 0x18(%ebx),%ecx + 7ddf: 8b 43 14 mov 0x14(%ebx),%eax + 7de2: 83 c4 0c add $0xc,%esp + 7de5: 39 c1 cmp %eax,%ecx + 7de7: 76 0c jbe 7df5 + 7de9: 29 c1 sub %eax,%ecx + 7deb: 89 c7 mov %eax,%edi + 7ded: b8 00 00 00 00 mov $0x0,%eax + 7df2: fc cld + 7df3: f3 aa rep stos %al,%es:(%edi) + 7df5: ff 53 1c call *0x1c(%ebx) + 7df8: eb d0 jmp 7dca diff --git a/out/bootblock.o b/out/bootblock.o new file mode 100644 index 0000000000000000000000000000000000000000..ef9f72f38aa412b3ca35bb9d9af97d2f7e313733 GIT binary patch literal 1732 zcma)7UrbwN6hF7E&~44-POGZ{le%CsqE?ESSpP&S;*5#{b3)@mB zf zG+FtAAGvac*DKHoCHIwbRVgf;P_C|QOpI`2Qw#&r17_ zIx>Hh_lNSYG)t8q48th!nH7J*?`rWnesc?}xrM2Uv-m4h>`KMoYOY70T`JySRPb^c zFS=Seg=O;DX4m;K=GMU7yq-7^F7NL*+vK%oPj1nkZFc9@?lBN;DNn6#)2D^N;>fQ4 zP$h-(@iOj+!08v9fyL1u54>iUzfOaMMuUW#tDHfee!+#q5NKt)UUEE6UV*fSCXN#} zn=6k$Y&(0VF|(ZSaoT$vajzDE|}Xdek#r_ktfIF4gCJQq#S zPc{rgC9?@>4LA9YWP?k>^OB{n@HO18b*EyckdU81{F^aRDG7er}q zXXhi{J^P}Wq?Yme{l0cz>;3+W3H`^~+I+3;Et@nq`MY4-TjHQ=#ttB!@G5!D;4|5V zsjG@Wcfz^Nf_DSoWx)>s-)F&(0zYfP9l$SJa5wNd3*HAjWWlcjpS0j8Fuw&=5y-rg zO~lXtCj27ee1ErMypF;q-Xh}jWvs*cfcc&n=V9lL;RhmNa!OeK?!8THd<4FQ(Hc3R{N#6jCM&ep5uD-FwQCg0~RQV8v!%$RXbSoH2JVbK6x;#q$3HLd;_UOLdNs`Uui@l z&lZ1g`Fyx?-7;(r<{@`OnZ`GRZsJ~s;oueBl3L!qU^tK8MV1ab5py-+SWS7YnhYWD oAOids!ZX3^nKKQG(3Z?0aC!?>*J8L6YRx;0h4_813HN0A3)Do8HUIzs literal 0 HcmV?d00001 diff --git a/out/bootmain.o b/out/bootmain.o new file mode 100644 index 0000000000000000000000000000000000000000..076cfe8de0e030cd79e25a196f809f6667deac06 GIT binary patch literal 1424 zcma)4Ur1A76hC*n>D0@|H5LsVwuc#x^5(?AMbXw;7L}>XKcFOcb2hVWvfXKgR5B>X z5_<2Y=O7Szu{}8^+M~VsrVkN@F)Yg>q;<~Sy=(PS2Y%o0{LXjI`Mz`S_rQ1M0>^Qn z8wW=CtpFB`rJZ(_nn8d%$bQ3&kEzY2)9&Q={D40*Y!|ooi^bw1Rc1fqTFCC=nqDuY z*K=E@>=z1=D`vmyt|j$mGrLD>(MDy|w4k=h%-Dt34=J{TvHji1&`5ruUp*$H*e&S| zo(g@tW}fS8hshU&FPfdrPdZ_QkBm8ZEaF(yF&|unF`Ukd%eKTn79Uk=jU*45o1<$2Y_j8LvBTo z9z%eKnI0QFOh_3Gfjl#LRvAzK@j605oJEv#9vMAMOz{C`_ApBi6McCmcveb9n06lV z1n~+nkNCUp95efv#mB4{nP}*&ttj@?`IynF*5@PLh+3b8^ikCM9Z5qV7E>bfcvK3)v^=hijwdD{9+F2Bp`fBUH_J(&_BY_0 zAI3h!&xm<|Jn;d5Mr=uJBaP3Dz9;dZ#!oc{DRDQV$N^*}UgEIs#Y49xC3HstX;fBZ zkOGMWNWoYn5{hCh8dE}2XIEcKLXm?LAW?QGJTexSBOz@5pLPWE=-XCl`E*Y=1vJy$ z2GlhOw-y(1=4LHMIXF6)5KRcuxUHI^H_)^$kD;dgf926Tr5a)~>UX^4sw?dgTpFuE zT%J>~!gP5RW8~wnP>u4|G@pp(AiIR9oVNonYSUuX$ojmMy)X=u*mx4T7D2O7o`|4c d`mE@}CgzFa}R*$I68$>an?vxfi?-#hB_-FtC literal 0 HcmV?d00001 diff --git a/out/kernel.asm b/out/kernel.asm new file mode 100644 index 0000000..86fa3b7 --- /dev/null +++ b/out/kernel.asm @@ -0,0 +1,3023 @@ + +out/kernel.elf: file format elf64-x86-64 + + +Disassembly of section .text: + +ffffffff80100000 : +ffffffff80100000: 02 b0 ad 1b 00 00 add 0x1bad(%rax),%dh +ffffffff80100006: 01 00 add %eax,(%rax) +ffffffff80100008: fe 4f 51 decb 0x51(%rdi) +ffffffff8010000b: e4 00 in $0x0,%al +ffffffff8010000d: 00 10 add %dl,(%rax) +ffffffff8010000f: 00 00 add %al,(%rax) +ffffffff80100011: 00 10 add %dl,(%rax) +ffffffff80100013: 00 00 add %al,(%rax) +ffffffff80100015: 30 10 xor %dl,(%rax) +ffffffff80100017: 00 00 add %al,(%rax) +ffffffff80100019: 40 10 00 rex adc %al,(%rax) +ffffffff8010001c: 20 00 and %al,(%rax) +ffffffff8010001e: 10 00 adc %al,(%rax) + +ffffffff80100020 : + .long mboot_entry_addr + +mboot_entry: + +# zero 4 pages for our bootstrap page tables + xor %eax, %eax +ffffffff80100020: 31 c0 xor %eax,%eax + mov $0x1000, %edi +ffffffff80100022: bf 00 10 00 00 mov $0x1000,%edi + mov $0x5000, %ecx +ffffffff80100027: b9 00 50 00 00 mov $0x5000,%ecx + rep stosb +ffffffff8010002c: f3 aa rep stos %al,%es:(%rdi) + +# P4ML[0] -> 0x2000 (PDPT-A) + mov $(0x2000 | 3), %eax +ffffffff8010002e: b8 03 20 00 00 mov $0x2003,%eax + mov %eax, 0x1000 +ffffffff80100033: a3 00 10 00 00 b8 03 movabs %eax,0x3003b800001000 +ffffffff8010003a: 30 00 + +# P4ML[511] -> 0x3000 (PDPT-B) + mov $(0x3000 | 3), %eax +ffffffff8010003c: 00 a3 f8 1f 00 00 add %ah,0x1ff8(%rbx) + mov %eax, 0x1FF8 + +# PDPT-A[0] -> 0x4000 (PD) + mov $(0x4000 | 3), %eax +ffffffff80100042: b8 03 40 00 00 mov $0x4003,%eax + mov %eax, 0x2000 +ffffffff80100047: a3 00 20 00 00 b8 03 movabs %eax,0x4003b800002000 +ffffffff8010004e: 40 00 + +# PDPT-B[510] -> 0x4000 (PD) + mov $(0x4000 | 3), %eax +ffffffff80100050: 00 a3 f0 3f 00 00 add %ah,0x3ff0(%rbx) + mov %eax, 0x3FF0 + +# PD[0..511] -> 0..1022MB + mov $0x83, %eax +ffffffff80100056: b8 83 00 00 00 mov $0x83,%eax + mov $0x4000, %ebx +ffffffff8010005b: bb 00 40 00 00 mov $0x4000,%ebx + mov $512, %ecx +ffffffff80100060: b9 00 02 00 00 mov $0x200,%ecx + +ffffffff80100065 : +ptbl_loop: + mov %eax, (%ebx) +ffffffff80100065: 89 03 mov %eax,(%rbx) + add $0x200000, %eax +ffffffff80100067: 05 00 00 20 00 add $0x200000,%eax + add $0x8, %ebx +ffffffff8010006c: 83 c3 08 add $0x8,%ebx + dec %ecx +ffffffff8010006f: 49 75 f3 rex.WB jne ffffffff80100065 + +# Clear ebx for initial processor boot. +# When secondary processors boot, they'll call through +# entry32mp (from entryother), but with a nonzero ebx. +# We'll reuse these bootstrap pagetables and GDT. + xor %ebx, %ebx +ffffffff80100072: 31 db xor %ebx,%ebx + +ffffffff80100074 : + +.global entry32mp +entry32mp: +# CR3 -> 0x1000 (P4ML) + mov $0x1000, %eax +ffffffff80100074: b8 00 10 00 00 mov $0x1000,%eax + mov %eax, %cr3 +ffffffff80100079: 0f 22 d8 mov %rax,%cr3 + + lgdt (gdtr64 - mboot_header + mboot_load_addr) +ffffffff8010007c: 0f 01 15 b0 00 10 00 lgdt 0x1000b0(%rip) # ffffffff80200133 + +# Enable PAE - CR4.PAE=1 + mov %cr4, %eax +ffffffff80100083: 0f 20 e0 mov %cr4,%rax + bts $5, %eax +ffffffff80100086: 0f ba e8 05 bts $0x5,%eax + mov %eax, %cr4 +ffffffff8010008a: 0f 22 e0 mov %rax,%cr4 + +# enable long mode - EFER.LME=1 + mov $0xc0000080, %ecx +ffffffff8010008d: b9 80 00 00 c0 mov $0xc0000080,%ecx + rdmsr +ffffffff80100092: 0f 32 rdmsr + bts $8, %eax +ffffffff80100094: 0f ba e8 08 bts $0x8,%eax + wrmsr +ffffffff80100098: 0f 30 wrmsr + +# enable paging + mov %cr0, %eax +ffffffff8010009a: 0f 20 c0 mov %cr0,%rax + bts $31, %eax +ffffffff8010009d: 0f ba e8 1f bts $0x1f,%eax + mov %eax, %cr0 +ffffffff801000a1: 0f 22 c0 mov %rax,%cr0 + +# shift to 64bit segment + ljmp $8,$(entry64low - mboot_header + mboot_load_addr) +ffffffff801000a4: ea (bad) +ffffffff801000a5: e0 00 loopne ffffffff801000a7 +ffffffff801000a7: 10 00 adc %al,(%rax) +ffffffff801000a9: 08 00 or %al,(%rax) +ffffffff801000ab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff801000b0 : +ffffffff801000b0: 17 (bad) +ffffffff801000b1: 00 c0 add %al,%al +ffffffff801000b3: 00 10 add %dl,(%rax) +ffffffff801000b5: 00 00 add %al,(%rax) +ffffffff801000b7: 00 00 add %al,(%rax) +ffffffff801000b9: 00 66 0f add %ah,0xf(%rsi) +ffffffff801000bc: 1f (bad) +ffffffff801000bd: 44 00 00 add %r8b,(%rax) + +ffffffff801000c0 : + ... +ffffffff801000cc: 00 98 20 00 00 00 add %bl,0x20(%rax) +ffffffff801000d2: 00 00 add %al,(%rax) +ffffffff801000d4: 00 .byte 0x0 +ffffffff801000d5: 90 nop + ... + +ffffffff801000d8 : +ffffffff801000d8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff801000df: 00 + +ffffffff801000e0 : +gdt64_end: + +.align 16 +.code64 +entry64low: + movq $entry64high, %rax +ffffffff801000e0: 48 c7 c0 e9 00 10 80 mov $0xffffffff801000e9,%rax + jmp *%rax +ffffffff801000e7: ff e0 jmp *%rax + +ffffffff801000e9 <_start>: +.global _start +_start: +entry64high: + +# ensure data segment registers are sane + xor %rax, %rax +ffffffff801000e9: 48 31 c0 xor %rax,%rax + mov %ax, %ss +ffffffff801000ec: 8e d0 mov %eax,%ss + mov %ax, %ds +ffffffff801000ee: 8e d8 mov %eax,%ds + mov %ax, %es +ffffffff801000f0: 8e c0 mov %eax,%es + mov %ax, %fs +ffffffff801000f2: 8e e0 mov %eax,%fs + mov %ax, %gs +ffffffff801000f4: 8e e8 mov %eax,%gs + +# check to see if we're booting a secondary core + test %ebx, %ebx +ffffffff801000f6: 85 db test %ebx,%ebx + jnz entry64mp +ffffffff801000f8: 75 11 jne ffffffff8010010b + +# setup initial stack + mov $0xFFFFFFFF80010000, %rax +ffffffff801000fa: 48 c7 c0 00 00 01 80 mov $0xffffffff80010000,%rax + mov %rax, %rsp +ffffffff80100101: 48 89 c4 mov %rax,%rsp + +# enter main() + jmp main +ffffffff80100104: e9 b1 07 00 00 jmp ffffffff801008ba
+ +ffffffff80100109 <__deadloop>: + +.global __deadloop +__deadloop: +# we should never return here... + jmp . +ffffffff80100109: eb fe jmp ffffffff80100109 <__deadloop> + +ffffffff8010010b : + +entry64mp: +# obtain kstack from data block before entryother + mov $0x7000, %rax +ffffffff8010010b: 48 c7 c0 00 70 00 00 mov $0x7000,%rax + mov -16(%rax), %rsp +ffffffff80100112: 48 8b 60 f0 mov -0x10(%rax),%rsp + +ffffffff80100116 : + +.global wrmsr +wrmsr: + mov %rdi, %rcx # arg0 -> msrnum +ffffffff80100116: 48 89 f9 mov %rdi,%rcx + mov %rsi, %rax # val.low -> eax +ffffffff80100119: 48 89 f0 mov %rsi,%rax + shr $32, %rsi +ffffffff8010011c: 48 c1 ee 20 shr $0x20,%rsi + mov %rsi, %rdx # val.high -> edx +ffffffff80100120: 48 89 f2 mov %rsi,%rdx + wrmsr +ffffffff80100123: 0f 30 wrmsr + retq +ffffffff80100125: c3 ret + +ffffffff80100126 : +// Routines to let C code use special x86 instructions. + +static inline u8 +inb(u16 port) +{ +ffffffff80100126: 55 push %rbp +ffffffff80100127: 48 89 e5 mov %rsp,%rbp +ffffffff8010012a: 48 83 ec 18 sub $0x18,%rsp +ffffffff8010012e: 89 f8 mov %edi,%eax +ffffffff80100130: 66 89 45 ec mov %ax,-0x14(%rbp) + u8 data; + + asm volatile("in %1,%0" : "=a" (data) : "d" (port)); +ffffffff80100134: 0f b7 45 ec movzwl -0x14(%rbp),%eax +ffffffff80100138: 89 c2 mov %eax,%edx +ffffffff8010013a: ec in (%dx),%al +ffffffff8010013b: 88 45 ff mov %al,-0x1(%rbp) + return data; +ffffffff8010013e: 0f b6 45 ff movzbl -0x1(%rbp),%eax +} +ffffffff80100142: c9 leave +ffffffff80100143: c3 ret + +ffffffff80100144 : + "memory", "cc"); +} + +static inline void +outb(u16 port, u8 data) +{ +ffffffff80100144: 55 push %rbp +ffffffff80100145: 48 89 e5 mov %rsp,%rbp +ffffffff80100148: 48 83 ec 08 sub $0x8,%rsp +ffffffff8010014c: 89 f8 mov %edi,%eax +ffffffff8010014e: 89 f2 mov %esi,%edx +ffffffff80100150: 66 89 45 fc mov %ax,-0x4(%rbp) +ffffffff80100154: 89 d0 mov %edx,%eax +ffffffff80100156: 88 45 f8 mov %al,-0x8(%rbp) + asm volatile("out %0,%1" : : "a" (data), "d" (port)); +ffffffff80100159: 0f b6 45 f8 movzbl -0x8(%rbp),%eax +ffffffff8010015d: 0f b7 55 fc movzwl -0x4(%rbp),%edx +ffffffff80100161: ee out %al,(%dx) +} +ffffffff80100162: 90 nop +ffffffff80100163: c9 leave +ffffffff80100164: c3 ret + +ffffffff80100165 : + asm volatile("movw %0, %%gs" : : "r" (v)); +} + +static inline void +cli(void) +{ +ffffffff80100165: 55 push %rbp +ffffffff80100166: 48 89 e5 mov %rsp,%rbp + asm volatile("cli"); +ffffffff80100169: fa cli +} +ffffffff8010016a: 90 nop +ffffffff8010016b: 5d pop %rbp +ffffffff8010016c: c3 ret + +ffffffff8010016d : +} cons;*/ + +static char digits[] = "0123456789abcdef"; + +static void +printptr(uintp x) { +ffffffff8010016d: f3 0f 1e fa endbr64 +ffffffff80100171: 55 push %rbp +ffffffff80100172: 48 89 e5 mov %rsp,%rbp +ffffffff80100175: 48 83 ec 20 sub $0x20,%rsp +ffffffff80100179: 48 89 7d e8 mov %rdi,-0x18(%rbp) + int i; + for (i = 0; i < (sizeof(uintp) * 2); i++, x <<= 4) +ffffffff8010017d: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) +ffffffff80100184: eb 22 jmp ffffffff801001a8 + consputc(digits[x >> (sizeof(uintp) * 8 - 4)]); +ffffffff80100186: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff8010018a: 48 c1 e8 3c shr $0x3c,%rax +ffffffff8010018e: 0f b6 80 00 20 10 80 movzbl -0x7fefe000(%rax),%eax +ffffffff80100195: 0f be c0 movsbl %al,%eax +ffffffff80100198: 89 c7 mov %eax,%edi +ffffffff8010019a: e8 ff 06 00 00 call ffffffff8010089e + for (i = 0; i < (sizeof(uintp) * 2); i++, x <<= 4) +ffffffff8010019f: 83 45 fc 01 addl $0x1,-0x4(%rbp) +ffffffff801001a3: 48 c1 65 e8 04 shlq $0x4,-0x18(%rbp) +ffffffff801001a8: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff801001ab: 83 f8 0f cmp $0xf,%eax +ffffffff801001ae: 76 d6 jbe ffffffff80100186 +} +ffffffff801001b0: 90 nop +ffffffff801001b1: 90 nop +ffffffff801001b2: c9 leave +ffffffff801001b3: c3 ret + +ffffffff801001b4 : + +static void +printint(int xx, int base, int sign) +{ +ffffffff801001b4: f3 0f 1e fa endbr64 +ffffffff801001b8: 55 push %rbp +ffffffff801001b9: 48 89 e5 mov %rsp,%rbp +ffffffff801001bc: 48 83 ec 30 sub $0x30,%rsp +ffffffff801001c0: 89 7d dc mov %edi,-0x24(%rbp) +ffffffff801001c3: 89 75 d8 mov %esi,-0x28(%rbp) +ffffffff801001c6: 89 55 d4 mov %edx,-0x2c(%rbp) + char buf[16]; + int i; + u32 x; + + if(sign && (sign = xx < 0)) +ffffffff801001c9: 83 7d d4 00 cmpl $0x0,-0x2c(%rbp) +ffffffff801001cd: 74 1c je ffffffff801001eb +ffffffff801001cf: 8b 45 dc mov -0x24(%rbp),%eax +ffffffff801001d2: c1 e8 1f shr $0x1f,%eax +ffffffff801001d5: 0f b6 c0 movzbl %al,%eax +ffffffff801001d8: 89 45 d4 mov %eax,-0x2c(%rbp) +ffffffff801001db: 83 7d d4 00 cmpl $0x0,-0x2c(%rbp) +ffffffff801001df: 74 0a je ffffffff801001eb + x = -xx; +ffffffff801001e1: 8b 45 dc mov -0x24(%rbp),%eax +ffffffff801001e4: f7 d8 neg %eax +ffffffff801001e6: 89 45 f8 mov %eax,-0x8(%rbp) +ffffffff801001e9: eb 06 jmp ffffffff801001f1 + else + x = xx; +ffffffff801001eb: 8b 45 dc mov -0x24(%rbp),%eax +ffffffff801001ee: 89 45 f8 mov %eax,-0x8(%rbp) + + i = 0; +ffffffff801001f1: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) + do{ + buf[i++] = digits[x % base]; +ffffffff801001f8: 8b 4d d8 mov -0x28(%rbp),%ecx +ffffffff801001fb: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff801001fe: ba 00 00 00 00 mov $0x0,%edx +ffffffff80100203: f7 f1 div %ecx +ffffffff80100205: 89 d1 mov %edx,%ecx +ffffffff80100207: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff8010020a: 8d 50 01 lea 0x1(%rax),%edx +ffffffff8010020d: 89 55 fc mov %edx,-0x4(%rbp) +ffffffff80100210: 89 ca mov %ecx,%edx +ffffffff80100212: 0f b6 92 00 20 10 80 movzbl -0x7fefe000(%rdx),%edx +ffffffff80100219: 48 98 cltq +ffffffff8010021b: 88 54 05 e0 mov %dl,-0x20(%rbp,%rax,1) + }while((x /= base) != 0); +ffffffff8010021f: 8b 75 d8 mov -0x28(%rbp),%esi +ffffffff80100222: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80100225: ba 00 00 00 00 mov $0x0,%edx +ffffffff8010022a: f7 f6 div %esi +ffffffff8010022c: 89 45 f8 mov %eax,-0x8(%rbp) +ffffffff8010022f: 83 7d f8 00 cmpl $0x0,-0x8(%rbp) +ffffffff80100233: 75 c3 jne ffffffff801001f8 + + if(sign) +ffffffff80100235: 83 7d d4 00 cmpl $0x0,-0x2c(%rbp) +ffffffff80100239: 74 26 je ffffffff80100261 + buf[i++] = '-'; +ffffffff8010023b: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff8010023e: 8d 50 01 lea 0x1(%rax),%edx +ffffffff80100241: 89 55 fc mov %edx,-0x4(%rbp) +ffffffff80100244: 48 98 cltq +ffffffff80100246: c6 44 05 e0 2d movb $0x2d,-0x20(%rbp,%rax,1) + + while(--i >= 0) +ffffffff8010024b: eb 14 jmp ffffffff80100261 + consputc(buf[i]); +ffffffff8010024d: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80100250: 48 98 cltq +ffffffff80100252: 0f b6 44 05 e0 movzbl -0x20(%rbp,%rax,1),%eax +ffffffff80100257: 0f be c0 movsbl %al,%eax +ffffffff8010025a: 89 c7 mov %eax,%edi +ffffffff8010025c: e8 3d 06 00 00 call ffffffff8010089e + while(--i >= 0) +ffffffff80100261: 83 6d fc 01 subl $0x1,-0x4(%rbp) +ffffffff80100265: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) +ffffffff80100269: 79 e2 jns ffffffff8010024d +} +ffffffff8010026b: 90 nop +ffffffff8010026c: 90 nop +ffffffff8010026d: c9 leave +ffffffff8010026e: c3 ret + +ffffffff8010026f : +//PAGEBREAK: 50 + +static void printlong(u64 xx, int base, int sign){ +ffffffff8010026f: f3 0f 1e fa endbr64 +ffffffff80100273: 55 push %rbp +ffffffff80100274: 48 89 e5 mov %rsp,%rbp +ffffffff80100277: 48 83 ec 30 sub $0x30,%rsp +ffffffff8010027b: 48 89 7d d8 mov %rdi,-0x28(%rbp) +ffffffff8010027f: 89 75 d4 mov %esi,-0x2c(%rbp) +ffffffff80100282: 89 55 d0 mov %edx,-0x30(%rbp) + static char digits[] = "0123456789abcdef"; + char buf[16]; + int i; + u64 x; + + if(sign && (sign = xx < 0)) +ffffffff80100285: 83 7d d0 00 cmpl $0x0,-0x30(%rbp) +ffffffff80100289: 74 1a je ffffffff801002a5 +ffffffff8010028b: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%rbp) +ffffffff80100292: 83 7d d0 00 cmpl $0x0,-0x30(%rbp) +ffffffff80100296: 74 0d je ffffffff801002a5 + x = -xx; +ffffffff80100298: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff8010029c: 48 f7 d8 neg %rax +ffffffff8010029f: 48 89 45 f0 mov %rax,-0x10(%rbp) +ffffffff801002a3: eb 08 jmp ffffffff801002ad + else + x = xx; +ffffffff801002a5: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff801002a9: 48 89 45 f0 mov %rax,-0x10(%rbp) + + i = 0; +ffffffff801002ad: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) + do{ + buf[i++] = digits[x % base]; +ffffffff801002b4: 8b 45 d4 mov -0x2c(%rbp),%eax +ffffffff801002b7: 48 63 c8 movslq %eax,%rcx +ffffffff801002ba: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801002be: ba 00 00 00 00 mov $0x0,%edx +ffffffff801002c3: 48 f7 f1 div %rcx +ffffffff801002c6: 48 89 d1 mov %rdx,%rcx +ffffffff801002c9: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff801002cc: 8d 50 01 lea 0x1(%rax),%edx +ffffffff801002cf: 89 55 fc mov %edx,-0x4(%rbp) +ffffffff801002d2: 0f b6 91 20 20 10 80 movzbl -0x7fefdfe0(%rcx),%edx +ffffffff801002d9: 48 98 cltq +ffffffff801002db: 88 54 05 e0 mov %dl,-0x20(%rbp,%rax,1) + }while((x /= base) != 0); +ffffffff801002df: 8b 45 d4 mov -0x2c(%rbp),%eax +ffffffff801002e2: 48 63 f0 movslq %eax,%rsi +ffffffff801002e5: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801002e9: ba 00 00 00 00 mov $0x0,%edx +ffffffff801002ee: 48 f7 f6 div %rsi +ffffffff801002f1: 48 89 45 f0 mov %rax,-0x10(%rbp) +ffffffff801002f5: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp) +ffffffff801002fa: 75 b8 jne ffffffff801002b4 + + if(sign) +ffffffff801002fc: 83 7d d0 00 cmpl $0x0,-0x30(%rbp) +ffffffff80100300: 74 26 je ffffffff80100328 + buf[i++] = '-'; +ffffffff80100302: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80100305: 8d 50 01 lea 0x1(%rax),%edx +ffffffff80100308: 89 55 fc mov %edx,-0x4(%rbp) +ffffffff8010030b: 48 98 cltq +ffffffff8010030d: c6 44 05 e0 2d movb $0x2d,-0x20(%rbp,%rax,1) + + while(--i >= 0) +ffffffff80100312: eb 14 jmp ffffffff80100328 + consputc(buf[i]); +ffffffff80100314: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80100317: 48 98 cltq +ffffffff80100319: 0f b6 44 05 e0 movzbl -0x20(%rbp,%rax,1),%eax +ffffffff8010031e: 0f be c0 movsbl %al,%eax +ffffffff80100321: 89 c7 mov %eax,%edi +ffffffff80100323: e8 76 05 00 00 call ffffffff8010089e + while(--i >= 0) +ffffffff80100328: 83 6d fc 01 subl $0x1,-0x4(%rbp) +ffffffff8010032c: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) +ffffffff80100330: 79 e2 jns ffffffff80100314 +} +ffffffff80100332: 90 nop +ffffffff80100333: 90 nop +ffffffff80100334: c9 leave +ffffffff80100335: c3 ret + +ffffffff80100336 : + +// Print to the console. only understands %d, %x, %p, %s. +void +cprintf(char *fmt, ...) +{ +ffffffff80100336: f3 0f 1e fa endbr64 +ffffffff8010033a: 55 push %rbp +ffffffff8010033b: 48 89 e5 mov %rsp,%rbp +ffffffff8010033e: 48 81 ec f0 00 00 00 sub $0xf0,%rsp +ffffffff80100345: 48 89 bd 18 ff ff ff mov %rdi,-0xe8(%rbp) +ffffffff8010034c: 48 89 b5 58 ff ff ff mov %rsi,-0xa8(%rbp) +ffffffff80100353: 48 89 95 60 ff ff ff mov %rdx,-0xa0(%rbp) +ffffffff8010035a: 48 89 8d 68 ff ff ff mov %rcx,-0x98(%rbp) +ffffffff80100361: 4c 89 85 70 ff ff ff mov %r8,-0x90(%rbp) +ffffffff80100368: 4c 89 8d 78 ff ff ff mov %r9,-0x88(%rbp) +ffffffff8010036f: 84 c0 test %al,%al +ffffffff80100371: 74 20 je ffffffff80100393 +ffffffff80100373: 0f 29 45 80 movaps %xmm0,-0x80(%rbp) +ffffffff80100377: 0f 29 4d 90 movaps %xmm1,-0x70(%rbp) +ffffffff8010037b: 0f 29 55 a0 movaps %xmm2,-0x60(%rbp) +ffffffff8010037f: 0f 29 5d b0 movaps %xmm3,-0x50(%rbp) +ffffffff80100383: 0f 29 65 c0 movaps %xmm4,-0x40(%rbp) +ffffffff80100387: 0f 29 6d d0 movaps %xmm5,-0x30(%rbp) +ffffffff8010038b: 0f 29 75 e0 movaps %xmm6,-0x20(%rbp) +ffffffff8010038f: 0f 29 7d f0 movaps %xmm7,-0x10(%rbp) + va_list ap; + int i, c; //locking; + char *s; + + va_start(ap, fmt); +ffffffff80100393: c7 85 20 ff ff ff 08 movl $0x8,-0xe0(%rbp) +ffffffff8010039a: 00 00 00 +ffffffff8010039d: c7 85 24 ff ff ff 30 movl $0x30,-0xdc(%rbp) +ffffffff801003a4: 00 00 00 +ffffffff801003a7: 48 8d 45 10 lea 0x10(%rbp),%rax +ffffffff801003ab: 48 89 85 28 ff ff ff mov %rax,-0xd8(%rbp) +ffffffff801003b2: 48 8d 85 50 ff ff ff lea -0xb0(%rbp),%rax +ffffffff801003b9: 48 89 85 30 ff ff ff mov %rax,-0xd0(%rbp) + + //locking = cons.locking; + //if(locking) + // acquire(&cons.lock); + + if (fmt == 0) +ffffffff801003c0: 48 83 bd 18 ff ff ff cmpq $0x0,-0xe8(%rbp) +ffffffff801003c7: 00 +ffffffff801003c8: 75 0c jne ffffffff801003d6 + panic("null fmt"); +ffffffff801003ca: 48 c7 c7 28 1d 10 80 mov $0xffffffff80101d28,%rdi +ffffffff801003d1: e8 fe 02 00 00 call ffffffff801006d4 + + for(i = 0; (c = fmt[i] & 0xff) != 0; i++){ +ffffffff801003d6: c7 85 4c ff ff ff 00 movl $0x0,-0xb4(%rbp) +ffffffff801003dd: 00 00 00 +ffffffff801003e0: e9 b8 02 00 00 jmp ffffffff8010069d + if(c != '%'){ +ffffffff801003e5: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp) +ffffffff801003ec: 74 12 je ffffffff80100400 + consputc(c); +ffffffff801003ee: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax +ffffffff801003f4: 89 c7 mov %eax,%edi +ffffffff801003f6: e8 a3 04 00 00 call ffffffff8010089e + continue; +ffffffff801003fb: e9 96 02 00 00 jmp ffffffff80100696 + } + c = fmt[++i] & 0xff; +ffffffff80100400: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp) +ffffffff80100407: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax +ffffffff8010040d: 48 63 d0 movslq %eax,%rdx +ffffffff80100410: 48 8b 85 18 ff ff ff mov -0xe8(%rbp),%rax +ffffffff80100417: 48 01 d0 add %rdx,%rax +ffffffff8010041a: 0f b6 00 movzbl (%rax),%eax +ffffffff8010041d: 0f be c0 movsbl %al,%eax +ffffffff80100420: 25 ff 00 00 00 and $0xff,%eax +ffffffff80100425: 89 85 3c ff ff ff mov %eax,-0xc4(%rbp) + if(c == 0) +ffffffff8010042b: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp) +ffffffff80100432: 0f 84 98 02 00 00 je ffffffff801006d0 + break; + switch(c){ +ffffffff80100438: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp) +ffffffff8010043f: 0f 84 2d 02 00 00 je ffffffff80100672 +ffffffff80100445: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp) +ffffffff8010044c: 0f 8c 2c 02 00 00 jl ffffffff8010067e +ffffffff80100452: 83 bd 3c ff ff ff 78 cmpl $0x78,-0xc4(%rbp) +ffffffff80100459: 0f 8f 1f 02 00 00 jg ffffffff8010067e +ffffffff8010045f: 83 bd 3c ff ff ff 64 cmpl $0x64,-0xc4(%rbp) +ffffffff80100466: 0f 8c 12 02 00 00 jl ffffffff8010067e +ffffffff8010046c: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax +ffffffff80100472: 83 e8 64 sub $0x64,%eax +ffffffff80100475: 83 f8 14 cmp $0x14,%eax +ffffffff80100478: 0f 87 00 02 00 00 ja ffffffff8010067e +ffffffff8010047e: 89 c0 mov %eax,%eax +ffffffff80100480: 48 8b 04 c5 38 1d 10 mov -0x7fefe2c8(,%rax,8),%rax +ffffffff80100487: 80 +ffffffff80100488: 3e ff e0 notrack jmp *%rax + case 'd': + printint(va_arg(ap, int), 10, 1); +ffffffff8010048b: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax +ffffffff80100491: 83 f8 2f cmp $0x2f,%eax +ffffffff80100494: 77 23 ja ffffffff801004b9 +ffffffff80100496: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax +ffffffff8010049d: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff801004a3: 89 d2 mov %edx,%edx +ffffffff801004a5: 48 01 d0 add %rdx,%rax +ffffffff801004a8: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff801004ae: 83 c2 08 add $0x8,%edx +ffffffff801004b1: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp) +ffffffff801004b7: eb 12 jmp ffffffff801004cb +ffffffff801004b9: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax +ffffffff801004c0: 48 8d 50 08 lea 0x8(%rax),%rdx +ffffffff801004c4: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp) +ffffffff801004cb: 8b 00 mov (%rax),%eax +ffffffff801004cd: ba 01 00 00 00 mov $0x1,%edx +ffffffff801004d2: be 0a 00 00 00 mov $0xa,%esi +ffffffff801004d7: 89 c7 mov %eax,%edi +ffffffff801004d9: e8 d6 fc ff ff call ffffffff801001b4 + break; +ffffffff801004de: e9 b3 01 00 00 jmp ffffffff80100696 + case 'x': + printint(va_arg(ap, int), 16, 0); +ffffffff801004e3: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax +ffffffff801004e9: 83 f8 2f cmp $0x2f,%eax +ffffffff801004ec: 77 23 ja ffffffff80100511 +ffffffff801004ee: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax +ffffffff801004f5: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff801004fb: 89 d2 mov %edx,%edx +ffffffff801004fd: 48 01 d0 add %rdx,%rax +ffffffff80100500: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff80100506: 83 c2 08 add $0x8,%edx +ffffffff80100509: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp) +ffffffff8010050f: eb 12 jmp ffffffff80100523 +ffffffff80100511: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax +ffffffff80100518: 48 8d 50 08 lea 0x8(%rax),%rdx +ffffffff8010051c: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp) +ffffffff80100523: 8b 00 mov (%rax),%eax +ffffffff80100525: ba 00 00 00 00 mov $0x0,%edx +ffffffff8010052a: be 10 00 00 00 mov $0x10,%esi +ffffffff8010052f: 89 c7 mov %eax,%edi +ffffffff80100531: e8 7e fc ff ff call ffffffff801001b4 + break; +ffffffff80100536: e9 5b 01 00 00 jmp ffffffff80100696 + case 'l': + printlong(va_arg(ap, u64), 16, 0); +ffffffff8010053b: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax +ffffffff80100541: 83 f8 2f cmp $0x2f,%eax +ffffffff80100544: 77 23 ja ffffffff80100569 +ffffffff80100546: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax +ffffffff8010054d: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff80100553: 89 d2 mov %edx,%edx +ffffffff80100555: 48 01 d0 add %rdx,%rax +ffffffff80100558: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff8010055e: 83 c2 08 add $0x8,%edx +ffffffff80100561: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp) +ffffffff80100567: eb 12 jmp ffffffff8010057b +ffffffff80100569: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax +ffffffff80100570: 48 8d 50 08 lea 0x8(%rax),%rdx +ffffffff80100574: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp) +ffffffff8010057b: 48 8b 00 mov (%rax),%rax +ffffffff8010057e: ba 00 00 00 00 mov $0x0,%edx +ffffffff80100583: be 10 00 00 00 mov $0x10,%esi +ffffffff80100588: 48 89 c7 mov %rax,%rdi +ffffffff8010058b: e8 df fc ff ff call ffffffff8010026f + break; +ffffffff80100590: e9 01 01 00 00 jmp ffffffff80100696 + case 'p': + printptr(va_arg(ap, uintp)); +ffffffff80100595: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax +ffffffff8010059b: 83 f8 2f cmp $0x2f,%eax +ffffffff8010059e: 77 23 ja ffffffff801005c3 +ffffffff801005a0: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax +ffffffff801005a7: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff801005ad: 89 d2 mov %edx,%edx +ffffffff801005af: 48 01 d0 add %rdx,%rax +ffffffff801005b2: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff801005b8: 83 c2 08 add $0x8,%edx +ffffffff801005bb: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp) +ffffffff801005c1: eb 12 jmp ffffffff801005d5 +ffffffff801005c3: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax +ffffffff801005ca: 48 8d 50 08 lea 0x8(%rax),%rdx +ffffffff801005ce: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp) +ffffffff801005d5: 48 8b 00 mov (%rax),%rax +ffffffff801005d8: 48 89 c7 mov %rax,%rdi +ffffffff801005db: e8 8d fb ff ff call ffffffff8010016d + break; +ffffffff801005e0: e9 b1 00 00 00 jmp ffffffff80100696 + case 's': + if((s = va_arg(ap, char*)) == 0) +ffffffff801005e5: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax +ffffffff801005eb: 83 f8 2f cmp $0x2f,%eax +ffffffff801005ee: 77 23 ja ffffffff80100613 +ffffffff801005f0: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax +ffffffff801005f7: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff801005fd: 89 d2 mov %edx,%edx +ffffffff801005ff: 48 01 d0 add %rdx,%rax +ffffffff80100602: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx +ffffffff80100608: 83 c2 08 add $0x8,%edx +ffffffff8010060b: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp) +ffffffff80100611: eb 12 jmp ffffffff80100625 +ffffffff80100613: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax +ffffffff8010061a: 48 8d 50 08 lea 0x8(%rax),%rdx +ffffffff8010061e: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp) +ffffffff80100625: 48 8b 00 mov (%rax),%rax +ffffffff80100628: 48 89 85 40 ff ff ff mov %rax,-0xc0(%rbp) +ffffffff8010062f: 48 83 bd 40 ff ff ff cmpq $0x0,-0xc0(%rbp) +ffffffff80100636: 00 +ffffffff80100637: 75 29 jne ffffffff80100662 + s = "(null)"; +ffffffff80100639: 48 c7 85 40 ff ff ff movq $0xffffffff80101d31,-0xc0(%rbp) +ffffffff80100640: 31 1d 10 80 + for(; *s; s++) +ffffffff80100644: eb 1c jmp ffffffff80100662 + consputc(*s); +ffffffff80100646: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax +ffffffff8010064d: 0f b6 00 movzbl (%rax),%eax +ffffffff80100650: 0f be c0 movsbl %al,%eax +ffffffff80100653: 89 c7 mov %eax,%edi +ffffffff80100655: e8 44 02 00 00 call ffffffff8010089e + for(; *s; s++) +ffffffff8010065a: 48 83 85 40 ff ff ff addq $0x1,-0xc0(%rbp) +ffffffff80100661: 01 +ffffffff80100662: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax +ffffffff80100669: 0f b6 00 movzbl (%rax),%eax +ffffffff8010066c: 84 c0 test %al,%al +ffffffff8010066e: 75 d6 jne ffffffff80100646 + break; +ffffffff80100670: eb 24 jmp ffffffff80100696 + case '%': + consputc('%'); +ffffffff80100672: bf 25 00 00 00 mov $0x25,%edi +ffffffff80100677: e8 22 02 00 00 call ffffffff8010089e + break; +ffffffff8010067c: eb 18 jmp ffffffff80100696 + default: + // Print unknown % sequence to draw attention. + consputc('%'); +ffffffff8010067e: bf 25 00 00 00 mov $0x25,%edi +ffffffff80100683: e8 16 02 00 00 call ffffffff8010089e + consputc(c); +ffffffff80100688: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax +ffffffff8010068e: 89 c7 mov %eax,%edi +ffffffff80100690: e8 09 02 00 00 call ffffffff8010089e + break; +ffffffff80100695: 90 nop + for(i = 0; (c = fmt[i] & 0xff) != 0; i++){ +ffffffff80100696: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp) +ffffffff8010069d: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax +ffffffff801006a3: 48 63 d0 movslq %eax,%rdx +ffffffff801006a6: 48 8b 85 18 ff ff ff mov -0xe8(%rbp),%rax +ffffffff801006ad: 48 01 d0 add %rdx,%rax +ffffffff801006b0: 0f b6 00 movzbl (%rax),%eax +ffffffff801006b3: 0f be c0 movsbl %al,%eax +ffffffff801006b6: 25 ff 00 00 00 and $0xff,%eax +ffffffff801006bb: 89 85 3c ff ff ff mov %eax,-0xc4(%rbp) +ffffffff801006c1: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp) +ffffffff801006c8: 0f 85 17 fd ff ff jne ffffffff801003e5 + } + } + + //if(locking) + // release(&cons.lock); +} +ffffffff801006ce: eb 01 jmp ffffffff801006d1 + break; +ffffffff801006d0: 90 nop +} +ffffffff801006d1: 90 nop +ffffffff801006d2: c9 leave +ffffffff801006d3: c3 ret + +ffffffff801006d4 : + +void +panic(char *s) +{ +ffffffff801006d4: f3 0f 1e fa endbr64 +ffffffff801006d8: 55 push %rbp +ffffffff801006d9: 48 89 e5 mov %rsp,%rbp +ffffffff801006dc: 48 83 ec 10 sub $0x10,%rsp +ffffffff801006e0: 48 89 7d f8 mov %rdi,-0x8(%rbp) + //int i; + //u64 pcs[10]; + + cli(); +ffffffff801006e4: e8 7c fa ff ff call ffffffff80100165 + //cons.locking = 0; + //cprintf("cpu%d: panic: ", cpu->id); + cprintf(s); +ffffffff801006e9: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801006ed: 48 89 c7 mov %rax,%rdi +ffffffff801006f0: b8 00 00 00 00 mov $0x0,%eax +ffffffff801006f5: e8 3c fc ff ff call ffffffff80100336 + cprintf("\n"); +ffffffff801006fa: 48 c7 c7 e0 1d 10 80 mov $0xffffffff80101de0,%rdi +ffffffff80100701: b8 00 00 00 00 mov $0x0,%eax +ffffffff80100706: e8 2b fc ff ff call ffffffff80100336 + //getcallerpcs(&s, pcs); + //for(i=0; i<10; i++) + // cprintf(" %p", pcs[i]); + panicked = 1; // freeze other CPU +ffffffff8010070b: c7 05 eb 28 00 00 01 movl $0x1,0x28eb(%rip) # ffffffff80103000 +ffffffff80100712: 00 00 00 + for(;;) +ffffffff80100715: eb fe jmp ffffffff80100715 + +ffffffff80100717 : +#define CRTPORT 0x3d4 +static u16 *crt = (u16*)P2V(0xb8000); // CGA memory + +static void +cgaputc(int c) +{ +ffffffff80100717: f3 0f 1e fa endbr64 +ffffffff8010071b: 55 push %rbp +ffffffff8010071c: 48 89 e5 mov %rsp,%rbp +ffffffff8010071f: 48 83 ec 20 sub $0x20,%rsp +ffffffff80100723: 89 7d ec mov %edi,-0x14(%rbp) + int pos; + + // Cursor position: col + 80*row. + outb(CRTPORT, 14); +ffffffff80100726: be 0e 00 00 00 mov $0xe,%esi +ffffffff8010072b: bf d4 03 00 00 mov $0x3d4,%edi +ffffffff80100730: e8 0f fa ff ff call ffffffff80100144 + pos = inb(CRTPORT+1) << 8; +ffffffff80100735: bf d5 03 00 00 mov $0x3d5,%edi +ffffffff8010073a: e8 e7 f9 ff ff call ffffffff80100126 +ffffffff8010073f: 0f b6 c0 movzbl %al,%eax +ffffffff80100742: c1 e0 08 shl $0x8,%eax +ffffffff80100745: 89 45 fc mov %eax,-0x4(%rbp) + outb(CRTPORT, 15); +ffffffff80100748: be 0f 00 00 00 mov $0xf,%esi +ffffffff8010074d: bf d4 03 00 00 mov $0x3d4,%edi +ffffffff80100752: e8 ed f9 ff ff call ffffffff80100144 + pos |= inb(CRTPORT+1); +ffffffff80100757: bf d5 03 00 00 mov $0x3d5,%edi +ffffffff8010075c: e8 c5 f9 ff ff call ffffffff80100126 +ffffffff80100761: 0f b6 c0 movzbl %al,%eax +ffffffff80100764: 09 45 fc or %eax,-0x4(%rbp) + + if(c == '\n') +ffffffff80100767: 83 7d ec 0a cmpl $0xa,-0x14(%rbp) +ffffffff8010076b: 75 37 jne ffffffff801007a4 + pos += 80 - pos%80; +ffffffff8010076d: 8b 55 fc mov -0x4(%rbp),%edx +ffffffff80100770: 48 63 c2 movslq %edx,%rax +ffffffff80100773: 48 69 c0 67 66 66 66 imul $0x66666667,%rax,%rax +ffffffff8010077a: 48 c1 e8 20 shr $0x20,%rax +ffffffff8010077e: c1 f8 05 sar $0x5,%eax +ffffffff80100781: 89 d6 mov %edx,%esi +ffffffff80100783: c1 fe 1f sar $0x1f,%esi +ffffffff80100786: 29 f0 sub %esi,%eax +ffffffff80100788: 89 c1 mov %eax,%ecx +ffffffff8010078a: 89 c8 mov %ecx,%eax +ffffffff8010078c: c1 e0 02 shl $0x2,%eax +ffffffff8010078f: 01 c8 add %ecx,%eax +ffffffff80100791: c1 e0 04 shl $0x4,%eax +ffffffff80100794: 89 d1 mov %edx,%ecx +ffffffff80100796: 29 c1 sub %eax,%ecx +ffffffff80100798: b8 50 00 00 00 mov $0x50,%eax +ffffffff8010079d: 29 c8 sub %ecx,%eax +ffffffff8010079f: 01 45 fc add %eax,-0x4(%rbp) +ffffffff801007a2: eb 3d jmp ffffffff801007e1 + else if(c == BACKSPACE){ +ffffffff801007a4: 81 7d ec 00 01 00 00 cmpl $0x100,-0x14(%rbp) +ffffffff801007ab: 75 0c jne ffffffff801007b9 + if(pos > 0) --pos; +ffffffff801007ad: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) +ffffffff801007b1: 7e 2e jle ffffffff801007e1 +ffffffff801007b3: 83 6d fc 01 subl $0x1,-0x4(%rbp) +ffffffff801007b7: eb 28 jmp ffffffff801007e1 + } else + crt[pos++] = (c&0xff) | 0x0700; // black on white +ffffffff801007b9: 8b 45 ec mov -0x14(%rbp),%eax +ffffffff801007bc: 0f b6 c0 movzbl %al,%eax +ffffffff801007bf: 80 cc 07 or $0x7,%ah +ffffffff801007c2: 89 c1 mov %eax,%ecx +ffffffff801007c4: 48 8b 35 4d 18 00 00 mov 0x184d(%rip),%rsi # ffffffff80102018 +ffffffff801007cb: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff801007ce: 8d 50 01 lea 0x1(%rax),%edx +ffffffff801007d1: 89 55 fc mov %edx,-0x4(%rbp) +ffffffff801007d4: 48 98 cltq +ffffffff801007d6: 48 01 c0 add %rax,%rax +ffffffff801007d9: 48 01 f0 add %rsi,%rax +ffffffff801007dc: 89 ca mov %ecx,%edx +ffffffff801007de: 66 89 10 mov %dx,(%rax) + + if((pos/80) >= 24){ // Scroll up. +ffffffff801007e1: 81 7d fc 7f 07 00 00 cmpl $0x77f,-0x4(%rbp) +ffffffff801007e8: 7e 55 jle ffffffff8010083f + memmove(crt, crt+80, sizeof(crt[0])*23*80); +ffffffff801007ea: 48 8b 05 27 18 00 00 mov 0x1827(%rip),%rax # ffffffff80102018 +ffffffff801007f1: 48 8d 88 a0 00 00 00 lea 0xa0(%rax),%rcx +ffffffff801007f8: 48 8b 05 19 18 00 00 mov 0x1819(%rip),%rax # ffffffff80102018 +ffffffff801007ff: ba 60 0e 00 00 mov $0xe60,%edx +ffffffff80100804: 48 89 ce mov %rcx,%rsi +ffffffff80100807: 48 89 c7 mov %rax,%rdi +ffffffff8010080a: e8 28 02 00 00 call ffffffff80100a37 + pos -= 80; +ffffffff8010080f: 83 6d fc 50 subl $0x50,-0x4(%rbp) + memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos)); +ffffffff80100813: b8 80 07 00 00 mov $0x780,%eax +ffffffff80100818: 2b 45 fc sub -0x4(%rbp),%eax +ffffffff8010081b: 48 98 cltq +ffffffff8010081d: 8d 14 00 lea (%rax,%rax,1),%edx +ffffffff80100820: 48 8b 0d f1 17 00 00 mov 0x17f1(%rip),%rcx # ffffffff80102018 +ffffffff80100827: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff8010082a: 48 98 cltq +ffffffff8010082c: 48 01 c0 add %rax,%rax +ffffffff8010082f: 48 01 c8 add %rcx,%rax +ffffffff80100832: be 00 00 00 00 mov $0x0,%esi +ffffffff80100837: 48 89 c7 mov %rax,%rdi +ffffffff8010083a: e8 03 01 00 00 call ffffffff80100942 + } + + outb(CRTPORT, 14); +ffffffff8010083f: be 0e 00 00 00 mov $0xe,%esi +ffffffff80100844: bf d4 03 00 00 mov $0x3d4,%edi +ffffffff80100849: e8 f6 f8 ff ff call ffffffff80100144 + outb(CRTPORT+1, pos>>8); +ffffffff8010084e: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80100851: c1 f8 08 sar $0x8,%eax +ffffffff80100854: 0f b6 c0 movzbl %al,%eax +ffffffff80100857: 89 c6 mov %eax,%esi +ffffffff80100859: bf d5 03 00 00 mov $0x3d5,%edi +ffffffff8010085e: e8 e1 f8 ff ff call ffffffff80100144 + outb(CRTPORT, 15); +ffffffff80100863: be 0f 00 00 00 mov $0xf,%esi +ffffffff80100868: bf d4 03 00 00 mov $0x3d4,%edi +ffffffff8010086d: e8 d2 f8 ff ff call ffffffff80100144 + outb(CRTPORT+1, pos); +ffffffff80100872: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80100875: 0f b6 c0 movzbl %al,%eax +ffffffff80100878: 89 c6 mov %eax,%esi +ffffffff8010087a: bf d5 03 00 00 mov $0x3d5,%edi +ffffffff8010087f: e8 c0 f8 ff ff call ffffffff80100144 + crt[pos] = ' ' | 0x0700; +ffffffff80100884: 48 8b 15 8d 17 00 00 mov 0x178d(%rip),%rdx # ffffffff80102018 +ffffffff8010088b: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff8010088e: 48 98 cltq +ffffffff80100890: 48 01 c0 add %rax,%rax +ffffffff80100893: 48 01 d0 add %rdx,%rax +ffffffff80100896: 66 c7 00 20 07 movw $0x720,(%rax) +} +ffffffff8010089b: 90 nop +ffffffff8010089c: c9 leave +ffffffff8010089d: c3 ret + +ffffffff8010089e : + +void +consputc(int c) +{ +ffffffff8010089e: f3 0f 1e fa endbr64 +ffffffff801008a2: 55 push %rbp +ffffffff801008a3: 48 89 e5 mov %rsp,%rbp +ffffffff801008a6: 48 83 ec 10 sub $0x10,%rsp +ffffffff801008aa: 89 7d fc mov %edi,-0x4(%rbp) + cgaputc(c); +ffffffff801008ad: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff801008b0: 89 c7 mov %eax,%edi +ffffffff801008b2: e8 60 fe ff ff call ffffffff80100717 +} +ffffffff801008b7: 90 nop +ffffffff801008b8: c9 leave +ffffffff801008b9: c3 ret + +ffffffff801008ba
: +#include "defs.h" +#include "mmu.h" +#include "memlayout.h" +#include "proc.h" + +int main(void){ +ffffffff801008ba: f3 0f 1e fa endbr64 +ffffffff801008be: 55 push %rbp +ffffffff801008bf: 48 89 e5 mov %rsp,%rbp + memblock_init(); +ffffffff801008c2: e8 8d 12 00 00 call ffffffff80101b54 + panic("ok"); +ffffffff801008c7: 48 c7 c7 e2 1d 10 80 mov $0xffffffff80101de2,%rdi +ffffffff801008ce: e8 01 fe ff ff call ffffffff801006d4 +} +ffffffff801008d3: 90 nop +ffffffff801008d4: 5d pop %rbp +ffffffff801008d5: c3 ret + +ffffffff801008d6 : +{ +ffffffff801008d6: 55 push %rbp +ffffffff801008d7: 48 89 e5 mov %rsp,%rbp +ffffffff801008da: 48 83 ec 10 sub $0x10,%rsp +ffffffff801008de: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff801008e2: 89 75 f4 mov %esi,-0xc(%rbp) +ffffffff801008e5: 89 55 f0 mov %edx,-0x10(%rbp) + asm volatile("cld; rep stosb" : +ffffffff801008e8: 48 8b 4d f8 mov -0x8(%rbp),%rcx +ffffffff801008ec: 8b 55 f0 mov -0x10(%rbp),%edx +ffffffff801008ef: 8b 45 f4 mov -0xc(%rbp),%eax +ffffffff801008f2: 48 89 ce mov %rcx,%rsi +ffffffff801008f5: 48 89 f7 mov %rsi,%rdi +ffffffff801008f8: 89 d1 mov %edx,%ecx +ffffffff801008fa: fc cld +ffffffff801008fb: f3 aa rep stos %al,%es:(%rdi) +ffffffff801008fd: 89 ca mov %ecx,%edx +ffffffff801008ff: 48 89 fe mov %rdi,%rsi +ffffffff80100902: 48 89 75 f8 mov %rsi,-0x8(%rbp) +ffffffff80100906: 89 55 f0 mov %edx,-0x10(%rbp) +} +ffffffff80100909: 90 nop +ffffffff8010090a: c9 leave +ffffffff8010090b: c3 ret + +ffffffff8010090c : +{ +ffffffff8010090c: 55 push %rbp +ffffffff8010090d: 48 89 e5 mov %rsp,%rbp +ffffffff80100910: 48 83 ec 10 sub $0x10,%rsp +ffffffff80100914: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff80100918: 89 75 f4 mov %esi,-0xc(%rbp) +ffffffff8010091b: 89 55 f0 mov %edx,-0x10(%rbp) + asm volatile("cld; rep stosl" : +ffffffff8010091e: 48 8b 4d f8 mov -0x8(%rbp),%rcx +ffffffff80100922: 8b 55 f0 mov -0x10(%rbp),%edx +ffffffff80100925: 8b 45 f4 mov -0xc(%rbp),%eax +ffffffff80100928: 48 89 ce mov %rcx,%rsi +ffffffff8010092b: 48 89 f7 mov %rsi,%rdi +ffffffff8010092e: 89 d1 mov %edx,%ecx +ffffffff80100930: fc cld +ffffffff80100931: f3 ab rep stos %eax,%es:(%rdi) +ffffffff80100933: 89 ca mov %ecx,%edx +ffffffff80100935: 48 89 fe mov %rdi,%rsi +ffffffff80100938: 48 89 75 f8 mov %rsi,-0x8(%rbp) +ffffffff8010093c: 89 55 f0 mov %edx,-0x10(%rbp) +} +ffffffff8010093f: 90 nop +ffffffff80100940: c9 leave +ffffffff80100941: c3 ret + +ffffffff80100942 : +#include "types.h" +#include "x86.h" + +//assign c to dst - dst+n +void* memset(void *dst, i32 c, u32 n){ +ffffffff80100942: f3 0f 1e fa endbr64 +ffffffff80100946: 55 push %rbp +ffffffff80100947: 48 89 e5 mov %rsp,%rbp +ffffffff8010094a: 48 83 ec 10 sub $0x10,%rsp +ffffffff8010094e: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff80100952: 89 75 f4 mov %esi,-0xc(%rbp) +ffffffff80100955: 89 55 f0 mov %edx,-0x10(%rbp) + if ((u64)dst%4 == 0 && n%4 == 0){ +ffffffff80100958: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff8010095c: 83 e0 03 and $0x3,%eax +ffffffff8010095f: 48 85 c0 test %rax,%rax +ffffffff80100962: 75 46 jne ffffffff801009aa +ffffffff80100964: 8b 45 f0 mov -0x10(%rbp),%eax +ffffffff80100967: 83 e0 03 and $0x3,%eax +ffffffff8010096a: 85 c0 test %eax,%eax +ffffffff8010096c: 75 3c jne ffffffff801009aa + c &= 0xFF; +ffffffff8010096e: 81 65 f4 ff 00 00 00 andl $0xff,-0xc(%rbp) + stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4); +ffffffff80100975: 8b 45 f0 mov -0x10(%rbp),%eax +ffffffff80100978: c1 e8 02 shr $0x2,%eax +ffffffff8010097b: 89 c2 mov %eax,%edx +ffffffff8010097d: 8b 45 f4 mov -0xc(%rbp),%eax +ffffffff80100980: c1 e0 18 shl $0x18,%eax +ffffffff80100983: 89 c1 mov %eax,%ecx +ffffffff80100985: 8b 45 f4 mov -0xc(%rbp),%eax +ffffffff80100988: c1 e0 10 shl $0x10,%eax +ffffffff8010098b: 09 c1 or %eax,%ecx +ffffffff8010098d: 8b 45 f4 mov -0xc(%rbp),%eax +ffffffff80100990: c1 e0 08 shl $0x8,%eax +ffffffff80100993: 09 c8 or %ecx,%eax +ffffffff80100995: 0b 45 f4 or -0xc(%rbp),%eax +ffffffff80100998: 89 c1 mov %eax,%ecx +ffffffff8010099a: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff8010099e: 89 ce mov %ecx,%esi +ffffffff801009a0: 48 89 c7 mov %rax,%rdi +ffffffff801009a3: e8 64 ff ff ff call ffffffff8010090c +ffffffff801009a8: eb 14 jmp ffffffff801009be + }else + stosb(dst, c, n); +ffffffff801009aa: 8b 55 f0 mov -0x10(%rbp),%edx +ffffffff801009ad: 8b 4d f4 mov -0xc(%rbp),%ecx +ffffffff801009b0: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801009b4: 89 ce mov %ecx,%esi +ffffffff801009b6: 48 89 c7 mov %rax,%rdi +ffffffff801009b9: e8 18 ff ff ff call ffffffff801008d6 + return dst; +ffffffff801009be: 48 8b 45 f8 mov -0x8(%rbp),%rax +} +ffffffff801009c2: c9 leave +ffffffff801009c3: c3 ret + +ffffffff801009c4 : + +//compare v1 with v2 return v1 - v2 +int memcmp(const void* v1, const void* v2, u32 n){ +ffffffff801009c4: f3 0f 1e fa endbr64 +ffffffff801009c8: 55 push %rbp +ffffffff801009c9: 48 89 e5 mov %rsp,%rbp +ffffffff801009cc: 48 83 ec 28 sub $0x28,%rsp +ffffffff801009d0: 48 89 7d e8 mov %rdi,-0x18(%rbp) +ffffffff801009d4: 48 89 75 e0 mov %rsi,-0x20(%rbp) +ffffffff801009d8: 89 55 dc mov %edx,-0x24(%rbp) + const u8 *s1, *s2; + + s1 = v1; +ffffffff801009db: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff801009df: 48 89 45 f8 mov %rax,-0x8(%rbp) + s2 = v2; +ffffffff801009e3: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff801009e7: 48 89 45 f0 mov %rax,-0x10(%rbp) + while(n-- > 0){ +ffffffff801009eb: eb 36 jmp ffffffff80100a23 + if(*s1 != *s2) +ffffffff801009ed: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801009f1: 0f b6 10 movzbl (%rax),%edx +ffffffff801009f4: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801009f8: 0f b6 00 movzbl (%rax),%eax +ffffffff801009fb: 38 c2 cmp %al,%dl +ffffffff801009fd: 74 1a je ffffffff80100a19 + return *s1 - *s2; +ffffffff801009ff: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100a03: 0f b6 00 movzbl (%rax),%eax +ffffffff80100a06: 0f b6 d0 movzbl %al,%edx +ffffffff80100a09: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80100a0d: 0f b6 00 movzbl (%rax),%eax +ffffffff80100a10: 0f b6 c8 movzbl %al,%ecx +ffffffff80100a13: 89 d0 mov %edx,%eax +ffffffff80100a15: 29 c8 sub %ecx,%eax +ffffffff80100a17: eb 1c jmp ffffffff80100a35 + s1++, s2++; +ffffffff80100a19: 48 83 45 f8 01 addq $0x1,-0x8(%rbp) +ffffffff80100a1e: 48 83 45 f0 01 addq $0x1,-0x10(%rbp) + while(n-- > 0){ +ffffffff80100a23: 8b 45 dc mov -0x24(%rbp),%eax +ffffffff80100a26: 8d 50 ff lea -0x1(%rax),%edx +ffffffff80100a29: 89 55 dc mov %edx,-0x24(%rbp) +ffffffff80100a2c: 85 c0 test %eax,%eax +ffffffff80100a2e: 75 bd jne ffffffff801009ed + } + + return 0; +ffffffff80100a30: b8 00 00 00 00 mov $0x0,%eax +} +ffffffff80100a35: c9 leave +ffffffff80100a36: c3 ret + +ffffffff80100a37 : + +//copy n chars from src to dst +void* memmove(void* dst, const void* src, u32 n){ +ffffffff80100a37: f3 0f 1e fa endbr64 +ffffffff80100a3b: 55 push %rbp +ffffffff80100a3c: 48 89 e5 mov %rsp,%rbp +ffffffff80100a3f: 48 83 ec 28 sub $0x28,%rsp +ffffffff80100a43: 48 89 7d e8 mov %rdi,-0x18(%rbp) +ffffffff80100a47: 48 89 75 e0 mov %rsi,-0x20(%rbp) +ffffffff80100a4b: 89 55 dc mov %edx,-0x24(%rbp) + const char* s; + char* d; + + s = src; +ffffffff80100a4e: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80100a52: 48 89 45 f8 mov %rax,-0x8(%rbp) + d = dst; +ffffffff80100a56: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100a5a: 48 89 45 f0 mov %rax,-0x10(%rbp) + if(s d){ +ffffffff80100a5e: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100a62: 48 3b 45 f0 cmp -0x10(%rbp),%rax +ffffffff80100a66: 73 46 jae ffffffff80100aae +ffffffff80100a68: 8b 55 dc mov -0x24(%rbp),%edx +ffffffff80100a6b: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100a6f: 48 01 d0 add %rdx,%rax +ffffffff80100a72: 48 39 45 f0 cmp %rax,-0x10(%rbp) +ffffffff80100a76: 73 36 jae ffffffff80100aae + s+=n; +ffffffff80100a78: 8b 45 dc mov -0x24(%rbp),%eax +ffffffff80100a7b: 48 01 45 f8 add %rax,-0x8(%rbp) + d+=n; +ffffffff80100a7f: 8b 45 dc mov -0x24(%rbp),%eax +ffffffff80100a82: 48 01 45 f0 add %rax,-0x10(%rbp) + while(n-- > 0) +ffffffff80100a86: eb 17 jmp ffffffff80100a9f + *--d = * --s; +ffffffff80100a88: 48 83 6d f8 01 subq $0x1,-0x8(%rbp) +ffffffff80100a8d: 48 83 6d f0 01 subq $0x1,-0x10(%rbp) +ffffffff80100a92: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100a96: 0f b6 10 movzbl (%rax),%edx +ffffffff80100a99: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80100a9d: 88 10 mov %dl,(%rax) + while(n-- > 0) +ffffffff80100a9f: 8b 45 dc mov -0x24(%rbp),%eax +ffffffff80100aa2: 8d 50 ff lea -0x1(%rax),%edx +ffffffff80100aa5: 89 55 dc mov %edx,-0x24(%rbp) +ffffffff80100aa8: 85 c0 test %eax,%eax +ffffffff80100aaa: 75 dc jne ffffffff80100a88 + if(s d){ +ffffffff80100aac: eb 05 jmp ffffffff80100ab3 + } + else + while(n-- < 0) +ffffffff80100aae: 90 nop +ffffffff80100aaf: 83 6d dc 01 subl $0x1,-0x24(%rbp) + *d++ = *s++; +} +ffffffff80100ab3: 90 nop +ffffffff80100ab4: c9 leave +ffffffff80100ab5: c3 ret + +ffffffff80100ab6 : +//compare string +int strncmp(const char* p, const char* q, u32 n){ +ffffffff80100ab6: f3 0f 1e fa endbr64 +ffffffff80100aba: 55 push %rbp +ffffffff80100abb: 48 89 e5 mov %rsp,%rbp +ffffffff80100abe: 48 83 ec 18 sub $0x18,%rsp +ffffffff80100ac2: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff80100ac6: 48 89 75 f0 mov %rsi,-0x10(%rbp) +ffffffff80100aca: 89 55 ec mov %edx,-0x14(%rbp) + while(n > 0 && *p && *p == *q) +ffffffff80100acd: eb 0e jmp ffffffff80100add + n--, p++, q++; +ffffffff80100acf: 83 6d ec 01 subl $0x1,-0x14(%rbp) +ffffffff80100ad3: 48 83 45 f8 01 addq $0x1,-0x8(%rbp) +ffffffff80100ad8: 48 83 45 f0 01 addq $0x1,-0x10(%rbp) + while(n > 0 && *p && *p == *q) +ffffffff80100add: 83 7d ec 00 cmpl $0x0,-0x14(%rbp) +ffffffff80100ae1: 74 1d je ffffffff80100b00 +ffffffff80100ae3: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100ae7: 0f b6 00 movzbl (%rax),%eax +ffffffff80100aea: 84 c0 test %al,%al +ffffffff80100aec: 74 12 je ffffffff80100b00 +ffffffff80100aee: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100af2: 0f b6 10 movzbl (%rax),%edx +ffffffff80100af5: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80100af9: 0f b6 00 movzbl (%rax),%eax +ffffffff80100afc: 38 c2 cmp %al,%dl +ffffffff80100afe: 74 cf je ffffffff80100acf + if(n == 0) +ffffffff80100b00: 83 7d ec 00 cmpl $0x0,-0x14(%rbp) +ffffffff80100b04: 75 07 jne ffffffff80100b0d + return 0; +ffffffff80100b06: b8 00 00 00 00 mov $0x0,%eax +ffffffff80100b0b: eb 18 jmp ffffffff80100b25 + return (u8)*p - (u8)*q; +ffffffff80100b0d: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100b11: 0f b6 00 movzbl (%rax),%eax +ffffffff80100b14: 0f b6 d0 movzbl %al,%edx +ffffffff80100b17: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80100b1b: 0f b6 00 movzbl (%rax),%eax +ffffffff80100b1e: 0f b6 c8 movzbl %al,%ecx +ffffffff80100b21: 89 d0 mov %edx,%eax +ffffffff80100b23: 29 c8 sub %ecx,%eax +} +ffffffff80100b25: c9 leave +ffffffff80100b26: c3 ret + +ffffffff80100b27 : + +//copy string most n char +char* strncpy(char* s, const char* t, i32 n){ +ffffffff80100b27: f3 0f 1e fa endbr64 +ffffffff80100b2b: 55 push %rbp +ffffffff80100b2c: 48 89 e5 mov %rsp,%rbp +ffffffff80100b2f: 48 83 ec 28 sub $0x28,%rsp +ffffffff80100b33: 48 89 7d e8 mov %rdi,-0x18(%rbp) +ffffffff80100b37: 48 89 75 e0 mov %rsi,-0x20(%rbp) +ffffffff80100b3b: 89 55 dc mov %edx,-0x24(%rbp) + char* os; + + os = s; +ffffffff80100b3e: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100b42: 48 89 45 f8 mov %rax,-0x8(%rbp) + while(n-- > 0 && (*s++ = *t++) != 0) +ffffffff80100b46: 90 nop +ffffffff80100b47: 8b 45 dc mov -0x24(%rbp),%eax +ffffffff80100b4a: 8d 50 ff lea -0x1(%rax),%edx +ffffffff80100b4d: 89 55 dc mov %edx,-0x24(%rbp) +ffffffff80100b50: 85 c0 test %eax,%eax +ffffffff80100b52: 7e 35 jle ffffffff80100b89 +ffffffff80100b54: 48 8b 55 e0 mov -0x20(%rbp),%rdx +ffffffff80100b58: 48 8d 42 01 lea 0x1(%rdx),%rax +ffffffff80100b5c: 48 89 45 e0 mov %rax,-0x20(%rbp) +ffffffff80100b60: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100b64: 48 8d 48 01 lea 0x1(%rax),%rcx +ffffffff80100b68: 48 89 4d e8 mov %rcx,-0x18(%rbp) +ffffffff80100b6c: 0f b6 12 movzbl (%rdx),%edx +ffffffff80100b6f: 88 10 mov %dl,(%rax) +ffffffff80100b71: 0f b6 00 movzbl (%rax),%eax +ffffffff80100b74: 84 c0 test %al,%al +ffffffff80100b76: 75 cf jne ffffffff80100b47 + ; + while(n-- > 0) +ffffffff80100b78: eb 0f jmp ffffffff80100b89 + *s++ = 0; +ffffffff80100b7a: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100b7e: 48 8d 50 01 lea 0x1(%rax),%rdx +ffffffff80100b82: 48 89 55 e8 mov %rdx,-0x18(%rbp) +ffffffff80100b86: c6 00 00 movb $0x0,(%rax) + while(n-- > 0) +ffffffff80100b89: 8b 45 dc mov -0x24(%rbp),%eax +ffffffff80100b8c: 8d 50 ff lea -0x1(%rax),%edx +ffffffff80100b8f: 89 55 dc mov %edx,-0x24(%rbp) +ffffffff80100b92: 85 c0 test %eax,%eax +ffffffff80100b94: 7f e4 jg ffffffff80100b7a + return os; +ffffffff80100b96: 48 8b 45 f8 mov -0x8(%rbp),%rax +} +ffffffff80100b9a: c9 leave +ffffffff80100b9b: c3 ret + +ffffffff80100b9c : + +//get the length of string +int strlen(const char* s){ +ffffffff80100b9c: f3 0f 1e fa endbr64 +ffffffff80100ba0: 55 push %rbp +ffffffff80100ba1: 48 89 e5 mov %rsp,%rbp +ffffffff80100ba4: 48 83 ec 18 sub $0x18,%rsp +ffffffff80100ba8: 48 89 7d e8 mov %rdi,-0x18(%rbp) + int n; + for(n = 0; s[n]; n++) +ffffffff80100bac: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) +ffffffff80100bb3: eb 04 jmp ffffffff80100bb9 +ffffffff80100bb5: 83 45 fc 01 addl $0x1,-0x4(%rbp) +ffffffff80100bb9: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80100bbc: 48 63 d0 movslq %eax,%rdx +ffffffff80100bbf: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100bc3: 48 01 d0 add %rdx,%rax +ffffffff80100bc6: 0f b6 00 movzbl (%rax),%eax +ffffffff80100bc9: 84 c0 test %al,%al +ffffffff80100bcb: 75 e8 jne ffffffff80100bb5 + ; + return n; +ffffffff80100bcd: 8b 45 fc mov -0x4(%rbp),%eax +} +ffffffff80100bd0: c9 leave +ffffffff80100bd1: c3 ret + +ffffffff80100bd2 : + +char* safestrcpy(char* s, const char* t, i32 n){ +ffffffff80100bd2: f3 0f 1e fa endbr64 +ffffffff80100bd6: 55 push %rbp +ffffffff80100bd7: 48 89 e5 mov %rsp,%rbp +ffffffff80100bda: 48 83 ec 28 sub $0x28,%rsp +ffffffff80100bde: 48 89 7d e8 mov %rdi,-0x18(%rbp) +ffffffff80100be2: 48 89 75 e0 mov %rsi,-0x20(%rbp) +ffffffff80100be6: 89 55 dc mov %edx,-0x24(%rbp) + char *os; + + os = s; +ffffffff80100be9: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100bed: 48 89 45 f8 mov %rax,-0x8(%rbp) + if(n <= 0) +ffffffff80100bf1: 83 7d dc 00 cmpl $0x0,-0x24(%rbp) +ffffffff80100bf5: 7f 06 jg ffffffff80100bfd + return os; +ffffffff80100bf7: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100bfb: eb 3a jmp ffffffff80100c37 + while(--n > 0 && (*s++ = *t++) != 0) +ffffffff80100bfd: 90 nop +ffffffff80100bfe: 83 6d dc 01 subl $0x1,-0x24(%rbp) +ffffffff80100c02: 83 7d dc 00 cmpl $0x0,-0x24(%rbp) +ffffffff80100c06: 7e 24 jle ffffffff80100c2c +ffffffff80100c08: 48 8b 55 e0 mov -0x20(%rbp),%rdx +ffffffff80100c0c: 48 8d 42 01 lea 0x1(%rdx),%rax +ffffffff80100c10: 48 89 45 e0 mov %rax,-0x20(%rbp) +ffffffff80100c14: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100c18: 48 8d 48 01 lea 0x1(%rax),%rcx +ffffffff80100c1c: 48 89 4d e8 mov %rcx,-0x18(%rbp) +ffffffff80100c20: 0f b6 12 movzbl (%rdx),%edx +ffffffff80100c23: 88 10 mov %dl,(%rax) +ffffffff80100c25: 0f b6 00 movzbl (%rax),%eax +ffffffff80100c28: 84 c0 test %al,%al +ffffffff80100c2a: 75 d2 jne ffffffff80100bfe + ; + *s = 0; +ffffffff80100c2c: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100c30: c6 00 00 movb $0x0,(%rax) + return os; +ffffffff80100c33: 48 8b 45 f8 mov -0x8(%rbp),%rax +} +ffffffff80100c37: c9 leave +ffffffff80100c38: c3 ret + +ffffffff80100c39 : + +#define KERNLINK (KERNBASE+EXTMEM) // Address where kernel is linked + +#ifndef __ASSEMBLER__ + +static inline u64 v2p(void *a) { return ((u64) (a)) - ((u64)KERNBASE); } +ffffffff80100c39: 55 push %rbp +ffffffff80100c3a: 48 89 e5 mov %rsp,%rbp +ffffffff80100c3d: 48 83 ec 08 sub $0x8,%rsp +ffffffff80100c41: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff80100c45: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100c49: ba 00 00 00 80 mov $0x80000000,%edx +ffffffff80100c4e: 48 01 d0 add %rdx,%rax +ffffffff80100c51: c9 leave +ffffffff80100c52: c3 ret + +ffffffff80100c53 : +#include "memlayout.h" + +// Return the address of the PTE in pml4 +// that corresponds to virtual address va. If alloc!=0, +// create any required page table pages. +static u64* page_walk(u64* root,const void* va,int alloc){ +ffffffff80100c53: f3 0f 1e fa endbr64 +ffffffff80100c57: 55 push %rbp +ffffffff80100c58: 48 89 e5 mov %rsp,%rbp +ffffffff80100c5b: 48 83 ec 40 sub $0x40,%rsp +ffffffff80100c5f: 48 89 7d d8 mov %rdi,-0x28(%rbp) +ffffffff80100c63: 48 89 75 d0 mov %rsi,-0x30(%rbp) +ffffffff80100c67: 89 55 cc mov %edx,-0x34(%rbp) + + u64 *pml4e, *pdpte, *pde, *pte; + + // Page map level 4 index + pml4e = &root[PML4X(va)]; +ffffffff80100c6a: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff80100c6e: 48 c1 e8 27 shr $0x27,%rax +ffffffff80100c72: 25 ff 01 00 00 and $0x1ff,%eax +ffffffff80100c77: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx +ffffffff80100c7e: 00 +ffffffff80100c7f: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff80100c83: 48 01 d0 add %rdx,%rax +ffffffff80100c86: 48 89 45 f8 mov %rax,-0x8(%rbp) + + if(!(*pml4e & PTE_P)){ +ffffffff80100c8a: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100c8e: 48 8b 00 mov (%rax),%rax +ffffffff80100c91: 83 e0 01 and $0x1,%eax +ffffffff80100c94: 48 85 c0 test %rax,%rax +ffffffff80100c97: 75 70 jne ffffffff80100d09 + if(!alloc || (pml4e = (u64*)memblock_alloc(PGSIZE, PGSIZE)) == 0) +ffffffff80100c99: 83 7d cc 00 cmpl $0x0,-0x34(%rbp) +ffffffff80100c9d: 74 1a je ffffffff80100cb9 +ffffffff80100c9f: be 00 10 00 00 mov $0x1000,%esi +ffffffff80100ca4: bf 00 10 00 00 mov $0x1000,%edi +ffffffff80100ca9: e8 e6 0b 00 00 call ffffffff80101894 +ffffffff80100cae: 48 89 45 f8 mov %rax,-0x8(%rbp) +ffffffff80100cb2: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp) +ffffffff80100cb7: 75 0a jne ffffffff80100cc3 + return 0; +ffffffff80100cb9: b8 00 00 00 00 mov $0x0,%eax +ffffffff80100cbe: e9 03 02 00 00 jmp ffffffff80100ec6 + memset(pml4e, 0, PGSIZE); +ffffffff80100cc3: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100cc7: ba 00 10 00 00 mov $0x1000,%edx +ffffffff80100ccc: be 00 00 00 00 mov $0x0,%esi +ffffffff80100cd1: 48 89 c7 mov %rax,%rdi +ffffffff80100cd4: e8 69 fc ff ff call ffffffff80100942 + root[PML4X(va)] = v2p(pml4e) | PTE_P | PTE_W | PTE_U; +ffffffff80100cd9: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100cdd: 48 89 c7 mov %rax,%rdi +ffffffff80100ce0: e8 54 ff ff ff call ffffffff80100c39 +ffffffff80100ce5: 48 8b 55 d0 mov -0x30(%rbp),%rdx +ffffffff80100ce9: 48 c1 ea 27 shr $0x27,%rdx +ffffffff80100ced: 81 e2 ff 01 00 00 and $0x1ff,%edx +ffffffff80100cf3: 48 8d 0c d5 00 00 00 lea 0x0(,%rdx,8),%rcx +ffffffff80100cfa: 00 +ffffffff80100cfb: 48 8b 55 d8 mov -0x28(%rbp),%rdx +ffffffff80100cff: 48 01 ca add %rcx,%rdx +ffffffff80100d02: 48 83 c8 07 or $0x7,%rax +ffffffff80100d06: 48 89 02 mov %rax,(%rdx) + } + + // Page directory pointer index + pdpte = &pdpte[PDPTX(va)]; +ffffffff80100d09: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff80100d0d: 48 c1 e8 1e shr $0x1e,%rax +ffffffff80100d11: 25 ff 01 00 00 and $0x1ff,%eax +ffffffff80100d16: 48 c1 e0 03 shl $0x3,%rax +ffffffff80100d1a: 48 01 45 f0 add %rax,-0x10(%rbp) + + if(!(*pdpte & PTE_P)){ +ffffffff80100d1e: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80100d22: 48 8b 00 mov (%rax),%rax +ffffffff80100d25: 83 e0 01 and $0x1,%eax +ffffffff80100d28: 48 85 c0 test %rax,%rax +ffffffff80100d2b: 75 70 jne ffffffff80100d9d + if(!alloc || (pdpte = (u64*)memblock_alloc(PGSIZE, PGSIZE)) == 0) +ffffffff80100d2d: 83 7d cc 00 cmpl $0x0,-0x34(%rbp) +ffffffff80100d31: 74 1a je ffffffff80100d4d +ffffffff80100d33: be 00 10 00 00 mov $0x1000,%esi +ffffffff80100d38: bf 00 10 00 00 mov $0x1000,%edi +ffffffff80100d3d: e8 52 0b 00 00 call ffffffff80101894 +ffffffff80100d42: 48 89 45 f0 mov %rax,-0x10(%rbp) +ffffffff80100d46: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp) +ffffffff80100d4b: 75 0a jne ffffffff80100d57 + return 0; +ffffffff80100d4d: b8 00 00 00 00 mov $0x0,%eax +ffffffff80100d52: e9 6f 01 00 00 jmp ffffffff80100ec6 + memset(pdpte, 0, PGSIZE); +ffffffff80100d57: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80100d5b: ba 00 10 00 00 mov $0x1000,%edx +ffffffff80100d60: be 00 00 00 00 mov $0x0,%esi +ffffffff80100d65: 48 89 c7 mov %rax,%rdi +ffffffff80100d68: e8 d5 fb ff ff call ffffffff80100942 + pml4e[PDPTX(va)] = v2p(pdpte) | PTE_P | PTE_W | PTE_U; +ffffffff80100d6d: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80100d71: 48 89 c7 mov %rax,%rdi +ffffffff80100d74: e8 c0 fe ff ff call ffffffff80100c39 +ffffffff80100d79: 48 8b 55 d0 mov -0x30(%rbp),%rdx +ffffffff80100d7d: 48 c1 ea 1e shr $0x1e,%rdx +ffffffff80100d81: 81 e2 ff 01 00 00 and $0x1ff,%edx +ffffffff80100d87: 48 8d 0c d5 00 00 00 lea 0x0(,%rdx,8),%rcx +ffffffff80100d8e: 00 +ffffffff80100d8f: 48 8b 55 f8 mov -0x8(%rbp),%rdx +ffffffff80100d93: 48 01 ca add %rcx,%rdx +ffffffff80100d96: 48 83 c8 07 or $0x7,%rax +ffffffff80100d9a: 48 89 02 mov %rax,(%rdx) + } + + // Page directory index + pde = &pde[PDX(va)]; +ffffffff80100d9d: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff80100da1: 48 c1 e8 15 shr $0x15,%rax +ffffffff80100da5: 25 ff 01 00 00 and $0x1ff,%eax +ffffffff80100daa: 48 c1 e0 03 shl $0x3,%rax +ffffffff80100dae: 48 01 45 e8 add %rax,-0x18(%rbp) + + if(!(*pde & PTE_P)){ +ffffffff80100db2: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100db6: 48 8b 00 mov (%rax),%rax +ffffffff80100db9: 83 e0 01 and $0x1,%eax +ffffffff80100dbc: 48 85 c0 test %rax,%rax +ffffffff80100dbf: 75 70 jne ffffffff80100e31 + if(!alloc || (pde = (u64*)memblock_alloc(PGSIZE, PGSIZE)) == 0) +ffffffff80100dc1: 83 7d cc 00 cmpl $0x0,-0x34(%rbp) +ffffffff80100dc5: 74 1a je ffffffff80100de1 +ffffffff80100dc7: be 00 10 00 00 mov $0x1000,%esi +ffffffff80100dcc: bf 00 10 00 00 mov $0x1000,%edi +ffffffff80100dd1: e8 be 0a 00 00 call ffffffff80101894 +ffffffff80100dd6: 48 89 45 e8 mov %rax,-0x18(%rbp) +ffffffff80100dda: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp) +ffffffff80100ddf: 75 0a jne ffffffff80100deb + return 0; +ffffffff80100de1: b8 00 00 00 00 mov $0x0,%eax +ffffffff80100de6: e9 db 00 00 00 jmp ffffffff80100ec6 + memset(pde, 0, PGSIZE); +ffffffff80100deb: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100def: ba 00 10 00 00 mov $0x1000,%edx +ffffffff80100df4: be 00 00 00 00 mov $0x0,%esi +ffffffff80100df9: 48 89 c7 mov %rax,%rdi +ffffffff80100dfc: e8 41 fb ff ff call ffffffff80100942 + pdpte[PDX(va)] = v2p(pde) | PTE_P | PTE_W | PTE_U; +ffffffff80100e01: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100e05: 48 89 c7 mov %rax,%rdi +ffffffff80100e08: e8 2c fe ff ff call ffffffff80100c39 +ffffffff80100e0d: 48 8b 55 d0 mov -0x30(%rbp),%rdx +ffffffff80100e11: 48 c1 ea 15 shr $0x15,%rdx +ffffffff80100e15: 81 e2 ff 01 00 00 and $0x1ff,%edx +ffffffff80100e1b: 48 8d 0c d5 00 00 00 lea 0x0(,%rdx,8),%rcx +ffffffff80100e22: 00 +ffffffff80100e23: 48 8b 55 f0 mov -0x10(%rbp),%rdx +ffffffff80100e27: 48 01 ca add %rcx,%rdx +ffffffff80100e2a: 48 83 c8 07 or $0x7,%rax +ffffffff80100e2e: 48 89 02 mov %rax,(%rdx) + } + + // Page table index + pte = &pte[PTX(va)]; +ffffffff80100e31: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff80100e35: 48 c1 e8 0c shr $0xc,%rax +ffffffff80100e39: 25 ff 01 00 00 and $0x1ff,%eax +ffffffff80100e3e: 48 c1 e0 03 shl $0x3,%rax +ffffffff80100e42: 48 01 45 e0 add %rax,-0x20(%rbp) + + if(!(*pte & PTE_P)){ +ffffffff80100e46: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80100e4a: 48 8b 00 mov (%rax),%rax +ffffffff80100e4d: 83 e0 01 and $0x1,%eax +ffffffff80100e50: 48 85 c0 test %rax,%rax +ffffffff80100e53: 75 6d jne ffffffff80100ec2 + if(!alloc || (pte = (u64*)memblock_alloc(PGSIZE, PGSIZE)) == 0) +ffffffff80100e55: 83 7d cc 00 cmpl $0x0,-0x34(%rbp) +ffffffff80100e59: 74 1a je ffffffff80100e75 +ffffffff80100e5b: be 00 10 00 00 mov $0x1000,%esi +ffffffff80100e60: bf 00 10 00 00 mov $0x1000,%edi +ffffffff80100e65: e8 2a 0a 00 00 call ffffffff80101894 +ffffffff80100e6a: 48 89 45 e0 mov %rax,-0x20(%rbp) +ffffffff80100e6e: 48 83 7d e0 00 cmpq $0x0,-0x20(%rbp) +ffffffff80100e73: 75 07 jne ffffffff80100e7c + return 0; +ffffffff80100e75: b8 00 00 00 00 mov $0x0,%eax +ffffffff80100e7a: eb 4a jmp ffffffff80100ec6 + memset(pte, 0, PGSIZE); +ffffffff80100e7c: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80100e80: ba 00 10 00 00 mov $0x1000,%edx +ffffffff80100e85: be 00 00 00 00 mov $0x0,%esi +ffffffff80100e8a: 48 89 c7 mov %rax,%rdi +ffffffff80100e8d: e8 b0 fa ff ff call ffffffff80100942 + pde[PTX(va)] = v2p(pte) | PTE_P | PTE_W | PTE_U; +ffffffff80100e92: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80100e96: 48 89 c7 mov %rax,%rdi +ffffffff80100e99: e8 9b fd ff ff call ffffffff80100c39 +ffffffff80100e9e: 48 8b 55 d0 mov -0x30(%rbp),%rdx +ffffffff80100ea2: 48 c1 ea 0c shr $0xc,%rdx +ffffffff80100ea6: 81 e2 ff 01 00 00 and $0x1ff,%edx +ffffffff80100eac: 48 8d 0c d5 00 00 00 lea 0x0(,%rdx,8),%rcx +ffffffff80100eb3: 00 +ffffffff80100eb4: 48 8b 55 e8 mov -0x18(%rbp),%rdx +ffffffff80100eb8: 48 01 ca add %rcx,%rdx +ffffffff80100ebb: 48 83 c8 07 or $0x7,%rax +ffffffff80100ebf: 48 89 02 mov %rax,(%rdx) + } + + return pte; +ffffffff80100ec2: 48 8b 45 e0 mov -0x20(%rbp),%rax +} +ffffffff80100ec6: c9 leave +ffffffff80100ec7: c3 ret + +ffffffff80100ec8 : + +// Create PTEs for virtual addresses starting at va that refer to +// physical addresses starting at pa. va and size might not +// be page-aligned. +static int mamppages(u64* pml4, void* va, u64 size, u64 pa, int perm){ +ffffffff80100ec8: f3 0f 1e fa endbr64 +ffffffff80100ecc: 55 push %rbp +ffffffff80100ecd: 48 89 e5 mov %rsp,%rbp +ffffffff80100ed0: 48 83 ec 50 sub $0x50,%rsp +ffffffff80100ed4: 48 89 7d d8 mov %rdi,-0x28(%rbp) +ffffffff80100ed8: 48 89 75 d0 mov %rsi,-0x30(%rbp) +ffffffff80100edc: 48 89 55 c8 mov %rdx,-0x38(%rbp) +ffffffff80100ee0: 48 89 4d c0 mov %rcx,-0x40(%rbp) +ffffffff80100ee4: 44 89 45 bc mov %r8d,-0x44(%rbp) + char *first, *last; + u64* pte; + + first = (char*)ALIGN_DOWN(((u64)va), ((u64)PGSIZE)); +ffffffff80100ee8: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff80100eec: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax +ffffffff80100ef2: 48 89 45 f8 mov %rax,-0x8(%rbp) + last = (char*)ALIGN_DOWN(((u64)va), ((u64)PGSIZE)); +ffffffff80100ef6: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff80100efa: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax +ffffffff80100f00: 48 89 45 f0 mov %rax,-0x10(%rbp) + while(1){ + if(pte = page_walk(pml4, first, 1) == 0) +ffffffff80100f04: 48 8b 4d f8 mov -0x8(%rbp),%rcx +ffffffff80100f08: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff80100f0c: ba 01 00 00 00 mov $0x1,%edx +ffffffff80100f11: 48 89 ce mov %rcx,%rsi +ffffffff80100f14: 48 89 c7 mov %rax,%rdi +ffffffff80100f17: e8 37 fd ff ff call ffffffff80100c53 +ffffffff80100f1c: 48 85 c0 test %rax,%rax +ffffffff80100f1f: 0f 94 c0 sete %al +ffffffff80100f22: 0f b6 c0 movzbl %al,%eax +ffffffff80100f25: 48 98 cltq +ffffffff80100f27: 48 89 45 e8 mov %rax,-0x18(%rbp) +ffffffff80100f2b: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp) +ffffffff80100f30: 74 07 je ffffffff80100f39 + return -1; +ffffffff80100f32: b8 ff ff ff ff mov $0xffffffff,%eax +ffffffff80100f37: eb 57 jmp ffffffff80100f90 + if(*pte & PTE_P) +ffffffff80100f39: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100f3d: 48 8b 00 mov (%rax),%rax +ffffffff80100f40: 83 e0 01 and $0x1,%eax +ffffffff80100f43: 48 85 c0 test %rax,%rax +ffffffff80100f46: 74 0c je ffffffff80100f54 + panic("remap"); +ffffffff80100f48: 48 c7 c7 e5 1d 10 80 mov $0xffffffff80101de5,%rdi +ffffffff80100f4f: e8 80 f7 ff ff call ffffffff801006d4 + *pte = pa | perm | PTE_P; +ffffffff80100f54: 8b 45 bc mov -0x44(%rbp),%eax +ffffffff80100f57: 48 98 cltq +ffffffff80100f59: 48 0b 45 c0 or -0x40(%rbp),%rax +ffffffff80100f5d: 48 83 c8 01 or $0x1,%rax +ffffffff80100f61: 48 89 c2 mov %rax,%rdx +ffffffff80100f64: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100f68: 48 89 10 mov %rdx,(%rax) + if(first == last) +ffffffff80100f6b: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100f6f: 48 3b 45 f0 cmp -0x10(%rbp),%rax +ffffffff80100f73: 74 15 je ffffffff80100f8a + break; + first += PGSIZE; +ffffffff80100f75: 48 81 45 f8 00 10 00 addq $0x1000,-0x8(%rbp) +ffffffff80100f7c: 00 + pa += PGSIZE; +ffffffff80100f7d: 48 81 45 c0 00 10 00 addq $0x1000,-0x40(%rbp) +ffffffff80100f84: 00 + if(pte = page_walk(pml4, first, 1) == 0) +ffffffff80100f85: e9 7a ff ff ff jmp ffffffff80100f04 + break; +ffffffff80100f8a: 90 nop + } + return 0; +ffffffff80100f8b: b8 00 00 00 00 mov $0x0,%eax +} +ffffffff80100f90: c9 leave +ffffffff80100f91: c3 ret + +ffffffff80100f92 : +#include "defs.h" + +#define clamp(val, lo, hi) min( (typeof(val))(max(val, lo)),hi) + +// Insert a region to the regions list +int memblock_insert_region(struct memblock_type *type, int idx, u64 base, u64 size){ +ffffffff80100f92: f3 0f 1e fa endbr64 +ffffffff80100f96: 55 push %rbp +ffffffff80100f97: 48 89 e5 mov %rsp,%rbp +ffffffff80100f9a: 48 83 ec 30 sub $0x30,%rsp +ffffffff80100f9e: 48 89 7d e8 mov %rdi,-0x18(%rbp) +ffffffff80100fa2: 89 75 e4 mov %esi,-0x1c(%rbp) +ffffffff80100fa5: 48 89 55 d8 mov %rdx,-0x28(%rbp) +ffffffff80100fa9: 48 89 4d d0 mov %rcx,-0x30(%rbp) + struct memblock_region* rgn = &type->regions[idx]; +ffffffff80100fad: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100fb1: 48 8b 50 18 mov 0x18(%rax),%rdx +ffffffff80100fb5: 8b 45 e4 mov -0x1c(%rbp),%eax +ffffffff80100fb8: 48 98 cltq +ffffffff80100fba: 48 c1 e0 04 shl $0x4,%rax +ffffffff80100fbe: 48 01 d0 add %rdx,%rax +ffffffff80100fc1: 48 89 45 f8 mov %rax,-0x8(%rbp) + memmove(rgn + 1, rgn, (type->cnt -idx)* sizeof(*rgn)); +ffffffff80100fc5: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80100fc9: 48 8b 00 mov (%rax),%rax +ffffffff80100fcc: 8b 55 e4 mov -0x1c(%rbp),%edx +ffffffff80100fcf: 48 63 d2 movslq %edx,%rdx +ffffffff80100fd2: 48 29 d0 sub %rdx,%rax +ffffffff80100fd5: c1 e0 04 shl $0x4,%eax +ffffffff80100fd8: 89 c2 mov %eax,%edx +ffffffff80100fda: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100fde: 48 8d 48 10 lea 0x10(%rax),%rcx +ffffffff80100fe2: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100fe6: 48 89 c6 mov %rax,%rsi +ffffffff80100fe9: 48 89 cf mov %rcx,%rdi +ffffffff80100fec: e8 46 fa ff ff call ffffffff80100a37 + rgn->base = base; +ffffffff80100ff1: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80100ff5: 48 8b 55 d8 mov -0x28(%rbp),%rdx +ffffffff80100ff9: 48 89 10 mov %rdx,(%rax) + rgn->size = size; +ffffffff80100ffc: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80101000: 48 8b 55 d0 mov -0x30(%rbp),%rdx +ffffffff80101004: 48 89 50 08 mov %rdx,0x8(%rax) + + type->cnt++; +ffffffff80101008: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff8010100c: 48 8b 00 mov (%rax),%rax +ffffffff8010100f: 48 8d 50 01 lea 0x1(%rax),%rdx +ffffffff80101013: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80101017: 48 89 10 mov %rdx,(%rax) + type->total_size+=size; +ffffffff8010101a: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff8010101e: 48 8b 50 10 mov 0x10(%rax),%rdx +ffffffff80101022: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff80101026: 48 01 c2 add %rax,%rdx +ffffffff80101029: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff8010102d: 48 89 50 10 mov %rdx,0x10(%rax) +} +ffffffff80101031: 90 nop +ffffffff80101032: c9 leave +ffffffff80101033: c3 ret + +ffffffff80101034 : + +// Merge the adjacent and continuous regions +int memblock_merge_regions(struct memblock_type *type){ +ffffffff80101034: f3 0f 1e fa endbr64 +ffffffff80101038: 55 push %rbp +ffffffff80101039: 48 89 e5 mov %rsp,%rbp +ffffffff8010103c: 48 83 ec 30 sub $0x30,%rsp +ffffffff80101040: 48 89 7d d8 mov %rdi,-0x28(%rbp) + int i = 0; +ffffffff80101044: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) + + while(i < type->cnt -1){ +ffffffff8010104b: e9 a0 00 00 00 jmp ffffffff801010f0 + struct memblock_region* this = &type->regions[i]; +ffffffff80101050: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff80101054: 48 8b 50 18 mov 0x18(%rax),%rdx +ffffffff80101058: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff8010105b: 48 98 cltq +ffffffff8010105d: 48 c1 e0 04 shl $0x4,%rax +ffffffff80101061: 48 01 d0 add %rdx,%rax +ffffffff80101064: 48 89 45 f0 mov %rax,-0x10(%rbp) + struct memblock_region* next = &type->regions[i+1]; +ffffffff80101068: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff8010106c: 48 8b 50 18 mov 0x18(%rax),%rdx +ffffffff80101070: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80101073: 48 98 cltq +ffffffff80101075: 48 83 c0 01 add $0x1,%rax +ffffffff80101079: 48 c1 e0 04 shl $0x4,%rax +ffffffff8010107d: 48 01 d0 add %rdx,%rax +ffffffff80101080: 48 89 45 e8 mov %rax,-0x18(%rbp) + + if(this->base + this->size != next->base){ +ffffffff80101084: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101088: 48 8b 10 mov (%rax),%rdx +ffffffff8010108b: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff8010108f: 48 8b 40 08 mov 0x8(%rax),%rax +ffffffff80101093: 48 01 c2 add %rax,%rdx +ffffffff80101096: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff8010109a: 48 8b 00 mov (%rax),%rax +ffffffff8010109d: 48 39 c2 cmp %rax,%rdx +ffffffff801010a0: 74 06 je ffffffff801010a8 + i++; +ffffffff801010a2: 83 45 fc 01 addl $0x1,-0x4(%rbp) + continue; +ffffffff801010a6: eb 48 jmp ffffffff801010f0 + } + + this->size += next->size; +ffffffff801010a8: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801010ac: 48 8b 50 08 mov 0x8(%rax),%rdx +ffffffff801010b0: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff801010b4: 48 8b 40 08 mov 0x8(%rax),%rax +ffffffff801010b8: 48 01 c2 add %rax,%rdx +ffffffff801010bb: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801010bf: 48 89 50 08 mov %rdx,0x8(%rax) + memmove(next, next + 1, (type->cnt -(i+2) * sizeof(*next))); +ffffffff801010c3: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff801010c7: 48 8b 00 mov (%rax),%rax +ffffffff801010ca: 89 c2 mov %eax,%edx +ffffffff801010cc: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff801010cf: 83 c0 02 add $0x2,%eax +ffffffff801010d2: 48 98 cltq +ffffffff801010d4: c1 e0 04 shl $0x4,%eax +ffffffff801010d7: 29 c2 sub %eax,%edx +ffffffff801010d9: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff801010dd: 48 8d 48 10 lea 0x10(%rax),%rcx +ffffffff801010e1: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff801010e5: 48 89 ce mov %rcx,%rsi +ffffffff801010e8: 48 89 c7 mov %rax,%rdi +ffffffff801010eb: e8 47 f9 ff ff call ffffffff80100a37 + while(i < type->cnt -1){ +ffffffff801010f0: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff801010f3: 48 63 d0 movslq %eax,%rdx +ffffffff801010f6: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff801010fa: 48 8b 00 mov (%rax),%rax +ffffffff801010fd: 48 83 e8 01 sub $0x1,%rax +ffffffff80101101: 48 39 c2 cmp %rax,%rdx +ffffffff80101104: 0f 82 46 ff ff ff jb ffffffff80101050 + } +} +ffffffff8010110a: 90 nop +ffffffff8010110b: c9 leave +ffffffff8010110c: c3 ret + +ffffffff8010110d : + +void memblock_remove_region(struct memblock_type* type, u64 i){ +ffffffff8010110d: f3 0f 1e fa endbr64 +ffffffff80101111: 55 push %rbp +ffffffff80101112: 48 89 e5 mov %rsp,%rbp +ffffffff80101115: 48 83 ec 10 sub $0x10,%rsp +ffffffff80101119: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff8010111d: 48 89 75 f0 mov %rsi,-0x10(%rbp) + type->total_size -= type->regions[i].size; +ffffffff80101121: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80101125: 48 8b 50 10 mov 0x10(%rax),%rdx +ffffffff80101129: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff8010112d: 48 8b 48 18 mov 0x18(%rax),%rcx +ffffffff80101131: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101135: 48 c1 e0 04 shl $0x4,%rax +ffffffff80101139: 48 01 c8 add %rcx,%rax +ffffffff8010113c: 48 8b 40 08 mov 0x8(%rax),%rax +ffffffff80101140: 48 29 c2 sub %rax,%rdx +ffffffff80101143: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80101147: 48 89 50 10 mov %rdx,0x10(%rax) + memmove(&type->regions[i], &type->regions[i+1], + type->cnt - (i + 1) * sizeof( type->regions[i] )); +ffffffff8010114b: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff8010114f: 48 8b 00 mov (%rax),%rax + memmove(&type->regions[i], &type->regions[i+1], +ffffffff80101152: 89 c2 mov %eax,%edx + type->cnt - (i + 1) * sizeof( type->regions[i] )); +ffffffff80101154: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101158: 48 83 c0 01 add $0x1,%rax + memmove(&type->regions[i], &type->regions[i+1], +ffffffff8010115c: c1 e0 04 shl $0x4,%eax +ffffffff8010115f: 29 c2 sub %eax,%edx +ffffffff80101161: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80101165: 48 8b 48 18 mov 0x18(%rax),%rcx +ffffffff80101169: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff8010116d: 48 83 c0 01 add $0x1,%rax +ffffffff80101171: 48 c1 e0 04 shl $0x4,%rax +ffffffff80101175: 48 01 c1 add %rax,%rcx +ffffffff80101178: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff8010117c: 48 8b 70 18 mov 0x18(%rax),%rsi +ffffffff80101180: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101184: 48 c1 e0 04 shl $0x4,%rax +ffffffff80101188: 48 01 f0 add %rsi,%rax +ffffffff8010118b: 48 89 ce mov %rcx,%rsi +ffffffff8010118e: 48 89 c7 mov %rax,%rdi +ffffffff80101191: e8 a1 f8 ff ff call ffffffff80100a37 + type->cnt--; +ffffffff80101196: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff8010119a: 48 8b 00 mov (%rax),%rax +ffffffff8010119d: 48 8d 50 ff lea -0x1(%rax),%rdx +ffffffff801011a1: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801011a5: 48 89 10 mov %rdx,(%rax) + + if(type->cnt == 0){ +ffffffff801011a8: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801011ac: 48 8b 00 mov (%rax),%rax +ffffffff801011af: 48 85 c0 test %rax,%rax +ffffffff801011b2: 75 2a jne ffffffff801011de + type->cnt = 1; +ffffffff801011b4: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801011b8: 48 c7 00 01 00 00 00 movq $0x1,(%rax) + type->regions[0].base = 0; +ffffffff801011bf: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801011c3: 48 8b 40 18 mov 0x18(%rax),%rax +ffffffff801011c7: 48 c7 00 00 00 00 00 movq $0x0,(%rax) + type->regions[0].size = 0; +ffffffff801011ce: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801011d2: 48 8b 40 18 mov 0x18(%rax),%rax +ffffffff801011d6: 48 c7 40 08 00 00 00 movq $0x0,0x8(%rax) +ffffffff801011dd: 00 + } +} +ffffffff801011de: 90 nop +ffffffff801011df: c9 leave +ffffffff801011e0: c3 ret + +ffffffff801011e1 : + +// The entry is sorted in default +int memblock_add_regions(struct memblock_type *type,u64 base,u64 size){ +ffffffff801011e1: f3 0f 1e fa endbr64 +ffffffff801011e5: 55 push %rbp +ffffffff801011e6: 48 89 e5 mov %rsp,%rbp +ffffffff801011e9: 48 83 ec 70 sub $0x70,%rsp +ffffffff801011ed: 48 89 7d a8 mov %rdi,-0x58(%rbp) +ffffffff801011f1: 48 89 75 a0 mov %rsi,-0x60(%rbp) +ffffffff801011f5: 48 89 55 98 mov %rdx,-0x68(%rbp) + int insert = 0; +ffffffff801011f9: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) + u64 obase = base; +ffffffff80101200: 48 8b 45 a0 mov -0x60(%rbp),%rax +ffffffff80101204: 48 89 45 e0 mov %rax,-0x20(%rbp) + u64 end = base + size; +ffffffff80101208: 48 8b 55 a0 mov -0x60(%rbp),%rdx +ffffffff8010120c: 48 8b 45 98 mov -0x68(%rbp),%rax +ffffffff80101210: 48 01 d0 add %rdx,%rax +ffffffff80101213: 48 89 45 d8 mov %rax,-0x28(%rbp) + int idx, nr_new; + struct memblock_region* rgn; + + if(!size)return 0; +ffffffff80101217: 48 83 7d 98 00 cmpq $0x0,-0x68(%rbp) +ffffffff8010121c: 75 0a jne ffffffff80101228 +ffffffff8010121e: b8 00 00 00 00 mov $0x0,%eax +ffffffff80101223: e9 b8 01 00 00 jmp ffffffff801013e0 + + if(type->regions[0].size == 0){ +ffffffff80101228: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff8010122c: 48 8b 40 18 mov 0x18(%rax),%rax +ffffffff80101230: 48 8b 40 08 mov 0x8(%rax),%rax +ffffffff80101234: 48 85 c0 test %rax,%rax +ffffffff80101237: 75 35 jne ffffffff8010126e + type->regions[0].base = base; +ffffffff80101239: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff8010123d: 48 8b 40 18 mov 0x18(%rax),%rax +ffffffff80101241: 48 8b 55 a0 mov -0x60(%rbp),%rdx +ffffffff80101245: 48 89 10 mov %rdx,(%rax) + type->regions[0].size = size; +ffffffff80101248: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff8010124c: 48 8b 40 18 mov 0x18(%rax),%rax +ffffffff80101250: 48 8b 55 98 mov -0x68(%rbp),%rdx +ffffffff80101254: 48 89 50 08 mov %rdx,0x8(%rax) + type->total_size = size; +ffffffff80101258: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff8010125c: 48 8b 55 98 mov -0x68(%rbp),%rdx +ffffffff80101260: 48 89 50 10 mov %rdx,0x10(%rax) + return 0; +ffffffff80101264: b8 00 00 00 00 mov $0x0,%eax +ffffffff80101269: e9 72 01 00 00 jmp ffffffff801013e0 + } + repeat: +ffffffff8010126e: 90 nop + base = obase; +ffffffff8010126f: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80101273: 48 89 45 a0 mov %rax,-0x60(%rbp) + nr_new = 0; +ffffffff80101277: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp) + for_each_memblock_type(idx, type, rgn){ +ffffffff8010127e: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%rbp) +ffffffff80101285: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff80101289: 48 8b 40 18 mov 0x18(%rax),%rax +ffffffff8010128d: 48 89 45 e8 mov %rax,-0x18(%rbp) +ffffffff80101291: e9 af 00 00 00 jmp ffffffff80101345 + u64 rbase = rgn->base; +ffffffff80101296: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff8010129a: 48 8b 00 mov (%rax),%rax +ffffffff8010129d: 48 89 45 d0 mov %rax,-0x30(%rbp) + u64 rend = rbase + rgn->size; +ffffffff801012a1: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff801012a5: 48 8b 50 08 mov 0x8(%rax),%rdx +ffffffff801012a9: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff801012ad: 48 01 d0 add %rdx,%rax +ffffffff801012b0: 48 89 45 c8 mov %rax,-0x38(%rbp) + + if(rbase >= end) +ffffffff801012b4: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff801012b8: 48 3b 45 d8 cmp -0x28(%rbp),%rax +ffffffff801012bc: 0f 83 9b 00 00 00 jae ffffffff8010135d + break; + if(rend <= base) +ffffffff801012c2: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff801012c6: 48 3b 45 a0 cmp -0x60(%rbp),%rax +ffffffff801012ca: 76 5c jbe ffffffff80101328 + continue; + if(rbase > base){ +ffffffff801012cc: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff801012d0: 48 3b 45 a0 cmp -0x60(%rbp),%rax +ffffffff801012d4: 76 2d jbe ffffffff80101303 + nr_new++; +ffffffff801012d6: 83 45 f4 01 addl $0x1,-0xc(%rbp) + if(insert) +ffffffff801012da: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) +ffffffff801012de: 74 23 je ffffffff80101303 + memblock_insert_region(type, idx++, base, rbase-base); +ffffffff801012e0: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff801012e4: 48 2b 45 a0 sub -0x60(%rbp),%rax +ffffffff801012e8: 48 89 c1 mov %rax,%rcx +ffffffff801012eb: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff801012ee: 8d 50 01 lea 0x1(%rax),%edx +ffffffff801012f1: 89 55 f8 mov %edx,-0x8(%rbp) +ffffffff801012f4: 48 8b 55 a0 mov -0x60(%rbp),%rdx +ffffffff801012f8: 48 8b 7d a8 mov -0x58(%rbp),%rdi +ffffffff801012fc: 89 c6 mov %eax,%esi +ffffffff801012fe: e8 8f fc ff ff call ffffffff80100f92 + } + base = min(rend, end); +ffffffff80101303: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101307: 48 89 45 c0 mov %rax,-0x40(%rbp) +ffffffff8010130b: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff8010130f: 48 89 45 b8 mov %rax,-0x48(%rbp) +ffffffff80101313: 48 8b 55 b8 mov -0x48(%rbp),%rdx +ffffffff80101317: 48 8b 45 c0 mov -0x40(%rbp),%rax +ffffffff8010131b: 48 39 c2 cmp %rax,%rdx +ffffffff8010131e: 48 0f 46 c2 cmovbe %rdx,%rax +ffffffff80101322: 48 89 45 a0 mov %rax,-0x60(%rbp) +ffffffff80101326: eb 01 jmp ffffffff80101329 + continue; +ffffffff80101328: 90 nop + for_each_memblock_type(idx, type, rgn){ +ffffffff80101329: 83 45 f8 01 addl $0x1,-0x8(%rbp) +ffffffff8010132d: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff80101331: 48 8b 50 18 mov 0x18(%rax),%rdx +ffffffff80101335: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101338: 48 98 cltq +ffffffff8010133a: 48 c1 e0 04 shl $0x4,%rax +ffffffff8010133e: 48 01 d0 add %rdx,%rax +ffffffff80101341: 48 89 45 e8 mov %rax,-0x18(%rbp) +ffffffff80101345: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101348: 48 63 d0 movslq %eax,%rdx +ffffffff8010134b: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff8010134f: 48 8b 00 mov (%rax),%rax +ffffffff80101352: 48 39 c2 cmp %rax,%rdx +ffffffff80101355: 0f 82 3b ff ff ff jb ffffffff80101296 +ffffffff8010135b: eb 01 jmp ffffffff8010135e + break; +ffffffff8010135d: 90 nop + } + + if(base < end){ +ffffffff8010135e: 48 8b 45 a0 mov -0x60(%rbp),%rax +ffffffff80101362: 48 3b 45 d8 cmp -0x28(%rbp),%rax +ffffffff80101366: 73 28 jae ffffffff80101390 + nr_new++; +ffffffff80101368: 83 45 f4 01 addl $0x1,-0xc(%rbp) + if(insert) +ffffffff8010136c: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) +ffffffff80101370: 74 1e je ffffffff80101390 + memblock_insert_region(type, idx, base, end-base); +ffffffff80101372: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff80101376: 48 2b 45 a0 sub -0x60(%rbp),%rax +ffffffff8010137a: 48 89 c1 mov %rax,%rcx +ffffffff8010137d: 48 8b 55 a0 mov -0x60(%rbp),%rdx +ffffffff80101381: 8b 75 f8 mov -0x8(%rbp),%esi +ffffffff80101384: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff80101388: 48 89 c7 mov %rax,%rdi +ffffffff8010138b: e8 02 fc ff ff call ffffffff80100f92 + } + + if(!nr_new) +ffffffff80101390: 83 7d f4 00 cmpl $0x0,-0xc(%rbp) +ffffffff80101394: 75 07 jne ffffffff8010139d + return 0; +ffffffff80101396: b8 00 00 00 00 mov $0x0,%eax +ffffffff8010139b: eb 43 jmp ffffffff801013e0 + + if(!insert){ +ffffffff8010139d: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) +ffffffff801013a1: 75 2c jne ffffffff801013cf + if(type->cnt + nr_new > type->max) +ffffffff801013a3: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff801013a7: 48 8b 10 mov (%rax),%rdx +ffffffff801013aa: 8b 45 f4 mov -0xc(%rbp),%eax +ffffffff801013ad: 48 98 cltq +ffffffff801013af: 48 01 c2 add %rax,%rdx +ffffffff801013b2: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff801013b6: 48 8b 40 08 mov 0x8(%rax),%rax +ffffffff801013ba: 48 39 c2 cmp %rax,%rdx +ffffffff801013bd: 0f 86 ac fe ff ff jbe ffffffff8010126f + //panic(); + insert = 1; +ffffffff801013c3: c7 45 fc 01 00 00 00 movl $0x1,-0x4(%rbp) + goto repeat; +ffffffff801013ca: e9 a0 fe ff ff jmp ffffffff8010126f + } + else{ + memblock_merge_regions(type); +ffffffff801013cf: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff801013d3: 48 89 c7 mov %rax,%rdi +ffffffff801013d6: e8 59 fc ff ff call ffffffff80101034 + return 0; +ffffffff801013db: b8 00 00 00 00 mov $0x0,%eax + } +} +ffffffff801013e0: c9 leave +ffffffff801013e1: c3 ret + +ffffffff801013e2 : + +int memblock_add(u64 base, u64 size){ +ffffffff801013e2: f3 0f 1e fa endbr64 +ffffffff801013e6: 55 push %rbp +ffffffff801013e7: 48 89 e5 mov %rsp,%rbp +ffffffff801013ea: 48 83 ec 10 sub $0x10,%rsp +ffffffff801013ee: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff801013f2: 48 89 75 f0 mov %rsi,-0x10(%rbp) + return memblock_add_regions(&memblock.memory, base, size); +ffffffff801013f6: 48 8b 55 f0 mov -0x10(%rbp),%rdx +ffffffff801013fa: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801013fe: 48 89 c6 mov %rax,%rsi +ffffffff80101401: 48 c7 c7 20 30 10 80 mov $0xffffffff80103020,%rdi +ffffffff80101408: e8 d4 fd ff ff call ffffffff801011e1 +} +ffffffff8010140d: c9 leave +ffffffff8010140e: c3 ret + +ffffffff8010140f : + +int memblock_reserve(u64 base, u64 size){ +ffffffff8010140f: f3 0f 1e fa endbr64 +ffffffff80101413: 55 push %rbp +ffffffff80101414: 48 89 e5 mov %rsp,%rbp +ffffffff80101417: 48 83 ec 10 sub $0x10,%rsp +ffffffff8010141b: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff8010141f: 48 89 75 f0 mov %rsi,-0x10(%rbp) + return memblock_add_regions(&memblock.reserved, base, size); +ffffffff80101423: 48 8b 55 f0 mov -0x10(%rbp),%rdx +ffffffff80101427: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff8010142b: 48 89 c6 mov %rax,%rsi +ffffffff8010142e: 48 c7 c7 48 30 10 80 mov $0xffffffff80103048,%rdi +ffffffff80101435: e8 a7 fd ff ff call ffffffff801011e1 +} +ffffffff8010143a: c9 leave +ffffffff8010143b: c3 ret + +ffffffff8010143c <__next_mem_range_rev>: + +void __next_mem_range_rev(u64* idx, struct memblock_type* type_a, struct memblock_type* type_b, u64 *out_start, u64 *out_end){ +ffffffff8010143c: f3 0f 1e fa endbr64 +ffffffff80101440: 55 push %rbp +ffffffff80101441: 48 89 e5 mov %rsp,%rbp +ffffffff80101444: 48 81 ec 88 00 00 00 sub $0x88,%rsp +ffffffff8010144b: 48 89 7d 98 mov %rdi,-0x68(%rbp) +ffffffff8010144f: 48 89 75 90 mov %rsi,-0x70(%rbp) +ffffffff80101453: 48 89 55 88 mov %rdx,-0x78(%rbp) +ffffffff80101457: 48 89 4d 80 mov %rcx,-0x80(%rbp) +ffffffff8010145b: 4c 89 85 78 ff ff ff mov %r8,-0x88(%rbp) + int idx_a = *idx & 0xffffffff; +ffffffff80101462: 48 8b 45 98 mov -0x68(%rbp),%rax +ffffffff80101466: 48 8b 00 mov (%rax),%rax +ffffffff80101469: 89 45 fc mov %eax,-0x4(%rbp) + int idx_b = *idx >> 32; +ffffffff8010146c: 48 8b 45 98 mov -0x68(%rbp),%rax +ffffffff80101470: 48 8b 00 mov (%rax),%rax +ffffffff80101473: 48 c1 e8 20 shr $0x20,%rax +ffffffff80101477: 89 45 f8 mov %eax,-0x8(%rbp) + + if (*idx == (u64)ULLONG_MAX){ +ffffffff8010147a: 48 8b 45 98 mov -0x68(%rbp),%rax +ffffffff8010147e: 48 8b 00 mov (%rax),%rax +ffffffff80101481: 48 83 f8 ff cmp $0xffffffffffffffff,%rax +ffffffff80101485: 0f 85 6d 01 00 00 jne ffffffff801015f8 <__next_mem_range_rev+0x1bc> + idx_a = type_a->cnt-1; +ffffffff8010148b: 48 8b 45 90 mov -0x70(%rbp),%rax +ffffffff8010148f: 48 8b 00 mov (%rax),%rax +ffffffff80101492: 83 e8 01 sub $0x1,%eax +ffffffff80101495: 89 45 fc mov %eax,-0x4(%rbp) + idx_b = type_b->cnt; +ffffffff80101498: 48 8b 45 88 mov -0x78(%rbp),%rax +ffffffff8010149c: 48 8b 00 mov (%rax),%rax +ffffffff8010149f: 89 45 f8 mov %eax,-0x8(%rbp) + } + + for(; idx_a >= 0; idx_a--){ +ffffffff801014a2: e9 51 01 00 00 jmp ffffffff801015f8 <__next_mem_range_rev+0x1bc> + struct memblock_region* m = &type_a->regions[idx_a]; +ffffffff801014a7: 48 8b 45 90 mov -0x70(%rbp),%rax +ffffffff801014ab: 48 8b 50 18 mov 0x18(%rax),%rdx +ffffffff801014af: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff801014b2: 48 98 cltq +ffffffff801014b4: 48 c1 e0 04 shl $0x4,%rax +ffffffff801014b8: 48 01 d0 add %rdx,%rax +ffffffff801014bb: 48 89 45 f0 mov %rax,-0x10(%rbp) + + u64 m_start = m->base; +ffffffff801014bf: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801014c3: 48 8b 00 mov (%rax),%rax +ffffffff801014c6: 48 89 45 e8 mov %rax,-0x18(%rbp) + u64 m_end = m->base + m->size; +ffffffff801014ca: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801014ce: 48 8b 10 mov (%rax),%rdx +ffffffff801014d1: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801014d5: 48 8b 40 08 mov 0x8(%rax),%rax +ffffffff801014d9: 48 01 d0 add %rdx,%rax +ffffffff801014dc: 48 89 45 e0 mov %rax,-0x20(%rbp) + + for(; idx_b >= 0; idx_b--){ +ffffffff801014e0: e9 02 01 00 00 jmp ffffffff801015e7 <__next_mem_range_rev+0x1ab> + struct memblock_region* r; + u64 r_start; + u64 r_end; + + r = &type_b->regions[idx_b]; +ffffffff801014e5: 48 8b 45 88 mov -0x78(%rbp),%rax +ffffffff801014e9: 48 8b 50 18 mov 0x18(%rax),%rdx +ffffffff801014ed: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff801014f0: 48 98 cltq +ffffffff801014f2: 48 c1 e0 04 shl $0x4,%rax +ffffffff801014f6: 48 01 d0 add %rdx,%rax +ffffffff801014f9: 48 89 45 d8 mov %rax,-0x28(%rbp) + r_start = idx_b ? r[-1].base + r[-1].size : 0; +ffffffff801014fd: 83 7d f8 00 cmpl $0x0,-0x8(%rbp) +ffffffff80101501: 74 1c je ffffffff8010151f <__next_mem_range_rev+0xe3> +ffffffff80101503: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff80101507: 48 83 e8 10 sub $0x10,%rax +ffffffff8010150b: 48 8b 10 mov (%rax),%rdx +ffffffff8010150e: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff80101512: 48 83 e8 10 sub $0x10,%rax +ffffffff80101516: 48 8b 40 08 mov 0x8(%rax),%rax +ffffffff8010151a: 48 01 d0 add %rdx,%rax +ffffffff8010151d: eb 05 jmp ffffffff80101524 <__next_mem_range_rev+0xe8> +ffffffff8010151f: b8 00 00 00 00 mov $0x0,%eax +ffffffff80101524: 48 89 45 d0 mov %rax,-0x30(%rbp) + r_end = idx_b < type_b->cnt ? r->base : ULLONG_MAX; +ffffffff80101528: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff8010152b: 48 63 d0 movslq %eax,%rdx +ffffffff8010152e: 48 8b 45 88 mov -0x78(%rbp),%rax +ffffffff80101532: 48 8b 00 mov (%rax),%rax +ffffffff80101535: 48 39 c2 cmp %rax,%rdx +ffffffff80101538: 73 09 jae ffffffff80101543 <__next_mem_range_rev+0x107> +ffffffff8010153a: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff8010153e: 48 8b 00 mov (%rax),%rax +ffffffff80101541: eb 07 jmp ffffffff8010154a <__next_mem_range_rev+0x10e> +ffffffff80101543: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax +ffffffff8010154a: 48 89 45 c8 mov %rax,-0x38(%rbp) + + if(r_end <= m_start) +ffffffff8010154e: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101552: 48 3b 45 e8 cmp -0x18(%rbp),%rax +ffffffff80101556: 0f 86 97 00 00 00 jbe ffffffff801015f3 <__next_mem_range_rev+0x1b7> + break; + if(m_end > r_start){ +ffffffff8010155c: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80101560: 48 3b 45 d0 cmp -0x30(%rbp),%rax +ffffffff80101564: 76 7d jbe ffffffff801015e3 <__next_mem_range_rev+0x1a7> + *out_start = max(m_start, r_start); +ffffffff80101566: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff8010156a: 48 89 45 c0 mov %rax,-0x40(%rbp) +ffffffff8010156e: 48 8b 45 d0 mov -0x30(%rbp),%rax +ffffffff80101572: 48 89 45 b8 mov %rax,-0x48(%rbp) +ffffffff80101576: 48 8b 55 b8 mov -0x48(%rbp),%rdx +ffffffff8010157a: 48 8b 45 c0 mov -0x40(%rbp),%rax +ffffffff8010157e: 48 39 c2 cmp %rax,%rdx +ffffffff80101581: 48 0f 42 d0 cmovb %rax,%rdx +ffffffff80101585: 48 8b 45 80 mov -0x80(%rbp),%rax +ffffffff80101589: 48 89 10 mov %rdx,(%rax) + *out_end = min(m_end, r_end); +ffffffff8010158c: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80101590: 48 89 45 b0 mov %rax,-0x50(%rbp) +ffffffff80101594: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101598: 48 89 45 a8 mov %rax,-0x58(%rbp) +ffffffff8010159c: 48 8b 55 a8 mov -0x58(%rbp),%rdx +ffffffff801015a0: 48 8b 45 b0 mov -0x50(%rbp),%rax +ffffffff801015a4: 48 39 c2 cmp %rax,%rdx +ffffffff801015a7: 48 0f 47 d0 cmova %rax,%rdx +ffffffff801015ab: 48 8b 85 78 ff ff ff mov -0x88(%rbp),%rax +ffffffff801015b2: 48 89 10 mov %rdx,(%rax) + + if(m_start >= r_start) +ffffffff801015b5: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff801015b9: 48 3b 45 d0 cmp -0x30(%rbp),%rax +ffffffff801015bd: 72 06 jb ffffffff801015c5 <__next_mem_range_rev+0x189> + idx_a--; +ffffffff801015bf: 83 6d fc 01 subl $0x1,-0x4(%rbp) +ffffffff801015c3: eb 04 jmp ffffffff801015c9 <__next_mem_range_rev+0x18d> + else + idx_b--; +ffffffff801015c5: 83 6d f8 01 subl $0x1,-0x8(%rbp) + *idx = (u32)idx_a | (u64)idx_b << 32; +ffffffff801015c9: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff801015cc: 89 c2 mov %eax,%edx +ffffffff801015ce: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff801015d1: 48 98 cltq +ffffffff801015d3: 48 c1 e0 20 shl $0x20,%rax +ffffffff801015d7: 48 09 c2 or %rax,%rdx +ffffffff801015da: 48 8b 45 98 mov -0x68(%rbp),%rax +ffffffff801015de: 48 89 10 mov %rdx,(%rax) + return; +ffffffff801015e1: eb 2a jmp ffffffff8010160d <__next_mem_range_rev+0x1d1> + for(; idx_b >= 0; idx_b--){ +ffffffff801015e3: 83 6d f8 01 subl $0x1,-0x8(%rbp) +ffffffff801015e7: 83 7d f8 00 cmpl $0x0,-0x8(%rbp) +ffffffff801015eb: 0f 89 f4 fe ff ff jns ffffffff801014e5 <__next_mem_range_rev+0xa9> +ffffffff801015f1: eb 01 jmp ffffffff801015f4 <__next_mem_range_rev+0x1b8> + break; +ffffffff801015f3: 90 nop + for(; idx_a >= 0; idx_a--){ +ffffffff801015f4: 83 6d fc 01 subl $0x1,-0x4(%rbp) +ffffffff801015f8: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) +ffffffff801015fc: 0f 89 a5 fe ff ff jns ffffffff801014a7 <__next_mem_range_rev+0x6b> + } + } + } + *idx = ULLONG_MAX; +ffffffff80101602: 48 8b 45 98 mov -0x68(%rbp),%rax +ffffffff80101606: 48 c7 00 ff ff ff ff movq $0xffffffffffffffff,(%rax) +} +ffffffff8010160d: c9 leave +ffffffff8010160e: c3 ret + +ffffffff8010160f <__memblock_find_range_top_down>: + +u64 __memblock_find_range_top_down(u64 start, u64 end, u64 size, u64 align){ +ffffffff8010160f: f3 0f 1e fa endbr64 +ffffffff80101613: 55 push %rbp +ffffffff80101614: 48 89 e5 mov %rsp,%rbp +ffffffff80101617: 48 83 c4 80 add $0xffffffffffffff80,%rsp +ffffffff8010161b: 48 89 7d 98 mov %rdi,-0x68(%rbp) +ffffffff8010161f: 48 89 75 90 mov %rsi,-0x70(%rbp) +ffffffff80101623: 48 89 55 88 mov %rdx,-0x78(%rbp) +ffffffff80101627: 48 89 4d 80 mov %rcx,-0x80(%rbp) + u64 this_start, this_end, cand; + u64 i; + + for_each_free_mem_range_reserve(i, &this_start, &this_end){ +ffffffff8010162b: 48 c7 45 e0 ff ff ff movq $0xffffffffffffffff,-0x20(%rbp) +ffffffff80101632: ff +ffffffff80101633: 48 8d 4d e8 lea -0x18(%rbp),%rcx +ffffffff80101637: 48 8d 55 f0 lea -0x10(%rbp),%rdx +ffffffff8010163b: 48 8d 45 e0 lea -0x20(%rbp),%rax +ffffffff8010163f: 49 89 c8 mov %rcx,%r8 +ffffffff80101642: 48 89 d1 mov %rdx,%rcx +ffffffff80101645: 48 c7 c2 48 30 10 80 mov $0xffffffff80103048,%rdx +ffffffff8010164c: 48 c7 c6 20 30 10 80 mov $0xffffffff80103020,%rsi +ffffffff80101653: 48 89 c7 mov %rax,%rdi +ffffffff80101656: e8 e1 fd ff ff call ffffffff8010143c <__next_mem_range_rev> +ffffffff8010165b: e9 c7 00 00 00 jmp ffffffff80101727 <__memblock_find_range_top_down+0x118> + this_start = clamp(this_start, start, end); +ffffffff80101660: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101664: 48 89 45 c8 mov %rax,-0x38(%rbp) +ffffffff80101668: 48 8b 45 98 mov -0x68(%rbp),%rax +ffffffff8010166c: 48 89 45 c0 mov %rax,-0x40(%rbp) +ffffffff80101670: 48 8b 55 c0 mov -0x40(%rbp),%rdx +ffffffff80101674: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101678: 48 39 c2 cmp %rax,%rdx +ffffffff8010167b: 48 0f 43 c2 cmovae %rdx,%rax +ffffffff8010167f: 48 89 45 d8 mov %rax,-0x28(%rbp) +ffffffff80101683: 48 8b 45 90 mov -0x70(%rbp),%rax +ffffffff80101687: 48 89 45 d0 mov %rax,-0x30(%rbp) +ffffffff8010168b: 48 8b 55 d0 mov -0x30(%rbp),%rdx +ffffffff8010168f: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff80101693: 48 39 c2 cmp %rax,%rdx +ffffffff80101696: 48 0f 46 c2 cmovbe %rdx,%rax +ffffffff8010169a: 48 89 45 f0 mov %rax,-0x10(%rbp) + this_end = clamp(this_end, start, end); +ffffffff8010169e: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff801016a2: 48 89 45 a8 mov %rax,-0x58(%rbp) +ffffffff801016a6: 48 8b 45 98 mov -0x68(%rbp),%rax +ffffffff801016aa: 48 89 45 a0 mov %rax,-0x60(%rbp) +ffffffff801016ae: 48 8b 55 a0 mov -0x60(%rbp),%rdx +ffffffff801016b2: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff801016b6: 48 39 c2 cmp %rax,%rdx +ffffffff801016b9: 48 0f 43 c2 cmovae %rdx,%rax +ffffffff801016bd: 48 89 45 b8 mov %rax,-0x48(%rbp) +ffffffff801016c1: 48 8b 45 90 mov -0x70(%rbp),%rax +ffffffff801016c5: 48 89 45 b0 mov %rax,-0x50(%rbp) +ffffffff801016c9: 48 8b 55 b0 mov -0x50(%rbp),%rdx +ffffffff801016cd: 48 8b 45 b8 mov -0x48(%rbp),%rax +ffffffff801016d1: 48 39 c2 cmp %rax,%rdx +ffffffff801016d4: 48 0f 46 c2 cmovbe %rdx,%rax +ffffffff801016d8: 48 89 45 e8 mov %rax,-0x18(%rbp) + + // The data is unsigned, so need to judge + if(this_end < size) +ffffffff801016dc: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff801016e0: 48 39 45 88 cmp %rax,-0x78(%rbp) +ffffffff801016e4: 77 18 ja ffffffff801016fe <__memblock_find_range_top_down+0xef> + continue; + + //cand = round_down(this_end - size, align); + cand = 1; +ffffffff801016e6: 48 c7 45 f8 01 00 00 movq $0x1,-0x8(%rbp) +ffffffff801016ed: 00 + if(cand >= this_start) +ffffffff801016ee: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801016f2: 48 39 45 f8 cmp %rax,-0x8(%rbp) +ffffffff801016f6: 72 07 jb ffffffff801016ff <__memblock_find_range_top_down+0xf0> + return cand; +ffffffff801016f8: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801016fc: eb 3c jmp ffffffff8010173a <__memblock_find_range_top_down+0x12b> + continue; +ffffffff801016fe: 90 nop + for_each_free_mem_range_reserve(i, &this_start, &this_end){ +ffffffff801016ff: 48 8d 4d e8 lea -0x18(%rbp),%rcx +ffffffff80101703: 48 8d 55 f0 lea -0x10(%rbp),%rdx +ffffffff80101707: 48 8d 45 e0 lea -0x20(%rbp),%rax +ffffffff8010170b: 49 89 c8 mov %rcx,%r8 +ffffffff8010170e: 48 89 d1 mov %rdx,%rcx +ffffffff80101711: 48 c7 c2 48 30 10 80 mov $0xffffffff80103048,%rdx +ffffffff80101718: 48 c7 c6 20 30 10 80 mov $0xffffffff80103020,%rsi +ffffffff8010171f: 48 89 c7 mov %rax,%rdi +ffffffff80101722: e8 15 fd ff ff call ffffffff8010143c <__next_mem_range_rev> +ffffffff80101727: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff8010172b: 48 83 f8 ff cmp $0xffffffffffffffff,%rax +ffffffff8010172f: 0f 85 2b ff ff ff jne ffffffff80101660 <__memblock_find_range_top_down+0x51> + } + + return 0; +ffffffff80101735: b8 00 00 00 00 mov $0x0,%eax +} +ffffffff8010173a: c9 leave +ffffffff8010173b: c3 ret + +ffffffff8010173c : + +u64 memblock_find_in_range(u64 size, u64 align, u64 start, u64 end){ +ffffffff8010173c: f3 0f 1e fa endbr64 +ffffffff80101740: 55 push %rbp +ffffffff80101741: 48 89 e5 mov %rsp,%rbp +ffffffff80101744: 48 83 ec 40 sub $0x40,%rsp +ffffffff80101748: 48 89 7d d8 mov %rdi,-0x28(%rbp) +ffffffff8010174c: 48 89 75 d0 mov %rsi,-0x30(%rbp) +ffffffff80101750: 48 89 55 c8 mov %rdx,-0x38(%rbp) +ffffffff80101754: 48 89 4d c0 mov %rcx,-0x40(%rbp) + start = max(start, PGSIZE); +ffffffff80101758: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff8010175c: 48 89 45 f8 mov %rax,-0x8(%rbp) +ffffffff80101760: c7 45 f4 00 10 00 00 movl $0x1000,-0xc(%rbp) +ffffffff80101767: 8b 45 f4 mov -0xc(%rbp),%eax +ffffffff8010176a: 48 63 d0 movslq %eax,%rdx +ffffffff8010176d: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80101771: 48 39 c2 cmp %rax,%rdx +ffffffff80101774: 48 0f 43 c2 cmovae %rdx,%rax +ffffffff80101778: 48 89 45 c8 mov %rax,-0x38(%rbp) + end = max(start, end); +ffffffff8010177c: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101780: 48 89 45 e8 mov %rax,-0x18(%rbp) +ffffffff80101784: 48 8b 45 c0 mov -0x40(%rbp),%rax +ffffffff80101788: 48 89 45 e0 mov %rax,-0x20(%rbp) +ffffffff8010178c: 48 8b 55 e0 mov -0x20(%rbp),%rdx +ffffffff80101790: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80101794: 48 39 c2 cmp %rax,%rdx +ffffffff80101797: 48 0f 43 c2 cmovae %rdx,%rax +ffffffff8010179b: 48 89 45 c0 mov %rax,-0x40(%rbp) + + return __memblock_find_range_top_down(start, end, size, align); +ffffffff8010179f: 48 8b 4d d0 mov -0x30(%rbp),%rcx +ffffffff801017a3: 48 8b 55 d8 mov -0x28(%rbp),%rdx +ffffffff801017a7: 48 8b 75 c0 mov -0x40(%rbp),%rsi +ffffffff801017ab: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff801017af: 48 89 c7 mov %rax,%rdi +ffffffff801017b2: e8 58 fe ff ff call ffffffff8010160f <__memblock_find_range_top_down> +} +ffffffff801017b7: c9 leave +ffffffff801017b8: c3 ret + +ffffffff801017b9 : + +static u64 memblock_alloc_range(u64 size, u64 align, u64 start, u64 end){ +ffffffff801017b9: f3 0f 1e fa endbr64 +ffffffff801017bd: 55 push %rbp +ffffffff801017be: 48 89 e5 mov %rsp,%rbp +ffffffff801017c1: 48 83 ec 30 sub $0x30,%rsp +ffffffff801017c5: 48 89 7d e8 mov %rdi,-0x18(%rbp) +ffffffff801017c9: 48 89 75 e0 mov %rsi,-0x20(%rbp) +ffffffff801017cd: 48 89 55 d8 mov %rdx,-0x28(%rbp) +ffffffff801017d1: 48 89 4d d0 mov %rcx,-0x30(%rbp) + u64 found; + + found = memblock_find_in_range(size, align, start, end); +ffffffff801017d5: 48 8b 4d d0 mov -0x30(%rbp),%rcx +ffffffff801017d9: 48 8b 55 d8 mov -0x28(%rbp),%rdx +ffffffff801017dd: 48 8b 75 e0 mov -0x20(%rbp),%rsi +ffffffff801017e1: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff801017e5: 48 89 c7 mov %rax,%rdi +ffffffff801017e8: e8 4f ff ff ff call ffffffff8010173c +ffffffff801017ed: 48 89 45 f8 mov %rax,-0x8(%rbp) + if(found && !memblock_reserve(found,size)){ +ffffffff801017f1: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp) +ffffffff801017f6: 74 1d je ffffffff80101815 +ffffffff801017f8: 48 8b 55 e8 mov -0x18(%rbp),%rdx +ffffffff801017fc: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80101800: 48 89 d6 mov %rdx,%rsi +ffffffff80101803: 48 89 c7 mov %rax,%rdi +ffffffff80101806: e8 04 fc ff ff call ffffffff8010140f +ffffffff8010180b: 85 c0 test %eax,%eax +ffffffff8010180d: 75 06 jne ffffffff80101815 + //kmemleak_alloc_phys(found, size, 0, 0); + return found; +ffffffff8010180f: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80101813: eb 05 jmp ffffffff8010181a + } + return 0; +ffffffff80101815: b8 00 00 00 00 mov $0x0,%eax +} +ffffffff8010181a: c9 leave +ffffffff8010181b: c3 ret + +ffffffff8010181c <__memblock_alloc_base>: + +u64 __memblock_alloc_base(u64 size, u64 align, u64 max_addr){ +ffffffff8010181c: f3 0f 1e fa endbr64 +ffffffff80101820: 55 push %rbp +ffffffff80101821: 48 89 e5 mov %rsp,%rbp +ffffffff80101824: 48 83 ec 20 sub $0x20,%rsp +ffffffff80101828: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff8010182c: 48 89 75 f0 mov %rsi,-0x10(%rbp) +ffffffff80101830: 48 89 55 e8 mov %rdx,-0x18(%rbp) + return memblock_alloc_range(size, align, 0, max_addr); +ffffffff80101834: 48 8b 55 e8 mov -0x18(%rbp),%rdx +ffffffff80101838: 48 8b 75 f0 mov -0x10(%rbp),%rsi +ffffffff8010183c: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80101840: 48 89 d1 mov %rdx,%rcx +ffffffff80101843: ba 00 00 00 00 mov $0x0,%edx +ffffffff80101848: 48 89 c7 mov %rax,%rdi +ffffffff8010184b: e8 69 ff ff ff call ffffffff801017b9 +} +ffffffff80101850: c9 leave +ffffffff80101851: c3 ret + +ffffffff80101852 : + +u64 memblock_alloc_base(u64 size, u64 align, u64 max_addr){ +ffffffff80101852: f3 0f 1e fa endbr64 +ffffffff80101856: 55 push %rbp +ffffffff80101857: 48 89 e5 mov %rsp,%rbp +ffffffff8010185a: 48 83 ec 30 sub $0x30,%rsp +ffffffff8010185e: 48 89 7d e8 mov %rdi,-0x18(%rbp) +ffffffff80101862: 48 89 75 e0 mov %rsi,-0x20(%rbp) +ffffffff80101866: 48 89 55 d8 mov %rdx,-0x28(%rbp) + u64 alloc; + + alloc = __memblock_alloc_base(size, align, max_addr); +ffffffff8010186a: 48 8b 55 d8 mov -0x28(%rbp),%rdx +ffffffff8010186e: 48 8b 4d e0 mov -0x20(%rbp),%rcx +ffffffff80101872: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80101876: 48 89 ce mov %rcx,%rsi +ffffffff80101879: 48 89 c7 mov %rax,%rdi +ffffffff8010187c: e8 9b ff ff ff call ffffffff8010181c <__memblock_alloc_base> +ffffffff80101881: 48 89 45 f8 mov %rax,-0x8(%rbp) + + if (alloc == 0) +ffffffff80101885: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp) +ffffffff8010188a: 75 06 jne ffffffff80101892 + //panic(); + return alloc; +ffffffff8010188c: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff80101890: eb 00 jmp ffffffff80101892 +} +ffffffff80101892: c9 leave +ffffffff80101893: c3 ret + +ffffffff80101894 : + +u64 memblock_alloc(u64 size, u64 align){ +ffffffff80101894: f3 0f 1e fa endbr64 +ffffffff80101898: 55 push %rbp +ffffffff80101899: 48 89 e5 mov %rsp,%rbp +ffffffff8010189c: 48 83 ec 10 sub $0x10,%rsp +ffffffff801018a0: 48 89 7d f8 mov %rdi,-0x8(%rbp) +ffffffff801018a4: 48 89 75 f0 mov %rsi,-0x10(%rbp) + return memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE); +ffffffff801018a8: 48 8b 4d f0 mov -0x10(%rbp),%rcx +ffffffff801018ac: 48 8b 45 f8 mov -0x8(%rbp),%rax +ffffffff801018b0: ba 00 00 00 00 mov $0x0,%edx +ffffffff801018b5: 48 89 ce mov %rcx,%rsi +ffffffff801018b8: 48 89 c7 mov %rax,%rdi +ffffffff801018bb: e8 92 ff ff ff call ffffffff80101852 +} +ffffffff801018c0: c9 leave +ffffffff801018c1: c3 ret + +ffffffff801018c2 : + +int memblock_isolate_range(struct memblock_type* type, u64 base, u64 size, int *start_rgn, int *end_rgn){ +ffffffff801018c2: f3 0f 1e fa endbr64 +ffffffff801018c6: 55 push %rbp +ffffffff801018c7: 48 89 e5 mov %rsp,%rbp +ffffffff801018ca: 48 83 ec 60 sub $0x60,%rsp +ffffffff801018ce: 48 89 7d c8 mov %rdi,-0x38(%rbp) +ffffffff801018d2: 48 89 75 c0 mov %rsi,-0x40(%rbp) +ffffffff801018d6: 48 89 55 b8 mov %rdx,-0x48(%rbp) +ffffffff801018da: 48 89 4d b0 mov %rcx,-0x50(%rbp) +ffffffff801018de: 4c 89 45 a8 mov %r8,-0x58(%rbp) + u64 end = base + size; +ffffffff801018e2: 48 8b 55 c0 mov -0x40(%rbp),%rdx +ffffffff801018e6: 48 8b 45 b8 mov -0x48(%rbp),%rax +ffffffff801018ea: 48 01 d0 add %rdx,%rax +ffffffff801018ed: 48 89 45 e8 mov %rax,-0x18(%rbp) + int idx; + struct memblock_region* rgn; + + *start_rgn = *end_rgn = 0; +ffffffff801018f1: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff801018f5: c7 00 00 00 00 00 movl $0x0,(%rax) +ffffffff801018fb: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff801018ff: 8b 10 mov (%rax),%edx +ffffffff80101901: 48 8b 45 b0 mov -0x50(%rbp),%rax +ffffffff80101905: 89 10 mov %edx,(%rax) + + if(!size) +ffffffff80101907: 48 83 7d b8 00 cmpq $0x0,-0x48(%rbp) +ffffffff8010190c: 75 0a jne ffffffff80101918 + return 0; +ffffffff8010190e: b8 00 00 00 00 mov $0x0,%eax +ffffffff80101913: e9 87 01 00 00 jmp ffffffff80101a9f + + for_each_memblock_type(idx, type, rgn){ +ffffffff80101918: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) +ffffffff8010191f: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101923: 48 8b 40 18 mov 0x18(%rax),%rax +ffffffff80101927: 48 89 45 f0 mov %rax,-0x10(%rbp) +ffffffff8010192b: e9 56 01 00 00 jmp ffffffff80101a86 + + u64 rbase = rgn->base; +ffffffff80101930: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101934: 48 8b 00 mov (%rax),%rax +ffffffff80101937: 48 89 45 e0 mov %rax,-0x20(%rbp) + u64 rend = rbase + rgn->size; +ffffffff8010193b: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff8010193f: 48 8b 50 08 mov 0x8(%rax),%rdx +ffffffff80101943: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80101947: 48 01 d0 add %rdx,%rax +ffffffff8010194a: 48 89 45 d8 mov %rax,-0x28(%rbp) + + if(rbase >= end) +ffffffff8010194e: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80101952: 48 3b 45 e8 cmp -0x18(%rbp),%rax +ffffffff80101956: 0f 83 42 01 00 00 jae ffffffff80101a9e + break; + if(rend <= base) +ffffffff8010195c: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff80101960: 48 3b 45 c0 cmp -0x40(%rbp),%rax +ffffffff80101964: 0f 86 ff 00 00 00 jbe ffffffff80101a69 + continue; + + if (rbase < base){ +ffffffff8010196a: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff8010196e: 48 3b 45 c0 cmp -0x40(%rbp),%rax +ffffffff80101972: 73 64 jae ffffffff801019d8 + rgn->base = base; +ffffffff80101974: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101978: 48 8b 55 c0 mov -0x40(%rbp),%rdx +ffffffff8010197c: 48 89 10 mov %rdx,(%rax) + rgn->size -= base - rbase; +ffffffff8010197f: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101983: 48 8b 50 08 mov 0x8(%rax),%rdx +ffffffff80101987: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff8010198b: 48 2b 45 c0 sub -0x40(%rbp),%rax +ffffffff8010198f: 48 01 c2 add %rax,%rdx +ffffffff80101992: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101996: 48 89 50 08 mov %rdx,0x8(%rax) + type->total_size -= base - rbase; +ffffffff8010199a: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff8010199e: 48 8b 50 10 mov 0x10(%rax),%rdx +ffffffff801019a2: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff801019a6: 48 2b 45 c0 sub -0x40(%rbp),%rax +ffffffff801019aa: 48 01 c2 add %rax,%rdx +ffffffff801019ad: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff801019b1: 48 89 50 10 mov %rdx,0x10(%rax) + memblock_insert_region(type, idx, rbase, base - rbase); +ffffffff801019b5: 48 8b 45 c0 mov -0x40(%rbp),%rax +ffffffff801019b9: 48 2b 45 e0 sub -0x20(%rbp),%rax +ffffffff801019bd: 48 89 c1 mov %rax,%rcx +ffffffff801019c0: 48 8b 55 e0 mov -0x20(%rbp),%rdx +ffffffff801019c4: 8b 75 fc mov -0x4(%rbp),%esi +ffffffff801019c7: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff801019cb: 48 89 c7 mov %rax,%rdi +ffffffff801019ce: e8 bf f5 ff ff call ffffffff80100f92 +ffffffff801019d3: e9 92 00 00 00 jmp ffffffff80101a6a + } + else if(rend > end){ +ffffffff801019d8: 48 8b 45 d8 mov -0x28(%rbp),%rax +ffffffff801019dc: 48 3b 45 e8 cmp -0x18(%rbp),%rax +ffffffff801019e0: 76 66 jbe ffffffff80101a48 + rgn->base = end; +ffffffff801019e2: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801019e6: 48 8b 55 e8 mov -0x18(%rbp),%rdx +ffffffff801019ea: 48 89 10 mov %rdx,(%rax) + rgn->size -= end - rbase; +ffffffff801019ed: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff801019f1: 48 8b 50 08 mov 0x8(%rax),%rdx +ffffffff801019f5: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff801019f9: 48 2b 45 e8 sub -0x18(%rbp),%rax +ffffffff801019fd: 48 01 c2 add %rax,%rdx +ffffffff80101a00: 48 8b 45 f0 mov -0x10(%rbp),%rax +ffffffff80101a04: 48 89 50 08 mov %rdx,0x8(%rax) + type->total_size -= end - rbase; +ffffffff80101a08: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101a0c: 48 8b 50 10 mov 0x10(%rax),%rdx +ffffffff80101a10: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80101a14: 48 2b 45 e8 sub -0x18(%rbp),%rax +ffffffff80101a18: 48 01 c2 add %rax,%rdx +ffffffff80101a1b: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101a1f: 48 89 50 10 mov %rdx,0x10(%rax) + memblock_insert_region(type, idx--, rbase, end - rbase); +ffffffff80101a23: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80101a27: 48 2b 45 e0 sub -0x20(%rbp),%rax +ffffffff80101a2b: 48 89 c1 mov %rax,%rcx +ffffffff80101a2e: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80101a31: 8d 50 ff lea -0x1(%rax),%edx +ffffffff80101a34: 89 55 fc mov %edx,-0x4(%rbp) +ffffffff80101a37: 48 8b 55 e0 mov -0x20(%rbp),%rdx +ffffffff80101a3b: 48 8b 7d c8 mov -0x38(%rbp),%rdi +ffffffff80101a3f: 89 c6 mov %eax,%esi +ffffffff80101a41: e8 4c f5 ff ff call ffffffff80100f92 +ffffffff80101a46: eb 22 jmp ffffffff80101a6a + } else{ + if (!*end_rgn) +ffffffff80101a48: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff80101a4c: 8b 00 mov (%rax),%eax +ffffffff80101a4e: 85 c0 test %eax,%eax +ffffffff80101a50: 75 09 jne ffffffff80101a5b + *start_rgn = idx; +ffffffff80101a52: 48 8b 45 b0 mov -0x50(%rbp),%rax +ffffffff80101a56: 8b 55 fc mov -0x4(%rbp),%edx +ffffffff80101a59: 89 10 mov %edx,(%rax) + *end_rgn = idx + 1; +ffffffff80101a5b: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80101a5e: 8d 50 01 lea 0x1(%rax),%edx +ffffffff80101a61: 48 8b 45 a8 mov -0x58(%rbp),%rax +ffffffff80101a65: 89 10 mov %edx,(%rax) +ffffffff80101a67: eb 01 jmp ffffffff80101a6a + continue; +ffffffff80101a69: 90 nop + for_each_memblock_type(idx, type, rgn){ +ffffffff80101a6a: 83 45 fc 01 addl $0x1,-0x4(%rbp) +ffffffff80101a6e: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101a72: 48 8b 50 18 mov 0x18(%rax),%rdx +ffffffff80101a76: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80101a79: 48 98 cltq +ffffffff80101a7b: 48 c1 e0 04 shl $0x4,%rax +ffffffff80101a7f: 48 01 d0 add %rdx,%rax +ffffffff80101a82: 48 89 45 f0 mov %rax,-0x10(%rbp) +ffffffff80101a86: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80101a89: 48 63 d0 movslq %eax,%rdx +ffffffff80101a8c: 48 8b 45 c8 mov -0x38(%rbp),%rax +ffffffff80101a90: 48 8b 00 mov (%rax),%rax +ffffffff80101a93: 48 39 c2 cmp %rax,%rdx +ffffffff80101a96: 0f 82 94 fe ff ff jb ffffffff80101930 +ffffffff80101a9c: eb 01 jmp ffffffff80101a9f + break; +ffffffff80101a9e: 90 nop + } + } +} +ffffffff80101a9f: c9 leave +ffffffff80101aa0: c3 ret + +ffffffff80101aa1 : + +int memblock_remove_range(struct memblock_type* type, u64 base, u64 size){ +ffffffff80101aa1: f3 0f 1e fa endbr64 +ffffffff80101aa5: 55 push %rbp +ffffffff80101aa6: 48 89 e5 mov %rsp,%rbp +ffffffff80101aa9: 48 83 ec 30 sub $0x30,%rsp +ffffffff80101aad: 48 89 7d e8 mov %rdi,-0x18(%rbp) +ffffffff80101ab1: 48 89 75 e0 mov %rsi,-0x20(%rbp) +ffffffff80101ab5: 48 89 55 d8 mov %rdx,-0x28(%rbp) + int start_rgn, end_rgn; + int i,ret; + + ret = memblock_isolate_range(type, base, size, &start_rgn, &end_rgn); +ffffffff80101ab9: 48 8d 7d f0 lea -0x10(%rbp),%rdi +ffffffff80101abd: 48 8d 4d f4 lea -0xc(%rbp),%rcx +ffffffff80101ac1: 48 8b 55 d8 mov -0x28(%rbp),%rdx +ffffffff80101ac5: 48 8b 75 e0 mov -0x20(%rbp),%rsi +ffffffff80101ac9: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80101acd: 49 89 f8 mov %rdi,%r8 +ffffffff80101ad0: 48 89 c7 mov %rax,%rdi +ffffffff80101ad3: e8 ea fd ff ff call ffffffff801018c2 +ffffffff80101ad8: 89 45 f8 mov %eax,-0x8(%rbp) + if(ret) +ffffffff80101adb: 83 7d f8 00 cmpl $0x0,-0x8(%rbp) +ffffffff80101adf: 74 05 je ffffffff80101ae6 + return ret; +ffffffff80101ae1: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101ae4: eb 2c jmp ffffffff80101b12 + + for(i = end_rgn - 1; i >= start_rgn; i--) +ffffffff80101ae6: 8b 45 f0 mov -0x10(%rbp),%eax +ffffffff80101ae9: 83 e8 01 sub $0x1,%eax +ffffffff80101aec: 89 45 fc mov %eax,-0x4(%rbp) +ffffffff80101aef: eb 19 jmp ffffffff80101b0a + memblock_remove_region(type, i); +ffffffff80101af1: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80101af4: 48 63 d0 movslq %eax,%rdx +ffffffff80101af7: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80101afb: 48 89 d6 mov %rdx,%rsi +ffffffff80101afe: 48 89 c7 mov %rax,%rdi +ffffffff80101b01: e8 07 f6 ff ff call ffffffff8010110d + for(i = end_rgn - 1; i >= start_rgn; i--) +ffffffff80101b06: 83 6d fc 01 subl $0x1,-0x4(%rbp) +ffffffff80101b0a: 8b 45 f4 mov -0xc(%rbp),%eax +ffffffff80101b0d: 39 45 fc cmp %eax,-0x4(%rbp) +ffffffff80101b10: 7d df jge ffffffff80101af1 +} +ffffffff80101b12: c9 leave +ffffffff80101b13: c3 ret + +ffffffff80101b14 : + +int memblock_free(u64 base, u64 size){ +ffffffff80101b14: f3 0f 1e fa endbr64 +ffffffff80101b18: 55 push %rbp +ffffffff80101b19: 48 89 e5 mov %rsp,%rbp +ffffffff80101b1c: 48 83 ec 20 sub $0x20,%rsp +ffffffff80101b20: 48 89 7d e8 mov %rdi,-0x18(%rbp) +ffffffff80101b24: 48 89 75 e0 mov %rsi,-0x20(%rbp) + u64 end = base + size -1; +ffffffff80101b28: 48 8b 55 e8 mov -0x18(%rbp),%rdx +ffffffff80101b2c: 48 8b 45 e0 mov -0x20(%rbp),%rax +ffffffff80101b30: 48 01 d0 add %rdx,%rax +ffffffff80101b33: 48 83 e8 01 sub $0x1,%rax +ffffffff80101b37: 48 89 45 f8 mov %rax,-0x8(%rbp) + + //kmemleak_free_part_phys(base, size); + return memblock_remove_range(&memblock.reserved, base, size); +ffffffff80101b3b: 48 8b 55 e0 mov -0x20(%rbp),%rdx +ffffffff80101b3f: 48 8b 45 e8 mov -0x18(%rbp),%rax +ffffffff80101b43: 48 89 c6 mov %rax,%rsi +ffffffff80101b46: 48 c7 c7 48 30 10 80 mov $0xffffffff80103048,%rdi +ffffffff80101b4d: e8 4f ff ff ff call ffffffff80101aa1 +} +ffffffff80101b52: c9 leave +ffffffff80101b53: c3 ret + +ffffffff80101b54 : + +void memblock_init(){ +ffffffff80101b54: f3 0f 1e fa endbr64 +ffffffff80101b58: 55 push %rbp +ffffffff80101b59: 48 89 e5 mov %rsp,%rbp +ffffffff80101b5c: 48 83 ec 10 sub $0x10,%rsp + struct MEMORY_E820* ARDS = (struct MEMORY_E820*)(KERNBASE+ARDSOFFSET); +ffffffff80101b60: 48 c7 45 f0 00 80 00 movq $0xffffffff80008000,-0x10(%rbp) +ffffffff80101b67: 80 + u32 mem_tot = 0; +ffffffff80101b68: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) + for(int i=0; i < 32; i++){ +ffffffff80101b6f: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%rbp) +ffffffff80101b76: e9 82 01 00 00 jmp ffffffff80101cfd + if(ARDS->map[i].type < 1 || ARDS->map[i].type > 4) break; +ffffffff80101b7b: 48 8b 4d f0 mov -0x10(%rbp),%rcx +ffffffff80101b7f: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101b82: 48 63 d0 movslq %eax,%rdx +ffffffff80101b85: 48 89 d0 mov %rdx,%rax +ffffffff80101b88: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101b8c: 48 01 d0 add %rdx,%rax +ffffffff80101b8f: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101b93: 48 01 c8 add %rcx,%rax +ffffffff80101b96: 48 83 c0 14 add $0x14,%rax +ffffffff80101b9a: 8b 00 mov (%rax),%eax +ffffffff80101b9c: 85 c0 test %eax,%eax +ffffffff80101b9e: 0f 84 63 01 00 00 je ffffffff80101d07 +ffffffff80101ba4: 48 8b 4d f0 mov -0x10(%rbp),%rcx +ffffffff80101ba8: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101bab: 48 63 d0 movslq %eax,%rdx +ffffffff80101bae: 48 89 d0 mov %rdx,%rax +ffffffff80101bb1: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101bb5: 48 01 d0 add %rdx,%rax +ffffffff80101bb8: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101bbc: 48 01 c8 add %rcx,%rax +ffffffff80101bbf: 48 83 c0 14 add $0x14,%rax +ffffffff80101bc3: 8b 00 mov (%rax),%eax +ffffffff80101bc5: 83 f8 04 cmp $0x4,%eax +ffffffff80101bc8: 0f 87 39 01 00 00 ja ffffffff80101d07 + mem_tot += ARDS->map[i].len; +ffffffff80101bce: 48 8b 4d f0 mov -0x10(%rbp),%rcx +ffffffff80101bd2: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101bd5: 48 63 d0 movslq %eax,%rdx +ffffffff80101bd8: 48 89 d0 mov %rdx,%rax +ffffffff80101bdb: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101bdf: 48 01 d0 add %rdx,%rax +ffffffff80101be2: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101be6: 48 01 c8 add %rcx,%rax +ffffffff80101be9: 48 8b 40 0c mov 0xc(%rax),%rax +ffffffff80101bed: 01 45 fc add %eax,-0x4(%rbp) + cprintf("%l %l %x\n", ARDS->map[i].addr, ARDS->map[i].addr+ARDS->map[i].len, ARDS->map[i].type); +ffffffff80101bf0: 48 8b 4d f0 mov -0x10(%rbp),%rcx +ffffffff80101bf4: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101bf7: 48 63 d0 movslq %eax,%rdx +ffffffff80101bfa: 48 89 d0 mov %rdx,%rax +ffffffff80101bfd: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101c01: 48 01 d0 add %rdx,%rax +ffffffff80101c04: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101c08: 48 01 c8 add %rcx,%rax +ffffffff80101c0b: 48 83 c0 14 add $0x14,%rax +ffffffff80101c0f: 8b 10 mov (%rax),%edx +ffffffff80101c11: 48 8b 75 f0 mov -0x10(%rbp),%rsi +ffffffff80101c15: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101c18: 48 63 c8 movslq %eax,%rcx +ffffffff80101c1b: 48 89 c8 mov %rcx,%rax +ffffffff80101c1e: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101c22: 48 01 c8 add %rcx,%rax +ffffffff80101c25: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101c29: 48 01 f0 add %rsi,%rax +ffffffff80101c2c: 48 8b 70 04 mov 0x4(%rax),%rsi +ffffffff80101c30: 48 8b 7d f0 mov -0x10(%rbp),%rdi +ffffffff80101c34: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101c37: 48 63 c8 movslq %eax,%rcx +ffffffff80101c3a: 48 89 c8 mov %rcx,%rax +ffffffff80101c3d: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101c41: 48 01 c8 add %rcx,%rax +ffffffff80101c44: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101c48: 48 01 f8 add %rdi,%rax +ffffffff80101c4b: 48 8b 40 0c mov 0xc(%rax),%rax +ffffffff80101c4f: 48 01 c6 add %rax,%rsi +ffffffff80101c52: 48 8b 7d f0 mov -0x10(%rbp),%rdi +ffffffff80101c56: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101c59: 48 63 c8 movslq %eax,%rcx +ffffffff80101c5c: 48 89 c8 mov %rcx,%rax +ffffffff80101c5f: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101c63: 48 01 c8 add %rcx,%rax +ffffffff80101c66: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101c6a: 48 01 f8 add %rdi,%rax +ffffffff80101c6d: 48 8b 40 04 mov 0x4(%rax),%rax +ffffffff80101c71: 89 d1 mov %edx,%ecx +ffffffff80101c73: 48 89 f2 mov %rsi,%rdx +ffffffff80101c76: 48 89 c6 mov %rax,%rsi +ffffffff80101c79: 48 c7 c7 eb 1d 10 80 mov $0xffffffff80101deb,%rdi +ffffffff80101c80: b8 00 00 00 00 mov $0x0,%eax +ffffffff80101c85: e8 ac e6 ff ff call ffffffff80100336 + if(ARDS->map[i].type == 1){ +ffffffff80101c8a: 48 8b 4d f0 mov -0x10(%rbp),%rcx +ffffffff80101c8e: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101c91: 48 63 d0 movslq %eax,%rdx +ffffffff80101c94: 48 89 d0 mov %rdx,%rax +ffffffff80101c97: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101c9b: 48 01 d0 add %rdx,%rax +ffffffff80101c9e: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101ca2: 48 01 c8 add %rcx,%rax +ffffffff80101ca5: 48 83 c0 14 add $0x14,%rax +ffffffff80101ca9: 8b 00 mov (%rax),%eax +ffffffff80101cab: 83 f8 01 cmp $0x1,%eax +ffffffff80101cae: 75 49 jne ffffffff80101cf9 + memblock_add(ARDS->map[i].addr, ARDS->map[i].len); +ffffffff80101cb0: 48 8b 4d f0 mov -0x10(%rbp),%rcx +ffffffff80101cb4: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101cb7: 48 63 d0 movslq %eax,%rdx +ffffffff80101cba: 48 89 d0 mov %rdx,%rax +ffffffff80101cbd: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101cc1: 48 01 d0 add %rdx,%rax +ffffffff80101cc4: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101cc8: 48 01 c8 add %rcx,%rax +ffffffff80101ccb: 48 8b 50 0c mov 0xc(%rax),%rdx +ffffffff80101ccf: 48 8b 75 f0 mov -0x10(%rbp),%rsi +ffffffff80101cd3: 8b 45 f8 mov -0x8(%rbp),%eax +ffffffff80101cd6: 48 63 c8 movslq %eax,%rcx +ffffffff80101cd9: 48 89 c8 mov %rcx,%rax +ffffffff80101cdc: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101ce0: 48 01 c8 add %rcx,%rax +ffffffff80101ce3: 48 c1 e0 02 shl $0x2,%rax +ffffffff80101ce7: 48 01 f0 add %rsi,%rax +ffffffff80101cea: 48 8b 40 04 mov 0x4(%rax),%rax +ffffffff80101cee: 48 89 d6 mov %rdx,%rsi +ffffffff80101cf1: 48 89 c7 mov %rax,%rdi +ffffffff80101cf4: e8 e9 f6 ff ff call ffffffff801013e2 + for(int i=0; i < 32; i++){ +ffffffff80101cf9: 83 45 f8 01 addl $0x1,-0x8(%rbp) +ffffffff80101cfd: 83 7d f8 1f cmpl $0x1f,-0x8(%rbp) +ffffffff80101d01: 0f 8e 74 fe ff ff jle ffffffff80101b7b + //cprintf("%x %x\n", ARDS->map[i].addr, ARDS->map[i].len); + } + } + cprintf("%dMB\n",mem_tot/1048576 + 1); +ffffffff80101d07: 8b 45 fc mov -0x4(%rbp),%eax +ffffffff80101d0a: c1 e8 14 shr $0x14,%eax +ffffffff80101d0d: 83 c0 01 add $0x1,%eax +ffffffff80101d10: 89 c6 mov %eax,%esi +ffffffff80101d12: 48 c7 c7 f5 1d 10 80 mov $0xffffffff80101df5,%rdi +ffffffff80101d19: b8 00 00 00 00 mov $0x0,%eax +ffffffff80101d1e: e8 13 e6 ff ff call ffffffff80100336 +} +ffffffff80101d23: 90 nop +ffffffff80101d24: c9 leave +ffffffff80101d25: c3 ret diff --git a/out/kernel.elf b/out/kernel.elf new file mode 100644 index 0000000000000000000000000000000000000000..5cb374122e1cabf279a761924e9964f38c39f05c GIT binary patch literal 32840 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 YrZrC2KjRAg-}o!R|9MeZztj2uFMR(v*8l(j literal 0 HcmV?d00001 diff --git a/out/kernel.sym b/out/kernel.sym new file mode 100644 index 0000000..10c2bfa --- /dev/null +++ b/out/kernel.sym @@ -0,0 +1,71 @@ +0000000000000000 entry64.o +ffffffff80100065 ptbl_loop +ffffffff801000b0 gdtr64 +ffffffff801000e0 entry64low +ffffffff801000d8 gdt64_end +ffffffff801000c0 gdt64_begin +ffffffff801000e9 entry64high +ffffffff8010010b entry64mp +0000000000000000 console.c +ffffffff80100126 inb +ffffffff80100144 outb +ffffffff80100165 cli +ffffffff80103000 panicked +ffffffff80102000 digits +ffffffff8010016d printptr +ffffffff8010089e consputc +ffffffff801001b4 printint +ffffffff8010026f printlong +ffffffff80102020 digits.0 +ffffffff80102018 crt +ffffffff80100717 cgaputc +0000000000000000 main.c +0000000000000000 string.c +ffffffff801008d6 stosb +ffffffff8010090c stosl +0000000000000000 vm.c +ffffffff80100c39 v2p +ffffffff80100c53 page_walk +ffffffff80100ec8 mamppages +0000000000000000 memblock.c +ffffffff801017b9 memblock_alloc_range +ffffffff80101034 memblock_merge_regions +ffffffff80100bd2 safestrcpy +ffffffff80101852 memblock_alloc_base +ffffffff80100a37 memmove +ffffffff80100336 cprintf +0000000000103000 mboot_load_end +ffffffff8010110d memblock_remove_region +ffffffff80101b14 memblock_free +0000000000100000 mboot_load_addr +ffffffff80103000 edata +ffffffff8010143c __next_mem_range_rev +0000000000100020 mboot_entry_addr +ffffffff80103020 memblock +ffffffff80101b54 memblock_init +ffffffff80100074 entry32mp +ffffffff80100109 __deadloop +ffffffff80100000 mboot_header +ffffffff80100020 mboot_entry +ffffffff801013e2 memblock_add +ffffffff80101894 memblock_alloc +ffffffff80104000 end +ffffffff801000e9 _start +ffffffff80100ab6 strncmp +ffffffff80100b27 strncpy +ffffffff8010140f memblock_reserve +0000000000104000 mboot_bss_end +ffffffff801006d4 panic +ffffffff80100000 begin +ffffffff801009c4 memcmp +ffffffff80100f92 memblock_insert_region +ffffffff80100942 memset +ffffffff801008ba main +ffffffff8010173c memblock_find_in_range +ffffffff801018c2 memblock_isolate_range +ffffffff80100116 wrmsr +ffffffff8010160f __memblock_find_range_top_down +ffffffff80100b9c strlen +ffffffff80101aa1 memblock_remove_range +ffffffff801011e1 memblock_add_regions +ffffffff8010181c __memblock_alloc_base diff --git a/tools/dot-bochsrc b/tools/dot-bochsrc new file mode 100644 index 0000000..ba13db7 --- /dev/null +++ b/tools/dot-bochsrc @@ -0,0 +1,738 @@ +# You may now use double quotes around pathnames, in case +# your pathname includes spaces. + +#======================================================================= +# CONFIG_INTERFACE +# +# The configuration interface is a series of menus or dialog boxes that +# allows you to change all the settings that control Bochs's behavior. +# There are two choices of configuration interface: a text mode version +# called "textconfig" and a graphical version called "wx". The text +# mode version uses stdin/stdout and is always compiled in. The graphical +# version is only available when you use "--with-wx" on the configure +# command. If you do not write a config_interface line, Bochs will +# choose a default for you. +# +# NOTE: if you use the "wx" configuration interface, you must also use +# the "wx" display library. +#======================================================================= +#config_interface: textconfig +#config_interface: wx + +#======================================================================= +# DISPLAY_LIBRARY +# +# The display library is the code that displays the Bochs VGA screen. Bochs +# has a selection of about 10 different display library implementations for +# different platforms. If you run configure with multiple --with-* options, +# the display_library command lets you choose which one you want to run with. +# If you do not write a display_library line, Bochs will choose a default for +# you. +# +# The choices are: +# x use X windows interface, cross platform +# win32 use native win32 libraries +# carbon use Carbon library (for MacOS X) +# beos use native BeOS libraries +# macintosh use MacOS pre-10 +# amigaos use native AmigaOS libraries +# sdl use SDL library, cross platform +# svga use SVGALIB library for Linux, allows graphics without X11 +# term text only, uses curses/ncurses library, cross platform +# rfb provides an interface to AT&T's VNC viewer, cross platform +# wx use wxWidgets library, cross platform +# nogui no display at all +# +# NOTE: if you use the "wx" configuration interface, you must also use +# the "wx" display library. +# +# Specific options: +# Some display libraries now support specific option to control their +# behaviour. See the examples below for currently supported options. +#======================================================================= +#display_library: amigaos +#display_library: beos +#display_library: carbon +#display_library: macintosh +#display_library: nogui +#display_library: rfb, options="timeout=60" # time to wait for client +#display_library: sdl, options="fullscreen" # startup in fullscreen mode +#display_library: term +#display_library: win32, options="legacyF12" # use F12 to toggle mouse +#display_library: wx +#display_library: x + +#======================================================================= +# ROMIMAGE: +# The ROM BIOS controls what the PC does when it first powers on. +# Normally, you can use a precompiled BIOS in the source or binary +# distribution called BIOS-bochs-latest. The ROM BIOS is usually loaded +# starting at address 0xf0000, and it is exactly 64k long. +# You can also use the environment variable $BXSHARE to specify the +# location of the BIOS. +# The usage of external large BIOS images (up to 512k) at memory top is +# now supported, but we still recommend to use the BIOS distributed with +# Bochs. Now the start address can be calculated from image size. +#======================================================================= +romimage: file=$BXSHARE/BIOS-bochs-latest +#romimage: file=mybios.bin, address=0xfff80000 # 512k at memory top +#romimage: file=mybios.bin # calculate start address from image size + +#======================================================================= +# CPU: +# This defines cpu-related parameters inside Bochs: +# +# COUNT: +# Set the number of processors when Bochs is compiled for SMP emulation. +# Bochs currently supports up to 8 processors. If Bochs is compiled +# without SMP support, it won't accept values different from 1. +# +# IPS: +# Emulated Instructions Per Second. This is the number of IPS that bochs +# is capable of running on your machine. You can recompile Bochs with +# --enable-show-ips option enabled, to find your workstation's capability. +# Measured IPS value will then be logged into your log file or status bar +# (if supported by the gui). +# +# IPS is used to calibrate many time-dependent events within the bochs +# simulation. For example, changing IPS affects the frequency of VGA +# updates, the duration of time before a key starts to autorepeat, and +# the measurement of BogoMips and other benchmarks. +# +# Examples: +# Machine Mips +# ________________________________________________________________ +# 2.1Ghz Athlon XP with Linux 2.6/g++ 3.4 12 to 15 Mips +# 1.6Ghz Intel P4 with Win2000/g++ 3.3 5 to 7 Mips +# 650Mhz Athlon K-7 with Linux 2.4.4/egcs-2.91.66 2 to 2.5 Mips +# 400Mhz Pentium II with Linux 2.0.36/egcs-1.0.3 1 to 1.8 Mips +#======================================================================= +cpu: count=2, ips=10000000 + +#======================================================================= +# MEGS +# Set the number of Megabytes of physical memory you want to emulate. +# The default is 32MB, most OS's won't need more than that. +# The maximum amount of memory supported is 2048Mb. +#======================================================================= +#megs: 256 +#megs: 128 +#megs: 64 +megs: 32 +#megs: 16 +#megs: 8 + +#======================================================================= +# OPTROMIMAGE[1-4]: +# You may now load up to 4 optional ROM images. Be sure to use a +# read-only area, typically between C8000 and EFFFF. These optional +# ROM images should not overwrite the rombios (located at +# F0000-FFFFF) and the videobios (located at C0000-C7FFF). +# Those ROM images will be initialized by the bios if they contain +# the right signature (0x55AA) and a valid checksum. +# It can also be a convenient way to upload some arbitrary code/data +# in the simulation, that can be retrieved by the boot loader +#======================================================================= +#optromimage1: file=optionalrom.bin, address=0xd0000 +#optromimage2: file=optionalrom.bin, address=0xd1000 +#optromimage3: file=optionalrom.bin, address=0xd2000 +#optromimage4: file=optionalrom.bin, address=0xd3000 + +#optramimage1: file=/path/file1.img, address=0x0010000 +#optramimage2: file=/path/file2.img, address=0x0020000 +#optramimage3: file=/path/file3.img, address=0x0030000 +#optramimage4: file=/path/file4.img, address=0x0040000 + +#======================================================================= +# VGAROMIMAGE +# You now need to load a VGA ROM BIOS into C0000. +#======================================================================= +#vgaromimage: file=bios/VGABIOS-elpin-2.40 +vgaromimage: file=$BXSHARE/VGABIOS-lgpl-latest +#vgaromimage: file=bios/VGABIOS-lgpl-latest-cirrus + +#======================================================================= +# VGA: +# Here you can specify the display extension to be used. With the value +# 'none' you can use standard VGA with no extension. Other supported +# values are 'vbe' for Bochs VBE and 'cirrus' for Cirrus SVGA support. +#======================================================================= +#vga: extension=cirrus +#vga: extension=vbe +vga: extension=none + +#======================================================================= +# FLOPPYA: +# Point this to pathname of floppy image file or device +# This should be of a bootable floppy(image/device) if you're +# booting from 'a' (or 'floppy'). +# +# You can set the initial status of the media to 'ejected' or 'inserted'. +# floppya: 2_88=path, status=ejected (2.88M 3.5" floppy) +# floppya: 1_44=path, status=inserted (1.44M 3.5" floppy) +# floppya: 1_2=path, status=ejected (1.2M 5.25" floppy) +# floppya: 720k=path, status=inserted (720K 3.5" floppy) +# floppya: 360k=path, status=inserted (360K 5.25" floppy) +# floppya: 320k=path, status=inserted (320K 5.25" floppy) +# floppya: 180k=path, status=inserted (180K 5.25" floppy) +# floppya: 160k=path, status=inserted (160K 5.25" floppy) +# floppya: image=path, status=inserted (guess type from image size) +# +# The path should be the name of a disk image file. On Unix, you can use a raw +# device name such as /dev/fd0 on Linux. On win32 platforms, use drive letters +# such as a: or b: as the path. The parameter 'image' works with image files +# only. In that case the size must match one of the supported types. +#======================================================================= +floppya: 1_44=/dev/fd0, status=inserted +#floppya: image=../1.44, status=inserted +#floppya: 1_44=/dev/fd0H1440, status=inserted +#floppya: 1_2=../1_2, status=inserted +#floppya: 1_44=a:, status=inserted +#floppya: 1_44=a.img, status=inserted +#floppya: 1_44=/dev/rfd0a, status=inserted + +#======================================================================= +# FLOPPYB: +# See FLOPPYA above for syntax +#======================================================================= +#floppyb: 1_44=b:, status=inserted +floppyb: 1_44=b.img, status=inserted + +#======================================================================= +# ATA0, ATA1, ATA2, ATA3 +# ATA controller for hard disks and cdroms +# +# ata[0-3]: enabled=[0|1], ioaddr1=addr, ioaddr2=addr, irq=number +# +# These options enables up to 4 ata channels. For each channel +# the two base io addresses and the irq must be specified. +# +# ata0 and ata1 are enabled by default with the values shown below +# +# Examples: +# ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14 +# ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15 +# ata2: enabled=1, ioaddr1=0x1e8, ioaddr2=0x3e0, irq=11 +# ata3: enabled=1, ioaddr1=0x168, ioaddr2=0x360, irq=9 +#======================================================================= +ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14 +ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15 +ata2: enabled=0, ioaddr1=0x1e8, ioaddr2=0x3e0, irq=11 +ata3: enabled=0, ioaddr1=0x168, ioaddr2=0x360, irq=9 + +#======================================================================= +# ATA[0-3]-MASTER, ATA[0-3]-SLAVE +# +# This defines the type and characteristics of all attached ata devices: +# type= type of attached device [disk|cdrom] +# mode= only valid for disks [flat|concat|external|dll|sparse|vmware3] +# mode= only valid for disks [undoable|growing|volatile] +# path= path of the image +# cylinders= only valid for disks +# heads= only valid for disks +# spt= only valid for disks +# status= only valid for cdroms [inserted|ejected] +# biosdetect= type of biosdetection [none|auto], only for disks on ata0 [cmos] +# translation=type of translation of the bios, only for disks [none|lba|large|rechs|auto] +# model= string returned by identify device command +# journal= optional filename of the redolog for undoable and volatile disks +# +# Point this at a hard disk image file, cdrom iso file, or physical cdrom +# device. To create a hard disk image, try running bximage. It will help you +# choose the size and then suggest a line that works with it. +# +# In UNIX it may be possible to use a raw device as a Bochs hard disk, +# but WE DON'T RECOMMEND IT. In Windows there is no easy way. +# +# In windows, the drive letter + colon notation should be used for cdroms. +# Depending on versions of windows and drivers, you may only be able to +# access the "first" cdrom in the system. On MacOSX, use path="drive" +# to access the physical drive. +# +# The path is always mandatory. For flat hard disk images created with +# bximage geometry autodetection can be used (cylinders=0 -> cylinders are +# calculated using heads=16 and spt=63). For other hard disk images and modes +# the cylinders, heads, and spt are mandatory. +# +# Default values are: +# mode=flat, biosdetect=auto, translation=auto, model="Generic 1234" +# +# The biosdetect option has currently no effect on the bios +# +# Examples: +# ata0-master: type=disk, mode=flat, path=10M.sample, cylinders=306, heads=4, spt=17 +# ata0-slave: type=disk, mode=flat, path=20M.sample, cylinders=615, heads=4, spt=17 +# ata1-master: type=disk, mode=flat, path=30M.sample, cylinders=615, heads=6, spt=17 +# ata1-slave: type=disk, mode=flat, path=46M.sample, cylinders=940, heads=6, spt=17 +# ata2-master: type=disk, mode=flat, path=62M.sample, cylinders=940, heads=8, spt=17 +# ata2-slave: type=disk, mode=flat, path=112M.sample, cylinders=900, heads=15, spt=17 +# ata3-master: type=disk, mode=flat, path=483M.sample, cylinders=1024, heads=15, spt=63 +# ata3-slave: type=cdrom, path=iso.sample, status=inserted +#======================================================================= +ata0-master: type=disk, mode=flat, path="xv6.img", cylinders=100, heads=10, spt=10 +ata0-slave: type=disk, mode=flat, path="fs.img", cylinders=1024, heads=1, spt=1 +#ata0-slave: type=cdrom, path=D:, status=inserted +#ata0-slave: type=cdrom, path=/dev/cdrom, status=inserted +#ata0-slave: type=cdrom, path="drive", status=inserted +#ata0-slave: type=cdrom, path=/dev/rcd0d, status=inserted + +#======================================================================= +# BOOT: +# This defines the boot sequence. Now you can specify up to 3 boot drives. +# You can either boot from 'floppy', 'disk' or 'cdrom' +# legacy 'a' and 'c' are also supported +# Examples: +# boot: floppy +# boot: disk +# boot: cdrom +# boot: c +# boot: a +# boot: cdrom, floppy, disk +#======================================================================= +#boot: floppy +boot: disk + +#======================================================================= +# CLOCK: +# This defines the parameters of the clock inside Bochs: +# +# SYNC: +# TO BE COMPLETED (see Greg explanation in feature request #536329) +# +# TIME0: +# Specifies the start (boot) time of the virtual machine. Use a time +# value as returned by the time(2) system call. If no time0 value is +# set or if time0 equal to 1 (special case) or if time0 equal 'local', +# the simulation will be started at the current local host time. +# If time0 equal to 2 (special case) or if time0 equal 'utc', +# the simulation will be started at the current utc time. +# +# Syntax: +# clock: sync=[none|slowdown|realtime|both], time0=[timeValue|local|utc] +# +# Example: +# clock: sync=none, time0=local # Now (localtime) +# clock: sync=slowdown, time0=315529200 # Tue Jan 1 00:00:00 1980 +# clock: sync=none, time0=631148400 # Mon Jan 1 00:00:00 1990 +# clock: sync=realtime, time0=938581955 # Wed Sep 29 07:12:35 1999 +# clock: sync=realtime, time0=946681200 # Sat Jan 1 00:00:00 2000 +# clock: sync=none, time0=1 # Now (localtime) +# clock: sync=none, time0=utc # Now (utc/gmt) +# +# Default value are sync=none, time0=local +#======================================================================= +#clock: sync=none, time0=local + + +#======================================================================= +# FLOPPY_BOOTSIG_CHECK: disabled=[0|1] +# Enables or disables the 0xaa55 signature check on boot floppies +# Defaults to disabled=0 +# Examples: +# floppy_bootsig_check: disabled=0 +# floppy_bootsig_check: disabled=1 +#======================================================================= +#floppy_bootsig_check: disabled=1 +floppy_bootsig_check: disabled=0 + +#======================================================================= +# LOG: +# Give the path of the log file you'd like Bochs debug and misc. verbiage +# to be written to. If you don't use this option or set the filename to +# '-' the output is written to the console. If you really don't want it, +# make it "/dev/null" (Unix) or "nul" (win32). :^( +# +# Examples: +# log: ./bochs.out +# log: /dev/tty +#======================================================================= +#log: /dev/null +log: bochsout.txt + +#======================================================================= +# LOGPREFIX: +# This handles the format of the string prepended to each log line. +# You may use those special tokens : +# %t : 11 decimal digits timer tick +# %i : 8 hexadecimal digits of cpu current eip (ignored in SMP configuration) +# %e : 1 character event type ('i'nfo, 'd'ebug, 'p'anic, 'e'rror) +# %d : 5 characters string of the device, between brackets +# +# Default : %t%e%d +# Examples: +# logprefix: %t-%e-@%i-%d +# logprefix: %i%e%d +#======================================================================= +#logprefix: %t%e%d + +#======================================================================= +# LOG CONTROLS +# +# Bochs now has four severity levels for event logging. +# panic: cannot proceed. If you choose to continue after a panic, +# don't be surprised if you get strange behavior or crashes. +# error: something went wrong, but it is probably safe to continue the +# simulation. +# info: interesting or useful messages. +# debug: messages useful only when debugging the code. This may +# spit out thousands per second. +# +# For events of each level, you can choose to crash, report, or ignore. +# TODO: allow choice based on the facility: e.g. crash on panics from +# everything except the cdrom, and only report those. +# +# If you are experiencing many panics, it can be helpful to change +# the panic action to report instead of fatal. However, be aware +# that anything executed after a panic is uncharted territory and can +# cause bochs to become unstable. The panic is a "graceful exit," so +# if you disable it you may get a spectacular disaster instead. +#======================================================================= +panic: action=ask +error: action=report +info: action=report +debug: action=ignore +#pass: action=fatal + +#======================================================================= +# DEBUGGER_LOG: +# Give the path of the log file you'd like Bochs to log debugger output. +# If you really don't want it, make it /dev/null or '-'. :^( +# +# Examples: +# debugger_log: ./debugger.out +#======================================================================= +#debugger_log: /dev/null +#debugger_log: debugger.out +debugger_log: - + +#======================================================================= +# COM1, COM2, COM3, COM4: +# This defines a serial port (UART type 16550A). In the 'term' you can specify +# a device to use as com1. This can be a real serial line, or a pty. To use +# a pty (under X/Unix), create two windows (xterms, usually). One of them will +# run bochs, and the other will act as com1. Find out the tty the com1 +# window using the `tty' command, and use that as the `dev' parameter. +# Then do `sleep 1000000' in the com1 window to keep the shell from +# messing with things, and run bochs in the other window. Serial I/O to +# com1 (port 0x3f8) will all go to the other window. +# Other serial modes are 'null' (no input/output), 'file' (output to a file +# specified as the 'dev' parameter), 'raw' (use the real serial port - under +# construction for win32), 'mouse' (standard serial mouse - requires +# mouse option setting 'type=serial' or 'type=serial_wheel') and 'socket' +# (connect a networking socket). +# +# Examples: +# com1: enabled=1, mode=null +# com1: enabled=1, mode=mouse +# com2: enabled=1, mode=file, dev=serial.out +# com3: enabled=1, mode=raw, dev=com1 +# com3: enabled=1, mode=socket, dev=localhost:8888 +#======================================================================= +#com1: enabled=1, mode=term, dev=/dev/ttyp9 + + +#======================================================================= +# PARPORT1, PARPORT2: +# This defines a parallel (printer) port. When turned on and an output file is +# defined the emulated printer port sends characters printed by the guest OS +# into the output file. On some platforms a device filename can be used to +# send the data to the real parallel port (e.g. "/dev/lp0" on Linux, "lpt1" on +# win32 platforms). +# +# Examples: +# parport1: enabled=1, file="parport.out" +# parport2: enabled=1, file="/dev/lp0" +# parport1: enabled=0 +#======================================================================= +parport1: enabled=1, file="/dev/stdout" + +#======================================================================= +# SB16: +# This defines the SB16 sound emulation. It can have several of the +# following properties. +# All properties are in the format sb16: property=value +# midi: The filename is where the midi data is sent. This can be a +# device or just a file if you want to record the midi data. +# midimode: +# 0=no data +# 1=output to device (system dependent. midi denotes the device driver) +# 2=SMF file output, including headers +# 3=output the midi data stream to the file (no midi headers and no +# delta times, just command and data bytes) +# wave: This is the device/file where wave output is stored +# wavemode: +# 0=no data +# 1=output to device (system dependent. wave denotes the device driver) +# 2=VOC file output, incl. headers +# 3=output the raw wave stream to the file +# log: The file to write the sb16 emulator messages to. +# loglevel: +# 0=no log +# 1=resource changes, midi program and bank changes +# 2=severe errors +# 3=all errors +# 4=all errors plus all port accesses +# 5=all errors and port accesses plus a lot of extra info +# dmatimer: +# microseconds per second for a DMA cycle. Make it smaller to fix +# non-continuous sound. 750000 is usually a good value. This needs a +# reasonably correct setting for the IPS parameter of the CPU option. +# +# For an example look at the next line: +#======================================================================= + +#sb16: midimode=1, midi=/dev/midi00, wavemode=1, wave=/dev/dsp, loglevel=2, log=sb16.log, dmatimer=600000 + +#======================================================================= +# VGA_UPDATE_INTERVAL: +# Video memory is scanned for updates and screen updated every so many +# virtual seconds. The default is 40000, about 25Hz. Keep in mind that +# you must tweak the 'cpu: ips=N' directive to be as close to the number +# of emulated instructions-per-second your workstation can do, for this +# to be accurate. +# +# Examples: +# vga_update_interval: 250000 +#======================================================================= +vga_update_interval: 300000 + +# using for Winstone '98 tests +#vga_update_interval: 100000 + +#======================================================================= +# KEYBOARD_SERIAL_DELAY: +# Approximate time in microseconds that it takes one character to +# be transfered from the keyboard to controller over the serial path. +# Examples: +# keyboard_serial_delay: 200 +#======================================================================= +keyboard_serial_delay: 250 + +#======================================================================= +# KEYBOARD_PASTE_DELAY: +# Approximate time in microseconds between attempts to paste +# characters to the keyboard controller. This leaves time for the +# guest os to deal with the flow of characters. The ideal setting +# depends on how your operating system processes characters. The +# default of 100000 usec (.1 seconds) was chosen because it works +# consistently in Windows. +# +# If your OS is losing characters during a paste, increase the paste +# delay until it stops losing characters. +# +# Examples: +# keyboard_paste_delay: 100000 +#======================================================================= +keyboard_paste_delay: 100000 + +#======================================================================= +# MOUSE: +# This option prevents Bochs from creating mouse "events" unless a mouse +# is enabled. The hardware emulation itself is not disabled by this. +# You can turn the mouse on by setting enabled to 1, or turn it off by +# setting enabled to 0. Unless you have a particular reason for enabling +# the mouse by default, it is recommended that you leave it off. +# You can also toggle the mouse usage at runtime (control key + middle +# mouse button on X11, SDL, wxWidgets and Win32). +# With the mouse type option you can select the type of mouse to emulate. +# The default value is 'ps2'. The other choices are 'imps2' (wheel mouse +# on PS/2), 'serial', 'serial_wheel' (one com port requires setting +# 'mode=mouse') and 'usb' (3-button mouse - one of the USB ports must be +# connected with the 'mouse' device - requires PCI and USB support). +# +# Examples: +# mouse: enabled=1 +# mouse: enabled=1, type=imps2 +# mouse: enabled=1, type=serial +# mouse: enabled=0 +#======================================================================= +mouse: enabled=0 + +#======================================================================= +# private_colormap: Request that the GUI create and use it's own +# non-shared colormap. This colormap will be used +# when in the bochs window. If not enabled, a +# shared colormap scheme may be used. Not implemented +# on all GUI's. +# +# Examples: +# private_colormap: enabled=1 +# private_colormap: enabled=0 +#======================================================================= +private_colormap: enabled=0 + +#======================================================================= +# fullscreen: ONLY IMPLEMENTED ON AMIGA +# Request that Bochs occupy the entire screen instead of a +# window. +# +# Examples: +# fullscreen: enabled=0 +# fullscreen: enabled=1 +#======================================================================= +#fullscreen: enabled=0 +#screenmode: name="sample" + +#======================================================================= +# ne2k: NE2000 compatible ethernet adapter +# +# Examples: +# ne2k: ioaddr=IOADDR, irq=IRQ, mac=MACADDR, ethmod=MODULE, ethdev=DEVICE, script=SCRIPT +# +# ioaddr, irq: You probably won't need to change ioaddr and irq, unless there +# are IRQ conflicts. +# +# mac: The MAC address MUST NOT match the address of any machine on the net. +# Also, the first byte must be an even number (bit 0 set means a multicast +# address), and you cannot use ff:ff:ff:ff:ff:ff because that's the broadcast +# address. For the ethertap module, you must use fe:fd:00:00:00:01. There may +# be other restrictions too. To be safe, just use the b0:c4... address. +# +# ethdev: The ethdev value is the name of the network interface on your host +# platform. On UNIX machines, you can get the name by running ifconfig. On +# Windows machines, you must run niclist to get the name of the ethdev. +# Niclist source code is in misc/niclist.c and it is included in Windows +# binary releases. +# +# script: The script value is optional, and is the name of a script that +# is executed after bochs initialize the network interface. You can use +# this script to configure this network interface, or enable masquerading. +# This is mainly useful for the tun/tap devices that only exist during +# Bochs execution. The network interface name is supplied to the script +# as first parameter +# +# If you don't want to make connections to any physical networks, +# you can use the following 'ethmod's to simulate a virtual network. +# null: All packets are discarded, but logged to a few files. +# arpback: ARP is simulated. Disabled by default. +# vde: Virtual Distributed Ethernet +# vnet: ARP, ICMP-echo(ping), DHCP and read/write TFTP are simulated. +# The virtual host uses 192.168.10.1. +# DHCP assigns 192.168.10.2 to the guest. +# TFTP uses the ethdev value for the root directory and doesn't +# overwrite files. +# +#======================================================================= +# ne2k: ioaddr=0x240, irq=9, mac=fe:fd:00:00:00:01, ethmod=fbsd, ethdev=en0 #macosx +# ne2k: ioaddr=0x240, irq=9, mac=b0:c4:20:00:00:00, ethmod=fbsd, ethdev=xl0 +# ne2k: ioaddr=0x240, irq=9, mac=b0:c4:20:00:00:00, ethmod=linux, ethdev=eth0 +# ne2k: ioaddr=0x240, irq=9, mac=b0:c4:20:00:00:01, ethmod=win32, ethdev=MYCARD +# ne2k: ioaddr=0x240, irq=9, mac=fe:fd:00:00:00:01, ethmod=tap, ethdev=tap0 +# ne2k: ioaddr=0x240, irq=9, mac=fe:fd:00:00:00:01, ethmod=tuntap, ethdev=/dev/net/tun0, script=./tunconfig +# ne2k: ioaddr=0x240, irq=9, mac=b0:c4:20:00:00:01, ethmod=null, ethdev=eth0 +# ne2k: ioaddr=0x240, irq=9, mac=b0:c4:20:00:00:01, ethmod=vde, ethdev="/tmp/vde.ctl" +# ne2k: ioaddr=0x240, irq=9, mac=b0:c4:20:00:00:01, ethmod=vnet, ethdev="c:/temp" + +#======================================================================= +# KEYBOARD_MAPPING: +# This enables a remap of a physical localized keyboard to a +# virtualized us keyboard, as the PC architecture expects. +# If enabled, the keymap file must be specified. +# +# Examples: +# keyboard_mapping: enabled=1, map=gui/keymaps/x11-pc-de.map +#======================================================================= +keyboard_mapping: enabled=0, map= + +#======================================================================= +# KEYBOARD_TYPE: +# Type of keyboard return by a "identify keyboard" command to the +# keyboard controler. It must be one of "xt", "at" or "mf". +# Defaults to "mf". It should be ok for almost everybody. A known +# exception is french macs, that do have a "at"-like keyboard. +# +# Examples: +# keyboard_type: mf +#======================================================================= +#keyboard_type: mf + +#======================================================================= +# USER_SHORTCUT: +# This defines the keyboard shortcut to be sent when you press the "user" +# button in the headerbar. The shortcut string is a combination of maximum +# 3 key names (listed below) separated with a '-' character. The old-style +# syntax (without the '-') still works for the key combinations supported +# in Bochs 2.2.1. +# Valid key names: +# "alt", "bksl", "bksp", "ctrl", "del", "down", "end", "enter", "esc", +# "f1", ... "f12", "home", "ins", "left", "menu", "minus", "pgdwn", "pgup", +# "plus", "right", "shift", "space", "tab", "up", and "win". +# +# Example: +# user_shortcut: keys=ctrl-alt-del +#======================================================================= +#user_shortcut: keys=ctrl-alt-del + +#======================================================================= +# I440FXSUPPORT: +# This option controls the presence of the i440FX PCI chipset. You can +# also specify the devices connected to PCI slots. Up to 5 slots are +# available now. These devices are currently supported: ne2k, pcivga, +# pcidev and pcipnic. If Bochs is compiled with Cirrus SVGA support +# you'll have the additional choice 'cirrus'. +# +# Example: +# i440fxsupport: enabled=1, slot1=pcivga, slot2=ne2k +#======================================================================= +#i440fxsupport: enabled=1 + +#======================================================================= +# USB1: +# This option controls the presence of the USB root hub which is a part +# of the i440FX PCI chipset. With the portX option you can connect devices +# to the hub (currently supported: 'mouse' and 'keypad'). If you connect +# the mouse to one of the ports and use the mouse option 'type=usb' you'll +# have a 3-button USB mouse. +# +# Example: +# usb1: enabled=1, port1=mouse, port2=keypad +#======================================================================= +#usb1: enabled=1 + +#======================================================================= +# CMOSIMAGE: +# This defines image file that can be loaded into the CMOS RAM at startup. +# The rtc_init parameter controls whether initialize the RTC with values stored +# in the image. By default the time0 argument given to the clock option is used. +# With 'rtc_init=image' the image is the source for the initial time. +# +# Example: +# cmosimage: file=cmos.img, rtc_init=image +#======================================================================= +#cmosimage: file=cmos.img, rtc_init=time0 + +#======================================================================= +# other stuff +#======================================================================= +#magic_break: enabled=1 +#load32bitOSImage: os=nullkernel, path=../kernel.img, iolog=../vga_io.log +#load32bitOSImage: os=linux, path=../linux.img, iolog=../vga_io.log, initrd=../initrd.img +#text_snapshot_check: enable + +#------------------------- +# PCI host device mapping +#------------------------- +#pcidev: vendor=0x1234, device=0x5678 + +#======================================================================= +# GDBSTUB: +# Enable GDB stub. See user documentation for details. +# Default value is enabled=0. +#======================================================================= +#gdbstub: enabled=0, port=1234, text_base=0, data_base=0, bss_base=0 + +#======================================================================= +# IPS: +# The IPS directive is DEPRECATED. Use the parameter IPS of the CPU +# directive instead. +#======================================================================= +#ips: 10000000 + +#======================================================================= +# for Macintosh, use the style of pathnames in the following +# examples. +# +# vgaromimage: :bios:VGABIOS-elpin-2.40 +# romimage: file=:bios:BIOS-bochs-latest, address=0xf0000 +# floppya: 1_44=[fd:], status=inserted +#======================================================================= diff --git a/tools/gdbinit.tmpl b/tools/gdbinit.tmpl new file mode 100644 index 0000000..f71681a --- /dev/null +++ b/tools/gdbinit.tmpl @@ -0,0 +1,27 @@ +set $lastcs = -1 + +define hook-stop + # There doesn't seem to be a good way to detect if we're in 16- or + # 32-bit mode, but in 32-bit mode we always run with CS == 8 in the + # kernel and CS == 35 in user space + if $cs == 8 || $cs == 35 + if $lastcs != 8 && $lastcs != 35 + set architecture i386 + end + x/i $pc + else + if $lastcs == -1 || $lastcs == 8 || $lastcs == 35 + set architecture i8086 + end + # Translate the segment:offset into a physical address + printf "[%4x:%4x] ", $cs, $eip + x/i $cs*16+$eip + end + set $lastcs = $cs +end + +echo + target remote localhost:1234\n +target remote localhost:1234 + +echo + symbol-file kernel\n +symbol-file kernel diff --git a/tools/gdbutil b/tools/gdbutil new file mode 100644 index 0000000..e0c362f --- /dev/null +++ b/tools/gdbutil @@ -0,0 +1,291 @@ +# -*- gdb-script -*- + +# Utility functions to pretty-print x86 segment/interrupt descriptors. +# To load this file, run "source gdbutil" in gdb. +# printdesc and printdescs are the main entry points. + +# IA32 2007, Volume 3A, Table 3-2 +set $STS_T16A = 0x1 +set $STS_LDT = 0x2 +set $STS_T16B = 0x3 +set $STS_CG16 = 0x4 +set $STS_TG = 0x5 +set $STS_IG16 = 0x6 +set $STS_TG16 = 0x7 +set $STS_T32A = 0x9 +set $STS_T32B = 0xB +set $STS_CG32 = 0xC +set $STS_IG32 = 0xE +set $STS_TG32 = 0xF + +define outputsts + while 1 + if $arg0 == $STS_T16A + echo STS_T16A + loop_break + end + if $arg0 == $STS_LDT + echo STS_LDT\ + loop_break + end + if $arg0 == $STS_T16B + echo STS_T16B + loop_break + end + if $arg0 == $STS_CG16 + echo STS_CG16 + loop_break + end + if $arg0 == $STS_TG + echo STS_TG\ \ + loop_break + end + if $arg0 == $STS_IG16 + echo STS_IG16 + loop_break + end + if $arg0 == $STS_TG16 + echo STS_TG16 + loop_break + end + if $arg0 == $STS_T32A + echo STS_T32A + loop_break + end + if $arg0 == $STS_T32B + echo STS_T32B + loop_break + end + if $arg0 == $STS_CG32 + echo STS_CG32 + loop_break + end + if $arg0 == $STS_IG32 + echo STS_IG32 + loop_break + end + if $arg0 == $STS_TG32 + echo STS_TG32 + loop_break + end + echo Reserved + loop_break + end +end + +# IA32 2007, Volume 3A, Table 3-1 +set $STA_X = 0x8 +set $STA_E = 0x4 +set $STA_C = 0x4 +set $STA_W = 0x2 +set $STA_R = 0x2 +set $STA_A = 0x1 + +define outputsta + if $arg0 & $STA_X + # Code segment + echo code + if $arg0 & $STA_C + echo |STA_C + end + if $arg0 & $STA_R + echo |STA_R + end + else + # Data segment + echo data + if $arg0 & $STA_E + echo |STA_E + end + if $arg0 & $STA_W + echo |STA_W + end + end + if $arg0 & $STA_A + echo |STA_A + else + printf " " + end +end + +# xv6-specific +set $SEG_KCODE = 1 +set $SEG_KDATA = 2 +set $SEG_KCPU = 3 +set $SEG_UCODE = 4 +set $SEG_UDATA = 5 +set $SEG_TSS = 6 + +define outputcs + if ($arg0 & 4) == 0 + if $arg0 >> 3 == $SEG_KCODE + printf "SEG_KCODE<<3" + end + if $arg0 >> 3 == $SEG_KDATA + printf "SEG_KDATA<<3" + end + if $arg0 >> 3 == $SEG_KCPU + printf "SEG_KCPU<<3" + end + if $arg0 >> 3 == $SEG_UCODE + printf "SEG_UCODE<<3" + end + if $arg0 >> 3 == $SEG_UDATA + printf "SEG_UDATA<<3" + end + if $arg0 >> 3 == $SEG_TSS + printf "SEG_TSS<<3" + end + if ($arg0 >> 3 < 1) + ($arg0 >> 3 > 6) + printf "GDT[%d]", $arg0 >> 3 + end + else + printf "LDT[%d]", $arg0 >> 3 + end + if ($arg0 & 3) > 0 + printf "|" + outputdpl ($arg0&3) + end +end + +define outputdpl + if $arg0 == 0 + printf "DPL_KERN" + else + if $arg0 == 3 + printf "DPL_USER" + else + printf "DPL%d", $arg0 + end + end +end + +define printdesc + if $argc != 1 + echo Usage: printdesc expr + else + _printdesc ((uint*)&($arg0))[0] ((uint*)&($arg0))[1] + printf "\n" + end +end + +document printdesc +Print an x86 segment or gate descriptor. +printdesc EXPR +EXPR must evaluate to a descriptor value. It can be of any C type. +end + +define _printdesc + _printdesc1 $arg0 $arg1 ($arg1>>15&1) ($arg1>>13&3) ($arg1>>12&1) ($arg1>>8&15) +end + +define _printdesc1 + # 2:P 3:DPL 4:S 5:Type + if $arg2 == 0 + printf "P = 0 (Not present)" + else + printf "type = " + if $arg4 == 0 + # System segment + outputsts $arg5 + printf " (0x%x) ", $arg5 + _printsysdesc $arg0 $arg1 $arg5 + else + # Code/data segment + outputsta $arg5 + printf " " + _printsegdesc $arg0 $arg1 + end + + printf " DPL = " + outputdpl $arg3 + printf " (%d)", $arg3 + end +end + +define _printsysdesc + # 2:Type + # GDB's || is buggy + if ($arg2 == $STS_TG) + (($arg2&7) == $STS_IG16) + (($arg2&7) == $STS_TG16) + # Gate descriptor + _printgate $arg2 ($arg0>>16) ($arg0&0xFFFF) ($arg1>>16) + else + # System segment descriptor + _printsegdesc $arg0 $arg1 + end +end + +define _printgate + # IA32 2007, Voume 3A, Figure 5-2 + # 0:Type 1:CS 2:Offset 15..0 3:Offset 31..16 + printf "CS = " + outputcs $arg1 + printf " (%d)", $arg1 + + if (($arg0&7) == $STS_IG16) + (($arg0&7) == $STS_TG16) + printf " Offset = " + output/a $arg3 << 16 | $arg2 + end +end + +define _printsegdesc + # IA32 20007, Volume 3A, Figure 3-8 and Figure 4-1 + _printsegdesc1 ($arg0>>16) ($arg1&0xFF) ($arg1>>24) ($arg0&0xFFFF) ($arg1>>16&15) ($arg1>>23&1) + if ($arg1>>12&1) == 1 + printf " AVL = %d", $arg1>>20&1 + if ($arg1>>11&1) == 0 + # Data segment + if ($arg1>>22&1) == 0 + printf " B = small (0) " + else + printf " B = big (1) " + end + else + # Code segment + printf " D = " + if ($arg1>>22&1) == 0 + printf "16-bit (0)" + else + printf "32-bit (1)" + end + end + end +end + +define _printsegdesc1 + # 0:Base 0..15 1:Base 16..23 2:Base 24..32 3:Limit 0..15 4:Limit 16..19 5:G + printf "base = 0x%08x", $arg0 | ($arg1<<16) | ($arg2<<24) + printf " limit = 0x" + if $arg5 == 0 + printf "%08x", $arg3 | ($arg4<<16) + else + printf "%08x", (($arg3 | ($arg4<<16)) << 12) | 0xFFF + end +end + +define printdescs + if $argc < 1 || $argc > 2 + echo Usage: printdescs expr [count] + else + if $argc == 1 + _printdescs ($arg0) (sizeof($arg0)/sizeof(($arg0)[0])) + else + _printdescs ($arg0) ($arg1) + end + end +end + +document printdescs +Print an array of x86 segment or gate descriptors. +printdescs EXPR [COUNT] +EXPR must evaluate to an array of descriptors. +end + +define _printdescs + set $i = 0 + while $i < $arg1 + printf "[%d] ", $i + printdesc $arg0[$i] + set $i = $i + 1 + end +end diff --git a/tools/mkfs.c b/tools/mkfs.c new file mode 100644 index 0000000..bb26c90 --- /dev/null +++ b/tools/mkfs.c @@ -0,0 +1,298 @@ +#include +#include +#include +#include +#include +#include + +#define stat xv6_stat // avoid clash with host struct stat +#include "../include/types.h" +#include "../include/fs.h" +#include "../include/stat.h" +#include "../include/param.h" + +#ifndef static_assert +# define static_assert(a, b) do { switch (0) case 0: case (a): ; } while (0) +#endif // static_assert + +int nblocks = 985; +int nlog = LOGSIZE; +int ninodes = 200; +int size = 1024; + +int fsfd; +struct superblock sb; +char zeroes[512]; +uint freeblock; +uint usedblocks; +uint bitblocks; +uint freeinode = 1; + +void balloc(int); +void wsect(uint, void*); +void winode(uint, struct dinode*); +void rinode(uint inum, struct dinode *ip); +void rsect(uint sec, void *buf); +uint ialloc(ushort type); +void iappend(uint inum, void *p, int n); + +// convert to intel byte order +ushort +xshort(ushort x) +{ + ushort y; + uchar *a = (uchar*)&y; + a[0] = x; + a[1] = x >> 8; + return y; +} + +uint +xint(uint x) +{ + uint y; + uchar *a = (uchar*)&y; + a[0] = x; + a[1] = x >> 8; + a[2] = x >> 16; + a[3] = x >> 24; + return y; +} + +int +main(int argc, char *argv[]) +{ + int i, cc, fd; + uint rootino, inum, off; + struct dirent de; + char buf[512]; + struct dinode din; + + + static_assert(sizeof(int) == 4, "Integers must be 4 bytes!"); + + if(argc < 2){ + fprintf(stderr, "Usage: mkfs fs.img files...\n"); + exit(1); + } + + assert((512 % sizeof(struct dinode)) == 0); + assert((512 % sizeof(struct dirent)) == 0); + + fsfd = open(argv[1], O_RDWR|O_CREAT|O_TRUNC, 0666); + if(fsfd < 0){ + perror(argv[1]); + exit(1); + } + + sb.size = xint(size); + sb.nblocks = xint(nblocks); // so whole disk is size sectors + sb.ninodes = xint(ninodes); + sb.nlog = xint(nlog); + + bitblocks = size/(512*8) + 1; + usedblocks = ninodes / IPB + 3 + bitblocks; + freeblock = usedblocks; + + printf("used %d (bit %d ninode %zu) free %u log %u total %d\n", usedblocks, + bitblocks, ninodes/IPB + 1, freeblock, nlog, nblocks+usedblocks+nlog); + + assert(nblocks + usedblocks + nlog == size); + + for(i = 0; i < nblocks + usedblocks + nlog; i++) + wsect(i, zeroes); + + memset(buf, 0, sizeof(buf)); + memmove(buf, &sb, sizeof(sb)); + wsect(1, buf); + + rootino = ialloc(T_DIR); + assert(rootino == ROOTINO); + + bzero(&de, sizeof(de)); + de.inum = xshort(rootino); + strcpy(de.name, "."); + iappend(rootino, &de, sizeof(de)); + + bzero(&de, sizeof(de)); + de.inum = xshort(rootino); + strcpy(de.name, ".."); + iappend(rootino, &de, sizeof(de)); + + for(i = 2; i < argc; i++){ + char *name = argv[i]; + + if (!strncmp(name, "fs/", 3)) + name += 3; + + assert(index(name, '/') == 0); + + if((fd = open(argv[i], 0)) < 0){ + perror(argv[i]); + exit(1); + } + + inum = ialloc(T_FILE); + + bzero(&de, sizeof(de)); + de.inum = xshort(inum); + strncpy(de.name, name, DIRSIZ); + iappend(rootino, &de, sizeof(de)); + + while((cc = read(fd, buf, sizeof(buf))) > 0) + iappend(inum, buf, cc); + + close(fd); + } + + // fix size of root inode dir + rinode(rootino, &din); + off = xint(din.size); + off = ((off/BSIZE) + 1) * BSIZE; + din.size = xint(off); + winode(rootino, &din); + + balloc(usedblocks); + + exit(0); +} + +void +wsect(uint sec, void *buf) +{ + if(lseek(fsfd, sec * 512L, 0) != sec * 512L){ + perror("lseek"); + exit(1); + } + if(write(fsfd, buf, 512) != 512){ + perror("write"); + exit(1); + } +} + +uint +i2b(uint inum) +{ + return (inum / IPB) + 2; +} + +void +winode(uint inum, struct dinode *ip) +{ + char buf[512]; + uint bn; + struct dinode *dip; + + bn = i2b(inum); + rsect(bn, buf); + dip = ((struct dinode*)buf) + (inum % IPB); + *dip = *ip; + wsect(bn, buf); +} + +void +rinode(uint inum, struct dinode *ip) +{ + char buf[512]; + uint bn; + struct dinode *dip; + + bn = i2b(inum); + rsect(bn, buf); + dip = ((struct dinode*)buf) + (inum % IPB); + *ip = *dip; +} + +void +rsect(uint sec, void *buf) +{ + if(lseek(fsfd, sec * 512L, 0) != sec * 512L){ + perror("lseek"); + exit(1); + } + if(read(fsfd, buf, 512) != 512){ + perror("read"); + exit(1); + } +} + +uint +ialloc(ushort type) +{ + uint inum = freeinode++; + struct dinode din; + + bzero(&din, sizeof(din)); + din.type = xshort(type); + din.nlink = xshort(1); + din.size = xint(0); + winode(inum, &din); + return inum; +} + +void +balloc(int used) +{ + uchar buf[512]; + int i; + + printf("balloc: first %d blocks have been allocated\n", used); + assert(used < 512*8); + bzero(buf, 512); + for(i = 0; i < used; i++){ + buf[i/8] = buf[i/8] | (0x1 << (i%8)); + } + printf("balloc: write bitmap block at sector %zu\n", ninodes/IPB + 3); + wsect(ninodes / IPB + 3, buf); +} + +#define min(a, b) ((a) < (b) ? (a) : (b)) + +void +iappend(uint inum, void *xp, int n) +{ + char *p = (char*)xp; + uint fbn, off, n1; + struct dinode din; + char buf[512]; + uint indirect[NINDIRECT]; + uint x; + + rinode(inum, &din); + + off = xint(din.size); + while(n > 0){ + fbn = off / 512; + assert(fbn < MAXFILE); + if(fbn < NDIRECT){ + if(xint(din.addrs[fbn]) == 0){ + din.addrs[fbn] = xint(freeblock++); + usedblocks++; + } + x = xint(din.addrs[fbn]); + } else { + if(xint(din.addrs[NDIRECT]) == 0){ + // printf("allocate indirect block\n"); + din.addrs[NDIRECT] = xint(freeblock++); + usedblocks++; + } + // printf("read indirect block\n"); + rsect(xint(din.addrs[NDIRECT]), (char*)indirect); + if(indirect[fbn - NDIRECT] == 0){ + indirect[fbn - NDIRECT] = xint(freeblock++); + usedblocks++; + wsect(xint(din.addrs[NDIRECT]), (char*)indirect); + } + x = xint(indirect[fbn-NDIRECT]); + } + n1 = min(n, (fbn + 1) * 512 - off); + rsect(x, buf); + bcopy(p, buf + off - (fbn * 512), n1); + wsect(x, buf); + n -= n1; + off += n1; + p += n1; + } + din.size = xint(off); + winode(inum, &din); +} diff --git a/tools/printpcs b/tools/printpcs new file mode 100644 index 0000000..81d039b --- /dev/null +++ b/tools/printpcs @@ -0,0 +1,14 @@ +#!/bin/sh + +# Decode the symbols from a panic EIP list + +# Find a working addr2line +for p in i386-jos-elf-addr2line addr2line; do + if which $p 2>&1 >/dev/null && \ + $p -h 2>&1 | grep -q '\belf32-i386\b'; then + break + fi +done + +# Enable as much pretty-printing as this addr2line can do +$p $($p -h | grep ' -[aipsf] ' | awk '{print $1}') -e kernel "$@" diff --git a/tools/sign.pl b/tools/sign.pl new file mode 100644 index 0000000..d793035 --- /dev/null +++ b/tools/sign.pl @@ -0,0 +1,19 @@ +#!/usr/bin/perl + +open(SIG, $ARGV[0]) || die "open $ARGV[0]: $!"; + +$n = sysread(SIG, $buf, 1000); + +if($n > 510){ + print STDERR "boot block too large: $n bytes (max 510)\n"; + exit 1; +} + +print STDERR "boot block is $n bytes (max 510)\n"; + +$buf .= "\0" x (510-$n); +$buf .= "\x55\xAA"; + +open(SIG, ">$ARGV[0]") || die "open >$ARGV[0]: $!"; +print SIG $buf; +close SIG; diff --git a/tools/sleep1.p b/tools/sleep1.p new file mode 100644 index 0000000..af69772 --- /dev/null +++ b/tools/sleep1.p @@ -0,0 +1,134 @@ +/* +This file defines a Promela model for xv6's +acquire, release, sleep, and wakeup, along with +a model of a simple producer/consumer queue. + +To run: + spinp sleep1.p + +(You may need to install Spin, available at http://spinroot.com/.) + +After a successful run spin prints something like: + + unreached in proctype consumer + (0 of 37 states) + unreached in proctype producer + (0 of 23 states) + +After an unsuccessful run, the spinp script prints +an execution trace that causes a deadlock. + +The safe body of producer reads: + + acquire(lk); + x = value; value = x + 1; x = 0; + wakeup(0); + release(lk); + i = i + 1; + +If this is changed to: + + x = value; value = x + 1; x = 0; + acquire(lk); + wakeup(0); + release(lk); + i = i + 1; + +then a deadlock can happen, because the non-atomic +increment of value conflicts with the non-atomic +decrement in consumer, causing value to have a bad value. +Try this. + +If it is changed to: + + acquire(lk); + x = value; value = x + 1; x = 0; + release(lk); + wakeup(0); + i = i + 1; + +then nothing bad happens: it is okay to wakeup after release +instead of before, although it seems morally wrong. +*/ + +#define ITER 4 +#define N 2 + +bit lk; +byte value; +bit sleeping[N]; + +inline acquire(x) +{ + atomic { x == 0; x = 1 } +} + +inline release(x) +{ + assert x==1; + x = 0 +} + +inline sleep(cond, lk) +{ + assert !sleeping[_pid]; + if + :: cond -> + skip + :: else -> + atomic { release(lk); sleeping[_pid] = 1 }; + sleeping[_pid] == 0; + acquire(lk) + fi +} + +inline wakeup() +{ + w = 0; + do + :: w < N -> + sleeping[w] = 0; + w = w + 1 + :: else -> + break + od +} + +active[N] proctype consumer() +{ + byte i, x; + + i = 0; + do + :: i < ITER -> + acquire(lk); + sleep(value > 0, lk); + x = value; value = x - 1; x = 0; + release(lk); + i = i + 1; + :: else -> + break + od; + i = 0; + skip +} + +active[N] proctype producer() +{ + byte i, x, w; + + i = 0; + do + :: i < ITER -> + acquire(lk); + x = value; value = x + 1; x = 0; + release(lk); + wakeup(); + i = i + 1; + :: else -> + break + od; + i = 0; + skip +} + diff --git a/tools/spinp b/tools/spinp new file mode 100644 index 0000000..db9614b --- /dev/null +++ b/tools/spinp @@ -0,0 +1,16 @@ +#!/bin/sh + +if [ $# != 1 ] || [ ! -f "$1" ]; then + echo 'usage: spinp file.p' 1>&2 + exit 1 +fi + +rm -f $1.trail +spin -a $1 || exit 1 +cc -DSAFETY -DREACH -DMEMLIM=500 -o pan pan.c +pan -i +rm pan.* pan +if [ -f $1.trail ]; then + spin -t -p $1 +fi + diff --git a/tools/vectors.pl b/tools/vectors.pl new file mode 100644 index 0000000..57b49dd --- /dev/null +++ b/tools/vectors.pl @@ -0,0 +1,47 @@ +#!/usr/bin/perl -w + +# Generate vectors.S, the trap/interrupt entry points. +# There has to be one entry point per interrupt number +# since otherwise there's no way for trap() to discover +# the interrupt number. + +print "# generated by vectors.pl - do not edit\n"; +print "# handlers\n"; +print ".globl alltraps\n"; +for(my $i = 0; $i < 256; $i++){ + print ".globl vector$i\n"; + print "vector$i:\n"; + if(!($i == 8 || ($i >= 10 && $i <= 14) || $i == 17)){ + print " pushl \$0\n"; + } + print " pushl \$$i\n"; + print " jmp alltraps\n"; +} + +print "\n# vector table\n"; +print ".data\n"; +print ".globl vectors\n"; +print "vectors:\n"; +for(my $i = 0; $i < 256; $i++){ + print " .long vector$i\n"; +} + +# sample output: +# # handlers +# .globl alltraps +# .globl vector0 +# vector0: +# pushl $0 +# pushl $0 +# jmp alltraps +# ... +# +# # vector table +# .data +# .globl vectors +# vectors: +# .long vector0 +# .long vector1 +# .long vector2 +# ... + diff --git a/tools/vectors64.pl b/tools/vectors64.pl new file mode 100644 index 0000000..d7bc818 --- /dev/null +++ b/tools/vectors64.pl @@ -0,0 +1,27 @@ +#!/usr/bin/perl -w + +# Generate vectors.S, the trap/interrupt entry points. +# There has to be one entry point per interrupt number +# since otherwise there's no way for trap() to discover +# the interrupt number. + +print "# generated by vectors.pl - do not edit\n"; +print "# handlers\n"; +print ".globl alltraps\n"; +for(my $i = 0; $i < 256; $i++){ + print ".globl vector$i\n"; + print "vector$i:\n"; + if(!($i == 8 || ($i >= 10 && $i <= 14) || $i == 17)){ + print " push \$0\n"; + } + print " push \$$i\n"; + print " jmp alltraps\n"; +} + +print "\n# vector table\n"; +print ".data\n"; +print ".globl vectors\n"; +print "vectors:\n"; +for(my $i = 0; $i < 256; $i++){ + print " .quad vector$i\n"; +} diff --git a/xv6.img b/xv6.img new file mode 100644 index 0000000000000000000000000000000000000000..cd2e00bc3b80d036b133a29f610599b61ad62eaf GIT binary patch literal 5120000 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

g36(S}M|79bnJS@4_Y0+DKCpW_2lCe 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 z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNCf|F%O1Bme*a0D}I%ZbzUKG+@Ah0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* w1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8Fm;AkSbFEdT%j literal 0 HcmV?d00001 From eda80de99c70b8955283738715f6d671e4357f05 Mon Sep 17 00:00:00 2001 From: Glam0rgan <49109723+Glam0rgan@users.noreply.github.com> Date: Fri, 13 Oct 2023 22:31:07 +0800 Subject: [PATCH 4/6] Delete Makefile --- Makefile | 91 -------------------------------------------------------- 1 file changed, 91 deletions(-) delete mode 100644 Makefile diff --git a/Makefile b/Makefile deleted file mode 100644 index d2475df..0000000 --- a/Makefile +++ /dev/null @@ -1,91 +0,0 @@ -# -----------Product Config----------- -# product name -PRODUCT_NAME = TOY_OS -BUILD_DIR = build -# -----------Disk Image Config----------- -# image file name -DISK_IMAGE = $(BUILD_DIR)/disk.img -# disk size in MB, can be specified by command line -DISK_SIZE ?= 64 -# sector size, 512 bytes by default -SECTOR_SIZE = 512 -# partition offset in sector, 2048 by default because of 4KB alignment -PART_START = 2048 -# end partition, partition size - 1 is the last partition -PART_END = $(shell echo $$((($(DISK_SIZE) * 1024 * 1024) / $(SECTOR_SIZE) - 1))) -# partition type, `0c` for FAT32 -TYPE = 0c -# mount point -MOUNT_POINT ?= /mnt/toy_os -# -----------C Compiler Config----------- -CFLAGS = -Wall -static -fno-stack-protector -m32 -I. - -.PHONY: clean mount unmount build run - -# -----------make----------- -run: build - qemu-system-x86_64 -drive file=$(DISK_IMAGE),format=raw - -build: $(BUILD_DIR)/flag_installed - -$(BUILD_DIR): - mkdir -p $@ - -# make disk image -$(DISK_IMAGE): - # create an empty disk image file filled with zeros - dd if=/dev/zero of=$@ bs=1M count=$(DISK_SIZE) - # create a MBR partition table with a FAT32 partition - echo "o\nn\np\n1\n$(PART_START)\n$(PART_END)\nt\n$(TYPE)\nw\n" | fdisk $@ - # format the partition as FAT32 - mkfs.vfat -F 32 -n "$(PRODUCT_NAME)" --offset $(PART_START) $@ - -# -----------MBR Boot Code----------- -BUILD_BOOT_DIR = $(BUILD_DIR)/boot - -$(BUILD_BOOT_DIR): $(BUILD_DIR) - mkdir -p $@ - -$(BUILD_BOOT_DIR)/mbr_boot_asm.o: boot/mbr_boot.asm $(BUILD_BOOT_DIR) - nasm $< -f elf32 -o $(BUILD_BOOT_DIR)/mbr_boot_asm.o - -$(BUILD_BOOT_DIR)/mbr_boot_c.o: boot/mbr_boot.c $(BUILD_BOOT_DIR) - gcc $(CFLAGS) -nostdinc -fno-builtin -fno-pie -fno-pic -fno-omit-frame-pointer -fno-strict-aliasing -s -c -o $(BUILD_BOOT_DIR)/mbr_boot_c.o $< - -$(BUILD_BOOT_DIR)/mbr_boot.o: $(BUILD_BOOT_DIR)/mbr_boot_asm.o $(BUILD_BOOT_DIR)/mbr_boot_c.o - # param explaination: - # -N: Do not page align data, do not make text readonly - # -e: Set entry point - # -Ttext: Set address of .text section - # -s: Strip all symbols - ld -m elf_i386 -N -e asm_main -Ttext 0x7c00 -s $(BUILD_BOOT_DIR)/mbr_boot_asm.o $(BUILD_BOOT_DIR)/mbr_boot_c.o -o $(BUILD_BOOT_DIR)/mbr_boot.o - -$(BUILD_BOOT_DIR)/mbr_boot.bin: $(BUILD_BOOT_DIR)/mbr_boot.o - # param explaination: - # -S: Strip all symbols and relocation information - # -O: Output target - # -j .text: Only copy section .text into the output - objcopy -S -O binary -j .text -j .rodata $(BUILD_BOOT_DIR)/mbr_boot.o $(BUILD_BOOT_DIR)/mbr_boot.bin - -$(BUILD_DIR)/flag_installed: $(BUILD_DIR)/boot/mbr_boot.bin $(DISK_IMAGE) - # make sure the size is less than 440 bytes - [ $(shell stat -c %s build/boot/mbr_boot.bin) -lt 440 ] - dd if=$< of=$(DISK_IMAGE) bs=440 count=1 conv=notrunc - touch $(BUILD_DIR)/flag_installed - -# -----------clean----------- -clean: - rm -rf $(BUILD_DIR) - -# -----------mount disk image----------- -mount: - sudo mkdir -p $(MOUNT_POINT) - LOOPDEV=$$(sudo kpartx -av $(DISK_IMAGE) | head -n 1 | cut -d ' ' -f 3); \ - echo "Loop device: $$LOOPDEV"; \ - sudo mount /dev/mapper/$$LOOPDEV $(MOUNT_POINT) - -# -----------unmount disk image----------- -unmount: - sudo umount $(MOUNT_POINT) - sudo kpartx -dv $(DISK_IMAGE) - sudo rm -rf $(MOUNT_POINT) \ No newline at end of file From f638468eb81fe8cbfa8f92b593aacf29e5f5c57e Mon Sep 17 00:00:00 2001 From: Glam0rgan <49109723+Glam0rgan@users.noreply.github.com> Date: Fri, 13 Oct 2023 22:31:45 +0800 Subject: [PATCH 5/6] Delete lang/c directory --- lang/c/types.h | 20 -------------------- lang/c/types32.h | 14 -------------- 2 files changed, 34 deletions(-) delete mode 100644 lang/c/types.h delete mode 100644 lang/c/types32.h diff --git a/lang/c/types.h b/lang/c/types.h deleted file mode 100644 index 0ce1d0d..0000000 --- a/lang/c/types.h +++ /dev/null @@ -1,20 +0,0 @@ -#include -#include - -typedef int8_t i8; -typedef int16_t i16; -typedef int32_t i32; -typedef int64_t i64; - -typedef uint8_t u8; -typedef uint16_t u16; -typedef uint32_t u32; -typedef uint64_t u64; - -typedef float f32; -typedef double f64; - -typedef uint8_t byte; -typedef uint16_t word; -typedef uint32_t dword; -typedef uint64_t qword; \ No newline at end of file diff --git a/lang/c/types32.h b/lang/c/types32.h deleted file mode 100644 index d22e0a0..0000000 --- a/lang/c/types32.h +++ /dev/null @@ -1,14 +0,0 @@ -typedef char i8; -typedef short i16; -typedef int i32; -typedef long long i64; - -typedef unsigned char u8; -typedef unsigned short u16; -typedef unsigned int u32; -typedef unsigned long long u64; - -typedef float f32; -typedef double f64; - -typedef u8 byte; \ No newline at end of file From f9e21440f0c93f03d7e0dce47011dae568602c75 Mon Sep 17 00:00:00 2001 From: Glam0rgan <49109723+Glam0rgan@users.noreply.github.com> Date: Fri, 13 Oct 2023 22:31:54 +0800 Subject: [PATCH 6/6] Delete boot directory --- boot/gdt.inc | 51 -------------------------------------- boot/mbr_boot.asm | 63 ----------------------------------------------- boot/mbr_boot.c | 27 -------------------- 3 files changed, 141 deletions(-) delete mode 100644 boot/gdt.inc delete mode 100644 boot/mbr_boot.asm delete mode 100644 boot/mbr_boot.c diff --git a/boot/gdt.inc b/boot/gdt.inc deleted file mode 100644 index ea4296e..0000000 --- a/boot/gdt.inc +++ /dev/null @@ -1,51 +0,0 @@ -; structure of gdt descriptor - -; @signature: descriptor base, limit, attr -; @param u32 base : Base address of the segment. -; @param u32 limit : Only low 20 bits are in use. The length of the segment - 1, because the max size is 2^20, and the max value of u20 is 2^20-1. -; @param u16 attr : Only the high 4 bits and low 8 bits are in use. -%macro descriptor 3 - dw %2 & 0xffff ; limit low 16 bits - dw %1 & 0xffff ; base low 16 bits - db (%1 >> 16) & 0xff ; base 16-23 bits - dw ( (%2 >> 8) & 0x0f00) | (%3 & 0xf0ff) ; attribute and limit high 8 bits - db (%1 >> 24) & 0xff ; base 24-31 bits -%endmacro - -; attribute - -; 0 bit: accessed -GDT_ACCESSED equ 0000_0001b ; best left clear (0), the CPU will set it when the segment is accessed. - -; 1-4 bits: type -; for data segment -GDT_TYPE_DATA_WRITABLE equ 0000_0010b ; read-only if clear (0) -GDT_TYPE_DATA_GROW_DOWN equ 0000_0100b ; Direction bit. If clear (0) the segment grows up. If set (1) the segment grows down, ie. the Offset has to be greater than the Limit, like stack. -; for code segment -GDT_TYPE_EXEC_READABLE equ 0000_0010b ; execute-only if clear (0) -GDT_TYPE_EXEC_CONFORMING equ 0000_0100b ; if set (1), code in this segment can be executed from an equal or lower privilege level; if clear (0), code in this segment can only be executed from the ring set in DPL. -; for system segment -GDT_TYPE_SYS_LDT equ 0x2 -GDT_TYPE_SYS_TSS equ 0x9 ; 32-bit TSS (Task State Segment) -GDT_TYPE_SYS_TSS_BUSY equ 0xb - -GDT_TYPE_EXECUTABLE equ 0000_1000b ; if clear (0) the descriptor defines a data segment. -GDT_TYPE_NON_SYSTEM equ 0001_0000b ; if clear (0) the descriptor defines a system segment; if set (1) the descriptor defines a data or code segment. - -; 5-6 bits: discriptor privilege level (DPL) -GDT_DPL_0 equ 0x0 << 5 -GDT_DPL_1 equ 0x1 << 5 -GDT_DPL_2 equ 0x2 << 5 -GDT_DPL_3 equ 0x3 << 5 - -; 7 bit: present -GDT_PRESENT equ 1000_0000b ; set (1) for any valid segment. - -; 13 bit: Long-mode -GDT_LONG_MODE equ 0010_0000_0000_0000b ; If set (1), the descriptor defines a 64-bit code segment and `DB` should always be clear (0). - -; 14 bit: -GDT_PROTECTED_MODE equ 0100_0000_0000_0000b ; If set (1), 32-bit segment, for stack segment use ESP rather than SP and the limit is 4GB rather than 64KB. If clear (0), 16-bit segment. - -; 15 bit: -GDT_PAGE_GRANULARITY equ 1000_0000_0000_0000b ; If set (1), the unit for the limit field is 4 KiB (just the size of a page). If clear (0), the unit is byte. \ No newline at end of file diff --git a/boot/mbr_boot.asm b/boot/mbr_boot.asm deleted file mode 100644 index 43e52b8..0000000 --- a/boot/mbr_boot.asm +++ /dev/null @@ -1,63 +0,0 @@ -%include "boot/gdt.inc" ; GDT descriptor structure -%define pos(x,y) (80*(x)+(y))*2 ; 80x25 screen position - -; In legacy boot mode, the bootloader will be load to 0x7c00, so we need `org 0x7c00` -; Now we will compile our code into a relocatable file, the offset `0x7c00` should be specified to the linker `ld` but not here. -; org 0x7c00 - -extern main ; external c main function -global boot_main ; asm entry point for the linker - -; strip most of the debug output to minimize the binary size - -[BITS 16] -boot_main: - ; init stack - mov ax, cs - mov ds, ax - mov es, ax - mov gs, ax - mov ss, ax - mov sp, 0x7c00 - - ; clear screen - mov ah, 0x00 ; new video mode - mov al, 0x03 ; 80x25 color text mode - int 0x10 ; modify video mode will clear the screen - - ; enable_A20 - cli - in al, 0x92 - or al, 0010b - out 0x92, al - - ; protected mode - lgdt [gdt_reg] - mov eax, cr0 - or eax, 0x00000001 - mov cr0, eax - jmp dword (DESC_CODE - GDT) : protected_main - -[BITS 32] -protected_main: - ; prepare segments for c codes - mov ax, DESC_DATA - GDT - mov ds, ax - mov es, ax - mov ss, ax - mov esp, 0x7c00 - mov ax, 0 - mov fs, ax - mov gs, ax - call main ; should never return - - jmp $ - -GDT: -DESC_NULL: descriptor 0, 0, 0 -DESC_CODE: descriptor 0, 0xffffffff, GDT_TYPE_EXECUTABLE | GDT_TYPE_EXEC_READABLE | GDT_TYPE_NON_SYSTEM | GDT_PROTECTED_MODE | GDT_PRESENT -DESC_DATA: descriptor 0, 0xffffffff, GDT_TYPE_DATA_WRITABLE | GDT_TYPE_NON_SYSTEM | GDT_PROTECTED_MODE | GDT_PRESENT - -gdt_len equ $ - GDT -gdt_reg dw gdt_len - 1 ; the length of gdt minus 1 - dd GDT ; the address of gdt \ No newline at end of file diff --git a/boot/mbr_boot.c b/boot/mbr_boot.c deleted file mode 100644 index 69e3921..0000000 --- a/boot/mbr_boot.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "lang/c/types32.h" - -const int SCREEN_WIDTH = 80; -#define screen_pos(x, y) (SCREEN_WIDTH * (x) + (y)) * 2 // 80x25 screen -byte* const screen = (byte*)0xb8000; -static int screen_pos_x = 0; -static int screen_pos_y = 0; - -void putcharb(char c) { - if (c != '\n') screen[screen_pos(screen_pos_x, screen_pos_y)] = c; - if (c == '\n' || ++screen_pos_y >= SCREEN_WIDTH) { - screen_pos_y = 0; - ++screen_pos_x; - } -} - -void printb(char* str) { - while (*str) { - putcharb(*str++); - } -} - -// This function will be called by `mbr_boot.asm` -int main() { - printb("Hello C World!\n"); - return 0; -} \ No newline at end of file