├── Abyon.img ├── LICENSE ├── Makefile ├── README.md ├── TAGS ├── arch ├── Makefile └── i386 │ ├── kernel │ ├── cpu │ │ └── common.c │ ├── entry.S │ ├── head.S │ ├── i8259.c │ ├── init_task.c │ ├── irq.c │ ├── process.c │ ├── setup.c │ ├── tail.S │ ├── timers │ │ ├── timer_pit.c │ │ └── timer_tsc.c │ └── traps.c │ ├── lib │ ├── bitops.c │ └── memcpy.c │ └── mm │ ├── discontig.c │ └── init.c ├── boot ├── Makefile ├── loaderS1.asm └── loaderS2.asm ├── drivers ├── base │ └── map.c └── vram │ ├── disp.c │ ├── disp.h │ ├── fonts.bin │ └── hankaku.txt ├── error.log ├── fs ├── binfmt_elf.c ├── block_dev.c ├── char_dev.c ├── dcache.c ├── elevator.c ├── exec.c ├── ext2 │ └── inode.c ├── file_table.c ├── filesystem.c ├── inode.c ├── mpage.c ├── namei.c ├── namespace.c ├── open.c ├── ramfs │ └── inode.c ├── read_write.c ├── super.c └── sysfs │ └── mount.c ├── include ├── abyon │ ├── binfmts.h │ ├── bio.h │ ├── blkdev.h │ ├── bootmem.h │ ├── dcache.h │ ├── elevator.h │ ├── errno.h │ ├── file.h │ ├── fs.h │ ├── fs_struct.h │ ├── gfp.h │ ├── init_task.h │ ├── interrupt.h │ ├── irq.h │ ├── jiffies.h │ ├── kernel.h │ ├── kobj_map.h │ ├── limits.h │ ├── list.h │ ├── mm.h │ ├── mmzone.h │ ├── mount.h │ ├── namei.h │ ├── namespace.h │ ├── notifier.h │ ├── page-flags.h │ ├── percpu.h │ ├── ptrace.h │ ├── rbtree.h │ ├── sched.h │ ├── security.h │ ├── signal.h │ ├── slab.h │ ├── thread_info.h │ ├── threads.h │ ├── timer.h │ ├── uio.h │ ├── vmalloc.h │ └── wait.h ├── acpi │ └── platform │ │ └── acenv.h ├── asm-generic │ └── div64.h ├── asm │ ├── atomic.h │ ├── bitops.h │ ├── cache.h │ ├── current.h │ ├── desc.h │ ├── dma.h │ ├── e820.h │ ├── errno.h │ ├── fixmap.h │ ├── highmem.h │ ├── hw_irq.h │ ├── i8259.h │ ├── io.h │ ├── io_ports.h │ ├── irq.h │ ├── irq_vectors.h │ ├── page.h │ ├── percpu.h │ ├── pgtable.h │ ├── processor.h │ ├── ptrace.h │ ├── segment.h │ ├── semaphore.h │ ├── signal.h │ ├── smp.h │ ├── string.h │ ├── system.h │ ├── thread_info.h │ ├── tlbflush.h │ └── unistd.h └── drivers │ └── disp.h ├── kernel.img ├── kernel ├── Makefile ├── bss.img ├── exit.c ├── fork.c ├── gasfunc.S ├── initramfs.c ├── irq │ └── manage.c ├── main.c ├── pid.c ├── printk.c ├── sched.c ├── softirq.c ├── sys.c └── timer.c ├── ldscript └── kernel.ld ├── lib ├── rbtree.c └── vsprintf.c ├── memorymap.txt ├── mm ├── bootmem.c ├── filemap.c ├── memory.c ├── mmap.c ├── page_alloc.c ├── pgtable.c ├── slab.c └── vmalloc.c ├── script └── prepare.sh ├── security ├── seabyon │ ├── av_permission.h │ ├── avc.c │ ├── hooks.c │ └── objsec.h └── security.c └── strace.log /Abyon.img: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RKX1209/TinyLinux/8bfcdbc2c85ec715470d4da7cf14bb5368563833/Abyon.img -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | IMGS = $(BOOT)/loader.img $(KERNEL)/kernel.img $(DRIVERS)/vram/fonts.bin 2 | HOME_DIR = $(CURDIR) 3 | USER_NAME = rkx 4 | 5 | #---Build Command--- 6 | CC = gcc 7 | CFLAGS = -fomit-frame-pointer -I$(HOME_DIR)/include -masm=intel -Wall 8 | LFLAGS = -T kernel_ld -Map kernel.map -nostdlib -e kernel_main --oformaty binary 9 | ASFLAGS = -msyntax=intel -march=i686 --32 10 | NASM = nasm 11 | LD = ld 12 | DD = dd 13 | MAKE = make 14 | #------------------- 15 | 16 | CP = cp 17 | MV = mv 18 | RM = rm 19 | CD = cd 20 | CAT = cat 21 | SUDO = sudo 22 | WHOAMI = whoami 23 | GRUB_INSTALL = grub-install 24 | 25 | #---Module path------- 26 | COMPILE_PATH = /tmp/Abyon 27 | BOOT = boot 28 | KERNEL = kernel 29 | ARCH = arch 30 | DRIVERS = drivers 31 | #--------------------- 32 | 33 | #---Virtual Loop Device--- 34 | SET_LPDEV = losetup 35 | LPDEV = /dev/loop0 36 | LPDEV_IMG = loop_device.img 37 | MNT_PATH = /media/$(USER_NAME) 38 | #------------------------- 39 | 40 | 41 | $(BOOT)/loader.img : Makefile 42 | ($(CD) $(BOOT);$(MAKE)) 43 | 44 | $(KERNEL)/kernel.img : Makefile 45 | ($(CD) $(KERNEL);$(MAKE) img) 46 | 47 | Abyon.img : $(IMGS) Makefile 48 | $(CAT) $(IMGS) > AbyonPlain.img 49 | $(DD) if=AbyonPlain.img of=Abyon.img conv=sync 50 | 51 | img : 52 | $(MAKE) Abyon.img 53 | 54 | install : 55 | ./script/prepare.sh 56 | ($(CD) $(COMPILE_PATH);$(MAKE) img) 57 | $(MV) $(COMPILE_PATH)/Abyon.img $(HOME_DIR)/Abyon.img 58 | 59 | #$(RM) -r $(COMPILE_PATH) 60 | init : 61 | $(DD) if=/dev/zero of=$(LPDEV_IMG) bs=1k count=1440 62 | $(SUDO) $(SET_LPDEV) $(LPDEV) $(LPDEV_IMG) 63 | $(SUDO) mkdosfs $(LPDEV) 64 | $(SUDO) mount -t vfat $(LPDEV) $(MNT_PATH) 65 | 66 | del : 67 | $(SUDO) umount $(LPDEV) 68 | $(SUDO) $(SET_LPDEV) -d $(LPDEV) 69 | 70 | clean : 71 | $(SUDO) $(RM) *.img 72 | ($(CD) $(BOOT);$(MAKE) clean) 73 | ($(CD) $(KERNEL);$(MAKE) clean) 74 | 75 | %.o : %.c Makefile 76 | $(CC) -c -o $*.o $*.c -O2 -Wall 77 | 78 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Tiny Linux 2 | ====================== 3 | **Author: rkx1209** 4 | **Overview:** 5 | Tiny kernel aimed to linux like system. 6 | It haven't been stable yet and you should be carefull when running. 7 | (explain more detail below) 8 | 9 | Installation 10 | --------------- 11 | ``` shell 12 | $ git clone https://github.com/RKX1209/TinyLinux 13 | $ cd TinyLinux 14 | $ make install 15 | ``` 16 | After building, 'Abyon.img' will be deployed in your current directory. 17 | It is the body of Abyon kernel itself. 18 | 19 | [**NOTICE**] 20 | **When you run 'make install', makefile create directory /tmp/Abyon and start building project there.** 21 | **You should be carefull of name collision to your own file under /tmp directory.** 22 | 23 | How to use 24 | --------------- 25 | (Example using qemu virtual machine) 26 | ``` shell 27 | $ qemu-system-i386 -m 4000 -fda Abyon.img 28 | ``` 29 | You can run this kernel by using virtual machine, like QEMU, Bochs...etc 30 | **Please don't run on real machine because it can make trouble.** 31 | This kernel only supports i386 system. 32 | 33 | 34 | License 35 | ---------- 36 | Copyright © 2014 rkx1209 37 | Licensed under the [GNU General Public License Version 2.0][GPL2] 38 | 39 | [GPL2]: http://www.gnu.org/licenses/gp2.html 40 | -------------------------------------------------------------------------------- /arch/Makefile: -------------------------------------------------------------------------------- 1 | SRCS = $(KERNEL)/head.S 2 | 3 | HOME_DIR = .. 4 | USER_NAME = rkx 5 | 6 | #---Build Command--- 7 | CC = gcc 8 | CFLAGS = -fomit-frame-pointer -I$(HOME_DIR)/include -Wall 9 | LFLAGS = -m elf_i386 --oformat binary -T $(LD_SCRIPT) -Map kernel.map -nostdlib -e $(KERNEL_ENTRY) -arch i386 10 | LFLAGS2 = -m elf_i386 -T $(LD_SCRIPT) -Map kernel.map -nostdlib -e $(KERNEL_ENTRY) -arch i386 11 | ASFLAGS = -c -m32 -I$(HOME_DIR)/include 12 | NASM = nasm 13 | LD = ld 14 | MAKE = make 15 | #------------------- 16 | 17 | CP = cp 18 | RM = rm 19 | CD = cd 20 | CAT = cat 21 | SUDO = sudo 22 | 23 | BOOT = boot 24 | KERNEL = kernel 25 | 26 | LD_SCRIPT_PATH = $(HOME_DIR)/ldscript 27 | LD_SCRIPT = $(LD_SCRIPT_PATH)/kernel.ld 28 | KERNEL_ENTRY = startup_32 29 | 30 | arch.o : $(SRCS) Makefile 31 | $(CC) -m32 -nostdlib -o arch.o $(SRCS) $(CFLAGS) 32 | 33 | default : 34 | $(MAKE) arch.o 35 | 36 | clean : 37 | $(SUDO) $(RM) *.img 38 | 39 | %.o : %.c Makefile 40 | $(CC) -m32 -c -o $*.o $*.c -O2 -Wall 41 | 42 | %.o : %.asm Makefile 43 | $(NASM) -f elf32 -o $*.o $*.asm 44 | 45 | -------------------------------------------------------------------------------- /arch/i386/kernel/cpu/common.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/cpu/common.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | #include 11 | 12 | extern int printk(const char *fmt, ...); 13 | 14 | /* [TODO] Init CPU(SMP) info, thread, */ 15 | 16 | void cpu_init(void){ 17 | int cpu = smp_processor_id(); 18 | printk("Initializing CPU#%d",cpu); 19 | struct tss_struct * t = &per_cpu(init_tss,cpu); 20 | struct thread_struct * thread = ¤t->thread; 21 | struct desc_struct *gdt = get_cpu_gdt_table(cpu); 22 | //memcpy(gdt,cpu_gdt_table,GDT_SIZE); 23 | //cpu_gdt_descr[cpu].size = GDT_SIZE - 1; 24 | //cpu_gdt_descr[cpu].address = (unsigned long)gdt; 25 | 26 | //printk("GDTbef(desc) = 0x%x",ga); 27 | 28 | //unsigned long *gp = (unsigned long)(&cpu_gdt_descr[cpu]); 29 | //unsigned long *ip = (unsigned long)(&idt_descr); 30 | 31 | //printk("gdt_descr[0](0x%x)",&cpu_gdt_descr[cpu]); 32 | //printk("idt_descr(0x%x)",&idt_descr); 33 | 34 | //load_gdt(&cpu_gdt_descr[cpu]); 35 | /* __asm__ __volatile__("movl $0x60,%edx ; movl %edx,%cs"); */ 36 | /* __asm__ __volatile__("movl $0x68,%edx ; movl %edx,%ds"); */ 37 | load_idt(&idt_descr); 38 | init_mm.mm_count++; 39 | current_thread_info()->status = 0; 40 | 41 | /* Delete NT flag */ 42 | __asm__("pushfl ; andl $0xffffbfff,(%esp) ; popfl"); 43 | 44 | unsigned long long ia,ga; 45 | //load_esp0(t,thread); 46 | set_tss_desc(cpu,t); 47 | load_TR_desc(); 48 | 49 | store_idt(&ia); 50 | store_gdt(&ga); 51 | printk("GDT(desc) = 0x%x",ga); 52 | printk("IDT(desc) = 0x%x",ia); 53 | //printk("ia(0x%x)",&ia); 54 | //printk("esp0 = 0x%x",t->esp0); 55 | __asm__ __volatile__("xorl %eax, %eax; movl %eax, %fs; movl %eax, %gs"); 56 | } 57 | -------------------------------------------------------------------------------- /arch/i386/kernel/entry.S: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/entry.S 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #define __ASSEMBLY__ 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | EBX = 0x00 13 | ECX = 0x04 14 | EDX = 0x08 15 | ESI = 0x0C 16 | EDI = 0x10 17 | EBP = 0x14 18 | EAX = 0x18 19 | DS = 0x1C 20 | ES = 0x20 21 | ORIG_EAX = 0x24 22 | EIP = 0x28 23 | CS = 0x2C 24 | EFLAGS = 0x30 25 | OLDESP = 0x34 26 | OLDSS = 0x38 27 | 28 | CF_MASK = 0x00000001 29 | TF_MASK = 0x00000100 30 | IF_MASK = 0x00000200 31 | DF_MASK = 0x00000400 32 | NT_MASK = 0x00004000 33 | VM_MASK = 0x00020000 34 | 35 | #define resume_kernel restore_nocheck /* kernel non preemption */ 36 | 37 | #define SAVE_ALL \ 38 | cld; \ 39 | pushl %es; \ 40 | pushl %ds; \ 41 | pushl %eax; \ 42 | pushl %ebp; \ 43 | pushl %edi; \ 44 | pushl %esi; \ 45 | pushl %edx; \ 46 | pushl %ecx; \ 47 | pushl %ebx; \ 48 | 49 | #define RESTORE_INT_REGS \ 50 | popl %ebx; \ 51 | popl %ecx; \ 52 | popl %edx; \ 53 | popl %esi; \ 54 | popl %edi; \ 55 | popl %ebp; \ 56 | popl %eax 57 | 58 | #define RESTORE_REGS \ 59 | RESTORE_INT_REGS; \ 60 | 1: popl %ds; \ 61 | 2: popl %es; \ 62 | /*.section .fixup,"ax"; \ 63 | 3: movl $0,(%esp); \ 64 | jmp 1b; \ 65 | 4: movl $0,(%esp); \ 66 | jmp 2b; \ 67 | .previous; \ 68 | .section __ex_table,"a";\ 69 | .align 4; \ 70 | .long 1b,3b; \ 71 | .long 2b,4b; \ 72 | .previous 73 | */ 74 | 75 | ret_from_exception: 76 | ret_from_intr: 77 | GET_THREAD_INFO(%ebp) 78 | movl EFLAGS(%esp), %eax 79 | movb CS(%esp),%al 80 | testl $(VM_MASK | 3), %eax /* VM mode or user mode */ 81 | jz resume_kernel 82 | resume_userspace: 83 | cli 84 | movl 0x8(%ebp), %ecx 85 | andl $_TIF_WORK_MASK, %ecx 86 | //jne work_pending 87 | jmp restore_all 88 | 89 | /* resume_kernel: 90 | cli 91 | cmpl $0, 0x14(%ebp) 92 | jnz restore_nocheck */ 93 | 94 | restore_all: 95 | movl EFLAGS(%esp), %eax 96 | movb OLDSS(%esp), %ah 97 | movb CS(%esp), %al 98 | andl $(VM_MASK | (4 << 8) | 3), %eax 99 | cmpl $((4 << 8) | 3), %eax 100 | //je ldt_ss 101 | restore_nocheck: 102 | RESTORE_REGS 103 | addl $4, %esp 104 | 1: iret 105 | 106 | work_pending: 107 | nop 108 | 109 | #define FIXUP_ESPFIX_STACK \ 110 | nop ; 111 | 112 | #define UNWIND_ESPFIX_STACK \ 113 | pushl %eax ; \ 114 | movl %ss,%eax ;\ 115 | cmpw $__ESPFIX_SS,%ax ;\ 116 | jne 28f ;\ 117 | movl $__KERNEL_DS, %edx ;\ 118 | movl %edx, %ds ;\ 119 | movl %edx, %es ;\ 120 | FIXUP_ESPFIX_STACK \ 121 | 28: popl %eax ; 122 | 123 | 124 | .data 125 | .global interrupt 126 | interrupt: 127 | .text 128 | vector=0 129 | .global irq_entries_start 130 | irq_entries_start: 131 | .rept NR_IRQS 132 | pushl $vector-256 133 | jmp common_interrupt 134 | .data 135 | .long irq_entries_start 136 | .text 137 | vector=vector+1 138 | .endr 139 | 140 | common_interrupt: 141 | SAVE_ALL 142 | movl %esp,%eax 143 | call do_IRQ 144 | jmp ret_from_intr 145 | 146 | .global system_call 147 | system_call: 148 | syscall_exit: 149 | syscall_exit_work: 150 | jmp resume_userspace 151 | 152 | .global divide_error 153 | divide_error: 154 | pushl $0 155 | pushl $do_divide_error 156 | .align 16,0x90 157 | error_code: 158 | pushl %ds 159 | pushl %eax 160 | xorl %eax,%eax 161 | pushl %ebp 162 | pushl %edi 163 | pushl %esi 164 | pushl %edx 165 | decl %eax 166 | pushl %ecx 167 | pushl %ebx 168 | cld 169 | pushl %es 170 | UNWIND_ESPFIX_STACK 171 | popl %ecx 172 | movl ES(%esp),%edi /* address of int handler */ 173 | movl ORIG_EAX(%esp), %edx /* Error code */ 174 | movl %eax, ORIG_EAX(%esp) 175 | movl %ecx,ES(%esp) 176 | movl $(__USER_DS),%ecx /* Change data segment(user mode) */ 177 | movl %ecx,%ds 178 | movl %ecx,%es 179 | movl %esp,%eax 180 | call *%edi 181 | jmp ret_from_exception 182 | 183 | .global coprocessor_error 184 | coprocessor_error: 185 | pushl $0 186 | pushl $do_coprocessor_error 187 | jmp error_code 188 | 189 | .global simd_coprocessor_error 190 | simd_coprocessor_error: 191 | pushl $0 192 | pushl $do_simd_coprocessor_error 193 | jmp error_code 194 | 195 | .global device_not_available 196 | device_not_available: 197 | jmp ret_from_exception 198 | 199 | .global debug 200 | debug: 201 | call do_debug 202 | jmp ret_from_exception 203 | 204 | .global nmi 205 | nmi: 206 | jmp restore_all 207 | 208 | .global int3 209 | int3: 210 | pushl $-1 211 | SAVE_ALL 212 | xorl %edx,%edx 213 | movl %esp,%eax 214 | call do_int3 215 | jmp ret_from_exception 216 | 217 | 218 | .global overflow 219 | overflow: 220 | pushl $0 221 | pushl $do_overflow 222 | jmp error_code 223 | 224 | .global bounds 225 | bounds: 226 | pushl $0 227 | pushl $do_bounds 228 | jmp error_code 229 | 230 | .global invalid_op 231 | invalid_op: 232 | pushl $0 233 | pushl $do_invalid_op 234 | jmp error_code 235 | 236 | .global coprocessor_segment_overrun 237 | coprocessor_segment_overrun: 238 | pushl $0 239 | pushl $do_coprocessor_segment_overrun 240 | jmp error_code 241 | 242 | .global invalid_TSS 243 | invalid_TSS: 244 | pushl $do_invalid_TSS 245 | jmp error_code 246 | 247 | .global segment_not_present 248 | segment_not_present: 249 | pushl $do_segment_not_present 250 | jmp error_code 251 | 252 | .global stack_segment 253 | stack_segment: 254 | pushl $do_stack_segment 255 | jmp error_code 256 | 257 | .global general_protection 258 | general_protection: 259 | pushl $do_general_protection 260 | jmp error_code 261 | .previous .text 262 | 263 | .global alignment_check 264 | alignment_check: 265 | pushl $do_alignment_check 266 | jmp error_code 267 | 268 | .global page_fault 269 | page_fault: 270 | pushl $do_page_fault 271 | jmp error_code 272 | 273 | .global spurious_interrupt_bug 274 | spurious_interrupt_bug: 275 | pushl $0 276 | pushl $do_spurious_interrupt_bug 277 | jmp error_code 278 | -------------------------------------------------------------------------------- /arch/i386/kernel/head.S: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/head.S 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | /* 8 | 32-bit kernel entrypoint 9 | */ 10 | 11 | 12 | .text 13 | 14 | .global startup_32 15 | .global kernel_main 16 | .global init_pg_tables_end 17 | 18 | #include 19 | #define __PAGE_OFFSET 0xC0000000 20 | #define INIT_MAP_BEYOND_END (128*1024) 21 | 22 | /* "foo - __PAGE_OFFSET" expression must be used 23 | * if you wanna change virtual address to physical address 24 | * in "straight map area" 25 | */ 26 | startup_32: 27 | /* Set temporary segments */ 28 | cld 29 | lgdt cpu_gdt_descr 30 | movl $(_data_init_task_end),%esp 31 | movl $(_data_init_task_end),%ebp 32 | movl $(__KERNEL_DS),%eax 33 | 34 | movl %eax,%ds 35 | movl %eax,%es 36 | movl %eax,%fs 37 | movl %eax,%gs 38 | movl %eax,%ss 39 | 40 | /* Clear BSS */ 41 | xorl %eax, %eax 42 | movl $_bss_start ,%edi 43 | movl $_bss_end ,%ecx 44 | subl %edi,%ecx 45 | shrl $2,%ecx 46 | rep ; stosl 47 | 48 | /* Set global directory for (8-MB) temporary memory 49 | * EAX = page frame number 50 | */ 51 | /*page_pde_offset = (__PAGE_OFFSET >> 22); 52 | 53 | movl $(pg0 ), %edi 54 | movl $(swapper_pg_dir ), %edx 55 | movl $0x007, %eax 56 | 10: 57 | leal 0x007(%edi),%ecx 58 | movl %ecx,(%edx) 59 | movl %ecx,page_pde_offset(%edx) 60 | addl $4,%edx 61 | movl $1024, %ecx 62 | 11: 63 | stosl 64 | addl $0x1000,%eax 65 | loop 11b 66 | //movl %edi,(init_pg_tables_end ) 67 | 68 | 10: 69 | leal 0x007(%edi),%ecx 70 | movl %ecx,(%edx) 71 | movl %ecx,page_pde_offset(%edx) 72 | addl $4,%edx 73 | movl $1024, %ecx 74 | 11: 75 | stosl 76 | addl $0x1000,%eax 77 | loop 11b 78 | */ 79 | /* 80 | * Enable paging 81 | */ 82 | /* movl $swapper_pg_dir,%eax 83 | movl %eax,%cr3 84 | movl %cr0,%eax 85 | orl $0x80000000,%eax 86 | movl %eax,%cr0*/ 87 | ljmp $__KERNEL_CS,$1f /* Clear prefetch and normalize %eip */ 88 | 1: 89 | pushl $0 90 | popfl 91 | 92 | call setup_idt 93 | call kernel_main 94 | /* sets up a idt with 256 entries pointing to 95 | * ignore_int(default interupt handler) 96 | */ 97 | setup_idt: 98 | lea ignore_int,%edx 99 | movl $(__KERNEL_CS << 16),%eax 100 | movw %dx,%ax 101 | movw $0x8e00,%dx 102 | 103 | lea idt_table,%edi 104 | mov $256,%ecx 105 | per_idt: 106 | movl %eax,(%edi) 107 | movl %edx,4(%edi) 108 | addl $8,%edi 109 | dec %ecx 110 | jne per_idt 111 | ret 112 | /* default interrupt handler */ 113 | ignore_int: 114 | cld 115 | iret 116 | 117 | /* 118 | * Initialize eflags. Some BIOS's leave bits like NT set. This would 119 | * confuse the debugger if this code is traced. 120 | * XXX - best to initialize before switching to protected mode. 121 | */ 122 | 123 | .data 124 | 125 | stack_begin: 126 | .fill 4096,1,0 127 | .word 0 128 | stack_end: 129 | .fill 256,1,0 130 | 131 | .global idt_descr 132 | .global cpu_gdt_descr 133 | .global boot_gdt_table 134 | 135 | .align 4096 136 | # early boot GDT descriptor (must use 1:1 address mapping) 137 | boot_gdt_descr: 138 | .word __BOOT_DS+7 139 | .long boot_gdt_table 140 | 141 | .align 4096 142 | idt_descr: 143 | .word IDT_ENTRIES*8-1 # idt contains 256 entries 144 | .long idt_table 145 | 146 | # boot GDT descriptor (later on used by CPU#0): 147 | 148 | .align 4096 # 32 bit align gdt_desc.address 149 | cpu_gdt_descr: 150 | .word GDT_ENTRIES*8-1 151 | .long cpu_gdt_table 152 | 153 | .align 4096 154 | boot_gdt_table: 155 | .fill GDT_ENTRY_BOOT_CS,8,0 156 | .quad 0x00cf9a000000ffff /* kernel 4GB code at 0x00000000 */ 157 | .quad 0x00cf92000000ffff /* kernel 4GB data at 0x00000000 */ 158 | 159 | .align 4096 160 | .global cpu_gdt_table 161 | cpu_gdt_table: 162 | .quad 0x0000000000000000 /* NULL descriptor */ 163 | .quad 0x0000000000000000 /* 0x0b reserved */ 164 | .quad 0x0000000000000000 /* 0x13 reserved */ 165 | .quad 0x0000000000000000 /* 0x1b reserved */ 166 | .quad 0x0000000000000000 /* 0x20 unused */ 167 | .quad 0x0000000000000000 /* 0x28 unused */ 168 | .quad 0x0000000000000000 /* 0x33 TLS entry 1 */ 169 | .quad 0x0000000000000000 /* 0x3b TLS entry 2 */ 170 | .quad 0x0000000000000000 /* 0x43 TLS entry 3 */ 171 | .quad 0x0000000000000000 /* 0x4b reserved */ 172 | .quad 0x0000000000000000 /* 0x53 reserved */ 173 | .quad 0x0000000000000000 /* 0x5b reserved */ 174 | 175 | .quad 0x00cf9a000000ffff /* 0x60 kernel 4GB code at 0x00000000 */ 176 | .quad 0x00cf92000000ffff /* 0x68 kernel 4GB data at 0x00000000 */ 177 | .quad 0x00cffa000000ffff /* 0x73 user 4GB code at 0x00000000 */ 178 | .quad 0x00cff2000000ffff /* 0x7b user 4GB data at 0x00000000 */ 179 | 180 | .quad 0x0000000000000000 /* 0x80 TSS descriptor */ 181 | .quad 0x0000000000000000 /* 0x88 LDT descriptor */ 182 | 183 | /* Segments used for calling PnP BIOS */ 184 | .quad 0x00c09a0000000000 /* 0x90 32-bit code */ 185 | .quad 0x00809a0000000000 /* 0x98 16-bit code */ 186 | .quad 0x0080920000000000 /* 0xa0 16-bit data */ 187 | .quad 0x0080920000000000 /* 0xa8 16-bit data */ 188 | .quad 0x0080920000000000 /* 0xb0 16-bit data */ 189 | /* 190 | * The APM segments have byte granularity and their bases 191 | * and limits are set at run time. 192 | */ 193 | .quad 0x00409a0000000000 /* 0xb8 APM CS code */ 194 | .quad 0x00009a0000000000 /* 0xc0 APM CS 16 code (16 bit) */ 195 | .quad 0x0040920000000000 /* 0xc8 APM DS data */ 196 | 197 | .quad 0x0000920000000000 /* 0xd0 - ESPFIX 16-bit SS */ 198 | .quad 0x0000000000000000 /* 0xd8 - unused */ 199 | .quad 0x0000000000000000 /* 0xe0 - unused */ 200 | .quad 0x0000000000000000 /* 0xe8 - unused */ 201 | .quad 0x0000000000000000 /* 0xf0 - unused */ 202 | .quad 0x0000000000000000 /* 0xf8 - GDT entry 31: double-fault TSS */ 203 | 204 | .section ".data.idt","w" 205 | idt_table: 206 | 207 | .bss 208 | .global swapper_pg_dir 209 | swapper_pg_dir: 210 | .fill 1024,4,0 211 | empty_zero_page: 212 | .fill 4096,1,0 213 | .fill 4096,1,0 214 | -------------------------------------------------------------------------------- /arch/i386/kernel/i8259.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/i8259.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #include 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | extern int printk(const char *fmt, ...); 13 | extern void set_intr_gate(unsigned int n, void *addr); 14 | extern void setup_pit_timer(void); 15 | extern int setup_irq(unsigned int irq, struct irqaction *new); 16 | 17 | int no_action(int cpl, void *dev_id, struct pt_regs *regs) { return 0; } 18 | static struct irqaction irq2 = { no_action,0,"cascade",0,0}; 19 | 20 | unsigned int startup_8259A_irq(unsigned int irq){ 21 | enable_8259A_irq(irq); 22 | return 0; 23 | } 24 | 25 | #define shutdown_8259A_irq disable_8259A_irq 26 | 27 | void enable_8259A_irq(unsigned int irq){ 28 | } 29 | 30 | void disable_8259A_irq(unsigned int irq){ 31 | } 32 | 33 | static void mask_and_ack_8259A(unsigned int irq){ ; } 34 | 35 | static void end_8259A_irq(unsigned int irq){ 36 | if(!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS)) && 37 | irq_desc[irq].action) 38 | enable_8259A_irq(irq); 39 | } 40 | 41 | static struct hw_interrupt_type i8259A_irq_type = { 42 | .typename = "XT-PIC", 43 | .startup = startup_8259A_irq, 44 | .shutdown = shutdown_8259A_irq, 45 | .enable = enable_8259A_irq, 46 | .disable = disable_8259A_irq, 47 | .ack = mask_and_ack_8259A, 48 | .end = end_8259A_irq, 49 | }; 50 | 51 | void init_8259A(int auto_eoi){ 52 | outb(0xff,PIC_MASTER_IMR); 53 | outb(0xff,PIC_SLAVE_IMR); 54 | 55 | outb_p(0x11, PIC_MASTER_CMD); 56 | outb_p(0x20 + 0, PIC_MASTER_IMR); 57 | outb_p(1U << PIC_CASCADE_IR, PIC_MASTER_IMR); 58 | if (auto_eoi) 59 | outb_p(MASTER_ICW4_DEFAULT | PIC_ICW4_AEOI, PIC_MASTER_IMR); 60 | else 61 | outb_p(MASTER_ICW4_DEFAULT, PIC_MASTER_IMR); 62 | 63 | outb_p(0x11, PIC_SLAVE_CMD); 64 | outb_p(0x20 + 8, PIC_SLAVE_IMR); 65 | outb_p(PIC_CASCADE_IR, PIC_SLAVE_IMR); 66 | outb_p(SLAVE_ICW4_DEFAULT, PIC_SLAVE_IMR); 67 | if (auto_eoi) 68 | i8259A_irq_type.ack = disable_8259A_irq; 69 | else 70 | i8259A_irq_type.ack = mask_and_ack_8259A; 71 | //udelay(100); 72 | //outb(cached_master_mask, PIC_MASTER_IMR); 73 | //outb(cached_slave_mask, PIC_SLAVE_IMR); 74 | outb(0xfb, PIC_MASTER_IMR); 75 | outb(0xff, PIC_SLAVE_IMR); 76 | printk("Initializing PIC(8259A)... [OK]"); 77 | } 78 | 79 | void init_ISA_irqs(void){ 80 | init_8259A(0); 81 | unsigned long i; 82 | for(i = 0; i < NR_IRQS; i++){ 83 | irq_desc[i].status = IRQ_DISABLED; 84 | irq_desc[i].action = 0; 85 | irq_desc[i].depth = 1; 86 | if(i < 16){ 87 | irq_desc[i].handler = &i8259A_irq_type; 88 | }else{ 89 | irq_desc[i].handler = &no_irq_type; 90 | } 91 | } 92 | 93 | } 94 | 95 | void interrupt_stub(){ 96 | printk("interrupt happen"); 97 | __asm__ __volatile__("iret"); 98 | } 99 | 100 | void init_IRQ(void){ 101 | init_ISA_irqs(); 102 | unsigned long i; 103 | for(i = 0; i < (NR_VECTORS - FIRST_EXTERNAL_VECTOR); i++){ 104 | int vector = FIRST_EXTERNAL_VECTOR + i; 105 | if(i >= NR_IRQS) break; 106 | //interrupt[i] = interrupt_stub; 107 | //printk("idt_table[%d](0x%x)->0x%x",vector,&interrupt[i],interrupt[i]); 108 | if(vector != SYSCALL_VECTOR) set_intr_gate(vector,interrupt[i]); 109 | } 110 | setup_irq(2,&irq2); 111 | setup_pit_timer(); 112 | outb(0xf9, PIC_MASTER_IMR); 113 | outb(0xef, PIC_SLAVE_IMR); 114 | printk("init_IRQ... [OK]"); 115 | } 116 | -------------------------------------------------------------------------------- /arch/i386/kernel/init_task.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/init_task.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | /* struct mm_struct init_mm = INIT_MM(init_mm); */ 15 | 16 | /* struct task_struct init_task = INIT_TASK(init_task); */ 17 | 18 | struct mm_struct init_mm; 19 | 20 | struct task_struct init_task; 21 | 22 | union thread_union init_thread_union __attribute__((__section__(".data.init_task"))) = { INIT_THREAD_INFO(init_task) }; 23 | 24 | DEFINE_PER_CPU(struct tss_struct, init_tss) = INIT_TSS; 25 | -------------------------------------------------------------------------------- /arch/i386/kernel/irq.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/irq.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | extern int printk(const char *fmt, ...); 10 | 11 | fastcall unsigned int do_IRQ(struct pt_regs *regs){ 12 | int irq = regs->orig_eax & 0xff; 13 | __do_IRQ(irq,regs); 14 | return 1; 15 | } 16 | 17 | fastcall unsigned int __do_IRQ(unsigned int irq,struct pt_regs *regs){ 18 | printk("__do_IRQ 0x%x",irq); 19 | irq_desc_t *desc = irq_desc + irq; 20 | 21 | if(desc->handler->ack) desc->handler->ack(irq); 22 | unsigned long status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING); 23 | status |= IRQ_PENDING; 24 | 25 | struct irqaction *action = 0; 26 | if(!(status & (IRQ_DISABLED | IRQ_INPROGRESS))){ 27 | action = desc->action; 28 | status &= ~IRQ_PENDING; 29 | status |= IRQ_INPROGRESS; 30 | } 31 | desc->status = status; 32 | int action_ret = handle_IRQ_event(irq,regs,action); 33 | desc->status &= ~IRQ_INPROGRESS; 34 | desc->handler->end(irq); 35 | return 1; 36 | } 37 | 38 | fastcall int handle_IRQ_event(unsigned int irq,struct pt_regs *regs,struct irqaction *action){ 39 | int retval = 0; 40 | //if(!(action->flags & SA_INTERRUPT)) local_irq_enable(); 41 | while(action){ 42 | int ret = action->handler(irq,action->dev_id,regs); 43 | retval |~ ret; 44 | action = action->next; 45 | } 46 | return retval; 47 | } 48 | -------------------------------------------------------------------------------- /arch/i386/kernel/process.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/process.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | extern long do_fork(unsigned long,unsigned long,struct pt_regs *, 15 | unsigned long,int *,int *); 16 | 17 | extern void kernel_thread_helper(void); 18 | __asm__(".section .text\n" 19 | ".align 4\n" 20 | "kernel_thread_helper:\n\t" 21 | "movl %edx,%eax\n\t" 22 | "pushl %edx\n\t" 23 | "call *%ebx\n\t" 24 | "pushl %eax\n\t" 25 | "call do_exit\n" 26 | ".previous"); 27 | 28 | int kernel_thread(int (*fn)(void*),void *arg,unsigned long flags){ 29 | struct pt_regs regs; 30 | memset(®s,0,sizeof(regs)); 31 | regs.ebx = (unsigned long)fn; 32 | regs.edx = (unsigned long)arg; 33 | 34 | regs.xds = __USER_DS; 35 | regs.xes = __USER_DS; 36 | regs.xes = __KERNEL_CS; 37 | regs.eip = (unsigned long)kernel_thread_helper; 38 | return do_fork(flags,0,®s,0,0,0); 39 | 40 | } 41 | 42 | struct task_struct __attribute__((regparm(3))) * __switch_to(struct task_struct *prev_p,struct task_struct *next_p){ 43 | struct thread_struct *prev = &prev_p->thread,*next = &next_p->thread; 44 | int cpu = smp_processor_id(); 45 | struct tss_struct *tss = &per_cpu(init_tss,cpu); 46 | load_esp0(tss,next); 47 | /* __asm__ __volatile__("movl %%fs,%0":"=m" (*(int *)&prev->fs)); */ 48 | /* __asm__ __volatile__("movl %%gs,%0":"=m" (*(int *)&prev->gs)); */ 49 | 50 | 51 | } 52 | 53 | void cpu_idle(void){ 54 | while(1){ 55 | schedule(); 56 | } 57 | } 58 | 59 | int sys_execve(struct pt_regs regs){ 60 | char *filename = getname((char *)regs.ebx); 61 | int error = do_execve(filename, 62 | (char *)regs.ecx, 63 | (char *)regs.edx, 64 | ®s); 65 | return error; 66 | } 67 | -------------------------------------------------------------------------------- /arch/i386/kernel/setup.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/setup.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | #include 11 | #include 12 | 13 | extern int printk(const char *fmt, ...); 14 | extern unsigned long _fin_end; 15 | void paging_init(void); 16 | unsigned long init_pg_tables_end = ~0UL; 17 | 18 | void init_e820(){ 19 | e820.nr_map = 7; 20 | e820.map[0] = (struct e820entry){ 0x00000000,0x0009ffff, E820_RAM }; 21 | e820.map[1] = (struct e820entry){ 0x000f0000,65536, E820_RESERVED }; 22 | e820.map[2] = (struct e820entry){ 0x00100000,133103616, E820_RAM }; 23 | e820.map[3] = (struct e820entry){ 0x07ff0000,125841408, E820_ACPI }; 24 | e820.map[4] = (struct e820entry){ 0x07ff3000,53248, E820_ACPI }; 25 | e820.map[5] = (struct e820entry){ 0x08000000,4160684032, E820_RAM }; 26 | e820.map[6] = (struct e820entry){ 0xffff0000,65536, E820_RESERVED }; 27 | } 28 | 29 | /* Enable bootmem low pages */ 30 | static void register_bootmem_low_pages(unsigned long max_low_pfn){ 31 | int i; 32 | for(i = 0; i < e820.nr_map; i++){ 33 | if(e820.map[i].type != E820_RAM) continue; 34 | 35 | unsigned long cur_pfn = PFN_UP(e820.map[i].addr); 36 | if(cur_pfn >= max_low_pfn) continue; 37 | 38 | unsigned long last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size); 39 | if (last_pfn > max_low_pfn) 40 | last_pfn = max_low_pfn; 41 | 42 | if (last_pfn <= cur_pfn) 43 | continue; 44 | 45 | unsigned long size = last_pfn - cur_pfn; 46 | printk("Clearing... e820[%d](%d,%d)",i,cur_pfn,last_pfn); 47 | free_bootmem(cur_pfn << PAGE_SHIFT,size << PAGE_SHIFT); 48 | } 49 | } 50 | 51 | /* Setup bootmem allocator */ 52 | void setup_bootmem_allocator(void){ 53 | unsigned long bootmap_size = init_bootmem(min_low_pfn,max_low_pfn); 54 | /* free all 'enable' pages */ 55 | register_bootmem_low_pages(max_low_pfn); 56 | printk("Free bootmem pages"); 57 | /* reserve memory map itself */ 58 | reserve_bootmem(min_low_pfn << PAGE_SHIFT, 59 | ((min_low_pfn << PAGE_SHIFT) + bootmap_size + PAGE_SIZE - 1) - (min_low_pfn << PAGE_SHIFT)); 60 | 61 | //printk("reserve bit table[%d,]",min_low_pfn); 62 | reserve_bootmem(__PAGE_OFFSET, 63 | ((unsigned long)&(_fin_end) - __PAGE_OFFSET)); 64 | //printk("reserve kernel[%d,%d]",__PAGE_OFFSET >> PAGE_SHIFT,(unsigned long)(&_fin_end) >> PAGE_SHIFT); 65 | reserve_bootmem(0,PAGE_SIZE); 66 | //printk("reserve BIOS[%d,%d]",0,PAGE_SIZE >> PAGE_SHIFT); 67 | 68 | /* reserve BIOS EBDA region */ 69 | reserve_bootmem(0x40E,PAGE_SIZE); 70 | //printk("reserve EBDA[%d,%d]",0x40e >> PAGE_SHIFT,(0x40e + PAGE_SIZE) >> PAGE_SHIFT); 71 | } 72 | 73 | static unsigned long setup_memory(void){ 74 | init_e820(); 75 | //printk("init_e820"); 76 | 77 | min_low_pfn = (e820.map[0].addr + 0x7e00) >> PAGE_SHIFT; 78 | max_low_pfn = (e820.map[6].addr + e820.map[6].size - 1) >> PAGE_SHIFT; 79 | 80 | setup_bootmem_allocator(); 81 | return max_low_pfn; 82 | } 83 | /* setup arch part */ 84 | void setup_arch(){ 85 | printk("setup arch"); 86 | /* Setup memory informations */ 87 | setup_memory(); 88 | 89 | /* Setup page tables */ 90 | paging_init(); 91 | printk("setup arch ....[OK]"); 92 | } 93 | -------------------------------------------------------------------------------- /arch/i386/kernel/tail.S: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/tail.S 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | /* 8 | 32-bit kernel entrypoint 9 | */ 10 | 11 | .data 12 | .global kernel_end 13 | kernel_end: 14 | -------------------------------------------------------------------------------- /arch/i386/kernel/timers/timer_pit.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/timers/timer_pit.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #define LATCH 0x2e9c 10 | 11 | extern int printk(const char *fmt, ...); 12 | 13 | void setup_pit_timer(void){ 14 | unsigned long flags; 15 | outb_p(0x34,PIT_MODE); /* binary, mode 2, LSB/MSB, ch 0 */ 16 | //udelay(10); 17 | outb_p(LATCH & 0xff , PIT_CH0); /* LSB */ 18 | //udelay(10); 19 | outb(LATCH >> 8 , PIT_CH0); /* MSB */ 20 | printk("Initializing PIT... [OK]"); 21 | } 22 | -------------------------------------------------------------------------------- /arch/i386/kernel/timers/timer_tsc.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/timers/timer_tsc.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | /* Get now time */ 7 | unsigned long long sched_clock(void){ 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /arch/i386/kernel/traps.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/kernel/traps.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | extern int printk(const char *fmt, ...); 15 | extern void cpu_init(void); 16 | struct desc_struct idt_table[256] __attribute__((__section__(".data.idt"))) = { {0,0},}; 17 | 18 | /* IDT functions*/ 19 | int system_call(void); 20 | void divide_error(void); 21 | void debug(void); 22 | void nmi(void); 23 | void int3(void); 24 | void overflow(void); 25 | void bounds(void); 26 | void invalid_op(void); 27 | void device_not_available(void); 28 | void coprocessor_segment_overrun(void); 29 | void invalid_TSS(void); 30 | void segment_not_present(void); 31 | void stack_segment(void); 32 | void general_protection(void); 33 | void page_fault(void); 34 | void coprocessor_error(void); 35 | void simd_coprocessor_error(void); 36 | void alignment_check(void); 37 | void spurious_interrupt_bug(void); 38 | void machine_check(void); 39 | 40 | #define DO_ERROR(trapnr, signr, str, name) \ 41 | fastcall void do_##name() \ 42 | { \ 43 | return; \ 44 | } 45 | 46 | #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \ 47 | fastcall void do_##name() \ 48 | { \ 49 | printk("do_error_info"); \ 50 | return; \ 51 | } 52 | 53 | #define DO_VM86_ERROR(trapnr, signr, str, name) \ 54 | fastcall void do_##name() \ 55 | { \ 56 | return; \ 57 | } 58 | 59 | #define DO_VM86_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \ 60 | fastcall void do_##name() \ 61 | { \ 62 | return; \ 63 | } 64 | 65 | /* Define trap gate handlers */ 66 | DO_VM86_ERROR_INFO( 0, SIGFPE, "divide error", divide_error, FPE_INTDIV, regs->eip) 67 | DO_VM86_ERROR( 3, SIGTRAP, "int3", int3) 68 | DO_VM86_ERROR( 4, SIGSEGV, "overflow", overflow) 69 | DO_VM86_ERROR( 5, SIGSEGV, "bounds", bounds) 70 | DO_ERROR_INFO( 6, SIGILL, "invalid operand", invalid_op, ILL_ILLOPN, regs->eip) 71 | DO_ERROR( 9, SIGFPE, "coprocessor segment overrun", coprocessor_segment_overrun) 72 | DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS) 73 | DO_ERROR(11, SIGBUS, "segment not present", segment_not_present) 74 | DO_ERROR(12, SIGBUS, "stack segment", stack_segment) 75 | DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0) 76 | DO_ERROR_INFO(32, SIGSEGV, "iret exception", iret_error, ILL_BADSTK, 0) 77 | 78 | fastcall void do_general_protection(struct pt_regs * regs, long error_code){ 79 | } 80 | fastcall void do_nmi(struct pt_regs * regs, long error_code){ 81 | } 82 | fastcall void do_debug(struct pt_regs * regs, long error_code){ 83 | } 84 | fastcall void do_coprocessor_error(struct pt_regs * regs, long error_code){ 85 | } 86 | fastcall void do_simd_coprocessor_error(struct pt_regs * regs, long error_code){ 87 | } 88 | fastcall void do_spurious_interrupt_bug(struct pt_regs * regs, long error_code){ 89 | } 90 | fastcall void do_page_fault(struct pt_regs * regs, long error_code){ 91 | } 92 | 93 | #define _set_gate(gate_addr,type,dpl,addr,seg) \ 94 | do { \ 95 | int __d0, __d1; \ 96 | __asm__ __volatile__ ("movw %%dx,%%ax\n\t" \ 97 | "movw %4,%%dx\n\t" \ 98 | "movl %%eax,%0\n\t" \ 99 | "movl %%edx,%1" \ 100 | :"=m" (*((long *) (gate_addr))), \ 101 | "=m" (*(1+(long *) (gate_addr))), "=&a" (__d0), "=&d" (__d1) \ 102 | :"i" ((short) (0x8000+(dpl<<13)+(type<<8))), \ 103 | "3" ((char *) (addr)),"2" ((seg) << 16)); \ 104 | } while (0) 105 | 106 | void set_intr_gate(unsigned int n, void *addr){ 107 | _set_gate(idt_table+n,14,0,addr,__KERNEL_CS); 108 | } 109 | 110 | static inline void set_system_intr_gate(unsigned int n, void *addr){ 111 | _set_gate(idt_table+n, 14, 3, addr, __KERNEL_CS); 112 | } 113 | 114 | static void set_trap_gate(unsigned int n, void *addr){ 115 | _set_gate(idt_table+n,15,0,addr,__KERNEL_CS); 116 | } 117 | 118 | static void set_system_gate(unsigned int n, void *addr){ 119 | _set_gate(idt_table+n,15,3,addr,__KERNEL_CS); 120 | } 121 | 122 | static void set_task_gate(unsigned int n, unsigned int gdt_entry){ 123 | _set_gate(idt_table+n,5,0,0,(gdt_entry<<3)); 124 | } 125 | 126 | void trap_init(void){ 127 | set_trap_gate(0,÷_error); 128 | set_intr_gate(1,&debug); 129 | set_intr_gate(2,&nmi); 130 | set_system_intr_gate(3, &int3); /* int3-5 can be called from all */ 131 | set_system_gate(4,&overflow); 132 | set_system_gate(5,&bounds); 133 | set_trap_gate(6,&invalid_op); 134 | set_trap_gate(7,&device_not_available); 135 | //set_task_gate(8,GDT_ENTRY_DOUBLEFAULT_TSS); 136 | set_trap_gate(9,&coprocessor_segment_overrun); 137 | set_trap_gate(10,&invalid_TSS); 138 | set_trap_gate(11,&segment_not_present); 139 | set_trap_gate(12,&stack_segment); 140 | set_trap_gate(13,&general_protection); 141 | set_intr_gate(14,&page_fault); 142 | set_trap_gate(15,&spurious_interrupt_bug); 143 | set_trap_gate(16,&coprocessor_error); 144 | set_trap_gate(17,&alignment_check); 145 | set_trap_gate(19,&simd_coprocessor_error); 146 | 147 | set_system_gate(SYSCALL_VECTOR,&system_call); 148 | 149 | /* Set GDT,TSS,IDT...etc */ 150 | cpu_init(); 151 | 152 | printk("trap_init... [OK]"); 153 | return; 154 | } 155 | -------------------------------------------------------------------------------- /arch/i386/lib/bitops.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/lib/bitops.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | 8 | int find_next_zero_bit(const unsigned long *addr, int size, int offset){ 9 | unsigned long *p = ((unsigned long *) addr) + (offset >> 5); 10 | int set = 0, bit = offset & 31, res; 11 | 12 | if (bit) { 13 | __asm__("bsfl %1,%0\n\t" 14 | "jne 1f\n\t" 15 | "movl $32, %0\n" 16 | "1:" 17 | : "=r" (set) 18 | : "r" (~(*p >> bit))); 19 | if (set < (32 - bit)) 20 | return set + offset; 21 | set = 32 - bit; 22 | p++; 23 | } 24 | res = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr)); 25 | return (offset + set + res); 26 | 27 | } 28 | -------------------------------------------------------------------------------- /arch/i386/lib/memcpy.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/lib/memcpy.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | 8 | void *memcpy(void *to, void *from, int n) 9 | { 10 | return __memcpy(to, from, n); 11 | } 12 | 13 | void *memset(void *s, int c, int count) 14 | { 15 | return __memset(s, c, count); 16 | } 17 | -------------------------------------------------------------------------------- /arch/i386/mm/discontig.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/mm/discontig.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #include 6 | 7 | 8 | extern void setup_bootmem_allocator(void); 9 | /* Setup memory informations */ 10 | unsigned long setup_memory(void){ 11 | setup_bootmem_allocator(); 12 | } 13 | -------------------------------------------------------------------------------- /arch/i386/mm/init.c: -------------------------------------------------------------------------------- 1 | /* 2 | * arch/i386/mm/init.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | extern unsigned long _text_start; 21 | extern unsigned long _text_end; 22 | extern unsigned long _data_start; 23 | extern unsigned long _data_end; 24 | extern unsigned long _bss_start; 25 | extern unsigned long _bss_end; 26 | 27 | extern int printk(const char *fmt, ...); 28 | 29 | static inline int is_kernel_text(unsigned long addr){ 30 | if(_text_start <= addr && addr <= _text_end) return 1; 31 | return 0; 32 | } 33 | 34 | int page_is_ram(unsigned long pagenr){ 35 | unsigned long i; 36 | for(i = 0; i < e820.nr_map; i++){ 37 | if(e820.map[i].type != E820_RAM) continue; 38 | unsigned long addr = (e820.map[i].addr + PAGE_SIZE - 1) >> PAGE_SHIFT; 39 | unsigned long end = (e820.map[i].addr + e820.map[i].size) >> PAGE_SHIFT; 40 | if(addr <= pagenr && pagenr < end) return 1; 41 | } 42 | return 0; 43 | } 44 | void mem_init(void){ 45 | unsigned long pfn = 0,reservedpages = 0; 46 | free_all_bootmem_node(NODE_DATA(0)); 47 | for(pfn = 0; pfn < max_low_pfn; pfn++){ 48 | struct page *tmp = pfn_to_page(pfn); 49 | if(page_is_ram(pfn) && test_bit(PG_reserved,&tmp->flags)) reservedpages++; 50 | } 51 | unsigned long codesize = (unsigned long)&_text_end - (unsigned long)&_text_start; 52 | unsigned long datasize = (unsigned long)&_data_end - (unsigned long)&_data_start; 53 | unsigned long bsssize = (unsigned long)&_bss_end - (unsigned long)&_bss_start; 54 | unsigned long num_physpages = max_low_pfn; 55 | 56 | printk("Memory: %dk/%dk available (%dk kernel code, %dk reserved, %dk data, %dk bss", 57 | (unsigned long) nr_free_pages() << (PAGE_SHIFT-10), 58 | num_physpages << (PAGE_SHIFT-10), 59 | codesize >> 10, 60 | reservedpages << (PAGE_SHIFT-10), 61 | datasize >> 10, 62 | bsssize >> 10); 63 | 64 | } 65 | 66 | static pte_t *one_page_table_init(pgd_t *pgd){ 67 | if(pgd_none(*pgd)){ 68 | 69 | pte_t *page_table = (pte_t *) alloc_bootmem_low_pages(PAGE_SIZE); 70 | unsigned long ph_addr = (unsigned long)page_table;//Straight map area 71 | //printk("alloc pgd[%d] (0x%x)",i++,ph_addr); 72 | pgd->pgd = (ph_addr | _PAGE_TABLE); 73 | return page_table; 74 | } 75 | return pgd_pa_addr(*pgd,0); 76 | } 77 | 78 | static void page_table_range_init(unsigned long start,unsigned long end,pgd_t *pgd_base){ 79 | unsigned long vaddr = start; 80 | int pgd_idx = pgd_index(vaddr); 81 | pgd_t *pgd = pgd_base + pgd_idx; 82 | for(; (pgd_idx < PTRS_PER_PGD) && (vaddr < end); pgd++,pgd_idx++){ 83 | if(pgd_none(*pgd)){ 84 | //printk("none"); 85 | one_page_table_init(pgd); 86 | } 87 | vaddr += PGDIR_SIZE; 88 | } 89 | } 90 | 91 | pte_t *kmap_pte; 92 | pgprot_t kmap_prot; 93 | 94 | static void kmap_init(void){ 95 | unsigned long kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN); 96 | kmap_pte = pte_virtual_addr(pgd_offset_k(kmap_vstart),kmap_vstart); 97 | kmap_prot = PAGE_KERNEL; 98 | } 99 | 100 | static void permanent_kmaps_init(pgd_t *pgd_base){ 101 | pgd_t *pgd; 102 | pte_t *pte; 103 | unsigned long vaddr = PKMAP_BASE; 104 | page_table_range_init(vaddr,vaddr + PAGE_SIZE * LAST_PKMAP,pgd_base); 105 | 106 | pgd = swapper_pg_dir + pgd_index(vaddr); 107 | pte = pte_virtual_addr(pgd,vaddr); 108 | pte_t *pkmap_page_table = pte; 109 | } 110 | 111 | static void kernel_physical_mapping_init(pgd_t *pgd_base){ 112 | pgd_t *pgd; 113 | pte_t *pte; 114 | int pgd_idx,pte_idx; 115 | 116 | pgd = pgd_base; 117 | 118 | unsigned long address; 119 | unsigned long pfn = 0; 120 | for(pfn = 0; pfn < max_low_pfn; pfn++){ 121 | address = pfn * PAGE_SIZE; 122 | pgd_idx = pgd_index(address); 123 | pte_idx = pte_index(address); 124 | 125 | pte = one_page_table_init(&pgd[pgd_idx]); 126 | pte_t* pte_entry = &(pte[pte_idx]); 127 | 128 | if(is_kernel_text(address)) 129 | set_pte(pte_entry,pfn_pte(pfn,PAGE_KERNEL_EXEC)); 130 | else 131 | set_pte(pte_entry,pfn_pte(pfn,PAGE_KERNEL)); 132 | 133 | /*if(pfn < 2){ 134 | printk("virt:0x%x->pgd[%d](0x%x)=(0x%x)",address,pgd_idx,&pgd[pgd_idx],pgd[pgd_idx].pgd); 135 | printk("=>pte(0x%x) pte[%d](0x%x) ph[0x%x]",pte,pte_idx,pte_entry,pte_entry->pte_low); 136 | } */ 137 | 138 | } 139 | printk("Setting memory tables... [OK]"); 140 | } 141 | 142 | kmem_cache_t *pgd_cache; 143 | void pgtable_cache_init(void){ 144 | pgd_cache = kmem_cache_create("pgd", 145 | PTRS_PER_PGD*sizeof(pgd_t), 146 | PTRS_PER_PGD*sizeof(pgd_t),0,0,0); 147 | } 148 | 149 | static void pagetable_init(void){ 150 | /* Set page tables of "straight map area" */ 151 | pgd_t *pgd_base = (pgd_t*)swapper_pg_dir; 152 | kernel_physical_mapping_init(pgd_base); 153 | 154 | 155 | /* Set page tables of "fix map area" */ 156 | unsigned long fixed_vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PGDIR_MASK; 157 | page_table_range_init(fixed_vaddr,0,pgd_base); 158 | 159 | /* Set page tables of "HIGHMEM area" */ 160 | //permanent_kmaps_init(pgd_base); 161 | return; 162 | } 163 | 164 | void paging_init(void){ 165 | pagetable_init(); 166 | pgd_t* pgd_base = (pgd_t*)swapper_pg_dir; 167 | 168 | write_cr3(pgd_base); 169 | //unsigned long cr3i = read_cr3(); 170 | //unsigned long cr4i = read_cr4(); 171 | unsigned long cr0i = read_cr0(); 172 | cr0i |= 0x80000000; 173 | write_cr0(cr0i); 174 | __flush_tlb_all(); 175 | //kmap_init(); 176 | } 177 | -------------------------------------------------------------------------------- /boot/Makefile: -------------------------------------------------------------------------------- 1 | # OBJS_PROTUNIX = Main.o ProcMng.o System1.o 2 | OBJS_PROTUNIX = Main.o 3 | 4 | HOME_DIR = "$(CURDIR)" 5 | USER_NAME = rkx 6 | 7 | CC = gcc 8 | CFLAGS = -fomit-frame-pointer -O2 -I$(HOME_DIR)/include -masm=intel -Wall 9 | ASFLAGS = -msyntax=intel -march=i686 --32 10 | LFLAGS = -T linkerscript -Map kernel.map -nostdlib -e _kernel_entry --oformaty binary 11 | NASM = nasm 12 | LD = ld 13 | DD = dd 14 | CP = cp 15 | RM = rm 16 | CD = cd 17 | CAT = cat 18 | MAKE = make 19 | SUDO = sudo 20 | WHOAMI = whoami 21 | GRUB_INSTALL = grub-install 22 | 23 | 24 | default : 25 | $(MAKE) loader.img 26 | 27 | img : 28 | $(MAKE) loader.img 29 | 30 | clean : 31 | $(SUDO) $(RM) *.img 32 | 33 | %.o : %.c Makefile 34 | $(CC) -c -o $*.o $*.c -O2 -Wall 35 | 36 | 37 | loaderS1.img : loaderS1.asm Makefile 38 | $(NASM) -o loaderS1.img loaderS1.asm 39 | 40 | loaderS2.img : loaderS2.asm Makefile 41 | $(NASM) -o loaderS2.img loaderS2.asm 42 | 43 | loader.img : loaderS1.img loaderS2.img Makefile 44 | $(CAT) loaderS1.img loaderS2.img > loader.img 45 | -------------------------------------------------------------------------------- /boot/loaderS1.asm: -------------------------------------------------------------------------------- 1 | ;; Copyright (C) <2014> <@RKX1209> 2 | 3 | ;-------------------------------------- 4 | ; Boot Loader stage1 (located in MBR) | 5 | ;-------------------------------------- 6 | 7 | 8 | RETRY EQU 5 9 | CYLS EQU 40 10 | KERNEL EQU 0x0820 11 | 12 | 13 | ORG 0x7c00 ;Boot loader location 14 | 15 | ; FAT12 file system 16 | JMP boot 17 | DB 0x90 18 | BS_Name DB "ABYON " 19 | BS_BytePerSec DW 512 20 | BS_ClSize DB 1 21 | BS_FATentry DW 1 22 | BS_FATnum DB 2 23 | BS_RootdSize DW 224 24 | BS_DriveSize DW 2880 25 | BS_MediaType DB 0xf0 26 | BS_FATsize DW 9 27 | BS_SecPerTr DW 18 28 | BS_HeadNum DW 2 29 | DW 0 30 | DD 2880 31 | DB 0,0,0x29 32 | DD 0xffffffff 33 | BS_DiskName DB "ABYON " 34 | BS_FileSystem DB "FAT12 " 35 | TIMES 18 DB 0 36 | 37 | boot: 38 | ;; Init registers 39 | XOR AX,AX 40 | MOV SS,AX 41 | MOV SP,0x7c00 42 | MOV DS,AX 43 | 44 | MOV AX,KERNEL 45 | MOV ES,AX 46 | MOV CH,0 ; cylinder 0 47 | MOV DH,0 ; head 0 48 | MOV CL,2 ; sector 2 49 | 50 | readloop: 51 | MOV SI,0 52 | read: 53 | MOV AH,0x02 54 | MOV AL,1 55 | MOV BX,0 56 | MOV DL,0x00 57 | INT 0x13 58 | JNC readnext 59 | ADD SI,1 60 | CMP SI,RETRY 61 | JAE readfail 62 | MOV AH,0x00 63 | MOV DL,0x00 64 | INT 0x13 65 | JMP read 66 | 67 | readnext: 68 | MOV AX,ES 69 | ADD AX,0x0020 70 | MOV ES,AX 71 | ADD CL,1 72 | CMP CL,18 73 | JBE readloop 74 | MOV CL,1 75 | ADD DH,1 76 | CMP DH,2 77 | JB readloop 78 | MOV DH,0 79 | ADD CH,1 80 | CMP CH,CYLS 81 | JB readloop 82 | 83 | MOV [0x0ff0],CH 84 | JMP KERNEL:0x0 85 | 86 | readfail: 87 | MOV AX,0 88 | MOV ES,AX 89 | MOV SI,msg 90 | putloop: 91 | MOV AL,[SI] 92 | ADD SI,1 93 | CMP AL,0 94 | JE fin 95 | MOV AH,0x0e 96 | MOV BX,15 97 | INT 0x10 98 | JMP putloop 99 | fin: 100 | HLT 101 | JMP fin 102 | msg: 103 | DB 0x0a, 0x0a 104 | DB "load error" 105 | DB 0x0a 106 | DB 0 107 | 108 | TIMES 510 - ($ - $$) DB 0 109 | 110 | DW 0xAA55 111 | -------------------------------------------------------------------------------- /boot/loaderS2.asm: -------------------------------------------------------------------------------- 1 | ;; Copyright (C) <2014> <@RKX1209> 2 | 3 | ;------------------------------------------------ 4 | ; Boot Loader stage2 (loaded by stage1 loader ) | 5 | ;------------------------------------------------ 6 | 7 | 8 | KERNEL EQU 0x00100000 9 | DSKCDST EQU 0x00280000 10 | DSKCSRC EQU 0x00008000 11 | 12 | VBEMODE EQU 0x105 13 | CYLS EQU 0x0ff0 14 | LEDS EQU 0x0ff1 15 | VMODE EQU 0x0ff2 16 | SCRNX EQU 0x0ff4 17 | SCRNY EQU 0x0ff6 18 | VRAM EQU 0x0ff8 19 | 20 | ORG 0x08200 21 | 22 | JMP boot2 23 | 24 | boot2: 25 | ;; Init registers 26 | XOR AX,AX 27 | XOR BX,BX 28 | XOR CX,CX 29 | XOR DX,DX 30 | MOV DS,AX 31 | MOV ES,AX 32 | 33 | MOV AX,0x9000 34 | MOV SS,AX 35 | MOV SP,0xfffc 36 | 37 | ;; ;; VBE(?) 38 | ;; MOV AX,0x9000 39 | ;; MOV ES,AX 40 | ;; MOV DI,0 41 | ;; MOV AX,0x4f00 42 | ;; INT 0x10 43 | ;; CMP AX,0x004f 44 | ;; JNE scrn320 45 | 46 | ;; ;; VBE version(?) 47 | 48 | ;; MOV AX,[ES:DI+4] 49 | ;; CMP AX,0x0200 50 | ;; JB scrn320 ; if (AX < 0x0200) goto scrn320 51 | 52 | ;; ;; Monitor mode(?) 53 | ;; MOV CX,VBEMODE 54 | ;; MOV AX,0x4f01 55 | ;; INT 0x10 56 | ;; CMP AX,0x004f 57 | ;; JNE scrn320 58 | 59 | ;; ;; Confirm monitor mode(?) 60 | 61 | ;; CMP BYTE [ES:DI+0x19],8 62 | ;; JNE scrn320 63 | ;; CMP BYTE [ES:DI+0x1b],4 64 | ;; JNE scrn320 65 | ;; MOV AX,[ES:DI+0x00] 66 | ;; AND AX,0x0080 67 | ;; JZ scrn320 68 | 69 | ;; ;; Change monitor mode(?) 70 | 71 | ;; MOV BX,VBEMODE+0x4000 72 | ;; MOV AX,0x4f02 73 | ;; INT 0x10 74 | ;; MOV BYTE [VMODE],8 75 | ;; MOV AX,[ES:DI+0x12] 76 | ;; MOV [SCRNX],AX 77 | ;; MOV AX,[ES:DI+0x14] 78 | ;; MOV [SCRNY],AX 79 | ;; MOV EAX,[ES:DI+0x28] 80 | ;; MOV [VRAM],EAX 81 | ;; JMP keystatus 82 | 83 | scrn320: 84 | MOV AL,0x13 85 | MOV AH,0x00 86 | INT 0x10 87 | MOV BYTE [VMODE],8 88 | MOV WORD [SCRNX],320 89 | MOV WORD [SCRNY],200 90 | MOV DWORD [VRAM],0x000a0000 91 | 92 | ;; Get keyboard LED status using BIOS 93 | keystatus: 94 | MOV AH,0x02 95 | INT 0x16 ; keyboard BIOS 96 | MOV [LEDS],AL 97 | 98 | ;; PIC Init(?) 99 | MOV AL,0xff 100 | OUT 0x21,AL 101 | NOP 102 | OUT 0xa1,AL 103 | CLI 104 | 105 | ;; enable A20 106 | CALL waitkbdout 107 | MOV AL,0xd1 108 | OUT 0x64,AL 109 | CALL waitkbdout 110 | MOV AL,0xdf 111 | OUT 0x60,AL 112 | CALL waitkbdout 113 | 114 | ;; set gdt 115 | CALL set_gdt 116 | 117 | ;; Enter protected mode 118 | MOV EAX,CR0 119 | AND EAX,0x7fffffff 120 | OR EAX,0x00000001 121 | MOV CR0,EAX 122 | JMP pipelineflash 123 | 124 | pipelineflash: 125 | MOV AX,1*8 126 | MOV DS,AX 127 | MOV ES,AX 128 | MOV FS,AX 129 | MOV GS,AX 130 | MOV SS,AX 131 | 132 | ;; Transfer kernel_entry to "KERNEL" 133 | MOV ESI,kernel_entry 134 | MOV EDI,KERNEL 135 | MOV ECX,512*2048/4 136 | CALL memcpy 137 | 138 | ;; Transfer disk image to "DSKCDST" (Memory maped) 139 | 140 | ;; [*] Transfer bootsector 141 | MOV ESI,0x7c00 142 | MOV EDI,DSKCDST 143 | MOV ECX,512/4 144 | CALL memcpy 145 | 146 | ;; [*] Transfer image body 147 | MOV ESI,DSKCSRC+512 148 | MOV EDI,DSKCDST+512 149 | MOV ECX,0 150 | MOV CL,BYTE [CYLS] 151 | IMUL ECX,512*18*2/4 152 | SUB ECX,512/4 153 | CALL memcpy 154 | 155 | ;; Boot kernel 156 | JMP DWORD 2*8:0x00000000 157 | ;; JMP 0x280000 158 | FIN: 159 | HLT 160 | JMP FIN 161 | 162 | 163 | set_gdt: 164 | CLI 165 | PUSHA 166 | LGDT [gdt_info] 167 | STI 168 | POPA 169 | RET 170 | 171 | waitkbdout: 172 | IN AL,0x64 173 | AND AL,0x02 174 | IN AL,0x60 175 | JNZ waitkbdout 176 | RET 177 | 178 | memcpy: 179 | MOV EAX,[ESI] 180 | ADD ESI,4 181 | MOV [EDI],EAX 182 | ADD EDI,4 183 | SUB ECX,1 184 | JNZ memcpy 185 | RET 186 | 187 | gdt: 188 | RESB 8 189 | DW 0xffff,0x0000,0x9200,0x00cf 190 | DW 0xffff,0x0000,0x9a10,0x0047 191 | DW 0 192 | gdt_info: 193 | DW 8*3-1 194 | DD gdt 195 | 196 | kernel_entry: 197 | -------------------------------------------------------------------------------- /drivers/base/map.c: -------------------------------------------------------------------------------- 1 | /* 2 | * drivers/base/map.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #include 6 | 7 | struct kobj_map{ 8 | struct probe{ 9 | struct probe *next; 10 | unsigned long dev; 11 | unsigned long range; 12 | void *data; 13 | } *probes[255]; 14 | }; 15 | 16 | struct kobj_map *kobj_map_init(kobj_probe_t *base_probe){ 17 | struct kobj_map *p = kmalloc(sizeof(struct kobj_map),0); 18 | struct probe *base = kmalloc(sizeof(*base),0); 19 | if((p == 0) || (base == 0)){ 20 | kfree(p); 21 | kfree(base); 22 | return 0; 23 | } 24 | base->dev = 1; 25 | base->range = ~0; 26 | //base->get = base_probe; 27 | int i; 28 | for(i = 0; i < 255; i++) 29 | p->probes[i] = base; 30 | return p; 31 | } 32 | -------------------------------------------------------------------------------- /drivers/vram/disp.c: -------------------------------------------------------------------------------- 1 | /* 2 | * drivers/vram/disp.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | 8 | void putfont(char *vram, int xsize, int x, int y, char col, unsigned char *font){ 9 | 10 | int i,j; 11 | int ysize = 16; 12 | for(i = 0; i < ysize; i++){ 13 | char *p = vram + (y + i) * xsize + x; 14 | char d = font[i]; 15 | for(j = 0; j < 8; j++){ 16 | if(d & 0x01) 17 | p[7 - j] = col; 18 | d >>= 1; 19 | } 20 | } 21 | return; 22 | } 23 | 24 | /* Put string with font(16 x 8) */ 25 | /* char font_A[16] = { */ 26 | /* 0x00, 0x18, 0x18, 0x18, 0x18, 0x24, 0x24, 0x24, */ 27 | /* 0x24, 0x7e, 0x42, 0x42, 0x42, 0xe7, 0x00, 0x00 */ 28 | /* }; */ 29 | void flush_screen(){ 30 | char *p; 31 | unsigned long i; 32 | for(i = 0xa0000; i <= 0xaffff; i++){ 33 | p = (char *)i; 34 | *p = COL8_000000; 35 | } 36 | } 37 | 38 | void putfonts_str(char *vram, int xsize, int x, int y, char col, unsigned char *s, unsigned char *k){ 39 | int i = 0; 40 | unsigned char* font0 = k; 41 | 42 | for (i = 0; *s; s++,i++) { 43 | if(*s == '\n'){ 44 | y += 16; 45 | x = 0; 46 | }else{ 47 | putfont(vram, xsize, x, y, col, (unsigned char*)(font0 + *s * 16)); 48 | x += 8; 49 | } 50 | } 51 | return; 52 | } 53 | -------------------------------------------------------------------------------- /drivers/vram/disp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * drivers/vram/disp.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #define COL8_000000 0 7 | #define COL8_FF0000 1 8 | #define COL8_00FF00 2 9 | #define COL8_FFFF00 3 10 | #define COL8_0000FF 4 11 | #define COL8_FF00FF 5 12 | #define COL8_00FFFF 6 13 | #define COL8_FFFFFF 7 14 | #define COL8_C6C6C6 8 15 | #define COL8_840000 9 16 | #define COL8_008400 10 17 | #define COL8_848400 11 18 | #define COL8_000084 12 19 | #define COL8_840084 13 20 | #define COL8_008484 14 21 | #define COL8_848484 15 22 | 23 | extern char* font0; 24 | //char *font_dat = font0; /* font0 in ldscript */ 25 | void putfont(char *vram, int xsize, int x, int y, char col, char *font); 26 | void putfonts_str(char *vram, int xsize, int x, int y, char col, unsigned char *s, unsigned char *end, unsigned char *k); 27 | -------------------------------------------------------------------------------- /drivers/vram/fonts.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RKX1209/TinyLinux/8bfcdbc2c85ec715470d4da7cf14bb5368563833/drivers/vram/fonts.bin -------------------------------------------------------------------------------- /drivers/vram/hankaku.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RKX1209/TinyLinux/8bfcdbc2c85ec715470d4da7cf14bb5368563833/drivers/vram/hankaku.txt -------------------------------------------------------------------------------- /error.log: -------------------------------------------------------------------------------- 1 | qemu: fatal: Trying to execute code outside RAM or ROM at 0xc010007c 2 | 3 | EAX=00100224 EBX=00000000 ECX=00000000 EDX=0010022c 4 | ESI=00035000 EDI=00104a28 EBP=00000000 ESP=0000fffc 5 | EIP=c010007c EFL=00000202 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0 6 | ES =0018 00000000 ffffffff 00cf9300 DPL=0 DS [-WA] 7 | CS =0010 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-] 8 | SS =0008 00000000 ffffffff 00cf9300 DPL=0 DS [-WA] 9 | DS =0018 00000000 ffffffff 00cf9300 DPL=0 DS [-WA] 10 | FS =0018 00000000 ffffffff 00cf9300 DPL=0 DS [-WA] 11 | GS =0018 00000000 ffffffff 00cf9300 DPL=0 DS [-WA] 12 | LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT 13 | TR =0000 00000000 0000ffff 00008b00 DPL=0 TSS32-busy 14 | GDT= 00100104 0000001f 15 | IDT= 00000000 000003ff 16 | CR0=00000011 CR2=00000000 CR3=00100224 CR4=00000000 17 | DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000 18 | DR6=ffff0ff0 DR7=00000400 19 | CCS=00001000 CCD=00800007 CCO=ADDL 20 | EFER=0000000000000000 21 | FCW=037f FSW=0000 [ST=0] FTW=00 MXCSR=00001f80 22 | FPR0=0000000000000000 0000 FPR1=0000000000000000 0000 23 | FPR2=0000000000000000 0000 FPR3=0000000000000000 0000 24 | FPR4=0000000000000000 0000 FPR5=0000000000000000 0000 25 | FPR6=0000000000000000 0000 FPR7=0000000000000000 0000 26 | XMM00=00000000000000000000000000000000 XMM01=00000000000000000000000000000000 27 | XMM02=00000000000000000000000000000000 XMM03=00000000000000000000000000000000 28 | XMM04=00000000000000000000000000000000 XMM05=00000000000000000000000000000000 29 | XMM06=00000000000000000000000000000000 XMM07=00000000000000000000000000000000 30 | 中止 (コアダンプ) 31 | -------------------------------------------------------------------------------- /fs/binfmt_elf.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/binfmt_elf.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #include 13 | #include 14 | static int load_elf_binary(struct abyon_binprm *bprm, struct pt_regs *regs){ 15 | return 0; 16 | } 17 | 18 | static struct abyon_binfmt elf_format = { 19 | .load_binary = load_elf_binary 20 | }; 21 | 22 | static int init_elf_binfmt(void){ 23 | return register_binfmt(&elf_format); 24 | } 25 | -------------------------------------------------------------------------------- /fs/block_dev.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/block_dev.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include 15 | #include 16 | 17 | struct bdev_inode{ 18 | struct block_device bdev; 19 | struct inode vfs_inode; 20 | }; 21 | 22 | static struct kmem_cache * bdev_cachep; 23 | static struct file_system_type bd_type = { 24 | .name = "bdev", 25 | /* .get_sb = bd_get_sb, */ 26 | /* .kill_sb = kill_anon_super, */ 27 | }; 28 | 29 | struct super_block *blockdev_superblock; 30 | void bdev_cache_init(void){ 31 | bdev_cachep = kmem_cache_create("bdev_cache",sizeof(struct bdev_inode),0,0,0); 32 | int err = register_filesystem(&bd_type); 33 | struct vfsmount *bd_mnt = kern_mount(&bd_type); 34 | blockdev_superblock = bd_mnt->mnt_sb; 35 | } 36 | -------------------------------------------------------------------------------- /fs/char_dev.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/char_dev.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include 16 | #include 17 | 18 | static struct kobj_map *cdev_map; 19 | 20 | static struct kobject *base_probe(unsigned long dev, int *part,void *data){ 21 | return 0; 22 | } 23 | void chrdev_init(void){ 24 | cdev_map = kobj_map_init(base_probe); 25 | 26 | } 27 | -------------------------------------------------------------------------------- /fs/dcache.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/dcache.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #define GOLDEN_RATIO_PRIME 0x9e370001UL 14 | static unsigned int d_hash_shift; 15 | static unsigned int d_hash_mask; 16 | #define D_HASHBITS d_hash_shift 17 | #define D_HASHMASK d_hash_mask 18 | 19 | typedef struct kmem_cache kmem_cache_t; 20 | 21 | extern struct files_stat_struct files_stat; 22 | static unsigned int d_hash_mask; 23 | static unsigned int d_hash_shift; 24 | static struct hlist_head *dentry_hashtable; 25 | static unsigned long dhash_entries; 26 | 27 | extern void inode_init_early(void); 28 | extern int printk(const char *fmt, ...); 29 | 30 | static kmem_cache_t *dentry_cache; 31 | static LIST_HEAD(dentry_unused); 32 | 33 | /* SLAB cache for __getname() consumers */ 34 | kmem_cache_t *names_cachep; 35 | /* SLAB cache for file structures */ 36 | kmem_cache_t *filp_cachep; 37 | /* SLAB cache for inode */ 38 | kmem_cache_t *inode_cachep; 39 | 40 | void dcache_init_early(void){ 41 | dhash_entries = 1024; 42 | dentry_hashtable = alloc_large_system_hash("Dentry cache", 43 | sizeof(struct hlist_head), 44 | dhash_entries, 45 | 13, 46 | HASH_EARLY, 47 | &d_hash_shift, 48 | &d_hash_mask, 49 | 0); 50 | int loop; 51 | for(loop = 0; loop < (1 << d_hash_shift); loop++) 52 | INIT_HLIST_HEAD(&dentry_hashtable[loop]); 53 | } 54 | 55 | void vfs_caches_init_early(void){ 56 | printk("vfs_init_early..."); 57 | dcache_init_early(); 58 | inode_init_early(); 59 | printk("vfs_init_early... [OK]"); 60 | } 61 | 62 | static void dcache_init(unsigned long mempages){ 63 | dentry_cache = kmem_cache_create("dentry_cache", 64 | sizeof(struct dentry), 65 | 0,0,0,0); 66 | } 67 | 68 | static void inode_init(unsigned long mempages){ 69 | inode_cachep = kmem_cache_create("inode_cache", 70 | sizeof(struct inode), 71 | 0,0,0,0); 72 | } 73 | 74 | void files_init(unsigned long mempages){ 75 | int n = (mempages * (PAGE_SIZE / 1024)) / 10; 76 | files_stat.max_files = n; 77 | if(files_stat.max_files < NR_FILE) 78 | files_stat.max_files = NR_FILE; 79 | } 80 | 81 | extern void bdev_cache_init(void); 82 | extern void cdev_cache_init(void); 83 | 84 | void vfs_caches_init(unsigned long mempages){ 85 | unsigned long reserve = min((mempages - nr_free_pages()) * 3 / 2, 86 | mempages - 1); 87 | mempages -= reserve; 88 | names_cachep = kmem_cache_create("names_cache",PATH_MAX,0, 89 | 0,0,0); 90 | filp_cachep = kmem_cache_create("filp",sizeof(struct file),0, 91 | 0,0,0); 92 | dcache_init(mempages); 93 | inode_init(mempages); 94 | files_init(mempages); 95 | mnt_init(mempages); 96 | bdev_cache_init(); 97 | chrdev_init(); 98 | } 99 | 100 | void dput(struct dentry *dentry){ 101 | if(!dentry) return; 102 | dentry->d_count--; 103 | /* It has been referenced by some process yet */ 104 | if(dentry->d_count){ 105 | return; 106 | } 107 | if(list_empty(&dentry->d_lru)){ 108 | list_add(&dentry->d_lru,&dentry_unused); 109 | } 110 | return; 111 | } 112 | 113 | static inline struct hlist_head *d_hash(struct dentry *parent,unsigned long hash){ 114 | hash += ((unsigned long) parent ^ GOLDEN_RATIO_PRIME); 115 | hash = hash ^ ((hash ^ GOLDEN_RATIO_PRIME) >> D_HASHBITS); 116 | return dentry_hashtable + (hash & D_HASHMASK); 117 | } 118 | 119 | struct dentry * __d_lookup(struct dentry *parent,struct qstr *name){ 120 | unsigned int len = name->len; 121 | unsigned int hash = name->hash; 122 | const unsigned char *str = name->name; 123 | struct hlist_head *head = d_hash(parent,hash); 124 | struct dentry *found = 0; 125 | struct hlist_node *node; 126 | for(node = head->first; node; node = node->next){ 127 | struct dentry *dentry = list_entry(node,struct dentry,d_hash); 128 | struct qstr *qstr; 129 | if (dentry->d_name.hash != hash) 130 | continue; 131 | if (dentry->d_parent != parent) 132 | continue; 133 | qstr = &dentry->d_name; 134 | found = dentry; 135 | } 136 | return found; 137 | } 138 | 139 | struct dentry * d_lookup(struct dentry * parent, struct qstr * name) { 140 | struct dentry *dentry = 0; 141 | return dentry; 142 | } 143 | -------------------------------------------------------------------------------- /fs/elevator.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/elevator.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | inline int elv_try_merge(struct request *__rq,struct bio *bio){ 12 | int ret = 0; 13 | if(1){ 14 | if(__rq->sector + __rq->nr_sectors == bio->bi_sector) return 1; 15 | // else if(__rq->sector - __rq->nr_sectors == bio->bi_sector) return 1; 16 | } 17 | } 18 | 19 | int elv_merge(request_queue_t *q,struct request **req,struct bio *bio){ 20 | elevator_t *e = q->elevator; 21 | int ret; 22 | if(q->last_merge){ 23 | ret = elv_try_merge(q->last_merge,bio); 24 | if(ret){ 25 | *req = q->last_merge; 26 | return ret; 27 | } 28 | } 29 | return 0; 30 | } 31 | 32 | int elv_queue_empty(request_queue_t *q){ 33 | elevator_t *e = q->elevator; 34 | if(!list_empty(&q->queue_head)) return 0; 35 | return 1; 36 | } 37 | -------------------------------------------------------------------------------- /fs/exec.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/exec.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #include 14 | #include 15 | 16 | static struct abyon_binfmt *formats; 17 | 18 | int register_binfmt(struct abyon_binfmt *fmt){ 19 | struct abyon_binfmt ** tmp = &formats; 20 | while(*tmp){ 21 | tmp = &(*tmp)->next; 22 | } 23 | fmt->next = formats; 24 | formats = fmt; 25 | return 0; 26 | } 27 | 28 | struct file *open_exec(const char *name){ 29 | struct nameidata nd; 30 | struct file *file; 31 | int err = path_lookup(name,0,&nd); 32 | if(!err){ 33 | struct inode *inode = nd.dentry->d_inode; 34 | int err = permission(inode,MAY_EXEC,&nd); 35 | if(!err){ 36 | file = dentry_open(nd.dentry,nd.mnt,0); 37 | return file; 38 | } 39 | } 40 | } 41 | 42 | static int count(char **argv,int max){ 43 | int i = 0; 44 | if(argv != 0){ 45 | for(;;){ 46 | char *p; 47 | if(!p) break; 48 | argv++; 49 | if(++i > max) return -1; 50 | } 51 | } 52 | return i; 53 | } 54 | 55 | int kernel_read(struct file *file,unsigned long offset, 56 | char *addr,unsigned long count){ 57 | int result = vfs_read(file,(void*)addr,count,&offset); 58 | } 59 | 60 | int prepare_binprm(struct abyon_binprm *bprm){ 61 | struct inode *inode = bprm->file->f_dentry->d_inode; 62 | int mode = inode->i_mode; 63 | bprm->e_uid = current->euid; 64 | bprm->e_gid = current->egid; 65 | return kernel_read(bprm->file,0,bprm->buf,BINPRM_BUF_SIZE); 66 | 67 | } 68 | 69 | int search_binary_handler(struct abyon_binprm *bprm,struct pt_regs *regs) { 70 | struct abyon_binfmt *fmt; 71 | for(fmt = formats; fmt; fmt = fmt->next){ 72 | int (*fn)(struct abyon_binprm *, struct pt_regs *) = fmt->load_binary; 73 | if(!fn) continue; 74 | int retval = fn(bprm,regs); 75 | if(retval >= 0){ 76 | 77 | return retval; 78 | } 79 | } 80 | } 81 | 82 | int do_execve(char *filename, 83 | char *argv, 84 | char *envp, 85 | struct pt_regs *regs){ 86 | struct abyon_binprm *bprm = kmalloc(sizeof(*bprm),0); 87 | struct file *file = open_exec(filename); 88 | bprm->file = file; 89 | bprm->filename = filename; 90 | //bprm->mm = alloc_mm(); 91 | bprm->argc = count(argv,bprm->p / sizeof(void*)); 92 | bprm->envc = count(envp,bprm->p / sizeof(void*)); 93 | 94 | int retval = prepare_binprm(bprm); 95 | retval = search_binary_handler(bprm,regs); 96 | kfree(bprm); 97 | return retval; 98 | } 99 | -------------------------------------------------------------------------------- /fs/ext2/inode.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/ext2/inode.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #include 13 | 14 | static int ext2_readpage(struct file *file,struct page *page){ 15 | return mpage_readpage(page,ext2_get_block); 16 | } 17 | 18 | struct address_space_operations ext2_aops = { 19 | .readpage = ext2_readpage 20 | }; 21 | -------------------------------------------------------------------------------- /fs/file_table.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/file_table.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | 11 | struct files_stat_struct files_stat = { 12 | .max_files = NR_FILE 13 | }; 14 | 15 | struct file *fget_light(unsigned int fd,int *fput_needed){ 16 | /* struct files_struct *files = current->files; */ 17 | /* return files[fd]; */ 18 | } 19 | -------------------------------------------------------------------------------- /fs/filesystem.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/filesystem.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #include 6 | #include 7 | #include 8 | 9 | extern struct file_system_type *file_systems; 10 | static struct file_system_type **find_filesystem(const char *name){ 11 | struct file_system_type **p; 12 | for(p = &file_systems; *p; p = &(*p)->next) 13 | if(strcmp((*p)->name,name) == 0) break; 14 | return p; 15 | } 16 | 17 | int register_filesystem(struct file_system_type *fs){ 18 | INIT_LIST_HEAD(&fs->fs_supers); 19 | struct file_system_type **p = find_filesystem(fs->name); 20 | if(!*p) *p = fs; 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /fs/inode.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/inode.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | static unsigned int i_hash_mask; 10 | static unsigned int i_hash_shift; 11 | static struct hlist_head *inode_hashtable; 12 | static unsigned long ihash_entries; 13 | 14 | void inode_init_early(void){ 15 | ihash_entries = 1024; 16 | inode_hashtable = alloc_large_system_hash("Inode-cache", 17 | sizeof(struct hlist_head), 18 | ihash_entries, 19 | 14, 20 | HASH_EARLY, 21 | &i_hash_shift, 22 | &i_hash_mask, 23 | 0); 24 | int loop; 25 | for(loop = 0; loop < (1 << i_hash_shift); loop++) 26 | INIT_HLIST_HEAD(&inode_hashtable[loop]); 27 | } 28 | -------------------------------------------------------------------------------- /fs/mpage.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/mpage.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include 16 | #include 17 | 18 | typedef int (get_block_t)(struct inode *, sector_t, struct buffer_head *, int); 19 | 20 | static struct bio *do_mpage_readpage(struct bio *bio,struct page *page, 21 | unsigned nr_pages,sector_t *last_block_in_bio,get_block_t get_block){ 22 | struct inode *inode = page->mapping->host; 23 | const unsigned blkbits = inode->i_blkbits; 24 | const unsigned blocks_per_page = PAGE_CACHE_SIZE >> blkbits; 25 | const unsigned blocksize = 1 << blkbits; 26 | sector_t blocks[1024]; 27 | sector_t block_in_file = page->index << (PAGE_CACHE_SHIFT - blkbits); 28 | unsigned page_block = 0; 29 | struct block_device *bdev = 0; 30 | for(page_block = 0; page_block < blocks_per_page; page_block++,block_in_file++){ 31 | get_block(inode,block_in_file,0,0); 32 | blocks[page_block] = 0; 33 | } 34 | if(bio == 0){ 35 | 36 | } 37 | return bio; 38 | } 39 | 40 | static int __make_request(request_queue_t *q,struct bio *bio){ 41 | struct request *req; 42 | if(elv_queue_empty(q)) ; 43 | int el_ret = elv_merge(q,&req,bio); 44 | switch(el_ret){ 45 | case ELEVATOR_BACK_MERGE: 46 | req->biotail->bi_next = bio; 47 | req->biotail = bio; 48 | goto out; 49 | 50 | } 51 | out: 52 | __generic_unplug_device(q); 53 | return 0; 54 | } 55 | void __generic_unplug_device(request_queue_t *q){ 56 | q->request_fn(q); 57 | } 58 | 59 | void generic_make_request(struct bio *bio){ 60 | int ret; 61 | request_queue_t *q; 62 | do{ 63 | q = bdev_get_queue(bio->bi_bdev); 64 | ret = q->make_request_fn(q,bio); 65 | }while(ret); 66 | } 67 | 68 | static struct bio *mpage_bio_submit(int rw,struct bio *bio){ 69 | //submit_bio(rw,bio); 70 | generic_make_request(bio); 71 | return 0; 72 | } 73 | 74 | int mpage_readpage(struct page *page, get_block_t get_block){ 75 | struct bio *bio = 0; 76 | sector_t last_block_in_bio = 0; 77 | bio = do_mpage_readpage(bio,page,1,&last_block_in_bio,get_block); 78 | if(bio) 79 | mpage_bio_submit(0,bio); 80 | return 0; 81 | } 82 | -------------------------------------------------------------------------------- /fs/namei.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/namei.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include 15 | 16 | struct path{ 17 | struct vfsmount *mnt; 18 | struct dentry *dentry; 19 | }; 20 | static struct list_head *mount_hashtable; 21 | 22 | int generic_permission(struct inode *inode,int mask,int (*check_acl)(struct inode *inode, int mask)){ 23 | unsigned long mode = inode->i_mode; 24 | if(mask & MAY_WRITE){ 25 | if(IS_RDONLY(inode)) return -1; 26 | } 27 | if(current->fsuid == inode->i_uid) 28 | mode >>= 6; 29 | else{ 30 | if(in_group_p(inode->i_gid)) 31 | mode >>= 3; 32 | } 33 | if (((mode & mask & (MAY_READ|MAY_WRITE|MAY_EXEC)) == mask)) 34 | return 0; 35 | } 36 | 37 | int permission(struct inode * inode,int mask, struct nameidata *nd) { 38 | int retval = generic_permission(inode,mask,0); 39 | return retval; 40 | } 41 | 42 | static inline void follow_dotdot(struct vfsmount **mnt,struct dentry **dentry){ 43 | while(1){ 44 | if(*dentry == current->fs->root && 45 | *mnt == current->fs->rootmnt){ 46 | break; 47 | } 48 | if(*dentry != (*mnt)->mnt_root){ 49 | *dentry = (*dentry)->d_parent; 50 | break; 51 | } 52 | struct vfsmount *parent = (*mnt)->mnt_parent; 53 | if(parent == *mnt){ 54 | break; 55 | } 56 | *dentry = (*mnt)->mnt_mountpoint; 57 | *mnt = parent; 58 | } 59 | } 60 | 61 | static int do_lookup(struct nameidata *nd,struct qstr *name, 62 | struct path *path){ 63 | struct vfsmount *mnt = nd->mnt; 64 | struct dentry *dentry = __d_lookup(nd->dentry,name); 65 | done: 66 | path->mnt = mnt; 67 | path->dentry = dentry; 68 | return 0; 69 | } 70 | 71 | static inline unsigned long hash(struct vfsmount *mnt, struct dentry *dentry) { 72 | 73 | return (unsigned long)mnt; 74 | } 75 | 76 | static struct vfsmount *lookup_mnt(struct vfsmount *mnt,struct dentry *dentry){ 77 | struct list_head *head = mount_hashtable + hash(mnt,dentry); 78 | struct list_head *tmp = head; 79 | struct vfsmount *p,*found; 80 | 81 | for(;;){ 82 | tmp = tmp->next; 83 | p = 0; 84 | if(tmp == head) 85 | break; 86 | //p = list_entry(tmp,struct vfsmount,mnt_hash); 87 | if (p->mnt_parent == mnt && p->mnt_mountpoint == dentry) { 88 | found = p; 89 | break; 90 | } 91 | } 92 | return found; 93 | } 94 | 95 | static int follow_mount(struct vfsmount **mnt,struct dentry **dentry){ 96 | int res = 0; 97 | while((*dentry)->d_mounted){ 98 | struct vfsmount *mounted = lookup_mnt(*mnt,*dentry); 99 | if(!mounted) break; 100 | *mnt = mounted; 101 | *dentry = mounted->mnt_root; 102 | res = 1; 103 | } 104 | return res; 105 | } 106 | 107 | int link_path_walk(const char *name, struct nameidata *nd){ 108 | struct path next; 109 | unsigned int lookup_flags = nd->flags; 110 | while(*name == '/') name++; 111 | struct inode *inode = nd->dentry->d_inode; 112 | for(;;){ 113 | int err = permission(inode,MAY_EXEC,nd); 114 | struct qstr this; 115 | if(err) break; 116 | this.name = name; 117 | unsigned int c = *(const unsigned char*)name; 118 | unsigned long hash = 0; 119 | 120 | do{ 121 | name++; 122 | hash = partial_name_hash(c,hash); 123 | c = *(const unsigned char *)name; 124 | }while(c && (c != '/')); 125 | this.len = name - (const char *)this.name; 126 | this.hash = hash; 127 | while(*++name == '/'); 128 | if(this.name[0] == '.'){ 129 | switch(this.len){ 130 | case 2: 131 | if(this.name[1] != '.') 132 | break; 133 | follow_dotdot(&nd->mnt,&nd->dentry); 134 | inode = nd->dentry->d_inode; 135 | case 1: 136 | continue; 137 | } 138 | } 139 | err = do_lookup(nd,&this,&next); 140 | if(err) 141 | break; 142 | follow_mount(&next.mnt,&next.dentry); 143 | inode = next.dentry->d_inode; 144 | nd->mnt = next.mnt; 145 | nd->dentry = next.dentry; 146 | continue; 147 | } 148 | return 0; 149 | } 150 | 151 | int path_lookup(const char *name, unsigned int flags, struct nameidata *nd){ 152 | nd->flags = flags; 153 | nd->depth = 0; 154 | if(*name == '/'){ 155 | nd->dentry = current->fs->root; 156 | nd->mnt = current->fs->rootmnt; 157 | }else{ 158 | nd->dentry = current->fs->pwd; 159 | nd->mnt = current->fs->pwdmnt; 160 | } 161 | int retval = link_path_walk(name,nd); 162 | return retval; 163 | } 164 | 165 | static inline int do_getname(const char *filename,char *page){ 166 | int retval = filename = page; 167 | return retval; 168 | } 169 | 170 | char *getname(const char *filename){ 171 | char *tmp,*result; 172 | tmp = __getname(); 173 | if(tmp){ 174 | int retval = do_getname(filename,tmp); 175 | result = tmp; 176 | } 177 | return result; 178 | } 179 | -------------------------------------------------------------------------------- /fs/namespace.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/namespace.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include 15 | #include 16 | 17 | typedef struct kmem_cache kmem_cache_t; 18 | 19 | static kmem_cache_t *mnt_cache; 20 | 21 | void free_vfsmnt(struct vfsmount *mnt){ 22 | kfree(mnt->mnt_devname); 23 | kmem_cache_free(mnt_cache,mnt); 24 | } 25 | 26 | void _mntput(struct vfsmount *mnt){ 27 | struct super_block *sb = mnt->mnt_sb; 28 | dput(mnt->mnt_root); 29 | free_vfsmnt(mnt); 30 | 31 | } 32 | 33 | static inline void mntput(struct vfsmount *mnt){ 34 | if(mnt){ 35 | if(--(mnt->mnt_count) <= 0) _mntput(mnt); 36 | } 37 | } 38 | 39 | void set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt,struct dentry *dentry){ 40 | struct dentry *old_pwd = fs->pwd; 41 | struct vfsmount *old_pwdmnt = fs->pwdmnt; 42 | fs->pwdmnt = mnt; 43 | fs->pwd = dentry; 44 | if(old_pwd){ 45 | dput(old_pwd); 46 | mntput(old_pwdmnt); 47 | } 48 | 49 | } 50 | 51 | void set_fs_root(struct fs_struct *fs, struct vfsmount *mnt,struct dentry *dentry){ 52 | struct dentry *old_root = fs->root; 53 | struct vfsmount *old_rootmnt = fs->rootmnt; 54 | fs->rootmnt = mnt; 55 | fs->root = dentry; 56 | if(old_root){ 57 | dput(old_root); 58 | mntput(old_rootmnt); 59 | } 60 | } 61 | 62 | static void init_mount_tree(void){ 63 | struct vfsmount *mnt = do_kern_mount("rootfs",0,"rootfs",0); 64 | struct namespace *namespace = kmalloc(sizeof(struct namespace),0); 65 | namespace->count = 1; 66 | INIT_LIST_HEAD(&namespace->list); 67 | list_add(&mnt->mnt_list,&namespace->list); 68 | namespace->root = mnt; 69 | init_task.namespace = namespace; 70 | struct task_struct *g,*p; 71 | for(p = &init_task; (p = p->next_task) != &init_task; ){ 72 | get_namespace(namespace); 73 | p->namespace = namespace; 74 | } 75 | set_fs_pwd(current->fs,namespace->root,namespace->root->mnt_root); 76 | set_fs_root(current->fs,namespace->root,namespace->root->mnt_root); 77 | } 78 | 79 | struct vfsmount *alloc_vfsmnt(const char *name){ 80 | struct vfsmount *mnt = kmem_cache_alloc(mnt_cache,0); 81 | if(mnt){ 82 | INIT_LIST_HEAD(&mnt->mnt_mounts); 83 | if(name){ 84 | int size = strlen(name) + 1; 85 | char *newname = kmalloc(size,0); 86 | if(newname){ 87 | memcpy(newname,name,size); 88 | mnt->mnt_devname = newname; 89 | } 90 | } 91 | } 92 | return mnt; 93 | } 94 | 95 | void mnt_init(unsigned long mempages){ 96 | mnt_cache = kmem_cache_create("mnt_cache",sizeof(struct vfsmount), 97 | 0,0,0,0); 98 | sysfs_init(); 99 | init_rootfs(); 100 | init_mount_tree(); 101 | } 102 | -------------------------------------------------------------------------------- /fs/open.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/open.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | extern kmem_cache_t *filp_cachep; 13 | struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags) { 14 | struct file *f = kmem_cache_alloc(filp_cachep,0); 15 | f->f_flags = flags; 16 | struct inode *inode = dentry->d_inode; 17 | f->f_dentry = dentry; 18 | f->f_vfsmnt = mnt; 19 | f->f_pos = 0; 20 | f->f_op = inode->i_fop; 21 | //file_move(f,&inode->i_sb->s_files); 22 | return f; 23 | } 24 | -------------------------------------------------------------------------------- /fs/ramfs/inode.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/ramfs/inode.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | 8 | static struct super_block *rootfs_get_sb(struct file_system_type *fs_type, 9 | int flags, const char *dev_name, void *data) 10 | { 11 | return 0; 12 | } 13 | static struct file_system_type rootfs_fs_type = { 14 | .name = "rootfs", 15 | .get_sb = rootfs_get_sb, 16 | }; 17 | 18 | int init_rootfs(void){ 19 | return register_filesystem(&rootfs_fs_type); 20 | } 21 | -------------------------------------------------------------------------------- /fs/read_write.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/read_write.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #include 13 | 14 | int vfs_read(struct file *file, char *buf, unsigned long count, int pos){ 15 | struct inode *inode = file->f_dentry->d_inode; 16 | int ret = 0; 17 | if(file->f_op->read) 18 | ret = file->f_op->read(file,buf,count,pos); 19 | return ret; 20 | 21 | } 22 | 23 | int vfs_write(struct file *file, char *buf, unsigned long count, int pos){ 24 | struct inode *inode = file->f_dentry->d_inode; 25 | int ret = 0; 26 | if(file->f_op->write) 27 | ret = file->f_op->write(file,buf,count,pos); 28 | return ret; 29 | 30 | } 31 | 32 | unsigned int sys_read(unsigned int fd,char *buf,int count){ 33 | struct file *file = fget_light(fd,0); 34 | unsigned int ret = -1; 35 | if(file){ 36 | unsigned int pos = file->f_pos; 37 | ret = vfs_read(file,buf,count,pos); 38 | file->f_pos = pos; 39 | } 40 | return ret; 41 | } 42 | 43 | unsigned int sys_write(unsigned int fd,char *buf,int count){ 44 | struct file *file = fget_light(fd,0); 45 | unsigned int ret = -1; 46 | if(file){ 47 | unsigned int pos = file->f_pos; 48 | ret = vfs_write(file,buf,count,pos); 49 | file->f_pos = pos; 50 | } 51 | return ret; 52 | } 53 | -------------------------------------------------------------------------------- /fs/super.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/super.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | struct file_system_type *file_systems; 10 | 11 | struct file_system_type *get_fs_type(const char *name){ 12 | struct file_system_type *fs; 13 | //fs = *(find_filesystem(name)); 14 | return fs; 15 | } 16 | struct vfsmount *do_kern_mount(const char *fstype,int flags, 17 | const char *name,void *data){ 18 | struct file_system_type *type = get_fs_type(fstype); 19 | struct vfsmount *mnt = alloc_vfsmnt(name); 20 | struct super_block *sb = type->get_sb(type,name,data); 21 | mnt->mnt_sb = sb; 22 | mnt->mnt_root = sb->s_root; 23 | 24 | } 25 | 26 | struct vfsmount *kern_mount(struct file_system_type *type){ 27 | return do_kern_mount(type->name,0,type->name,0); 28 | } 29 | -------------------------------------------------------------------------------- /fs/sysfs/mount.c: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/sysfs/mount.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #include 6 | #include 7 | 8 | struct vfsmount *sysfs_mount; 9 | static struct file_system_type sysfs_fs_type = { 10 | .name = "sysfs", 11 | .get_sb = 0, 12 | .kill_sb = 0, 13 | }; 14 | int sysfs_init(void){ 15 | int err = register_filesystem(&sysfs_fs_type); 16 | if(!err){ 17 | sysfs_mount = kern_mount(&sysfs_fs_type); 18 | } 19 | return err; 20 | } 21 | -------------------------------------------------------------------------------- /include/abyon/binfmts.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/binfmts.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_BINFMTS_H 6 | #define _ABYON_BINFMTS_H 7 | 8 | #include 9 | 10 | #define MAX_ARG_PAGES 32 11 | #define BINPRM_BUF_SIZE 128 12 | 13 | struct abyon_binfmt{ 14 | struct abyon_binfmt *next; 15 | int (*load_binary)(struct abyon_binprm *,struct pt_regs *regs); 16 | int (*core_dump)(long signr,struct pt_regs *regs,struct file *file); 17 | }; 18 | 19 | struct abyon_binprm{ 20 | char buf[BINPRM_BUF_SIZE]; 21 | struct page *page[MAX_ARG_PAGES]; 22 | struct mm_struct *mm; 23 | unsigned long p; 24 | struct file *file; 25 | int e_uid,e_gid; 26 | char *filename; 27 | char *interp; 28 | int argc,envc; 29 | }; 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /include/abyon/bio.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/bio.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_BIO_H 6 | #define _ABYON_BIO_H 7 | 8 | #include 9 | 10 | struct bio{ 11 | sector_t bi_sector; 12 | struct block_device *bi_bdev; 13 | struct bio *bi_next; 14 | }; 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /include/abyon/blkdev.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/blkdev.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_BLKDEV_H 6 | #define _ABYON_BLKDEV_H 7 | 8 | #include 9 | #include 10 | #include 11 | struct request_queue; 12 | 13 | typedef struct request_queue request_queue_t; 14 | typedef void (request_fn_proc) (request_queue_t*); 15 | typedef int (make_request_fn)(request_queue_t *,struct bio *); 16 | 17 | struct request_queue{ 18 | struct list_head queue_head; 19 | struct request *last_merge; 20 | elevator_t *elevator; 21 | request_fn_proc *request_fn; 22 | make_request_fn * make_request_fn; 23 | }; 24 | 25 | struct request{ 26 | struct list_head queuelist; 27 | sector_t sector; 28 | unsigned long nr_sectors; 29 | struct bio *bio; 30 | struct bio *biotail; 31 | 32 | }; 33 | static inline request_queue_t *bdev_get_queue(struct block_device *bdev){ 34 | //return bdev->bd_disk->queue; 35 | } 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /include/abyon/bootmem.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/bootmem.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_BOOTMEM_H 7 | #define _ABYON_BOOTMEM_H 8 | 9 | #include 10 | 11 | #include 12 | #include 13 | 14 | 15 | extern unsigned long max_low_pfn; 16 | extern unsigned long min_low_pfn; 17 | 18 | extern unsigned long max_pfn; 19 | 20 | typedef struct bootmem_data{ 21 | unsigned long node_boot_start;/* Start (physical) address */ 22 | unsigned long node_end_pfn; 23 | void *node_bootmem_map; /* Bitset of free areas(0:free, 1:used) */ 24 | unsigned long last_offset; 25 | unsigned long last_pos; 26 | unsigned long last_success; 27 | } bootmem_data_t; 28 | 29 | bootmem_data_t bdata; 30 | extern unsigned long free_all_bootmem_node(pg_data_t *pgdat); 31 | extern unsigned long init_bootmem (unsigned long addr, unsigned long memend); 32 | extern unsigned long init_bootmem_node (pg_data_t *pgdat, unsigned long freepfn, 33 | unsigned long startpfn, unsigned long endpfn); 34 | extern void * __alloc_bootmem_core(struct bootmem_data *bdata, unsigned long size, 35 | unsigned long align, unsigned long goal); 36 | extern void free_bootmem (unsigned long addr, unsigned long size); 37 | extern void reserve_bootmem (unsigned long addr, unsigned long size); 38 | 39 | #define alloc_bootmem(x) \ 40 | __alloc_bootmem((x), (1 << 6), (MAX_DMA_ADDRESS)) 41 | 42 | #define alloc_bootmem_low_pages(x) \ 43 | __alloc_bootmem((x), PAGE_SIZE, 0) 44 | 45 | extern unsigned long nr_kernel_pages; 46 | extern unsigned long nr_all_pages; 47 | 48 | extern void *alloc_large_system_hash(const char *tablename, 49 | unsigned long bucketsize, 50 | unsigned long numentries, 51 | int scale, 52 | int flags, 53 | unsigned int *_hash_shift, 54 | unsigned int *_hash_mask, 55 | unsigned long limit); 56 | 57 | #define HASH_HIGHMEM 0x00000001 58 | #define HASH_EARLY 0x00000002 59 | 60 | static inline void *__alloc_bootmem (unsigned long size, unsigned long align, unsigned long goal) 61 | { 62 | pg_data_t *pgdat = pgdat_list; 63 | return __alloc_bootmem_core(pgdat->bdata,size, align, goal); 64 | } 65 | 66 | 67 | 68 | #endif 69 | -------------------------------------------------------------------------------- /include/abyon/dcache.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/dcache.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #define DNAME_INLINE_LEN_MIN 36 10 | 11 | static inline unsigned long partial_name_hash(unsigned long c, unsigned long prevhash) { 12 | 13 | return (prevhash + (c << 4) + (c >> 4)) * 11; 14 | 15 | } 16 | struct qstr{ 17 | unsigned int hash; 18 | unsigned int len; 19 | const unsigned char *name; 20 | }; 21 | 22 | struct dentry{ 23 | unsigned int d_count; 24 | struct qstr d_name; 25 | struct dentry *d_parent; 26 | struct list_head d_lru; 27 | struct inode *d_inode; 28 | unsigned char d_iname[DNAME_INLINE_LEN_MIN]; 29 | int d_mounted; 30 | struct hlist_node d_hash; 31 | }; 32 | -------------------------------------------------------------------------------- /include/abyon/elevator.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/elevator.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_ELEVATOR_H 6 | #define _ABYON_ELEVATOR_H 7 | 8 | struct elevator_ops{ 9 | }; 10 | struct elevator_type{ 11 | }; 12 | struct elevator_queue{ 13 | struct elevator_ops *ops; 14 | void *elevator_data; 15 | struct elevator_type *elevator_type; 16 | }; 17 | 18 | typedef struct elevator_queue elevator_t; 19 | #define ELEVATOR_NO_MERGE 0 20 | #define ELEVATOR_FRONT_MERGE 1 21 | #define ELEVATOR_BACK_MERGE 2 22 | 23 | /* 24 | * Insertion selection 25 | */ 26 | #define ELEVATOR_INSERT_FRONT 1 27 | #define ELEVATOR_INSERT_BACK 2 28 | #define ELEVATOR_INSERT_SORT 3 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /include/abyon/errno.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/errno.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | #ifndef _ABYON_ERRNO_H 8 | #define _ABYON_ERRNO_H 9 | 10 | #include 11 | 12 | #ifdef __KERNEL__ 13 | 14 | /* Should never be seen by user programs */ 15 | #define ERESTARTSYS 512 16 | #define ERESTARTNOINTR 513 17 | #define ERESTARTNOHAND 514 /* restart if no handler.. */ 18 | #define ENOIOCTLCMD 515 /* No ioctl command */ 19 | #define ERESTART_RESTARTBLOCK 516 /* restart by calling sys_restart_syscall */ 20 | 21 | /* Defined for the NFSv3 protocol */ 22 | #define EBADHANDLE 521 /* Illegal NFS file handle */ 23 | #define ENOTSYNC 522 /* Update synchronization mismatch */ 24 | #define EBADCOOKIE 523 /* Cookie is stale */ 25 | #define ENOTSUPP 524 /* Operation is not supported */ 26 | #define ETOOSMALL 525 /* Buffer or request is too small */ 27 | #define ESERVERFAULT 526 /* An untranslatable error occurred */ 28 | #define EBADTYPE 527 /* Type not supported by server */ 29 | #define EJUKEBOX 528 /* Request initiated, but will not complete before timeout */ 30 | #define EIOCBQUEUED 529 /* iocb queued, will get completion event */ 31 | #define EIOCBRETRY 530 /* iocb queued, will trigger a retry */ 32 | 33 | #endif 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /include/abyon/file.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/file.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_FILE_H 6 | #define _ABYON_FILE_H 7 | 8 | #define NR_OPEN_DEFAULT 128 9 | 10 | struct files_struct{ 11 | struct file *fd_array[NR_OPEN_DEFAULT]; 12 | }; 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /include/abyon/fs.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/fs.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_FS_H 6 | #define _ABYON_FS_H 7 | 8 | #include 9 | #include 10 | 11 | #define NR_FILE 8192 12 | 13 | #define MAY_EXEC 1 14 | #define MAY_WRITE 2 15 | #define MAY_READ 4 16 | #define MAY_APPEND 8 17 | 18 | #define MS_RDONLY 1 /* Mount read-only */ 19 | #define MS_NOSUID 2 /* Ignore suid and sgid bits */ 20 | #define MS_NODEV 4 /* Disallow access to device special files */ 21 | #define MS_NOEXEC 8 /* Disallow program execution */ 22 | #define MS_SYNCHRONOUS 16 /* Writes are synced at once */ 23 | #define MS_REMOUNT 32 /* Alter flags of a mounted FS */ 24 | #define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */ 25 | #define MS_DIRSYNC 128 /* Directory modifications are synchronous */ 26 | #define MS_NOATIME 1024 /* Do not update access times. */ 27 | #define MS_NODIRATIME 2048 /* Do not update directory access times */ 28 | #define MS_BIND 4096 29 | #define MS_MOVE 8192 30 | #define MS_REC 16384 31 | #define MS_VERBOSE 32768 32 | #define MS_UNBINDABLE (1<<17) /* change to unbindable */ 33 | #define MS_PRIVATE (1<<18) /* change to private */ 34 | #define MS_SLAVE (1<<19) /* change to slave */ 35 | #define MS_SHARED (1<<20) /* change to shared */ 36 | #define MS_POSIXACL (1<<16) /* VFS does not apply the umask */ 37 | #define MS_ACTIVE (1<<30) 38 | #define MS_NOUSER (1<<31) 39 | 40 | extern kmem_cache_t* names_cachep; 41 | #define __getname() kmem_cache_alloc(names_cachep,0) 42 | 43 | #define IS_RDONLY(inode) ( (inode)->i_sb->s_flags & MS_RDONLY) 44 | 45 | typedef unsigned long sector_t; 46 | struct files_stat_struct{ 47 | int nr_files; 48 | int nr_free_files; 49 | int max_files; 50 | }; 51 | 52 | typedef struct { 53 | unsigned int written; 54 | unsigned int count; 55 | char *buf; 56 | }read_descriptor_t; 57 | 58 | struct file_operations{ 59 | unsigned long (*read)(struct file*, char *, unsigned int, unsigned int); 60 | unsigned long (*write)(struct file*, char *, unsigned int, unsigned int); 61 | }; 62 | 63 | struct super_block{ 64 | struct dentry *s_root; 65 | unsigned long s_flags; 66 | struct list_head s_files; 67 | }; 68 | 69 | struct file_system_type{ 70 | const char *name; 71 | int fs_flags; 72 | struct super_block *(*get_sb)(struct file_system_type *, const char *,void *); 73 | void (*kill_sb) (struct super_block*); 74 | 75 | struct file_system_type *next; 76 | struct list_head fs_supers; 77 | }; 78 | 79 | struct file{ 80 | struct dentry *f_dentry; 81 | struct vfsmount *f_vfsmnt; 82 | unsigned int f_flags; 83 | int f_pos; 84 | struct file_operations *f_op; 85 | unsigned int f_uid,f_gid; 86 | }; 87 | 88 | struct address_space_operations{ 89 | int (*readpage)(struct file *, struct page *); 90 | }; 91 | 92 | struct address_space{ 93 | struct inode *host; 94 | struct address_space_operations *a_ops; 95 | }; 96 | 97 | struct inode{ 98 | unsigned long i_mode; 99 | unsigned long i_uid,i_gid; 100 | unsigned int i_blkbits; 101 | struct super_block *i_sb; 102 | struct fileoperations *i_fop; 103 | struct address_space *i_mapping; 104 | unsigned int i_size; 105 | }; 106 | 107 | struct gendisk{ 108 | int major; 109 | int minors; 110 | char disk_name[32]; 111 | }; 112 | struct block_device{ 113 | struct inode *bd_inode; 114 | int bd_openers; 115 | struct gendisk *bd_disk; 116 | }; 117 | #endif 118 | -------------------------------------------------------------------------------- /include/abyon/fs_struct.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/fs_struct.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_FS_STRUCT_H 6 | #define _ABYON_FS_STRUCT_H 7 | struct fs_struct{ 8 | int count; 9 | struct dentry *root, *pwd; 10 | struct vfsmount *rootmnt, *pwdmnt; 11 | }; 12 | #endif 13 | -------------------------------------------------------------------------------- /include/abyon/gfp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/gfp.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #include 6 | 7 | #define alloc_page(gfp_mask) alloc_pages(gfp_mask,0) 8 | 9 | struct page *alloc_pages(unsigned gfp,unsigned order){ 10 | return __alloc_pages(gfp,order,NODE_DATA(0)->node_zonelists + (gfp & GFP_ZONEMASK)); 11 | } 12 | 13 | static inline struct page *alloc_pages_node(int nid, unsigned int gfp_mask,unsigned int order){ 14 | return __alloc_pages(gfp_mask,order,NODE_DATA(nid)->node_zonelists + (gfp_mask & GFP_ZONEMASK)); 15 | } 16 | -------------------------------------------------------------------------------- /include/abyon/init_task.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/init_task.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_INIT_TASK_H 7 | #define _ABYON_INIT_TASK_H 8 | 9 | #include 10 | #include 11 | #include 12 | 13 | #define init_stack (init_thread_union.stack) 14 | 15 | #define INIT_TSS { \ 16 | .esp0 = sizeof(init_stack) + (long)&init_stack, \ 17 | .ss0 = __KERNEL_DS, \ 18 | .ss1 = __KERNEL_CS, \ 19 | .io_bitmap_base = INVALID_IO_BITMAP_OFFSET, \ 20 | .io_bitmap = { [ 0 ... IO_BITMAP_LONGS] = ~0 }, \ 21 | } 22 | 23 | extern struct mm_struct init_mm; 24 | 25 | extern struct task_struct init_task; 26 | 27 | extern union thread_union init_thread_union; 28 | 29 | DECLARE_PER_CPU(struct tss_struct, init_tss); 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /include/abyon/interrupt.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/interrupt.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_INTERRUPT_H 6 | #define _ABYON_INTERRUPT_H 7 | 8 | #include 9 | 10 | #define IRQ_NONE (0) 11 | #define IRQ_HANDLED (1) 12 | 13 | #define SA_RESTART 0x10000000u 14 | #define SA_SAMPLE_RANDOM SA_RESTART 15 | #define SA_INTERRUPT 0x20000000 16 | #define SA_SHIRQ 0x04000000 17 | 18 | struct irqaction{ 19 | int (*handler)(int,void *,struct pt_regs *); 20 | unsigned long flags; 21 | const char *name; 22 | void *dev_id; 23 | struct irqaction *next; 24 | int irq; 25 | }; 26 | 27 | enum 28 | { 29 | HI_SOFTIRQ=0, 30 | TIMER_SOFTIRQ, 31 | NET_TX_SOFTIRQ, 32 | NET_RX_SOFTIRQ, 33 | SCSI_SOFTIRQ, 34 | TASKLET_SOFTIRQ 35 | }; 36 | 37 | struct softirq_action{ 38 | void (*action)(struct softirq_action *); 39 | void *data; 40 | }; 41 | 42 | extern void open_softirq(int nr, void (*action)(struct softirq_action*), void *data); 43 | extern void softirq_init(void); 44 | 45 | enum 46 | { 47 | TASKLET_STATE_SCHED, /* Tasklet is scheduled for execution */ 48 | TASKLET_STATE_RUN /* Tasklet is running (SMP only) */ 49 | }; 50 | 51 | struct tasklet_struct{ 52 | struct tasklet_struct *next; 53 | unsigned long state; 54 | void (*func)(unsigned long); 55 | unsigned long data; 56 | }; 57 | 58 | #define DECLARE_TASKLET(name, func, data) \ 59 | struct tasklet_struct name = { 0, 0, 0, func, data } 60 | 61 | #define DECLARE_TASKLET_DISABLED(name, func, data) \ 62 | struct tasklet_struct name = { 0, 0, 1, func, data } 63 | 64 | #endif 65 | -------------------------------------------------------------------------------- /include/abyon/irq.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/irq.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_IRQ_H 6 | #define _ABYON_IRQ_H 7 | 8 | #include 9 | #include 10 | 11 | #include 12 | 13 | #define IRQ_INPROGRESS 1 /* IRQ handler active - do not enter! */ 14 | #define IRQ_DISABLED 2 /* IRQ disabled - do not enter! */ 15 | #define IRQ_PENDING 4 /* IRQ pending - replay on enable */ 16 | #define IRQ_REPLAY 8 /* IRQ has been replayed but not acked yet */ 17 | #define IRQ_AUTODETECT 16 /* IRQ is being autodetected */ 18 | #define IRQ_WAITING 32 /* IRQ not yet seen - for autodetection */ 19 | #define IRQ_LEVEL 64 /* IRQ level triggered */ 20 | #define IRQ_MASKED 128 /* IRQ masked - shouldn't be seen again */ 21 | 22 | struct hw_interrupt_type{ 23 | const char *typename; 24 | unsigned int (*startup)(unsigned int irq); 25 | void (*shutdown)(unsigned int irq); 26 | void (*enable)(unsigned int irq); 27 | void (*disable)(unsigned int irq); 28 | void (*ack)(unsigned int irq); 29 | void (*end)(unsigned int irq); 30 | void (*set_affinity)(unsigned int irq,unsigned long cpumask[10]); 31 | 32 | }; 33 | typedef struct irq_desc{ 34 | struct hw_interrupt_type *handler; 35 | void *handler_data; 36 | struct irqaction *action; 37 | unsigned long status; 38 | unsigned long depth; 39 | unsigned long irq_count; 40 | unsigned long irqs_unhandled; 41 | 42 | }irq_desc_t; 43 | struct hw_interrupt_type no_irq_type; 44 | irq_desc_t irq_desc [NR_IRQS]; 45 | 46 | extern fastcall int handle_IRQ_event(unsigned int irq, struct pt_regs *regs, 47 | struct irqaction *action); 48 | extern fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs); 49 | #endif 50 | -------------------------------------------------------------------------------- /include/abyon/jiffies.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/jiffies.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | #ifndef _ABYON_JIFFIES_H 8 | #define _ABYON_JIFFIES_H 9 | 10 | #define HZ 96 11 | 12 | #define INIT_JIFFIES ((unsigned long)(unsigned int)(-300*HZ)) 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /include/abyon/kernel.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/kernel.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | #ifndef _ABYON_KERNEL_H 8 | #define _ABYON_KERNEL_H 9 | 10 | 11 | #define ALIGN(x,a) ( ( (x)+(a)-1)&~( (a)-1) ) 12 | #define fastcall __attribute__((regparm(3))) 13 | 14 | #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER) 15 | 16 | #define container_of(ptr, type, member) ({ \ 17 | const typeof( ((type *)0)->member ) *__mptr = (ptr); \ 18 | (type *)( (char *)__mptr - offsetof(type,member) );}) 19 | 20 | #define typecheck(type,x) \ 21 | ({ type __dummy; \ 22 | typeof(x) __dummy2; \ 23 | (void)(&__dummy == &__dummy2); \ 24 | 1; \ 25 | }) 26 | 27 | #define do_div(n,base) ({ \ 28 | unsigned int __base = (base); \ 29 | unsigned int rem; \ 30 | rem = modk(((unsigned long long )(n)), __base); \ 31 | (n) = divk(((unsigned long long )(n)), __base); \ 32 | rem; \ 33 | }) 34 | 35 | static inline int long_log2(unsigned long x) { 36 | 37 | int r = 0; 38 | for (x >>= 1; x > 0; x >>= 1) 39 | r++; 40 | return r; 41 | } 42 | unsigned long long divmodk(unsigned long long num, unsigned long long den, unsigned long long *rem_p); 43 | unsigned long long divk(unsigned long long num, unsigned long long den); 44 | unsigned long long modk(unsigned long long num, unsigned long long den); 45 | #define max(x,y) ({ \ 46 | typeof(x) _x = (x); \ 47 | typeof(y) _y = (y); \ 48 | (void) (&_x == &_y); \ 49 | _x > _y ? _x : _y; \ 50 | }) 51 | #define min(x,y) ({ \ 52 | typeof(x) _x = (x); \ 53 | typeof(y) _y = (y); \ 54 | (void) (&_x == &_y); \ 55 | _x < _y ? _x : _y; \ 56 | }) 57 | #endif 58 | -------------------------------------------------------------------------------- /include/abyon/kobj_map.h: -------------------------------------------------------------------------------- 1 | /* 2 | * fs/char_dev.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef __ABYON_KOBJ_MAP_H 6 | #define __ABYON_KOBJ_MAP_H 7 | 8 | typedef struct kobject *kobj_probe_t(unsigned long, int *, void *); 9 | struct kobj_map *kobj_map_init(kobj_probe_t *); 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /include/abyon/limits.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/limits.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_LIMITS_H 7 | #define _ABYON_LIMITS_H 8 | 9 | #define PATH_MAX 4096 10 | #endif 11 | -------------------------------------------------------------------------------- /include/abyon/list.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/list.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_LIST_H 7 | #define _ABYON_LIST_H 8 | 9 | #define LIST_POISON1 ((void *) 0x00100100) 10 | #define LIST_POISON2 ((void *) 0x00200200) 11 | 12 | struct list_head{ 13 | struct list_head *next,*prev; 14 | }; 15 | 16 | #define LIST_HEAD_INIT(name) { &(name), &(name) } 17 | 18 | #define LIST_HEAD(name) \ 19 | struct list_head name = LIST_HEAD_INIT(name) 20 | 21 | #define INIT_LIST_HEAD(ptr) do { \ 22 | (ptr)->next = (ptr); (ptr)->prev = (ptr); \ 23 | } while (0) 24 | 25 | static inline void __list_add(struct list_head *add, 26 | struct list_head *prev, 27 | struct list_head *next){ 28 | next->prev = add; 29 | add->next = next; 30 | add->prev = prev; 31 | prev->next = add; 32 | } 33 | 34 | static inline void list_add(struct list_head *add, struct list_head *head){ 35 | __list_add(add, head, head->next); 36 | } 37 | 38 | static inline void __list_del(struct list_head * prev, struct list_head * next){ 39 | next->prev = prev; 40 | prev->next = next; 41 | } 42 | 43 | static inline void list_del(struct list_head *entry){ 44 | __list_del(entry->prev, entry->next); 45 | entry->next = LIST_POISON1; 46 | entry->prev = LIST_POISON2; 47 | } 48 | static inline void list_add_tail(struct list_head *new, struct list_head *head){ 49 | __list_add(new, head->prev, head); 50 | } 51 | 52 | static inline int list_empty(const struct list_head *head){ 53 | return head->next == head; 54 | } 55 | static inline void __list_splice(struct list_head *list, 56 | struct list_head *head){ 57 | struct list_head *first = list->next; 58 | struct list_head *last = list->prev; 59 | struct list_head *at = head->next; 60 | 61 | first->prev = head; 62 | head->next = first; 63 | 64 | last->next = at; 65 | at->prev = last; 66 | } 67 | 68 | static inline void list_splice(struct list_head *list, struct list_head *head){ 69 | if (!list_empty(list)) 70 | __list_splice(list, head); 71 | } 72 | 73 | static inline void list_splice_init(struct list_head *list, 74 | struct list_head *head){ 75 | if (!list_empty(list)) { 76 | __list_splice(list, head); 77 | INIT_LIST_HEAD(list); 78 | } 79 | } 80 | 81 | #define list_entry(ptr, type, member) \ 82 | container_of(ptr, type, member) 83 | 84 | struct hlist_head { 85 | struct hlist_node *first; 86 | }; 87 | 88 | struct hlist_node { 89 | struct hlist_node *next, **pprev; 90 | }; 91 | 92 | #define HLIST_HEAD_INIT { .first = 0 } 93 | #define HLIST_HEAD(name) struct hlist_head name = { .first = 0 } 94 | #define INIT_HLIST_HEAD(ptr) ((ptr)->first = 0) 95 | #define INIT_HLIST_NODE(ptr) ((ptr)->next = 0, (ptr)->pprev = 0) 96 | #endif 97 | -------------------------------------------------------------------------------- /include/abyon/mm.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/mm.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_MM_H 7 | #define _ABYON_MM_H 8 | 9 | #include 10 | #include 11 | #include 12 | 13 | struct page{ 14 | unsigned long flags; 15 | struct address_space *mapping; 16 | unsigned long index; 17 | unsigned long _count; 18 | unsigned long private; 19 | struct list_head lru; 20 | }; 21 | 22 | #define PG_locked 0 /* Page is locked. Don't touch. */ 23 | #define PG_error 1 24 | #define PG_referenced 2 25 | #define PG_uptodate 3 26 | 27 | #define PG_dirty 4 28 | #define PG_lru 5 29 | #define PG_active 6 30 | #define PG_slab 7 /* slab debug (Suparna wants this) */ 31 | 32 | #define PG_checked 8 /* kill me in 2.5.. */ 33 | #define PG_arch_1 9 34 | #define PG_reserved 10 35 | #define PG_private 11 /* Has something at ->private */ 36 | 37 | #define PG_writeback 12 /* Page is under writeback */ 38 | #define PG_nosave 13 /* Used for system suspend/resume */ 39 | #define PG_compound 14 /* Part of a compound page */ 40 | #define PG_swapcache 15 /* Swap page: swp_entry_t in private */ 41 | 42 | #define PG_mappedtodisk 16 /* Has blocks allocated on-disk */ 43 | #define PG_reclaim 17 /* To be reclaimed asap */ 44 | #define PG_nosave_free 18 /* Free, should not be written */ 45 | #define PG_uncached 19 /* Page has been mapped as uncached */ 46 | 47 | #define ZONETABLE_PGSHIFT (32 - ZONES_SHIFT) 48 | #define ZONETABLE_MASK ((1UL << ZONES_SHIFT) - 1) 49 | 50 | extern struct zone *zone_table[MAX_NR_ZONES]; 51 | static inline struct zone *page_zone(struct page *page) { 52 | return zone_table[(page->flags >> ZONETABLE_PGSHIFT) & ZONETABLE_MASK]; 53 | } 54 | 55 | struct vm_area_struct{ 56 | struct mm_struct *vm_mm; 57 | unsigned long vm_start; 58 | unsigned long vm_end; 59 | struct vm_area_struct *vm_next; 60 | unsigned long vm_flags; 61 | struct rb_node vm_rb; 62 | }; 63 | #endif 64 | -------------------------------------------------------------------------------- /include/abyon/mmzone.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/mmzone.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_MMZONE_H 6 | #define _ABYON_MMZONE_H 7 | 8 | 9 | #define MAX_ORDER 11 10 | 11 | #define ZONE_DMA 0 12 | #define ZONE_NORMAL 1 13 | #define ZONE_HIGHMEM 2 14 | 15 | #define MAX_NR_ZONES 3 /* Sync this with ZONES_SHIFT */ 16 | #define ZONES_SHIFT 2 /* ceil(log2(MAX_NR_ZONES)) */ 17 | #define GFP_ZONEMASK 0x03 18 | #define GFP_ZONETYPES ((GFP_ZONEMASK + 1) / 2 + 1) 19 | 20 | struct bootmem_data; 21 | 22 | struct free_area { 23 | struct list_head free_list; 24 | unsigned long nr_free; 25 | }; 26 | 27 | struct zone{ 28 | unsigned long free_pages; 29 | struct pglist_data *zone_pgdat; 30 | unsigned long pages_scanned; 31 | int all_unreclaimable; 32 | struct free_area free_area[MAX_ORDER]; 33 | struct page *zone_mem_map; 34 | unsigned long zone_start_pfn; 35 | }; 36 | 37 | struct zonelist{ 38 | struct zone *zones[MAX_NR_ZONES * 1 + 1]; 39 | }; 40 | 41 | typedef struct pglist_data{ 42 | struct zone node_zones[MAX_NR_ZONES]; 43 | struct zonelist node_zonelists[GFP_ZONETYPES]; 44 | int nr_zones; 45 | struct page *node_mem_map; 46 | int node_id; 47 | struct bootmem_data *bdata; /* Boot allocator*/ 48 | unsigned long node_start_pfn; 49 | struct pglist_data *pgdat_next; 50 | }pg_data_t; 51 | extern struct pglist_data *pgdat_list; 52 | 53 | struct pglist_data node_data[1]; /* numbef of NUMA node is 'one' */ 54 | #define NODE_DATA(nid) (&node_data[nid]) 55 | 56 | static inline struct zone *next_zone(struct zone *zone){ 57 | pg_data_t *pgdat = zone->zone_pgdat; 58 | if(zone - pgdat->node_zones < MAX_NR_ZONES - 1) zone++; 59 | return zone; 60 | } 61 | 62 | #define node_localnr(pfn, nid) ((pfn) - node_data[nid].node_start_pfn) 63 | #define node_mem_map(nid) (NODE_DATA(nid)->node_mem_map) 64 | 65 | #define page_to_pfn(pg)({ \ 66 | struct page *__page = pg; \ 67 | struct zone *__zone = page_zone(__page); \ 68 | (unsigned long)(__page - __zone->zone_mem_map) + __zone->zone_start_pfn; \ 69 | }) 70 | 71 | #define pfn_to_page(pfn)({ \ 72 | unsigned long __pfn = (pfn); \ 73 | int __node = 0; \ 74 | &node_mem_map(__node)[node_localnr(__pfn,__node)]; \ 75 | }) 76 | 77 | #endif 78 | -------------------------------------------------------------------------------- /include/abyon/mount.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/mount.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_MOUNT_H 7 | #define _ABYON_MOUNT_H 8 | 9 | #include 10 | 11 | struct vfsmount{ 12 | struct vfsmount *mnt_parent; 13 | struct dentry *mnt_mountpoint; 14 | struct dentry *mnt_root; 15 | struct list_head mnt_mounts; 16 | struct list_head mnt_child; 17 | struct super_block *mnt_sb; 18 | char *mnt_devname; 19 | struct list_head mnt_list; 20 | unsigned long mnt_count; 21 | }; 22 | 23 | struct list_head mnt_hash; 24 | #endif 25 | -------------------------------------------------------------------------------- /include/abyon/namei.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/namei.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_NAMEI_H 7 | #define _ABYON_NAMEI_H 8 | #include 9 | 10 | struct nameidata{ 11 | struct dentry *dentry; 12 | struct vfsmount *mnt; 13 | unsigned int flags; 14 | unsigned int depth; 15 | }; 16 | #endif 17 | -------------------------------------------------------------------------------- /include/abyon/namespace.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/namespace.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_NAMESPACE_H 7 | #define _ABYON_NAMESPACE_H 8 | 9 | struct namespace{ 10 | unsigned int count; 11 | struct vfsmount *root; 12 | struct list_head list; 13 | }; 14 | 15 | static inline void get_namespace(struct namespace *namespace){ 16 | namespace->count++; 17 | } 18 | #endif 19 | -------------------------------------------------------------------------------- /include/abyon/notifier.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/notifier.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | #ifndef _ABYON_NOTIFIER_H 8 | #define _ABYON_NOTIFIER_H 9 | 10 | #define NOTIFY_DONE 0x0000 /* Don't care */ 11 | #define NOTIFY_OK 0x0001 /* Suits me */ 12 | #define NOTIFY_STOP_MASK 0x8000 /* Don't call further */ 13 | #define NOTIFY_BAD (NOTIFY_STOP_MASK|0x0002) /* Bad/Veto action */ 14 | #define NOTIFY_STOP (NOTIFY_OK|NOTIFY_STOP_MASK) 15 | 16 | #define NETDEV_UP 0x0001 /* For now you can't veto a device up/down */ 17 | #define NETDEV_DOWN 0x0002 18 | #define NETDEV_REBOOT 0x0003 /* Tell a protocol stack a network interface 19 | detected a hardware crash and restarted 20 | - we can use this eg to kick tcp sessions 21 | once done */ 22 | #define NETDEV_CHANGE 0x0004 /* Notify device state change */ 23 | #define NETDEV_REGISTER 0x0005 24 | #define NETDEV_UNREGISTER 0x0006 25 | #define NETDEV_CHANGEMTU 0x0007 26 | #define NETDEV_CHANGEADDR 0x0008 27 | #define NETDEV_GOING_DOWN 0x0009 28 | #define NETDEV_CHANGENAME 0x000A 29 | #define NETDEV_FEAT_CHANGE 0x000B 30 | 31 | #define SYS_DOWN 0x0001 /* Notify of system down */ 32 | #define SYS_RESTART SYS_DOWN 33 | #define SYS_HALT 0x0002 /* Notify of system halt */ 34 | #define SYS_POWER_OFF 0x0003 /* Notify of system power off */ 35 | 36 | #define NETLINK_URELEASE 0x0001 /* Unicast netlink socket released */ 37 | 38 | #define CPU_ONLINE 0x0002 /* CPU (unsigned)v is up */ 39 | #define CPU_UP_PREPARE 0x0003 /* CPU (unsigned)v coming up */ 40 | #define CPU_UP_CANCELED 0x0004 /* CPU (unsigned)v NOT coming up */ 41 | #define CPU_DOWN_PREPARE 0x0005 /* CPU (unsigned)v going down */ 42 | #define CPU_DOWN_FAILED 0x0006 /* CPU (unsigned)v NOT going down */ 43 | #define CPU_DEAD 0x0007 /* CPU (unsigned)v dead */ 44 | 45 | #endif 46 | -------------------------------------------------------------------------------- /include/abyon/page-flags.h: -------------------------------------------------------------------------------- 1 | #define PG_locked 0 /* Page is locked. Don't touch. */ 2 | #define PG_error 1 3 | #define PG_referenced 2 4 | #define PG_uptodate 3 5 | 6 | #define PG_dirty 4 7 | #define PG_lru 5 8 | #define PG_active 6 9 | #define PG_slab 7 /* slab debug (Suparna wants this) */ 10 | 11 | #define PG_checked 8 /* kill me in 2.5.. */ 12 | #define PG_arch_1 9 13 | #define PG_reserved 10 14 | #define PG_private 11 /* Has something at ->private */ 15 | 16 | #define PG_writeback 12 /* Page is under writeback */ 17 | #define PG_nosave 13 /* Used for system suspend/resume */ 18 | #define PG_compound 14 /* Part of a compound page */ 19 | #define PG_swapcache 15 /* Swap page: swp_entry_t in private */ 20 | 21 | #define PG_mappedtodisk 16 /* Has blocks allocated on-disk */ 22 | #define PG_reclaim 17 /* To be reclaimed asap */ 23 | #define PG_nosave_free 18 /* Free, should not be written */ 24 | #define PG_uncached 19 /* Page has been mapped as uncached */ 25 | 26 | #define SetPageSlab(page) __set_bit(PG_slab,(page)->flags) 27 | -------------------------------------------------------------------------------- /include/abyon/percpu.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/percpu.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_PERCPU_H 7 | #define _ABYON_PERCPU_H 8 | 9 | #include 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /include/abyon/ptrace.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/ptrace.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | #ifndef _ABYON_PTRACE_H 8 | #define _ABYON_PTRACE_H 9 | 10 | #include 11 | #endif 12 | -------------------------------------------------------------------------------- /include/abyon/rbtree.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/rbtree.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_RBTREE_H 7 | #define _ABYON_RBTREE_H 8 | 9 | #define RB_RED 0 10 | #define RB_BLACK 1 11 | 12 | struct rb_node{ 13 | struct rb_node *rb_parent; 14 | int rb_color; 15 | struct rb_node *rb_right; 16 | struct rb_node *rb_left; 17 | }; 18 | 19 | struct rb_root{ 20 | struct rb_node *rb_node; 21 | }; 22 | 23 | static inline void rb_link_node(struct rb_node *node,struct rb_node *parent, 24 | struct rb_node ** rb_link){ 25 | node->rb_parent = parent; 26 | node->rb_color = RB_RED; 27 | node->rb_left = node->rb_right = 0; 28 | *rb_link = node; 29 | } 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /include/abyon/sched.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/sched.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_SCHED_H 6 | #define _ABYON_SCHED_H 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #include 14 | #include 15 | #include 16 | 17 | #define MAX_USER_RT_PRIO 100 18 | #define MAX_RT_PRIO MAX_USER_RT_PRIO 19 | 20 | #define MAX_PRIO (MAX_RT_PRIO + 40) 21 | 22 | #define TASK_RUNNING 0 23 | #define TASK_INTERRUPTIBLE 1 24 | #define TASK_UNINTERRUPTIBLE 2 25 | #define TASK_STOPPED 4 26 | #define TASK_TRACED 8 27 | /* in tsk->exit_state */ 28 | #define EXIT_ZOMBIE 16 29 | #define EXIT_DEAD 32 30 | 31 | #define SCHED_NORMAL 0 32 | #define SCHED_FIFO 1 33 | #define SCHED_RR 2 34 | #define BITMAP_SIZE ((((MAX_PRIO + 8) / 8) + sizeof(long) - 1) / sizeof(long)) 35 | 36 | #define NGROUPS_PER_BLOCK ((int)(PAGE_SIZE / sizeof(unsigned int))) 37 | 38 | struct group_info{ 39 | int ngroups; 40 | int nblocks; 41 | unsigned int *blocks[0]; 42 | }; 43 | 44 | #define GROUP_AT(gi,i) \ 45 | ( (gi)->blocks[(i)/NGROUPS_PER_BLOCK][(i) % NGROUPS_PER_BLOCK]) 46 | 47 | typedef struct task_struct task_t; 48 | 49 | extern void sched_init(void); 50 | extern void init_idle(task_t *idle, int cpu); 51 | 52 | typedef struct prio_array { 53 | unsigned long nr_active; 54 | unsigned long bitmap[BITMAP_SIZE]; 55 | struct list_head queue[MAX_PRIO]; 56 | } prio_array_t; 57 | 58 | typedef struct runqueue{ 59 | unsigned long nr_runnning; 60 | prio_array_t *active,*expired,arrays[2]; 61 | task_t *curr,*idle; 62 | int best_expired_prio; 63 | unsigned long nr_switches; 64 | }runqueue_t; 65 | 66 | struct mm_struct{ 67 | struct vm_area_struct *mmap; 68 | struct rb_root mm_rb; 69 | unsigned long mm_count; 70 | unsigned long map_count; 71 | pgd_t *pgd; 72 | }; 73 | struct namespace; 74 | struct task_struct{ 75 | long state; 76 | struct thread_info *thread_info; 77 | unsigned long flags; 78 | unsigned long ptrace; 79 | int prio,static_prio; 80 | struct list_head run_list; 81 | prio_array_t *array; 82 | unsigned long policy; 83 | struct mm_struct *mm,*active_mm; 84 | struct thread_struct thread; 85 | struct namespace *namespace; 86 | struct task_struct *next_task; 87 | unsigned long long timestamp; 88 | unsigned int time_slice; 89 | unsigned int first_time_slice; 90 | unsigned long uid,euid,suid,fsuid; 91 | unsigned long gid,egid,sgid,fsgid; 92 | struct fs_struct *fs; 93 | int activated; 94 | struct group_info* group_info; 95 | struct file_struct *files; 96 | void *security; 97 | }; 98 | 99 | static inline void set_task_cpu(struct task_struct *p, unsigned int cpu){ 100 | p->thread_info->cpu = cpu; 101 | } 102 | 103 | #endif 104 | -------------------------------------------------------------------------------- /include/abyon/signal.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/sched.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_SIGNAL_H 6 | #define _ABYON_SIGNAL_H 7 | 8 | #include 9 | 10 | #endif 11 | -------------------------------------------------------------------------------- /include/abyon/slab.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/slab.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_SLAB_H 6 | #define _ABYON_SLAB_H 7 | 8 | #define SLAB_DEBUG_FREE 0x00000100UL /* Peform (expensive) checks on free */ 9 | #define SLAB_DEBUG_INITIAL 0x00000200UL /* Call constructor (as verifier) */ 10 | #define SLAB_RED_ZONE 0x00000400UL /* Red zone objs in a cache */ 11 | #define SLAB_POISON 0x00000800UL /* Poison objects */ 12 | #define SLAB_NO_REAP 0x00001000UL /* never reap from the cache */ 13 | #define SLAB_HWCACHE_ALIGN 0x00002000UL /* align objs on a h/w cache lines */ 14 | #define SLAB_CACHE_DMA 0x00004000UL /* use GFP_DMA memory */ 15 | #define SLAB_MUST_HWCACHE_ALIGN 0x00008000UL /* force alignment */ 16 | #define SLAB_STORE_USER 0x00010000UL /* store the last owner for bug hunting */ 17 | #define SLAB_RECLAIM_ACCOUNT 0x00020000UL /* track pages allocated to indicate 18 | what is reclaimable later*/ 19 | #define SLAB_PANIC 0x00040000UL /* panic if kmem_cache_create() fails */ 20 | #define SLAB_DESTROY_BY_RCU 0x00080000UL /* defer freeing pages to RCU */ 21 | struct kmem_cache; 22 | struct cache_sizes{ 23 | unsigned long cs_size; 24 | struct kmem_cache *cs_cachep; 25 | struct kmem_cache *cs_dmacachep; 26 | }; 27 | typedef struct kmem_cache kmem_cache_t; 28 | #endif 29 | -------------------------------------------------------------------------------- /include/abyon/thread_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/thread_info.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_THREAD_INFO_H 7 | #define _ABYON_THREAD_INFO_H 8 | 9 | #include 10 | #include 11 | 12 | #define preempt_count() (current_thread_info()->preempt_count) 13 | 14 | static inline void set_ti_thread_flag(struct thread_info *ti,int flag){ 15 | __set_bit(flag,&ti->flags); 16 | } 17 | #endif 18 | -------------------------------------------------------------------------------- /include/abyon/threads.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/threads.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef __ASM_THREADS_H 7 | #define __ASM_THREADS_H 8 | 9 | #define NR_CRUS 1 10 | 11 | #define PID_MAX 0x8000 12 | 13 | #endif 14 | -------------------------------------------------------------------------------- /include/abyon/timer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/timer.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | #ifndef _ABYON_TIMER_H 8 | #define _ABYON_TIMER_H 9 | 10 | struct timer_base_s; 11 | struct timer_list{ 12 | struct list_head entry; 13 | unsigned long expires; 14 | void (*function)(unsigned long); 15 | unsigned long data; 16 | struct timer_base_s *base; 17 | }; 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /include/abyon/uio.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/uio.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ABYON_UIO_H 7 | #define _ABYON_UIO_H 8 | 9 | struct iovec{ 10 | void *iov_base; 11 | unsigned long iov_len; 12 | }; 13 | 14 | struct kiocb{ 15 | 16 | }; 17 | 18 | #define init_sync_kiocb(x,filp) \ 19 | do{ \ 20 | struct task_struct *tsk = current; \ 21 | }while(0) 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /include/abyon/vmalloc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/vmalloc.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _I386_VMALLOC_H 7 | #define _I386_VMALLOC_H 8 | 9 | #define VM_IOREMAP 0x00000001 /* ioremap() and friends */ 10 | #define VM_ALLOC 0x00000002 /* vmalloc() */ 11 | #define VM_MAP 0x00000004 /* vmap()ed pages */ 12 | 13 | struct vm_struct{ 14 | void *addr; 15 | unsigned long size; 16 | unsigned long flags; 17 | struct page **pages; 18 | unsigned int nr_pages; 19 | unsigned long phys_addr; 20 | struct vm_struct *next; 21 | }; 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /include/abyon/wait.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/abyon/wait.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ABYON_WAIT_H 6 | #define _ABYON_WAIT_H 7 | 8 | #include 9 | 10 | typedef struct __wait_queue wait_queue_t; 11 | typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int sync, void *key); 12 | int default_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key); 13 | 14 | struct task_struct; 15 | struct __wait_queue{ 16 | unsigned int flags; 17 | struct task_struct *task; 18 | wait_queue_func_t func; 19 | struct list_head task_list; 20 | }; 21 | 22 | struct __wait_queue_head{ 23 | struct list_head task_list; 24 | }; 25 | 26 | typedef struct __wait_queue_head wait_queue_head_t; 27 | 28 | static inline void init_waitqueue_head(wait_queue_head_t *q){ 29 | INIT_LIST_HEAD(&q->task_list); 30 | } 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /include/acpi/platform/acenv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/acpi/platform/acenv.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ACPI_ACENV_H 7 | #define _ACPI_ACENV_H 8 | 9 | typedef char* va_list; 10 | 11 | extern unsigned long acpi_native_int; 12 | 13 | /* #define _AUPBND (sizeof (acpi_native_int) - 1) */ 14 | /* #define _ADNBND (sizeof (acpi_native_int) - 1) */ 15 | 16 | #define _AUPBND 3 17 | #define _ADNBND 3 18 | 19 | #define _bnd(X, bnd) (((sizeof (X)) + (bnd)) & (~(bnd))) 20 | #define va_arg(ap, T) (*(T *)(((ap) += (_bnd (T, _AUPBND))) - (_bnd (T,_ADNBND)))) 21 | #define va_start(ap, A) (void) ((ap) = (((char *) &(A)) + (_bnd (A,_AUPBND)))) 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /include/asm-generic/div64.h: -------------------------------------------------------------------------------- 1 | /* 2 | include/asm-generic/div64.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ASM_GENERIC_DIV64_H 7 | #define _ASM_GENERIC_DIV64_H 8 | 9 | 10 | unsigned long long __udivmoddi4(unsigned long long num, unsigned long long den, unsigned long long *rem_p){ 11 | printk("%d,%d\n",num,den); 12 | unsigned long long quot = 0, qbit = 1; 13 | while ( (unsigned long long)den >= 0 ) { 14 | den <<= 1; 15 | qbit <<= 1; 16 | } 17 | 18 | while ( qbit ) { 19 | if ( den <= num ) { 20 | num -= den; 21 | quot += qbit; 22 | } 23 | den >>= 1; 24 | qbit >>= 1; 25 | } 26 | 27 | if ( rem_p ) 28 | *rem_p = num; 29 | 30 | return quot; 31 | } 32 | 33 | 34 | unsigned long long __udivdi3(unsigned long long num, unsigned long long den){ 35 | printk("%d,%d\n",num,den); 36 | return __udivmoddi4(num, den, 0); 37 | } 38 | unsigned long long __umoddi3(unsigned long long num, unsigned long long den){ 39 | unsigned long long v; 40 | (void) __udivmoddi4(num, den, &v); 41 | return v; 42 | } 43 | 44 | unsigned long long divmodk(unsigned long long num, unsigned long long den, unsigned long long *rem_p){ 45 | //printk("%d,%d\n",num,den); 46 | unsigned long long quot = 0, qbit = 1; 47 | while ( (unsigned long long)den >= 0 ) { 48 | den <<= 1; 49 | qbit <<= 1; 50 | } 51 | 52 | while ( qbit ) { 53 | if ( den <= num ) { 54 | num -= den; 55 | quot += qbit; 56 | } 57 | den >>= 1; 58 | qbit >>= 1; 59 | } 60 | 61 | if ( rem_p ) 62 | *rem_p = num; 63 | 64 | return quot; 65 | } 66 | 67 | 68 | unsigned long long divk(unsigned long long num, unsigned long long den){ 69 | printk("%d,%d\n",num,den); 70 | return divmodk(num, den, 0); 71 | } 72 | 73 | unsigned long long modk(unsigned long long num, unsigned long long den){ 74 | printk("%d,%d\n",num,den); 75 | unsigned long long v; 76 | (void) divmodk(num, den, &v); 77 | return v; 78 | } 79 | #endif 80 | -------------------------------------------------------------------------------- /include/asm/atomic.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/atomic.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ASM_ATOMIC_H 6 | #define _ASM_ATOMIC_H 7 | 8 | #define LOCK "" 9 | 10 | typedef struct { volatile int counter; } atomic_t; 11 | 12 | #define ATMOIC_INIT(i) { (i) } 13 | #define atomic_read(v) ((v)->counter) 14 | #define atomic_set(v,i) (((v)->counter) = (i)) 15 | 16 | static inline void atomic_add(int i,atomic_t *v){ 17 | __asm__ __volatile__( 18 | LOCK "addl %1,%0" 19 | :"=m" (v->counter) 20 | :"ir" (i), "m" (v->counter)); 21 | } 22 | 23 | static inline void atomic_sub(int i,atomic_t *v){ 24 | __asm__ __volatile__( 25 | LOCK "subl %1,%0" 26 | :"=m" (v->counter) 27 | :"ir" (i), "m" (v->counter)); 28 | } 29 | 30 | static __inline__ void atomic_inc(atomic_t *v) 31 | { 32 | __asm__ __volatile__( 33 | LOCK "incl %0" 34 | :"=m" (v->counter) 35 | :"m" (v->counter)); 36 | } 37 | 38 | static __inline__ void atomic_dec(atomic_t *v) 39 | { 40 | __asm__ __volatile__( 41 | LOCK "decl %0" 42 | :"=m" (v->counter) 43 | :"m" (v->counter)); 44 | } 45 | 46 | #endif 47 | -------------------------------------------------------------------------------- /include/asm/bitops.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/bitops.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ASM_BITOPS_H 6 | #define _ASM_BITOPS_H 7 | 8 | static inline int test_and_set_bit(int nr, volatile unsigned long * addr) 9 | { 10 | unsigned long index = nr / 32; 11 | unsigned long * tmp = (unsigned long *)&((addr)[index]); 12 | unsigned char bit = 32 - (nr % 32) - 1; 13 | *tmp = *tmp | (1 << bit); 14 | //printk("%d=>index:%d bit:%d",nr,index,bit); 15 | 16 | /* unsigned long oldbit; */ 17 | /* __asm__( */ 18 | /* "btsl %2,%1\n\tsbbl %0,%0" */ 19 | /* :"=r" (oldbit),"=m" (addr) */ 20 | /* :"Ir" (nr)); */ 21 | return 1; 22 | } 23 | 24 | 25 | static int test_and_clear_bit(int nr, volatile unsigned long * addr){ 26 | unsigned long index = nr / 32; 27 | unsigned long * tmp = (unsigned long *)&((addr)[index]); 28 | unsigned char bit = 32 - (nr % 32) - 1; 29 | *tmp = *tmp & ~(1 << bit); 30 | 31 | /* __asm__ __volatile__( */ 32 | /* "btrl %2,%1\n\tsbbl %0,%0" */ 33 | /* :"=r" (oldbit),"=m" (addr) */ 34 | /* :"Ir" (nr) : "memory"); */ 35 | return 1; 36 | } 37 | 38 | static inline int find_first_zero_bit(const unsigned long *addr, unsigned size) 39 | { 40 | int d0, d1, d2; 41 | int res; 42 | 43 | if (!size) 44 | return 0; 45 | 46 | __asm__ __volatile__( 47 | "movl $-1,%%eax\n\t" 48 | "xorl %%edx,%%edx\n\t" 49 | "repe; scasl\n\t" 50 | "je 1f\n\t" 51 | "xorl -4(%%edi),%%eax\n\t" 52 | "subl $4,%%edi\n\t" 53 | "bsfl %%eax,%%edx\n" 54 | "1:\tsubl %%ebx,%%edi\n\t" 55 | "shll $3,%%edi\n\t" 56 | "addl %%edi,%%edx" 57 | :"=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2) 58 | :"1" ((size + 31) >> 5), "2" (addr), "b" (addr) : "memory"); 59 | return res; 60 | } 61 | 62 | static int constant_test_bit(int nr, const volatile unsigned long *addr){ 63 | unsigned long index = nr / 32; 64 | unsigned long * tmp = (unsigned long *)&((addr)[index]); 65 | unsigned char bit = 32 - (nr % 32) - 1; 66 | 67 | if(*tmp & (1 << bit)) return 1; 68 | return 0; 69 | } 70 | 71 | static inline void __set_bit(int nr, volatile unsigned long * addr) { 72 | 73 | __asm__( 74 | "btsl %1,%0" 75 | :"=m" (addr) 76 | :"Ir" (nr)); 77 | 78 | } 79 | static inline void __clear_bit(int nr, volatile unsigned long * addr){ 80 | __asm__ __volatile__( 81 | "btrl %1,%0" 82 | :"=m" (addr) 83 | :"Ir" (nr)); 84 | } 85 | #define test_bit(nr,addr) \ 86 | constant_test_bit((nr),(addr)) 87 | 88 | static inline int ffs(int x){ 89 | int r; 90 | 91 | __asm__("bsfl %1,%0\n\t" 92 | "jnz 1f\n\t" 93 | "movl $-1,%0\n" 94 | "1:" : "=r" (r) : "rm" (x)); 95 | return r+1; 96 | } 97 | static inline unsigned long __ffs(unsigned long word){ 98 | __asm__("bsfl %1,%0" 99 | :"=r" (word) 100 | :"rm" (word)); 101 | return word; 102 | } 103 | 104 | static inline int sched_find_first_bit(const unsigned long *b){ 105 | if (b[0]) 106 | return __ffs(b[0]); 107 | if (b[1]) 108 | return __ffs(b[1]) + 32; 109 | if (b[2]) 110 | return __ffs(b[2]) + 64; 111 | if (b[3]) 112 | return __ffs(b[3]) + 96; 113 | return __ffs(b[4]) + 128; 114 | } 115 | 116 | #endif 117 | -------------------------------------------------------------------------------- /include/asm/cache.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/cache.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef __ARCH_I386_CACHE_H 7 | #define __ARCH_I386_CACHE_H 8 | 9 | #define L1_CACHE_SHIFT 8 10 | #define L1_CACHE_BYTES (1 << L1_CACHE_SHIFT) 11 | #endif 12 | -------------------------------------------------------------------------------- /include/asm/current.h: -------------------------------------------------------------------------------- 1 | #ifndef _I386_CURRENT_H 2 | #define _I386_CURRENT_H 3 | 4 | #include 5 | struct task_struct; 6 | 7 | static inline struct task_struct *get_current(void){ 8 | return current_thread_info()->task; 9 | } 10 | #define current get_current() 11 | #endif 12 | -------------------------------------------------------------------------------- /include/asm/desc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/desc.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef __ASM_DESC_H 7 | #define __ASM_DESC_H 8 | 9 | #include 10 | #include 11 | 12 | #include 13 | #include 14 | #include 15 | 16 | extern struct desc_struct cpu_gdt_table[GDT_ENTRIES]; 17 | DECLARE_PER_CPU(struct desc_struct, cpu_gdt_table[GDT_ENTRIES]); 18 | 19 | #define get_cpu_gdt_table(_cpu) (cpu_gdt_table) 20 | 21 | struct Xgt_desc_struct{ 22 | unsigned short size; 23 | unsigned long address __attribute__((packed)); 24 | unsigned short pad; 25 | }__attribute__((packed)); 26 | 27 | extern struct Xgt_desc_struct idt_descr, cpu_gdt_descr[1]; 28 | 29 | #define load_TR_desc() __asm__ __volatile__("ltr %w0"::"q" (GDT_ENTRY_TSS*8)) 30 | #define load_LDT_desc() __asm__ __volatile__("lldt %w0"::"q" (GDT_ENTRY_LDT*8)) 31 | 32 | #define load_gdt(dtr) __asm__ __volatile__("lgdt %0"::"m" (*dtr)) 33 | #define load_idt(dtr) __asm__ __volatile__("lidt %0"::"m" (*dtr)) 34 | #define load_tr(tr) __asm__ __volatile__("ltr %0"::"mr" (tr)) 35 | #define load_ldt(ldt) __asm__ __volatile__("lldt %0"::"mr" (ldt)) 36 | 37 | #define store_gdt(dtr) __asm__ __volatile__("sgdt %0":"=m" (*dtr)) 38 | #define store_idt(dtr) __asm__ __volatile__("sidt %0":"=m" (*dtr)) 39 | #define store_tr(tr) __asm__ __volatile__("str %0":"=mr" (tr)) 40 | #define store_ldt(ldt) __asm__ __volatile__("sldt %0":"=mr" (ldt)) 41 | 42 | #define _set_tssldt_desc(n,addr,limit,type) \ 43 | __asm__ __volatile__ ("movw %w3,0(%2)\n\t" \ 44 | "movw %w1,2(%2)\n\t" \ 45 | "rorl $16,%1\n\t" \ 46 | "movb %b1,4(%2)\n\t" \ 47 | "movb %4,5(%2)\n\t" \ 48 | "movb $0,6(%2)\n\t" \ 49 | "movb %h1,7(%2)\n\t" \ 50 | "rorl $16,%1" \ 51 | : "=m"(*(n)) : "q" (addr), "r"(n), "ir"(limit), "i"(type)) 52 | 53 | 54 | static inline void __set_tss_desc(unsigned int cpu, unsigned int entry, void *addr){ 55 | _set_tssldt_desc(&get_cpu_gdt_table(cpu)[entry], (int)addr, 56 | offsetof(struct tss_struct, __cacheline_filler) - 1, 0x89); 57 | } 58 | #define set_tss_desc(cpu,addr) __set_tss_desc(cpu, GDT_ENTRY_TSS, addr) 59 | #endif 60 | -------------------------------------------------------------------------------- /include/asm/dma.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/dma.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ASM_DMA_H 7 | #define _ASM_DMA_H 8 | 9 | #include 10 | #define MAX_DMA_ADDRESS (PAGE_OFFSET+0x1000000) 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /include/asm/e820.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/e820.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | #ifndef __E820_HEADER 8 | #define __E820_HEADER 9 | 10 | #define E820MAX 128 11 | 12 | #define E820_RAM 1 13 | #define E820_RESERVED 2 14 | #define E820_ACPI 3 15 | #define E820_NVS 4 16 | 17 | extern int printk(const char *fmt, ...); 18 | 19 | struct e820map { 20 | int nr_map; 21 | struct e820entry { 22 | unsigned long addr; /* start of memory segment */ 23 | unsigned long size; /* size of memory segment */ 24 | unsigned long type; /* type of memory segment */ 25 | } map[E820MAX]; 26 | }; 27 | 28 | 29 | struct e820map e820; 30 | 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /include/asm/fixmap.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/fixmap.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ASM_FIXMAP_H 7 | #define _ASM_FIXMAP_H 8 | 9 | #include 10 | 11 | #define __FIXADDR_TOP 0xfffff000 12 | 13 | enum fixed_addresses { 14 | FIX_HOLE, 15 | FIX_VSYSCALL, 16 | FIX_APIC_BASE, /* local (CPU) APIC) -- required for SMP or not */ 17 | FIX_IO_APIC_BASE_0, 18 | FIX_IO_APIC_BASE_END = FIX_IO_APIC_BASE_0,// + MAX_IO_APICS-1, 19 | FIX_CO_CPU, /* Cobalt timer */ 20 | FIX_CO_APIC, /* Cobalt APIC Redirection Table */ 21 | FIX_LI_PCIA, /* Lithium PCI Bridge A */ 22 | FIX_LI_PCIB, /* Lithium PCI Bridge B */ 23 | FIX_F00F_IDT, /* Virtual mapping for IDT */ 24 | FIX_CYCLONE_TIMER, /*cyclone timer register*/ 25 | FIX_KMAP_BEGIN, /* reserved pte's for temporary kernel mappings */ 26 | FIX_KMAP_END,// = FIX_KMAP_BEGIN+(KM_TYPE_NR*NR_CPUS)-1, 27 | FIX_ACPI_BEGIN, 28 | FIX_ACPI_END,// = FIX_ACPI_BEGIN + FIX_ACPI_PAGES - 1, 29 | FIX_PCIE_MCFG, 30 | __end_of_permanent_fixed_addresses, 31 | /* temporary boot-time mappings, used before ioremap() is functional */ 32 | #define NR_FIX_BTMAPS 16 33 | FIX_BTMAP_END = __end_of_permanent_fixed_addresses, 34 | FIX_BTMAP_BEGIN = FIX_BTMAP_END + NR_FIX_BTMAPS - 1, 35 | FIX_WP_TEST, 36 | __end_of_fixed_addresses 37 | }; 38 | 39 | #define FIXADDR_TOP ((unsigned long)__FIXADDR_TOP) 40 | #define FIXADDR_START FIXADDR_TOP 41 | 42 | /* Exchange fix index and virtual address */ 43 | #define __fix_to_virt(x) (FIXADDR_TOP - ((x) << PAGE_SHIFT)) 44 | #define __virt_to_fix(x) ((FIXADDR_TOP - ((x) & PAGE_MASK)) >> PAGE_SHIFT) 45 | 46 | #endif 47 | -------------------------------------------------------------------------------- /include/asm/highmem.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/highmem.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ASM_HIGHMEM_H 7 | #define _ASM_HIGHMEM_H 8 | 9 | /* head (virtual) address of HIGHMEM */ 10 | extern pte_t *pkmap_page_table; 11 | 12 | 13 | #define LAST_PKMAP 1024 14 | 15 | #define PKMAP_BASE 0xff800000UL 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /include/asm/hw_irq.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/hw_irq.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef __ASM_HW_IRQ_H__ 6 | #define __ASM_HW_IRQ_H__ 7 | 8 | #include 9 | extern void (*interrupt[NR_VECTORS-FIRST_EXTERNAL_VECTOR])(void); 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /include/asm/i8259.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/i8259.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef __ASM_I8259_H__ 6 | #define __ASM_I8259_H__ 7 | 8 | unsigned int cached_irq_mask = 0xf9ef; 9 | 10 | #define __byte(x,y) (((unsigned char *) &(y))[x]) 11 | /* #define cached_master_mask (__byte(0, cached_irq_mask)) */ 12 | /* #define cached_slave_mask (__byte(1, cached_irq_mask)) */ 13 | #define cached_master_mask 0xf9 14 | #define cached_slave_mask 0xef 15 | 16 | 17 | extern void init_8259A(int auto_eoi); 18 | extern void enable_8259A_irq(unsigned int irq); 19 | extern void disable_8259A_irq(unsigned int irq); 20 | extern unsigned int startup_8259A_irq(unsigned int irq); 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /include/asm/io.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/io.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef __ASM_IO_H__ 7 | #define __ASM_IO_H__ 8 | 9 | static inline void outb(unsigned short port, unsigned char val){ 10 | asm volatile ( "outb %0, %1" : : "a"(val), "Nd"(port) ); 11 | } 12 | 13 | #define outb_p outb 14 | #endif 15 | -------------------------------------------------------------------------------- /include/asm/io_ports.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/io_ports.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ASM_IO_PORTS_H 6 | #define _ASM_IO_PORTS_H 7 | 8 | /* i8253A PIT registers */ 9 | #define PIT_MODE 0x43 10 | #define PIT_CH0 0x40 11 | #define PIT_CH2 0x42 12 | 13 | /* i8259A PIC registers */ 14 | #define PIC_MASTER_CMD 0x20 15 | #define PIC_MASTER_IMR 0x21 16 | #define PIC_MASTER_ISR PIC_MASTER_CMD 17 | #define PIC_MASTER_POLL PIC_MASTER_ISR 18 | #define PIC_MASTER_OCW3 PIC_MASTER_ISR 19 | #define PIC_SLAVE_CMD 0xa0 20 | #define PIC_SLAVE_IMR 0xa1 21 | 22 | /* i8259A PIC related value */ 23 | #define PIC_CASCADE_IR 2 24 | #define MASTER_ICW4_DEFAULT 0x01 25 | #define SLAVE_ICW4_DEFAULT 0x01 26 | #define PIC_ICW4_AEOI 2 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /include/asm/irq.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/irq.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #define NR_IRQS 16 7 | -------------------------------------------------------------------------------- /include/asm/irq_vectors.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/irq_vectors.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ASM_IRQ_VECTORS_H 7 | #define _ASM_IRQ_VECTORS_H 8 | 9 | #define FIRST_EXTERNAL_VECTOR 0x20 10 | #define SYSCALL_VECTOR 0x80 11 | 12 | #define TIMER_IRQ 0 13 | #define NR_VECTORS 256 14 | 15 | #define FPU_IRQ 13 16 | #endif 17 | -------------------------------------------------------------------------------- /include/asm/page.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/page.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _I386_PAGE_H 7 | #define _I386_PAGE_H 8 | 9 | /* Page size(4k) */ 10 | #define PAGE_SHIFT 12 11 | #define PAGE_SIZE (1UL << PAGE_SHIFT) 12 | #define PAGE_MASK (~(PAGE_SIZE - 1)) 13 | #define PAGE_CACHE_SHIFT PAGE_SHIFT 14 | #define PAGE_CACHE_SIZE PAGE_SIZE 15 | 16 | /* Virtual page tables */ 17 | typedef struct { unsigned long pte_low; } pte_t; 18 | typedef struct { unsigned long pgd; } pgd_t; 19 | typedef struct { unsigned long pgprot; } pgprot_t; 20 | 21 | 22 | /* Kernel entry address */ 23 | #define __PAGE_OFFSET (0x00100000) 24 | #define __PHYSICAL_START (0x00100000) 25 | #define PAGE_OFFSET ((unsigned long)__PAGE_OFFSET) 26 | 27 | #define virt_to_page(kaddr) pfn_to_page(kaddr >> PAGE_SHIFT) 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /include/asm/percpu.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/percpu.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ASM_PERCPU_H 7 | #define _ASM_PERCPU_H 8 | 9 | #define DEFINE_PER_CPU(type,name) \ 10 | __typeof__(type) per_cpu__##name 11 | #define per_cpu(var,cpu) (*((void)(cpu),&per_cpu__##var)) 12 | #define __get_cpu_var(var) per_cpu__##var 13 | #define DECLARE_PER_CPU(type, name) extern __typeof__(type) per_cpu__##name 14 | #endif 15 | -------------------------------------------------------------------------------- /include/asm/pgtable.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/pgtable.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _I386_PGTABLE_H 7 | #define _I386_PGTABLE_H 8 | 9 | #include 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | extern pgd_t swapper_pg_dir[1024]; 16 | 17 | #define VMALLOC_START (896 * 1024 * 1024) 18 | #define VMALLOC_END FIXADDR_START - 2 * PAGE_SIZE 19 | 20 | #define PTRS_PER_PGD 1024 //entries per one pgd 21 | #define PTRS_PER_PTE 1024 //entries per one pte 22 | 23 | /* */ 24 | #define PGDIR_SHIFT 22 25 | #define PGDIR_SIZE (1UL << PGDIR_SHIFT) 26 | #define PGDIR_MASK (~(PGDIR_SIZE - 1)) 27 | 28 | /* Get pgd index from virtual address */ 29 | #define pgd_index(addr) (((addr) >> PGDIR_SHIFT) & (PTRS_PER_PGD - 1)) 30 | 31 | /* Get pgd */ 32 | #define pgd_offset(mm,addr) ((mm)->pgd + pgd_index(addr)) 33 | #define pgd_offset_k(addr) pgd_offset(&init_mm,addr) 34 | 35 | /* Page table */ 36 | #define PTE_SHIFT 37 | #define pte_index(addr) (((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)) 38 | 39 | /* Page directory entry attribute */ 40 | #define _PAGE_PRESENT 0x001 41 | #define _PAGE_RW 0x002 42 | #define _PAGE_USER 0x004 43 | #define _PAGE_PWT 0x008 44 | #define _PAGE_PCD 0x010 45 | #define _PAGE_ACCESSED 0x020 46 | #define _PAGE_DIRTY 0x040 47 | #define _PAGE_PSE 0x080 48 | #define _PAGE_GLOBAL 0x100 49 | #define _PAGE_UNUSED1 0x200 50 | #define _PAGE_UNUSED2 0x400 51 | #define _PAGE_UNUSED3 0x800 52 | 53 | #define _PAGE_FILE 0x040 54 | #define _PAGE_PROTNONE 0x080 55 | #define _PAGE_NX 0 56 | 57 | #define _PAGE_TABLE (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY) 58 | 59 | #define _PAGE_SHARED \ 60 | (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED) 61 | 62 | #define _PAGE_SHARED_EXEC \ 63 | (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED) 64 | 65 | #define _PAGE_KERNEL \ 66 | (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_NX) 67 | #define _PAGE_KERNEL_EXEC \ 68 | (_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED) 69 | 70 | #define PAGE_SHARED (pgprot_t){_PAGE_SHARED} 71 | #define PAGE_SHARED_EXEC (pgprot_t){_PAGE_SHARED_EXEC} 72 | #define PAGE_KERNEL (pgprot_t){_PAGE_KERNEL} 73 | #define PAGE_KERNEL_EXEC (pgprot_t){_PAGE_KERNEL_EXEC} 74 | 75 | /* Generate PDE or PTE from pfn(page frame number) */ 76 | #define pfn_pte(pfn,prot) (pte_t){((pfn) << PAGE_SHIFT) | prot.pgprot} 77 | #define pte_pfn(x) ((unsigned long)(((x).pte_low >> PAGE_SHIFT))) 78 | 79 | #define pgd_none(x) ((x).pgd == 0) 80 | 81 | #define pte_virtual_addr(pgdt,addr) \ 82 | ((pte_t *) pa_to_va((pgdt)->pgd & PAGE_MASK) + pte_index(addr)) 83 | 84 | /* #define pgd_pa_addr(pgdat,addr) \ */ 85 | /* ((pte_t *) (((pgdat).pgd ^ ((pgdat).pgd & PAGE_MASK)) + pgd_index(addr))) */ 86 | 87 | /* #define pte_pa_addr(ptedat,addr) \ */ 88 | /* ((unsigned long) (((ptedat).pte_low ^ ((ptedat).pte_low & PAGE_MASK)) + pte_index(addr))) */ 89 | 90 | #define pgd_pa_addr(pgdat,addr) \ 91 | ((pte_t *) (((pgdat).pgd & 0xfffff000) + pgd_index(addr))) 92 | 93 | #define pte_pa_addr(ptedat,addr) \ 94 | ((unsigned long) (((ptedat).pte_low & 0xfffff000) + pte_index(addr))) 95 | 96 | /* Change physical address to virtual address (Straight map area) */ 97 | #define pa_to_va(addr) (void *)((unsigned long)(addr)) 98 | 99 | 100 | #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) 101 | #define PFN_DOWN(x) ((x) >> PAGE_SHIFT) 102 | 103 | /* set_pte: Gurantee the order of memory access 104 | * not to have late access to PTE. 105 | * Use memory barrier. 106 | */ 107 | static inline void set_pte(pte_t *ptep,pte_t pte){ 108 | ptep->pte_low = pte.pte_low; 109 | //smp_wmb(); //Write memory barrier 110 | } 111 | 112 | #endif 113 | -------------------------------------------------------------------------------- /include/asm/processor.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/processor.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef __ASM_I386_PROCESSOR_H 7 | #define __ASM_I386_PROCESSOR_H 8 | 9 | #include 10 | 11 | #include 12 | #include 13 | 14 | struct desc_struct { 15 | unsigned long a,b; 16 | }; 17 | 18 | DECLARE_PER_CPU(struct tss_struct, init_tss); 19 | 20 | #define IO_BITMAP_BITS 65536 21 | #define IO_BITMAP_BYTES (IO_BITMAP_BITS/8) 22 | #define IO_BITMAP_LONGS (IO_BITMAP_BYTES/sizeof(long)) 23 | #define IO_BITMAP_OFFSET offsetof(struct tss_struct,io_bitmap) 24 | #define INVALID_IO_BITMAP_OFFSET 0x8000 25 | #define INVALID_IO_BITMAP_OFFSET_LAZY 0x9000 26 | 27 | #define cache_line_size() (128) 28 | 29 | struct tss_struct { 30 | unsigned short back_link,__blh; 31 | unsigned long esp0; 32 | unsigned short ss0,__ss0h; 33 | unsigned long esp1; 34 | unsigned short ss1,__ss1h; /* ss1 is used to cache MSR_IA32_SYSENTER_CS */ 35 | unsigned long esp2; 36 | unsigned short ss2,__ss2h; 37 | unsigned long __cr3; 38 | unsigned long eip; 39 | unsigned long eflags; 40 | unsigned long eax,ecx,edx,ebx; 41 | unsigned long esp; 42 | unsigned long ebp; 43 | unsigned long esi; 44 | unsigned long edi; 45 | unsigned short es, __esh; 46 | unsigned short cs, __csh; 47 | unsigned short ss, __ssh; 48 | unsigned short ds, __dsh; 49 | unsigned short fs, __fsh; 50 | unsigned short gs, __gsh; 51 | unsigned short ldt, __ldth; 52 | unsigned short trace, io_bitmap_base; 53 | unsigned long io_bitmap[IO_BITMAP_LONGS + 1]; 54 | unsigned long io_bitmap_max; 55 | struct thread_struct *io_bitmap_owner; 56 | unsigned long __cacheline_filler[35]; 57 | unsigned long stack[64]; 58 | } __attribute__((packed)); 59 | 60 | struct thread_struct { 61 | struct desc_struct tls_array[GDT_ENTRY_TLS_ENTRIES]; 62 | unsigned long esp0; 63 | unsigned long sysenter_cs; 64 | unsigned long eip; 65 | unsigned long esp; 66 | unsigned long fs; 67 | unsigned long gs; 68 | unsigned long debugreg[8]; /* %%db0-7 debug registers */ 69 | unsigned long cr2, trap_no, error_code; 70 | unsigned long screen_bitmap; 71 | unsigned long v86flags, v86mask, saved_esp0; 72 | unsigned int saved_fs, saved_gs; 73 | unsigned long *io_bitmap_ptr; 74 | unsigned long iopl; 75 | unsigned long io_bitmap_max; 76 | }; 77 | 78 | #define INIT_THREAD { \ 79 | .io_bitmap_ptr = NULL, \ 80 | } 81 | 82 | #define THREAD_SIZE (2 * PAGE_SIZE) 83 | static inline void load_esp0(struct tss_struct *tss, struct thread_struct *thread){ 84 | tss->esp0 = thread->esp0; 85 | } 86 | #endif 87 | -------------------------------------------------------------------------------- /include/asm/ptrace.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/ptrace.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _I386_PTRACE_H 7 | #define _I386_PTRACE_H 8 | 9 | #define EBX 0 10 | #define ECX 1 11 | #define EDX 2 12 | #define ESI 3 13 | #define EDI 4 14 | #define EBP 5 15 | #define EAX 6 16 | #define DS 7 17 | #define ES 8 18 | #define FS 9 19 | #define GS 10 20 | #define ORIG_EAX 11 21 | #define EIP 12 22 | #define CS 13 23 | #define EFL 14 24 | #define UESP 15 25 | #define SS 16 26 | #define FRAME_SIZE 17 27 | 28 | struct pt_regs { 29 | long ebx; 30 | long ecx; 31 | long edx; 32 | long esi; 33 | long edi; 34 | long ebp; 35 | long eax; 36 | int xds; 37 | int xes; 38 | long orig_eax; 39 | long eip; 40 | int xcs; 41 | long eflags; 42 | long esp; 43 | int xss; 44 | }; 45 | 46 | 47 | #endif 48 | -------------------------------------------------------------------------------- /include/asm/segment.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/segment.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | 7 | #ifndef _ASM_SEGMENT_H 8 | #define _ASM_SEGMENT_H 9 | 10 | /* 11 | * The layout of the per-CPU GDT under Abyon: 12 | * 13 | * 0 - null 14 | * 1 - reserved 15 | * 2 - reserved 16 | * 3 - reserved 17 | * 18 | * 4 - unused <==== new cacheline 19 | * 5 - unused 20 | * 21 | * ------- start of TLS (Thread-Local Storage) segments: 22 | * 23 | * 6 - TLS segment #1 [ glibc's TLS segment ] 24 | * 7 - TLS segment #2 [ Wine's %fs Win32 segment ] 25 | * 8 - TLS segment #3 26 | * 9 - reserved 27 | * 10 - reserved 28 | * 11 - reserved 29 | * 30 | * ------- start of kernel segments: 31 | * 32 | * 12 - kernel code segment <==== new cacheline 33 | * 13 - kernel data segment 34 | * 14 - default user CS 35 | * 15 - default user DS 36 | * 16 - TSS 37 | * 17 - LDT 38 | * 18 - PNPBIOS support (16->32 gate) 39 | * 19 - PNPBIOS support 40 | * 20 - PNPBIOS support 41 | * 21 - PNPBIOS support 42 | * 22 - PNPBIOS support 43 | * 23 - APM BIOS support 44 | * 24 - APM BIOS support 45 | * 25 - APM BIOS support 46 | * 47 | * 26 - ESPFIX small SS 48 | * 27 - unused 49 | * 28 - unused 50 | * 29 - unused 51 | * 30 - unused 52 | * 31 - TSS for double fault handler 53 | */ 54 | 55 | #define GDT_ENTRY_TLS_ENTRIES 3 56 | #define GDT_ENTRY_TLS_MIN 6 57 | #define GDT_ENTRY_TLS_MAX (GDT_ENTRY_TLS_MIN + GDT_ENTRY_TLS_ENTRIES - 1) 58 | 59 | #define TLS_SIZE (GDT_ENTRY_TLS_ENTRIES * 8) 60 | 61 | /* GDT entry (User space) */ 62 | #define GDT_ENTRY_DEFAULT_USER_CS 14 //User CS 63 | #define __USER_CS (GDT_ENTRY_DEFAULT_USER_CS * 8 + 3) 64 | 65 | #define GDT_ENTRY_DEFAULT_USER_DS 15 //User DS 66 | #define __USER_DS (GDT_ENTRY_DEFAULT_USER_DS * 8 + 3) 67 | 68 | /* GDT entry (Kernel space) */ 69 | #define GDT_ENTRY_KERNEL_BASE 12 70 | 71 | #define GDT_ENTRY_KERNEL_CS (GDT_ENTRY_KERNEL_BASE + 0)//Kernel CS 72 | #define __KERNEL_CS (GDT_ENTRY_KERNEL_CS * 8) 73 | 74 | #define GDT_ENTRY_KERNEL_DS (GDT_ENTRY_KERNEL_BASE + 1)//Kernel DS 75 | #define __KERNEL_DS (GDT_ENTRY_KERNEL_DS * 8) 76 | 77 | #define GDT_ENTRY_TSS (GDT_ENTRY_KERNEL_BASE + 4) 78 | #define GDT_ENTRY_LDT (GDT_ENTRY_KERNEL_BASE + 5) 79 | 80 | #define GDT_ENTRY_PNPBIOS_BASE (GDT_ENTRY_KERNEL_BASE + 6) 81 | #define GDT_ENTRY_APMBIOS_BASE (GDT_ENTRY_KERNEL_BASE + 11) 82 | 83 | #define GDT_ENTRY_ESPFIX_SS (GDT_ENTRY_KERNEL_BASE + 14) 84 | #define __ESPFIX_SS (GDT_ENTRY_ESPFIX_SS * 8) 85 | 86 | #define GDT_ENTRY_DOUBLEFAULT_TSS 31 87 | 88 | /* GDT Size */ 89 | #define GDT_ENTRIES 32 90 | #define GDT_SIZE (GDT_ENTRIES * 8) 91 | 92 | /* Simple GDT entries used in booting process */ 93 | #define GDT_ENTRY_BOOT_CS 2 94 | #define __BOOT_CS (GDT_ENTRY_BOOT_CS * 8) 95 | 96 | #define GDT_ENTRY_BOOT_DS (GDT_ENTRY_BOOT_CS + 1) 97 | #define __BOOT_DS (GDT_ENTRY_BOOT_DS * 8) 98 | 99 | /* IDT Size */ 100 | #define IDT_ENTRIES 256 101 | 102 | #endif 103 | -------------------------------------------------------------------------------- /include/asm/semaphore.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/semaphore.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ASM_SEMAPHORE_H 6 | #define _ASM_SEMAPHORE_H 7 | 8 | #include 9 | 10 | #include 11 | 12 | struct semaphore{ 13 | atomic_t count; 14 | int sleepers; 15 | wait_queue_head_t wait; 16 | }; 17 | 18 | static inline void sema_init(struct semaphore *sem,int val){ 19 | atomic_set(&sem->count,val); 20 | sem->sleepers = 0; 21 | init_waitqueue_head(&sem->wait); 22 | } 23 | 24 | static inline void init_MUTEX(struct semaphore *sem){ 25 | sema_init(sem,1); 26 | } 27 | #endif 28 | -------------------------------------------------------------------------------- /include/asm/signal.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/signal.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #ifndef _ASM_SIGNAL_H 6 | #define _ASM_SIGNAL_H 7 | 8 | #define _NSIG 64 9 | #define NSIG 32 10 | 11 | #define SIGHUP 1 12 | #define SIGINT 2 13 | #define SIGQUIT 3 14 | #define SIGILL 4 15 | #define SIGTRAP 5 16 | #define SIGABRT 6 17 | #define SIGIOT 6 18 | #define SIGBUS 7 19 | #define SIGFPE 8 20 | #define SIGKILL 9 21 | #define SIGUSR1 10 22 | #define SIGSEGV 11 23 | #define SIGUSR2 12 24 | #define SIGPIPE 13 25 | #define SIGALRM 14 26 | #define SIGTERM 15 27 | #define SIGSTKFLT 16 28 | #define SIGCHLD 17 29 | #define SIGCONT 18 30 | #define SIGSTOP 19 31 | #define SIGTSTP 20 32 | #define SIGTTIN 21 33 | #define SIGTTOU 22 34 | #define SIGURG 23 35 | #define SIGXCPU 24 36 | #define SIGXFSZ 25 37 | #define SIGVTALRM 26 38 | #define SIGPROF 27 39 | #define SIGWINCH 28 40 | #define SIGIO 29 41 | #define SIGPOLL SIGIO 42 | /* 43 | #define SIGLOST 29 44 | */ 45 | #define SIGPWR 30 46 | #define SIGSYS 31 47 | #define SIGUNUSED 31 48 | 49 | /* These should not be considered constants from userland. */ 50 | #define SIGRTMIN 32 51 | #define SIGRTMAX _NSIG 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /include/asm/smp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/smp.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ASM_SMP_H 7 | #define _ASM_SMP_H 8 | 9 | #include 10 | #define smp_processor_id() (current_thread_info()->cpu) 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /include/asm/string.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/string.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ASM_STRING_H 7 | #define _ASM_STRING_H 8 | 9 | static inline void *__memcpy(void *to,void *from ,int n){ 10 | int d0,d1,d2; 11 | __asm__ __volatile__( 12 | "rep ; movsl\n\t" 13 | "movl %4,%%ecx\n\t" 14 | "andl $3,%%ecx\n\t" 15 | "rep ; movsb\n\t" 16 | :"=&c" (d0),"=&D" (d1), "=&S" (d2) 17 | :"0" (n/4),"g" (n), "1" ((long)to),"2" ((long)from) 18 | :"memory"); 19 | return (to); 20 | } 21 | static inline void * __memset_generic(void * s, char c,int count){ 22 | int d0,d1; 23 | __asm__ __volatile__( 24 | "rep\n\t" 25 | "stosb" 26 | : "=&c" (d0), "=&D" (d1) 27 | :"a" (c),"1" (s),"0" (count) 28 | :"memory"); 29 | return s; 30 | } 31 | static inline unsigned long strlen(const char * s) 32 | { 33 | int d0; 34 | register int __res; 35 | __asm__ __volatile__( 36 | "repne\n\t" 37 | "scasb\n\t" 38 | "notl %0\n\t" 39 | "decl %0" 40 | :"=c" (__res), "=&D" (d0) 41 | :"1" (s),"a" (0), "0" (0xffffffffu) 42 | :"memory"); 43 | return __res; 44 | } 45 | static inline unsigned long strnlen(const char *s, unsigned long count){ 46 | int __res; 47 | int d0; 48 | __asm__ __volatile__( 49 | "movl %2,%0\n\t" 50 | "jmp 2f\n" 51 | "1:\tcmpb $0,(%0)\n\t" 52 | "je 3f\n\t" 53 | "incl %0\n" 54 | "2:\tdecl %1\n\t" 55 | "cmpl $-1,%1\n\t" 56 | "jne 1b\n" 57 | "3:\tsubl %2,%0" 58 | :"=a" (__res), "=&d" (d0) 59 | :"c" (s), "1" (count) 60 | :"memory"); 61 | return __res; 62 | } 63 | 64 | static inline int strcmp(const char * cs,const char * ct){ 65 | int d0, d1; 66 | register int __res; 67 | __asm__ __volatile__( 68 | "1:\tlodsb\n\t" 69 | "scasb\n\t" 70 | "jne 2f\n\t" 71 | "testb %%al,%%al\n\t" 72 | "jne 1b\n\t" 73 | "xorl %%eax,%%eax\n\t" 74 | "jmp 3f\n" 75 | "2:\tsbbl %%eax,%%eax\n\t" 76 | "orb $1,%%al\n" 77 | "3:" 78 | :"=a" (__res), "=&S" (d0), "=&D" (d1) 79 | :"1" (cs),"2" (ct) 80 | :"memory"); 81 | return __res; 82 | } 83 | #define __memset(s,c,count) \ 84 | (__memset_generic((s),(c),(count))) 85 | 86 | 87 | #endif 88 | -------------------------------------------------------------------------------- /include/asm/system.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/system.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef __ASM_SYSTEM_H 7 | #define __ASM_SYSTEM_H 8 | 9 | /* Operation of special registes */ 10 | #define read_cr0()({ \ 11 | unsigned int __ret; \ 12 | __asm__ __volatile__( \ 13 | "movl %%cr0,%0\n\t" \ 14 | :"=r" (__ret)); \ 15 | __ret; \ 16 | }) 17 | 18 | #define write_cr0(x) \ 19 | __asm__ __volatile__("movl %0,%%cr0": :"r" (x)); 20 | 21 | #define read_cr2()({ \ 22 | unsigned int __ret; \ 23 | __asm__ __volatile__( \ 24 | "movl %%cr2,%0\n\t" \ 25 | :"=r" (__ret)); \ 26 | __ret; \ 27 | }) 28 | 29 | #define write_cr2(x) \ 30 | __asm__ __volatile__("movl %0,%%cr2": :"r" (x)); 31 | 32 | #define read_cr3()({ \ 33 | unsigned int __ret; \ 34 | __asm__ __volatile__( \ 35 | "movl %%cr3,%0\n\t" \ 36 | :"=r" (__ret)); \ 37 | __ret; \ 38 | }) 39 | 40 | #define write_cr3(x) \ 41 | __asm__ __volatile__("movl %0,%%cr3": :"r" (x)); 42 | 43 | #define read_cr4()({ \ 44 | unsigned int __ret; \ 45 | __asm__ __volatile__( \ 46 | "movl %%cr4,%0\n\t" \ 47 | :"=r" (__ret)); \ 48 | __ret; \ 49 | }) 50 | 51 | #define write_cr4(x) \ 52 | __asm__ __volatile__("movl %0,%%cr4": :"r" (x)); 53 | 54 | /* Write memory barrier */ 55 | #define wmb() __asm__ __volatile__("sfence"); 56 | #define smp_wmb() wmb() 57 | 58 | /* Enable Interupt (set IF = 1) */ 59 | #define local_irq_enable() __asm__ __volatile__("sti": : :"memory") 60 | #define local_irq_save(x) __asm__ __volatile__("pushfl ; popl %0 ; cli":"=g" (x): /* no input */ :"memory") 61 | 62 | #define switch_to(prev,next,last) do{ \ 63 | unsigned long esi,edi; \ 64 | __asm__ __volatile__("pushfl\n\t"\ 65 | "pushl %%ebp\n\t" \ 66 | "movl %%esp,%0\n\t" \ 67 | "movl %5,%%esp\n\t" \ 68 | "movl $1f,%1\n\t"\ 69 | "pushl %6\n\t" \ 70 | "jmp __switch_to\n" \ 71 | "1:\t" \ 72 | "popl %%ebp\n\t" \ 73 | "popfl" \ 74 | :"=m" (prev->thread.esp),"=m" (prev->thread.eip), \ 75 | "=a" (last),"=S" (esi),"=D" (edi) \ 76 | :"m" (next->thread.esp),"m" (next->thread.eip), \ 77 | "2" (prev), "d" (next)); \ 78 | }while(0) 79 | #endif 80 | -------------------------------------------------------------------------------- /include/asm/thread_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * include/asm/thread_info.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #ifndef _ASM_THREAD_INFO_H 7 | #define _ASM_THREAD_INFO_H 8 | 9 | 10 | #define THREAD_SIZE 8192 11 | 12 | #ifndef __ASSEMBLY__ 13 | 14 | struct thread_info{ 15 | struct task_struct *task; 16 | struct exec_domain *exec_domain; 17 | unsigned long flags; 18 | unsigned long status; 19 | unsigned long cpu; 20 | int preempt_count; 21 | unsigned long addr_limit; 22 | 23 | }; 24 | 25 | union thread_union{ 26 | struct thread_info thread_info; 27 | unsigned long stack[THREAD_SIZE / sizeof(long)]; 28 | }; 29 | 30 | 31 | #define init_thread_info (init_thread_union.thread_info) 32 | #define init_stack (init_thread_union.stack) 33 | 34 | #define alloc_thread_info(tsk) kmalloc(THREAD_SIZE,0) 35 | #define free_thread_info(info) kfree(info) 36 | 37 | static inline struct thread_info *current_thread_info(void){ 38 | struct thread_info *ti; 39 | __asm__("andl %%esp,%0; ":"=r"(ti) : "0" ((~(THREAD_SIZE - 1)))); 40 | return ti; 41 | } 42 | #else 43 | 44 | #define GET_THREAD_INFO(reg) \ 45 | movl $-THREAD_SIZE,reg; \ 46 | andl %esp,reg 47 | 48 | #endif 49 | 50 | #define TIF_SYSCALL_TRACE 0 /* syscall trace active */ 51 | #define TIF_NOTIFY_RESUME 1 /* resumption notification requested */ 52 | #define TIF_SIGPENDING 2 /* signal pending */ 53 | #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ 54 | #define TIF_SINGLESTEP 4 /* restore singlestep on return to user mode */ 55 | #define TIF_IRET 5 /* return with iret */ 56 | #define TIF_SYSCALL_EMU 6 /* syscall emulation active */ 57 | #define TIF_SYSCALL_AUDIT 7 /* syscall auditing active */ 58 | #define TIF_SECCOMP 8 /* secure computing */ 59 | #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ 60 | #define TIF_MEMDIE 17 61 | 62 | #define _TIF_SYSCALL_TRACE (1< <@RKX1209> 4 | */ 5 | 6 | #ifndef _I386_TLBFLUSH_H 7 | #define _I386_TLBFLUSH_H 8 | 9 | #include 10 | 11 | #define __flush_tlb() \ 12 | do { \ 13 | unsigned int tmpreg; \ 14 | \ 15 | __asm__ __volatile__( \ 16 | "movl %%cr3, %0; \n" \ 17 | "movl %0, %%cr3; # flush TLB \n" \ 18 | : "=r" (tmpreg) \ 19 | :: "memory"); \ 20 | } while (0) 21 | 22 | # define __flush_tlb_all() \ 23 | do { \ 24 | __flush_tlb(); \ 25 | } while (0) 26 | #endif 27 | -------------------------------------------------------------------------------- /include/drivers/disp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * drivers/vram/disp.h 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | 8 | #define COL8_000000 0 9 | #define COL8_FF0000 1 10 | #define COL8_00FF00 2 11 | #define COL8_FFFF00 3 12 | #define COL8_0000FF 4 13 | #define COL8_FF00FF 5 14 | #define COL8_00FFFF 6 15 | #define COL8_FFFFFF 7 16 | #define COL8_C6C6C6 8 17 | #define COL8_840000 9 18 | #define COL8_008400 10 19 | #define COL8_848400 11 20 | #define COL8_000084 12 21 | #define COL8_840084 13 22 | #define COL8_008484 14 23 | #define COL8_848484 15 24 | 25 | extern unsigned char* _font_data; 26 | void flush_screen(); 27 | void putfont(char *vram, int xsize, int x, int y, char col, unsigned char *font); 28 | void putfonts_str(char *vram, int xsize, int x, int y, char col, unsigned char *s, unsigned char *k); 29 | -------------------------------------------------------------------------------- /kernel.img: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RKX1209/TinyLinux/8bfcdbc2c85ec715470d4da7cf14bb5368563833/kernel.img -------------------------------------------------------------------------------- /kernel/Makefile: -------------------------------------------------------------------------------- 1 | OBJS = $(ARCH_KERNEL)/head.o $(KERNEL)/main.o $(KERNEL)/gasfunc \ 2 | $(KERNEL)/sched.o $(KERNEL)/printk.o $(KERNEL)/timer.o $(KERNEL)/softirq.o \ 3 | $(KERNEL)/pid.o $(KERNEL)/fork.o $(KERNEL)/exit.o $(KERNEL)/initramfs.o $(KERNEL)/sys.o \ 4 | $(KERNEL_IRQ)/manage.o \ 5 | $(ARCH_KERNEL)/setup.o $(ARCH_KERNEL)/traps.o $(ARCH_KERNEL)/entry.o \ 6 | $(ARCH_KERNEL)/init_task.o $(ARCH_KERNEL)/i8259.o $(ARCH_KERNEL)/irq.o $(ARCH_KERNEL)/process.o \ 7 | $(ARCH_KERNEL_CPU)/common.o \ 8 | $(ARCH_KERNEL_TIMERS)/timer_pit.o $(ARCH_KERNEL_TIMERS)/timer_tsc.o \ 9 | $(ARCH_MM)/init.o \ 10 | $(ARCH_LIB)/memcpy.o $(ARCH_LIB)/bitops.o \ 11 | $(MM)/bootmem.o $(MM)/page_alloc.o $(MM)/slab.o $(MM)/pgtable.o \ 12 | $(MM)/mmap.o $(MM)/memory.o \ 13 | $(FS)/file_table.o $(FS)/dcache.o $(FS)/inode.o $(FS)/namespace.o \ 14 | $(FS)/filesystem.o $(FS)/super.o $(FS)/block_dev.o $(FS)/char_dev.o \ 15 | $(FS)/exec.o $(FS)/namei.o $(FS)/open.o $(FS)/read_write.o $(FS)/binfmt_elf.o \ 16 | $(FS)/elevator.o $(FS)/mpage.o \ 17 | $(FS_RAMFS)/inode.o \ 18 | $(FS_SYSFS)/mount.o \ 19 | $(LIB)/vsprintf.o $(LIB)/rbtree.o \ 20 | $(DRIVERS_VRAM)/disp.o \ 21 | $(DRIVERS_BASE)/map.o \ 22 | $(ARCH_KERNEL)/tail.o \ 23 | $(SECURITY)/security.o \ 24 | $(SEABYON)/hooks.o $(SEABYON)/avc.o \ 25 | 26 | HOME_DIR = .. 27 | 28 | #---Build Command--- 29 | CC = gcc 30 | #CFLAGS = -I$(HOME_DIR)/include -Wall -fno-tree-scev-cprop -Wno-pointer-sign -fno-stack-protector 31 | CFLAGS = -O0 -I$(HOME_DIR)/include -fno-tree-scev-cprop -Wno-pointer-sign -fno-stack-protector 32 | LFLAGS = -m elf_i386 --oformat binary -T $(LD_SCRIPT) -Map kernel.map -nostdlib -e $(KERNEL_ENTRY) -arch i386 33 | LFLAGS2 = -m elf_i386 -T $(LD_SCRIPT) -Map kernel_e.map -nostdlib -e $(KERNEL_ENTRY) -arch i386 34 | ASFLAGS = -c -m32 -I$(HOME_DIR)/include 35 | NASM = nasm 36 | LD = ld 37 | DD = dd 38 | MAKE = make 39 | #------------------- 40 | 41 | CP = cp 42 | RM = rm 43 | CD = cd 44 | CAT = cat 45 | SUDO = sudo 46 | 47 | #---Kernel path------------- 48 | KERNEL = . 49 | KERNEL_IRQ = $(KERNEL)/irq 50 | #------------------------- 51 | 52 | #---Arch path------------- 53 | ARCH = ../arch 54 | ARCH_BOOT = $(ARCH)/boot 55 | ARCH_KERNEL = $(ARCH)/kernel 56 | ARCH_KERNEL_CPU = $(ARCH_KERNEL)/cpu 57 | ARCH_KERNEL_TIMERS = $(ARCH_KERNEL)/timers 58 | ARCH_MM = $(ARCH)/mm 59 | ARCH_LIB = $(ARCH)/lib 60 | #------------------------- 61 | 62 | #---MM path------------- 63 | MM = ../mm 64 | #------------------------- 65 | 66 | #---FS path------------- 67 | FS = ../fs 68 | FS_RAMFS = ../fs/ramfs 69 | FS_SYSFS = ../fs/sysfs 70 | FS_EXT2 = ../fs/ext2 71 | #------------------------- 72 | 73 | #---Drivers path------------- 74 | DRIVERS = ../drivers 75 | DRIVERS_VRAM = $(DRIVERS)/vram 76 | DRIVERS_BASE = $(DRIVERS)/base 77 | #------------------------- 78 | 79 | #---Lib path------------- 80 | LIB = ../lib 81 | #------------------------- 82 | 83 | #---Security path------------- 84 | SECURITY = ../security 85 | SEABYON = $(SECURITY)/seabyon 86 | #----------------------------- 87 | 88 | LD_SCRIPT_PATH = ../ldscript 89 | LD_SCRIPT = $(LD_SCRIPT_PATH)/kernel.ld 90 | KERNEL_ENTRY = startup_32 91 | 92 | kernel.img : $(OBJS) Makefile 93 | $(LD) $(LFLAGS) -o kernel.img $(OBJS) 94 | $(LD) $(LFLAGS2) -o kernel.elf $(OBJS) 95 | $(CAT) kernel.img > kernel_plain.img 96 | #$(CAT) kernel_plain.img $(BSS_AREA) > kernel.img 97 | default : 98 | $(MAKE) kernel.img 99 | 100 | img : 101 | $(MAKE) kernel.img 102 | 103 | 104 | %.o : %.c Makefile 105 | $(CC) -m32 -c -o $*.o $*.c $(CFLAGS) 106 | 107 | %.o : %.S Makefile 108 | $(CC) -o $*.o $*.S $(ASFLAGS) 109 | 110 | $(KERNEL_IRQ)/%.o : $(KERNEL_IRQ)/%.c Makefile 111 | $(CC) -m32 -c -o $(KERNEL_IRQ)/$*.o $(KERNEL_IRQ)/$*.c $(CFLAGS) 112 | 113 | $(KERNEL_IRQ)/%.o : $(KERNEL_IRQ)/%.S Makefile 114 | $(CC) -o $(KERNEL_IRQ)/$*.o $(KERNEL_IRQ)/$*.S $(ASFLAGS) 115 | 116 | $(ARCH_KERNEL_CPU)/%.o : $(ARCH_KERNEL_CPU)/%.c Makefile 117 | $(CC) -m32 -c -o $(ARCH_KERNEL_CPU)/$*.o $(ARCH_KERNEL_CPU)/$*.c $(CFLAGS) 118 | 119 | $(ARCH_KERNEL_CPU)/%.o : $(ARCH_KERNEL_CPU)/%.S Makefile 120 | $(CC) -o $(ARCH_KERNEL_CPU)/$*.o $(ARCH_KERNEL_CPU)/$*.S $(ASFLAGS) 121 | 122 | $(ARCH_KERNEL)/%.o : $(ARCH_KERNEL)/%.c Makefile 123 | $(CC) -m32 -c -o $(ARCH_KERNEL)/$*.o $(ARCH_KERNEL)/$*.c $(CFLAGS) 124 | 125 | $(ARCH_KERNEL)/%.o : $(ARCH_KERNEL)/%.S Makefile 126 | $(CC) -o $(ARCH_KERNEL)/$*.o $(ARCH_KERNEL)/$*.S $(ASFLAGS) 127 | 128 | $(ARCH_MM)/%.o : $(ARCH_MM)/%.c Makefile 129 | $(CC) -m32 -c -o $(ARCH_MM)/$*.o $(ARCH_MM)/$*.c $(CFLAGS) 130 | 131 | $(ARCH_MM)/%.o : $(ARCH_MM)/%.S Makefile 132 | $(CC) -o $(ARCH_MM)/$*.o $(ARCH_MM)/$*.S $(ASFLAGS) 133 | 134 | $(MM)/%.o : $(MM)/%.c Makefile 135 | $(CC) -m32 -c -o $(MM)/$*.o $(MM)/$*.c $(CFLAGS) 136 | 137 | $(MM)/%.o : $(MM)/%.S Makefile 138 | $(CC) -o $(MM)/$*.o $(MM)/$*.S $(ASFLAGS) 139 | 140 | $(FS)/%.o : $(FS)/%.c Makefile 141 | $(CC) -m32 -c -o $(FS)/$*.o $(FS)/$*.c $(CFLAGS) 142 | 143 | $(FS)/%.o : $(FS)/%.S Makefile 144 | $(CC) -o $(FS)/$*.o $(FS)/$*.S $(ASFLAGS) 145 | 146 | $(FS_RAMFS)/%.o : $(FS_RAMFS)/%.c Makefile 147 | $(CC) -m32 -c -o $(FS_RAMFS)/$*.o $(FS_RAMFS)/$*.c $(CFLAGS) 148 | 149 | $(FS_RAMFS)/%.o : $(FS_RAMFS)/%.S Makefile 150 | $(CC) -o $(FS_RAMFS)/$*.o $(FS_RAMFS)/$*.S $(ASFLAGS) 151 | 152 | $(LIB)/%.o : $(LIB)/%.c Makefile 153 | $(CC) -m32 -c -o $(LIB)/$*.o $(LIB)/$*.c $(CFLAGS) 154 | 155 | $(LIB)/%.o : $(LIB)/%.S Makefile 156 | $(CC) -o $(LIB)/$*.o $(LIB)/$*.S $(ASFLAGS) 157 | 158 | $(SECURITY)/%.o : $(SECURITY)/%.c Makefile 159 | $(CC) -m32 -c -o $(SECURITY)/$*.o $(SECURITY)/$*.c $(CFLAGS) 160 | 161 | $(SECURITY)/%.o : $(SECURITY)/%.S Makefile 162 | $(CC) -o $(SECURITY)/$*.o $(SECURITY)/$*.S $(ASFLAGS) 163 | 164 | $(SEABYON)/%.o : $(SEABYON)/%.c Makefile 165 | $(CC) -m32 -c -o $(SEABYON)/$*.o $(SEABYON)/$*.c $(CFLAGS) 166 | 167 | $(SEABYON)/%.o : $(SEABYON)/%.S Makefile 168 | $(CC) -o $(SEABYON)/$*.o $(SEABYON)/$*.S $(ASFLAGS) 169 | 170 | 171 | -------------------------------------------------------------------------------- /kernel/exit.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/exit.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | void do_exit(long code){ 7 | 8 | } 9 | -------------------------------------------------------------------------------- /kernel/fork.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/fork.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #define alloc_task_struct() kmem_cache_alloc(task_struct_cachep,0) 19 | #define alloc_mm() kmem_cache_alloc(mm_cachep,0) 20 | #define free_mm(mm) (kmem_cache_free(mm_cachep, (mm))) 21 | 22 | static kmem_cache_t *task_struct_cachep; 23 | static kmem_cache_t *mm_cachep; 24 | static kmem_cache_t *vm_area_cachep; 25 | static kmem_cache_t *fs_cachep; 26 | 27 | int max_threads; 28 | 29 | void fork_init(unsigned long mempages){ 30 | #define ARCH_MIN_TASKALIGN L1_CACHE_BYTES 31 | task_struct_cachep = kmem_cache_create("task_struct",sizeof(struct task_struct), 32 | ARCH_MIN_TASKALIGN,0,0,0); 33 | max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE); 34 | if(max_threads < 20) max_threads = 20; 35 | 36 | } 37 | 38 | static struct task_struct *dup_task_struct(struct task_struct *orig){ 39 | struct task_struct *tsk = alloc_task_struct(); 40 | struct thread_info *ti = alloc_thread_info(tsk); 41 | *ti = *orig->thread_info; 42 | *tsk = *orig; 43 | tsk->thread_info = ti; 44 | ti->task = tsk; 45 | return tsk; 46 | } 47 | 48 | static inline int mm_alloc_pgd(struct mm_struct *mm){ 49 | mm->pgd = pgd_alloc(mm); 50 | return 0; 51 | } 52 | 53 | 54 | static struct mm_struct *mm_init(struct mm_struct *mm){ 55 | mm_alloc_pgd(mm); 56 | return mm; 57 | } 58 | 59 | static inline int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm){ 60 | mm->mmap = 0; 61 | mm->map_count = 0; 62 | mm->mm_rb = (struct rb_root){0}; 63 | struct rb_node **rb_link = &mm->mm_rb.rb_node; 64 | struct rb_node *rb_parent = 0; 65 | struct vm_area_struct *mpnt; 66 | for(mpnt = current->mm->mmap; mpnt; mpnt = mpnt->vm_next){ 67 | struct vm_area_struct *tmp = kmem_cache_alloc(vm_area_cachep,0); 68 | *tmp = *mpnt; 69 | tmp->vm_mm = mm; 70 | tmp->vm_next = 0; 71 | __vma_link_rb(mm,tmp,rb_link,rb_parent); 72 | rb_link = &tmp->vm_rb.rb_right; 73 | rb_parent = &tmp->vm_rb; 74 | mm->map_count++; 75 | copy_page_range(mm,current->mm,tmp); 76 | } 77 | } 78 | 79 | static int copy_mm(unsigned long clone_flags,struct task_struct *tsk){ 80 | struct mm_struct *oldmm = current->mm; 81 | struct mm_struct *mm = alloc_mm(); 82 | memcpy(mm,oldmm,sizeof(*mm)); 83 | mm_init(mm); 84 | tsk->mm = mm; 85 | return 0; 86 | } 87 | static inline struct fs_struct *__copy_fs_struct(struct fs_struct *old){ 88 | struct fs_struct *fs = kmem_cache_alloc(fs_cachep,0); 89 | if(fs){ 90 | 91 | } 92 | return fs; 93 | } 94 | 95 | static inline int copy_fs(unsigned long clone_flags, struct task_struct *tsk){ 96 | tsk->fs = __copy_fs_struct(current->fs); 97 | return 0; 98 | } 99 | 100 | void sched_fork(task_t *p){ 101 | p->state = TASK_RUNNING; 102 | INIT_LIST_HEAD(&p->run_list); 103 | p->array = 0; 104 | p->time_slice = (current->time_slice + 1) >> 1; 105 | p->first_time_slice = 1; 106 | current->time_slice >>= 1; 107 | p->time_slice = sched_clock(); 108 | } 109 | 110 | int copy_thread(int nr, unsigned long clone_flags, unsigned long esp, 111 | unsigned long unused, 112 | struct task_struct * p, struct pt_regs * regs){ 113 | 114 | } 115 | 116 | static struct task_struct *copy_process(unsigned long clone_flags, 117 | unsigned long stack_start, 118 | struct pt_regs *regs, 119 | unsigned long stack_size, 120 | int *parent_tidptr, 121 | int *child_tidptr, 122 | int pid){ 123 | struct task_struct *p = dup_task_struct(current); 124 | copy_mm(clone_flags,p); 125 | copy_thread(0,clone_flags,stack_start,stack_size,p,regs); 126 | copy_fs(clone_flags,p); 127 | sched_fork(p); 128 | return p; 129 | } 130 | 131 | long do_fork(unsigned long clone_flags, 132 | unsigned long stack_start, 133 | struct pt_regs *regs, 134 | unsigned long stack_size, 135 | int *parent_tidptr, 136 | int *child_tidptr){ 137 | 138 | long pid = alloc_pidmap(); 139 | struct task_struct *p = copy_process(clone_flags,stack_start,regs,stack_size, 140 | parent_tidptr,child_tidptr,pid); 141 | return pid; 142 | } 143 | -------------------------------------------------------------------------------- /kernel/gasfunc.S: -------------------------------------------------------------------------------- 1 | .text 2 | 3 | .global io_hlt 4 | .global key_int 5 | 6 | io_hlt: 7 | hlt 8 | ret 9 | key_int: 10 | int $33 11 | ret 12 | -------------------------------------------------------------------------------- /kernel/initramfs.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/initramfs.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | extern unsigned long _initramfs_start; 10 | extern unsigned long _initramfs_end; 11 | 12 | static char * unpack_to_rootfs(char *buf,unsigned len){ 13 | 14 | } 15 | 16 | void populate_rootfs(void){ 17 | char *err = unpack_to_rootfs(_initramfs_start,_initramfs_end - _initramfs_start); 18 | } 19 | -------------------------------------------------------------------------------- /kernel/irq/manage.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/irq/manage.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | int setup_irq(unsigned int irq, struct irqaction *new){ 10 | struct irq_desc *desc = irq_desc + irq; 11 | struct irqaction *old,**p; 12 | unsigned long flags; 13 | int shared = 0; 14 | if(desc->handler == &no_irq_type) return -ENOSYS; 15 | p = &desc->action; 16 | if((old = *p) != 0){ 17 | if(!(old->flags & new->flags & SA_SHIRQ)){ 18 | return -EBUSY; 19 | } 20 | do{ 21 | p = &old->next; 22 | old = *p; 23 | }while(old); 24 | shared = 1; 25 | } 26 | *p = new; 27 | if (!shared) { 28 | desc->depth = 0; 29 | desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | 30 | IRQ_WAITING | IRQ_INPROGRESS); 31 | if (desc->handler->startup) 32 | desc->handler->startup(irq); 33 | else 34 | desc->handler->enable(irq); 35 | } 36 | new->irq = irq; 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /kernel/main.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/main.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | extern void io_hlt(void); 12 | 13 | extern int printk(const char *fmt, ...); 14 | extern void setup_arch(); 15 | extern void trap_init(); 16 | extern void init_IRQ(); 17 | extern void init_timers(); 18 | extern void softirq_init(); 19 | extern void key_int(); 20 | extern void pgtable_cache_init(void); 21 | extern void kernel_main(void); 22 | static void rest_init(void); 23 | static int init(void *unused); 24 | 25 | static char *ramdisk_execute_command = "/init"; 26 | static const char *argv_init[3] = {"init",0,}; 27 | const char *envp_init[4] = {"HOME=/","TERM=linux",0,}; 28 | 29 | void kernel_main(void){ 30 | printk("Welcome to Abyon kernel!"); 31 | setup_arch();//init e820, bootmem, pagetable(pgd,pte...), fix area paging on 32 | 33 | sched_init(); //init runqueue, current <= idle_proc 34 | 35 | trap_init(); //init trap tables 36 | 37 | init_IRQ(); //init 8259A, IQR table[i] = interrupt[i] => do_IRQ(entry.S), init PIT 38 | 39 | init_timers();//init softirq[TIMER_SOFTIRQ] => timer 40 | 41 | softirq_init();//init softirq[TASKLET,HI_SOFTIRQ] 42 | 43 | local_irq_enable(); 44 | 45 | key_int(); 46 | 47 | vfs_caches_init_early();//init dentry cache, init inode cache 48 | 49 | //mem_init(); //free bootmem area 50 | //kmem_cache_init(); //init slab allocator 51 | 52 | pgtable_cache_init(); 53 | 54 | vfs_caches_init(); 55 | 56 | rest_init(); 57 | printk("Enter sleeping..."); 58 | for(;;){ 59 | io_hlt(); 60 | } 61 | return; 62 | } 63 | 64 | static void rest_init(void){ 65 | kernel_thread(init,0,0); 66 | schedule(); 67 | cpu_idle(); 68 | } 69 | 70 | static void do_basic_setup(void){ 71 | 72 | } 73 | 74 | int kernel_execve(const char *filename, 75 | const char *const argv[], 76 | const char *const envp[]){ 77 | long __res; 78 | __asm__ __volatile__("int $0x80" \ 79 | : "=a" (__res) \ 80 | : "" (__NR_execve), "b" (filename), "c" (argv), "d" (envp) :"memory"); 81 | return __res; 82 | } 83 | 84 | static void run_init_process(const char *init_filename){ 85 | argv_init[0] = init_filename; 86 | kernel_execve(init_filename,argv_init,envp_init); 87 | } 88 | 89 | static int init(void *unused){ 90 | populate_rootfs(); 91 | do_basic_setup(); 92 | if(ramdisk_execute_command){ 93 | run_init_process(ramdisk_execute_command); 94 | } 95 | return 0; 96 | } 97 | -------------------------------------------------------------------------------- /kernel/pid.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/pid.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #include 6 | #include 7 | 8 | #define BITS_PER_PAGE (PAGE_SIZE * 8) 9 | #define PID_MAX_LIMIT 114514 10 | #define RESERVED_PIDS 300 11 | #define PIDMAP_ENTRIES ((PID_MAX_LIMIT + 8*PAGE_SIZE - 1)/PAGE_SIZE/8) 12 | #define BITS_PER_PAGE_MASK (BITS_PER_PAGE-1) 13 | 14 | #define mk_pid(map, off) ( ( (map) - pidmap_array)*BITS_PER_PAGE + (off)) 15 | 16 | typedef struct pidmap { 17 | int nr_free; 18 | void *page; 19 | }pidmap_t; 20 | 21 | static pidmap_t pidmap_array[PIDMAP_ENTRIES] = {[0 ... PIDMAP_ENTRIES - 1] = {BITS_PER_PAGE,0}}; 22 | int pid_max = 114514; 23 | int last_pid; 24 | 25 | int alloc_pidmap(void){ 26 | int last = last_pid; 27 | int pid = last + 1; 28 | if(pid >= pid_max) 29 | pid = RESERVED_PIDS; 30 | int offset = pid & BITS_PER_PAGE_MASK; 31 | pidmap_t *map = &pidmap_array[pid/BITS_PER_PAGE]; 32 | int max_scan = (pid_max + BITS_PER_PAGE - 1) / BITS_PER_PAGE - !offset; 33 | int i; 34 | for(i = 0; i <= max_scan; i++){ 35 | if(!map->page){ 36 | unsigned long page = get_zeroed_page(0); 37 | map->page = (void*)page; 38 | } 39 | if(map->nr_free){ 40 | do{ 41 | if(!test_and_set_bit(offset,map->page)){ 42 | map->nr_free--; 43 | last_pid = pid; 44 | return pid; 45 | } 46 | offset = find_next_zero_bit((map)->page,BITS_PER_PAGE,offset); 47 | pid = mk_pid(map,offset); 48 | }while(offset < BITS_PER_PAGE && pid < pid_max); 49 | } 50 | pid = mk_pid(map,offset); 51 | } 52 | return -1; 53 | } 54 | -------------------------------------------------------------------------------- /kernel/printk.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/printk.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #define __LOG_BUF_LEN (1 << 15) 10 | #define __LOG_BUF_LIMIT 12 11 | 12 | char __log_buf[__LOG_BUF_LEN][256]; 13 | static int log_buf_lim = __LOG_BUF_LIMIT; 14 | 15 | static unsigned long log_start; 16 | static unsigned long log_end; 17 | 18 | /* Get line number of idx */ 19 | #define LOG_BUF_MASK (log_buf_len-1) 20 | #define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK]) 21 | 22 | extern int vscnprintf(char *buf, unsigned long size, const char *fmt, va_list args); 23 | 24 | int vprintk(const char *fmt, va_list args){ 25 | int printed_len = vscnprintf(__log_buf[log_end],sizeof(__log_buf[log_end]),fmt,args); 26 | 27 | char *vram = (char*)0xa0000; 28 | flush_screen(); 29 | int y = 0,i = 0; 30 | int lines = (log_end - log_start + 1); 31 | if(lines > log_buf_lim) lines = log_buf_lim; 32 | 33 | for(i = 0; i < lines; i++){ 34 | putfonts_str(vram,320,0,y + i * 16,COL8_FFFFFF, 35 | __log_buf[log_start + i], 36 | (unsigned char *)&_font_data); 37 | } 38 | log_end++; 39 | lines = (log_end - log_start + 1); 40 | if(lines > log_buf_lim) log_start++; 41 | 42 | return printed_len; 43 | } 44 | int printk(const char *fmt, ...){ 45 | va_list args; 46 | va_start(args,fmt); 47 | int r = vprintk(fmt,args); 48 | return r; 49 | } 50 | 51 | 52 | -------------------------------------------------------------------------------- /kernel/sched.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/sched.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #include 13 | #include 14 | #include 15 | 16 | extern int printk(const char *fmt, ...); 17 | 18 | static DEFINE_PER_CPU(struct runqueue,runqueues); 19 | 20 | #define cpu_rq(cpu) (&per_cpu(runqueues, (cpu))) 21 | #define CURRENT_BONUS(p) 1 22 | 23 | void sched_init(void){ 24 | printk("sched_init..."); 25 | runqueue_t *rq; 26 | int i,j,k; 27 | for(i = 0; i < NR_CRUS; i++){ 28 | rq = cpu_rq(i); 29 | rq->active = rq->arrays; 30 | rq->expired = rq->arrays + 1; 31 | rq->best_expired_prio = MAX_PRIO; 32 | } 33 | for(j = 0; j < 2; j++){ 34 | prio_array_t *array = rq->arrays + j; 35 | for(k = 0; k < MAX_PRIO; k++){ 36 | INIT_LIST_HEAD(array->queue + k); 37 | __clear_bit(k,array->bitmap); 38 | } 39 | __set_bit(MAX_PRIO,array->bitmap); 40 | } 41 | init_mm.mm_count++; 42 | init_idle(current,smp_processor_id()); 43 | printk("sched_init... [OK]"); 44 | } 45 | 46 | void init_idle(task_t *idle, int cpu){ 47 | runqueue_t *rq = cpu_rq(cpu); 48 | idle->array = 0; 49 | idle->prio = MAX_PRIO; 50 | idle->state = TASK_RUNNING; 51 | set_task_cpu(idle,cpu); 52 | rq->curr = rq->idle = idle; 53 | } 54 | static void dequeue_task(struct task_struct *p, prio_array_t *array) { 55 | list_del(&p->run_list); 56 | if(list_empty(array->queue + p->prio)) 57 | __clear_bit(p->prio,array->bitmap); 58 | 59 | } 60 | 61 | static void deactivate_task(struct task_struct *p, runqueue_t *rq) { 62 | rq->nr_runnning--; 63 | dequeue_task(p,p->array); 64 | p->array = 0; 65 | } 66 | 67 | static int effective_prio(task_t *p){ 68 | return p->prio; 69 | } 70 | 71 | static void recalc_task_prio(task_t *p,unsigned long long now){ 72 | unsigned long long sleep_time = now - p->timestamp; 73 | if(sleep_time > 0){ 74 | } 75 | p->prio = effective_prio(p); 76 | } 77 | 78 | static void enqueue_task(struct task_struct *p, prio_array_t *array) { 79 | list_add_tail(&p->run_list,array->queue + p->prio); 80 | __set_bit(p->prio,array->bitmap); 81 | array->nr_active++; 82 | p->array = array; 83 | } 84 | 85 | static inline void switch_mm(struct mm_struct *prev, 86 | struct mm_struct *next, 87 | struct task_struct *tsk){ 88 | int cpu = smp_processor_id(); 89 | write_cr3(next->pgd); 90 | 91 | } 92 | 93 | static inline task_t *context_switch(runqueue_t *rq,task_t *prev,task_t *next){ 94 | struct mm_struct *mm = next->mm; 95 | struct mm_struct *oldmm = prev->active_mm; 96 | switch_mm(oldmm,mm,next); 97 | switch_to(prev,next,prev); 98 | return prev; 99 | } 100 | 101 | void scheduler_tick(int user_ticks,int sys_ticks){ 102 | int cpu = smp_processor_id(); 103 | runqueue_t *rq = cpu_rq(cpu); 104 | //rq->timestamp_last_tick = sched_clock(); 105 | task_t *p = current; 106 | if(!--p->time_slice){ 107 | dequeue_task(p,rq->active); 108 | set_ti_thread_flag(p->thread_info,TIF_NEED_RESCHED); 109 | p->prio = effective_prio(p); 110 | enqueue_task(p,rq->expired); 111 | }else{ 112 | } 113 | 114 | } 115 | 116 | void schedule(){ 117 | task_t *prev,*next; 118 | need_resched: 119 | prev = current; 120 | runqueue_t *rq = cpu_rq(smp_processor_id()); 121 | unsigned long long now = sched_clock(); 122 | unsigned long long run_time; 123 | run_time = now - prev->timestamp; 124 | run_time /= CURRENT_BONUS(prev); 125 | if(prev->state){ 126 | if(prev->state & TASK_INTERRUPTIBLE) 127 | prev->state = TASK_RUNNING; 128 | else{ 129 | deactivate_task(prev,rq); 130 | } 131 | } 132 | if(!(rq->nr_runnning)){ 133 | go_idle: 134 | ; 135 | //idle_balance(smp_processor_id(),rq); 136 | }else{ 137 | next = rq->idle; 138 | goto switch_tasks; 139 | } 140 | prio_array_t *array = rq->active; 141 | if(!array->nr_active){ 142 | rq->active = rq->expired; 143 | rq->expired = array; 144 | array = rq->active; 145 | } 146 | int idx = sched_find_first_bit(array->bitmap); 147 | struct list_head *queue = array->queue + idx; 148 | //next = list_entry(queue->next,task_t,run_list); 149 | if(next->activated > 0){ 150 | unsigned long long delta = now - next->timestamp; 151 | array = next->array; 152 | dequeue_task(next,array); 153 | recalc_task_prio(next,next->timestamp + delta); 154 | enqueue_task(next,array); 155 | } 156 | switch_tasks: 157 | if(prev != next){ 158 | next->timestamp = now; 159 | rq->nr_switches++; 160 | rq->curr = next; 161 | prev = context_switch(rq,prev,next); 162 | } 163 | } 164 | -------------------------------------------------------------------------------- /kernel/softirq.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/softirq.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | 11 | extern int printk(const char *fmt, ...); 12 | 13 | static struct softirq_action softirq_vec[32]; 14 | 15 | struct tasklet_head{ 16 | struct tasklet_struct *list; 17 | }; 18 | 19 | static DEFINE_PER_CPU(struct task_struct *,ksoftirqd); 20 | static DEFINE_PER_CPU(struct tasklet_head, tasklet_vec) = { 0 }; 21 | static DEFINE_PER_CPU(struct tasklet_head, tasklet_hi_vec) = { 0 }; 22 | 23 | static void tasklet_action(struct softirq_action *a){ 24 | struct tasklet_struct *list = per_cpu(tasklet_vec,smp_processor_id()).list; 25 | per_cpu(tasklet_vec,smp_processor_id()).list = 0; 26 | while(list){ 27 | struct tasklet_struct *t = list; 28 | list = list->next; 29 | t->func(t->data); 30 | } 31 | } 32 | 33 | static void tasklet_hi_action(struct softirq_action *a){ 34 | struct tasklet_struct *list = per_cpu(tasklet_hi_vec,smp_processor_id()).list; 35 | per_cpu(tasklet_hi_vec,smp_processor_id()).list = 0; 36 | while(list){ 37 | struct tasklet_struct *t = list; 38 | list = list->next; 39 | t->func(t->data); 40 | } 41 | } 42 | 43 | void softirq_init(void){ 44 | open_softirq(TASKLET_SOFTIRQ,tasklet_action,0); 45 | open_softirq(HI_SOFTIRQ,tasklet_hi_action,0); 46 | printk("softirq_init... [OK]"); 47 | } 48 | 49 | void open_softirq(int nr,void (*action)(struct softirq_action*),void *data){ 50 | softirq_vec[nr].data = data; 51 | softirq_vec[nr].action = action; 52 | } 53 | -------------------------------------------------------------------------------- /kernel/sys.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/sys.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #include 6 | 7 | #include 8 | 9 | static int groups_search(struct group_info *group_info, unsigned int grp){ 10 | int left = 0; 11 | int right = group_info->ngroups; 12 | while(left < right){ 13 | int mid = (left + right) / 2; 14 | int cmp = grp - GROUP_AT(group_info,mid); 15 | if(cmp > 0) left = mid + 1; 16 | else if(cmp < 0) right = mid; 17 | else return 1; 18 | } 19 | return 0; 20 | } 21 | 22 | int in_group_p(unsigned long grp){ 23 | int retval = 1; 24 | if(grp != current->fsgid){ 25 | retval = groups_search(current->group_info,grp); 26 | } 27 | return retval; 28 | } 29 | -------------------------------------------------------------------------------- /kernel/timer.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/timer.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include 15 | 16 | #define TVN_BITS 4 17 | #define TVR_BITS 6 18 | #define TVN_SIZE (1 << TVN_BITS) 19 | #define TVR_SIZE (1 << TVR_BITS) 20 | #define TVN_MASK (TVN_SIZE - 1) 21 | #define TVR_MASK (TVR_SIZE - 1) 22 | 23 | extern int printk(const char *fmt, ...); 24 | 25 | unsigned long long jiffies = INIT_JIFFIES; 26 | typedef struct tvec_s{ 27 | struct list_head vec[TVN_SIZE]; 28 | }tvec_t; 29 | 30 | typedef struct tvec_root_s{ 31 | struct list_head vec[TVR_SIZE]; 32 | }tvec_root_t; 33 | 34 | typedef struct tvec_t_base_s{ 35 | unsigned long timer_jiffies; 36 | struct timer_list *running_timer; 37 | tvec_root_t tv1; 38 | tvec_t tv2; 39 | tvec_t tv3; 40 | tvec_t tv4; 41 | tvec_t tv5; 42 | }tvec_base_t; 43 | 44 | static DEFINE_PER_CPU(tvec_base_t, tvec_bases); 45 | 46 | static inline void detach_timer(struct timer_list *timer, 47 | int clear_pending){ 48 | struct list_head *entry = &timer->entry; 49 | __list_del(entry->prev, entry->next); 50 | if (clear_pending) 51 | entry->next = 0; 52 | } 53 | 54 | static void internal_add_timer(tvec_base_t *base, struct timer_list *timer){ 55 | unsigned long expires = timer->expires; 56 | unsigned long idx = expires - base->timer_jiffies; 57 | struct list_head *vec; 58 | 59 | if (idx < TVR_SIZE) { 60 | int i = expires & TVR_MASK; 61 | vec = base->tv1.vec + i; 62 | } else if (idx < 1 << (TVR_BITS + TVN_BITS)) { 63 | int i = (expires >> TVR_BITS) & TVN_MASK; 64 | vec = base->tv2.vec + i; 65 | } else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) { 66 | int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK; 67 | vec = base->tv3.vec + i; 68 | } else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) { 69 | int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK; 70 | vec = base->tv4.vec + i; 71 | } else if ((signed long) idx < 0) { 72 | vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK); 73 | } else { 74 | int i; 75 | if (idx > 0xffffffffUL) { 76 | idx = 0xffffffffUL; 77 | expires = idx + base->timer_jiffies; 78 | } 79 | i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK; 80 | vec = base->tv5.vec + i; 81 | } 82 | list_add_tail(&timer->entry, vec); 83 | } 84 | 85 | static void init_timer_cpu(int cpu){ 86 | tvec_base_t *base; 87 | base = &per_cpu(tvec_bases,cpu); 88 | int j; 89 | for(j = 0; j < TVN_SIZE; j++){ 90 | INIT_LIST_HEAD(base->tv2.vec + j); 91 | INIT_LIST_HEAD(base->tv3.vec + j); 92 | INIT_LIST_HEAD(base->tv4.vec + j); 93 | INIT_LIST_HEAD(base->tv5.vec + j); 94 | } 95 | for(j = 0; j < TVR_SIZE; j++) 96 | INIT_LIST_HEAD(base->tv1.vec + j); 97 | base->timer_jiffies = jiffies; 98 | } 99 | 100 | static int cascade(tvec_base_t *base,tvec_t *tv,int index){ 101 | struct list_head *head = tv->vec + index; 102 | struct list_head *curr = head->next; 103 | while(curr != head){ 104 | struct timer_list *tmp = list_entry(curr,struct timer_list,entry); 105 | curr = curr->next; 106 | internal_add_timer(base,tmp); 107 | 108 | } 109 | INIT_LIST_HEAD(head); 110 | return index; 111 | } 112 | 113 | #define INDEX(N) (base->timer_jiffies >> (TVR_BITS + N * TVN_BITS)) & TVN_MASK 114 | 115 | static void __run_timers(tvec_base_t *base){ 116 | while(jiffies >= (base->timer_jiffies)){ 117 | struct list_head work_list = LIST_HEAD_INIT(work_list); 118 | struct list_head *head = &work_list; 119 | int index = base->timer_jiffies & TVR_MASK; 120 | if (!index && 121 | (!cascade(base, &base->tv2, INDEX(0))) && 122 | (!cascade(base, &base->tv3, INDEX(1))) && 123 | !cascade(base, &base->tv4, INDEX(2))) 124 | cascade(base, &base->tv5, INDEX(3)); 125 | ++(base->timer_jiffies); 126 | list_splice_init(base->tv1.vec + index,&work_list); 127 | while(!list_empty(head)){ 128 | void (*fn)(unsigned long); 129 | unsigned long data; 130 | struct timer_list *timer = list_entry(head->next,struct timer_list,entry); 131 | fn = timer->function; 132 | data = timer->data; 133 | detach_timer(timer,1); 134 | fn(data); 135 | } 136 | } 137 | } 138 | static int timer_cpu_notify(unsigned long action,void *hcpu){ 139 | long cpu = (long)hcpu; 140 | switch(action){ 141 | case CPU_UP_PREPARE: 142 | init_timer_cpu(cpu); 143 | break; 144 | default: 145 | break; 146 | } 147 | return NOTIFY_OK; 148 | } 149 | 150 | static void run_timer_softirq(struct softirq_action *h){ 151 | tvec_base_t *base = &per_cpu(tvec_bases,smp_processor_id()); 152 | if(jiffies >= (base->timer_jiffies)) __run_timers(base); 153 | } 154 | 155 | void init_timers(void){ 156 | timer_cpu_notify((unsigned long)CPU_UP_PREPARE,(void *)(long)smp_processor_id()); 157 | open_softirq(TIMER_SOFTIRQ, run_timer_softirq, 0); 158 | printk("init_timers... [OK]"); 159 | } 160 | 161 | -------------------------------------------------------------------------------- /ldscript/kernel.ld: -------------------------------------------------------------------------------- 1 | SECTIONS 2 | { 3 | /* . = 0xC0100000; */ 4 | . = 0x00100000; 5 | .text : 6 | { 7 | _text_start = .; 8 | *(.text) 9 | _text_end = .; 10 | } 11 | 12 | .rodata : 13 | { 14 | _rodata_start = .; 15 | *(.rodata) 16 | _rodata_end = .; 17 | } 18 | 19 | .data : 20 | { 21 | _data_start = .; 22 | *(.data) 23 | _data_end = .; 24 | } 25 | 26 | . = ALIGN(4096); 27 | 28 | .data.idt : 29 | { 30 | _data_idt_start = .; 31 | *(.data.idt) 32 | _data_idt_end = .; 33 | } 34 | 35 | . = ALIGN(8192); /* init_task (THREAD_SIZE = 8192)*/ 36 | 37 | .data.init_task : 38 | { 39 | _data_init_task_start = .; 40 | *(.data.init_task) 41 | _data_init_task_end = .; 42 | } 43 | 44 | _font_data = .; 45 | . += 0x3000; /* font data area */ 46 | . = ALIGN(4096); 47 | 48 | _initramfs_start = .; 49 | . += 0x3000; /* font data area */ 50 | . = ALIGN(4096); 51 | _initramfs_end = .; 52 | 53 | .bss : 54 | { 55 | _bss_start = .; 56 | *(.bss) 57 | _bss_end = .; 58 | } 59 | .fin : 60 | { 61 | _fin_start = .; 62 | *(.fin) 63 | _fin_end = .; 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /lib/rbtree.c: -------------------------------------------------------------------------------- 1 | /* 2 | * lib/rbtree.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | 8 | static void __rb_rotate_left(struct rb_node *node,struct rb_root *root){ 9 | struct rb_node *right = node->rb_right; 10 | if((node->rb_right = right->rb_left)) 11 | right->rb_left->rb_parent = node; 12 | right->rb_left = node; 13 | if((right->rb_parent = node->rb_parent)){ 14 | if(node == node->rb_parent->rb_left) 15 | node->rb_parent->rb_left = right; 16 | else 17 | node->rb_parent->rb_right = right; 18 | }else 19 | root->rb_node = right; 20 | node->rb_parent = right; 21 | } 22 | 23 | static void __rb_rotate_right(struct rb_node *node, struct rb_root *root) { 24 | struct rb_node *left = node->rb_left; 25 | if ((node->rb_left = left->rb_right)) 26 | left->rb_right->rb_parent = node; 27 | left->rb_right = node; 28 | 29 | if((left->rb_parent = node->rb_parent)){ 30 | if (node == node->rb_parent->rb_right) 31 | node->rb_parent->rb_right = left; 32 | else 33 | node->rb_parent->rb_left = left; 34 | }else 35 | root->rb_node = left; 36 | node->rb_parent = left; 37 | 38 | } 39 | void rb_insert_color(struct rb_node *node, struct rb_root *root){ 40 | struct rb_node *parent,*gparent; 41 | while((parent = node->rb_parent) && parent->rb_color == RB_RED){ 42 | gparent = parent->rb_parent; 43 | if(parent == gparent->rb_left){ 44 | { 45 | struct rb_node *uncle = gparent->rb_right; 46 | if(uncle && uncle->rb_color == RB_RED){ 47 | uncle->rb_color = RB_BLACK; 48 | parent->rb_color = RB_BLACK; 49 | gparent->rb_color = RB_RED; 50 | node = gparent; 51 | continue; 52 | } 53 | } 54 | if(parent->rb_right == node){ 55 | __rb_rotate_left(parent,root); 56 | struct rb_node *tmp; 57 | tmp = parent; 58 | parent = node; 59 | node = tmp; 60 | } 61 | parent->rb_color = RB_BLACK; 62 | gparent->rb_color = RB_RED; 63 | __rb_rotate_right(gparent,root); 64 | } else{ 65 | { 66 | struct rb_node *uncle = gparent->rb_left; 67 | if(uncle && uncle->rb_color == RB_RED){ 68 | uncle->rb_color = RB_BLACK; 69 | parent->rb_color = RB_BLACK; 70 | gparent->rb_color = RB_RED; 71 | node = gparent; 72 | continue; 73 | } 74 | } 75 | if(parent->rb_left == node){ 76 | __rb_rotate_right(parent,root); 77 | struct rb_node *tmp; 78 | tmp = parent; 79 | parent = node; 80 | node = tmp; 81 | } 82 | parent->rb_color = RB_BLACK; 83 | gparent->rb_color = RB_RED; 84 | __rb_rotate_right(gparent,root); 85 | 86 | } 87 | } 88 | root->rb_node->rb_color = RB_BLACK; 89 | } 90 | -------------------------------------------------------------------------------- /lib/vsprintf.c: -------------------------------------------------------------------------------- 1 | /* 2 | lib/vsprintf.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | #define ZEROPAD 1 /* pad with zero */ 11 | #define SIGN 2 /* unsigned/signed long */ 12 | #define PLUS 4 /* show plus */ 13 | #define SPACE 8 /* space if plus */ 14 | #define LEFT 16 /* left justified */ 15 | #define SPECIAL 32 /* 0x */ 16 | #define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */ 17 | 18 | /* num => buf */ 19 | static char* number(char * buf, char * end, unsigned long num, int base, int size){ 20 | static const char small_digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; 21 | const char *digits = small_digits; 22 | char tmp[66]; 23 | int i = 0; 24 | if(num == 0){ 25 | tmp[i++] = '0'; 26 | } 27 | else{ 28 | while(num > 0){ 29 | tmp[i++] = digits[num % base]; 30 | num /= base; 31 | } 32 | } 33 | while(i-- > 0){ 34 | if(buf <= end) *buf = tmp[i]; 35 | ++buf; 36 | } 37 | return buf; 38 | } 39 | 40 | int vsnprintf(char *buf, unsigned long size, const char *fmt, va_list args){ 41 | char *str = buf; 42 | char *end = buf + size - 1; 43 | int base = 10,len,i; 44 | char c; 45 | const char *s; 46 | unsigned int num; 47 | 48 | for(; *fmt; fmt++){ 49 | base = 10; 50 | /* Plain text */ 51 | if(*fmt != '%'){ 52 | if(str <= end) *str = *fmt; 53 | ++str; 54 | continue; 55 | } 56 | int flags = 0; 57 | repeat:; 58 | ++fmt; 59 | switch(*fmt){ 60 | case '-': flags |= LEFT; goto repeat; 61 | case '+': flags |= PLUS; goto repeat; 62 | case ' ': flags |= SPACE; goto repeat; 63 | case '#': flags |= SPECIAL; goto repeat; 64 | case '0': flags |= ZEROPAD; goto repeat; 65 | } 66 | 67 | switch(*fmt){ 68 | case 'c': 69 | c = (char)va_arg(args,int); 70 | if(str <= end) *str = c; 71 | ++str; 72 | continue; 73 | case 's': 74 | s = va_arg(args,char*); 75 | len = strnlen(s,-1); 76 | for(i = 0; i < len; i++){ 77 | if(str <= end) *str = *s; 78 | ++str;++s; 79 | } 80 | continue; 81 | case 'x': 82 | base = 16; 83 | break; 84 | case 'd': 85 | break; 86 | default: 87 | if(str <= end) *str = '%'; 88 | ++str; 89 | if(*fmt){ 90 | if(str <= end) *str = *fmt; 91 | ++str; 92 | }else{ 93 | --fmt; 94 | } 95 | continue; 96 | } 97 | num = va_arg(args,unsigned int); 98 | str = number(str,end,num,base,size); 99 | } 100 | if(str <= end) *str = '\0'; 101 | else if(size > 0) *end = '\0'; 102 | return str - buf; 103 | } 104 | 105 | int vscnprintf(char *buf, unsigned long size, const char *fmt, va_list args){ 106 | int i = vsnprintf(buf,size,fmt,args); 107 | return (i >= size) ? (size - 1) : i; 108 | } 109 | -------------------------------------------------------------------------------- /memorymap.txt: -------------------------------------------------------------------------------- 1 | <16-bit:real mode> 2 | 0x7c00 - 0x7e00 Boot Loader(loaderS1) 3 | 0x7000 - 0x???? Boot alloc bit map 4 | 0x8000 - 0x8200 Boot Loader[2](loaderS1) <= Copy 5 | 0x8200 - 0xA0000 Kernel Image(temporary) 6 | <32-bit:protected mode> 7 | 0x00100000 - 0x???????? kernel body 8 | 0x???????? - 0x???????? init page table 9 | ~ init_pg_tables_end ~ 10 | 0x00300000 - 0x???????? root disk(mounted on /) 11 | 12 | -------------------------------------------------------------------------------- /mm/filemap.c: -------------------------------------------------------------------------------- 1 | /* 2 | * mm/filemap.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #include 6 | #include 7 | #include 8 | 9 | #include 10 | 11 | struct page *find_get_page(struct address_space *mapping,unsigned long offset){ 12 | 13 | } 14 | 15 | void do_generic_file_read(struct file *filp,unsigned int *ppos, 16 | read_descriptor_t *desc,int dumm){ 17 | struct address_space *mapping = filp->f_dentry->d_inode->i_mapping; 18 | struct inode *inode = mapping->host; 19 | unsigned long index = *ppos >> PAGE_CACHE_SHIFT; 20 | unsigned long offset = *ppos & ~PAGE_CACHE_SHIFT; 21 | for(;;){ 22 | struct page *page = find_get_page(mapping,index); 23 | unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT; 24 | if(index > end_index) break; 25 | unsigned long nr,ret; 26 | nr = PAGE_CACHE_SIZE; 27 | nr = nr - offset; 28 | mapping->a_ops->readpage(filp,page); 29 | } 30 | } 31 | 32 | int file_read_actor(read_descriptor_t *desc, struct page *page, 33 | unsigned long offset, unsigned long size){ 34 | 35 | } 36 | unsigned int __generic_file_aio_read(struct kiocb *iocb,const struct iovec *iov, 37 | unsigned long nr_segs,unsigned int *ppos){ 38 | unsigned long seg; 39 | unsigned int count; 40 | for(seg = 0; seg < nr_segs; seg++){ 41 | const struct iovec *iv = &iov[seg]; 42 | count += iv->iov_len; 43 | } 44 | if(count){ 45 | for(seg = 0; seg < nr_segs; seg++){ 46 | read_descriptor_t desc; 47 | desc.written = 0; 48 | desc.buf = iov[seg].iov_base; 49 | desc.count = iov[seg].iov_len; 50 | if(desc.count == 0) 51 | continue; 52 | do_generic_file_read(filp,ppos,&desc,0); 53 | } 54 | } 55 | return retval; 56 | } 57 | 58 | unsigned int generic_file_read(struct file *filp,char *buf, 59 | unsigned int count,int *ppos){ 60 | struct iovec local_iov = { .iov_base = buf, .iov_len = count }; 61 | struct kiocb kiocb; 62 | init_sync_kiocb(&kiocb,filp); 63 | int ret = __generic_file_aio_read(&kiocb,&local_iov,1,ppos); 64 | return ret; 65 | } 66 | -------------------------------------------------------------------------------- /mm/memory.c: -------------------------------------------------------------------------------- 1 | /* 2 | * mm/memory.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | #include 6 | #include 7 | 8 | #include 9 | 10 | int copy_page_range(struct mm_struct *dst, struct mm_struct *src, 11 | struct vm_area_struct *vma){ 12 | unsigned long next; 13 | unsigned long address = vma->vm_start; 14 | unsigned long end = vma->vm_end; 15 | pgd_t *dst_pgd = pgd_offset(dst,address); 16 | pgd_t *src_pgd = pgd_offset(src,address); 17 | do{ 18 | 19 | }while(dst_pgd++,src_pgd++,address = next,address != end); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /mm/mmap.c: -------------------------------------------------------------------------------- 1 | /* 2 | * mm/mmap.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | void __vma_link_rb(struct mm_struct *mm,struct vm_area_struct *vma, 11 | struct rb_node **rb_link, struct rb_node *rb_parent){ 12 | rb_link_node(&vma->vm_rb,rb_parent,rb_link); 13 | rb_insert_color(&vma->vm_rb,&mm->mm_rb); 14 | } 15 | -------------------------------------------------------------------------------- /mm/page_alloc.c: -------------------------------------------------------------------------------- 1 | /* 2 | * mm/page_alloc.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #include 12 | 13 | struct pglist_data *pgdat_list; 14 | struct zone *zone_table[MAX_NR_ZONES]; 15 | 16 | unsigned long nr_kernel_pages; 17 | unsigned long nr_all_pages; 18 | static inline struct page * expand(struct zone *zone, struct page *page,unsigned long index, int low, int high, struct free_area *area){ 19 | unsigned long size = 1 << high; 20 | while(high > low){ 21 | area--; 22 | high--; 23 | size >>= 1; 24 | list_add(&page[size].lru, &area->free_list); 25 | } 26 | return page; 27 | } 28 | static struct page *__rmqueue(struct zone *zone, unsigned int order) { 29 | struct free_area *area; 30 | unsigned int current_order; 31 | struct page* page; 32 | unsigned int index; 33 | for(current_order = order; current_order < MAX_ORDER; current_order++){ 34 | area = zone->free_area + current_order; 35 | if(!list_empty(&area->free_list)) continue; 36 | page = list_entry(area->free_list.next,struct page,lru); 37 | list_del(&page->lru); 38 | index = page - zone->zone_mem_map; 39 | zone->free_pages -= 1UL << order; 40 | return expand(zone,page,index,order,current_order,area); 41 | } 42 | 43 | } 44 | static struct page *buffered_rmqueue(struct zone *zone, int order, int gfp_flags) { 45 | struct page* page = 0; 46 | page = __rmqueue(zone,order); 47 | if(page != 0){ 48 | 49 | } 50 | return page; 51 | } 52 | 53 | struct page * __alloc_pages(unsigned int gfp_mask,unsigned int order,struct zonelist *zonelist){ 54 | struct zone **zones = zonelist->zones; 55 | if(zones[0] == 0) return 0; 56 | struct zone *z; 57 | struct page *page; 58 | int i; 59 | for(i = 0; (z = zones[i]) != 0; i++){ 60 | unsigned long min = (1 << order); 61 | if(z->free_pages < min) continue; 62 | page = buffered_rmqueue(z,order,gfp_mask); 63 | if(page) 64 | goto got_pg; 65 | } 66 | got_pg: 67 | return page; 68 | } 69 | 70 | unsigned long __get_free_pages(unsigned int gfp_mask,unsigned int order){ 71 | struct page *page = alloc_pages(gfp_mask,order); 72 | if(!page) return 0; 73 | //return (unsigned long)page_address(page); 74 | return 0; 75 | } 76 | 77 | unsigned long nr_free_pages(void){ 78 | unsigned int sum = 0; 79 | struct zone *zone; 80 | for(zone = pgdat_list->node_zones; zone; zone = next_zone(zone)){ 81 | sum += zone->free_pages; 82 | } 83 | return sum; 84 | } 85 | 86 | static inline int page_is_buddy(struct page *page, int order){ 87 | if(test_bit(PG_private, &page->flags) && 88 | page->private == order && 89 | page->_count == 0) 90 | return 1; 91 | return 0; 92 | } 93 | 94 | static inline void __free_pages_bulk (struct page *page, 95 | struct zone *zone, unsigned int order){ 96 | unsigned long page_idx = page_to_pfn(page) & ((1 << MAX_ORDER) - 1); 97 | struct page *base = zone->zone_mem_map; 98 | int order_size = 1 << order; 99 | zone->free_pages += order_size; 100 | while(order < MAX_ORDER - 1){ 101 | unsigned long buddy_idx = page_idx ^ (1 << order); 102 | struct page *buddy = base + buddy_idx; 103 | if(!page_is_buddy(buddy,order)) break; 104 | list_del(&buddy->lru); 105 | zone->free_area[order].nr_free--; 106 | __clear_bit(PG_private,&buddy->flags); 107 | buddy->private = 0; 108 | page_idx &= buddy_idx; 109 | order++; 110 | } 111 | page->private = order; 112 | list_add(&page->lru,&zone->free_area[order].free_list); 113 | zone->free_area[order].nr_free++; 114 | } 115 | 116 | static int free_pages_bulk(struct zone *zone, int count, 117 | struct list_head *list, unsigned int order){ 118 | int ret = 0; 119 | zone->all_unreclaimable = 0; 120 | zone->pages_scanned = 0; 121 | while(!list_empty(list) && count--){ 122 | struct page *page = list_entry(list->prev,struct page,lru); 123 | list_del(&page->lru); 124 | __free_pages_bulk(page, zone, order); 125 | ret++; 126 | } 127 | return ret; 128 | } 129 | void __free_pages_ok(struct page *page, unsigned int order){ 130 | LIST_HEAD(list); 131 | list_add(&page->lru,&list); 132 | free_pages_bulk(page_zone(page),1,&list,order); 133 | } 134 | 135 | fastcall void __free_pages(struct page *page,unsigned int order){ 136 | if(page->_count == 0){ 137 | if(order == 0); 138 | else __free_pages_ok(page,order); 139 | } 140 | } 141 | 142 | void *alloc_large_system_hash(const char *tablename, 143 | unsigned long bucketsize, 144 | unsigned long numentries, 145 | int scale, 146 | int flags, 147 | unsigned int *_hash_shift, 148 | unsigned int *_hash_mask, 149 | unsigned long limit){ 150 | nr_all_pages = 8192000; 151 | unsigned long max = limit; 152 | unsigned log2qty,size; 153 | void *table = 0; 154 | numentries = 1UL << (long_log2(numentries) + 1); 155 | if(max == 0){ 156 | max = ((unsigned long)nr_all_pages << PAGE_SHIFT) >> 4; 157 | max /= bucketsize; 158 | } 159 | if(numentries > max) numentries = max; 160 | log2qty = long_log2(numentries); 161 | 162 | do{ 163 | size = bucketsize << log2qty; 164 | table = (void*)alloc_bootmem(size); 165 | }while(!table && size > PAGE_SIZE && --log2qty); 166 | printk("%s hash table entries: %d\n",tablename,(1UL << log2qty)); 167 | if(_hash_shift) *_hash_shift = log2qty; 168 | if(_hash_mask) *_hash_mask = (1 << log2qty) - 1; 169 | return table; 170 | } 171 | 172 | unsigned long get_zeroed_page(unsigned int gfp_mask){ 173 | struct page *page = alloc_pages(gfp_mask,0); 174 | if(page){ 175 | //void *address = page_address(page); 176 | void *address = 0; 177 | //clear_page(address); 178 | return (unsigned long)address; 179 | } 180 | return 0; 181 | 182 | } 183 | -------------------------------------------------------------------------------- /mm/pgtable.c: -------------------------------------------------------------------------------- 1 | /* 2 | * kernel/pgtable.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | 11 | extern kmem_cache_t *pgd_cache; 12 | pgd_t *pgd_alloc(struct mm_struct *mm){ 13 | pgd_t *pgd = kmem_cache_alloc(pgd_cache,0); 14 | int i; 15 | for(i = 0; i < PTRS_PER_PGD; ++i){ 16 | 17 | } 18 | return pgd; 19 | } 20 | -------------------------------------------------------------------------------- /mm/vmalloc.c: -------------------------------------------------------------------------------- 1 | /* 2 | * mm/vmalloc.c 3 | * Copyright (C) <2014> <@RKX1209> 4 | */ 5 | #include 6 | 7 | struct vm_struct *vmlist; 8 | 9 | int map_vm_area(struct vm_struct *area, unsigned long prot,struct page ***pages){ 10 | unsigned long address = (unsigned long) area->addr; 11 | unsigned long end = address + (area->size-PAGE_SIZE); 12 | pgd_t *dir = pgd_offset_k(address); 13 | do{ 14 | dir++; 15 | }while(address && (address < end)); 16 | return 1; 17 | } 18 | 19 | struct vm_struct *__get_vm_area(unsigned long size,unsigned long flags, 20 | unsigned long start,unsigned long end){ 21 | unsigned long addr = start; 22 | struct vm_struct *area = kmalloc(sizeof(*area),0); 23 | if(!area) return 0; 24 | size += PAGE_SIZE; 25 | struct vm_struct **p,*tmp; 26 | for(p = &vmlist; (tmp = *p) != 0; p = &tmp->next){ 27 | if((size + addr) < addr) goto out; 28 | if(size + addr <= (unsigned long)tmp->addr) goto found; 29 | } 30 | found: 31 | area->next = *p; 32 | *p = area; 33 | area->flags = flags; 34 | area->addr = (void*)addr; 35 | area->size = size; 36 | area->pages = 0; 37 | area->nr_pages = 0; 38 | area->phys_addr = 0; 39 | 40 | return area; 41 | } 42 | struct vm_struct *get_vm_area(unsigned long size,unsigned long flags){ 43 | return __get_vm_area(size,flags,VMALLOC_START,VMALLOC_END); 44 | } 45 | 46 | void *__vmalloc(unsigned long size, int gfp_mask, unsigned long prot){ 47 | /* Get free space from [VMALLOC_START,VMALLOC_END] */ 48 | struct vm_struct *area = get_vm_area(size,VM_ALLOC); 49 | struct page **pages; 50 | if(!area) return 0; 51 | unsigned int nr_pages = size >> PAGE_SHIFT; 52 | unsigned array_size = (nr_pages * sizeof(struct page*)); 53 | area->nr_pages = nr_pages; 54 | area->pages = pages = kmalloc(array_size,0); 55 | memset(area->pages,0,array_size); 56 | unsigned long i; 57 | for(i = 0; i < area->nr_pages; i++){ 58 | area->pages[i] = alloc_page(0); 59 | } 60 | if(map_vm_area(area,prot,&pages)) goto fail; 61 | return area->addr; 62 | 63 | fail: 64 | vfree(area->addr); 65 | return 0; 66 | } 67 | 68 | void *vmalloc(unsigned long size){ 69 | return __vmalloc(size,0,0); 70 | } 71 | 72 | void unmap_vm_area(struct vm_struct *area){ 73 | unsigned long address = (unsigned long)area->addr; 74 | unsigned long end = (address + area->size); 75 | pgd_t *dir = pgd_offset_k(address); 76 | do{ 77 | dir++; 78 | }while(address && (address next){ 84 | if(tmp->addr == addr) goto found; 85 | } 86 | return 0; 87 | found: 88 | unmap_vm_area(tmp); 89 | *p = tmp->next; 90 | return tmp; 91 | } 92 | 93 | void __vunmap(void *addr, int deallocate_pages){ 94 | if(!addr) return; 95 | struct vm_struct *area = remove_vm_area(addr); 96 | kfree(area); 97 | return; 98 | } 99 | 100 | void vfree(void *addr){ 101 | __vunmap(addr,1); 102 | } 103 | -------------------------------------------------------------------------------- /script/prepare.sh: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | copy_f(){ 4 | for e in $1/*; do 5 | path=$e 6 | if [ -d "$path" ]; then 7 | #echo "D:$path" 8 | copy_f "$path" 9 | elif [ -f "$path" ]; then 10 | echo "F:$path" 11 | mv "$path" /tmp/Abyon/arch 12 | fi 13 | done 14 | } 15 | mkdir /tmp/Abyon 16 | cp -r ./arch /tmp/Abyon 17 | cp -r ./boot /tmp/Abyon 18 | cp -r ./include /tmp/Abyon 19 | cp -r ./kernel /tmp/Abyon 20 | cp -r ./mm /tmp/Abyon 21 | cp -r ./fs /tmp/Abyon 22 | cp -r ./lib /tmp/Abyon 23 | cp -r ./drivers /tmp/Abyon 24 | cp -r ./ldscript /tmp/Abyon 25 | cp -r ./security /tmp/Abyon 26 | cp Makefile /tmp/Abyon 27 | cp -r /tmp/Abyon/arch/i386/* /tmp/Abyon/arch/ 28 | #copy_f /tmp/Abyon/arch 29 | -------------------------------------------------------------------------------- /security/seabyon/avc.c: -------------------------------------------------------------------------------- 1 | /* 2 | * security/seabyon/avc.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #define AVC_CACHE_SLOTS 512 10 | struct av_decision{ 11 | unsigned int allowed; 12 | unsigned int decided; 13 | unsigned int auditallow; 14 | unsigned int auditdeny; 15 | unsigned int seqno; 16 | }; 17 | 18 | struct avc_entry{ 19 | unsigned int ssid; 20 | unsigned int tsid; 21 | unsigned int tclass; 22 | struct av_decision avd; 23 | }; 24 | 25 | struct avc_node{ 26 | struct avc_entry ae; 27 | struct list_head list; 28 | }; 29 | 30 | struct avc_cache{ 31 | struct list_head slots[AVC_CACHE_SLOTS]; 32 | 33 | }; 34 | 35 | static struct avc_cache avc_cache; 36 | 37 | void avc_init(void){ 38 | int i; 39 | for(i = 0; i < AVC_CACHE_SLOTS; i++){ 40 | INIT_LIST_HEAD(&avc_cache.slots[i]); 41 | } 42 | } 43 | 44 | static inline int avc_hash(unsigned long ssid, unsigned long tsid, 45 | unsigned short tclass){ 46 | return (ssid ^ (tsid<<2) ^ (tclass<<4)) & (AVC_CACHE_SLOTS - 1); 47 | } 48 | 49 | static inline struct avc_node *avc_search_node(unsigned int ssid,unsigned int tsid,unsigned short tclass){ 50 | int hvalue = avc_hash(ssid,tsid,tclass); 51 | struct avc_node *ret = &avc_cache.slots[hvalue]; 52 | return ret; 53 | } 54 | static struct avc_node *avc_lookup(unsigned int ssid,unsigned int tsid, 55 | unsigned short tclass,unsigned int requested){ 56 | struct avc_node *node = avc_search_node(ssid,tsid,tclass); 57 | return node; 58 | } 59 | 60 | int avc_has_perm(unsigned long ssid,unsigned long tsid,unsigned short tclass, 61 | unsigned long requested,int dumm){ 62 | struct avc_node *node = avc_lookup(ssid,tsid,tclass,requested); 63 | struct avc_entry *p_ae = &node->ae; 64 | unsigned int denied = requested & ~(p_ae->avd.allowed); 65 | if(denied) return -1; 66 | return 1; 67 | } 68 | 69 | -------------------------------------------------------------------------------- /security/seabyon/hooks.c: -------------------------------------------------------------------------------- 1 | /* 2 | * security/seabyon/hooks.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | #include "av_permission.h" 8 | #include "objsec.h" 9 | 10 | struct security_operations *secondary_ops = 0; 11 | struct security_operations *original_ops = 0; 12 | extern struct security_operations *security_ops; 13 | 14 | static int task_has_perm(struct task_struct *tsk1, 15 | struct task_struct *tsk2, 16 | unsigned int perms){ 17 | struct task_security_struct *tsec1,*tsec2; 18 | tsec1 = tsk1->security; 19 | tsec2 = tsk2->security; 20 | return avc_has_perm(tsec1->sid,tsec2->sid, 21 | 0,perms,0); 22 | } 23 | static int seabyon_ptrace(struct task_struct *parent,struct task_struct *child){ 24 | struct task_security_struct *psec = parent->security; 25 | struct task_security_struct *csec = child->security; 26 | 27 | int rc = secondary_ops->ptrace(parent,child); 28 | if(rc) return rc; 29 | rc = task_has_perm(parent,child,PROCESS__PTRACE); 30 | return rc; 31 | } 32 | 33 | static struct security_operations seabyon_ops = { 34 | .ptrace = seabyon_ptrace 35 | }; 36 | 37 | static int seabyon_init(void){ 38 | original_ops = secondary_ops = security_ops; 39 | avc_init(); 40 | register_security(&seabyon_ops); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /security/seabyon/objsec.h: -------------------------------------------------------------------------------- 1 | /* 2 | * security/seabyon/objsec.h 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #ifndef _SEABYON_OBJSEC_H 7 | #define _SEABYON_OBJSEC_H 8 | #include 9 | 10 | struct task_security_struct{ 11 | unsigned long magic; 12 | struct task_struct *task; 13 | unsigned int osid; 14 | unsigned int sid; 15 | unsigned int exec_sid; 16 | unsigned int create_sid; 17 | unsigned int ptrace_sid; 18 | }; 19 | #endif 20 | -------------------------------------------------------------------------------- /security/security.c: -------------------------------------------------------------------------------- 1 | /* 2 | * security/security.c 3 | * Copyright (C) <2015> <@RKX1209> 4 | */ 5 | 6 | #include 7 | 8 | struct security_operations dummy_security_ops; 9 | struct security_operations *security_ops; 10 | 11 | int security_init(void){ 12 | security_ops = &dummy_security_ops; 13 | } 14 | 15 | int register_security(struct security_operations *ops){ 16 | security_ops = ops; 17 | return 0; 18 | } 19 | 20 | int unregister_security(struct security_operations *ops){ 21 | security_ops = &dummy_security_ops; 22 | return 0; 23 | } 24 | --------------------------------------------------------------------------------