From 338e4baffa01e0ac4f5df5cbad42f990b8c87f17 Mon Sep 17 00:00:00 2001 From: huroy5518 Date: Mon, 26 Jun 2023 22:38:32 +0800 Subject: [PATCH] After Demo lab6, 7, 8 --- Makefile | 21 +- Makefile.old | 84 +++++ config.txt | 3 - include/cpio/cpio.h | 17 +- include/dtb/dtb.h | 2 +- include/framebuffer.h | 12 + include/fs/fat32.h | 103 ++++++ include/fs/tmpfs.h | 33 ++ include/fs/vfs.h | 123 +++++++ include/interrupt.h | 41 +++ include/mbox/mbox.h | 3 +- include/mem/mem.h | 6 +- include/mem/page.h | 5 +- include/mmu/mmu-def.h | 40 +++ include/mmu/mmu.h | 8 + include/peripherals/base.h | 2 +- include/peripherals/mini_uart.h | 14 +- include/power.h | 5 +- include/process.h | 63 ++++ include/sd.h | 12 + include/signal.h | 26 ++ include/syscall.h | 44 +++ include/test/demo.h | 2 +- include/test/demo_page.h | 1 - include/thread.h | 75 +++++ include/type.h | 6 +- include/utils.h | 2 +- include/waitqueue.h | 13 + initramfs.cpio | Bin 512 -> 207872 bytes lab5.cpio | Bin 0 -> 247296 bytes lab6.cpio | Bin 0 -> 247808 bytes lab7.cpio | Bin 0 -> 404480 bytes lab8.cpio | Bin 0 -> 405504 bytes send_kernel.py | 41 ++- src/bootloader/mini_uart.c | 2 + src/initramfs/Makefile | 28 +- src/initramfs/hello.S | 10 + src/initramfs/linker.ld | 13 +- src/initramfs/sys_test.c | 181 ++++++++++ src/initramfs/test.S | 22 ++ src/kernel/boot.S | 134 ++++++-- src/kernel/context_switch.S | 35 ++ src/kernel/cpio/cpio.c | 115 ++++++- src/kernel/event.c | 5 +- src/kernel/framebuffer.c | 157 +++++++++ src/kernel/fs/fat32.c | 570 ++++++++++++++++++++++++++++++++ src/kernel/fs/tmpfs.c | 224 +++++++++++++ src/kernel/fs/vfs.c | 308 +++++++++++++++++ src/kernel/interrupt.c | 103 ++++-- src/kernel/kernel_main.c | 360 ++++++++++++++++---- src/kernel/linker.ld | 9 +- src/kernel/lock.c | 6 +- src/kernel/mbox.c | 31 +- src/kernel/mem/mem.c | 53 ++- src/kernel/mem/page.c | 49 +-- src/kernel/mini_uart.c | 221 +++++++++++-- src/kernel/mmu.S | 68 ++++ src/kernel/mmu.c | 54 +++ src/kernel/process.c | 417 +++++++++++++++++++++++ src/kernel/sd.c | 244 ++++++++++++++ src/kernel/signal.S | 4 + src/kernel/signal.c | 133 ++++++++ src/kernel/syscall.c | 209 ++++++++++++ src/kernel/thread.c | 244 ++++++++++++++ src/kernel/utils.S | 28 +- src/kernel/utils.c | 7 + src/kernel/waitqueue.c | 56 ++++ 67 files changed, 4672 insertions(+), 235 deletions(-) create mode 100755 Makefile.old delete mode 100644 config.txt create mode 100644 include/framebuffer.h create mode 100644 include/fs/fat32.h create mode 100644 include/fs/tmpfs.h create mode 100644 include/fs/vfs.h create mode 100644 include/mmu/mmu-def.h create mode 100644 include/mmu/mmu.h create mode 100755 include/process.h create mode 100644 include/sd.h create mode 100755 include/signal.h create mode 100755 include/syscall.h create mode 100755 include/thread.h create mode 100755 include/waitqueue.h create mode 100755 lab5.cpio create mode 100644 lab6.cpio create mode 100644 lab7.cpio create mode 100644 lab8.cpio create mode 100755 src/initramfs/hello.S create mode 100755 src/initramfs/sys_test.c create mode 100755 src/initramfs/test.S create mode 100755 src/kernel/context_switch.S create mode 100644 src/kernel/framebuffer.c create mode 100644 src/kernel/fs/fat32.c create mode 100644 src/kernel/fs/tmpfs.c create mode 100644 src/kernel/fs/vfs.c create mode 100644 src/kernel/mmu.S create mode 100644 src/kernel/mmu.c create mode 100755 src/kernel/process.c create mode 100644 src/kernel/sd.c create mode 100755 src/kernel/signal.S create mode 100755 src/kernel/signal.c create mode 100755 src/kernel/syscall.c create mode 100755 src/kernel/thread.c create mode 100755 src/kernel/waitqueue.c diff --git a/Makefile b/Makefile index 4f74a1aa2..f5276750f 100644 --- a/Makefile +++ b/Makefile @@ -17,7 +17,7 @@ INITRAMFS_SRC_DIR = $(SRC_DIR)/initramfs MAKE = make -COPS = -Wall -nostdlib -nostartfiles -ffreestanding -Iinclude -mgeneral-regs-only -ggdb +COPS = -Wall -nostdlib -nostartfiles -ffreestanding -Iinclude -mgeneral-regs-only -ggdb -std=gnu11 ASMOPS = -Iinclude -ggdb -mtune=cortex-a53 @@ -37,7 +37,7 @@ DEP_FILES += $(BOOTLOADER_OBJ_FILES:%.o=%.d) .DEFAULT_GOAL=all -.PHONY: default all clean kernel bootloader debug send $(INITRAMFS_BUILD_DIR) +.PHONY: default all clean kernel bootloader debug send $(INITRAMFS_BUILD_DIR) lab5 lab6 default: all all : kernel8.img bootloader.img $(INITRAMFS_BUILD_DIR) @@ -56,7 +56,22 @@ run: kernel8.img bootloader.img $(INITRAMFS_BUILD_DIR) boot: kernel8.img bootloader.img $(INITRAMFS_BUILD_DIR) cd build/initramfs && find . | cpio -o -H newc > ../../initramfs.cpio - qemu-system-aarch64 -M raspi3b -cpu cortex-a72 -serial null -serial pty -kernel bootloader.img -display none -initrd initramfs.cpio -dtb bcm2710-rpi-3-b-plus.dtb -d int + qemu-system-aarch64 -M raspi3b -cpu cortex-a72 -serial null -serial pty -kernel bootloader.img -initrd initramfs.cpio -dtb bcm2710-rpi-3-b-plus.dtb -d int -display none + # qemu-system-aarch64 -M raspi3b -kernel bootloader.img -initrd ./initramfs.cpio -dtb bcm2710-rpi-3-b-plus.dtb -serial null -serial pty -d int + +lab5: + qemu-system-aarch64 -M raspi3b -cpu cortex-a72 -serial null -serial pty -kernel bootloader.img -display vnc=0.0.0.0:0 -initrd lab5.cpio -dtb bcm2710-rpi-3-b-plus.dtb -d int -vga std -drive if=sd,file=sfn_nctuos.img,format=raw + +lab6: + qemu-system-aarch64 -M raspi3b -cpu cortex-a72 -serial null -serial pty -kernel bootloader.img -display vnc=0.0.0.0:0 -initrd lab6.cpio -dtb bcm2710-rpi-3-b-plus.dtb -d int -vga std -drive if=sd,file=sfn_nctuos.img,format=raw + # qemu-system-aarch64 -M raspi3b -cpu cortex-a72 -serial null -serial pty -kernel bootloader.img -display gtk -initrd lab6.cpio -dtb bcm2710-rpi-3-b-plus.dtb -d int -vga std + +lab7: + qemu-system-aarch64 -M raspi3b -cpu cortex-a72 -serial null -serial pty -kernel bootloader.img -display vnc=0.0.0.0:0 -initrd lab7.cpio -dtb bcm2710-rpi-3-b-plus.dtb -d int -vga std -drive if=sd,file=sfn_nctuos.img,format=raw + + +lab8: + qemu-system-aarch64 -M raspi3b -cpu cortex-a72 -serial null -serial pty -kernel bootloader.img -display vnc=0.0.0.0:0 -initrd lab8.cpio -dtb bcm2710-rpi-3-b-plus.dtb -d int -vga std -drive if=sd,file=sfn_nctuos.img,format=raw copy: make && sudo ./copy_kernel.sh ./bootloader.img && sudo ./copy_ramdisk.sh build/initramfs diff --git a/Makefile.old b/Makefile.old new file mode 100755 index 000000000..94f55085e --- /dev/null +++ b/Makefile.old @@ -0,0 +1,84 @@ +ARMGNU ?= aarch64-linux-gnu + +INITRAMFS_BUILD_DIR = $(BUILD_DIR)/initramfs +INITRAMFS_SRC_DIR = $(SRC_DIR)/initramfs + +MAKE = make + +COPS = -Wall -nostdlib -nostartfiles -ffreestanding -Iinclude -mgeneral-regs-only -ggdb +ASMOPS = -Iinclude -ggdb -mtune=cortex-a53 + +SRC_DIR = src +BUILD_DIR = build +KERNEL_BUILD_DIR = $(BUILD_DIR)/kernel +KERNEL_SRC_DIR = $(SRC_DIR)/kernel + +BOOTLOADER_BUILD_DIR = $(BUILD_DIR)/bootloader +BOOTLOADER_SRC_DIR = $(SRC_DIR)/bootloader + + +.PHONY: all clean kernel bootloader debug send $(INITRAMFS_BUILD_DIR) +all : kernel8.img bootloader.img $(INITRAMFS_BUILD_DIR) + +kernel: kernel8.img + +bootloader: bootloader.img + +clean : + rm -rf $(KERNEL_BUILD_DIR) $(BOOTLOADER_BUILD_DIR) $(BUILD_DIR) $(INITRAMFS_BUILD_DIR) *.img + +# run : +# make && qemu-system-aarch64 -M raspi3b -cpu cortex-a72 -dtb bcm2710-rpi-3-b-plus.dtb -m 1G -smp 4 -serial null -serial stdio -kernel kernel8.img -display none +run: kernel8.img bootloader.img $(INITRAMFS_BUILD_DIR) + qemu-system-aarch64 -M raspi3b -serial null -serial stdio -kernel kernel8.img -display none + +boot: kernel8.img bootloader.img $(INITRAMFS_BUILD_DIR) + cd build/initramfs && find . | cpio -o -H newc > ../../initramfs.cpio + qemu-system-aarch64 -M raspi3b -cpu cortex-a72 -serial null -serial pty -kernel bootloader.img -display none -initrd initramfs.cpio -dtb bcm2710-rpi-3-b-plus.dtb -d int + +copy: + make && sudo ./copy_kernel.sh ./bootloader.img && sudo ./copy_ramdisk.sh build/initramfs + +send: + make kernel && sudo python3 send_kernel.py $(SER_DEV) + +$(KERNEL_BUILD_DIR)/%_s.o: $(KERNEL_SRC_DIR)/%.S + $(ARMGNU)-gcc $(ASMOPS) -MMD -c -o $@ $< + +$(BOOTLOADER_BUILD_DIR)/%_s.o: $(BOOTLOADER_SRC_DIR)/%.S + $(ARMGNU)-gcc $(ASMOPS) -MMD -c -o $@ $< + +$(KERNEL_BUILD_DIR)/%_c.o: $(KERNEL_SRC_DIR)/%.c + $(ARMGNU)-gcc $(COPS) -MMD -c -o $@ $< + +$(BOOTLOADER_BUILD_DIR)/%_c.o: $(BOOTLOADER_SRC_DIR)/%.c + $(ARMGNU)-gcc $(COPS) -MMD -c -o $@ $< + +KERNEL_C_FILES = $(wildcard $(KERNEL_SRC_DIR)/*.c) +KERNEL_ASM_FILES = $(wildcard $(KERNEL_SRC_DIR)/*.S) +KERNEL_OBJ_FILES = $(KERNEL_C_FILES:$(KERNEL_SRC_DIR)/%.c=$(KERNEL_BUILD_DIR)/%_c.o) +KERNEL_OBJ_FILES += $(KERNEL_ASM_FILES:$(KERNEL_SRC_DIR)/%.S=$(KERNEL_BUILD_DIR)/%_s.o) +BOOTLOADER_C_FILES += $(wildcard $(BOOTLOADER_SRC_DIR)/*.c) +BOOTLOADER_ASM_FILES += $(wildcard $(BOOTLOADER_SRC_DIR)/*.S) +BOOTLOADER_OBJ_FILES += $(BOOTLOADER_C_FILES:$(BOOTLOADER_SRC_DIR)/%.c=$(BOOTLOADER_BUILD_DIR)/%_c.o) +BOOTLOADER_OBJ_FILES += $(BOOTLOADER_ASM_FILES:$(BOOTLOADER_SRC_DIR)/%.S=$(BOOTLOADER_BUILD_DIR)/%_s.o) + +DEP_FILES = $(KERNEL_OBJ_FILES:%.o=%.d) +DEP_FILES += $(BOOTLOADER_OBJ_FILES:%.o=%.d) +-include $(DEP_FILES) + +kernel8.img: $(KERNEL_SRC_DIR)/linker.ld $(KERNEL_OBJ_FILES) + mkdir -p $(KERNEL_BUILD_DIR) + $(ARMGNU)-ld -T $(KERNEL_SRC_DIR)/linker.ld -o $(KERNEL_BUILD_DIR)/kernel8.elf $(KERNEL_OBJ_FILES) + $(ARMGNU)-objcopy $(KERNEL_BUILD_DIR)/kernel8.elf -O binary kernel8.img + +bootloader.img: $(BOOTLOADER_SRC_DIR)/linker.ld $(BOOTLOADER_OBJ_FILES) + $(ARMGNU)-ld -T $(BOOTLOADER_SRC_DIR)/linker.ld -o $(BOOTLOADER_BUILD_DIR)/bootloader.elf $(BOOTLOADER_OBJ_FILES) + $(ARMGNU)-objcopy $(BOOTLOADER_BUILD_DIR)/bootloader.elf -O binary bootloader.img + +$(INITRAMFS_BUILD_DIR): + $(MAKE) -C $(INITRAMFS_SRC_DIR) + +$(shell mkdir -p $(KERNEL_BUILD_DIR)) +$(shell mkdir -p $(BOOTLOADER_BUILD_DIR)) +$(shell mkdir -p $(INITRAMFS_BUILD_DIR)) diff --git a/config.txt b/config.txt deleted file mode 100644 index 933de3548..000000000 --- a/config.txt +++ /dev/null @@ -1,3 +0,0 @@ -kernel=bootloader.img -arm_64bit=1 -initramfs initramfs.cpio 0x20000000 \ No newline at end of file diff --git a/include/cpio/cpio.h b/include/cpio/cpio.h index 520c981d7..485b9926a 100644 --- a/include/cpio/cpio.h +++ b/include/cpio/cpio.h @@ -1,9 +1,17 @@ -#include "type.h" - #ifndef __CPIO_H - #define __CPIO_H +#include "type.h" +#include "fs/vfs.h" + +#define C_FMASK 0170000 +#define C_SOCK 0140000 // File type value for sockets. +#define C_SYMBOL 0120000 // File type value for symbolic links. +#define C_REG 0100000 // File type value for regular files. +#define C_BLKDEV 0060000 // File type value for block special devices. +#define C_DIR 0040000 // File type value for directories. +#define C_CHDEV 0020000 // File type value for character special devices. +#define C_FIFO 0010000 // File type value for named pipes or FIFOs. // char *_cpio_buf = (char *)INITRAMFS_ADDR; @@ -29,5 +37,8 @@ void list_files(); unsigned int cat_file(const char *file); void set_initramfs_addr(uint32_t addr); unsigned int load_program(const char *file); +uint8_t get_file(const char *filename, char **content, unsigned int *c_filesize); +void mount_initramfs(); +int init_cpio_fs(struct filesystem *fs); #endif \ No newline at end of file diff --git a/include/dtb/dtb.h b/include/dtb/dtb.h index a46a06645..841a398cf 100644 --- a/include/dtb/dtb.h +++ b/include/dtb/dtb.h @@ -1,7 +1,7 @@ -#include "type.h" #ifndef __DTB_H #define __DTB_H +#include "type.h" struct fdt_header { uint32_t magic; uint32_t totalsize; diff --git a/include/framebuffer.h b/include/framebuffer.h new file mode 100644 index 000000000..82e5c7e72 --- /dev/null +++ b/include/framebuffer.h @@ -0,0 +1,12 @@ +#ifndef __FRAMEBUFFER_H +#define __FRAMEBUFFER_H + +int init_framebuffer(struct filesystem* fs); +int framebuffer_setup_mount(struct filesystem* fs, struct mount *mnt); +int framebuffer_close(struct file *f); +int framebuffer_lseek64(struct file *f, int offset, int whence); +int framebuffer_open(struct vnode *file_node, struct file **target); +int framebuffer_write(struct file *f, void *buf, long len); +int framebuffer_ioctl(struct file *f, unsigned long request, void *buf); +void setup_dev_framebuffer(); +#endif \ No newline at end of file diff --git a/include/fs/fat32.h b/include/fs/fat32.h new file mode 100644 index 000000000..29ad39938 --- /dev/null +++ b/include/fs/fat32.h @@ -0,0 +1,103 @@ +#ifndef __FAT32_H +#define __FAT32_H +#include "sd.h" +#include "type.h" +#include "fs/vfs.h" +#define ATTR_READ_ONLY 0x01 +#define ATTR_HIDDEN 0x02 +#define ATTR_SYSTEM 0x04 +#define ATTR_VOLUME_ID 0x08 +#define ATTR_DIRECTORY 0x10 +#define ATTR_ARCHIVE 0x20 +#define ATTR_LONG_NAME 0xf /* should be examined first */ + +#define END_OF_CLUSTER 0x0ffffff8 + +#define FAT_DIR_CACHE_NUM 16 + +struct fat32_file_cache { + char name[16]; + uint32_t filesize; + uint32_t *FAT; + uint32_t FAT_cnt; + // unsigned int root_index; + uint32_t dir_ent_clus_idx; + uint32_t dir_idx; + void *tmpdata; + uint32_t data_cluster_index; + uint32_t maxsize; + uint8_t dirty; + uint8_t cached; + uint8_t opening; +}; + +struct fat32_dir_cache { + char dir_name[16]; + uint32_t *FAT; + uint32_t dir_clus_idx; + uint32_t FAT_cnt; +}; + +struct partition_entry { + uint8_t state; + uint8_t beg_head; + uint16_t beg_cly_sec; + uint8_t type; + uint8_t end_head; + uint16_t end_cly_sec; + uint32_t num_between; + uint32_t num_sec; +}__attribute__((__packed__)); + +struct fat_boot_sector { + uint8_t jmpcode[3]; + uint8_t oemname[8]; + uint16_t n_bytes_per_sec; + uint8_t n_sec_per_clus; + uint16_t n_reserve_sec; + uint8_t n_copy; + uint16_t n_root_dir_ent; + uint16_t tot_sec_not_used; + uint8_t media_desc; + uint16_t n_sec_per_fat_not_used; + uint16_t n_sec_per_track; + uint16_t n_head; + uint32_t n_hidden_sec; + uint32_t tot_sec; + uint32_t n_sec_per_fat; + uint16_t mirror_flags; + uint16_t fs_version; + uint32_t first_cluster_of_root; + uint16_t fs_info_reserve; + uint16_t backup_sec; + uint8_t reserve[12]; + uint8_t driver_num; + uint8_t cur_head; + uint8_t extend_sig; + uint32_t serial_num; + uint8_t label[11]; + uint8_t fs_type[8]; +}__attribute__((__packed__)); + +struct fat32_dir_entry { + uint8_t filename[8]; + uint8_t ext[3]; + uint8_t attr; + uint8_t reserve[8]; + uint16_t beg_clus_h; + uint16_t mod_time; + uint16_t mod_date; + uint16_t beg_clus_l; + uint32_t file_size; +}__attribute__((__packed__)); +int fat32_init(struct filesystem *fs); +int fat32_setup_mount(struct filesystem *fs, struct mount *mnt); +int fat32_lookup(struct vnode* dir_node, struct vnode **target, const char *component); +int fat32_open(struct vnode* node, struct file **target); +int fat32_read(struct file *f, void *buf, long len); +int fat32_write(struct file *f, void *buf, long len); +int fat32_create(struct vnode *dir_node, struct vnode **target, const char *comp); +void fat32_sync(); +int fat32_close(struct file *f); +void setup_boot(); +#endif \ No newline at end of file diff --git a/include/fs/tmpfs.h b/include/fs/tmpfs.h new file mode 100644 index 000000000..c6d99346c --- /dev/null +++ b/include/fs/tmpfs.h @@ -0,0 +1,33 @@ +#ifndef __TMPFS_H +#define __TMPFS_H + +#include "vfs.h" + +#define TMPFS_MAX_CONTENT_SIZE 4096 + +struct tmpfs_vinfo { + char name[16]; + int namesize; + int filesize; + // make this pointer + // we may store the absolute address from initramfs + char *content; +}; +int mount_tmpfs(struct filesystem *fs, struct mount *mnt); + +int tmpfs_lookup(struct vnode* dir_node, struct vnode** target, const char * componenet_name); + +int tmpfs_create(struct vnode* dir_node, struct vnode** target, const char *component_name); + +int tmpfs_mkdir(struct vnode* dir_node, struct vnode** target, const char *componenet_name); +int tmpfs_write(struct file* file, const void *buf, size_t len); +int tmpfs_read(struct file* file, const void *buf, size_t len); +int tmpfs_open(struct vnode* file_node, struct file** target); +int tmpfs_close(struct file* file); +long tmpfs_lseek64(struct file* file, long offset, int whence); +void tmpfs_print_name(struct vnode* node); +void init_fs(); +struct vnode* new_tmpfs_node(const char *name, struct vnode *dir_node); +int init_tmpfs(struct filesystem *fs); +int tmpfs_stat(struct file *f, struct fstat *stat); +#endif \ No newline at end of file diff --git a/include/fs/vfs.h b/include/fs/vfs.h new file mode 100644 index 000000000..3276c18ee --- /dev/null +++ b/include/fs/vfs.h @@ -0,0 +1,123 @@ +#ifndef __VFS_H +#define __VFS_H + +#define O_CREAT 000000100 +#define O_READ 000000010 +#define O_WRITE 000000001 + +#define VFS_DIR 0 +#define VFS_FILE 1 + +# define SEEK_SET 0 +#define VFS_NOT_FOUND -1 +#define VFS_NOT_DIR -2 +#define VFS_MOUNTED -3 +#define VFS_CAN_CREATE -4 +#define VFS_EXIST -5 +#define VFS_NOT_SUPPORT -6 +#define VFS_CANNOT_OPEN_DIR -7 +#define HANDLE_NOT_USED -1 + +#include "ds/list.h" +typedef unsigned long size_t; +typedef void (*apply_dir_func)(struct vnode*); + +struct vnode { + // if mount is not NULL + // that means the vnode is being mounted + // we can use and must use the mount->root as new vnode for operations + struct mount* mount; + struct vnode* parent; + struct vnode_operations* v_ops; + struct file_operations* f_ops; + // list for store child vnode + // should only be used if vnode is for directory + struct ds_list_head ch_list; + // list for being link to be as child + struct ds_list_head v_head; + int flag; + void* internal; +}; + +// file handle +struct file { + struct vnode* vnode; + size_t f_pos; // RW position of this file handle + struct file_operations* f_ops; + int flags; +}; + +struct fstat { + long filesize; + long namesize; +}; + +struct mount { + struct vnode* root; + struct vnode* mountpoint; + struct filesystem* fs; +}; + +struct filesystem { + const char* name; + struct vnode *root; + int (*init_fs)(struct filesystem *fs); + int (*setup_mount)(struct filesystem* fs, struct mount* mount); + struct ds_list_head fs_head; +}; + +struct file_operations { + int (*write)(struct file* file, const void* buf, size_t len); + int (*read)(struct file* file, void* buf, size_t len); + int (*open)(struct vnode* file_node, struct file** target); + int (*close)(struct file* file); + int (*stat)(struct file *file, struct fstat *stat); + long (*lseek64)(struct file* file, long offset, int whence); + int (*ioctl)(struct file *file, unsigned long request, void *buf); +}; + +struct vnode_operations { + int (*lookup)(struct vnode* dir_node, struct vnode** target, + const char* component_name); + int (*create)(struct vnode* dir_node, struct vnode** target, + const char* component_name); + int (*mkdir)(struct vnode* dir_node, struct vnode** target, + const char* component_name); +}; + + +// register the file system to the kernel. +// you can also initialize memory pool of the file system here. +int register_filesystem(struct filesystem* fs); + +// 1. Lookup pathname +// 2. Create a new file handle for this vnode if found. +// 3. Create a new file if O_CREAT is specified in flags and vnode not found +// lookup error code shows if file exist or not or other error occurs +// 4. Return error code if fails +int vfs_open(const char* pathname, int flags, struct file** target); + +// 1. release the file handle +// 2. Return error code if fails +int vfs_close(struct file* file); + +// 1. write len byte from buf to the opened file. +// 2. return written size or error code if an error occurs. +int vfs_write(struct file* file, const void* buf, size_t len); + +// 1. read min(len, readable size) byte to buf from the opened file. +// 2. block if nothing to read for FIFO type +// 2. return read size or error code if an error occurs. +int vfs_read(struct file* file, void* buf, size_t len); +int vfs_mkdir(const char* pathname); +int vfs_mount(const char* target, const char* filesystem); +int vfs_lookup(const char* pathname, struct vnode** target); + +struct filesystem *find_fs_by_name(const char *name); +void vfs_apply_dir(struct vnode* dir_node, apply_dir_func func); +int vfs_create(const char *pathname, int flags, struct vnode** target); +int vfs_stat(struct file *f, struct fstat *stat); +int vfs_lseek64(struct file *f, long offset, int whence); +int vops_not_support(); +int fops_not_support(); +#endif \ No newline at end of file diff --git a/include/interrupt.h b/include/interrupt.h index 0eafdb61c..ea8578c41 100644 --- a/include/interrupt.h +++ b/include/interrupt.h @@ -12,6 +12,44 @@ #define DISABLE_IRQ1 (PBASE+0x0000B21C) #define DISABLE_IRQ2 (PBASE+0x0000B220) +struct Trapframe_t{ + uint64_t x0; + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t elr_el1; + uint64_t sp; + uint64_t spsr_el1; + uint64_t esr_el1; +}; + void exception_entry(); void enable_interrupt(); void disable_interrupt(); @@ -20,5 +58,8 @@ void irqhandler_dec(); int irqhandler_cnt_get(); uint64_t interrupt_disable_save(); void interrupt_enable_restore(uint64_t flag); +void lower_irq_handler(struct Trapframe_t *frame); +void spx_irq_handler(struct Trapframe_t *frame, uint64_t esr); +void svc_handler(struct Trapframe_t *frame); extern struct k_event_queue event_queue; #endif \ No newline at end of file diff --git a/include/mbox/mbox.h b/include/mbox/mbox.h index db176fb34..0b9059a7a 100644 --- a/include/mbox/mbox.h +++ b/include/mbox/mbox.h @@ -4,7 +4,7 @@ // #define MBOX_GET_FIRMWARE_REVISION (0x00000001) -extern volatile unsigned int mbox_buf[16]; +extern volatile unsigned int mbox_buf[256]; #define MBOX_CH_PROPERTY_TAG (8) @@ -31,4 +31,5 @@ extern volatile unsigned int mbox_buf[16]; #define MAIL_WRITE (MAIL_BASE + 0x20) int mbox_call_func(unsigned char prop_tag); +int mbox_call(unsigned char prop_tag, unsigned int *buf); #endif diff --git a/include/mem/mem.h b/include/mem/mem.h index 842bbf16f..0b24cba92 100644 --- a/include/mem/mem.h +++ b/include/mem/mem.h @@ -1,14 +1,16 @@ - #ifndef __MEM_H #define __MEM_H #include "type.h" -#define NULL (0) +#ifndef NULL + #define NULL (0) +#endif void *simple_malloc(uint32_t size); void simple_free(void *ptr); void smem_init(); void *kmalloc(uint32_t size); +void *cmalloc(uint32_t size); void kfree(void *ptr); void set_init_mem_region(char *name, char *prop_name, char *data); diff --git a/include/mem/page.h b/include/mem/page.h index a1fdb0217..da2d63737 100644 --- a/include/mem/page.h +++ b/include/mem/page.h @@ -9,7 +9,7 @@ #define PAGE_SIZE_ORDER (12) #define PAGE_SIZE (1 << PAGE_SIZE_ORDER) -#define PAGE_MAX_ORDER (10) +#define PAGE_MAX_ORDER (20) #define PAGE_CONTAINED (255) #define PAGE_ALLOCATED (254) @@ -19,8 +19,9 @@ struct frame_entry { uint32_t idx; uint8_t order; int8_t flag; + uint8_t used_cnt; + uint8_t dyn_ord; uint32_t dyn_count; - uint64_t dyn_ord; struct mem_region *mem_region; struct ds_list_head head; struct ds_list_head chunk_head; diff --git a/include/mmu/mmu-def.h b/include/mmu/mmu-def.h new file mode 100644 index 000000000..9fb1bf4b7 --- /dev/null +++ b/include/mmu/mmu-def.h @@ -0,0 +1,40 @@ +#ifndef __MMU_DEF_H +#define __MMU_DEF_H +// #include "type.h" + +#define TCR_CONFIG_REGION_48bit (((64 - 48) << 0) | ((64 - 48) << 16)) +#define TCR_CONFIG_4KB ((0b00 << 14) | (0b10 << 30)) +#define TCR_CONFIG_DEFAULT (TCR_CONFIG_REGION_48bit | TCR_CONFIG_4KB) +#define MAIR_DEVICE_nGnRnE 0b00000000 +#define MAIR_NORMAL_NOCACHE 0b01000100 +#define MAIR_IDX_DEVICE_nGnRnE 0 +#define MAIR_IDX_NORMAL_NOCACHE 1 +#define PD_TABLE 0b11 +#define PD_BLOCK 0b01 +#define PD_PAGE 0b11 +#define PD_UNX (1 << 54) +#define PD_PNX (1 << 53) +#define PD_USERACCESS (1 << 6) +#define PD_ACCESS (1 << 10) +#define BOOT_PGD_ATTR PD_TABLE +#define BOOT_PUD_ATTR_DEVICE (PD_ACCESS | (MAIR_IDX_DEVICE_nGnRnE << 2) | PD_BLOCK) +#define BOOT_PUD_ATTR_NORMAL (PD_ACCESS | (MAIR_IDX_NORMAL_NOCACHE << 2) | PD_BLOCK) +#define BOOT_PUD_TABLE PD_TABLE +#define BOOT_PUD_ATTR BOOT_PUD_ATTR_DEVICE +#define BOOT_PMD_ATTR_NORMAL (PD_ACCESS | (MAIR_IDX_NORMAL_NOCACHE << 2) | PD_BLOCK) +#define BOOT_PMD_ATTR_DEVICE (PD_ACCESS | (MAIR_IDX_DEVICE_nGnRnE << 2) | PD_BLOCK) +#define PROC_PTE_ATTR_NORMAL (PD_ACCESS | (MAIR_IDX_NORMAL_NOCACHE << 2) | PD_PAGE) +#define PROC_PTE_ATTR_DEVICE (PD_ACCESS | (MAIR_IDX_DEVICE_nGnRnE << 2) | PD_PAGE) + +#define kernel_va2pa(x) ((unsigned long long)(x) & (~(0xffff000000000000ULL))) +#define kernel_pa2va(x) ((unsigned long long)(x) | (0xffff000000000000ULL)) +// #define user_va2pa(x) ((unsigned long long)(x) & (0xffffffffULL)) +// #define user_pa2va(x) ((unsigned long long)(x) | (0x0000ffff00000000ULL)) + +#define PROT_READ (1) +#define PROT_WRITE (2) +#define PROT_EXEC (4) + +#define KERNEL_SPACE_OFFSET 0xffff000000000000 + +#endif \ No newline at end of file diff --git a/include/mmu/mmu.h b/include/mmu/mmu.h new file mode 100644 index 000000000..8d01c646b --- /dev/null +++ b/include/mmu/mmu.h @@ -0,0 +1,8 @@ + +#ifndef __MMU_H +#define __MMU_H +#include "mmu/mmu-def.h" +#include "type.h" + +uint64_t mappages(void *pgd, uint64_t va, uint64_t size, uint64_t pa); +#endif \ No newline at end of file diff --git a/include/peripherals/base.h b/include/peripherals/base.h index ae88e7840..8ad945bcd 100644 --- a/include/peripherals/base.h +++ b/include/peripherals/base.h @@ -1,6 +1,6 @@ #ifndef _P_BASE_H #define _P_BASE_H -#define PBASE 0x3F000000 +#define PBASE 0xffff00003F000000 #endif \ No newline at end of file diff --git a/include/peripherals/mini_uart.h b/include/peripherals/mini_uart.h index b38105bf5..59f89eb32 100644 --- a/include/peripherals/mini_uart.h +++ b/include/peripherals/mini_uart.h @@ -2,6 +2,8 @@ #define _P_MINI_UART_H #include "peripherals/base.h" +#include "type.h" +#include "fs/vfs.h" #define AUX_IQR (PBASE + 0x00215000) #define AUX_ENABLES (PBASE + 0x00215004) #define AUX_MU_IO_REG (PBASE + 0x00215040) @@ -15,7 +17,7 @@ #define AUX_MU_CNTL_REG (PBASE + 0x00215060) #define AUX_MU_STAT_REG (PBASE + 0x00215064) #define AUX_MU_BAUD_REG (PBASE + 0x00215068) -#define UART_QUEUE_SIZE (1024) +#define UART_QUEUE_SIZE (40) #define UART_ASYNC 0 #define UART_DEFAULT 1 @@ -26,7 +28,7 @@ void uart_send(char c); void uart_send_string(const char *c); void uart_send_u32(unsigned int u32); void uart_send_u64(unsigned long u64); -void uart_send_n(const char *c, unsigned long long n); +uint64_t uart_send_n(const char *c, unsigned long long n); void uart_send_dec(unsigned long dec); void uart_int_trans_handler(); void uart_int_recv_handler(); @@ -34,6 +36,7 @@ void enable_aux_interrupt(); void disable_aux_interrupt(); char async_uart_recv(void); void async_uart_send(char c); +uint64_t async_uart_rx_buf(char buf[], uint64_t sz); void async_uart_send_seting(const char *buf); void uart_switch_func(unsigned int func); struct Uart_MSG_Queue { @@ -43,6 +46,13 @@ struct Uart_MSG_Queue { char buf[UART_QUEUE_SIZE]; }; + +int uart_file_write(struct file *f, const void *buf, long len); + +int uart_file_read(struct file *f, const void *buf, long len) ; + +int uart_file_open(struct vnode *f, struct file **target); +int uart_file_close(struct file *f); // static struct Uart_MSG_Queue txbuf; // static struct Uart_MSG_Queue rxbuf; #endif \ No newline at end of file diff --git a/include/power.h b/include/power.h index 5242ab284..d2387c24b 100644 --- a/include/power.h +++ b/include/power.h @@ -1,5 +1,8 @@ +#ifndef __POWER_H +#define __POWER_H #define PM_PASSWORD 0x5a000000 #define PM_RSTC 0x3F10001c #define PM_WDOG 0x3F100024 -void reset(int tick); \ No newline at end of file +void reset(int tick); +#endif \ No newline at end of file diff --git a/include/process.h b/include/process.h new file mode 100755 index 000000000..2d73228a3 --- /dev/null +++ b/include/process.h @@ -0,0 +1,63 @@ +#ifndef __PROCESS_H +#define __PROCESS_H + +#include "signal.h" +#include "type.h" +#include "ds/list.h" +#include "thread.h" +#include "interrupt.h" +#include "mmu/mmu.h" +#include "fs/vfs.h" + +#define PID_MAX 2048 +#define P_FD_MAX 20 +typedef enum PStatus_ { + P_INIT=0, + P_RUNNING, + P_WAIT, + P_EXIT, + P_ZOMBIE +}PStatus; + +// struct ProcMemReg_t{ +// void *addr; +// uint64_t sz; +// // struct ds_list_head reg_head; +// }; +struct Process_t { + // uint64_t pid; + // PStatus status; + // char *filename; + // struct ds_list_head pq_head; + // struct ds_list_head mem_reg_list; + // pde_t* pgdir; // not used in this lab + PStatus status; + uint32_t pid; + uint32_t exit_code; + struct Process_t *parent; + struct ds_list_head th_list; + struct ds_list_head pl_head; + // struct File_t *ofile[] // not used in this lab + // struct inode *cwd; // not used in this lab + uint8_t signal[10 + 1]; + uint8_t handling_signal; + struct ds_list_head sig_list; + void *share_section; + uint64_t share_section_sz; + uint64_t ttbr0_el1; + char name[16]; + struct vnode* cur_vnode; + struct mount *mnt; + struct file *files[P_FD_MAX]; +}; +struct Process_t *process_get_current(); +struct Process_t* process_load(const char *filename); +uint64_t process_fork(struct Trapframe_t *frame); +void process_control_init(); +uint64_t process_exec(const char* name, char *const argv[], uint8_t kernel); +struct Thread_t* process_thread_create(void * func, void *arg, struct Process_t* proc, uint8_t kernel); +struct Process_t *create_process_instance(); +void process_free(struct Process_t *proc); +struct Process_t *get_process_from_pid(uint32_t pid); +void run_user_thread(); +#endif \ No newline at end of file diff --git a/include/sd.h b/include/sd.h new file mode 100644 index 000000000..6fa4e836c --- /dev/null +++ b/include/sd.h @@ -0,0 +1,12 @@ +#ifndef __SD_H +#define __SD_H + +#include "type.h" + +#define SECTOR_SIZE 512 + +void sd_init(); +void writeblock(int block_idx, void* buf); +void readblock(int block_idx, void* buf); + +#endif \ No newline at end of file diff --git a/include/signal.h b/include/signal.h new file mode 100755 index 000000000..e237014ee --- /dev/null +++ b/include/signal.h @@ -0,0 +1,26 @@ +#ifndef __SIGNAL_H +#define __SIGNAL_H + +#include "ds/list.h" +#include "thread.h" + +#define SIGNUMS 10 + +typedef void (*signal_handler)(); + +struct Signal_t { + uint8_t sig_num; + signal_handler handler; + void *sig_return; + struct Thread_t *th; + struct ds_list_head sig_head; +}; + +void signal_register(uint8_t signum, signal_handler handler); +void signal_kill(uint32_t pid, uint8_t signum); +void signal_sigreturn(); +void signal_handler_exec(uint8_t signum); +void signal_check(); + + +#endif \ No newline at end of file diff --git a/include/syscall.h b/include/syscall.h new file mode 100755 index 000000000..5adfb6db2 --- /dev/null +++ b/include/syscall.h @@ -0,0 +1,44 @@ +#ifndef __SYSCALL_H +#define __SYSCALL_H + +#include "type.h" + +# define SEEK_SET 0 + + +int sys_get_pid(); +uint64_t sys_uartread(char buf[], uint64_t size); +uint64_t sys_uartwrite(const char buf[], uint64_t size); +int sys_exec(const char* name, char *const argv[]); +int sys_fork(); +void sys_exit(int status); +int sys_mbox_call(unsigned char ch, unsigned int *mbox); +void sys_kill(int pid); +void syscall_handler(struct Trapframe_t *frame); +int sys_open(const char *pathname, int flags); + +// syscall number : 12 +int sys_close(int fd); + +// syscall number : 13 +// remember to return read size or error code +long sys_write(int fd, const void *buf, unsigned long count); + +// syscall number : 14 +// remember to return read size or error code +long sys_read(int fd, void *buf, unsigned long count); + +// syscall number : 15 +// you can ignore mode, since there is no access control +int sys_mkdir(const char *pathname, unsigned mode); + +// syscall number : 16 +// you can ignore arguments other than target (where to mount) and filesystem (fs name) +int sys_mount(const char *src, const char *target, const char *filesystem, unsigned long flags, const void *data); + +// syscall number : 17 +int sys_chdir(const char *path); +long sys_lseek64(int fd, long offset, int whence); +int sys_ioctl(int fd, unsigned long request, void *buf); + +#endif \ No newline at end of file diff --git a/include/test/demo.h b/include/test/demo.h index 8782e9374..47360de9f 100644 --- a/include/test/demo.h +++ b/include/test/demo.h @@ -1,6 +1,6 @@ -#include "type.h" #ifndef __DEMO_H #define __DEMO_H +#include "type.h" #include "test/demo_page.h" #include "test/test_simple_alloc.h" #include "test/test_kmalloc.h" diff --git a/include/test/demo_page.h b/include/test/demo_page.h index 8d386876b..2c49ba110 100644 --- a/include/test/demo_page.h +++ b/include/test/demo_page.h @@ -1,6 +1,5 @@ #ifndef __DEMO_PAGE_H #define __DEMO_PAGE_H #include "random.h" -#define MEM_DEMO void demo_page(); #endif \ No newline at end of file diff --git a/include/thread.h b/include/thread.h new file mode 100755 index 000000000..b41d10f20 --- /dev/null +++ b/include/thread.h @@ -0,0 +1,75 @@ +#ifndef __THREAD_H +#define __THREAD_H +#include "process.h" +#include "waitqueue.h" + +#define DEFAULT_STACK_SZ ((1 << 14)) +typedef void (*thread_func)(void*); +typedef enum THStatus_{ + TH_IN_RUNNING=0, + TH_RUNNING, + TH_WAIT, + TH_EXIT, + TH_ZOMBIE +} THStatus; +struct RegState_t { + uint64_t x0; + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t fp; + uint64_t lr; + uint64_t sp; + uint64_t ttbr0_el1; + uint64_t pad; + uint64_t tcb_addr; +}; +struct Thread_t{ + uint64_t tid; + THStatus status; + struct Process_t *proc; + void *arg; + // for adding thread to run_queue or wait_queue + struct ds_list_head tq_head; + // for adding thread to process list + struct ds_list_head th_head; + thread_func entry; + void *sp; + void *sig_sp; + uint64_t stack_sz; + struct RegState_t saved_reg; + struct waitqueue_t* waitqueue; +}; +struct Thread_t * thread_create(thread_func func, void *arg); +void schedule(uint8_t preempt); +void thread_control_init(); +struct Thread_t *thread_get_current_instance(); +void handle_time_schedule(struct Trapframe_t *frame); +void schedule_init(); +void thread_exec_wrapper(); +#endif \ No newline at end of file diff --git a/include/type.h b/include/type.h index 0e97e5321..518424c5c 100644 --- a/include/type.h +++ b/include/type.h @@ -1,6 +1,6 @@ - #ifndef __TYPE_H #define __TYPE_H + typedef unsigned long long uint64_t; typedef long long int64_t; typedef unsigned int uint32_t; @@ -9,5 +9,9 @@ typedef unsigned short uint16_t; typedef short int16_t; typedef unsigned char uint8_t; typedef char int8_t; +// typedef unsigned char bool; +// typedef uint8_t bool; +// #define false (0) +// #define true (1) #endif \ No newline at end of file diff --git a/include/utils.h b/include/utils.h index 0de44d023..ca0d7c742 100644 --- a/include/utils.h +++ b/include/utils.h @@ -1,7 +1,7 @@ -#include "type.h" #ifndef _UTILS_H #define _UTILS_H +#include "type.h" #include #define container_of(ptr, type, mem) ({\ diff --git a/include/waitqueue.h b/include/waitqueue.h new file mode 100755 index 000000000..3369c3d00 --- /dev/null +++ b/include/waitqueue.h @@ -0,0 +1,13 @@ +#ifndef __WAITQUEUE_H +#define __WAITQUEUE_H + +#include "thread.h" +#include "ds/list.h" +struct waitqueue_t { + struct ds_list_head th_list; +}; + +void waitqueue_init(struct waitqueue_t *queue); +void wait(struct waitqueue_t *queue); + +#endif \ No newline at end of file diff --git a/initramfs.cpio b/initramfs.cpio index b3a221a361ae084047afc05bacf34b65e75516c3..18f2f48730ac3f250ee7d762eaf1c280853a3d3c 100644 GIT binary patch literal 207872 zcmeI$U2GfIl?U)M98upNl%=g5*o{V62XO<7AC@A?ZrxCptyqoLNfl>XEYQ-VIFi^< zq(V}$TpNiNDR$esSky&;B5fR`d09KngSRM<7}yprvOoiL9~vjy-Io@Wfkg{+A2vlF zDl`iBoICfDqmdN2i$3(>KY`}nd+xa(^PAz2PJApr7Ei?GIC*qZijlsgLWSg5 zyG>1W#Ugrdpr79Veyw(vgZ;j}Bu5yWuh0VJ+$#E?{B@IA`Y$1o>8&n#zijA`TP64{wdvG=2EVq_7=TUZJ~{In>K2D zX@lpuUG1ZdcJ5p6OKwzc>oxlQv+ojFm+24By(@jyy~z#nsB*r_X-RH8O!V8YeONoI z+P@C{;FT9&{GD^@)_3WHNpB3#H9++KPl(P|?c|2lyf(|8M`b;Z_tysK<~~`I=c;n9 z(|YSW)&bg69ay`0hx3y}mj`cA?;yuyTs@EIXKMel*PYfKNZ#bV_Evd*nQNW*E_;3Z zgW6fS4!-^?x9rp}lmq9ichJTi_PA!P-In`Zwdpmv&MmpmH_Q(4{_A;sFRDE}=kt2b zNqXn2{(hdf%GXz$Z1lH&RKIVXMSoskoz06sQqO}t3+r7Jkv)99R{OT>`wm~@1jpEU z_NN>po@evoTi4{8{o~eJ)@G|Qy4lV5pc+fwT<1BQgM1GOg#z~#;kAGOJ9p+Nv)3RxX$qlk@Q#j?{)6a za%uWMr~4(e=;rgqu6Bwijtq}HG&(kZbmGM1$x~Cl_sBz|>YaJl?-Bj#ZM;Z!eUCh3 zaw@qcmp4=WTc+esiH@Lv00bZa0SG_<0uX=z z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV= z5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHaf zKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_ z009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz z00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_< z0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb z2tWV=5P$##AOHafKmY;|fB*y_0D-?Gf!ZX!vw4xOTNXuLrM25h{E95Gr^wNBpDsH(F zeS!}1G-0w@WjeK-nfs7LTKI27de*F7itO#R_Vn1@`@8S&?h8w|?>NkL-WMNgDlQ#q zkeWu-wx0Czf6|s8IrF45@q}|EIy}C0vOvpLSKb*3Zns><;$L)t*w`%msJ!qo$YmJCkYgfhg{denlG;m%0DlW4*s%B1mxe{TA@j(1O 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 YFoCnP6Vo%NW(Nlc1KUFLFIeFJ0P5+?LjV8( literal 512 zcmXpoH!wFaGynoK0~Z$%ZDQyKrVWf;EkJxYZD3$zW@2LE980!w4p# z#{jeqYM+UL1z6kyw|$1F_8CIlV?fY86PSIOc_j=W&~S-?g<&Ei1H%=05r&Ve|NjpG z3W}h(1?(ph+yb?Npj%8~ZYjykO$FNe!1^kX>}Gf*4Wg0U08@vD2FDW~d0bLXFo}>L QM^7KuAVoz*pxs~q0C?JF?EnA( diff --git a/lab5.cpio b/lab5.cpio new file mode 100755 index 0000000000000000000000000000000000000000..0676fb1584617bc4d73624b3b212a12133e97d8e GIT binary patch literal 247296 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

c^Tb>2N|NR(AN_u8?_))rgP-qh<=|vgoS4* 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 Kr!%kPgiTOHf4<+9YG5OLTb05s*f*rV}@eKyx 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�rf+7M}20+lX#0E53+{R(s9;*`|jXM?1GFnaI)`}eOWr|aP(Ck@FTYmhw-;(`V6J}@0&)(6BMjq9Fz6M0HuNX8 zA{`4{Vfv%`gXE%GqJx%dw|~ZWukaMn@k($OgLdl{%RMJ{68_J4IY)0<;#vI4_NB9K z3J>}K{Yvzah}mmzPd|cFd%{M|-finHbc?)p?rB8+;AAJcYJ)c~eEU3!9W3#m#>hbk zwhKop$WuF~Hgosnv@OMj2ezUu^zS^f!40Dp=C^Yg=e^+>;@9&24feoihf-#G(YkV;u#<^d#gS!pRj5BCpkTgZnRXN^VTacV;`($Bgqm$d7K0J=5;bi>AGP zjlEL7hhKIvX*V8+H9rHNdHp;dW8x=K`ynkso@21I9CLMUPA=s7YanCjZrpBo)0;cj z?}fG2oO(rmgZ2iK$F5`?H}kV!Dh;rYh1|!hH_0rY^U^rwZN~5?2lw4})M`A`x#&Dc za`M_*WUs^d^EgZ$_x;vj*P3@a`}`We9`^$sctLCKm8kU@@LSTTWtA~aVoJ;|V^sT5IBXJSD{HSCkLNCzuhypPz;Jfd z9;EH~NwN2!)LW|hgF$>fUm4kEU2_gCKYna=o`;O7?UzY+-`1UPr@Ve-J$3T@xG;0W z>xepgucSwxMF*S{`dA)4Ve{xm$wMFT{RJ@;>F2uBZ4a6Sk9BL)-XtHP9HE_?=|S4v zN$uR1^eg0f_1xVxHoDKM%g4+nZ)&+Qt+(#GIDU8PiTY>c$TL@hd#Zedar?f@*9+Cd ziFGKkH)T$>ZovM;2ERWg=Z?e@N`8xsmOVaN&q2Nr7<>BDhB4jYF+TBZc$U5+vaLM( zY~jC?I0|6D%yhM!ZG7)k7~H%ZUoQSI`7Ra$87((DlopvvUDnCygqn$+>e($mYm+U( z8oBDYwY;u6x9)XUiam;HY`(OTF~ldYFqrx{*te+pT5CK9PQf)wHQy{XTr=NOr;+YD ze!Qd3UC zG$yC~$X#WQ^LTlwF%H1xl(mfb_i$8`b4+y9N)|5Ecy2shcaKfA@?)#K%w{*lWxaT_ zW}F|_n8n=5nk;Eus-@c2tt2{n>AbvAhxbv9AKY?n>y&DTmt2#x9N*r{wZo%4xjf6~ z$4fo(Jb#|rnCK&Wbo()jeKljOteuqKyez*K{-?7hEXVuhUH7<}J)SdOvo;qWk9w41 z8E^cFc1hdR`n|68ZcD=%l=r$N_<{1(sXE-eA?pOKvum6!;Tk!PgF!zPk<@yYan_PLiLxvq*U*7}tbEiWgYqG~#TOmnzp|IdFaIjznm!{j zOK<*UT;UKN4#&sv2SfXi_OlLR*{jruZ%%k>A_s@ONFBGmm%R}VBz|_`6(Ivp#1esW zIGmt}>7!r%iT_K!kNS%eXF$#=PVO7EIpjJgeJG!=TK2GAe7Zw&_zv;km*jhtFJE!5 z1S688l|1(8D>2<_hy6&}^u5no8u@!UENO@Mw2;G`9=`N3$(#zR{fcMDm%sJ#G5kTn zHo1SHJjkW=@$OfKwHHxEmJ>;L<=*(E$wMB$9iPGhW_UxsO+3+p6nqC*@#0emo|z#Ce#03Kq{-u}m#t zdtxV{t%NWbFPr3x$A`ce_1p0uHu5FMe~eek_m=R@x-B-&$W;1j`_p6Q z=mdjD6FZcBWm)`Tbj~vVJHZ-xO5X$#JG8D>(`sG)MaS%H*5mcA-+VZR)L0gEgV|x{ zjDbQ#mYS^Uo{8S)*|FLr(H!wD^BccAlwH%WWW18&YrNve-Q8o6uU>ZCA>la-xTlV9 z&%<%+Gx&q5-6DhF0P-(^pIz!}Z^gz#*_41E{@*V-K1)Hr^zlm{f5#p8)vx}JyZXO> zr(kH|H1XaW7P5h9U717haq&0Nm&G(9^FGht^#_?$0pSwU58@BXI*~cBT&5VUo z`LKPzK+awD8X?qtua(b-?W{fPoN-M#MU|Hj?BYZCgZOn7mLRfdaE!`*a=vZxRP8j~ zV$+KbtaLVi>Kz}@)Y`rw*o^@WCEN;XOnplILD}a@-;sE@vS5Scqc*MAb#u6kTgSdz zIMHUaNu4|JtrtEX$t{W;w$b+lTlg6Mpwa_-De|!&tQr!LYbjIoc2BSX!R%i6L4}tC z$I-hR=J{2czEPA=_`=S5rtu~@UkgLroG5&3JlIO8!sIDGol_adhv zCpw9(wyS}4>t}sr`V9UcF(cRodj#oRN;k1vKe-Cb)dGw#5B7t9Q83ynyv}Ap>|?ze z&AZoQqm@i{K88O?<8|eu5`!)f#k6g^gJVE0PVjjjTUPg9`jpr;KI>|kx<;A%u2y^4 zwbIA%2gT1Iz8JM{%V@P)eMP)Q+A|wqQsA4)2Ty;36G9y(1AK6?%XPtm&-nkrE%w46 zG>y#BO0}*D@k6@jjY*xRYVtt}*+;({zq?ia_vfR~j6KNn=@m}w*K&=;V>N&iP9DA5 zl)Hyd*1=be&%M-Z-nZvWHNGpXR;vs56}vQAtyv*Z^P1X!(v>VkILI6#$D41Nc&PaCI9_wYIz~EKO=*4Tb*!R$=T%PB8!<^xNY5RP&G;1Mx?T z-|FjBd5Ym?NC*CQ3P(8+!>^y;y-avMd%iQzCU>&+OuS>Ig}h$f2kB(~RPUcbh`GOg zdp)~~DZuxC`?UB<`Av}ney!c@po4iVFlTmPry8#Tb}VDm&NoMkK>_Sx7nIVQ%Xa>{ z4f61a(Tm^~0l1p6z{lU(ct)w?49->8PUDMqz==5rLEZ7wP1ne`~mGCH$+A(w8=G~}N*952_b#FvMsAMZYQ=Q1^=1b5f&gLs;@!vUpMi+L7o z5dM_(3HpcNBS9Xl2@D4O;=i7ybPrs1Kp!ROTyUu&e%JgO>`uO8Rjo4&ai8~2m%KtH zYYL{a?aWre&K_-Z#V!6SQGw`JbR%)BU{t#`+{Y64K5_3KwJzwHZh;T(n(6E2>UEM& z(;xN(pIz~O)>xV3V=&1oY(nt9pk-4-POu|s%Mt7teD{!_$t`npdJ27>_pBT<-Kb8Mo0perI=gDF5`WCOpXfv4fD&5L znwA}J&e$3gTgY7sncb>W&80@mKFs0zB|p2>62}C6R%~$Cx#>-0N#DG5GT7Gyt6ive z3EvjZXJDUAes`j5NwC~KxVW5vG3u1(3bT%Hz!ojO(*%DK&MR0~3B7`g`p){e$sIe* zj%DXf`Y)KFxnE5(mHVNmyY%)C(yWyg-9kwbPv!zRJ#z`-o+;vm4$zd};h<$|em%y=03$P(_Y>K{mGKRr_XKV@L zr_F2J9Nbp4x7s@OPQnXD2Kg_MTEBGa(@Jgxawz~vy>{0M{_tt6Qpg>%&*7`^YLw1i zTJ;m+7r19Leh1u2a4)H2lwPe@7;)|K+&;STeI^w@q+hZ9-3t!5&E!!%Z>RKQrkarR zu*}8myXTK)o%$-%O>n>WVCfrT3IqofTzK>ywl-8c58}PmbKL8vvg*Fu>(v&#Rt8+< zr=AI4TVjytQ^-TS(qQ%IR}0{SnfaqQBtBr$h##7dT|VaR<8Au%6Kr(=eu{lEk8m&P zW0}GvA^n;BCgED2d&Is)a61`;`8oW?>QVi){Cqo}9<}RtuprvK4D5y6qj201Y*Y0w zuKRazyZroAsOiP(WxZIAh*vNwgLGrUcZxn#JcImhzi~~RoK67mA79)E?qhR!-kN&j zQdqlotT{gT# z#VtB@kC+Ycz&1IRn=&qYKdt_ta+|97Y1W8xgS1uqvU(IAb|KczTT8uIthPtD<3o6WK)JJbl73OjRbwL`iVLxa&|xgug#t zV1^HBK3t93_C}6Or%=o6jEVcqj_V`U$LS+{w~V8VL3N2!kV9g;W0kYp+vgg`%sNB7yMjh@H`CyL`^5WtQw~^KQ^OIoKPyMTuJ| z-HwG#CS561C+BSPFg|9F=VEqWwVXq(k~qYZ$-|_W-kJLIH$RvTVT{AOzwT9Sf@iDk zT#mrq$_XdfML9IbL4Jr}|+O)7Dm1TQ$l*ss14Qz*xD=q=`DH zY=At}me|7SDlBO`-AwG21xu{mbC~0P^R)~1v443(aqbInu<*;1zQaDB?*TWKHJjAZ zk^93bH%!j2*YWbU02DAEF00yoUpong5)4Dmn8FT9y=RDnIM4PxJC*xL-%@Rnz64K` zI0NZZ#1g2Jze|jwT+_5toZ0}Cb0+>`>4WETNzQ_1J*fLEygQ-%41p2ki8LQ^zVQdk zkNWC7h})Ble~OK?f094QJ*&W3K{i#VLF!tGzvS#2tXsqJOkqIhZ9r_7Kp8>^b)xk^Zy`i;9Q_^HBmc;vS$q7U7YwU7p92s>u(R(>gU|3y#S?(hQrK*b}+ zJl|!V@80;FItWiFxx+MTAP&K9zHl{#<9rH#kfvHw>ANbYGke0cZ!C#bN#KW5bCx!K z*!gcVe90n@N*QOSto`;fwC_R+IV4U)@ywB7>zfA$8&3!}>B#z<<7=$? zdQ{g`KNh=TEFNMx{}zAnkbpO&^uT}cPz{%W-~L1FU5$}n5(`F(Zn&=rnOoImUZX~N z9@8y3|4sg&Y7uS0=B;*`K6MKG_LbMtHYFe&mfzyY)!X?`$sjL2gg*%0Ph;Nem;^QY ztV7^i#Aq(1k;wMG_iufCyY}v%AHyG1c22Ebrfk}n^!FM-e1Z5FW%{Z2+C?>A{r61| zUzgA$^EC@{@#Qh>F_1HthJ6*TtE>sWPUT~g_1t&YMCFY49O3)a*IMd(_)m=ya!K`P z^*8?evhlA+bzQoS%;ysSN-k>qa3YR@{kw#iWyII0>Cxa1GDoVoeYM98{0j@e?Jew2 z+^2}}2XzhJubR_k4Gb4m^x?P9=n=b-+=?kc!pP$Abls!whHj%Y1oWTqJ z7vkW;{im$k>6@y~qjX|yK>G0q@&{>qxULl}ikL*xwI%PoYX6~MQF=fZpUxkIXCO8p zV+L!;M9TLM1VK^9Qsk3yB`W+ul@~+CENlUJsPX!wj-{{0Dba(77!Cd)bwA#=j2u!+ z?e5lPZ?28nm048ygUnaVbu{`Q_N>Kye;OQe)9Y?E1Md)@TtxVTYCfm?SoAISv9F@# z+_n|*kJiBr@byN7KghZO-+<(kK^+XeP5~TaAoyiPFpsG42Sfh`{wb}_`YHqF+;4(` z;1?C2weT1t!XLym7;|NgMvg>mn@dc|1&JIfFhF>wQQ;4Y9Pku4WUkhBufjSoC9iI7 z9CA}5!XIQ!rEEhm9s1SXZ8Uuoj6~J5Om(8d9}L$Wtl7~;vr&J658xNo+1r|pN5Rk| z!yi0I9$`8c|LoWE85mh|DCV;FephSG3d)BS3I3q$$LLQwIEXXoN^B4Oe_J2li^b*3 z$VY}hDC@*Szg(YcYw-SIU?d;pE|0HP`e>Sg5FZ)-py(r!p0<<3!jL1_e-f`y)f@`l z6|2))WcY(J=7QhBS)IDOQ-yRAH^2B|+%-BkHycESKgd`saWdFPf;yIm`aTED>zn9? z+!02q9~J(fbSn71bS|+IEpNY;=GmDQ=55b3#>;Y4_=ETnblsBelEf*JztY$~PtIk< zYeZE3&S>xlzxlG@+8u;5cmVrYN-jT5SKAu1LBRSrF(2wU2 z{zwk75@h*&{-Epw<@f{pz|YP*BETQ~fgDH}4gTPt%ON%%3I5;@>?1P#K`{;G{}kTf zmbpW?sLX-tn*1?B$1gcPOIg44@k<|n#~t|9ul|m^`agar`#|Ok;&V!Yd3gkWon5Zr zI%O48#yo=m_dTERoH$FtNz@|XqxgfWej>gGTJPI^_>WVGEurztG&xA{(S^BxM4nIP z59$^zJfII^Nd^B8%%u&U!(KL=&?CbiBu1D0g)|$i)*|j|d(cG>_^&4|uN@iwpo*^) z8_|eaT3#Q;@*!?%bbqYJg_v=fEOn9;iADG6nv0zRAO|&(x#hR;YmCLIUo&W@MDqT4`S08#}+Y& zA@kjZS3H8{kT2Ja!6OkKs^swdeEuMF1o$SCgUaXg)LsP-94Cg~eGPUF$2=nZLES&sBX_Fylse!-U=t%zN`*vK45Py(y zS8%nAc6O$4#^&UU%2ltFb0$;LUGx;I+k(<=E?A+}-Q~E+{$L$>W`C zMTb8qF{}wm>ZaZLm*+CGtxsCl&N4gO!JEuPhd)@Bc~H|W_Jii*^(+=Vkx8a_4)Uf( zhCis{mB4H>K5@IAUBAlsMeHT>V}|+@5#bL?&Q59fAwhnU={Yc{wIqBzh1bgdO5y|} zz#o+UgB%j;P5l*OGTH|f<0sdZEHVs4fIrB3UBxueR{SM!^<@z+Isj7_>{-PrQ-ARD z`Gd5VB^G0r)Wh+7>#X!(shpIe6fGM3LH2{h^ob7OcfpN%c<4c{5u-2ife%K5KS+J9 zu$EWgXOJU99S6z3ivaiz1#^x9e^6p8<-Wt$%D~qqr@eJo{u8Owc|fA5@CR9w;Ae=t z_Hu__ga;YdEkt8~h%Zir439ToP4HXoi^Ha39X^CV7}~h_L|rC!+FVcQJTUf3o-#GH zM}a>`n`tY)U4u|19?=c2#l98i7SW=@A5?P%++b>Vp&R@sYJZ3z2%~a0Ali4wJ8tH; zD|{Y1Vqjnm@Ne=5Lpx`@l{`%E;0Do$_!*^taYlka2xb6(P;nnc4(Vqk_E5UuJ|kN+ z>JKWc170ndfi5{Tr0r@fE|Bv>^2kSoKltVuu&z?M!MXqFpfBs)aJ*7|D+2sMk;9TT z$w6s?94?rItk)CdF%sJq`}utSp!juZDE+E$lY>C<4piHzF``@Y7scI-Lj6Jd5&E!~ zXUS_I_Q76IjkR&n1Cm69Kd9D&)MTLcW5@%M@k{Jvv{XSvK{-7metX2w)`efX?6j!ST`QE6%C^ZXl0@1g?JEKs4khLK8!Td2D zE!x9VugP2jm}6J54QeSyg+D0q$1HTk=QF&y-9z_Ceg?@a3Pz~qvq*VsyG5)5ASEwdXH{vhL(9Qfdt*F#=6$T>|uzntVg?mhas$nXc5F$yyFzPtw9 z^ASm)eCp+yjqB!=Z#ArkZbha3pw!)^FqrGwzEQkUXOaA?spfdm50>4S5gq;@&*B`9OBb>6_;yhoh)|-*x50Wbi z8%f-^^_}m>@HbSk@l;>x0^i+vIV$`?8LK3&?_Q{{$LV$*&Yed-0C=|5smnYP8UCP* zyToMp_QjoK`djuJ>CrNoU9K8dVcaf6hCc}R5jiwBNQ`BSWiKc-4$u)#%UVgd#Ge&` z`h&7;XTO18lzo)!#l`O<59&Z3$pOa!-{qtEgFli35yUtB@%+Ib$??|5$MXk&B!~1V zWchgh;E&|M-;UGw^ZA26k^^-_f^IW|M@%d`H;iXA$E`b6FzJ9hU64h`B7yfrS>8g z^GX<3rhP1bkjXAEsky7x=MtL`#)*qO+#A6;5rXR?(uda{WG_hmV`=vnKC20rGq1C^ zjSPQ~dyQ}Rfe^)TU#m8?8RAT|=_A{U41W+`qHiW74;;q9KdTMiEcqadE8k4@BE%m= zAMOJXM8$^*;5=z(8~CumqR0ao8UCQ;2*2!zV^H~b$xAkS?Yb4}J>pv=FK0yfgN#EN z&z~+)Lo5bvzRB(=D)W-OeaIj+2P0B{knZ%3Euo%6B5`(BcXZIe?>-F%3e$-Me~=g% z=8yVD;s4Z5J-i0Xz&p|QYMYv<^{DU%=~ser9y)Ui$fI3z`Zr`S;X%fVj91yH@CT7Y z>XvM4(`jfPez452-i7JIn-G#p&2i4Ono)-AcNK3x7B?6T8m0 z{-7Fn>kr4H{-1ZF2BYM$j5S|gvyiVIx{=`zG67=e$8-MrqI@E9NbTSlu`x#NzInwX z!ymNBzv5fZN^P4m#^vVO0q!)bl7pUFlH+c4_=D6avfHgr$}(l`&Y7KL8kPCO8x+UZ zGBW%@3LLWDm3klaFxgAN;Vx&gy2UGS+{o|;sojo!IP3?>Z$SMgN{b=^wM~%AQt_6N zs6QwSBpbqQW1P{h$S>R>s^uvIzf%TH>naIvorDTom|&;-~V=hpk)G!xAB+ z4y;DT5AluCucE>q^vtcJ%UDI5Q3xCg8KYF)IFTd73gyqjTSGU3->TKjIqkj4~3GFLk(7v7mE%Tf%=2k#-95g4ppjKsqrd?f0t`q5IxB8*2lN!?|iqP zQhyNN?p>LM>RZB7lY@9Gl@^OS$=~wxhJOkB()+o3z^wRe$U*w|_=E5U(FbExxelLR znj_I9G6AYuwhYEHeqkr-n%F*P$h!@nt2su*|NSXr_y6UZVDw+>1{rF=@8!4NcuUBa z<9p~Dv_-hfQV&&P+uon!XE+r0q52N*6`hFfD$W!il-CjA58`9M&czlac2DJy;-%ck zx=#IS){4>K4=R2aIuw6{=uY|*>qY)U*P=tN=@FSM_-tq(DkngC^Snx4&bGw5`!;+j&u`r4JS zuHny43AYg6qr3;-9e!=!^T{3A9KpRH?_v{7t_wCtF2+AQJ)7@p%I|c1&jvSY!UKXU z=e?x1n|!v&?+(E)%3+SpT(>mI%o$H(wE5cs&lz6{O0WuQKdAG3(oQbOkxIKICucPH zgMnQ?>R`5vv1*K}ocjxBH*dqAfCD*37csD@7`(_F_|BU9WaIn2&RUIUr&WJucdLQv z@7CPYE_}UMTX+iihbzLZ@@=X6XYf6LcFOm6d)vvuFM&m=##H@H4n^`fzNszm^nTd4gMhOUD=y+1K{6T zg*1Lqm;NL+F!T*Wc2dxtp5DWv#q_jZWweT{o+~(qlCEgXF>?Z&zK@v5(Ag zTYh=cmxY%as|epKD*VB~Jh-y1Wdoa;uPR+~^vQVIqd!gH55}TWe-PglwddP$HWk{- zGy9%x3>jZy4|nFbF1v(oMT0*W>^1R;7A6Z%<}>HES801}Dac)M`pA!{@CPNI0rR<*8EaXidgvc|vj_1$G7nAyJ2#06e~`S7 zYs6rulyVN=n zampeNhuTl6{d#2hgFlo5vBWq1>HNVT%AtJf?5#4VLa=xIV0iZeIZCjmIJ^?)u=F?; z(}iNCP~Fv%8T*_~9I8|Q6tCpYwMy!IuB0xLLH1nBCNA+o_HsTJkCS5jR2!w2)t$b{ zoyL5R`ab^iy#4v*4FlKbyX9DRQzO++RA0g0`TgVj4?mPc-iIuo&L8}t9QaJd7^*k%z zYP;%nvMOKWyE3{d+~d1$`PgrI{$i!Ry(HgPb42Or!uXRiC z9KqLAd?J99+M5W@gWvH(>kq1ZAMI4_=26z^vY&z%!vBIL@F@5^|2~^Pm{s?iMu&K_ z+T)VzHABseDDejcrzKt~jC(~Gh1aU!nCU}rM1?oTWwbZ>(;!X4Jrs9+4v3TvR1rMR`MDlBz77M1peUoRcw}hGe(X}sdE>N`h%J! zHBrSTB=(}M!ynxFJ0CoG&b__iAB_lqkXRVTCgu+GAwz3#bVY|f`jQFH2sxrre~|e? zYOZid{@_gZuXM20^ov15$0 zj8m~i<~j}RST`tk1+N|6`_))f_=D(yc-(}Rw3ZsA~al)-uk*p?@_TZ`>$=<3xx*2yRo*4$jOc4xW+!QYD9-WNNkDKrUp8E3C1RgM;tA#&H1xp8K+A*GWA$c3-ueL#>iH#FNRxq?q2H^~64Q)ep67>TvF4_mg7Ej(NJNPxs04A${?O zeaCmUzH#1y7VVz<^v<;x_QNQ(=`UcH~A>UujA!yAvY?dlcEPM}R*_ z{Y2H~GWSnp<_zyCvXDQ6`=|QX$JZaE=|4Im!XNyR7*VM|_~&xqmx}^_@Xv+7!lP4v z@JFJAe}D7U1iuZ(V=k*$htJ>-{$GTM0)Oy_a;UkGcfIwY-Y?JJF$JH(AN-*lzmI`X zed+s8F;6l_BN)EDe~&+?e7ZDC#c#-5Xc3b9o)6WWD1VCpe^A}o1F`L2hpbn=>o>>} zk@|y-tnUMze0whIFWr({6Vc!ga=&GLrLm4@LG@lE9u&`3UPOjJsN@h%s~VSN-3}iz zT<^m7qV}uuH-0{UQ1*VJ4|Rwhs821=S@RNODbFHOe^8B067eQHWAVGgyJHI}h9ARU zDndqqKPY1>HZ9E#?Lp*F`(E0=SnZ<1A5CA~eh0=S zjGg?VE9zOM^5CdoAqM)027fSIkO=ILT@VlO<_{K-WrBYcKBQmrc2ZAq%-QWsTF=J1 z<6A+{8V2@eaYGOwQ76T z?9sUdrMTq>`H5=}NBDwpD5WR2T|QY&B=+l7;|6wFrA>`aqkN+e2|ybjV&MwoZ0owE z_=A@aQ)_~ulfPCtI;JrP6RF(_-Atu+AVj!z4Ezmo!}(d@-{GU)r>-4uuCw!Ir8bf= zo19aUUm1r{m@`7K?*D$`I|C6`bF?>nY%PnO;=zqu8M$-+1@ zKK1k$KJ@ybyE`&RhyG6yK@N*G6zh}h$SQ^WLE$RHg`|#RRQQAVsEEgq^_7-htg>zR zgC+Dv{6K8}EErl;_=D(%d9SY}IN^GAd^mT3(M;aAJGWh5F_uMxKPa|Ae@=oA4g$N2 zT?_ZFIkwXE`)c*-MTI}8;a8V6)XC|1^e2hKsF0Vlwaix5(`+g-{6Vn~{Q!S(&`dKn z4VgDsi&Q(0UCbzs54EW92W33e4~gV{Gs8S`mWl&VeXDEU3)#r<2X)ES#rig*yT#&( z>b1_`$=XV=&Ix@iGWHNX}Xzzb}fnQ6!DWA?C{BKSF{k16Y2Y=t@-@g_cj{<-2_wD}u>tFoA-`|m6uYcWv zUw7cw9r$$z{{QL@;A7zU#UJ#$)YLKSA-*77scIcQk3k+Sco$s@-*8i%23)JJQ?9Ap zkMjOl9p47I+{Qybm-32+=?+qL$Gw#wy&FNP$EVpm=5+j>vPKGVSK>y&FY&v5@8A8! zAC$bAo-H-Ate|+qw_WXV&s&}+wY0jDQM@dtnL2kD1`17q8qDtG3*wO-98 z)%etpg|Wn%erQV^LUx!Mj2Q}(F z5hQLq;DhOLQ0g`B+jFKG-xXG?m0*5S+p5)?6$0UPDV&-A!}xG{@{2!6exzLx#Fv4w z7=wXsJfqZc2Is14r&~_Zsi|`i)Ez(Fbd7vV9>1NQ)Aa1t;O+*ozzoP2xEb&`_3ix> z9CbH(82?{;SGKJvvnIRyqTfTs?Sz8jJTQq9DwAvlWP0Sj?8oW&65X|{&QO2doV8A` z%&HVn9QOA?l4N8=G&hI+>Y10LAZt8E;Z9Hck6!Ls>8roz;cVHW!n~k)dB)o=W$Kc1pgMMT-7m ziR(A=K+hM^w)Diqtv{|0l+W|=WJ04{8maB6#k%vv=R&uU^9MgahF12Jcl}HbH+QAk zZT7=mq6kTAWCcxGxJE-EOVMq@>+w?_`>`}W-KFvMA@6Ewf822-D@(fDiHUZn>Wce> z>CwEfiO8O#`z4I~kHT#2^`^locJ@`@{WVt?8aM1Z!sfPe{$Qa;#d)o`gL+L_1XoRM z><-$kv(pvhVkr}Ur|dp=x9fw|?diU~O?nwYbpgRS$M)dUa-`dM)V>LWRtW9OgVo6|D`>G0tr987N(87=zIZPAYLpw{s^xKwmTpr^5)^u6Mz1 zMq{TH3;RJ7n*C_3ijlDIKSI0zz`evhw4p(|?>@qjqSP1jR2OmG4sq#Vi9t%f>5GC4 zTaEc3B~;#+{(D(H``gED?27Dz+3&{Md&x9xy%HST%-{4f8Tu!V(CyuYf$|8=`KQ&D zg7LEBThkV+!m?2=|G3N&)(AHfFK zJMfxcdZ~Z-H_+eC`Gf6k>V`1lXx~ctf_4=DsnWU^vJ~JUM@1pdw3QWJ`NYA>_APXJ zzAER{!Da^z<>6P()^CrfZ#xh_1fRi|516z{*@2*URrMlJ)@Sh6>9U=MQ2|J88?o*R0}EQfw)t|F{}B4XBdd0LAb7zR}lL00*2d4-4 z-?v&Qq;&?|0IwAq;e(hfOqjryaK$0hO;l&%6Z(nq^__^f-z9y zITEMjU09wue-JvCQ}|^~7#91+U}@2jaOB-1E4_Xmx7&(8ihkT4F#zp?XF)k5iiwazpdHmhL z!=U*7v)Y4?Td(uDcH`~5likv3g18H*GgHz*uaoCbddOve?+J+)u(R{Uob?H6(3j&Wd~l18tD{#B-y zYN{SrckvOO6IWVHhi8A4!^)>XTh{_EB(19Ui)o1>2RL8YBj*ot{-CI&g{b6G+e)2O ziX8!3#f)3I112>A<^fzqw)UsPa6PllXR#jo7cB%nhyjY$h_08z@ovWsCwk!gLFyYf zB317qjyhpdr9R$go@^B|@Q@<3am-=xK(tG*4J;Qp#=8=h_^O2mZY$v@#RZrk-m8ni ze8-II3Vdb1iA?w-)@r9Ncyy)knX2g=n$6Q^zEV@C(Hn(}Ro$TZW1K%2Tn=F&%PPiT zj}*syZgoz{LEg6V%l4@HYUEta`7~zrxJ*o{*fx&cyM9Oly%l(yx$4Xh%cUotf$;)| zM-K9Ge#m9aWvH-6;vy3UOnC4H_?LM-YbK_dK(A66`>C3cDl*A!Ublb)kGB%Bb~;L!R^hQJBg66<2Pb1|F{cY|!xFeVLle~U33rhQ2F zMz~p`hdTO%Lt!&?R)M{blRdU^&48Z)6$2f3&L3oW9>$du;1=n1wYBAXbF~^>PkQ}y z)EYb246^gC(F_hZKifAZ_uXyt*f*}pR+$7wqwnaA&SmKPy0<#q*qAg8RhMaAcwvNL zYbZmcMJ5YA8%KVR>(JQSd;IOaWJ&q`1HF;+2mdwxgTK!P_CQWKfAC-9KloSj!TE#3 z9_DM~nvLNy9Gj%^IltdEV}37=OKo{MZ_mzV7N?Sjz7yF^0Kgjum#Ek;B&?CPs z-~o&`IV=b8wqd-;75IFT3Y4%uPvBh| zurCR|dcav+!quSnr@=3Xv=09Ub0*yRN6jQf$&16NC=PS@9d5yW#F&_}f)60Llsy%g zkY1|p2)ToY-wM7^Gh-y|ROszutb~oFyi$UEaR0&OxvQF`w6z&ec<=ycU`EG1Vy+>M z;0D~EGscs57+*HiK?!})VnJh{Z2k_N zf{e4$r2E>cl5TXR9ZmB>UX|wKHXG0d6rHCAzKVy>6mgSlU2_fN)bf$G?MQ8Zh_}fm zyeuC$RyXc>f2Y$N8kW`AXf-d3lEeK6%X!5E(n4s%Mn)+Srxg5BUC{z~4%pID6-cdpEX~38va1?q0eIic&Uq9j$g!b9>C*sL5ZX+~#3m4o{#-9TROezV}JOS$@yc77CjAI{_*6FoUxRlZb z`je>!9@hr10jHCZSK@c2=it%{mb0bdiW=}xV5XX9Tb)tluj?7KP?b}nlGh{QLwMl+ zgB9*YxLVsj+aLjt*MXq=VgN^o49BD+Mu=(7+&4r{)31c+NvYv z18t3X!Caknrip6iliV@pu4^-M#$~lFmI0`gd#J zdsuhrF($s93Z9*f*8{eF56xa^eMqaRJqC7zg3CL78u*X7OxqO?58j6(*0(h!sha4rM)AEbMm4e=bP-%!m7 zVOT4s43kz8@mScsFZRQIP{V*{uFrPH1D(56(BXK^D`6k-=A_a~gxUTfZp-}#DR9JX zKxMo*iZd#$zboZ{jYohZMswsSM+RNz`pr7sA5qM|p9{zjS>JIW!Oi%*;|_#T7HO8f|x>u-tR{)5$V`m06^ z_1)+>)~29c`q4JAxUzGA&V#DHVh@hIu|Qvg#_Z@MqIk1B&^Gp^=_ORzS2los)ap2% zzY66Kh5HXK``YaOvAkcy<#ZQnkGyMj>I`p5z0jg3S1+ccK&$_et+pJAga+<(w2@&kEm zfzt(F9af+4mV02Gctup7goV6c1K;TR;vBtSzmdNabUAM`>P6dV82=yXOW=%rHo&dwjYroXfC${F_`#27y5nr=$9m_geVF`b#^0Q#wf5f&@b zpd`K2e_V4HI#%FKVxJ;+$@7UY+DVl=`kdAPxzeF$IfVW#v=e(P+3FlH&eNzHKhnYd z2b1M|l5`zg)e7f~n6AJJ0LO0N_Hc|7R=a}MEaEExBmZZWu=CaWx=cQm@ind+6>oq= z8htP$sw>I0=mYn~XRV-3+*tc-HDmp=Z`TiygQ{@{?mx)=2MI@l_7?Xa%W=YxBtlO(t@x0n(ODb`H%!jU)k2;1^FrIs z+{;JI?x)c9)w%zmU6k!T<{2EIF$*2j`61QD(?m`CnIw-3O`ZZPB)o8)N$piy2uoI- zazT9GbP&zrK{Nqgh(1S%xlg5?q4>E5_jOWnYNT2noFfKh2Ma6LS#UROa5qjLfxEKaSnu#>|fpj_< zNL4cJM2sO-<3d&3|5zvPl@IPeXm@}KcA?SPiv+a|jm~atIeln%c4+B`ro6tJLxLGI z{gPBE(2)w#Tl6qJ?(!s`y07@Zk8`Budwza%cF>pv_aD5)#qE|iLrd)i)<@G1ryrg$ zYFw2py;{Tayp3b4(G2x=65`xo=L2zr*?Cf(D;2JWGiLT-F6#aZ7kUN%D@VUg290rZ z|G_vf4Mf+;^tK1Al6c-|hhED{p0;X}5PPhky$UJ*=o&B(9ZwN2vMQI}?fO&Lf5l~f zdXaDN2=EB-2=EB-2>iteRAbhhKgjumoIm)5-~1RP;r@f%e~|MB&%_<({K5PIY+h0C z*)&zgr-<>IBzS~z{vh`s{RcUJka;7z>bZO0&!?O}_>&(Y_aA&< ztc@n>SA|UpAYa8ry>8To-qZX9E{t|{HZ7$Uai^hWC>_YN@zGy(Mq?lIIOhR;-JpdC zk2l7jiFTPQKwtDQ8;wl}P=XIY<9kF1sK)SU9PjT}&L8CdgCF*S^9P|dO1!~RhE5{q z4|4y(y>g28Ztk{*)7@kqIl>Ufh6SD+_aEf^LGC~J9(UvXL5x>7sdE0{s%2K4T0FkT zY2VAQ7yiNujxFv#$o&U_3v>S9FQ*IlAN(aCe3M6jM}S9wN8tZg1Zch@jbqkcy6)Jn z8#FhBhEBRHU+g>G)&4Zv96C$w)Jcp(9PG_wuuz)DjC~*bZu(;U2GSYz7r;cB z{tD(C;2z*hgQbrj_A1b7!OyDRLrc1EV!s_4%QQ`)MoYry@jvvh`^A14ie{b;8W{WS zDFx>ba{i$I<6wHPasD9Z4|4t>=MO@^7uwC7KbQ{EF{^4hNsIO@gLN4#ziOV&a(Avq zS=oRNrJZcY4}?^m1prl7$V%wQ!j>=vqC* z^_zGTwZ^e?-vQfRm4g+ueP?>KQ5y4o4gQOVX`1(DBjMyHg|JGTaM6Yh0I&Lcu#Wg(oBF$)jT+uIT@9ah$``D@0o+{Sq^2}Sa)KPjP zAwD3U(7%P}0s2nXF3mopYGE5`r!OQ-0#vo2v)9E+i~NukS%K%sv?;{pb>`YCRx=r6GP-WG<}es|0HgDf^a+4#|L2z9Ue zq_quS9-?qy4Yi6X^}nET>(`jK*uOo05Pw(G>?lv|XhU0;$u)j0nXD|hq*!j}PJ9UK zwJ4kpV|XUs1-luA_YU+>MQlsaSQR5--;V@ma1U*fRm;J1)3H)t%u`Q>ka^{sSbYg( z&2=2E_)cgF`#*Viy|LQ&65;=CF`6|q*3hS|%GddU&BF8Wl@Q96%hccWGI>~QU&D{? zr}Z&>Sn4diC}6b>0O;OuQ+O?sL*cAGa{4A@&@^OLQW=J7S)p+#8 z8}KIZczqg=r1p_{*3e1cg0!YR`>^MF{81c|$LhR#o^O{TjXfFd2NirE{S8br^~hpG z-h=eYKGEj*!0Pw2l|OqB8&^B?MDUS+E-WwjT6`JwSxGAwTyDKAAJCId9M6iKXm{7- zUFwDoG^f3yJR;uI)V(WVu_@wTW@z*9C(!TKQ+!6kUU+>TUcuiLW&2ucbW0zoGos%3s~@*H1IwPlSPSy6gh{=J(I~b@_j(t(HXq literal 0 HcmV?d00001 diff --git a/lab8.cpio b/lab8.cpio new file mode 100644 index 0000000000000000000000000000000000000000..d129e21ccea26bc1592ca8d1a964f3bbc721fdde GIT binary patch literal 405504 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 ALI3~& literal 0 HcmV?d00001 diff --git a/send_kernel.py b/send_kernel.py index c2cd0907d..c513feb42 100644 --- a/send_kernel.py +++ b/send_kernel.py @@ -1,3 +1,26 @@ +# import sys +# with open('kernel8.img', 'rb') as f: +# kernel = f.read() + + +# path = '/dev/ttyUSB0' + +# if len(sys.argv) > 1: +# path = sys.argv[1] + + + +# print(hex(len(kernel))) +# with open(path, 'wb') as tty: +# kernel_len = len(kernel) +# tty.write(b'S') +# tty.write(bytes([(kernel_len & 0xff000000) >> 24])) +# tty.write(bytes([(kernel_len & 0x00ff0000) >> 16])) +# tty.write(bytes([(kernel_len & 0x0000ff00) >> 8])) +# tty.write(bytes([kernel_len & 0x000000ff])) +# tty.write(kernel) + +import serial import sys with open('kernel8.img', 'rb') as f: kernel = f.read() @@ -7,15 +30,13 @@ if len(sys.argv) > 1: path = sys.argv[1] +ser = serial.Serial(path, baudrate=115200) - - -print(hex(len(kernel))) -with open(path, 'wb') as tty: +if ser.is_open: kernel_len = len(kernel) - tty.write(b'S') - tty.write(bytes([(kernel_len & 0xff000000) >> 24])) - tty.write(bytes([(kernel_len & 0x00ff0000) >> 16])) - tty.write(bytes([(kernel_len & 0x0000ff00) >> 8])) - tty.write(bytes([kernel_len & 0x000000ff])) - tty.write(kernel) + ser.write(b'S') + ser.write(bytes([(kernel_len & 0xff000000) >> 24])) + ser.write(bytes([(kernel_len & 0x00ff0000) >> 16])) + ser.write(bytes([(kernel_len & 0x0000ff00) >> 8])) + ser.write(bytes([kernel_len & 0x000000ff])) + ser.write(kernel) \ No newline at end of file diff --git a/src/bootloader/mini_uart.c b/src/bootloader/mini_uart.c index 8eb8edc56..51921f6dc 100644 --- a/src/bootloader/mini_uart.c +++ b/src/bootloader/mini_uart.c @@ -4,6 +4,8 @@ static char hex_char[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; +#define PBASE 0x3F000000 + void uart_init() { unsigned int selector; diff --git a/src/initramfs/Makefile b/src/initramfs/Makefile index 7cb4ad3f6..d073f441d 100644 --- a/src/initramfs/Makefile +++ b/src/initramfs/Makefile @@ -1,18 +1,20 @@ ARMGNU ?= aarch64-linux-gnu MAKE := make -COPS = -Wall -nostdlib -nostartfiles -ffreestanding -I../include -mgeneral-regs-only -ggdb -ASMOPS = -I ../include -ggdb +COPS = -Wall -nostdlib -nostartfiles -ffreestanding -I../include -mgeneral-regs-only -ggdb -mcmodel=tiny -std=gnu11 +ASMOPS = -I../include -ggdb INITRAMFS_BUILD_DIR = ../../build/initramfs KERNEL_BUILD_DIR = ../../build/kernel -all: $(INITRAMFS_BUILD_DIR)/int $(INITRAMFS_BUILD_DIR)/time +all: $(INITRAMFS_BUILD_DIR)/int $(INITRAMFS_BUILD_DIR)/time $(INITRAMFS_BUILD_DIR)/sys_test $(INITRAMFS_BUILD_DIR)/test $(INITRAMFS_BUILD_DIR)/hello $(INITRAMFS_BUILD_DIR)/%_s.o: %.S $(ARMGNU)-gcc $(ASMOPS) -c -o $@ $< +$(INITRAMFS_BUILD_DIR)/%_c.o: %.c + $(ARMGNU)-gcc $(COPS) -c -o $@ $< # INT_DEP = $(INITRAMFS_BUILD_DIR)/int_s.o # -include($(INT_DEP)) @@ -31,4 +33,22 @@ $(INITRAMFS_BUILD_DIR)/time: $(INITRAMFS_BUILD_DIR)/time_s.o $(ARMGNU)-ld -T linker.ld -o $@.elf $< $(ARMGNU)-objcopy $@.elf -O binary $@ rm $< - rm $@.elf \ No newline at end of file + rm $@.elf + +$(INITRAMFS_BUILD_DIR)/sys_test: $(INITRAMFS_BUILD_DIR)/sys_test_c.o + $(ARMGNU)-ld -T linker.ld -o $@.elf $< + $(ARMGNU)-objcopy $@.elf -O binary $@ + rm $< + # rm $@.elf + +$(INITRAMFS_BUILD_DIR)/test: $(INITRAMFS_BUILD_DIR)/test_s.o + $(ARMGNU)-ld -T linker.ld -o $@.elf $< + $(ARMGNU)-objcopy $@.elf -O binary $@ + rm $< + # rm $@.elf + +$(INITRAMFS_BUILD_DIR)/hello: $(INITRAMFS_BUILD_DIR)/hello_s.o + $(ARMGNU)-ld -T linker.ld -o $@.elf $< + $(ARMGNU)-objcopy $@.elf -O binary $@ + rm $< + # rm $@.elf \ No newline at end of file diff --git a/src/initramfs/hello.S b/src/initramfs/hello.S new file mode 100755 index 000000000..54108518c --- /dev/null +++ b/src/initramfs/hello.S @@ -0,0 +1,10 @@ +.section ".data" + hello: .string "hello: " + +.section ".text" + adr x0, hello + mov x1, #5 + mov x8, 2 + svc 0 +func: + b func \ No newline at end of file diff --git a/src/initramfs/linker.ld b/src/initramfs/linker.ld index 004d68856..d0421049f 100644 --- a/src/initramfs/linker.ld +++ b/src/initramfs/linker.ld @@ -1,15 +1,16 @@ ENTRY(start) SECTIONS { - . = 0x100000; - .text : { *(.text) } - .rodata : { *(.rodata) } - .data : { *(.data) } + . = 0x200000; + .entry : { *(.entry) } + .text : { *(.text*) } + .rodata : { *(.rodata*) } + .data : { *(.data*) } . = ALIGN(0x8); _bss_begin = .; .bss : { *(.bss*) } . = ALIGN(0x8); _bss_end = .; - _heap_begin = . + 0x5000; - _stack_begin = . + 0x10000; + _heap_begin = . + 0x1000; + _stack_begin = 0x280000; } \ No newline at end of file diff --git a/src/initramfs/sys_test.c b/src/initramfs/sys_test.c new file mode 100755 index 000000000..e229e8319 --- /dev/null +++ b/src/initramfs/sys_test.c @@ -0,0 +1,181 @@ +#include "syscall.h" + +char hello[] = "hello\r\n"; + +char hex_char[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; + +unsigned long long write(unsigned int fd, char buf[], unsigned long long len); +unsigned long long write_dec(unsigned long long val); +unsigned long long write_u64(unsigned long long val); +unsigned long long fork(); +unsigned long long getpid(); +unsigned long long read(char buf[], unsigned long long len); +unsigned long long exec(char name[], char *arg); +unsigned long long dec2buf(unsigned long long val, char *buf); +unsigned long long u642buf(unsigned long long val, char *buf); + // unsigned long long x = write(buf, 7); +unsigned long long pid; + +char buf[20]; +int start(){ + unsigned long long pid = getpid(); + write(1, "\nPID=",5); + write_dec(pid); + pid = fork(); + write(1, "\nPID=",5); + write_dec(pid); + while(1) { + + } + return; + // unsigned long long pid = getpid(); + // write("\nFork Test, pid ", 16); + // write_dec(pid); + // write("\n", 1); + // int cnt = 1; + // int ret = 0; + // if ((ret = fork()) == 0) { // child + // long long cur_sp; + // asm volatile("mov %0, sp" : "=r"(cur_sp)); + // write("first child pid: ", 17); + // write_dec(getpid()); + // write(", cnt: ", 6); + // write_dec(cnt); + // write(", ptr: ", 7); + // write_u64(&cnt); + // write(", sp: ", 7); + // write_u64(cur_sp); + // write("\n", 1); + // ++cnt; + + // if ((ret = fork()) != 0){ + // asm volatile("mov %0, sp" : "=r"(cur_sp)); + // write("first child pid: ", 17); + // write_dec(getpid()); + // write(", cnt: ", 6); + // write_dec(cnt); + // write(", ptr: ", 7); + // write_u64(&cnt); + // write(", sp: ", 7); + // write_u64(cur_sp); + // write("\n", 1); + // // printf("first child pid: %d, cnt: %d, ptr: %x, sp : %x\n", get_pid(), cnt, &cnt, cur_sp); + // } + // else{ + // while (cnt < 5) { + // asm volatile("mov %0, sp" : "=r"(cur_sp)); + // // printf("second child pid: %d, cnt: %d, ptr: %x, sp : %x\n", get_pid(), cnt, &cnt, cur_sp); + // write("Second child pid: ", 17); + // write_dec(getpid()); + // write(", cnt: ", 6); + // write_dec(cnt); + // write(", ptr: ", 7); + // write_u64(&cnt); + // write(", sp: ", 7); + // write_u64(cur_sp); + // write("\n", 1); + // long x = 1000000; + // while(x --) { + // asm volatile("nop"); + // } + // ++cnt; + // } + // } + // // exit(); + // } + // else { + // write("parent\n", 7); + // // printf("parent here, pid %d, child %d\n", get_pid(), ret); + + // } + // +} + +unsigned long long dec2buf(unsigned long long val, char *buf) { + unsigned long long cnt = 0; + unsigned long long ret = 1; + while(ret <= val) { + ret *= 10; + cnt += 1; + } + ret /= 10; + if(ret == 0) { + buf[0] = '0'; + return 1; + } + for(int i = 0; i < cnt; i ++) { + buf[i] = val / ret + '0'; + val -= ret; + ret /= 10; + } + return cnt; +} +unsigned long long write(unsigned int fd, char buf[], unsigned long long len){ + asm volatile( + "mov x8, 13\n" + "svc 0\n" + ); + unsigned long long val; + asm volatile( + "mov %0, x0\n":"=r"(val) + ); + return val; +} +unsigned long long read(char buf[], unsigned long long x) { + asm volatile( + "mov x8, 1\n" + "svc 0\n" + ); + unsigned long long val; + asm volatile( + "mov %0, x0\n":"=r"(val) + ); + return val; +} +unsigned long long fork() { + asm volatile( + "mov x8, 4\n" + "svc 0\n" + ); + unsigned long long val; + asm volatile( + "mov %0, x0\n":"=r"(val) + ); + return val; +} +unsigned long long getpid() { + asm volatile( + "mov x8, 0\n" + "svc 0\n" + ); + unsigned long long val; + asm volatile( + "mov %0, x0\n":"=r"(val) + ); + return val; +} +unsigned long long exec(char name[], char *arg) { + asm volatile( + "mov x8, 3\n" + "svc 0\n" + ); + unsigned long long val; + asm volatile( + "mov %0, x0\n":"=r"(val) + ); + return val; +} + +unsigned long long write_dec(unsigned long long val) { + + unsigned long long n = dec2buf(val, buf); + write(1, buf, n); + + return 0; +} +unsigned long long write_u64(unsigned long long val) { + for(int cnt = 60; cnt >= 0; cnt -= 4) { + write(1, &(hex_char[(val >> cnt) & 0xF]), 1); + } + return 0; +} \ No newline at end of file diff --git a/src/initramfs/test.S b/src/initramfs/test.S new file mode 100755 index 000000000..2f5e02b46 --- /dev/null +++ b/src/initramfs/test.S @@ -0,0 +1,22 @@ +.section ".data" + bad: .string "BAD: " + hello: .string "hello" + +.section ".text" + sub sp, sp, 16 + stp x29, x30, [sp] + adr x1, bad + mov x2, #5 + mov x0, 2 + svc 0 + mov x0, 4 + svc 0 + ldp x29, x30, [sp] + ret + // ldr x3, [sp] + // strb w3, [x1] + // mov x0, 2 + // svc 0 +// func: + // b func + diff --git a/src/kernel/boot.S b/src/kernel/boot.S index dca0e68d4..49ad2ad17 100644 --- a/src/kernel/boot.S +++ b/src/kernel/boot.S @@ -1,7 +1,13 @@ -#define CORE0_TIMER_IRQ_CTRL 0x40000040 -#define CORE1_TIMER_IRQ_CTRL 0x40000044 -#define CORE2_TIMER_IRQ_CTRL 0x40000048 -#define CORE3_TIMER_IRQ_CTRL 0x4000004C +// #define CORE0_TIMER_IRQ_CTRL 0x40000040 +// #define CORE1_TIMER_IRQ_CTRL 0x40000044 +// #define CORE2_TIMER_IRQ_CTRL 0x40000048 +// #define CORE3_TIMER_IRQ_CTRL 0x4000004C +#define CORE0_TIMER_IRQ_CTRL 0xffff000040000040 +#define CORE1_TIMER_IRQ_CTRL 0xffff000040000044 +#define CORE2_TIMER_IRQ_CTRL 0xffff000040000048 +#define CORE3_TIMER_IRQ_CTRL 0xffff00004000004C + + .extern exception_entry .extern spx_irq_handler @@ -9,6 +15,10 @@ .extern enable_interrupt .extern disable_interrupt .extern event_queue_handle +.extern svc_handler +.extern check_exception_depth +.extern enable_kernel_mmu +.extern load_all_eret_log .section ".text.boot" .globl _start @@ -17,7 +27,14 @@ _start: mov x11, x1 mov x12, x2 mov x13, x3 + bl from_el2_to_el1 + ldr x0, =boot_rest + b enable_kernel_mmu + br x0 + + +boot_rest: mrs x0, mpidr_el1 and x0, x0, #0xFF cbz x0, master @@ -25,9 +42,12 @@ _start: // switch to el1 from_el2_to_el1: - mov x0, (1 << 31) + ldr x0, =(1 << 31 | 1 << 34) // make execution state for el1 is aarch64 msr hcr_el2, x0 + mrs x0, SCTLR_EL1 + orr x0, x0, #512 + msr sctlr_el1, x0 mov x0, 0x3c5 msr spsr_el2, x0 msr elr_el2, lr @@ -86,17 +106,16 @@ master: stp x28, x29, [sp ,16 * 14] mrs x0, elr_el1 stp x30, x0, [sp, 16 * 15] - mrs x0, spsr_el1 - str x0, [sp, 16 * 16] + // mov x0, sp + mrs x0, sp_el0 + mrs x1, spsr_el1 + stp x0, x1, [sp, 16 * 16] + mrs x1, esr_el1 + str x1, [sp, 16 * 17] .endm // load general registers from stack .macro load_all - ldr x0, [sp, 16 * 16] - msr spsr_el1, x0 - ldp x30, x0, [sp, 16 * 15] - msr elr_el1, x0 - ldp x0, x1, [sp ,16 * 0] ldp x2, x3, [sp ,16 * 1] ldp x4, x5, [sp ,16 * 2] ldp x6, x7, [sp ,16 * 3] @@ -111,6 +130,13 @@ master: ldp x24, x25, [sp ,16 * 12] ldp x26, x27, [sp ,16 * 13] ldp x28, x29, [sp ,16 * 14] + ldp x0, x1, [sp, 16 * 16] + // mov sp, x0 + msr sp_el0, x0 + msr spsr_el1, x1 + ldp x30, x0, [sp, 16 * 15] + msr elr_el1, x0 + ldp x0, x1, [sp ,16 * 0] // ldr x30, [sp, 16 * 15] add sp, sp, 32 * 9 .endm @@ -137,7 +163,7 @@ exception_vector_table: .balign 0x80 b exception_handler .balign 0x80 - b exception_handler + b _sync_handler .balign 0x80 b el_aarch64_irq_epx .balign 0x80 @@ -145,9 +171,10 @@ exception_vector_table: .balign 0x80 b exception_handler .balign 0x80 - b exception_handler + b _sync_handler .balign 0x80 - b _lower_el_aarch64_irq + b el_aarch64_irq_epx + //b _lower_el_aarch64_irq .balign 0x80 b exception_handler .balign 0x80 @@ -192,30 +219,79 @@ core_timer_handler: msr cntp_tval_el0, x0 ret el_aarch64_irq_epx: - msr DAIFSet, 0xf save_all - mrs x0, esr_el1 - mrs x1, elr_el1 - mrs x2, spsr_el1 + msr DAIFSet, 0xf + mov x0, sp + mrs x1, esr_el1 bl spx_irq_handler - msr DAIFClr, 0xf + // msr DAIFClr, 0xf bl event_queue_handle - msr DAIFSet, 0xf - load_all + // msr DAIFSet, 0xf + bl check_exception_depth msr DAIFClr, 0xf + load_all eret _lower_el_aarch64_irq: - msr DAIFSet, 0xf save_all - mrs x0, esr_el1 - mrs x1, elr_el1 - mrs x2, spsr_el1 + msr DAIFSet, 0xf + mov x0, sp + // msr DAIFClr, 0xf bl lower_irq_handler - msr DAIFClr, 0xf bl event_queue_handle - msr DAIFSet, 0xf + // msr DAIFSet, 0xf + msr DAIFClr, 0xf load_all + eret + +_sync_handler: + save_all + msr DAIFSet, 0xf + // bl check_exception_depth + mov x0, sp + bl svc_handler + // msr DAIFClr, 0xf + + // bl event_queue_handle + // msr DAIFSet, 0xf + // bl check_exception_depth msr DAIFClr, 0xf - eret \ No newline at end of file + load_all + eret + +.global load_all_eret +load_all_eret: + // bl load_all_eret_log + ldp x2, x3, [sp ,16 * 1] + ldp x4, x5, [sp ,16 * 2] + ldp x6, x7, [sp ,16 * 3] + ldp x8, x9, [sp ,16 * 4] + ldp x10, x11, [sp ,16 * 5] + ldp x12, x13, [sp ,16 * 6] + ldp x14, x15, [sp ,16 * 7] + ldp x16, x17, [sp ,16 * 8] + ldp x18, x19, [sp ,16 * 9] + ldp x20, x21, [sp ,16 * 10] + ldp x22, x23, [sp ,16 * 11] + ldp x24, x25, [sp ,16 * 12] + ldp x26, x27, [sp ,16 * 13] + ldp x28, x29, [sp ,16 * 14] + ldp x0, x1, [sp, 16 * 16] + // mov sp, x0 + msr sp_el0, x0 + msr spsr_el1, x1 + ldp x30, x0, [sp, 16 * 15] + msr elr_el1, x0 + ldp x0, x1, [sp ,16 * 0] + add sp, sp, 32 * 9 + // ldr x30, [sp, 16 * 15] + eret + +.global back_el1 +back_el1: + msr elr_el1, lr + mov x0, 0x345 + msr spsr_el1, x0 + eret + diff --git a/src/kernel/context_switch.S b/src/kernel/context_switch.S new file mode 100755 index 000000000..bb8711e7f --- /dev/null +++ b/src/kernel/context_switch.S @@ -0,0 +1,35 @@ +.global context_switch_to +context_switch_to: + str x19, [x0, 16 * 9 + 8] + stp x20, x21, [x0, 16 * 10] + stp x22, x23, [x0, 16 * 11] + stp x24, x25, [x0, 16 * 12] + stp x26, x27, [x0, 16 * 13] + stp x28, fp, [x0, 16 * 14] + mov x3, sp + mrs x12, ttbr0_el1 + stp lr, x3, [x0, 16 * 15] + str x12, [x0, 16 * 16] + + ldr x12, [x1, 16 * 16] + ldr x19, [x1, 16 * 9 + 8] + ldp x20, x21, [x1, 16 * 10] + ldp x22, x23, [x1, 16 * 11] + ldp x24, x25, [x1, 16 * 12] + ldp x26, x27, [x1, 16 * 13] + ldp x28, fp, [x1, 16 * 14] + ldp lr, x3, [x1, 16 * 15] + mov sp, x3 + msr tpidr_el1, x2 + + dsb ish + msr ttbr0_el1, x12 + tlbi vmalle1is + dsb ish + isb + ret + +.global thread_get_current +thread_get_current: + mrs x0, tpidr_el1 + ret \ No newline at end of file diff --git a/src/kernel/cpio/cpio.c b/src/kernel/cpio/cpio.c index 1a3c759b7..a8809ae73 100644 --- a/src/kernel/cpio/cpio.c +++ b/src/kernel/cpio/cpio.c @@ -1,11 +1,16 @@ #include "cpio/cpio.h" #include "utils.h" #include "peripherals/mini_uart.h" +#include "process.h" +#include "fs/tmpfs.h" +#include "fs/vfs.h" +#include "mmu/mmu-def.h" +// extern void thread_exec_wrapper; char *initramfs_addr; void set_initramfs_addr(uint32_t addr) { - initramfs_addr = (char*)addr; + initramfs_addr = (char*)kernel_pa2va(addr); } unsigned int hex_to_uint(char* c) { @@ -30,12 +35,11 @@ void list_files() { for(;;) { unsigned int namesize = hex_to_uint(((cpio_newc_header*)tmp)->c_namesize); unsigned int filesize = hex_to_uint(((cpio_newc_header*)tmp)->c_filesize); + unsigned int filemode = hex_to_uint(((cpio_newc_header*)tmp)->c_mode); if(strncmp(tmp + offset, "TRAILER!!!", 10) == 0) { break; } - uart_send_n(tmp + offset, namesize); - uart_send_string("\r\n"); tmp += (((((namesize + offset) & 0x3) ^ 0x3) + 1) & 0x3) + namesize + offset; tmp += ((((filesize & 0x3) ^ 0x3) + 1) & 0x3) + filesize; } @@ -47,6 +51,7 @@ unsigned int cat_file(const char *filename) { unsigned int namesize = hex_to_uint(((cpio_newc_header*)tmp)->c_namesize); unsigned int filesize = hex_to_uint(((cpio_newc_header*)tmp)->c_filesize); + if(strncmp(tmp + offset, "TRAILER!!!", 10) == 0) { uart_send_string("file not found!\r\n"); return 255; @@ -63,8 +68,12 @@ unsigned int cat_file(const char *filename) { } unsigned int load_program(const char *filename) { - uint64_t program_addr = 0x100000; - char *tmp = (char *)initramfs_addr; + process_exec(filename, NULL, 0); +} + +uint8_t get_file(const char *filename, char **content, unsigned int *c_filesize) { + uart_send_string("in get file\r\n"); + char *tmp = (char *)kernel_pa2va(initramfs_addr); int offset = sizeof(cpio_newc_header); for(;;) { unsigned int namesize = hex_to_uint(((cpio_newc_header*)tmp)->c_namesize); @@ -76,16 +85,8 @@ unsigned int load_program(const char *filename) { } if(strncmp(tmp + offset, filename, namesize) == 0) { uint64_t content_offset = (((((namesize + offset) & 0x3) ^ 0x3) + 1) & 0x3) + namesize + offset; - memcpy((char*)program_addr, tmp + content_offset, filesize); - asm volatile( - "mov x0, 0x340\n" - "msr spsr_el1, x0\n" - "mov x0, 0x100000\n" - "msr elr_el1, x0\n" - "mov x0, 0x110000\n" - "msr sp_el0, x0\n" - "eret\n" - ); + *content = (char *)(content_offset + tmp); + *c_filesize = filesize; return 0; } // Since the (name + offset) size will be pad to align 4bytes @@ -93,4 +94,88 @@ unsigned int load_program(const char *filename) { // Since the filesize will be pad to align 4 bytes tmp += ((((filesize & 0x3) ^ 0x3) + 1) & 0x3) + filesize; } +} + + + +struct filesystem cpio_fs = { + .name = "cpio_fs", + .root = NULL, + // .init_fs = &init_tmpfs, + .init_fs = &init_cpio_fs, + .setup_mount = &mount_tmpfs +}; + +struct vnode_operations cpio_vops = { + .create = &vops_not_support, + .lookup = &tmpfs_lookup, + .mkdir = &vops_not_support +}; + +struct file_operations cpio_fops = { + .close = &tmpfs_close, + .ioctl = &fops_not_support, + .lseek64 = &tmpfs_lseek64, + .open = &tmpfs_open, + .read = &tmpfs_read, + .stat = &tmpfs_stat, + .write = &fops_not_support +}; + +int init_cpio_fs(struct filesystem *fs) { + init_tmpfs(fs); + return 0; +} + +void parse_cpio() { + struct vnode* cpio_root = cpio_fs.root; + cpio_root->flag = VFS_DIR; + + char *tmp = (char *)initramfs_addr; + int offset = sizeof(cpio_newc_header); + char name[100]; + for(;;) { + unsigned int namesize = hex_to_uint(((cpio_newc_header*)tmp)->c_namesize); + unsigned int filesize = hex_to_uint(((cpio_newc_header*)tmp)->c_filesize); + unsigned int filemode = hex_to_uint(((cpio_newc_header*)tmp)->c_mode) & C_FMASK; + + if(strncmp(tmp + offset, "TRAILER!!!", 10) == 0) { + break; + } + + if(strncmp(tmp + offset, ".", 1) != 0) { + if(filemode == C_REG) { + struct vnode *newnode; + memcpy(name, "/initramfs/", 11); + memcpy(name + 11, tmp + offset, namesize); + name[12 + namesize] = '\0'; + vfs_create(name, 0777, &newnode); + struct tmpfs_vinfo* info = newnode->internal; + uint64_t content_offset = (((((namesize + offset) & 0x3) ^ 0x3) + 1) & 0x3) + namesize + offset; + info->content = (char *)(content_offset + tmp); + info->filesize = filesize; + } else if(filemode == C_DIR) { + strncpy(name, "/initramfs/", 12); + strncpy(name + 12, tmp + offset, namesize); + name[12 + namesize] = '\0'; + vfs_mkdir(name); + } + } + tmp += (((((namesize + offset) & 0x3) ^ 0x3) + 1) & 0x3) + namesize + offset; + tmp += ((((filesize & 0x3) ^ 0x3) + 1) & 0x3) + filesize; + } + cpio_fs.root->f_ops = &cpio_fops; + cpio_fs.root->v_ops = &cpio_vops; + +} + + +void mount_initramfs() { + vfs_mkdir("/initramfs"); + register_filesystem(&cpio_fs); + vfs_mount("/initramfs", "cpio_fs"); + + parse_cpio(); + + return; } \ No newline at end of file diff --git a/src/kernel/event.c b/src/kernel/event.c index 050796fc3..f6790cc8e 100644 --- a/src/kernel/event.c +++ b/src/kernel/event.c @@ -44,7 +44,7 @@ struct k_event* k_event_front() { int flag = interrupt_disable_save(); struct k_event *ke; if(event_queue.heap.size == 0) { - ke == NULL; + ke = NULL; goto ret; } ke = ds_heap_front(&(event_queue.heap)); @@ -75,7 +75,6 @@ void event_queue_handle() { return; } if(event->preempt == 3) return; - // uart_send_dec(event->pri); event->preempt = 3; event->cb(event->ptr, event->ptr_len); @@ -84,5 +83,7 @@ void event_queue_handle() { if(irqhandler_cnt_get() == 0) { event_queue.cur_max_event_pri = -0x7fffffffffffffff; } + counter += 1; + } } \ No newline at end of file diff --git a/src/kernel/framebuffer.c b/src/kernel/framebuffer.c new file mode 100644 index 000000000..f0ebec1b3 --- /dev/null +++ b/src/kernel/framebuffer.c @@ -0,0 +1,157 @@ +#include "mbox/mbox.h" +#include "fs/vfs.h" +#include "mem/mem.h" +#include "framebuffer.h" +#include "mmu/mmu-def.h" + +#define MBOX_REQUEST 0 +#define MBOX_CH_PROP 8 +#define MBOX_TAG_LAST 0 + +unsigned int __attribute__((aligned(16))) framebuffer_mbox[36]; +unsigned int width, height, pitch, isrgb; /* dimensions and channel order */ +unsigned char *lfb; /* raw frame buffer address */ + +struct filesystem framebuffer_fs = { + .name = "framebuffer", + .init_fs = &init_framebuffer, + .root = NULL, + .setup_mount = &framebuffer_setup_mount +}; + + +struct file_operations framebuffer_fops = { + .close = &framebuffer_close, + .lseek64 = &framebuffer_lseek64, + .open = &framebuffer_open, + .read = &vops_not_support, + .stat = &vops_not_support, + .write = &framebuffer_write, + .ioctl = &framebuffer_ioctl +}; + +struct vnode_operations framebuffer_vops = { + .create = &fops_not_support, + .lookup = &fops_not_support, + .mkdir = &fops_not_support +}; + +int init_framebuffer(struct filesystem* fs) { + fs->root = (struct vnode*)kmalloc(sizeof(struct vnode)); + ds_list_head_init(&(fs->root->ch_list)); + ds_list_head_init(&(fs->root->v_head)); + fs->root->flag = VFS_FILE; + fs->root->internal = NULL; + fs->root->v_ops = &framebuffer_vops; + fs->root->f_ops = &framebuffer_fops; + fs->root->mount = NULL; + + framebuffer_mbox[0] = 35 * 4; + framebuffer_mbox[1] = MBOX_REQUEST; + + framebuffer_mbox[2] = 0x48003; // set phy wh + framebuffer_mbox[3] = 8; + framebuffer_mbox[4] = 8; + framebuffer_mbox[5] = 1024; // FrameBufferInfo.width + framebuffer_mbox[6] = 768; // FrameBufferInfo.height + + framebuffer_mbox[7] = 0x48004; // set virt wh + framebuffer_mbox[8] = 8; + framebuffer_mbox[9] = 8; + framebuffer_mbox[10] = 1024; // FrameBufferInfo.virtual_width + framebuffer_mbox[11] = 768; // FrameBufferInfo.virtual_height + + framebuffer_mbox[12] = 0x48009; // set virt offset + framebuffer_mbox[13] = 8; + framebuffer_mbox[14] = 8; + framebuffer_mbox[15] = 0; // FrameBufferInfo.x_offset + framebuffer_mbox[16] = 0; // FrameBufferInfo.y.offset + + framebuffer_mbox[17] = 0x48005; // set depth + framebuffer_mbox[18] = 4; + framebuffer_mbox[19] = 4; + framebuffer_mbox[20] = 32; // FrameBufferInfo.depth + + framebuffer_mbox[21] = 0x48006; // set pixel order + framebuffer_mbox[22] = 4; + framebuffer_mbox[23] = 4; + framebuffer_mbox[24] = 1; // RGB, not BGR preferably + + framebuffer_mbox[25] = 0x40001; // get framebuffer, gets alignment on request + framebuffer_mbox[26] = 8; + framebuffer_mbox[27] = 8; + framebuffer_mbox[28] = 4096; // FrameBufferInfo.pointer + framebuffer_mbox[29] = 0; // FrameBufferInfo.size + + framebuffer_mbox[30] = 0x40008; // get pitch + framebuffer_mbox[31] = 4; + framebuffer_mbox[32] = 4; + framebuffer_mbox[33] = 0; // FrameBufferInfo.pitch + + framebuffer_mbox[34] = MBOX_TAG_LAST; + + // this might not return exactly what we asked for, could be + // the closest supported resolution instead + if (mbox_call(MBOX_CH_PROP, framebuffer_mbox) && framebuffer_mbox[20] == 32 && framebuffer_mbox[28] != 0) { + framebuffer_mbox[28] &= 0x3FFFFFFF; // convert GPU address to ARM address + width = framebuffer_mbox[5]; // get actual physical width + height = framebuffer_mbox[6]; // get actual physical height + pitch = framebuffer_mbox[33]; // get number of bytes per line + isrgb = framebuffer_mbox[24]; // get the actual channel order + lfb = (void *)((unsigned long)framebuffer_mbox[28]); + lfb = kernel_pa2va(lfb); + } else { + uart_send_string("Unable to set screen resolution to 1024x768x32\n"); + } +} + +int framebuffer_ioctl(struct file *f, unsigned long request, void *buf) { + return 0; +} + +int framebuffer_close(struct file *f) { + kfree(f); + return 0; +} +int framebuffer_lseek64(struct file *f, int offset, int whence) { + if(whence == SEEK_SET) { + f->f_pos = offset; + return 0; + } else { + return 0; + } +} + +int framebuffer_open(struct vnode *file_node, struct file **target) { + struct file *ret = (struct file *)kmalloc(sizeof(struct file)); + ret->f_ops = &framebuffer_fops; + ret->f_pos = 0; + ret->flags = 0777; + ret->vnode = framebuffer_fs.root; + *target = ret; + return 0; +} + + +int framebuffer_write(struct file *f, void *buf, long len) { + for(int i = 0; i < len; i ++, f->f_pos ++) { + *(char*)(lfb + f->f_pos) = *(char*)(buf + i); + } + return len; +} + +int framebuffer_setup_mount(struct filesystem* fs, struct mount *mnt) { + ds_list_head_init(&(fs->root->ch_list)); + ds_list_head_init(&(fs->root->v_head)); + fs->root->flag = VFS_FILE; + fs->root->mount = mnt; + mnt->root = fs->root; + mnt->fs = fs; +} + + +void setup_dev_framebuffer() { + register_filesystem(&framebuffer_fs); + vfs_mkdir("/dev/framebuffer"); + vfs_mount("/dev/framebuffer", "framebuffer"); +} diff --git a/src/kernel/fs/fat32.c b/src/kernel/fs/fat32.c new file mode 100644 index 000000000..2da81555a --- /dev/null +++ b/src/kernel/fs/fat32.c @@ -0,0 +1,570 @@ +#include "fs/fat32.h" +#include "sd.h" +#include "fs/vfs.h" +#include "mem/mem.h" +#include "mem/page.h" +#include "peripherals/mini_uart.h" +#include "utils.h" + + +struct partition_entry pe[4]; +unsigned int fat_base_idx; +unsigned int fat_blk_idx; +unsigned int fat_data_region_idx; + +struct filesystem fat32_fs = { + .name = "fat32_boot", + .init_fs = &fat32_init, + .root = NULL, + .setup_mount = &fat32_setup_mount +}; + +struct file_operations fat32_fops = { + .close = fat32_close, + .ioctl = fops_not_support, + .lseek64 = fops_not_support, + .open = fat32_open, + .read = fat32_read, + .write = fat32_write, + .stat = fops_not_support +}; +struct vnode_operations fat32_vops = { + .create = fat32_create, + .mkdir = vops_not_support, + .lookup = fat32_lookup +}; + +int end_of_cluster(unsigned int val) { + if(val >= END_OF_CLUSTER) { + return 1; + } else { + return 0; + } +} + +int fat32_close(struct file *f) { + struct fat32_file_cache *f_cache = f->vnode->internal; + f_cache->opening -= 1; + kfree(f); + return 0; +} +int dirent2filename(struct fat32_dir_entry *ent, char *buf) { + int ridx = 7; + for(;ridx >= 0; ridx --) { + if(ent->filename[ridx] != ' ') { + break; + } + } + if(ridx < 0) return 0; + memcpy(buf, ent->filename, ridx + 1); + int ext_ridx = 2; + for(; ext_ridx >= 0; ext_ridx --) { + if(ent->ext[ext_ridx] != ' ') { + break; + } + } + + if(ext_ridx >= 0) { + buf[ridx + 1] = '.'; + memcpy(buf + ridx + 2, ent->ext, ext_ridx + 1); + buf[ridx + 2 + ext_ridx + 1] = '\0'; + return ridx + 2 + ext_ridx + 1; + } else { + buf[ridx + 1] = '\0'; + return ridx + 1; + } +} + +int clusteridx2datablkidx(int clus_idx) { + return clus_idx - 2 + fat_data_region_idx; +} + +int build_up_fat(uint8_t **FAT, int beg_clus_idx) { + int cnt = 0; + int cur_clus_idx = beg_clus_idx; + int old_clus_idx = cur_clus_idx - (cur_clus_idx & 0x7f); + unsigned int buf[150]; + readblock(fat_blk_idx + (old_clus_idx >> 7),&(buf[0])); + while(!end_of_cluster(cur_clus_idx)) { + if(cur_clus_idx - old_clus_idx >= 0x80 || cur_clus_idx - old_clus_idx <= -0x80) { + old_clus_idx = cur_clus_idx - (cur_clus_idx & 0x7f); + readblock(fat_blk_idx + (old_clus_idx >> 7), &(buf[0])); + } + cur_clus_idx = buf[cur_clus_idx % 128]; + cnt += 1; + } + uint32_t *new_FAT = (unsigned int*)kmalloc(cnt * 4); + + *FAT = new_FAT; + cur_clus_idx = beg_clus_idx; + old_clus_idx = cur_clus_idx - (cur_clus_idx & 0x7f); + cnt = 0; + readblock(fat_blk_idx + (old_clus_idx >> 7),&(buf[0])); + while(!end_of_cluster(cur_clus_idx)) { + + if(cur_clus_idx - old_clus_idx >= 0x80 || cur_clus_idx - old_clus_idx <= -0x80) { + old_clus_idx = cur_clus_idx - (cur_clus_idx & 0x7f); + readblock(fat_blk_idx + (old_clus_idx >> 7), &(buf[0])); + } + cur_clus_idx = buf[cur_clus_idx % 128]; + new_FAT[cnt++] = cur_clus_idx; + } + return cnt; +} + +void init_fat32_dir_vnode(struct vnode *node, struct fat32_dir_entry *ent, const char *comp) { + node->internal = kmalloc(sizeof(struct fat32_dir_cache)); + node->flag = VFS_DIR; + node->f_ops = &fat32_fops; + node->v_ops = &fat32_vops; + node->mount = NULL; + node->parent = NULL; + ds_list_head_init(&(node->ch_list)); + ds_list_head_init(&(node->v_head)); + struct fat32_dir_cache *dir_cache = node->internal; + if(comp != NULL) { + memcpy(dir_cache->dir_name, comp, strlen(comp)); + } + + dir_cache->dir_clus_idx = ent->beg_clus_l - 2; + + dir_cache->FAT_cnt = build_up_fat(&(dir_cache->FAT), dir_cache->dir_clus_idx); +} + +void init_fat32_file_vnode(struct vnode* node, struct fat32_dir_entry *ent, const char *comp) { + node->internal = kmalloc(sizeof(struct fat32_file_cache)); + node->flag = VFS_FILE; + node->f_ops = &fat32_fops; + node->v_ops = &fat32_vops; + node->mount = NULL; + node->parent = NULL; + ds_list_head_init(&(node->ch_list)); + ds_list_head_init(&(node->v_head)); + struct fat32_file_cache *file_cache = node->internal; + if(comp != NULL) { + memcpy(file_cache->name, comp, strlen(comp)); + } + file_cache->filesize = ent->file_size; + file_cache->data_cluster_index = ent->beg_clus_l; + + int cur_clus_idx = file_cache->data_cluster_index; + file_cache->dirty = 0; + file_cache->cached = 0; + file_cache->opening = 0; + + file_cache->FAT_cnt = build_up_fat(&(file_cache->FAT), file_cache->data_cluster_index); + +} + + +int fat32_lookup(struct vnode* dir_node, struct vnode **target, const char *component) { + struct fat32_dir_cache *dir_cache = dir_node->internal; + + + struct ds_list_head *head = dir_node->ch_list.next; + while(head != &(dir_node->ch_list)) { + struct fat32_file_cache *f_cache; + struct vnode *node = container_of(head, struct vnode, v_head); + f_cache = node->internal; + if(strncmp(component, f_cache->name, strlen(component)) == 0) { + *target = node; + return 0; + } + head = ds_list_front(head); + } + + char filename[12]; + + // if not found + char buf[768]; + readblock(clusteridx2datablkidx(dir_cache->dir_clus_idx), buf); + int cur_clus_idx = dir_cache->dir_clus_idx; + struct fat32_dir_entry *ent = buf; + int fat_idx = 0; + while(!end_of_cluster(cur_clus_idx)) { + + for(int i = 0; i < 16; i ++) { + int len = dirent2filename(ent, filename); + if(strncmp(filename, component, strlen(component)) == 0){ + struct vnode *cur_node = (struct vnode*)kmalloc(sizeof(struct vnode)); + if(ent->attr == ATTR_DIRECTORY) { + init_fat32_dir_vnode(cur_node, ent, component); + cur_node->parent = dir_node; + } else { + init_fat32_file_vnode(cur_node, ent, component); + struct fat32_file_cache *f_cache = cur_node->internal; + f_cache->dir_ent_clus_idx = cur_clus_idx; + f_cache->dir_idx = i; + cur_node->parent = dir_node; + } + + ds_list_addprev(&(dir_node->ch_list), &(cur_node->v_head)); + *target = cur_node; + return 0; + } + ent = (buf + 32 * i); + } + cur_clus_idx = dir_cache->FAT[fat_idx ++]; + } + return VFS_NOT_FOUND; +} + +int fat32_init(struct filesystem *fs) { + fs->root = (struct vnode*)kmalloc(sizeof(struct vnode)); + + ds_list_head_init(&(fs->root->ch_list)); + ds_list_head_init(&(fs->root->v_head)); + fs->root->flag = VFS_DIR; + fs->root->v_ops = &fat32_vops; + fs->root->f_ops = &fat32_fops; + fs->root->internal = (struct fat32_dir_cache*)kmalloc(sizeof(struct fat32_dir_cache)); + struct fat32_dir_cache *dir_cache = fs->root->internal; + // dir_cache->dir_clus_idx = fat_blk_idx + fat_base_idx; + dir_cache->dir_clus_idx = 2; + // int cur_clus_idx = dir_cache->dir_clus_idx; + // int old_clus_idx = cur_clus_idx - (cur_clus_idx & 0x7f); + + dir_cache->FAT_cnt = build_up_fat(&(dir_cache->FAT), dir_cache->dir_clus_idx); + return 0; +} + +int fat32_open(struct vnode* node, struct file **target) { + if(node->flag == VFS_DIR) return VFS_CANNOT_OPEN_DIR; + struct file *file = (struct file*)kmalloc(sizeof(struct file)); + struct fat32_file_cache *file_cache = node->internal; + file_cache->opening += 1; + + file->f_ops = &fat32_fops; + file->f_pos = 0; + file->vnode = node; + + *target = file; + return 0; +} + +uint32_t bin_align(uint32_t val) { + int ret = 4096; + while(ret < val) { + ret *= 2; + } + return ret; +} +void build_up_cache(struct fat32_file_cache *file_cache) { + file_cache->maxsize = bin_align(file_cache->filesize); + file_cache->tmpdata = cmalloc(file_cache->maxsize); + int cur_clus_idx = file_cache->data_cluster_index; + int cnt = 0; + + while(!end_of_cluster(cur_clus_idx)) { + readblock(clusteridx2datablkidx(cur_clus_idx), file_cache->tmpdata + cnt * SECTOR_SIZE); + cur_clus_idx = file_cache->FAT[cnt ++]; + } +} + +int fat32_read(struct file *f, void *buf, long len) { + struct vnode* node = f->vnode; + + struct fat32_file_cache *file_cache = node->internal; + if(file_cache->cached == 0) { + // load the file into cache + // fully cache for each file + // maybe not very good implementation + build_up_cache(file_cache); + file_cache->cached = 1; + } + + + for(int i = 0; i < len; i ++, f->f_pos ++) { + if(f->f_pos == file_cache->filesize) { + return i; + } + *(char *)(buf + i) = *(char *)(file_cache->tmpdata + f->f_pos); + } + + return len; +} + +int fat32_write(struct file *f, void *buf, long len) { + struct vnode* node = f->vnode; + + struct fat32_file_cache *file_cache = node->internal; + if(file_cache->cached == 0) { + // load the file into cache + // fully cache for each file + // maybe not very good implementation + build_up_cache(file_cache); + file_cache->cached = 1; + } + file_cache->dirty = 1; + + for(int i = 0; i < len; i ++, f->f_pos ++) { + if(f->f_pos == file_cache->maxsize) { + // if hit maxsize, alloc new cache and free old one + void *newcache = cmalloc(file_cache->maxsize << 1); + memcpy(newcache, file_cache->tmpdata, file_cache->maxsize); + kfree(file_cache->tmpdata); + file_cache->tmpdata = newcache; + file_cache->maxsize <<= 1; + } + if(f->f_pos >= file_cache->filesize) { + file_cache->filesize = f->f_pos + 1; + } + *(char *)(file_cache->tmpdata + f->f_pos) = *(char *)(buf + i); + } + + return len; +} + +int fat32_create(struct vnode *dir_node, struct vnode **target, const char *comp) { + // uart_send_string("In fat32 create\r\n"); + struct vnode *new_node = (struct vnode*)kmalloc(sizeof(struct vnode)); + + new_node->internal = kmalloc(sizeof(struct fat32_file_cache)); + new_node->flag = VFS_FILE; + new_node->f_ops = &fat32_fops; + new_node->v_ops = &fat32_vops; + new_node->mount = NULL; + new_node->parent = NULL; + ds_list_head_init(&(new_node->ch_list)); + ds_list_head_init(&(new_node->v_head)); + struct fat32_file_cache *file_cache = new_node->internal; + if(comp != NULL) { + memcpy(file_cache->name, comp, strlen(comp)); + } + file_cache->name[strlen(comp)] = '\0'; + file_cache->filesize = 0; + + int cur_clus_idx = file_cache->data_cluster_index; + file_cache->dirty = 1; + file_cache->cached = 1; + file_cache->opening = 0; + file_cache->tmpdata = cmalloc(PAGE_SIZE); + file_cache->maxsize = PAGE_SIZE; + file_cache->filesize = 1; + struct fat32_dir_cache *dir_cache = dir_node->internal; + file_cache->dir_ent_clus_idx = dir_cache->dir_clus_idx; + file_cache->dir_idx = 0xffffffff; + file_cache->FAT_cnt = 0xffffffff; + file_cache->FAT = NULL; + + ds_list_addprev(&(dir_node->ch_list), &(new_node->v_head)); + new_node->parent = dir_node; + + *target = new_node; + + return 0; +} + +int fat32_setup_mount(struct filesystem *fs, struct mount *mnt) { + // uart_send_string("In fat32 setup mount\r\n"); + mnt->root = fs->root; + mnt->fs = fs; + if(fs->root->mount == NULL) { + fs->root->mount = mnt; + } + return 0; +} + +void setup_boot() { + char buf[1024]; + readblock(0, buf); + for(int i = 0; i < 4; i ++) { + memcpy(&pe[i], buf + (446 + 16 * i), 16); + } + + // read first partition + struct fat_boot_sector partition1; + + readblock(pe[0].num_between, buf); + fat_base_idx = pe[0].num_between; + memcpy(&partition1, buf, sizeof(struct fat_boot_sector)); + + fat_blk_idx = partition1.n_reserve_sec + fat_base_idx; + fat_data_region_idx = partition1.n_copy * partition1.n_sec_per_fat + partition1.n_reserve_sec + fat_base_idx; + + register_filesystem(&fat32_fs); + vfs_mkdir("/boot"); + vfs_mount("/boot", "fat32_boot"); +} + +void fat32_sync_dir(struct vnode* dir_node) { + struct ds_list_head *head = dir_node->ch_list.next; + while(head != &(dir_node->ch_list)) { + struct vnode *node = container_of(head, struct vnode, v_head); + if(node->flag == VFS_FILE) { + fat32_sync_file(node, dir_node); + } else { + fat32_sync_dir(node); + } + head = ds_list_front(head); + } +} + +void gen_new_fat(struct fat32_file_cache *f_cache, uint32_t new_fat_cnt) { + uint32_t *new_fat = kmalloc(new_fat_cnt * 4); + int cnt = 0; + if(f_cache->FAT_cnt != 0xffffffff) { + for(; cnt < f_cache->FAT_cnt - 1; cnt ++) { + new_fat[cnt] = f_cache->FAT[cnt]; + } + } else { + cnt = -1; + } + + + + uint32_t buf[150]; + int idx = 0; + + while(cnt < (int)(new_fat_cnt - 1)) { + readblock(idx + fat_blk_idx, &(buf[0])); + for(int i = 0; i < 128; i ++) { + if(buf[i] == 0) { + if(f_cache->FAT_cnt == 0xffffffff) { + f_cache->data_cluster_index = idx * 128 + i; + f_cache->FAT_cnt = new_fat_cnt; + cnt ++; + } else { + new_fat[cnt] = idx * 128 + i; + cnt ++; + } + if(cnt >= new_fat_cnt - 1) break; + } + } + idx ++; + } + new_fat[new_fat_cnt - 1] = END_OF_CLUSTER; + kfree(f_cache->FAT); + f_cache->FAT = new_fat; + f_cache->FAT_cnt = new_fat_cnt; +} + +void flush_new_fat(struct fat32_file_cache *f_cache) { + uint32_t cur_clus_idx = f_cache->data_cluster_index; + uint32_t buf[150]; + int cnt = 0; + while(!end_of_cluster(cur_clus_idx)) { + readblock((cur_clus_idx >> 7) + fat_blk_idx, &(buf[0])); + buf[cur_clus_idx & 0x7f] = f_cache->FAT[cnt]; + writeblock((cur_clus_idx >> 7) + fat_blk_idx, &(buf[0])); + cur_clus_idx = f_cache->FAT[cnt]; + cnt += 1; + } +} +void flush_data(struct fat32_file_cache *f_cache) { + uint32_t cur_clus_idx = f_cache->data_cluster_index; + int cnt = 0; + while(!end_of_cluster(cur_clus_idx)) { + writeblock(clusteridx2datablkidx(cur_clus_idx), (f_cache->tmpdata + 512 * cnt)); + cur_clus_idx = f_cache->FAT[cnt]; + cnt += 1; + } +} + +void copy_name(struct fat32_dir_entry *ent, struct fat32_file_cache *f_cache) { + uint8_t found = 0; + int i; + for(i = 0; i < 8; i ++) { + if(f_cache->name[i] == '.') { + found = i; + } + if(found) { + ent->filename[i] = ' '; + } else { + if(f_cache->name[i] >= 'a' && f_cache->name[i] <= 'z') { + ent->filename[i] = f_cache->name[i] + ('A' - 'a'); + } else { + ent->filename[i] = f_cache->name[i]; + } + } + } + if(found == 0) return; + for(i = found + 1; i <= found + 3; i ++) { + if(f_cache->name[i] == '\0') { + break; + } + if(f_cache->name[i] >= 'a' && f_cache->name[i] <= 'z') { + ent->ext[i - found - 1] = f_cache->name[i] + ('A' - 'a'); + } else { + ent->ext[i - found - 1] = f_cache->name[i]; + } + } +} + +void fat32_sync_file(struct vnode* file_node, struct vnode *dir_node) { + + struct fat32_file_cache *f_cache = file_node->internal; + if(!f_cache->dirty) return; + + char buf[768]; + if(f_cache->dir_idx != 0xffffffff) { + // update the dir entry for the file + readblock(clusteridx2datablkidx(f_cache->dir_ent_clus_idx), buf); + struct fat32_dir_entry *ent = ((void*)(buf + 32 * f_cache->dir_idx)); + ent->file_size = f_cache->filesize; + writeblock(clusteridx2datablkidx(f_cache->dir_ent_clus_idx), buf); + + // update the file entry for the file + uint32_t new_fat_cnt = (f_cache->filesize + SECTOR_SIZE - 1) / SECTOR_SIZE; + if(f_cache->FAT_cnt < new_fat_cnt) { + gen_new_fat(f_cache, new_fat_cnt); + flush_new_fat(f_cache); + } + flush_data(f_cache); + } else { + uint32_t new_fat_cnt = (f_cache->filesize + SECTOR_SIZE - 1) / SECTOR_SIZE; + gen_new_fat(f_cache, new_fat_cnt); + flush_new_fat(f_cache); + int cur_clus_idx = f_cache->dir_ent_clus_idx; + struct fat32_dir_cache *dir_cache = dir_node->internal; + int cnt = 0; + while(!end_of_cluster(cur_clus_idx)) { + readblock(clusteridx2datablkidx(cur_clus_idx), buf); + struct fat32_dir_entry *ent; + for(int i = 0; i < 16; i ++) { + ent = ((void*)(buf + 32 * i)); + if(*(uint64_t*)(ent) == 0) { + ent->attr = ATTR_ARCHIVE; + ent->beg_clus_l = f_cache->data_cluster_index & 0xffff; + ent->file_size = f_cache->filesize; + copy_name(ent, f_cache); + writeblock(clusteridx2datablkidx(cur_clus_idx), buf); + goto find; + } + } + cur_clus_idx = dir_cache->FAT[cnt ++]; + } + + struct fat32_file_cache tmp; + tmp.FAT_cnt = dir_cache->FAT_cnt; + tmp.FAT = dir_cache->FAT; + tmp.data_cluster_index = dir_cache->dir_clus_idx; + + // if not found, find a new fat table + // this implementation is not very good + // but I don't wanna spend more time on this + gen_new_fat(&(tmp), dir_cache->FAT_cnt + 1); + dir_cache->FAT_cnt = tmp.FAT_cnt; + dir_cache->FAT = tmp.FAT; + flush_new_fat(&(tmp)); + cur_clus_idx = tmp.FAT[tmp.FAT_cnt - 2]; + readblock(clusteridx2datablkidx(cur_clus_idx), buf); + + struct fat32_dir_entry *ent; + ent = buf; + ent->attr = ATTR_ARCHIVE; + ent->beg_clus_l = f_cache->data_cluster_index & 0xffff; + ent->beg_clus_h = (f_cache->data_cluster_index >> 16) & 0xffff; + ent->file_size = f_cache->filesize; + copy_name(ent, f_cache); + writeblock(clusteridx2datablkidx(cur_clus_idx), buf); + + find:; + flush_data(f_cache); + } + +} + +void fat32_sync() { + fat32_sync_dir(fat32_fs.root); +} \ No newline at end of file diff --git a/src/kernel/fs/tmpfs.c b/src/kernel/fs/tmpfs.c new file mode 100644 index 000000000..efa511de3 --- /dev/null +++ b/src/kernel/fs/tmpfs.c @@ -0,0 +1,224 @@ +#include "fs/vfs.h" +#include "fs/tmpfs.h" +#include "mem/mem.h" +#include "utils.h" + + +struct file tmpfs_filehandle[24]; +static uint8_t tmpfs_first_mount = 0; + +struct filesystem tmpfs = { + .name = "tmpfs", + .root = NULL, + .init_fs = &init_tmpfs, + .setup_mount = &mount_tmpfs +}; + +struct vnode_operations tmpfs_vnode_ops = { + .lookup = &tmpfs_lookup, + .create = &tmpfs_create, + .mkdir = &tmpfs_mkdir +}; + +struct file_operations tmpfs_file_ops = { + .write = &tmpfs_write, + .read = &tmpfs_read, + .open = &tmpfs_open, + .close = &tmpfs_close, + .lseek64 = &tmpfs_lseek64, + .stat = &tmpfs_stat, + .ioctl = &fops_not_support +}; + +int init_tmpfs(struct filesystem *fs) { + fs->root = (struct vnode*)kmalloc(sizeof(struct vnode)); + fs->root->v_ops = &tmpfs_vnode_ops; + fs->root->f_ops = &tmpfs_file_ops; + ds_list_head_init(&(fs->root->ch_list)); + ds_list_head_init(&(fs->root->v_head)); + fs->root->flag = VFS_DIR; + fs->root->mount = NULL; + fs->root->internal = (struct tmpfs_vinfo*)kmalloc(sizeof(struct tmpfs_vinfo)); + struct tmpfs_vinfo *info = fs->root->internal; + info->content = NULL; + strncpy((info->name), "/", 2); + info->namesize = 1; + return 0; +} + +int mount_tmpfs(struct filesystem *fs, struct mount *mnt) { + // general version of mount + + mnt->root = fs->root; + if(fs->root->mount == NULL) { + fs->root->mount = mnt; + } + + mnt->fs = fs; + if(tmpfs_first_mount == 0) { + for(int i = 0; i < 24; i ++) { + tmpfs_filehandle[i].flags = HANDLE_NOT_USED; + } + tmpfs_first_mount = 1; + } + return 0; +} + +int tmpfs_lookup(struct vnode* dir_node, struct vnode** target, const char * componenet_name) { + + struct ds_list_head *cur = dir_node->ch_list.next; + struct vnode* v; + struct tmpfs_vinfo *info; + while(cur != &(dir_node->ch_list)) { + v = container_of(cur, struct vnode, v_head); + info = v->internal; + if(strncmp(info->name, componenet_name, strlen(componenet_name)) == 0) { + *target = v; + return 0; + } + + cur = ds_list_front(cur); + if(cur == NULL) { + return VFS_NOT_FOUND; + } + } + return VFS_NOT_FOUND; +} + +struct vnode* new_tmpfs_node(const char *name, struct vnode *dir_node) { + struct vnode* ret = (struct vnode*)kmalloc(sizeof(struct vnode)); + + + if(dir_node != NULL) { + ret->f_ops = dir_node->f_ops; + ret->v_ops = dir_node->v_ops; + ret->parent = dir_node; + } else { + ret->f_ops = &tmpfs_file_ops; + ret->v_ops = &tmpfs_vnode_ops; + ret->parent = NULL; + } + + ret->mount = NULL; + ds_list_head_init(&(ret->ch_list)); + ds_list_head_init(&(ret->v_head)); + ret->internal = (struct tmpfs_vinfo*)kmalloc(sizeof(struct tmpfs_vinfo)); + struct tmpfs_vinfo *ptr = ret->internal; + int len = strlen(name); + memcpy(&(ptr->name), name, len); + ptr->namesize = len; + ptr->content = NULL; + ptr->filesize = 0; + ptr->name[len] = '\0'; + return ret; +} + + +int tmpfs_create(struct vnode* dir_node, struct vnode** target, const char *component_name) { + + struct vnode* ret; + int err = tmpfs_lookup(dir_node, &ret, component_name); + if(err == VFS_NOT_FOUND) { + ret = new_tmpfs_node(component_name, dir_node); + } else { + struct tmpfs_vinfo *info = ret->internal; + kfree(info->content); + info->filesize = 0; + info->content = NULL; + } + ds_list_addprev(&(dir_node->ch_list), &(ret->v_head)); + ret->parent = dir_node; + *target = ret; + return 0; +} + +int tmpfs_mkdir(struct vnode* dir_node, struct vnode** target, const char *componenet_name) { + struct vnode* ret = new_tmpfs_node(componenet_name, dir_node); + ret->flag = VFS_DIR; + ds_list_addprev(&(dir_node->ch_list), &(ret->v_head)); + ret->parent = dir_node; + + *target = ret; + return 0; +} + +void init_fs() { + register_filesystem(&tmpfs); + vfs_mount("/", "tmpfs"); + return; +} + + +int tmpfs_read(struct file* file, const void *buf, size_t len) { + struct vnode *vn = file->vnode; + struct tmpfs_vinfo *info = vn->internal; + + for(int i = 0; i < len; i ++, file->f_pos ++) { + if(file->f_pos == info->filesize) { + return i; + } + *(char *)(buf + i) = *(char *)(info->content + file->f_pos); + } + return len; +} + +int tmpfs_open(struct vnode* file_node, struct file** target) { + // uart_send_string("In tmpfs open\r\n"); + + + tmpfs_print_name(file_node); + for(int i = 0; i < 24; i ++) { + if(tmpfs_filehandle[i].flags == HANDLE_NOT_USED) { + tmpfs_filehandle[i].vnode = file_node; + tmpfs_filehandle[i].f_ops = &tmpfs_file_ops; + tmpfs_filehandle[i].f_pos = 0; + tmpfs_filehandle[i].flags = 0; + *(target) = &(tmpfs_filehandle[i]); + return i; + } + } + return -1; +} + +int tmpfs_close(struct file* file) { + file->flags = HANDLE_NOT_USED; + file->vnode = NULL; + return 0; +} + +long tmpfs_lseek64(struct file* file, long offset, int whence) { + return 0; +} + +int tmpfs_write(struct file *file, const void *buf, size_t len) { + struct vnode* vn = file->vnode; + struct tmpfs_vinfo *info = (struct tmpfs_vinfo*)file->vnode->internal; + if(info->content == NULL) { + info->content = (void*)cmalloc((1 << 12)); + } + + for(int j = 0; j < len; j ++, file->f_pos ++) { + if(file->f_pos == TMPFS_MAX_CONTENT_SIZE) { + return j; + } + *(char *)(info->content + file->f_pos) = *(char*)(buf + j); + if(info->filesize <= file->f_pos) { + info->filesize = file->f_pos + 1; + } + } + return len; +} + +void tmpfs_print_name(struct vnode* node) { + struct tmpfs_vinfo *info = node->internal; + + uart_send_string(info->name); + uart_send_string("\r\n"); +} + +int tmpfs_stat(struct file *f, struct fstat *stat) { + struct tmpfs_vinfo *info = f->vnode->internal; + (stat)->filesize = info->filesize; + (stat)->namesize = info->namesize; + return 0; +} \ No newline at end of file diff --git a/src/kernel/fs/vfs.c b/src/kernel/fs/vfs.c new file mode 100644 index 000000000..d791674bd --- /dev/null +++ b/src/kernel/fs/vfs.c @@ -0,0 +1,308 @@ +#include "fs/vfs.h" +#include "mem/mem.h" +#include "utils.h" +#include "ds/list.h" +#include "interrupt.h" +#include "peripherals/mini_uart.h" +#include "process.h" + + +struct mount* rootfs; +struct ds_list_head fs_list; +void vfs_init(){ + rootfs = NULL; + ds_list_head_init(&fs_list); + return; +} + +struct vnode* get_parent_vnode(struct vnode* node) { + return node->parent; +} + +struct filesystem *find_fs_by_name(const char *name) { + // struct ds_list_head *head = ds_list_front(&fs_list); + struct ds_list_head *head = fs_list.next; + // if(head == NULL) { + // return NULL; + // } + while(head != &fs_list) { + struct filesystem *fs = container_of(head, struct filesystem, fs_head); + // uart_send_string(fs->name); + if(strncmp(name, fs->name, strlen(fs->name)) == 0) { + return fs; + } + head = ds_list_front(head); + if(head == NULL) { + return NULL; + } + } + return NULL; +} + +int register_filesystem(struct filesystem* fs) { + + struct filesystem *same = find_fs_by_name(fs->name); + if(same == NULL) { + if(fs->init_fs != NULL) { + fs->init_fs(fs); + } + ds_list_head_init(&(fs->fs_head)); + ds_list_addprev(&fs_list, &(fs->fs_head)); + return 0; + } else { + return VFS_NOT_FOUND; + } +} + + +// this is very bad implementation +// can only fit comp[20][20] array +int split_path(const char* pathname, char comp[][20]) { + + int len = strlen(pathname); + int beg = 0; + int end = 0; + int idx = 0; + + for(int i = 0; i < len; i ++) { + if(pathname[i] == '/') { + end = i; + if(end - beg > 0) { + memcpy(comp[idx], pathname + beg, end - beg); + comp[idx][end - beg] = '\0'; + idx ++; + } + beg = i + 1; + } + } + char *ptr = comp[idx]; + if(len != beg) { + memcpy(ptr, pathname + beg, len - beg); + *(char *)(ptr + len - beg) = '\0'; + idx += 1; + } + return idx; +} + + +int vfs_lookup(const char* pathname, struct vnode** target) { + + + + struct vnode* vnode_itr; + + if(pathname[0] == '/') { + // uart_send_string("From root\r\n"); + vnode_itr = rootfs->root; + } else { + struct Process_t *proc = process_get_current(); + vnode_itr = proc->cur_vnode; + } + + char comp[20][20]; + + int num = split_path(pathname, &comp); + *target = NULL; + + for(int i = 0; i < num; i ++) { + // uart_send_string(comp[i]); + // int x = strncmp(comp[i], "..", 2); + // uart_send_dec(x); + if(strncmp(comp[i], "..", 2) == 0) { + vnode_itr = vnode_itr->parent; + continue; + } else if(strncmp(comp[i], ".", 1) == 0) { + continue; + } + struct vnode* next_vnode; + // uart_send_u64(vnode_itr); + // uart_send_string("before this\r\n"); + struct vnode* ret = vnode_itr->v_ops->lookup(vnode_itr, &next_vnode, comp[i]); + // uart_send_string("After this\r\n"); + if(ret != 0) { + // if this is last one + if(i == num - 1) { + *target = vnode_itr; + return VFS_CAN_CREATE; + } + return ret; + } + if(next_vnode->mount != NULL) { + // uart_send_string("Jump to mounted vnode \r\n"); + // uart_send_u64(next_vnode->mount->root); + // uart_send_string("\r\n"); + vnode_itr = next_vnode->mount->root; + } else { + vnode_itr = next_vnode; + } + } + + *target = vnode_itr; + return 0; +} + +// api spec: +// different filesystem should provide its own root vnode. +int vfs_mount(const char *target, const char *filesystem) { + // uart_send_string(target); + // uart_send_string("\r\n"); + // uart_send_string(filesystem); + // uart_send_string("\r\n"); + struct filesystem* fs = find_fs_by_name(filesystem); + if(fs == NULL) { + // uart_send_string(filesystem); + // uart_send_string(" not found\r\n"); + return VFS_NOT_FOUND; + } + if(rootfs == NULL) { + rootfs = (struct mount *)kmalloc(sizeof(struct mount)); + rootfs->mountpoint = NULL; + int err = fs->setup_mount(fs, rootfs); + rootfs->root->parent = rootfs->root; + return err; + } else { + struct vnode *v; + int err = vfs_lookup(target, &v); + if(v->flag != VFS_DIR) { + return VFS_NOT_DIR; + } + + if(v->mount != NULL) { + return VFS_MOUNTED; + } + if(err) { + // uart_send_string("Error when mounting\r\n"); + return err; + } + v->mount = (struct mount *)kmalloc(sizeof(struct mount)); + err = fs->setup_mount(fs, v->mount); + if(err == 0) { + if(v->mount == fs->root->mount) { + v->mount->root->parent = v->parent; + v->mount->mountpoint = v; + } + } + return err; + } +} + +int vfs_open(const char* pathname, int flags, struct file** target) { + // 1. Lookup pathname + // 2. Create a new file handle for this vnode if found. + // 3. Create a new file if O_CREAT is specified in flags and vnode not found + // lookup error code shows if file exist or not or other error occurs + // 4. Return error code if fails + // uart_send_string("OPening flags\r\n"); + // uart_send_dec(flags); + // uart_send_string("\r\n"); + struct vnode *v; + // uart_send_string("hello\r\n"); + int err = vfs_lookup(pathname, &v); + char comp[20][20]; + // uart_send_string("hello\r\n"); + int num = split_path(pathname, comp); + if(err) { + if(err == VFS_CAN_CREATE && (flags & O_CREAT)) { + struct vnode *tmpv = v; + err = tmpv->v_ops->create(tmpv, &v, comp[num - 1]); + if(err) { + return err; + } + } else { + return err; + } + } else { + if(flags & O_CREAT) { + struct vnode *tmpv = v; + err = tmpv->parent->v_ops->create(tmpv->parent, &v, comp[num - 1]); + if(err) { + return err; + } + } + } + int fd = v->f_ops->open(v, target); + if(fd > 0) { + (*target)->flags = flags; + return 0; + } + return fd; +} + +int vfs_close(struct file* file) { + // 1. release the file handle + // 2. Return error code if fails + return file->f_ops->close(file); +} + +int vfs_write(struct file* file, const void* buf, size_t len) { + return file->f_ops->write(file, buf, len); +} + +int vfs_read(struct file* file, void* buf, size_t len) { + return file->f_ops->read(file, buf, len); +} + +void vfs_apply_dir(struct vnode* dir_node, apply_dir_func func) { + struct ds_list_head *head = ds_list_front(&(dir_node->ch_list)); + if(head == NULL) { + return; + } + + while(head != &(dir_node->ch_list)) { + struct vnode* node = container_of(head, struct vnode, v_head); + func(node); + head = ds_list_front(head); + } +} + +int vfs_create(const char *pathname, int flags, struct vnode** target) { + struct vnode *ret; + int err = vfs_lookup(pathname, &ret); + + + if(err == 0) { + *(target) = ret; + return VFS_EXIST; + } else if(err == VFS_CAN_CREATE) { + char comp[20][20]; + int num = split_path(pathname, comp); + struct vnode *tmpret = ret; + err = tmpret->v_ops->create(tmpret, &ret, comp[num - 1]); + *(target) = ret; + return err; + } else { + return err; + } +} + +int vfs_mkdir(const char *pathname) { + + struct vnode *v; + + int err = vfs_lookup(pathname, &v); + if(err == 0) { + return VFS_EXIST; + } else if(err == VFS_CAN_CREATE) { + char comp[20][20]; + int num = split_path(pathname, comp); + err = v->v_ops->mkdir(v, &v, comp[num - 1]); + return err; + } else { + return err; + } +} + +int vfs_stat(struct file *f, struct fstat *stat) { + return f->f_ops->stat(f, stat); +} + +int vops_not_support() { + return VFS_NOT_SUPPORT; +} +int fops_not_support() { + return VFS_NOT_SUPPORT; +} + +int vfs_lseek64(struct file *f, long offset, int whence) { + return f->f_ops->lseek64(f, offset, whence); +} \ No newline at end of file diff --git a/src/kernel/interrupt.c b/src/kernel/interrupt.c index 9b358034e..acf573900 100644 --- a/src/kernel/interrupt.c +++ b/src/kernel/interrupt.c @@ -7,11 +7,14 @@ #include "time.h" #include "type.h" #include "event.h" +#include "thread.h" +#include "process.h" +#include "syscall.h" #define IRQ_BASIC_PENDING (PBASE + 0xB200) #define IRQ_GPU_PENDING1 (PBASE + 0xB204) #define IRQ_GPU_PENDING2 (PBASE + 0xB208) -#define CORE_IRQ_SOURCE (0x40000060) +#define CORE_IRQ_SOURCE (0xffff000040000060) #define GPU_INTERRUPT (0x100) #define AUX_INT (1 << 29) @@ -21,7 +24,6 @@ extern struct k_event demo_timer_event; int demo_state = 0; void irqhandler_inc() { - // asm volatile ("msr DAIFSet, 0xf\n"); int flag = interrupt_disable_save(); interrupt_handler_counter += 1; interrupt_enable_restore(flag); @@ -37,15 +39,10 @@ int irqhandler_cnt_get() { } void enable_interrupt() { - interrupt_counter -= 1; - if(interrupt_counter < 0) interrupt_counter = 0; - if(interrupt_counter == 0) { - asm volatile ("msr DAIFClr, 0xf\n"); - } + asm volatile ("msr DAIFClr, 0xf\n"); } void disable_interrupt() { asm volatile ("msr DAIFSet, 0xf\n"); - interrupt_counter += 1; } void exception_entry(unsigned long esr, unsigned long elr, unsigned long spsr) { @@ -60,18 +57,19 @@ void exception_entry(unsigned long esr, unsigned long elr, unsigned long spsr) { uart_send_u64(spsr); uart_send_string("\r\n"); uart_switch_func(UART_ASYNC); + while(1) { + asm volatile("nop\n"); + } return; } -void time_interrupt_handler() { +void time_interrupt_handler(struct Trapframe_t *frame) { struct k_timeout *t; uint64_t tick; while(1) { - // uart_send_string("xxxx\r\n"); asm volatile("mrs %0, cntpct_el0\n":"=r"(tick)); t = k_timeout_queue_front(); if(t == NULL) { - uint64_t x = 0x3f3f3f3fLL; asm volatile( "ldr x0, =0xffffffffff\n" "msr cntp_cval_el0, x0\n" @@ -90,6 +88,7 @@ void time_interrupt_handler() { break; } } + handle_time_schedule(frame); } void uart_handler() { @@ -97,8 +96,8 @@ void uart_handler() { if(pending & AUX_INT) { unsigned int IER_REG = *(volatile unsigned int*)(AUX_MU_IER_REG); if(IER_REG & 1) { + // only recv can delay the work irqhandler_inc(); - // uart_send_dec(irqhandler_cnt_get()); uart_int_recv_handler(); } if(IER_REG & 2) { @@ -106,26 +105,32 @@ void uart_handler() { } } } -void spx_irq_handler(unsigned long esr, unsigned long elr, unsigned long spsr) { +void spx_irq_handler(struct Trapframe_t *frame, uint64_t esr) { unsigned int pending = read_reg_32(CORE_IRQ_SOURCE); - if(pending & 0x2) { - time_interrupt_handler(); - } if(pending & GPU_INTERRUPT) { + uart_handler(); } + else if(pending & 0x2) { + time_interrupt_handler(frame); + } + else { + // uint64_t dfsr_value; + // asm volatile ("mrs %0, dfsr_el1" : "=r" (dfsr_value)); + + } + return; } -void lower_irq_handler(unsigned long esr, unsigned long elr, unsigned long spsr) { +void lower_irq_handler(struct Trapframe_t *frame) { unsigned int pending = read_reg_32(CORE_IRQ_SOURCE); if(pending & GPU_INTERRUPT) { uart_handler(); } - if(pending & 0x2) { - irqhandler_inc(); - demo_state = 1; - k_event_submit(&demo_timer_event, NULL, 0, 100); + else if(pending & 0x2) { + + time_interrupt_handler(frame); } return; } @@ -145,4 +150,60 @@ uint64_t interrupt_disable_save() { "msr DAIFSet, 0xf\n" ); return flag; +} + + +struct Trapframe_t anoFrame; +void svc_handler(struct Trapframe_t *frame) { + if(frame->esr_el1 >> 26 == 0b010101) { + // memcpy(&anoFrame, frame, sizeof(struct Trapframe_t)); + uint16_t svcnum = frame->esr_el1 & 0xffff; + if(svcnum == 0) { + syscall_handler(frame); + } + // for(int i = 0; i < sizeof(struct Trapframe_t) >> 3; i ++) { + // if(*((uint64_t*)(&anoFrame) + i) != *((uint64_t*)(frame) + i)) { + // uart_switch_func(UART_DEFAULT); + // // uart_send_string("fucked\r\n"); + // uart_send_string("In i = "); + // uart_send_dec(i); + // uart_send_string("\r\n"); + // uart_switch_func(UART_ASYNC); + // } + // } + } else { + // uart_switch_func(UART_DEFAULT); + // uart_send_string("\r\nOther interrupt\r\n"); + // // uart_send_u64(frame->esr_el1); + // // uart_send_string("\r\n"); + // // uart_send_u64(frame->elr_el1); + // uart_send_u64(thread_get_current_instance()->tid); + // uart_send_string("\r\n"); + // // } + // uart_switch_func(UART_ASYNC); + } +} + +uint64_t check_exception_depth() { + struct Thread_t *th = thread_get_current_instance(); + uint64_t sp; + uint64_t lr; + asm volatile( + "mov x0, sp\n" + "mov %[sp], x0\n" + "mrs %[lr], elr_el1\n":[sp]"=r"(sp), [lr]"=r"(lr) + ); + uint64_t val = ((uint64_t)th->sp - sp) / (32 * 9); + // if(th->sp < sp) { + // uart_switch_func(UART_DEFAULT); + // uart_send_string("Except Fucked\r\n"); + // uart_send_u64(th->sp); + // uart_send_string("\r\n"); + // uart_send_u64(sp); + // uart_send_string("\r\n"); + // uart_send_u64(lr); + // uart_send_string("\r\n"); + // uart_switch_func(UART_ASYNC); + // } + return val; } \ No newline at end of file diff --git a/src/kernel/kernel_main.c b/src/kernel/kernel_main.c index e931ca1b9..a5b954c48 100644 --- a/src/kernel/kernel_main.c +++ b/src/kernel/kernel_main.c @@ -2,6 +2,7 @@ #include "mbox/mbox.h" #include "power.h" #include "utils.h" +#include "ds/list.h" #include "cpio/cpio.h" #include "dtb/dtb.h" #include "mem/mem.h" @@ -10,7 +11,17 @@ #include "ds/heap.h" #include "test/demo.h" #include "mem/page.h" - +#include "process.h" +#include "thread.h" +#include "mmu/mmu.h" +#include "fs/tmpfs.h" +#include "fs/vfs.h" +#include "framebuffer.h" +#include "sd.h" +#include "fs/fat32.h" + +extern struct Trapframe_t *gen_trapframe(); +extern struct ds_list_head process_list; #define SHELL_BUFSIZE 64 #define REPLY_BUFSIZE 128 @@ -95,7 +106,7 @@ unsigned int _info_cb(char *arg) { uart_send_u32(mbox_buf[5]); uart_send_string("\r\n"); } else { - uart_send_string("Error when gather info!!\r\n"); + uart_send_string("Error when gather info!!\r\n"); } mbox_buf[0] = 8 * 4; mbox_buf[1] = 0; @@ -113,7 +124,7 @@ unsigned int _info_cb(char *arg) { uart_send_u32(mbox_buf[6]); uart_send_string("\r\n"); } else { - uart_send_string("Error when gather info!!\r\n"); + uart_send_string("Error when gather info!!\r\n"); } return 0; } @@ -125,17 +136,36 @@ unsigned int _reboot_cb(char *arg) { } unsigned int _ls_cb(char *arg) { - list_files(); + // list_files(); + struct Process_t *cur_proc = process_get_current(); + vfs_apply_dir(cur_proc->cur_vnode, &tmpfs_print_name); return 0; } unsigned int _cat_cb(char *arg) { - cat_file(arg); - return 0; + // cat_file(arg); + + struct file *f; + // uart_send_string(arg); + int err = vfs_open(arg, O_READ, &f); + + char _buf[100]; + int n; + if(err == 0) { + while(n = vfs_read(f, _buf, 100)) { + uart_send_n(_buf, n); + } + vfs_close(f); + } else { + uart_send_dec(-err); + uart_send_string("Error when opening the file\r\n"); + return err; + } } unsigned int _load_cb(char *arg) { load_program(arg); + // process_load(arg); return 0; } @@ -170,26 +200,143 @@ unsigned int _test_uart_cb(char *arg) { } return 0; } -void *ptr[128]; -static unsigned int k_malloc_cnt = 0; -unsigned int str_to_int(char *arg) { - unsigned int ret = 0; - while(*arg != '\0') { - if(*arg >= '0' && *arg <= '9') { - ret = ret * 10 + (*arg - '0'); +void _test_thread_get_current() { + return; + // uart_send_u64(thread_get_current()); +} +void _test_thread_set_current() { + asm volatile( + "mov x0, 1\n" + "msr tpidr_el1, x0\n" + ); +} + +void foo() { + for(int i = 0; i < 10; i ++) { + uart_send_string("Thread id: "); + uart_send_dec(thread_get_current()); + uart_send_string(" "); + uart_send_dec(i); + uart_send_string("\r\n"); + delay(1000000); + schedule(0); + } + return; +} + +static void _test_thread() { + int N = 3; + for(int i = 0; i < N; ++i) { // N should > 2 + thread_create(foo, NULL); + } + schedule(0); +} + +static void _test_fork() { + // uint64_t n = process_fork(); + // if(n == 0) { + // while(1) { + // asm volatile("nop"); + // } + // } + asm volatile( + "mov x8, 4\n" + "svc 0\n" + ); + uint64_t pid; + asm volatile( + "mov %[pid], x0":[pid]"=r"(pid) + ); + if(pid == 0) { + uart_send_string("after fork\r\n"); + while(1) { + asm volatile("nop"); + } + } + // uart_send_string("What happen\r\n"); + // while(1){ + // schedule(0); + // } +} +unsigned int _touch(char *arg) { + // cat_file(arg); + // struct file *f; + struct vnode* target; + int err = vfs_create(arg, O_CREAT, &target); + + // int err = vfs_open(arg, O_CREAT, &f); + // err = vfs_close(f); + // uart_send_dec(err); + return 0; +} +unsigned int _open(char *arg) { + struct file *f; + int err = vfs_open(arg, O_READ, &f); + uart_send_dec(err); + return 0; +} +unsigned int _test_write(char *arg) { + struct file *f; + int err = vfs_open(arg, O_WRITE, &f); + char _buf[] = "TETSTING WRITE\r\n"; + if(err == 0) { + for(int i = 0; i < 10; i ++) { + err = vfs_write(f, _buf, strlen(_buf)); + if(err < 0) { + uart_send_string("Error when writing\r\n"); + } } - arg ++; + err = vfs_close(f); + if(err < 0) { + uart_send_string("Error when closing\r\n"); + } + } else { + uart_send_string("Error when opening file\r\n"); } - return ret; } -unsigned int _kmalloc(char *arg) { - uart_send_string(arg); - uint32_t sz = str_to_int(arg); - ptr[++k_malloc_cnt] = kmalloc(sz); +unsigned int _test_read(char *arg) { + struct file *f; + int err = vfs_open(arg, O_READ, &f); + char _buf[10]; + if(err == 0) { + int n = vfs_read(f, _buf, 5); + while(n > 0) { + uart_send_n(_buf, n); + n = vfs_read(f, _buf, 5); + } + err = vfs_close(f); + if(err < 0) { + uart_send_string("Error when closing\r\n"); + } + } else { + uart_send_string("Error when opening file\r\n"); + } +} +unsigned int _mkdir(char *arg) { + int err = vfs_mkdir(arg); + if(err) { + uart_send_string("Error happen when creating dir\r\n"); + } + return 0; } -unsigned int _kfree(char *arg) { - unsigned int x = str_to_int(arg); - kfree(ptr[x]); + +unsigned int _cd(char *arg) { + struct vnode *dir; + int err = vfs_lookup(arg, &dir); + + if(err != 0) { + uart_send_string("Error when switching directory\r\n"); + } else { + struct Process_t *proc = process_get_current(); + proc->cur_vnode = dir; + proc->mnt = dir->mount; + } +} +unsigned int _mount(char *arg) { + char *mntpoint, *fsname; + split_comm_arg(arg, &mntpoint, &fsname); + // vfs_mkdir(mntpoint); + vfs_mount(mntpoint, fsname); } struct CmdNode cmds[] = { { @@ -199,7 +346,7 @@ struct CmdNode cmds[] = { { .comm = "help", .cb = _help_cb - }, + }, { .comm = "info", .cb = _info_cb @@ -211,7 +358,7 @@ struct CmdNode cmds[] = { { .comm = "ls", .cb = _ls_cb - }, + }, { .comm = "cat", .cb = _cat_cb @@ -235,11 +382,11 @@ struct CmdNode cmds[] = { { .comm = "setTimeout", .cb = _setTimeout_cb - }, + }, { .comm = "demo_page", .cb = demo_page - }, + }, { .comm = "test_simple_alloc", .cb = test_simple_alloc @@ -253,22 +400,69 @@ struct CmdNode cmds[] = { .cb = test_kmalloc }, { - .comm = "kmalloc", - .cb = _kmalloc + .comm = "get_t", + .cb = _test_thread_get_current + }, { + .comm = "set_t", + .cb = _test_thread_set_current + }, + { + .comm = "sched", + .cb = schedule + }, + { + .comm = "test_thread", + .cb = _test_thread + }, + { + .comm = "test_fork", + .cb = _test_fork + }, + { + .comm = "touch", + .cb = _touch + }, + { + .comm = "test_write", + .cb = _test_write + }, + { + .comm = "test_read", + .cb = _test_read }, { - .comm = "kfree", - .cb = _kfree + .comm = "open", + .cb = _open + }, + { + .comm = "mkdir", + .cb = _mkdir + }, + { + .comm = "cd", + .cb = _cd + }, + { + .comm = "mount", + .cb = _mount + }, + { + .comm = "sync", + .cb = fat32_sync } + // { + // .comm = "close", + // .cb = _close + // } }; - - - int handle_input(char *buf) { // uart_send_string(buf); int tot_len = strlen(buf); + if(tot_len == 0) { + return 0; + } // discard tailing space while(tot_len && buf[tot_len - 1] <= ' ') { buf[tot_len - 1] = '\0'; @@ -311,9 +505,7 @@ const char shell_beg[] = "______________________\r\n" void get_initramfs_addr(char *name, char *prop_name, char *data) { if(strncmp(name, "chosen", 6) == 0) { if(strncmp(prop_name, "linux,initrd-start", 18) == 0) { - unsigned long long x = ntohi(*(unsigned int*)(data)); - set_initramfs_addr(x); - memory_reserve(x, x + 0x10000); + set_initramfs_addr(ntohi(*(unsigned int*)(data))); } } } @@ -322,28 +514,8 @@ void print_msg(void *arg) { uart_send_string(arg); } -void kernel_main(void* dtb_addr) { - // uart_send_string("fucked\r\n"); - smem_init(); - fdt_param_init(dtb_addr); - k_event_queue_init(); - demo_init(); - uart_init(); - k_timeout_init(&msg, &print_msg); - enable_interrupt(); - enable_aux_interrupt(); - // frame_init(0x3c000000); - fdt_traverse(&set_init_mem_region); - kmalloc_init(); - // memory_reserve(0, 0x10000000); - memory_reserve(0, 0x1000); - memory_reserve(0x80000, 0x150000); - memory_reserve(dtb_addr, dtb_addr + 40000); - fdt_traverse(&get_initramfs_addr); - uart_send_string(shell_beg); - uart_send_string("# "); - - +void shell() { + // uart_send_string("Inside SHELL\r\n"); char cur; char *buf = simple_malloc(256); @@ -351,7 +523,8 @@ void kernel_main(void* dtb_addr) { int idx = 0; memset(buf, 0, 64); while(1) { - cur = uart_recv(); + // cur = uart_recv(); + uint32_t n = async_uart_rx_buf(&cur, 1); if(cur == 255) continue; if(cur == 127 || cur == 8) { if(idx == 0) continue; @@ -378,5 +551,74 @@ void kernel_main(void* dtb_addr) { buf[idx++] = cur; if(idx == 63) idx = 0; uart_send(cur); + // schedule(); } } + +extern struct Process_t init_process; +void go_el0() { + // uint64_t x, y, z; + // asm volatile( + // // "mrs x10, sp_el0\n" + // "mov %0, lr\n":"=r"(x) + // ); + // uart_send_u64(x); + // uart_send_string("\r\n"); + asm volatile( + "mov x10, 0x340\n" + "msr spsr_el1, x10\n" + "mov x10, lr\n" + "msr elr_el1, x10\n" + "eret\n" + ); +} +void kernel_main(void* dtb_addr) { + // uart_send_string("fucked\r\n"); + smem_init(); + fdt_param_init(dtb_addr); + k_event_queue_init(); + demo_init(); + uart_init(); + k_timeout_init(&msg, &print_msg); + kmalloc_init(); + memory_reserve(0 + KERNEL_SPACE_OFFSET, 0x15000000 + KERNEL_SPACE_OFFSET); + memory_reserve(0x20000000 + KERNEL_SPACE_OFFSET, 0x21000000 + KERNEL_SPACE_OFFSET); + memory_reserve(0x2f000000 + KERNEL_SPACE_OFFSET, 0x2f100000 + KERNEL_SPACE_OFFSET); + memory_reserve(0x3a000000 + KERNEL_SPACE_OFFSET, 0x3c000000 + KERNEL_SPACE_OFFSET); + fdt_traverse(&get_initramfs_addr); + fdt_traverse(&set_init_mem_region); + enable_interrupt(); + uart_switch_func(UART_DEFAULT); + enable_aux_interrupt(); + vfs_init(); + init_fs(); + uart_switch_func(UART_ASYNC); + mount_initramfs(); + thread_control_init(); + process_control_init(); + uart_send_string(shell_beg); + uart_send_string("# "); + + vfs_mkdir("/dev"); + vfs_mkdir("/tmp"); + setup_dev_uart(); + setup_dev_framebuffer(); + + sd_init(); + + + setup_boot(); + + struct Process_t *shell_proc = create_process_instance(); + shell_proc->ttbr0_el1 = 0x1000; + memcpy(shell_proc->name, "shell", 6); + + struct Thread_t *th = process_thread_create(shell, NULL, shell_proc, 1); + + // struct ds_list_head *front = ds_list_front(&(process_list)); + // while(front != &(process_list)) { + // struct Process_t *proc = container_of(front, struct Process_t, pl_head); + // front = ds_list_front(front); + // } + schedule_init(); +} diff --git a/src/kernel/linker.ld b/src/kernel/linker.ld index 9db0109b2..a6740ec6c 100644 --- a/src/kernel/linker.ld +++ b/src/kernel/linker.ld @@ -1,7 +1,8 @@ ENTRY(_start) SECTIONS { - . = 0x80000; + . = 0xffff000000000000; + . += 0x80000; .text.boot : { *(.text.boot*) } .text : { *(.text*) } .rodata : { *(.rodata*) } @@ -11,7 +12,7 @@ SECTIONS .bss : { *(.bss*) } . = ALIGN(0x10); _bss_end = .; - _stack_begin = 0x98000; - _heap_begin = . + 0x1000; - _heap_end = . + 0x1010000; + _stack_begin = 0xffff000000380000; + _heap_begin = 0xffff000000380000; + _heap_end = 0xffff000001010000; } \ No newline at end of file diff --git a/src/kernel/lock.c b/src/kernel/lock.c index 213e9aa69..f31295a62 100644 --- a/src/kernel/lock.c +++ b/src/kernel/lock.c @@ -11,7 +11,11 @@ struct k_lock* k_lock_new() { void k_lock_get(struct k_lock *lock) { uint64_t flag = interrupt_disable_save(); - while(lock->lock){asm volatile("nop");} + while(lock->lock){ + enable_interrupt(); + // asm volatile("nop"); + } + disable_interrupt(); lock->lock = 1; interrupt_enable_restore(flag); } diff --git a/src/kernel/mbox.c b/src/kernel/mbox.c index 533dbadd2..2a1b98a21 100644 --- a/src/kernel/mbox.c +++ b/src/kernel/mbox.c @@ -1,8 +1,10 @@ #include "mbox/mbox.h" #include "utils.h" #include "peripherals/mini_uart.h" +#include "mem/mem.h" +#include "mmu/mmu.h" -volatile unsigned int mbox_buf[16]__attribute__((aligned(16))); +volatile unsigned int mbox_buf[256]__attribute__((aligned(16))); int mbox_call_func(unsigned char prop_tag) { @@ -21,8 +23,35 @@ int mbox_call_func(unsigned char prop_tag) { break; } } + if(addr == read_reg_32(MAIL_READ)) { return mbox_buf[1] == MAIL_RESPONSE; } } } + +int mbox_call(unsigned char prop_tag, unsigned int *buf) { + + memcpy(&mbox_buf, buf, (size_t)buf[0]); + unsigned int addr = (((unsigned long)kernel_va2pa(mbox_buf)) & (~(0xF))) | prop_tag; + while(1) { + if((read_reg_32(MAIL_STATUS) & MAIL_FULL) == 0) { + break; + } + } + write_reg_32(MAIL_WRITE, addr); + + //fill mbox request + while(1) { + while(1) { + if((read_reg_32(MAIL_STATUS) & MAIL_EMPTY) == 0) { + break; + } + } + if(addr == read_reg_32(MAIL_READ)) { + + memcpy(buf, &mbox_buf, (size_t)mbox_buf[0]); + return buf[1] == MAIL_RESPONSE; + } + } +} \ No newline at end of file diff --git a/src/kernel/mem/mem.c b/src/kernel/mem/mem.c index c11a5488d..983a8e35a 100644 --- a/src/kernel/mem/mem.c +++ b/src/kernel/mem/mem.c @@ -8,6 +8,9 @@ #define SMALL_CHUNK_MAX_ORDER (PAGE_SIZE_ORDER) #define SMEM_CHUNK_MAX 31 #define ALLOC_MIN_ORD 5 +#define MIN_FREE_PAGE_CNT 20 + +// #define MEM_DEMO extern uint32_t _heap_begin; void* cur_mem_offset = &_heap_begin; @@ -49,9 +52,7 @@ void smem_init() { void *simple_malloc(uint32_t size) { // pad to align 8 bytes - // uint32_t offset = ((((size & 0x7) ^ 0x7) + 1) & 0x7) + size; - // cur_mem_offset += offset; - // return (cur_mem_offset - offset); + uint32_t flag = interrupt_disable_save(); uint8_t ord = size2ord(size); if(ord < 5) { @@ -87,7 +88,6 @@ void simple_free(void *ptr) { void kmalloc_init() { - // frame_init(); for(int i = 0; i < SMALL_CHUNK_MAX_ORDER + 1; i ++) { ds_list_head_init(&(kmem_pool[i])); } @@ -112,8 +112,9 @@ void *kmalloc(uint32_t size) { if(size == 0){ goto _r; } + void *ret; - if(size > (PAGE_SIZE >> 1)) { + if(size >= (PAGE_SIZE >> 1)) { ret = page_alloc(size); goto _r; } @@ -128,8 +129,7 @@ void *kmalloc(uint32_t size) { front = ds_list_front(&(ent->chunk_head)); struct kmem_node *node = container_of(front, struct kmem_node, head); ret = node->addr; - // uart_send_u64(ret); - // uart_send_string("\r\n"); + // remove from page pool ds_list_remove(&(node->head)); ent->dyn_count -= 1; @@ -154,7 +154,7 @@ void *kmalloc(uint32_t size) { init_page_chunk(ptr, ent, ord); #ifdef MEM_DEMO uart_send_string("\r\n"); - uart_send_string("Small Chunk new Base"); + uart_send_string("Small Chunk new Base\r\n"); uart_send_u64(ptr); uart_send_string("\r\n"); uart_send_u64(ent); @@ -169,6 +169,14 @@ void *kmalloc(uint32_t size) { } _r: interrupt_enable_restore(flag); + #ifdef MEM_DEMO + uart_send_string("size = "); + uart_send_dec(size); + uart_send_string("\r\n"); + uart_send_string("ret = "); + uart_send_u64(ret); + uart_send_string("\r\n"); + #endif return ret; } @@ -184,6 +192,12 @@ void free_chunk(struct frame_entry *ent) { } void kfree(void *ptr) { + #ifdef MEM_DEMO + uart_send_string("kfree ptr = "); + uart_send_u64(ptr); + uart_send_string("\r\n"); + #endif + if(ptr == NULL) return; uint32_t flag = interrupt_disable_save(); struct frame_entry *ent = get_entry_from_addr(ptr); // We does not handle the address freed is not valid @@ -195,10 +209,14 @@ void kfree(void *ptr) { } ent->dyn_count += 1; if(ent->dyn_count == (1 << (PAGE_SIZE_ORDER - ord))) { - ds_list_remove(&(ent->head)); - free_chunk(ent); - page_free((uint64_t)ptr & (~((1LL << PAGE_SIZE_ORDER) - 1))); - goto _r; + if(ent->used_cnt < MIN_FREE_PAGE_CNT) { + ent->used_cnt += 1; + } else { + ds_list_remove(&(ent->head)); + free_chunk(ent); + page_free((uint64_t)ptr & (~((1LL << PAGE_SIZE_ORDER) - 1))); + goto _r; + } } // need to add back the frame entry to kmem_pool struct kmem_node *node = simple_malloc(sizeof(struct kmem_node)); @@ -224,4 +242,15 @@ void set_init_mem_region(char *name, char *prop_name, char *data) { frame_init(sz); } } +} +void *cmalloc(uint32_t size) { + void *ret = kmalloc(size); + for(uint32_t k = 0; k < (size >> 3); k ++) { + *((uint64_t*)(ret) + k) = 0; + } + uint32_t tmp = ((size >> 3) << 3); + for(int i = tmp; i < size; i ++) { + *(char *)(ret + i) = 0; + } + return ret; } \ No newline at end of file diff --git a/src/kernel/mem/page.c b/src/kernel/mem/page.c index 453b2103c..7ce24c8c3 100644 --- a/src/kernel/mem/page.c +++ b/src/kernel/mem/page.c @@ -5,11 +5,12 @@ #include "utils.h" #include "peripherals/mini_uart.h" #include "dtb/dtb.h" +#include "mmu/mmu.h" -#define MEM_DEMO // #define ENTRY_NUM (PAGE_END - PAGE_BEGIN) / PAGE_SIZE +// #define MEM_DEMO 1 // struct frame_entry entry[ENTRY_NUM]; struct ds_list_head frame_list[PAGE_MAX_ORDER + 1]; @@ -36,7 +37,7 @@ uint64_t order_to_size(uint8_t order) { } static uint32_t addr2idx(uint64_t addr, uint64_t base) { - return (addr - base) >> PAGE_SIZE_ORDER; + return ((addr - base) >> PAGE_SIZE_ORDER); } static uint64_t idx2addr(uint32_t idx, uint64_t base) { @@ -45,8 +46,11 @@ static uint64_t idx2addr(uint32_t idx, uint64_t base) { struct frame_entry* get_entry_from_addr(void *ptr) { uint64_t addr = (uint64_t)ptr; + + for(struct ds_list_head *head = mem_list.next; head != &mem_list; head = head->next) { struct mem_region *region = container_of(head, struct mem_region, head); + if(addr >= region->begin_addr && addr <= region->begin_addr + region->size) { uint64_t idx = addr2idx(addr, region->begin_addr); return &(region->entries[idx]); @@ -59,17 +63,21 @@ void init_mem_region(struct mem_region* ptr, uint64_t begin, uint64_t end) { uint8_t ord = 0; while(ptr->size >> ord) { ord += 1; - if(ord > PAGE_MAX_ORDER + PAGE_SIZE_ORDER)break; + if(ord > (PAGE_MAX_ORDER + PAGE_SIZE_ORDER))break; } ord -= 1; + if((begin & ((1 << ord) - 1)) || (end & ((1 << ord) - 1))) { + ord -= 1; + } + ptr->max_ord = ord - PAGE_SIZE_ORDER; } void frame_init(uint64_t full_sz) { struct mem_region *new_region = simple_malloc(sizeof(struct mem_region)); - init_mem_region(new_region, 0x0, full_sz); + init_mem_region(new_region, 0x0 + KERNEL_SPACE_OFFSET, full_sz + KERNEL_SPACE_OFFSET); ds_list_head_init(&(new_region->head)); - ds_list_addnext(&mem_list, &(new_region->head)); + ds_list_addprev(&mem_list, &(new_region->head)); for(struct ds_list_head *tmp = reserve_list.next; tmp != &reserve_list; tmp = tmp->next) { struct reserve_node *node = container_of(tmp, struct reserve_node, head); for(struct ds_list_head *region = mem_list.next; region != &mem_list; region = region->next) { @@ -89,7 +97,8 @@ void frame_init(uint64_t full_sz) { struct mem_region *new_reg = simple_malloc(sizeof(struct mem_region)); init_mem_region(new_reg, node->e, end); ds_list_head_init(&(new_reg->head)); - ds_list_addnext(region, &(new_reg->head)); + ds_list_addprev(region, &(new_reg->head)); + // ds_list_addnext(region, &(new_reg->head)); } init_mem_region(old_region, start, node->s); if(node->s - start < PAGE_SIZE) { @@ -135,6 +144,8 @@ void frame_init(uint64_t full_sz) { ds_list_head_init(&(region->entries[i].head)); region->entries[i].flag = region->max_ord; region->entries[i].order = region->max_ord; + region->entries[i].used_cnt = 0; + // ds_list_addprev(&frame_list[region->max_ord], &(region->entries[i].head)); ds_list_addnext(&frame_list[region->max_ord], &(region->entries[i].head)); } } @@ -149,9 +160,9 @@ uint8_t page_size_to_order(uint64_t sz) { } } if((sz & ((1 << i) - 1)) == 0) { - return (i >> PAGE_SIZE_ORDER); + return (i - PAGE_SIZE_ORDER); } - return (i + 1) >> PAGE_SIZE_ORDER; + return (i + 1) - PAGE_SIZE_ORDER; } void *_split_page(uint8_t cur_order, uint8_t target_order) { @@ -200,8 +211,8 @@ void *_split_page(uint8_t cur_order, uint8_t target_order) { // push entries into list ds_list_head_init(&(region->entries[right_idx].head)); ds_list_head_init(&(region->entries[ent->idx].head)); - ds_list_addnext(&frame_list[cur_order - 1], &(region->entries[ent->idx].head)); - ds_list_addnext(&frame_list[cur_order - 1], &(region->entries[right_idx].head)); + ds_list_addprev(&frame_list[cur_order - 1], &(region->entries[ent->idx].head)); + ds_list_addprev(&frame_list[cur_order - 1], &(region->entries[right_idx].head)); return _split_page(cur_order - 1, target_order); } @@ -213,7 +224,8 @@ void *_find_page(uint8_t order) { struct frame_entry *ent = container_of(head, struct frame_entry, head); ent->flag = PAGE_ALLOCATED; ds_list_remove(frame_list[order].next); - uart_send_string("Successfully find page\r\n"); + // uart_send_u64(ent->idx); + // uart_send_u64(ent->mem_region->begin_addr); return (void*)idx2addr(ent->idx, ent->mem_region->begin_addr); } @@ -234,27 +246,21 @@ void *_find_page(uint8_t order) { void *page_alloc(uint64_t size) { int order = page_size_to_order(size); - uart_send_dec(order); - uart_send_string("\r\n"); if(order > PAGE_MAX_ORDER) { return NULL; } void *ptr = _find_page(order); - uart_send_string("Allocated page: "); - uart_send_u64((uint64_t)ptr); - uart_send_string("\r\n"); return ptr; } void _merge_page(void *addr, uint8_t cur_order, struct mem_region *region) { - // if(cur_order >= PAGE_MAX_ORDER) { - // return; - // } uint32_t idx = addr2idx((uint64_t)addr, region->begin_addr); uint64_t ano_addr = (uint64_t)addr ^ (1LL << (cur_order + PAGE_SIZE_ORDER)); uint32_t ano_idx = addr2idx((uint64_t)ano_addr, region->begin_addr); + if(cur_order < region->max_ord && region->entries[ano_idx].flag == cur_order) { #ifdef MEM_DEMO + uart_switch_func(UART_DEFAULT); uart_send_string("Merge Page addr, addr, size "); uart_send_u64((uint64_t)addr); uart_send_string(", "); @@ -262,6 +268,7 @@ void _merge_page(void *addr, uint8_t cur_order, struct mem_region *region) { uart_send_string(", "); uart_send_u64((1LL << (cur_order + PAGE_SIZE_ORDER))); uart_send_string("\r\n"); + uart_switch_func(UART_ASYNC); #endif ds_list_remove(&(region->entries[ano_idx].head)); // happen when addr is left @@ -276,11 +283,12 @@ void _merge_page(void *addr, uint8_t cur_order, struct mem_region *region) { region->entries[idx].flag = cur_order; region->entries[idx].order = cur_order; ds_list_head_init(&(region->entries[idx].head)); - ds_list_addnext(&frame_list[cur_order], &(region->entries[idx].head)); + ds_list_addprev(&frame_list[cur_order], &(region->entries[idx].head)); } } void page_free(void *addr) { + struct mem_region *region; for(struct ds_list_head *head = mem_list.next; head != &(mem_list); head = head->next) { region = container_of(head, struct mem_region, head); @@ -289,6 +297,7 @@ void page_free(void *addr) { } } uint32_t idx = addr2idx((uint64_t)addr, region->begin_addr); + _merge_page(addr, region->entries[idx].order, region); } void memory_reserve(uint64_t start, uint64_t end) { diff --git a/src/kernel/mini_uart.c b/src/kernel/mini_uart.c index 4bca9a90e..87f2ff2f0 100644 --- a/src/kernel/mini_uart.c +++ b/src/kernel/mini_uart.c @@ -5,6 +5,9 @@ #include "interrupt.h" #include "mem/mem.h" #include "event.h" +#include "power.h" +#include "waitqueue.h" +#include "fs/vfs.h" #define QUEUE_FULL 1 #define QUEUE_EMPTY 2 @@ -14,12 +17,15 @@ static char hex_char[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; static int uart_func; -static char rx_copy_buf[1024]; +static char rx_copy_buf[4096]; struct k_event uart_recv_event; + extern int demo_state; +struct waitqueue_t uart_rx_wait_queue; + struct Uart_MSG_Queue* Uart_MSG_Queue_init() { // init Uart MSG Queue struct Uart_MSG_Queue *ret = (struct Uart_MSG_Queue*)simple_malloc(sizeof(struct Uart_MSG_Queue)); @@ -38,6 +44,30 @@ void disable_transmit_interrupt() { write_reg_32(AUX_MU_IER_REG, 1); } +void _putchar(char c) { + uint16_t val = 0; + while(1) { + if(read_reg_32(AUX_MU_LSR_REG) & 0x20) { + break; + } + val += 1; + if(val > 1000) { + reset(100); + } + } + write_reg_32(AUX_MU_IO_REG, c); +} + +char _getchar() { + while(1) { + if(read_reg_32(AUX_MU_LSR_REG) & 0x01) { + break; + } + } + return (read_reg_32(AUX_MU_IO_REG) & 0xff); +} + + unsigned int uart_pop(struct Uart_MSG_Queue *que, unsigned int *res) { @@ -76,41 +106,42 @@ static struct Uart_MSG_Queue *txbuf; // static uint16_t* uart_func_sw; -void _putchar(char c) { - while(1) { - if(read_reg_32(AUX_MU_LSR_REG) & 0x20) { - break; - } - } - write_reg_32(AUX_MU_IO_REG, c); -} - -char _getchar() { - while(1) { - if(read_reg_32(AUX_MU_LSR_REG) & 0x01) { - break; - } - } - return (read_reg_32(AUX_MU_IO_REG) & 0xff); -} +static uint16_t ena; +static uint16_t dis; // not very good implement // should implement the same way as interrupt_disable_save void enable_aux_interrupt() { + ena += 1; + // if(ena > 20000) { + // uart_switch_func(UART_DEFAULT); + // uart_send_string("Enabling\r\n"); + // uart_switch_func(UART_ASYNC); + // } write_reg_32(ENABLE_IRQ1, (1 << 29)); } void disable_aux_interrupt() { + dis += 1; + // if(dis > 20000) { + // uart_switch_func(UART_DEFAULT); + // uart_send_string("Disabling\r\n"); + // uart_switch_func(UART_ASYNC); + // } write_reg_32(DISABLE_IRQ1, (1 << 29)); } void uart_rx_to_buf(void* ptr, uint32_t sz) { // TODO reconstruct demo codes - if(demo_state) { - uart_send(*(char*)ptr); - } + // if(demo_state) { + // uart_send(*(char*)ptr); + // } for(int i = 0; i < sz; i ++) { + disable_aux_interrupt(); uart_push(rxbuf, *(char*)ptr); + enable_aux_interrupt(); } + simple_free(ptr); + wakeup(&uart_rx_wait_queue); } void uart_init() { @@ -118,6 +149,7 @@ void uart_init() { // uart_func_sw = (uint16_t*)simple_malloc(sizeof(uart_func_sw)); // set the selected function for pin14,15 to mini uart + disable_aux_interrupt(); selector = read_reg_32(GPFSEL1); selector &= ~(7 << 12); @@ -153,6 +185,7 @@ void uart_init() { txbuf = Uart_MSG_Queue_init(); uart_func = UART_ASYNC; k_event_init(&uart_recv_event, &uart_rx_to_buf); + waitqueue_init(&uart_rx_wait_queue); // uart_func = UART_DEFAULT; } @@ -186,6 +219,34 @@ char async_uart_recv(void) { } return (val & 0xff); } +uint64_t async_uart_rx_buf(char *buf, uint64_t sz) { + int err; + unsigned int val; + int i; + // uart_send_dec(sz); + // uart_send_string("\r\n"); + for(i = 0; i < sz; i ++) { + disable_aux_interrupt(); + int err = uart_pop(rxbuf, &val); + enable_aux_interrupt(); + if(err == QUEUE_EMPTY) { + if(i == 0) { + wait(&uart_rx_wait_queue); + i-= 1; + continue; + } else { + goto _r; + } + } else { + buf[i] = (val & 0xff); + } + } +_r:; + // uart_send_string("ffff "); + // uart_send_u64(i); + // uart_send_string("\r\n"); + return i; +} void async_uart_send(char c) { // first disable aux interrupt so that txbuf won't race @@ -197,6 +258,7 @@ void async_uart_send(char c) { void async_uart_send_string(const char *buf) { // first disable aux interrupt so that txbuf won't race + // uart_send_string("send string for user\r\n"); disable_aux_interrupt(); for(const char *ch = buf; *ch != '\0'; ch ++) { uart_push(txbuf, *ch); @@ -218,7 +280,7 @@ void uart_send_u32(unsigned int u32) { } void uart_send_string(const char *c) { - if(uart_func == UART_ASYNC) { + if(0 && uart_func == UART_ASYNC) { async_uart_send_string(c); } else { for(const char *ch = c; *ch != '\0'; ch ++) { @@ -226,17 +288,30 @@ void uart_send_string(const char *c) { } } } -void uart_send_n(const char *c, unsigned long long n) { - for(int i = 0; i < n; i ++) { +uint64_t uart_send_n(const char *c, unsigned long long n) { + uint64_t i; + // uart_switch_func(UART_DEFAULT); + // uart_send_dec(ena); + // uart_send_string(" "); + // uart_send_dec(dis); + // uart_send_string("\r\n"); + // uart_switch_func(UART_ASYNC); + for(i = 0; i < n; i ++) { if(c[i] == '\n') { uart_send('\r'); } uart_send(c[i]); } + // uart_send_string("after send\r\n"); + return i; } void uart_send_dec(unsigned long dec) { char buf[20]; int idx = 0; + uint8_t s = 0; + if(dec == 0) { + s = 1; + } while(dec) { buf[idx ++] = (dec % 10) + '0'; dec /= 10; @@ -244,30 +319,122 @@ void uart_send_dec(unsigned long dec) { for(int i = idx - 1; i >= 0; i --) { uart_send(buf[i]); } + if(s) { + uart_send('0'); + } } void uart_int_trans_handler() { unsigned int val; int err; + disable_aux_interrupt(); while(read_reg_32(AUX_MU_LSR_REG) & 0x20) { err = uart_pop(txbuf, &val); if(err == 0) { - write_reg_32(AUX_MU_IO_REG, val % 0xff); + write_reg_32(AUX_MU_IO_REG, (val & 0xff)); } else { + // uart_switch_func(UART_DEFAULT); + // uart_send_string("After send\r\n"); + // uart_switch_func(UART_ASYNC); + uint64_t elr; + asm volatile ( + "mrs %[elr], elr_el1\n":[elr]"=r"(elr) + ); + // uart_send_u64(elr); disable_transmit_interrupt(); + // uart_switch_func(UART_DEFAULT); + // uart_send_string("disalbe transmit interrupt\r\n"); + // uart_switch_func(UART_ASYNC); break; } } + enable_aux_interrupt(); } void uart_int_recv_handler() { int idx = 0; unsigned int val; + char *ptr = (char*)simple_malloc(64); while(read_reg_32(AUX_MU_LSR_REG) & 0x01) { val = read_reg_32(AUX_MU_IO_REG); - rx_copy_buf[idx ++] = (val & 0xff); + // uart_push(rxbuf, (val & 0xff)); + // wakeup(&uart_rx_wait_queue); + ptr[idx ++] = (val & 0xff); } - k_event_submit(&uart_recv_event, rx_copy_buf, idx, 200); + + + k_event_submit(&uart_recv_event, ptr, idx, 200); } void uart_switch_func(unsigned int func) { uart_func = func; +} + +struct file uart_file; +int uart_init_fs(struct filesystem* fs) { + fs->root = (struct vnode *)kmalloc(sizeof(struct vnode)); + return 0; +} + +struct file_operations uart_fops = { + .close = &fops_not_support, + .open = &uart_file_open, + .lseek64 = &fops_not_support, + .stat = &fops_not_support, + .write = &uart_file_write, + .read = &uart_file_read, + .ioctl = &fops_not_support +}; + +struct vnode_operations uart_vops = { + .create = &vops_not_support, + .lookup = &vops_not_support, + .mkdir = &vops_not_support +}; + +int uart_setup_mount(struct filesystem* fs, struct mount *mnt) { + ds_list_head_init(&(fs->root->ch_list)); + ds_list_head_init(&(fs->root->v_head)); + uart_file.f_ops = &uart_fops; + uart_file.f_pos = 0; + uart_file.flags = 0777; + uart_file.vnode = fs->root; + fs->root->flag = VFS_FILE; + fs->root->mount = mnt; + mnt->root = fs->root; + mnt->fs = fs; +} + + +struct filesystem uart_fs = { + .name = "uartfs", + .init_fs = &uart_init_fs, + .root = NULL, + .setup_mount = &uart_setup_mount +}; + +int uart_file_write(struct file *f, const void *buf, long len) { + int n = uart_send_n(buf, len); + return n; +} + +int uart_file_read(struct file *f, const void *buf, long len) { + int n = async_uart_rx_buf(buf, len); + return n; +} + +int uart_file_open(struct vnode *f, struct file **target) { + *target = &uart_file; + return 0; +} + +int uart_file_close(struct file *f) { + return 0; +} + +// int uart_v_lookup(struct vnode *dir_node, ) + +void setup_dev_uart() { + register_filesystem(&uart_fs); + vfs_mkdir("/dev/uart"); + vfs_mount("/dev/uart", "uartfs"); + return; } \ No newline at end of file diff --git a/src/kernel/mmu.S b/src/kernel/mmu.S new file mode 100644 index 000000000..f202b1e3f --- /dev/null +++ b/src/kernel/mmu.S @@ -0,0 +1,68 @@ +#include "mmu/mmu-def.h" + +.section ".text.mmu" +.global enable_kernel_mmu +enable_kernel_mmu: + // setup kernel virtaul memory + mov x4, x0 + ldr x0, =TCR_CONFIG_DEFAULT + msr tcr_el1, x0 + + ldr x0, =(\ + (MAIR_DEVICE_nGnRnE << (MAIR_IDX_DEVICE_nGnRnE * 8)) | \ + (MAIR_NORMAL_NOCACHE << (MAIR_IDX_NORMAL_NOCACHE * 8)) \ + ) + msr mair_el1, x0 + + mov x0, 0x1000 // kernel PGD + mov x1, 0x2000 // kernel PUD + mov x5, 0x3000 // kernel PMD + + // set PGD entry + ldr x2, =BOOT_PGD_ATTR + orr x2, x1, x2 + str x2, [x0] + + + ldr x2, =BOOT_PUD_TABLE + orr x3, x5, x2 + str x3, [x1] + ldr x2, =BOOT_PMD_ATTR_NORMAL + + mov x6, 0 + mov x7, 0 + .setup_normal_kernel_PMD: + orr x3, x6, x2 + str x3, [x5], 8 + add x6, x6, 0x200000 + add x7, x7, 1 + cmp x7, #480 + blt .setup_normal_kernel_PMD + + ldr x2, =BOOT_PMD_ATTR_DEVICE + + .setup_device_kernel_PMD: + orr x3, x6, x2 + str x3, [x5], 8 + add x6, x6, 0x200000 + add x7, x7, 1 + cmp x7, 512 + blt .setup_device_kernel_PMD + + // ldr x2, =BOOT_PUD_ATTR_NORMAL + // mov x3, 0x00000000 + // orr x3, x2, x3 + // str x3, [x1] + + ldr x2, =BOOT_PUD_ATTR_DEVICE + mov x3, 0x40000000 + orr x3, x2, x3 + str x3, [x1, 8] + + msr ttbr0_el1, x0 + msr ttbr1_el1, x0 + + mrs x2, sctlr_el1 + orr x2, x2, 1 + msr sctlr_el1, x2 + br x4 \ No newline at end of file diff --git a/src/kernel/mmu.c b/src/kernel/mmu.c new file mode 100644 index 000000000..2654496bb --- /dev/null +++ b/src/kernel/mmu.c @@ -0,0 +1,54 @@ +#include "mmu/mmu.h" +#include "type.h" +#include "mem/mem.h" + + +uint64_t* find_pte(void *pgd, unsigned long long va, uint8_t create) { + pgd = kernel_pa2va(pgd); + + uint64_t *PGD = pgd; + + uint64_t pud_idx = (va >> 39) & 0b111111111; + if((PGD[pud_idx] & 1) == 0) { + if(!create) return 0; + uint64_t new_PUD = (uint64_t)cmalloc((1 << 12)); + PGD[pud_idx] = (uint64_t)kernel_va2pa((new_PUD | PD_TABLE)); + } + uint64_t *PUD = (uint64_t*)kernel_pa2va((PGD[pud_idx] >> 12) << 12); + uint64_t pmd_idx = (va >> 30) & 0b111111111; + if((PUD[pmd_idx] & 1) == 0) { + if(!create) return 0; + uint64_t new_PMD = (uint64_t)cmalloc(1 << 12); + PUD[pmd_idx] = (uint64_t)kernel_va2pa(new_PMD | PD_TABLE); + } + uint64_t *PMD = (uint64_t*)kernel_pa2va((PUD[pmd_idx] >> 12) << 12); + uint64_t pte_idx = (va >> 21) & 0b111111111; + if((PMD[pte_idx] & 1) == 0) { + if(!create) return 0; + uint64_t new_PTE = (uint64_t)cmalloc(1 << 12); + PMD[pte_idx] = (uint64_t)kernel_va2pa(new_PTE | PD_TABLE); + } + + uint64_t *PTE = (uint64_t*)kernel_pa2va((PMD[pte_idx] >> 12) << 12); + uint64_t pe_idx = (va >> 12) & 0b111111111; + + return &PTE[pe_idx]; +} + +uint64_t mappages(void *pgd, uint64_t va, uint64_t size, uint64_t pa) { + + for(uint64_t i = 0; i < size; i += (1 << 12)) { + uint64_t *pte_entry = find_pte(pgd, va + i, 1); + + uint64_t page_attr = PROC_PTE_ATTR_NORMAL; + page_attr |= PD_USERACCESS; + *pte_entry = ((pa + i) | page_attr); + } +} +int mmu_map_peripheral(uint64_t ttbr0_el1) { + for(uint64_t va = 0x30000000; va < 0x40010000; va += (1 << 12)) { + uint64_t *PTE = find_pte(ttbr0_el1, va, 1); + uint64_t newPTE = (va | PROC_PTE_ATTR_DEVICE | PD_USERACCESS); + *PTE = newPTE; + } +} \ No newline at end of file diff --git a/src/kernel/process.c b/src/kernel/process.c new file mode 100755 index 000000000..3af12a726 --- /dev/null +++ b/src/kernel/process.c @@ -0,0 +1,417 @@ +#include "process.h" +#include "ds/list.h" +#include "mem/mem.h" +#include "thread.h" +#include "utils.h" +#include "peripherals/mini_uart.h" +#include "interrupt.h" +#include "type.h" +#include "mmu/mmu.h" +#include "fs/vfs.h" + +struct Process_t init_process; +struct ds_list_head process_list; +extern long long _bss_end; +extern void load_all_eret(); +extern struct filesystem tmpfs; +extern struct mount *rootfs; + +extern void thread_exit(); +extern void thread_check_zombie(void *); + +extern struct file uart_file; +static uint32_t pid_counter = 0; + +struct Thread_t * process_thread_create(void * func, void *arg, struct Process_t* proc, uint8_t kernel) { + struct Thread_t *th = thread_create(func, arg); + if(kernel == 1) { + } else if(kernel == 0) { + mappages(proc->ttbr0_el1, 0xffffffffb000ULL, (1 << 14), kernel_va2pa(th->sp - DEFAULT_STACK_SZ)); + } else if (kernel == 2) { + // uart_send_string("Mapping Signal\r\n"); + mappages(proc->ttbr0_el1, 0xffffffff7000ULL, (1 << 14), kernel_va2pa(th->sp - DEFAULT_STACK_SZ)); + } + // mappages(proc->ttbr0_el1, th->sp, ) + ds_list_addprev(&(proc->th_list), &(th->th_head)); + // th->sp = 0xfffffffff000ULL; + // uart_send_string("In process thread create \r\n"); + // uart_send_u64(proc->ttbr0_el1); + // uart_send_string("\r\n"); + th->proc = proc; + th->saved_reg.ttbr0_el1 = proc->ttbr0_el1; + return th; +} + +void process_control_init() { + ds_list_head_init(&(init_process.pl_head)); + ds_list_head_init(&(init_process.th_list)); + ds_list_head_init(&process_list); + // create a init process, although in kernel space is weird; + // the init process contain a idle thread that clean zombie thread and process + init_process.ttbr0_el1 = 0x1000; + struct Thread_t *th = process_thread_create(&thread_check_zombie, NULL, &init_process, 1); + init_process.parent = NULL; + init_process.pid = pid_counter ++; + init_process.share_section = (void *)0x80000; + init_process.share_section_sz = _bss_end; + strncpy(init_process.name, "initd", 5); + init_process.status = P_INIT; + for(int i = 0; i < SIGNUMS; i ++) { + init_process.signal[i] = 0; + } + + for(int i = 0; i < P_FD_MAX; i ++) { + init_process.files[i] = NULL; + } + init_process.cur_vnode = tmpfs.root; + init_process.mnt = rootfs; + ds_list_head_init(&(init_process.sig_list)); + ds_list_addnext(&(init_process.th_list), &(th->th_head)); + ds_list_addprev(&(process_list), &(init_process.pl_head)); + th->proc = &(init_process); +} +void _run_user_thread(void *prog, void *ret, void *stackbase) { + void *base = (uint64_t)stackbase - 32 * 360; + // disable_interrupt(); + + // uart_switch_func(UART_DEFAULT); + // uart_send_string("in _run user thread\r\n"); + // uart_switch_func(UART_ASYNC); + struct Thread_t *cur = thread_get_current_instance(); + uint64_t ttbr0_el1 = cur->saved_reg.ttbr0_el1; + asm volatile( + "mov x0, #0\n" + "mov x1, #0\n" + "mov x2, #0\n" + "mov x3, #0\n" + "mov x4, #0\n" + "mov x5, #0\n" + "mov x6, #0\t\n" + "mov x7, #0\t\n" + "mov x8, #0\t\n" + "mov x9, #0\t\n" + "mov x10, #0\t\n" + "mov x11, #0\t\n" + "mov x12, #0\t\n" + "mov x13, #0\t\n" + "mov x14, #0\t\n" + "mov x15, #0\t\n" + "mov x16, #0\t\n" + "mov x17, #0\t\n" + "mov x18, #0\t\n" + "mov x19, #0\t\n" + "mov x20, #0\t\n" + "mov x21, #0\t\n" + "mov x22, #0\t\n" + "mov x23, #0\t\n" + "mov x24, #0\t\n" + "mov x25, #0\t\n" + "mov x26, #0\t\n" + "mov x27, #0\t\n" + "mov x28, #0\t\n" + ); + asm volatile( + "dsb ish\n" + "msr ttbr0_el1, %[ttbr0]\n" + "tlbi vmalle1is\n" + "dsb ish\n" + "isb\n" + "mov sp, %[sp]\n" + "mov lr, %[ret]\n" + "msr elr_el1, %[elr]\n" + "msr sp_el0, %[base_addr]\n" + "mov x0, 0x0\n" + "msr spsr_el1, x0\n" + "eret"::[ret]"r"(ret), [elr]"r"(prog), [base_addr]"r"(base), [ttbr0]"r"(ttbr0_el1), [sp]"r"(stackbase) + ); +} +void run_user_thread() { + struct Thread_t *th = thread_get_current_instance(); + + _run_user_thread(th->entry, &thread_exit, 0xfffffffff000); +} + + + + +uint64_t process_exec(const char* name, char *const argv[], uint8_t kernel) { + + char *content; + uint32_t filesize; + + struct file *f; + int err = vfs_open(name, 0, &f); + if(err) { + return err; + } + struct fstat stat; + err = vfs_stat(f, &stat); + uint64_t flag = interrupt_disable_save(); + struct Thread_t *th = thread_get_current_instance(); + struct Process_t* cur_proc = th->proc; + struct Process_t* new_proc = (struct Process_t*)kmalloc(sizeof(struct Process_t)); + + filesize = stat.filesize; + + // setup fs info + new_proc->cur_vnode = cur_proc->cur_vnode; + new_proc->mnt = cur_proc->mnt; + + + + void *share_section = (void *)kmalloc((1 << 13) + filesize); + new_proc->share_section_sz = (1 << 13) + filesize; + new_proc->share_section = share_section; + + new_proc->parent = cur_proc->parent; + new_proc->pid = pid_counter ++; + + + for(int i = 0; i < P_FD_MAX; i ++) { + if(i < 3) { + new_proc->files[i] = &uart_file; + } else { + new_proc->files[i] = NULL; + } + } + + // copy code, data and bss + int n = 0; + while(n = vfs_read(f, new_proc->share_section + n, filesize)) { + + continue; + } + if(kernel == 0) { + new_proc->ttbr0_el1 = kernel_va2pa((void *)cmalloc((1 << 12))); + uint64_t addr = kernel_va2pa(new_proc->share_section); + mappages(new_proc->ttbr0_el1, 0x0, new_proc->share_section_sz, addr); + } else { + new_proc->ttbr0_el1 = 0x1000; + } + + ds_list_head_init(&(new_proc->sig_list)); + + for(int i = 0; i < SIGNUMS; i ++) { + new_proc->signal[i] = 0; + } + + uint32_t namelen = strlen(name); + memcpy(new_proc->name, name, namelen); + new_proc->name[namelen] = '\0'; + // create a main thread for process + // currently set argv NULL + ds_list_head_init(&(new_proc->th_list)); + struct Thread_t *new_th = process_thread_create((thread_func)0, NULL, new_proc, kernel); + new_th->proc= new_proc; + + new_th->entry = 0; + + + new_th->saved_reg.lr = run_user_thread; + + new_proc->exit_code = 0; + new_proc->handling_signal = 0; + + if(pid_counter > PID_MAX) { + pid_counter = 1; + } + new_proc->status = P_INIT; + + // freeing all the thread belongs to original process + struct ds_list_head *front = ds_list_front(&(cur_proc->th_list)); + struct Thread_t *th_en; + while(front != &(cur_proc->th_list)) { + th_en = container_of(front, struct Thread_t, th_head); + th_en->status = TH_ZOMBIE; + front = ds_list_front(front); + } + + // add process to list + ds_list_head_init(&(new_proc->pl_head)); + ds_list_addprev(&(process_list), &(new_proc->pl_head)); + + interrupt_enable_restore(flag); + while(1) { + enable_interrupt(); + asm volatile("nop"); + } +} +void process_exit(int status) { + uint64_t flag = interrupt_disable_save(); + struct Process_t *proc = process_get_current(); + struct ds_list_head *front = ds_list_front(&(proc->th_list)); + while(front != &(proc->th_list)) { + struct Thread_t *th = container_of(front, struct Thread_t, th_head); + th->status = TH_ZOMBIE; + front = ds_list_front(front); + } + // enable_interrupt(); + // while(1) { + // asm volatile("nop"); + // } + schedule(0); + interrupt_enable_restore(flag); +} +void load_all_eret_log() { + uart_send_string("In load all eret\r\n"); +} + +uint64_t process_fork(struct Trapframe_t *frame) { + uint64_t flag = interrupt_disable_save(); + struct Thread_t *th = thread_get_current_instance(); + struct Process_t* cur_proc = th->proc; + struct Process_t* new_proc = (struct Process_t*)kmalloc(sizeof(struct Process_t)); + new_proc->share_section = (char *)kmalloc(cur_proc->share_section_sz); + new_proc->share_section_sz = cur_proc->share_section_sz; + memcpy(new_proc->share_section, cur_proc->share_section, cur_proc->share_section_sz); + + + + // setup fs info + new_proc->cur_vnode = cur_proc->cur_vnode; + new_proc->mnt = cur_proc->mnt; + + for(int i = 0; i < P_FD_MAX; i ++) { + new_proc->files[i] = cur_proc->files[i]; + } + + new_proc->ttbr0_el1 = kernel_va2pa((void *)cmalloc((1 << 12))); + uint64_t addr = kernel_va2pa(new_proc->share_section); + mappages(new_proc->ttbr0_el1, 0x0, cur_proc->share_section_sz, addr); + + new_proc->parent = cur_proc; + + // copy code, data and bss + uint32_t namelen = strlen(cur_proc->name); + memcpy(new_proc->name, cur_proc->name, namelen); + new_proc->name[namelen] = '\0'; + + ds_list_head_init(&(new_proc->th_list)); + + struct Thread_t *new_th = process_thread_create((thread_func)0, NULL, new_proc, 0); + new_proc->parent = cur_proc; + new_proc->exit_code = 0; + new_proc->pid = pid_counter ++; + if(pid_counter > PID_MAX) { + pid_counter = 1; + } + + new_proc->status = P_INIT; + + + ds_list_head_init(&(new_proc->pl_head)); + ds_list_addprev(&(process_list), &(new_proc->pl_head)); + + + + // copy signal handler; + ds_list_head_init(&(new_proc->sig_list)); + struct ds_list_head *front = ds_list_front(&(cur_proc->sig_list)); + if(front != NULL) { + while(front != &(cur_proc->sig_list)) { + struct Signal_t *sig = container_of(front, struct Signal_t, sig_head); + struct Signal_t *new_sig = (struct Signal_t *)kmalloc(sizeof(struct Signal_t)); + new_sig->sig_num = sig->sig_num; + new_sig->handler = sig->handler; + new_sig->th = NULL; + ds_list_head_init(&(new_sig->sig_head)); + ds_list_addprev(&(new_proc->sig_list), &(new_sig->sig_head)); + front = ds_list_front(front); + } + } + + for(int i = 0; i < SIGNUMS; i ++) { + new_proc->signal[i] = 0; + } + + + // we need to set the reg + // copy stack + memcpy(new_th->sp - th->stack_sz, th->sp - th->stack_sz, th->stack_sz); + uint64_t sp_offset = (uint64_t)(0xfffffffff000ULL) - (uint64_t)frame->sp; + new_th->saved_reg.sp = (uint64_t)(0xfffffffff000ULL) - (uint64_t)sp_offset; + + uint64_t tmp = frame->elr_el1; + uint64_t tmp_sp = frame->sp; + frame->elr_el1 = frame->elr_el1; + + frame->sp = new_th->saved_reg.sp; + new_th->saved_reg.sp = (0xfffffffff000ULL) - 32 * 10; + uint64_t tmp_x0 = frame->x0; + frame->x0 = 0; + memcpy((void *)new_th->sp - 32 * 10, frame, 32 * 9); + frame->elr_el1 = tmp; + frame->sp = tmp_sp; + frame->x0 = tmp_x0; + + + new_proc->handling_signal = 0; + new_th->saved_reg.lr = &load_all_eret; + + mmu_map_peripheral(new_proc->ttbr0_el1); + + interrupt_enable_restore(flag); + + return new_proc->pid; +} + +struct Process_t *process_get_current() { + struct Thread_t *th = thread_get_current_instance(); + + return th->proc; +} + +struct Process_t *create_process_instance() { + uint64_t flag = interrupt_disable_save(); + struct Process_t *ret = (struct Process_t*)kmalloc(sizeof(struct Process_t)); + ret->exit_code = 0; + ret->pid = pid_counter ++; + ds_list_head_init(&(ret->pl_head)); + ds_list_head_init(&(ret->sig_list)); + ret->cur_vnode = tmpfs.root; + ret->mnt = rootfs; + for(int i = 0; i < SIGNUMS; i ++) { + ret->signal[i] = 0; + } + for(int i = 0; i < P_FD_MAX; i ++) { + ret->files[i] = NULL; + } + ds_list_addprev(&(process_list), &(ret->pl_head)); + ds_list_head_init(&(ret->th_list)); + interrupt_enable_restore(flag); + return ret; +} + +void process_free(struct Process_t *proc) { + struct ds_list_head *front = ds_list_front(&(proc->th_list)); + if(front == NULL) { + uint64_t flag = interrupt_disable_save(); + + ds_list_remove(&(proc->pl_head)); + proc->exit_code = 0; + + kfree(proc); + interrupt_enable_restore(flag); + } +} + +struct Process_t *get_process_from_pid(uint32_t pid) { + struct ds_list_head *front = ds_list_front(&process_list); + if(front == NULL) { + return NULL; + } + + uint64_t val = 0; + while(front != (&(process_list))) { + struct Process_t *proc = container_of(front, struct Process_t, pl_head); + + if(proc->pid == pid) { + return proc; + } + front = ds_list_front(front); + val += 1; + + } + + return NULL; +} \ No newline at end of file diff --git a/src/kernel/sd.c b/src/kernel/sd.c new file mode 100644 index 000000000..96b13b913 --- /dev/null +++ b/src/kernel/sd.c @@ -0,0 +1,244 @@ +#include "sd.h" +// mmio +#define KVA 0xffff000000000000 +#define MMIO_BASE (KVA + 0x3f000000) + +// SD card command +#define GO_IDLE_STATE 0 +#define SEND_OP_CMD 1 +#define ALL_SEND_CID 2 +#define SEND_RELATIVE_ADDR 3 +#define SELECT_CARD 7 +#define SEND_IF_COND 8 + #define VOLTAGE_CHECK_PATTERN 0x1aa +#define STOP_TRANSMISSION 12 +#define SET_BLOCKLEN 16 +#define READ_SINGLE_BLOCK 17 +#define WRITE_SINGLE_BLOCK 24 +#define SD_APP_OP_COND 41 + #define SDCARD_3_3V (1 << 21) + #define SDCARD_ISHCS (1 << 30) + #define SDCARD_READY (1 << 31) +#define APP_CMD 55 + +// gpio +#define GPIO_BASE (MMIO_BASE + 0x200000) +#define GPIO_GPFSEL4 (GPIO_BASE + 0x10) +#define GPIO_GPFSEL5 (GPIO_BASE + 0x14) +#define GPIO_GPPUD (GPIO_BASE + 0x94) +#define GPIO_GPPUDCLK1 (GPIO_BASE + 0x9c) + +// sdhost +#define SDHOST_BASE (MMIO_BASE + 0x202000) +#define SDHOST_CMD (SDHOST_BASE + 0) + #define SDHOST_READ 0x40 + #define SDHOST_WRITE 0x80 + #define SDHOST_LONG_RESPONSE 0x200 + #define SDHOST_NO_REPONSE 0x400 + #define SDHOST_BUSY 0x800 + #define SDHOST_NEW_CMD 0x8000 +#define SDHOST_ARG (SDHOST_BASE + 0x4) +#define SDHOST_TOUT (SDHOST_BASE + 0x8) + #define SDHOST_TOUT_DEFAULT 0xf00000 +#define SDHOST_CDIV (SDHOST_BASE + 0xc) + #define SDHOST_CDIV_MAXDIV 0x7ff + #define SDHOST_CDIV_DEFAULT 0x148 +#define SDHOST_RESP0 (SDHOST_BASE + 0x10) +#define SDHOST_RESP1 (SDHOST_BASE + 0x14) +#define SDHOST_RESP2 (SDHOST_BASE + 0x18) +#define SDHOST_RESP3 (SDHOST_BASE + 0x1c) +#define SDHOST_HSTS (SDHOST_BASE + 0x20) + #define SDHOST_HSTS_MASK (0x7f8) + #define SDHOST_HSTS_ERR_MASK (0xf8) + #define SDHOST_HSTS_DATA (1 << 0) +#define SDHOST_PWR (SDHOST_BASE + 0x30) +#define SDHOST_DBG (SDHOST_BASE + 0x34) + #define SDHOST_DBG_FSM_DATA 1 + #define SDHOST_DBG_FSM_MASK 0xf + #define SDHOST_DBG_MASK (0x1f << 14 | 0x1f << 9) + #define SDHOST_DBG_FIFO (0x4 << 14 | 0x4 << 9) +#define SDHOST_CFG (SDHOST_BASE + 0x38) + #define SDHOST_CFG_DATA_EN (1 << 4) + #define SDHOST_CFG_SLOW (1 << 3) + #define SDHOST_CFG_INTBUS (1 << 1) +#define SDHOST_SIZE (SDHOST_BASE + 0x3c) +#define SDHOST_DATA (SDHOST_BASE + 0x40) +#define SDHOST_CNT (SDHOST_BASE + 0x50) + +// helper +#define set(io_addr, val) \ + asm volatile("str %w1, [%0]" ::"r"(io_addr), "r"(val) : "memory"); + +#define get(io_addr, val) \ + asm volatile("ldr %w0, [%1]" : "=r"(val) : "r"(io_addr) : "memory"); + +static inline void delay(unsigned long tick) { + while (tick--) { + asm volatile("nop"); + } +} + +static int is_hcs; // high capcacity(SDHC) + +static void pin_setup() { + set(GPIO_GPFSEL4, 0x24000000); + set(GPIO_GPFSEL5, 0x924); + set(GPIO_GPPUD, 0); + delay(15000); + set(GPIO_GPPUDCLK1, 0xffffffff); + delay(15000); + set(GPIO_GPPUDCLK1, 0); +} + +static void sdhost_setup() { + unsigned int tmp; + set(SDHOST_PWR, 0); + set(SDHOST_CMD, 0); + set(SDHOST_ARG, 0); + set(SDHOST_TOUT, SDHOST_TOUT_DEFAULT); + set(SDHOST_CDIV, 0); + set(SDHOST_HSTS, SDHOST_HSTS_MASK); + set(SDHOST_CFG, 0); + set(SDHOST_CNT, 0); + set(SDHOST_SIZE, 0); + get(SDHOST_DBG, tmp); + tmp &= ~SDHOST_DBG_MASK; + tmp |= SDHOST_DBG_FIFO; + set(SDHOST_DBG, tmp); + delay(250000); + set(SDHOST_PWR, 1); + delay(250000); + set(SDHOST_CFG, SDHOST_CFG_SLOW | SDHOST_CFG_INTBUS | SDHOST_CFG_DATA_EN); + set(SDHOST_CDIV, SDHOST_CDIV_DEFAULT); +} + +static int wait_sd() { + int cnt = 1000000; + unsigned int cmd; + do { + if (cnt == 0) { + return -1; + } + get(SDHOST_CMD, cmd); + --cnt; + } while (cmd & SDHOST_NEW_CMD); + return 0; +} + +static int sd_cmd(unsigned cmd, unsigned int arg) { + set(SDHOST_ARG, arg); + set(SDHOST_CMD, cmd | SDHOST_NEW_CMD); + return wait_sd(); +} + +static int sdcard_setup() { + unsigned int tmp; + sd_cmd(GO_IDLE_STATE | SDHOST_NO_REPONSE, 0); + sd_cmd(SEND_IF_COND, VOLTAGE_CHECK_PATTERN); + get(SDHOST_RESP0, tmp); + if (tmp != VOLTAGE_CHECK_PATTERN) { + return -1; + } + while (1) { + if (sd_cmd(APP_CMD, 0) == -1) { + // MMC card or invalid card status + // currently not support + continue; + } + sd_cmd(SD_APP_OP_COND, SDCARD_3_3V | SDCARD_ISHCS); + get(SDHOST_RESP0, tmp); + if (tmp & SDCARD_READY) { + break; + } + delay(1000000); + } + + is_hcs = tmp & SDCARD_ISHCS; + sd_cmd(ALL_SEND_CID | SDHOST_LONG_RESPONSE, 0); + sd_cmd(SEND_RELATIVE_ADDR, 0); + get(SDHOST_RESP0, tmp); + sd_cmd(SELECT_CARD, tmp); + sd_cmd(SET_BLOCKLEN, 512); + return 0; +} + +static int wait_fifo() { + int cnt = 1000000; + unsigned int hsts; + do { + if (cnt == 0) { + return -1; + } + get(SDHOST_HSTS, hsts); + --cnt; + } while ((hsts & SDHOST_HSTS_DATA) == 0); + return 0; +} + +static void set_block(int size, int cnt) { + set(SDHOST_SIZE, size); + set(SDHOST_CNT, cnt); +} + +static void wait_finish() { + unsigned int dbg; + do { + get(SDHOST_DBG, dbg); + } while ((dbg & SDHOST_DBG_FSM_MASK) != SDHOST_HSTS_DATA); +} + +void readblock(int block_idx, void* buf) { + unsigned int* buf_u = (unsigned int*)buf; + int succ = 0; + if (!is_hcs) { + block_idx <<= 9; + } + do{ + set_block(512, 1); + sd_cmd(READ_SINGLE_BLOCK | SDHOST_READ, block_idx); + for (int i = 0; i < 128; ++i) { + wait_fifo(); + get(SDHOST_DATA, buf_u[i]); + } + unsigned int hsts; + get(SDHOST_HSTS, hsts); + if (hsts & SDHOST_HSTS_ERR_MASK) { + set(SDHOST_HSTS, SDHOST_HSTS_ERR_MASK); + sd_cmd(STOP_TRANSMISSION | SDHOST_BUSY, 0); + } else { + succ = 1; + } + } while(!succ); + wait_finish(); +} + +void writeblock(int block_idx, void* buf) { + unsigned int* buf_u = (unsigned int*)buf; + int succ = 0; + if (!is_hcs) { + block_idx <<= 9; + } + do{ + set_block(512, 1); + sd_cmd(WRITE_SINGLE_BLOCK | SDHOST_WRITE, block_idx); + for (int i = 0; i < 128; ++i) { + wait_fifo(); + set(SDHOST_DATA, buf_u[i]); + } + unsigned int hsts; + get(SDHOST_HSTS, hsts); + if (hsts & SDHOST_HSTS_ERR_MASK) { + set(SDHOST_HSTS, SDHOST_HSTS_ERR_MASK); + sd_cmd(STOP_TRANSMISSION | SDHOST_BUSY, 0); + } else { + succ = 1; + } + } while(!succ); + wait_finish(); +} + +void sd_init() { + pin_setup(); + sdhost_setup(); + sdcard_setup(); +} diff --git a/src/kernel/signal.S b/src/kernel/signal.S new file mode 100755 index 000000000..670861685 --- /dev/null +++ b/src/kernel/signal.S @@ -0,0 +1,4 @@ +.global syscall_sigreturn +syscall_sigreturn: + mov x8, #10 + svc 0 \ No newline at end of file diff --git a/src/kernel/signal.c b/src/kernel/signal.c new file mode 100755 index 000000000..c09f31ed0 --- /dev/null +++ b/src/kernel/signal.c @@ -0,0 +1,133 @@ +#include "signal.h" +#include "thread.h" +#include "ds/list.h" +#include "utils.h" +#include "peripherals/mini_uart.h" +#include "interrupt.h" +#include "process.h" +#include "waitqueue.h" +#include "process.h" + +extern void syscall_sigreturn(); + + + + +struct Signal_t *signum2handler(uint8_t signal, struct Process_t *proc) { + struct ds_list_head *front = ds_list_front(&(proc->sig_list)); + if(front == NULL) { + return NULL; + } + + while(front != (&(proc->sig_list))) { + struct Signal_t *sig = container_of(front, struct Signal_t, sig_head); + if(sig->sig_num == signal) { + return sig; + } + front = ds_list_front(front); + } + return NULL; +} + +void signal_register(uint8_t signal, signal_handler handler) { + + struct Process_t *proc = process_get_current(); + struct Signal_t *sig = signum2handler(signal, proc); + if(sig != NULL) { + sig->handler = handler; + } else { + + sig = (struct Signal_t *)kmalloc(sizeof(struct Signal_t)); + ds_list_head_init(&(sig->sig_head)); + sig->sig_num = signal; + sig->handler = handler; + ds_list_addprev(&(proc->sig_list), &(sig->sig_head)); + } +} + +void signal_kill(unsigned int pid, uint8_t signal) { + struct Process_t *proc = get_process_from_pid(pid); +; + if(proc == NULL) { + return; + } + if(signal > SIGNUMS || signal < 1) { + return; + } + + proc->signal[signal] += 1; +} + +void signal_handler_default() { + uart_send_string("Default handler\r\n"); + return; +} + +void signal_kill_default() { + process_exit(0); + return; +} + +void run_signal_thread() { + + struct Thread_t *th = thread_get_current_instance(); + + _run_user_thread(th->entry, 0xffffffff6000ULL, 0xffffffffb000ULL); + // _run_user_thread(th->entry, &syscall_sigreturn, 0xffffffffb000ULL); +} +void signal_call_handler(struct Process_t *proc, uint8_t signum) { + struct Signal_t *sig = signum2handler(signum, proc); + signal_handler handler; + if(sig == NULL) { + if(signum == 9) { + handler = signal_kill_default; + } else { + handler = signal_handler_default; + } + // run default handler in el1 + uint64_t flag = interrupt_disable_save(); + handler(); + interrupt_enable_restore(flag); + // syscall_sigreturn(); + } else { + handler = sig->handler; + struct Thread_t *th = process_thread_create(handler, NULL, proc, 2); + sig->sig_return = (void*)kmalloc((1 << 12)); + memcpy(sig->sig_return, &syscall_sigreturn, (1 << 8)); + mappages(th->saved_reg.ttbr0_el1, 0xffffffff6000, (1 << 12), kernel_va2pa(sig->sig_return)); + th->saved_reg.lr = run_signal_thread; + struct Thread_t *wait_th = thread_get_current_instance(); + sig->th = wait_th; + waitthread(thread_get_current_instance()); + } + return; +} + +void signal_check() { + struct Process_t *proc = process_get_current(); + if(proc->handling_signal != 0) return; + for(int i = 0; i < SIGNUMS; i ++) { + if(proc->signal[i] > 0) { + // first set to 0 otherwise other thread for the same process may run the same handler + + proc->handling_signal = i; + signal_call_handler(proc, i); + } + } +} + +void signal_sigreturn() { + uint64_t flag = interrupt_disable_save(); + struct Thread_t *th = thread_get_current_instance(); + struct Process_t *proc = th->proc; + struct Signal_t *sig = signum2handler(proc->handling_signal, proc); + wakeupthread(sig->th); + sig->th = NULL; + th->status = TH_ZOMBIE; + proc->handling_signal = 0; + proc->signal[sig->sig_num] -= 1; + schedule(0); + interrupt_disable_save(flag); +} + + diff --git a/src/kernel/syscall.c b/src/kernel/syscall.c new file mode 100755 index 000000000..53b86f10b --- /dev/null +++ b/src/kernel/syscall.c @@ -0,0 +1,209 @@ +#include "process.h" +#include "thread.h" +#include "syscall.h" +#include "interrupt.h" +#include "peripherals/mini_uart.h" +#include "mbox/mbox.h" +#include "fs/vfs.h" +#include "fs/fat32.h" + +int sys_get_pid() { + struct Process_t *proc = process_get_current(); + + return proc->pid; +} +uint64_t sys_uartread(char buf[], uint64_t size) { + uint64_t ret = async_uart_rx_buf(buf, size); + return ret; +} +uint64_t sys_uartwrite(const char buf[], uint64_t size) { + uint64_t ret = uart_send_n(buf, size); + return ret; +} +int sys_exec(const char* name, char *const argv[]) { + uint64_t ret = process_exec(name, argv, 0); + return ret; +} +int sys_fork(struct Trapframe_t *frame) { + uint64_t ret = process_fork(frame); + + return ret; +} +void sys_exit(int status) { + process_exit(status); + return; +} + +int sys_mbox_call(unsigned char ch, unsigned int *mbox) { + uint64_t x = mbox_call(ch, mbox); + return x; +} + +void sys_kill(int pid) { + signal_kill(pid, 9); + return; +} + +int sys_open(const char *pathname, int flags) { + struct file *f; + int err = vfs_open(pathname, flags, &f); + if(err) return err; + struct Process_t *cur_proc = process_get_current(); + for(int i = 0; i < P_FD_MAX; i ++) { + if(cur_proc->files[i] == NULL) { + cur_proc->files[i] = f; + return i; + } + } + return -1; +} + +int sys_close(int fd) { + struct file *f; + struct Process_t *cur_proc = process_get_current(); + int err = vfs_close(cur_proc->files[fd]); + if(err) return err; + cur_proc->files[fd] = NULL; + return err; +} + +// syscall number : 13 +// remember to return read size or error code +long sys_write(int fd, const void *buf, unsigned long count) { + struct Process_t *cur_proc = process_get_current(); + int err = vfs_write(cur_proc->files[fd], buf, count); + return err; +} + +// syscall number : 14 +// remember to return read size or error code +long sys_read(int fd, void *buf, unsigned long count) { + struct Process_t *cur_proc = process_get_current(); + int err = vfs_read(cur_proc->files[fd], buf, count); + return err; +} + +// syscall number : 15 +// you can ignore mode, since there is no access control +int sys_mkdir(const char *pathname, unsigned mode) { + int err = vfs_mkdir(pathname); + return err; +} + + +// syscall number : 16 +// you can ignore arguments other than target (where to mount) and filesystem (fs name) +int sys_mount(const char *src, const char *target, const char *filesystem, unsigned long flags, const void *data) { + int err = vfs_mount(target, filesystem); + return err; +} + + +// syscall number : 17 +int sys_chdir(const char *path) { + struct vnode *dir; + int err = vfs_lookup(path, &dir); + + if(err != 0) { + return err; + } else { + struct Process_t *proc = process_get_current(); + proc->cur_vnode = dir; + proc->mnt = dir->mount; + } + return err; +} + +int sys_lseek(int fd, long offset, int whence) { + struct Process_t *proc = process_get_current(); + struct file *f = proc->files[fd]; + + return f->f_ops->lseek64(f, offset, whence); +} + +int sys_ioctl(int fd, unsigned long request, void *buf) { + struct Process_t *proc = process_get_current(); + struct file *f = proc->files[fd]; + + return f->f_ops->ioctl(f, request, buf); +} + +void syscall_handler(struct Trapframe_t *frame) { + + switch(frame->x8) { + case 0: + frame->x0 = sys_get_pid(); + break; + case 1: + frame->x0 = sys_uartread(frame->x0, frame->x1); + break; + case 2: + frame->x0 = sys_uartwrite(frame->x0, frame->x1); + break; + case 3: + frame->x0 = sys_exec(frame->x0, frame->x1); + break; + case 4: + unsigned long long val = sys_fork(frame); + frame->x0 = val; + break; + case 5: + sys_exit(frame->x1); + break; + case 6: + frame->x0 = sys_mbox_call(frame->x0, frame->x1); + break; + case 7: + sys_kill(frame->x0); + break; + + case 8: + signal_register(frame->x0, frame->x1); + break; + case 9: + signal_kill(frame->x0, frame->x1); + break; + case 10: + signal_sigreturn(); + break; + + case 11: + frame->x0 = sys_open(frame->x0, frame->x1); + break; + case 12: + frame->x0 = sys_close(frame->x0); + break; + case 13: + frame->x0 = sys_write(frame->x0, frame->x1, frame->x2); + break; + case 14: + frame->x0 = sys_read(frame->x0, frame->x1, frame->x2); + break; + + case 15: + frame->x0 = sys_mkdir(frame->x0, frame->x1); + break; + + case 16: + + sys_mount(frame->x0, frame->x1, frame->x2, frame->x3, frame->x4); + break; + + case 17: + frame->x0 = sys_chdir(frame->x0); + break; + + case 18: + frame->x0 = sys_lseek(frame->x0, frame->x1, frame->x2); + break; + + case 19: + frame->x0 = sys_ioctl(frame->x0, frame->x1, frame->x2); + break; + + case 20: + fat32_sync(); + + } + +} diff --git a/src/kernel/thread.c b/src/kernel/thread.c new file mode 100755 index 000000000..c566dcd32 --- /dev/null +++ b/src/kernel/thread.c @@ -0,0 +1,244 @@ +#include "thread.h" +#include "ds/list.h" +#include "utils.h" +#include +#include "interrupt.h" +#include "peripherals/mini_uart.h" + +// 8 different pri +struct ds_list_head run_queue; +struct ds_list_head zombie_queue; +static bool _inited = 0; +static uint64_t thread_num = 0; + +#define CHECK_ZNUM 3 + +struct RegState_t kernel_state; + +void thread_clean(struct Thread_t *th) { + + kfree(th->sp - DEFAULT_STACK_SZ); + kfree(th->arg); + ds_list_remove(&(th->th_head)); + process_free(th->proc); + kfree(th); +} + +void thread_check_zombie(void * arg) { + while(true) { + struct ds_list_head *front = ds_list_front(&zombie_queue); + for(int i = 0; i < CHECK_ZNUM && front != NULL; i ++) { + uint64_t flag = interrupt_disable_save(); + struct Thread_t *th = container_of(front, struct Thread_t, tq_head); + ds_list_remove(&(th->tq_head)); + + interrupt_enable_restore(flag); + front = ds_list_front(&zombie_queue); + asm volatile("nop"); + } + } +} +void thread_control_init() { + if(_inited) { + return; + } + _inited = 1; + ds_list_head_init(&run_queue); + ds_list_head_init(&zombie_queue); +} + + +extern void back_el1(); +void thread_exit() { + + back_el1(); + struct Thread_t *th = thread_get_current_instance(); + th->status = TH_ZOMBIE; + + + // wait for interrupt + // This make sure that the scheudle is called in el1 + enable_interrupt(); + while(1) { + asm volatile("nop"); + } +} + + +void _thread_exit() { + struct ds_list_head *front = ds_list_front(&(run_queue)); + // front should not be NULL, since we have idle thread + struct Thread_t *th = container_of(front, struct Thread_t, tq_head); + thread_exit(); +} + +void sys_call_exit() { + asm volatile( + "mov x0, 5\n" + "svc 0\n" + ); + return; +} + +void thread_exec_wrapper() { + + uint64_t flag = interrupt_disable_save(); + struct Thread_t *cur_thread = thread_get_current_instance(); + interrupt_enable_restore(flag); + cur_thread->entry(cur_thread->arg); + + flag = interrupt_disable_save(); + thread_exit(); + interrupt_enable_restore(flag); +} + +struct Thread_t * thread_create(thread_func func, void *arg) { + struct Thread_t *th = (struct Thread_t *)kmalloc(sizeof(struct Thread_t)); + if(arg == NULL) { + th->arg = NULL; + } else { + uint32_t arg_len = strlen(arg); + th->arg = (void *)kmalloc(arg_len + 1); + memcpy(th->arg, arg, arg_len); + *(char*)(th->arg + arg_len) = '\0'; + } + // TID may races, + uint64_t flag = interrupt_disable_save(); + th->tid = ++ thread_num; + th->entry = func; + // 4KB stack + ds_list_head_init(&(th->tq_head)); + ds_list_head_init(&(th->th_head)); + th->sp = (void *)kmalloc(DEFAULT_STACK_SZ) + (DEFAULT_STACK_SZ); + th->stack_sz = DEFAULT_STACK_SZ; + th->status = TH_IN_RUNNING; + ds_list_addprev(&run_queue, &(th->tq_head)); + memset(&th->saved_reg, 0, sizeof(struct RegState_t)); + th->saved_reg.fp = th->sp; + th->saved_reg.sp = th->sp; + // this should make the function end will jump to cleanup function + th->saved_reg.lr = thread_exec_wrapper; + th->saved_reg.tcb_addr = th; + interrupt_enable_restore(flag); + return th; +} +static uint64_t switch_time; + +void schedule_init() { + uint64_t freq, clock; + asm volatile("mrs %0, cntfrq_el0\n":"=r"(freq)); + asm volatile("mrs %0, cntpct_el0\n":"=r"(clock)); + freq >>= 5; + asm volatile("msr cntp_tval_el0, %0": "=r"(freq)); + switch_time = freq + clock; +} + + +static uint8_t first_schedule = 1; + +void schedule(uint8_t preempt) { + uint64_t flag = interrupt_disable_save(); + struct ds_list_head *front = ds_list_front(&(run_queue)); + // front should not be NULL, since we have idle thread + struct Thread_t *cur_thread = container_of(front, struct Thread_t, tq_head); + ds_list_remove(&(cur_thread->tq_head)); + ds_list_head_init(&(cur_thread->tq_head)); + + + //setup next timer + uint64_t freq; + if(preempt) { + asm volatile("mrs %0, cntfrq_el0\n":"=r"(freq)); + freq >>= 5; + asm volatile("msr cntp_tval_el0, %0": "=r"(freq)); + } + + if(first_schedule) { + cur_thread->status = TH_RUNNING; + first_schedule = 0; + // Make first context switch push front + // so that the status of the run queue is correct + // namely, the first thread instance should be running. + ds_list_addnext(&run_queue, &(cur_thread->tq_head)); + enable_interrupt(); + context_switch_to(&(kernel_state), &(cur_thread->saved_reg), cur_thread->tid); + return; + } + + + else { + front = ds_list_front(&(run_queue)); + if(front == NULL) { + goto _r; + } + struct Thread_t *next_thread = container_of(front, struct Thread_t, tq_head); + while(next_thread->status != TH_IN_RUNNING) { + + if(next_thread == cur_thread) { + break; + } + ds_list_remove(&(next_thread->tq_head)); + ds_list_head_init(&(next_thread->tq_head)); + if(next_thread == TH_WAIT) { + if(next_thread->waitqueue != NULL) { + ds_list_addprev(&(next_thread->waitqueue->th_list), &(next_thread->tq_head)); + } + } else if(next_thread->status == TH_ZOMBIE) { + ds_list_addprev(&(zombie_queue), &(next_thread->tq_head)); + } + front = ds_list_front(&(run_queue)); + if(front == NULL) { + goto _r; + } + next_thread = container_of(front, struct Thread_t, tq_head); + } + if(cur_thread->status != TH_RUNNING) { + if(cur_thread->status == TH_WAIT) { + if(cur_thread->waitqueue != NULL) { + ds_list_addprev(&(cur_thread->waitqueue->th_list), &(cur_thread->tq_head)); + } + } else if(cur_thread->status == TH_ZOMBIE) { + ds_list_addprev(&(zombie_queue), &(cur_thread->tq_head)); + } else{ + } + } else{ + cur_thread->status = TH_IN_RUNNING; + ds_list_addprev(&(run_queue), &(cur_thread->tq_head)); + } + next_thread->status = TH_RUNNING; + + + + enable_interrupt(); + context_switch_to(&(cur_thread->saved_reg), &(next_thread->saved_reg), next_thread->tid); + signal_check(); + return; + } + _r: + + ds_list_addprev(&(run_queue), &(cur_thread->tq_head)); + interrupt_enable_restore(flag); + signal_check(); + return; +} + +struct Thread_t *thread_get_current_instance() { + struct ds_list_head *front = ds_list_front(&(run_queue)); + struct Thread_t *cur_thread = container_of(front, struct Thread_t, tq_head); + return cur_thread; +} + +void handle_time_schedule(struct Trapframe_t *frame) { + // return; + uint64_t freq, clock; + asm volatile("mrs %0, cntfrq_el0\n":"=r"(freq)); + asm volatile("mrs %0, cntpct_el0\n":"=r"(clock)); + + if(switch_time > clock) { + return; + } + switch_time = clock + (freq >> 5); + struct Thread_t *cur_th = thread_get_current_instance(); + // Since we won't do eret after schedule, we need to enable the interrupt first + schedule(1); +} \ No newline at end of file diff --git a/src/kernel/utils.S b/src/kernel/utils.S index 92768a1bd..d5a3a1b6e 100644 --- a/src/kernel/utils.S +++ b/src/kernel/utils.S @@ -20,4 +20,30 @@ delay_test: mov x1, 0x65 bne delay // bl uart_send - ret \ No newline at end of file + ret + +.global gen_trapframe +gen_trapframe: + mov x0, 272 + mov x1, lr; + bl kmalloc + stp x0, x1, [x0 ,16 * 0] + stp x2, x3, [x0 ,16 * 1] + stp x4, x5, [x0 ,16 * 2] + stp x6, x7, [x0 ,16 * 3] + stp x8, x9, [x0 ,16 * 4] + stp x10, x11, [x0 ,16 * 5] + stp x12, x13, [x0 ,16 * 6] + stp x14, x15, [x0 ,16 * 7] + stp x16, x17, [x0 ,16 * 8] + stp x18, x19, [x0 ,16 * 9] + stp x20, x21, [x0 ,16 * 10] + stp x22, x23, [x0 ,16 * 11] + stp x24, x25, [x0 ,16 * 12] + stp x26, x27, [x0 ,16 * 13] + stp x28, x29, [x0 ,16 * 14] + stp x30, x0, [x0, 16 * 15] + mov x2, sp + stp x1, x2, [x0, 16 * 16] + mov lr, x1 + ret \ No newline at end of file diff --git a/src/kernel/utils.c b/src/kernel/utils.c index 053e7d530..95b96d99f 100644 --- a/src/kernel/utils.c +++ b/src/kernel/utils.c @@ -1,11 +1,18 @@ #include "type.h" #include "utils.h" +#include "peripherals/mini_uart.h" void memcpy(void* dest, void *src, unsigned long long size) { + // if(dest <= 0x3bffa000 && dest + size >= 0x3bffa000) { + // uart_send_string("copying\r\n"); + // } for(int i = 0; i < size; i ++) { *(char*)(dest + i) = *(char*)(src + i); } } void memset(void *dest, char val, unsigned int size) { + // if(dest <= 0x3bffa000 && dest + size >= 0x3bffa000) { + // uart_send_string("setting\r\n"); + // } for(int i = 0; i < size; i ++) { *(char*)(dest + i) = val; } diff --git a/src/kernel/waitqueue.c b/src/kernel/waitqueue.c new file mode 100755 index 000000000..726653c84 --- /dev/null +++ b/src/kernel/waitqueue.c @@ -0,0 +1,56 @@ +#include "waitqueue.h" +#include "thread.h" +#include "ds/list.h" +#include "type.h" +#include "utils.h" +#include "peripherals/mini_uart.h" + +extern struct ds_list_head run_queue; + +void waitqueue_init(struct waitqueue_t *queue) { + ds_list_head_init(&(queue->th_list)); +} + +void wait(struct waitqueue_t *queue) { + uint64_t flag = interrupt_disable_save(); + struct Thread_t* th = thread_get_current_instance(); + + signal_check(); + th->status = TH_WAIT; + th->waitqueue = queue; + schedule(0); + interrupt_enable_restore(flag); + return; +} + +void waitthread(struct Thread_t *th) { + uint64_t flag = interrupt_disable_save(); + + th->status = TH_WAIT; + th->waitqueue = NULL; + schedule(0); + interrupt_enable_restore(flag); + return; +} + +void wakeupthread(struct Thread_t *th) { + th->status = TH_IN_RUNNING; + ds_list_head_init(&(th->tq_head)); + ds_list_addprev(&(run_queue), &(th->tq_head)); + return; +} + +void wakeup(struct waitqueue_t *queue) { + struct ds_list_head *front = ds_list_front(&(queue->th_list)); + if(front == NULL) { + return; + } + struct Thread_t *th = container_of(front, struct Thread_t, tq_head); + + ds_list_remove(&(th->tq_head)); + th->status = TH_IN_RUNNING; + th->waitqueue = NULL; + ds_list_head_init(&(th->tq_head)); + ds_list_addprev(&(run_queue), &(th->tq_head)); + return; +} \ No newline at end of file