Implementing a simple shell<\/span><\/p>\nA shell accepts command from the user and takes appropriate actions. Below is a shell implementation<\/p>\n
of my hobby operating system.<\/p>\n
[sourcecode language=”text”]
\n#########################################################################################################
\n;# #
\n;# shell.asm #
\n;# This implements the shell . This is a really simple shell .It gets a string from the user #
\n;# and checks whether it is one of the commands known to shell ,if it is one them it just calls #
\n;# the corresponding functions , else it check that there exists an external file in the disk #
\n;# that has a same name as the input . If it exits , its loaded and executed #
\n;#########################################################################################################<\/p>\n
;——————————————————————————-+
\n; procedure shell_initialize |
\n; performs various operations before starting the shell . |
\n; (1) print the Sandman Logo \ud83d\ude42 |
\n; |
\n;——————————————————————————-+
\nshell_initialize:
\n mov [save_address],dx
\n mov [cs_save],ax
\n push cs
\n pop ds
\n push ds
\n pop es
\n cld<\/p>\n
mov si , initial_msg
\n call print_string
\n cli
\n call install_interrupts
\n sti
\nshell_loop:
\n call print_prompt
\n mov di , cmd_buffer
\n mov cx , 13
\n call read_string
\n mov di , cmd_buffer
\n call to_upper
\n mov si , cmd_buffer
\n mov di , cmd_cls
\n stc
\n call string_equal
\n jnc .do_cls<\/p>\n
mov si , cmd_buffer
\n mov di , cmd_help
\n stc
\n call string_equal
\n jnc .do_help<\/p>\n
mov si , cmd_buffer
\n mov di , cmd_dir
\n stc
\n call string_equal
\n jnc .do_dir<\/p>\n
.load_prog:<\/p>\n
call ConvertFileName<\/p>\n
stc
\n mov di , RootConvertedFileName
\n add di , 8
\n mov si , com_ext
\n call string_equal
\n jnc .file_extension_ok<\/p>\n
stc
\n mov di , RootConvertedFileName
\n add di , 8
\n mov si , exe_ext
\n call string_equal
\n jnc .file_extension_ok<\/p>\n
jmp shell_loop
\n.file_extension_ok:<\/p>\n
mov ax,0x80
\n shl ax, 6
\n mov word[end_memory],ax
\n int 12h
\n shl ax,6
\n mov word[top_memory],ax<\/p>\n
sub ax,512 \/ 16
\n mov es,ax
\n sub ax,2048 \/ 16
\n mov ss,ax
\n mov sp,2048<\/p>\n
mov cx, 11
\n mov si, RootConvertedFileName
\n mov di,[save_address]
\n rep movsb<\/p>\n
push es
\n mov bx,[cs_save]
\n push bx
\n xor bx,bx
\n retf
\n jmp $<\/p>\n
.do_cls:
\n xor dx , dx
\n call set_cursor
\n call clear_screen
\n jmp shell_loop<\/p>\n
.do_help:
\n mov si , help_msg
\n call print_string
\n jmp shell_loop
\n .do_dir:
\n call clear_screen
\n call DirPrintFile
\n jmp shell_loop<\/p>\n
;——————————————————————————–+
\n; procedure print_prompt : |
\n; prints the prompt to the user . |
\n; input : none |
\n; output : prints the prompt |
\n;——————————————————————————–+
\nprint_prompt:
\n mov si , prompt
\n call print_string
\n ret<\/p>\n
cmd_cls db ‘CLS’,0
\ncmd_help db ‘HELP’,0
\ncmd_dir db ‘DIR’,0
\nprompt db ‘$’ ,0
\ncmd_buffer: times 14 db 0
\ncom_ext db ‘COM’,0
\nexe_ext db ‘EXE’,0<\/p>\n
initial_msg db ‘Welcome to 1K-DOS \ud83d\ude42 ‘,13,10, ‘ ^ ^ ^’,13,10, ‘ ( *|* )’,13,10, ‘ \/ ~ \\’,13,10, ‘ \/ \\’,13,10, ‘ ———‘,13,10,’ | |’,13,10, ‘ _| _| by S@ndM@n ‘,13,10 ,0
\nhelp_msg db 13 , 10 ,’CLS – Clears the Screen ‘ ,13 , 10 , ‘HELP – Displays This Info ‘ , 13,10 , ‘<FILENAME> – Executes Given File’ ,13 , 10,’DIR -List Contents of Root Directory’ ,13 , 10, 0
\nsave_address dw 0
\ncs_save dw 0<\/p>\n
include ‘util.asm<\/p>\n
[\/sourcecode]<\/p>\n
Executing programs<\/span><\/p>\nWhat you need to do is load the program into memory ( since it a fat12 file , we by now know how to load the file to memory ) and perform relocation if necessary . They jump to beginning of the first executable instruction. in the program. This is illustrated by the following code : ( taken from alexi a frounze , bootcode)<\/p>\n
[sourcecode language=”text”]
\n;;;;;;;;;;;;;;;;;;;;;;;;;;;
\n;; Load entire a program ;;
\n;;;;;;;;;;;;;;;;;;;;;;;;;;;<\/p>\n
ReadNextCluster:
\n call ReadCluster
\n cmp si, 0FF8h
\n jc ReadNextCluster ; if not End Of File<\/p>\n
;;;;;;;;;;;;;;;;;;;
\n;; Type checking ;;
\n;;;;;;;;;;;;;;;;;;;<\/p>\n
cli ; for stack adjustments<\/p>\n
mov ax, ImageLoadSeg
\n mov es, ax<\/p>\n
cmp word [es:0], 5A4Dh ; "MZ" signature?
\n je RelocateEXE ; yes, it’s an EXE program<\/p>\n
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
\n;; Setup and Run COM program ;;
\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<\/p>\n
mov ax, es
\n sub ax, 10h ; "org 100h" stuff \ud83d\ude42
\n mov es, ax
\n mov ds, ax
\n mov ss, ax
\n xor sp, sp
\n push es
\n push word 100h
\n jmp Run<\/p>\n
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
\n;; Relocate, setup and run EXE program ;;
\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<\/p>\n
RelocateEXE:
\n mov ds, ax<\/p>\n
add ax, [ds:08h] ; ax = image base
\n mov cx, [ds:06h] ; cx = reloc items
\n mov bx, [ds:18h] ; bx = reloc table pointer<\/p>\n
jcxz RelocationDone<\/p>\n
ReloCycle:
\n mov di, [ds:bx] ; di = item ofs
\n mov dx, [ds:bx+2] ; dx = item seg (rel)
\n add dx, ax ; dx = item seg (abs)<\/p>\n
push ds
\n mov ds, dx ; ds = dx
\n add [ds:di], ax ; fixup
\n pop ds<\/p>\n
add bx, 4 ; point to next entry
\n loop ReloCycle<\/p>\n
RelocationDone:<\/p>\n
mov bx, ax
\n add bx, [ds:0Eh]
\n mov ss, bx ; ss for EXE
\n mov sp, [ds:10h] ; sp for EXE<\/p>\n
add ax, [ds:16h] ; cs
\n push ax
\n push word [ds:14h] ; ip
\nRun:
\n mov dl, [cs:bsDriveNumber] ; let program know boot drive
\n sti
\n retf<\/p>\n
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
\n;; Reads a FAT12 cluster ;;
\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
\n;; Inout: ES:BX -> buffer ;;
\n;; SI = cluster no ;;
\n;; Output: SI = next cluster ;;
\n;; ES:BX -> next addr ;;
\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<\/p>\n
ReadCluster:
\n mov bp, sp<\/p>\n
lea ax, [si-2]
\n xor ch, ch
\n mov cl, [bpbSectorsPerCluster]
\n ; cx = sector count
\n mul cx<\/p>\n
add ax, [ss:bp+1*2]
\n adc dx, [ss:bp+2*2]
\n ; dx:ax = LBA<\/p>\n
call ReadSector<\/p>\n
mov ax, [bpbBytesPerSector]
\n shr ax, 4 ; ax = paragraphs per sector
\n mul cx ; ax = paragraphs read<\/p>\n
mov cx, es
\n add cx, ax
\n mov es, cx ; es:bx updated<\/p>\n
mov ax, 3
\n mul si
\n shr ax, 1
\n xchg ax, si ; si = cluster * 3 \/ 2<\/p>\n
push ds
\n mov ds, [ss:bp+3*2] ; ds = FAT segment
\n mov si, [ds:si] ; si = next cluster
\n pop ds<\/p>\n
jnc ReadClusterEven<\/p>\n
shr si, 4<\/p>\n
ReadClusterEven:
\n and si, 0FFFh ; mask cluster value
\nReadClusterDone:
\n ret<\/p>\n
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
\n;; Reads a sector using BIOS Int 13h fn 2 ;;
\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
\n;; Input: DX:AX = LBA ;;
\n;; CX = sector count ;;
\n;; ES:BX -> buffer address ;;
\n;; Output: CF = 1 if error ;;
\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<\/p>\n
ReadSector:
\n pusha<\/p>\n
ReadSectorNext:
\n mov di, 5 ; attempts to read<\/p>\n
ReadSectorRetry:
\n pusha<\/p>\n
div word [bpbSectorsPerTrack]
\n ; ax = LBA \/ SPT
\n ; dx = LBA % SPT = sector – 1<\/p>\n
mov cx, dx
\n inc cx
\n ; cx = sector no.<\/p>\n
xor dx, dx
\n div word [bpbHeadsPerCylinder]
\n ; ax = (LBA \/ SPT) \/ HPC = cylinder
\n ; dx = (LBA \/ SPT) % HPC = head<\/p>\n
mov ch, al
\n ; ch = LSB 0…7 of cylinder no.
\n shl ah, 6
\n or cl, ah
\n ; cl = MSB 8…9 of cylinder no. + sector no.<\/p>\n
mov dh, dl
\n ; dh = head no.<\/p>\n
mov dl, [bsDriveNumber]
\n ; dl = drive no.<\/p>\n
mov ax, 201h
\n ; al = sector count
\n ; ah = 2 = read function no.<\/p>\n
int 13h ; read sectors
\n jnc ReadSectorDone ; CF = 0 if no error<\/p>\n
xor ah, ah ; ah = 0 = reset function
\n int 13h ; reset drive<\/p>\n
popa
\n dec di
\n jnz ReadSectorRetry ; extra attempt
\n jmp short ErrRead<\/p>\n
ReadSectorDone:
\n popa
\n dec cx
\n jz ReadSectorDone2 ; last sector<\/p>\n
add bx, [bpbBytesPerSector] ; adjust offset for next sector
\n add ax, 1
\n adc dx, 0 ; adjust LBA for next sector
\n jmp short ReadSectorNext<\/p>\n
ReadSectorDone2:
\n popa
\n ret<\/p>\n
[\/sourcecode]<\/p>\n
Implementing system calls or writing your own interrupt handler<\/span><\/p>\nWriting real mode interrupt handler is very easy, all you need to do is set the address of the of the interrupt routines in the real mode interrupt table. It is shown in the code below.<\/p>\n
[sourcecode language=”text”]
\n———————————————————————-+
\n; procedure install_interrupts : |
\n; The main goal of this procedure is to initialize the real mode |
\n; intterrupt table . The real mode interrupt table is initialized |
\n; as follows [0000 : int_no * 4 ] := handler offset address and |
\n; [0000 : int_no *4 +2 ] := handler segment address . |
\n; |
\n; input : none |
\n; output : sets the real mode interrupt table |
\n;———————————————————————-+<\/p>\n
install_interrupts:
\n push ax
\n push es
\n cli
\n xor ax , ax
\n mov es , ax
\n ; install the int20 interrupt handler
\n mov WORD [es : 0x20 *4] , int20_handler
\n mov WORD [es : 0x20 * 4 + 2] , cs
\n ; install the int21 interrupt handler
\n mov WORD [es : 0x21 *4 ] ,int21_handler
\n mov WORD [es : 0x21 *4 + 2],cs
\n sti
\n pop es
\n pop ax
\n ret<\/p>\n
[\/sourcecode]<\/p>\n
Implementing Multitasking in real mode<\/span><\/p>\nThis link explains it very well\u00a0 : http:\/\/nw08.american.edu\/~mblack\/projects\/OSProjectE.doc<\/p>\n
Books on real mode OS development<\/span><\/p>\nFreeDos kernel<\/p>\n
Dissecting DOS<\/p>\n
Operating\u00a0 System Source code worth reading<\/span><\/p>\nMikeOS Operating System :-\u00a0 http:\/\/mikeos.berlios.de\/<\/p>\n
Public Domain DOS – pdos86\u00a0 :- http:\/\/sourceforge.net\/projects\/pdos\/<\/p>\n
Free DOS Operating System – http:\/\/sourceforge.net\/projects\/freedos\/<\/p>\n
RxDOS Operating System –\u00a0 http:\/\/rxdos.sourceforge.net\/<\/p>\n
Pico Embedded RTOS :-http:\/\/sourceforge.net\/projects\/picoos\/?source=directory<\/p>\n
PS : This article has become very messy because i could not really devote much time to it , i will work on it when i get some more time.<\/p>\n","protected":false},"excerpt":{"rendered":"
Writing real mode operating systems is not hard at all, in fact almost anyone with a little\u00a0 knowledge of\u00a0 x86 assembler will be able to create simple real mode operating systems. The idea of this post is to get you started with real mode operating system development. In this tutorial we will build a\u00a0 simple […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[6],"tags":[],"_links":{"self":[{"href":"https:\/\/sandeepmathew.com\/index.php\/wp-json\/wp\/v2\/posts\/68"}],"collection":[{"href":"https:\/\/sandeepmathew.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sandeepmathew.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sandeepmathew.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/sandeepmathew.com\/index.php\/wp-json\/wp\/v2\/comments?post=68"}],"version-history":[{"count":0,"href":"https:\/\/sandeepmathew.com\/index.php\/wp-json\/wp\/v2\/posts\/68\/revisions"}],"wp:attachment":[{"href":"https:\/\/sandeepmathew.com\/index.php\/wp-json\/wp\/v2\/media?parent=68"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sandeepmathew.com\/index.php\/wp-json\/wp\/v2\/categories?post=68"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sandeepmathew.com\/index.php\/wp-json\/wp\/v2\/tags?post=68"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}