os-k-team
/
kvisc
mirror of https://gitlab.os-k.eu/os-k-team/kvisc.git
1
0
Fork 0
Code Releases Activity
kvisc/vm/ob/doskrnl.k

1631 lines
25 KiB
Plaintext
Raw Blame History

# 1 "doskrnl.k"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "doskrnl.k"
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
__sysmain:
jmp start
# 1 "crt/crt.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
;
; Limits
;
# 31 "crt/crt.k"
;
; Magic numbers
;
;
; CRT librairies
;
# 1 "./crt/sys.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
;
; SHUTDOWN syscall
;
; End virtual machine
;
Sys.Shutdown := 0x00
;
; EXIT syscall
;
; Return to COMMAND.COM
;
Sys.Exit := 0x01
;
; EXEC syscall
;
; IN
; ax0 = new RIP to load
; ax1 = frame ID to switch to
;
; New frame ID must be higher than current
; frame ID, and cannot be below 5
;
; New CR1 is set so that new RIP corresponds to 1MB
;
Sys.ExecuteInFrame := 0x02
; FIND syscalls
;
; Find file on disk
;
; IN
; ax0 = address of name buffer
; ax1 = size of name buffer
;
; OUT
; rax = # of bytes written in name buffer
; rdx = size of file
;
;
Sys.FindFirst := 0x20
Sys.FindNext := 0x21
;
; OPEN syscall
;
; IN
; ax0 = name string
;
; OUT
; rax = handle of file, or <0 if couldn't open
;
Sys.OpenFile := 0x30
;
; CREATE syscall
;
; IN
; ax0 = name string
;
; OUT
; rax = 0 on success, or <0 if couldn't open
;
Sys.CreateFile := 0x31
;
; REMOVE syscall
;
; IN
; ax0 = name string
;
; OUT
; rax = 0 on success, or <0 if couldn't open
;
Sys.RemoveFile := 0x32
;
; CLOSE syscall
;
; IN
; ax0 = file handle
;
Sys.CloseFile := 0x35
;
; READ syscall
;
; IN
; ax0 = file handle
; ax1 = buffer address
; ax2 = buffer size
;
; OUT
; rax = number of bytes read, <0 on error
;
Sys.ReadFile := 0x38
; Halt mode
Sys.EnterHaltMode := 0x999
# 43 "crt/crt.k" 2
# 1 "./crt/str.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
;
; int strnlen(char *, int)
;
strnlen:
mov rcx, ax1
scasb ax0, zero
sub rax, ax1, rcx
ret
;
; int strlen(char *)
;
strlen:
mov rcx, 0x7AFFFFFF
mov rdx, rcx
scasb ax0, zero
sub rax, rdx, rcx
ret
;
; void strcpy(char *, const char *)
;
strcpy:
.l:
mov rcx, b[ax1]
mov b[ax0], rcx
jrcxz .r
inc ax0
inc ax1
jmp .l
.r:
ret
;
; void strncpy(char *, const char *, int)
;
strncpy:
mov rcx, ax2
jrcxz .r
.l:
mov b[ax0], b[ax1]
inc ax0
inc ax1
loop .l
.r:
ret
;
; void strnzcpy(char *, const char *, int)
;
strnzcpy:
mov rcx, ax2
jrcxz .r
.l:
mov rax, b[ax1]
mov b[ax0], rax
jraxz .r
inc ax0
inc ax1
loop .l
.z:
nul b[ax0]
.r:
ret
;
; int strcmp(const char *str1, const char *str2)
;
; Returns:
; 0 if the contents of both strings are equal
; >0 if the first character that does not match has a greater value in str1 than in str2
; <0 if the first character that does not match has a lower value in str1 than in str2
;
strcmp:
nul rsi
.l:
movzx rax, b[ax0+rsi]
movzx rdx, b[ax1+rsi]
bne rax, rdx, .r
; both zero?
add rcx, rax, rdx
jrcxz .r
inc rsi
jmp .l
.r:
sub rax, rdx
ret
;
; int strncmp(const char *str1, const char *str2, int maxn)
;
strncmp:
mov rcx, ax2
jrcxz .r
.l:
movzx rax, b[ax0]
movzx rdx, b[ax1]
bne rax, rdx, .r
inc ax0
inc ax1
loop .l
.r:
sub rax, rdx
ret
;
; char *strchrnul(const char *str, int ch)
;
strchrnul:
mov rcx, 0x7AFFFFFF
scasb ax0, ax1
mov rax, ax0
ret
;
; char *strchr(const char *str, int ch)
;
strchr:
mov rcx, 0x7AFFFFFF
scasb ax0, ax1
bnz b[ax0], .r
nul rax
ret
.r:
mov rax, ax0
ret
;
; void strrev(char *buf, const char *str)
;
; buf and src must NOT overlap
;
strrev:
bzr b[ax1], .z
; save str's location
mov rsi, ax1
; go to str's end, just before
; the null terminator
mov rcx, 0x7AFFFFFF
scasb ax1, zero
dec ax1
.l:
; copy, going backward though str
; and forward through buf
mov b[ax0], b[ax1]
beq ax1, rsi, .r
inc ax0
dec ax1
jmp .l
.r:
nul b[ax0+1]
ret
.z:
nul b[ax0]
ret
;
; void strrev2(char *str)
;
; Inverses str
;
strrev2:
bzr b[ax0], .r
mov ax1, ax0
; go to str's end, just before
; the null terminator
mov rcx, 0x7AFFFFFF
scasb ax1, zero
dec ax1
; increase ax0 while decreasing ax1, performing exchanges
.l:
blteu ax1, ax0, .r
xchg b[ax0], b[ax1]
inc ax0
dec ax1
jmp .l
.r:
ret
# 44 "crt/crt.k" 2
# 1 "./crt/mem.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
;
; void memcpy(void *, const void *, int)
;
memcpy:
mov rcx, ax2
jrcxz .r
.l:
sub rdx, ax2, rcx
mov b[ax0+rdx], b[ax1+rdx]
loop .l
.r:
ret
;
; void memzero(void *, int)
;
memzero:
mov rcx, ax1
jrcxz .r
.l:
nul b[ax0]
inc ax0
loop .l
.r:
ret
# 45 "crt/crt.k" 2
# 1 "./crt/time.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
;
; struct TIME
; {
; byte sec; +0 (0-59)
; byte min; +1 (0-59)
; byte hour; +2 (0-23)
; byte mday; +3 (0-31)
; byte month; +4 (0-11)
; byte; +5 (pad)
; word year; +6 (0-65536)
; word yday; +8 (0-365)
; word; +10 (pad)
; dword; +12 (pad)
; } 16 bytes
;
;
; int DaysInYear(int year)
;
DaysInYear:
mov rax, 365
; divisible by 4?
rem rcx, ax0, 4
jrcxnz .end
; divisible by 100?
rem rcx, ax0, 100
jrcxnz .leap
; divisible by 400?
rem rcx, ax0, 400
jrcxnz .end
.leap:
inc rax
.end:
ret
;
; TIME *GetTimeUTC(void)
;
GetTimeUTC:
ytime
mov rdi, .buf
; seconds
rem rsi, rax, 60
mov b[rdi], rsi
; minutes
div rsi, rax, 60
rem rsi, 60
mov b[rdi+1], rsi
; hours
div rsi, rax, 3600
rem rsi, 24
mov b[rdi+2], rsi
; month days
div rsi, rax, 3600*24
mov b[rdi+3], rsi
; month
mov b[rdi+4], rbx
; years
mov w[rdi+6], rcx
;
; ydays (TODO)
;
mov rax, .buf
ret
.buf = [24]
# 46 "crt/crt.k" 2
# 1 "./crt/fmt/ltostr.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
;
; void itoa(char *buf, int num, int base)
;
itoa:
mov ax3, 1
jmp ltostr
;
; void utoa(char *buf, int num, int base)
;
utoa:
nul ax3
jmp ltostr
;
; void ltostr(char *buf, int num, int base, bool signed)
;
ltostr:
mov rax, ax0
nul rcx
; make sure base is in [2, 32]
bltu ax2, 2, .bad
bltu 36, ax2, .bad
; deal with zero
bzr ax1, .is_zero
; deal with base 10 signedness
bzr ax3, .conv
bne ax2, 10, .conv ; base 10
shr rcx, ax1, 63 ; extract ax1 sign
jrcxz .conv
neg ax1 ; NEG if negative
; main loop
.conv:
bzr ax1, .fini
rem rdx, ax1, ax2 ; ax1 % base
blt 9, rdx, .nondec ; rdx > 9 ?
add rdx, '0'
jmp .next
.nondec:
add rdx, 55 ; 'A' - 10
.next:
mov b[ax0], rdx
inc ax0
div ax1, ax2
jmp .conv
; add minus flag, null-terminate and reverse
.fini:
jrcxz .cxz
mov b[ax0], '-'
inc ax0
.cxz:
nul b[ax0]
call strrev2, rax
ret
;
; exceptional cases
;
.bad:
mov b[ax0], 0
ret
.is_zero:
mov b[ax0], 48 ; '0'
mov b[ax0+1], 0
ret
# 48 "crt/crt.k" 2
# 1 "./crt/fmt/strtol.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
;
; int strtol(const char *str, int base)
;
; rax = integer extracted from str
; rdx = pointer to first invalid byte
;
strtol:
mov ax2, 1
jmp strtoq
;
; int strtoul(const char *str, int base)
;
; rax = integer extracted from str
; rdx = pointer to first invalid byte
;
strtoul:
nul ax2
jmp strtoq
;
; int strtoq(const char *str, int base, bool signed)
;
; guesses base when 'base'=0
;
strtoq:
nul rax, rsi
mov rdx, ax0
; make sure base is in [2, 32]
beq ax1, 1, .bad
bltu 36, ax1, .bad
; empty string?
bzr b[rdx], .done
.skip_spc:
bne b[rdx], ' ', .no_spc
inc rdx
jmp .skip_spc
.no_spc:
; skip +
bne b[rdx], '+', .no_plus
inc rdx
.no_plus:
; unsigned?
bzr ax2, .unsigned
; parse '-'
bne b[rdx], '-', .unsigned
inc rdx
mov rsi, 1
.unsigned:
; base 0
bzr ax1, .base_0
; base prefix?
bne b[rdx], '0', .main_loop
inc rdx
movzx rcx, b[rdx]
; "0x"/"0b" prefix
jrcxz .done ; "0"
beq rcx, 'x', .parsed_0x
beq rcx, 'b', .parsed_0b
; may be octal, but we don't care
; we accept "0110101010" (despite base=2) for instance
jmp .main_loop
.parsed_0x:
; are we in base 16?
; if not, leave rax = 0 and *rdx = 'x'
bne ax1, 16, .done
; else
inc rdx
jmp .main_loop
.parsed_0b:
; are we in base 2?
; if not, leave rax = 0 and *rdx = 'b'
bne ax1, 2, .done
; else
inc rdx
jmp .main_loop
.base_0:
; guess base
beq b[rdx], '0', .b0_not10
; must be base 10
mov ax1, 10
jmp .main_loop
.b0_not10:
inc rdx
bne b[rdx], 'x', .b0_not16
inc rdx
mov ax1, 16
jmp .main_loop
.b0_not16:
bne b[rdx], 'b', .b0_not2
inc rdx
mov ax1, 2
jmp .main_loop
.b0_not2:
; take octal by default
mov ax1, 8
.main_loop:
movzx rcx, b[rdx]
inc rdx
; between 0 and 9?
bltu rcx, '0', .done
bltu '9', rcx, .not_digit10
; yes
sub rcx, '0'
jmp .next
.not_digit10:
bltu rcx, 'A', .done
bltu 'Z', rcx, .not_digitAZ
sub rcx, 55 ; 'A' - 10
jmp .next
.not_digitAZ:
bltu rcx, 'a', .done
bltu 'z', rcx, .done
sub rcx, 87 ; 'a' - 10
jmp .next
.next:
; too large for base?
blteu ax1, rcx, .done
mul rax, ax1
add rax, rcx
jmp .main_loop
.done:
; negative?
bzr rsi, .r
; yes
neg rax
.r:
ret
.bad:
ret
# 49 "crt/crt.k" 2
# 1 "./crt/fmt/doprnt.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
;
; typedef int (*PUTC)(int ch)
; int doprnt(PUTC putc, int n, const char *fmt, va_list ap)
;
doprnt:
push rbp
mov rbp, rsp
push r12, r13, r14
push r15, r16, r17
mov r12, ax2 ; fmt
mov r14, ax3 ; va_list
mov r15, ax1 ; n
mov r17, ax0 ; putc
nul r16 ; return value
.main_loop:
; find '%' or null-terminator
mov rcx, 0x7AFFFFFF
mov r13, r12
scasb r13, '%'
; everything below r13 is a regular character; print it
.print_regular:
beq r12, r13, .check_modf
call .doput, b[r12]
inc r12
jmp .print_regular
.check_modf:
; did we find a '%' ?
; if not, then we found fmt's null-terminator; we're done
bne b[r12], '%', .epilogue
; we did find a modifier / '%'
mov rax, b[r12+1]
add r12, 2
beq rax, 's', .modf_s
beq rax, 'c', .modf_c
beq rax, 'p', .modf_p
beq rax, 'x', .modf_x
beq rax, 'd', .modf_d
beq rax, 'o', .modf_o
beq rax, 'b', .modf_b
beq rax, '%', .modf_percent
; unrecognized
jmp .bad_modifier
.modf_s:
; get string address
mov r13, q[r14]
add r14, 8
bzr r13, .nullstring
.print_string:
movzx ax0, b[r13]
bzr ax0, .main_loop
inc r13
call .doput
jmp .print_string
.modf_c:
call .doput, q[r14]
add r14, 8
jmp .main_loop
.modf_p:
call .doput, '0'
call .doput, 'x'
; Fallthrough
.modf_x:
mov ax2, 16
jmp .print_number
.modf_d:
mov ax2, 10
jmp .print_number
.modf_o:
mov ax2, 8
jmp .print_number
.modf_b:
mov ax2, 2
jmp .print_number
.print_number:
; allocate itoa conversion buffer
sub rsp, 80
mov r13, rsp
; assume modifier already set up ax2
call itoa, rsp, q[r14]
add r14, 8
.print_itoa_buf:
movzx ax0, b[r13]
bzr ax0, .pib_end_loop
inc r13
call .doput
jmp .print_itoa_buf
.pib_end_loop:
add rsp, 80
jmp .main_loop
.modf_percent:
call .doput, '%'
jmp .main_loop
.bad_modifier:
; print "%?" to clearly indicate that something is wrong
call .doput, '%'
call .doput, '?'
jmp .main_loop
.nullstring:
; %s was passed a NULL
call .doput, '('
call .doput, 'n'
call .doput, 'u'
call .doput, 'l'
call .doput, 'l'
call .doput, ')'
jmp .main_loop
.epilogue:
mov rax, r16
pop r17, r16
pop r15, r14
pop r13, r12
leave
ret
;
; prints ax0
;
.doput:
; update print count
inc r16
; if n==0, don't print
; we follow the C convention that sprintf()-like functions
; should return the number of characters that would have
; been printed/written if 'n' were big enough
bzr r15, .r
; decrement n and print
dec r15
call r17
; did putc fail?
jraxz .r
; yes, so artificially set n=0
nul r15
.r:
ret
# 50 "crt/crt.k" 2
# 1 "./crt/fmt/printf.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
;
; int putc(int ch)
;
putc:
prn ax0
nul rax
ret
;
; int printf(const char *fmt, ...)
;
printf:
mov ax2, ax0
mov ax0, putc
mov ax1, 0x7AFFFFFF
add ax3, rsp, 8
jmp doprnt
;
; int nprintf(const char *fmt, int n, ...)
;
nprintf:
mov ax2, ax0
mov ax0, putc
add ax3, rsp, 8
jmp doprnt
;
; Print a string
; Guaranteed to only affect rcx and ax0
;
print:
.l:
movzx rax, b[ax0]
jraxz .r
prn rax
inc ax0
jmp .l
.r:
ret
;
; Print exactly ax1 characters
;
nprint:
mov rcx, ax1
jrcxz .r
.l:
prn b[ax0]
inc ax0
loop .l
.r:
ret
# 51 "crt/crt.k" 2
exit:
mov rax, Sys.Exit
trap 0
abort:
crash
# 8 "doskrnl.k" 2
;
; Special addresses
;
; The kernel guarantees that COMMAND.COM
; will always be loaded on a 16KB boundary
; This is guaranteed to be the case in all
; future versions as well
;
; Entry point
;
start:
mov esp, 0x104000
mov ebp, zero
;dump
call main
crash
;
; Disk Operating System
;
# 1 "sys/drv/cpudev.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
CPUDEV := 0
RFS.GetMaxIdx:
iocall CPUDEV, 16
ret
RFS.GetUsage:
iocall CPUDEV, 17
ret
RFS.GetCurIdx:
iocall CPUDEV, 18
ret
RFS.GetLeastAvail:
iocall CPUDEV, 19
ret
RFS.IsFrameActive:
iocall CPUDEV, 20
ret
RFS.ActivateFrame:
iocall CPUDEV, 21
ret
RFS.DeactivateFrame:
iocall CPUDEV, 22
ret
RFS.CopyFrame:
iocall CPUDEV, 23
ret
RFS.MoveFrame:
iocall CPUDEV, 24
ret
RFS.SwitchFrame:
iocall CPUDEV, 25
ret
RFS.LoadArgs:
iocall CPUDEV, 32
ret
RFS.LoadReg:
iocall CPUDEV, 33
ret
RFS.StoreReg:
iocall CPUDEV, 48
ret
IDT.AddHandler:
iocall CPUDEV, 64
ret
IDT.DelHandler:
iocall CPUDEV, 65
ret
IDT.QueryHandler:
iocall CPUDEV, 66
IDT.DoneHandling:
iocall CPUDEV, 67
ret
# 43 "doskrnl.k" 2
# 1 "sys/drv/memdev.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
MEMDEV := 1
MEM.GetMemOff:
iocall MEMDEV, 0
ret
MEM.GetMemSize:
iocall MEMDEV, 1
ret
# 44 "doskrnl.k" 2
# 1 "sys/drv/diskdev.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
DISKDEV := 4
DISK.FindFirst:
.slot := 16
iocall DISKDEV, .slot
ret
DISK.FindNext:
.slot := 17
iocall DISKDEV, .slot
ret
DISK.OpenFile:
iocall DISKDEV, 25
ret
DISK.CloseFile:
iocall DISKDEV, 26
ret
DISK.CreateFile:
iocall DISKDEV, 27
ret
DISK.RemoveFile:
iocall DISKDEV, 28
ret
DISK.ReadFile:
iocall DISKDEV, 32
ret
DISK.WriteFile:
iocall DISKDEV, 33
ret
# 45 "doskrnl.k" 2
# 1 "sys/intr/excepts.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
DefaultExceptionHandler:
mov esp, 0x105800
mov ax1, nx0
bzr nx0, DefaultTrapHandler.handle_Shutdown
bltu 11, nx0, .unknown
mov esi, .err_ukn
lea ax0, b[esi + nx0 * 32]
call ScreenOfDeath
.unknown:
call ScreenOfDeath, .err_ukn
crash
.err_ukn = "Unknown exception number\0\0\0\0\0\0\0"
.err_udf = "Undefined behaviour exception\0\0"
.err_ill = "Illformed instruction exception"
.err_acc = "Invalid memory access exception"
.err_sys = "Supervisor-only instruct. used\0"
.err_dbf = "Double fault exception~~~~~~~~\0"
.err_imp = "Feat. not implemented exception"
.err_ali = "Misalignmed address exception\0\0"
.err_brk = "BREAK key (Ctrl+C) exception\0\0\0"
.err_ovf = "Overflow flag raised exception\0"
.err_div = "Division by zero exception\0\0\0\0\0"
# 47 "doskrnl.k" 2
# 1 "sys/intr/common.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
ScreenOfDeath:
push nx0
mov nx0, ax0
prn 10
prn 0x8BF00001
prn 0x8BF00002
push ax1
call printf, .scr1
pop
bnz nx2, .not_con
push .scr2_con
jmp .do_print
.not_con:
; rframes #2-#3-#4 belong to kernel
blt 4, nx2, .not_krn
push .scr2_krn
jmp .do_print
.not_krn:
push .scr2_usr
.do_print:
push nx2, nx0
call printf, .scr2
add esp, 24
call dumprf, nx2
prn 10
call print, .scr3
.loop:
pause
pause
scan eax
jraxz .loop
beq eax, 0x0A, DefaultTrapHandler.handle_Exit
beq eax, 0x1B, DefaultTrapHandler.handle_Shutdown
jmp .loop
crash
.scr1 = "-------- Unhandled EXCEPTION, TRAP/SYSCALL or INTERRUPT (code %d)\n"
.scr2 = "Description: %s\nFrame: %d (%s)\n\n"
.scr3 = "Press:\n ENTER to procede to COMMAND.COM\n ESCAPE to shutdown machine\n\n"
.scr2_con = "dedicated command.com frame"
.scr2_usr = "userspace application frame"
.scr2_krn = "exception/interrupt handler"
# 48 "doskrnl.k" 2
# 1 "sys/intr/trap0.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
TrapHandlers.prolog:
nul ebp
; eax = caller's cr1
call RFS.LoadReg, nx2, $cr1
; we don't preserve the nx0 we got
mov nx0, eax
nul edx
jmp ecx
TrapHandlers.epilog:
; TRAP return values: eax-edx
mov ax2, eax
call RFS.StoreReg, nx2, $eax
mov ax2, edx
call RFS.StoreReg, nx2, $edx
call IDT.DoneHandling, nx1
iret
;
; TRAP #0 handler
;
DefaultTrapHandler:
.init:
mov ecx, .text
mov esp, 0x104800
jmp TrapHandlers.prolog
.text:
call RFS.LoadReg, nx2, $eax
call RFS.LoadArgs, nx2
; will be optimized with a table
; when we have a "finished" consistent API
jraxz .handle_Shutdown
beq eax, Sys.Exit, .handle_Exit
beq eax, Sys.ExecuteInFrame, .handle_EIF
beq eax, Sys.ReadFile, .handle_ReadFile
beq eax, Sys.OpenFile, .handle_OpenFile
beq eax, Sys.CloseFile, .handle_CloseFile
beq eax, Sys.CreateFile, .handle_CreateFile
beq eax, Sys.RemoveFile, .handle_RemoveFile
beq eax, Sys.FindNext, .handle_FindNext
beq eax, Sys.FindFirst, .handle_FindFirst
beq eax, Sys.EnterHaltMode, .handle_HaltMode
.sod:
call ScreenOfDeath, .badsyscall, nx1
.wrong:
call ScreenOfDeath, .badparams, nx1
.fini.savecx:
mov ax2, ecx
call RFS.StoreReg, nx2, $ecx
.fini:
jmp TrapHandlers.epilog
.badsyscall = "Invalid syscall number in eax"
.badparams = "Invalid syscall parameters"
;------------------------------------------------;
; Syscall implementations ;
;------------------------------------------------;
;
; Pass control to COMMAND.COM in frame 0
;
.handle_Exit:
; deactivate current rframe
bzr nx2, .hE_nz ; unless it's 0...
call RFS.DeactivateFrame, nx2
.hE_nz:
; open COMMAND.COM
call DISK.OpenFile, .cmdcom
; crash on failure
bltz eax, abort
; load at 0x108000
mov ax1, 0x108000
mov ax2, 0x80000
call DISK.ReadFile, eax
; assume that COMMAND.COM being
; less then 4KB means something
; went wrong
blt eax, 0x1000, abort
; close the handle
call DISK.CloseFile, eax
; code address
mov ax2, 0x100000
call RFS.StoreReg, zero, $eip
; usermode
mov ax2, 3
call RFS.StoreReg, zero, $cr0
mov ecx, 0x108000
sub ecx, 0x100000
; code offset
mov ax2, ecx
call RFS.StoreReg, zero, $cr1
; return frame
nul nx2
jmp .fini
.cmdcom = "command.com"
.handle_EIF:
blt ax1, 5, .wrong
; eip can't be <1MB
mov ecx, 0x100000
blt ax0, ecx, .wrong
; add old CR1
add ax0, nx0
; real eip can't be <1MB+32KB either
; (kernel + cmdcom personal space)
add edx, ecx, 0x8000
blt ax0, ecx, .wrong
; save rframe and compute new CR1
mov ebx, ax1
sub edi, ax0, ecx
; activate rframe
call RFS.ActivateFrame, ebx
; save new CR1
mov ax2, edi
call RFS.StoreReg, ebx, $cr1
; interruptible user mode
mov ax2, 3
call RFS.StoreReg, ebx, $cr0
; set eip = 1MB
mov ax2, ecx
call RFS.StoreReg, ebx, $eip
; change return frame
mov nx2, ebx
jmp .fini
;
; Disk API
;
.handle_FindFirst:
add ax0, nx0
call DISK.FindFirst
jmp .fini.savecx
.handle_FindNext:
add ax0, nx0
call DISK.FindNext
jmp .fini.savecx
.handle_OpenFile:
add ax0, nx0
call DISK.OpenFile
jmp .fini
.handle_CreateFile:
add ax0, nx0
call DISK.CreateFile
jmp .fini
.handle_RemoveFile:
add ax0, nx0
call DISK.RemoveFile
jmp .fini
.handle_CloseFile:
call DISK.CloseFile
jmp .fini
.handle_ReadFile:
add ax1, nx0
call DISK.ReadFile
jmp .fini
;
; Misc.
;
.handle_Shutdown:
call IDT.DelHandler, zero
stop
.handle_HaltMode:
pause
pause
hlt
jmp .handle_HaltMode
# 49 "doskrnl.k" 2
# 1 "sys/dumprf.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
dumprf:
push rbp
mov rbp, rsp
push r12, r13
mov r12, ax0
mov r13, rsp
call RFS.LoadReg, r12, $cr1
push rax
call RFS.LoadReg, r12, $cr0
push rax
call RFS.LoadReg, r12, $rip
push rax
push r12
call printf, .dmp1
call RFS.LoadReg, r12, $srp
push rax
call RFS.LoadReg, r12, $trp
push rax
push zero # fixme
call RFS.LoadReg, r12, $rbp
push rax
call RFS.LoadReg, r12, $rsp
push rax
call printf, .dmp2
call RFS.LoadReg, r12, $ax5
push rax
call RFS.LoadReg, r12, $ax4
push rax
call RFS.LoadReg, r12, $ax3
push rax
call RFS.LoadReg, r12, $ax2
push rax
call RFS.LoadReg, r12, $ax1
push rax
call RFS.LoadReg, r12, $ax0
push rax
call printf, .dmp3
call RFS.LoadReg, r12, $rdi
push rax
call RFS.LoadReg, r12, $rsi
push rax
call RFS.LoadReg, r12, $rdx
push rax
call RFS.LoadReg, r12, $rcx
push rax
call RFS.LoadReg, r12, $rbx
push rax
call RFS.LoadReg, r12, $rax
push rax
call printf, .dmp4
call RFS.LoadReg, r12, $r17
push rax
call RFS.LoadReg, r12, $r16
push rax
call RFS.LoadReg, r12, $r15
push rax
call RFS.LoadReg, r12, $r14
push rax
call RFS.LoadReg, r12, $r13
push rax
call RFS.LoadReg, r12, $r12
push rax
call printf, .dmp5
call RFS.LoadReg, r12, $r20
push rax
call RFS.LoadReg, r12, $r19
push rax
call RFS.LoadReg, r12, $r18
push rax
call printf, .dmp6
mov rsp, r13
pop r13, r12
leave
ret
.dmp1 = "Environ #1:\nfrm=0d%d rip=0x%x\ncr0=0x%x cr1=0x%x\n\n"
.dmp2 = "Environ #2:\nrsp=0x%x rbp=0x%x ind=0d%d\ngrp=0x%x trp=0x%x srp=0x%x\n\n"
.dmp3 = "Argument:\nax0=0x%x ax1=0x%x ax2=0x%x\nax3=0x%x ax4=0x%x ax5=0x%x\n\n"
.dmp4 = "Volatile:\nrax=0x%x rbx=0x%x rcx=0x%x\nrdx=0x%x rsi=0x%x rdi=0x%x\n\n"
.dmp5 = "Persistent:\nr12=0x%x r13=0x%x r14=0x%x\nr15=0x%x r16=0x%x r17=0x%x\n"
.dmp6 = "r18=0x%x r19=0x%x r20=0x%x\n"
# 51 "doskrnl.k" 2
# 1 "sys/main.k" 1
; The OS/K Team licenses this file to you under the MIT license.
; See the LICENSE file in the project root for more information.
PrintBootMsg:
call print, .bootmsg
ret
.bootmsg = "Starting DOS...\n\n"
;
; Initialize TRAP handlers
;
InitSyscalls:
call RFS.ActivateFrame, 1
mov ax1, $rip
mov ax2, DefaultTrapHandler
call RFS.StoreReg
mov ax0, 256
mov ax1, 1
call IDT.AddHandler
ret
InitExcepts:
call RFS.ActivateFrame, 2
mov ax1, $rip
mov ax2, DefaultExceptionHandler
call RFS.StoreReg
call IDT.AddHandler, zero, 2
SwitchToCMD:
mov rax, Sys.Exit
trap 0
;
; Main function
;
main:
call PrintBootMsg
call InitSyscalls
call InitExcepts
call SwitchToCMD
ret
# 52 "doskrnl.k" 2
View Git Blame Copy Permalink