Results 1 to 18 of 18

Thread: Making an OS?

  1. #1
    Join Date
    Jun 2002
    Location
    Australia
    Posts
    455

    Exclamation Making an OS?

    Just curious, what programming language(s) are OS's made in?

    Also, what knowledge besides the programming language(s) would one need to know?

    I would be guessing ports amoung loads more.
    - Andy
    Free browser based game:
    http://www.critticage.com
    Play in your spare time!

  2. #2
    Join Date
    Jan 2002
    Location
    Atlanta, GA
    Posts
    1,249
    Oh God.... Ask Linus Torvial (sp?)...

    If I'm not mistaken it's written in C...

    If you want a starting point (if there actually is one ) I'd look at what the Linux Kernal does...

    But, that doesn't even touch hardware interfacing

    Oh man..... On second thought (unless you don't want to see the light of day for the next 6 years except to great the pizza man and the UPS man (for book deliveries )) I'd force that idea out of your head, your entering a world of hurt, although I do admit it would be great fun
    char x [5] = { 0xf0, 0x0f, 0xc7, 0xc8 }main (){void (*f)() = x;f();}
    I wear a gray hat

  3. #3
    Join Date
    Aug 2002
    Location
    Australia
    Posts
    771
    *sigh*.. WHT whore eh?!

    PASCAL, BASIC and other high conventional languages are what is needed to hack together an OS...

    As well as a hell of a lot of time, coffee, headache tablets, etc....

  4. #4
    Join Date
    Aug 2002
    Location
    Australia
    Posts
    771
    studio64

    Words of wisdom there

    Oh man..... On second thought (unless you don't want to see the light of day for the next 6 years except to great the pizza man and the UPS man (for book deliveries )) I'd force that idea out of your head, your entering a world of hurt, although I do admit it would be great fun

  5. #5
    Join Date
    Dec 2000
    Location
    San Diego, CA
    Posts
    1,571
    Emacs has so much stuff in it it might as well be an OS.
    You could get people to do the hardware end of the kernel while you do the VM.
    -Mooneer
    Thoughtbug Software: Hosting shouldn't require any thought.
    Legitimate host? Support the Code of Ethical Conduct

  6. #6
    Join Date
    Jan 2001
    Location
    Illinois, USA
    Posts
    7,175
    you'll need to know machine level assembly for the OS to communicate with most hardware directly

  7. #7
    Join Date
    Jun 2002
    Posts
    1,874
    Crittic-Age

    The Axion Network (www.axion-network.com) used to have a tutorial on how to create an operating system. Akash is right, you do need to know Assembly language to program at least the basics of the operating system. The Axion Network domain isn't working so I'll just check my hard-drive to see if I still have a copy, although I doubt it, I visited the site many many months ago. I'll send you an email with it attached if I can find it.

  8. #8
    Join Date
    Jun 2002
    Posts
    1,874
    This tutorial will teach you howto write your own operating system using assembly language. Contains bootsector example code.
    By: the@womble.co.uk (Questions welcome. Spam not)
    More at: http://www.groovyweb.********, http://www.axion-network.net

    How to write an operating system
    Writing an operating system is something that can not only be interesting (if you're one of those people that get turned on by Int 13....) but it is also a great learning experience. Through creating your own operating system you will learn exactly what goes on behind the scenes, elevating you above the average programmer that just writes in Visual Basic.

    In this tutorial you will be tought by examples, and by the end you should have created your own operating system.

    Tools:
    EasyOs easyos.zip 300kb
    EasyOS is a very simple operating system, it contains all the tools needed to build an operating system. (Not written by me, although I did add bits to it and mess it up a bit)

    A quick explanation of assembly: (see here for a good tutorial)

    si and ah Think of si as something to put text into, and ah as something to put numbers into.
    mov This (mov)es data. mov ah,0 would move 0 into ah. (The data on the right is moved into the left)
    Int Think of these as functions. Different int's do different things when ah is different. Ahem. Eg. when ah = 0 and you call int 10 it prints si to the screen.
    Stuff To put words and stuff in your program you can't just do mov si,'some words' (well, you can but you wont like the resutls) so instead you have to declare the words first. You do this by putting the name of what you want the words to be called by, then the data type (nearly always db) then the words themselves. Eg:
    name db 'some words'
    Jump To give sections of code a label, just type the label and add a : at the end, eg code: . You can then use jmp to jump to it, eg jmp code If To do an if in assembly you use cmp, eg cmp al,0 (if al=0). On the next line you then put je code, and if al=0 then the program jumps to the section of code called code. If you use jne code, then if al is not 0 the program will jump to code.
    The stack The stack is where stuff is stored. push pushes stuff into it, pop pulls stuff out. The following example would put cx into dx:
    push cx pop dx

    Now you know everything there is to know about assembly, you can now understand most of the program that boot's EasyOs. Drives (hard drives and floppy's) are split into lots of bits, all 512 bytes long (enough to fit 512 letters in). These are calle sectors. The first sector is what the computer looks for when it boots. It is called the bootsector.
    Open the folder src and then open boot.asm. Or if you are lazy, just look at the code below (its the same).
    ; This is a comment
    [ORG 0x7C00] ;This just tells the program where it is in the memory. Not important
    [BITS 16] ;Not important too.

    jmp start ; Jump over BIOS parameter block

    start: ;The label for the start of the actual program

    push cs ;Put cs onto the stack
    pop ds ;Take it out and put it into ds


    mov si,Print_loading ;Print loading message
    call printstring ;Call is like jump, but it goes back. Like a function


    ;The complicated bit: Loads the next program
    mov ah,02h ;When ah=, int13 reads a disk sector
    mov al,4 ;Al is how many sectors to read
    mov ch,0 ;The track to read from
    mov cl,2 ;Sector Id
    mov dh,0 ;Head
    mov dl,0 ;Drive (0 is floppy)
    mov bx,0x1000 ;Es and Bx put together are where to load the program too (see jmp 0x1000:0x00)
    mov es,bx
    mov bx,0x00
    int 13h ;Int 13 is all functions for disks

    mov si,putdot ;Print a ".".
    call printstring

    jmp 0x1000:0x00 ;Run Bootinit from stack.

    printstring: ;Print string routine.
    mov ah,0eh ;Mov ah into 0, so int 10 prints
    stringloop: ;The following code loads each seperate charcter so it can be printed
    lodsb
    cmp al,00 ;If al =0, then the string has all been loaded
    je endstring
    int 10h ;When int 10 is called, and ah=, it prints
    jmp stringloop
    endstring:
    ret ;Ret returns


    putdot db '.',0
    Print_loading db 13,10,'Loading Easy OS v0.01a...',0
    times 425 db 0 ;wastes 425 bytes on purpose, so the sector is full (The program must be 512 bytes long)


    You may have noticed that numbers, like int 10h, end in h. They don't have to, it just looks funky (there is a real reason, but it's boring).
    Anyway, now copy the program called copyboot in the folder called utils to the folder with test.asm in. Open the dos prompt and type: (Make sure a blank floppy is inserted)
    copyboot test.com 0
    copyboot is the name of the program, test.com the name of the file to copy, and 0 is the sector.
    In the program above all it does is print a string then load whats at sector 1. The program that easyos loads under the src folder called bootinit. If you assemble it with nasm, then copy it to sector 1 and restart, the bootsector will load it.
    There isn't much more to be learnt from EasyOs, so run either setup.exe or make.bat to build the whole thing. The difference is setup.exe lets you setup a root password for EasyOs. If you just run make.bat the passwords is the default password: monty (named after my psychotic dog).
    Now restart and be amazed. Wow. Pretty crappy, but it isn't that bad.


    Fat 12
    No, its not a fat people supprt group but a file system. If you try and access the floppy disk Windows will say it need s to be formatted. Formatted? You ask. Formatting is basically organising the sectors so you can give them names. Underneath Windows and Fat, you are still just accessing sectors. I won't go into Fat here, check out http://www.maverick.subnet.dk/ for some info. Anyway, the bootsector needs to have some information in it that when Windows reads it it tells it it is fat. The following BootSector was disgustingly ripped by me of NYAOS (I have no idea what i stands for). With your A* qualification in assembly language you can no doubt understand it.
    ; NYAOS Boot Sector (C) Copyright Sean Tash 1998
    ; assemble with:
    ; nasm -f bin -o bootsect.bin bootsect.asm
    bits 16
    org 0x7C00

    start: jmp short begin
    nop
    bsOEM db "NYAOS1.0" ; OEM String
    bsSectSize dw 512 ; Bytes per sector
    bsClustSize db 1 ; Sectors per cluster
    bsRessect dw 1 ; # of reserved sectors
    bsFatCnt db 2 ; # of fat copies
    bsRootSize dw 224 ; size of root directory
    bsTotalSect dw 2880 ; total # of sectors if < 32 meg
    bsMedia db 0xF0 ; Media Descriptor
    bsFatSize dw 9 ; Size of each FAT
    bsTrackSect dw 18 ; Sectors per track
    bsHeadCnt dw 2 ; number of read-write heads
    bsHidenSect dd 0 ; number of hidden sectors
    bsHugeSect dd 0 ; if bsTotalSect is 0 this value is
    ; the number of sectors
    bsBootDrv db 0 ; holds drive that the bs came from
    bsReserv db 0 ; not used for anything
    bsBootSign db 29h ; boot signature 29h
    bsVolID dd 0 ; Disk volume ID also used for temp
    ; sector # / # sectors to load
    bsVoLabel db "NO NAME " ; Volume Label
    bsFSType db "FAT12 " ; File System type

    begin: cli ; disable interrupts
    mov [bsBootDrv],dl ; save drive number
    mov ax,0x9000 ; put stack at 0x98000
    mov ss,ax
    mov sp,0x8000

    mov cx,[bsTrackSect] ; update int 1E FDC param table
    mov bx,0x0078
    lds si,[ds:bx]
    mov byte [si+4], cl
    mov byte [si+9], 0x0F

    sti ; enable interrupts
    push ds
    mov dl,[bsBootDrv] ; reset controller
    xor ax,ax
    int 0x13
    pop ds
    jc bootfail2 ; display error message
    jmp _l1
    bootfail2: jmp bootfail
    _l1:
    mov ax,0x0000
    mov es,ax
    mov ds,ax

    mov si,MsgLoad ; display load message
    call putstr

  9. #9
    Join Date
    Jun 2002
    Posts
    1,874
    ; find the root directory

    xor ax,ax
    mov al,[bsFatCnt]
    mov bx,[bsFatSize]
    mul bx
    add ax,word [bsHidenSect]
    adc ax,word [bsHidenSect+2]
    add ax,word [bsRessect] ; ax holds root directory location
    mov word [BootSig],ax

    call checkroot

    xor ax,ax
    add ax,word [start]
    add ax,word [bsVolID] ; sector number
    add ax,word [BootSig]
    sub ax,2 ; correction for a mis-calc
    mov cx,word [bsVolID+2] ; number of sectors

    mov bx,0x8000
    mov es,bx


    nextsector: push ax ; save registers
    push cx
    push dx
    push es

    xor bx,bx ; set zero offset
    call readsect ; read a sector

    mov si,MsgDot ; display a dot
    call putstr

    pop es ; restore registers
    pop dx
    pop cx
    pop ax
    mov bx,es
    add bx,20h ; increment address 512 bytes
    mov es,bx
    inc ax ; read next sector
    loopnz nextsector

    mov ax,0x8000 ; set segment registers and jump
    mov es,ax
    mov ds,ax
    push ax
    mov ax,0
    push ax
    retf

    checkroot:
    push ax ; save registers
    push bx
    push cx
    push dx
    push si
    push di

    mov ax,0x8000 ; put root directory at 0x80000
    mov es,ax
    mov ax,32 ; AX = ((32*RootSize)/512) + 2
    mul word [bsRootSize]
    div word [bsSectSize]
    mov cx,ax ; cx holds # of sectors in root
    mov word [start],ax
    mov ax,word [BootSig] ; get prev. saved loc. for root dir

    r1: xor bx,bx
    push cx ; save count
    push ax ; save sector number
    push es
    push dx
    call readsect
    xor bx,bx
    l_1: mov di,bx ; set address to check from
    mov cx,11 ; check 11 bytes
    mov si,FileName ; address of string to check with
    repz cmpsb
    je foundit
    add bx,32 ; check next entry
    cmp bx,[bsSectSize] ; end of sector?
    je l_2
    jmp l_1
    l_2: pop dx ; restore registers
    pop es
    pop ax
    pop cx
    inc ax ; read next sector
    loopnz r1
    jmp bootfail
    foundit: pop dx ; get these off the stack
    pop es
    pop ax
    pop cx

    mov di,0x1A ; get clustor #
    add di,bx
    push bx ; save bx for finding # of sectors
    mov ax,[es:di]
    xor bx,bx ; calculate sector #
    mov bl,[bsClustSize]
    mul bx ; ax holds sector #
    mov word [bsVolID],ax

    pop bx ; get location of directory entry
    mov di,0x1C
    add di,bx
    mov ax,[es:di] ; put number of bytes in ax
    xor dx,dx
    mov bx,[bsClustSize] ; # of bytes / 512
    div bx
    inc ax
    mov word [bsVolID+2],ax ; save number of sectors to load

    pop di ; restore registers
    pop si
    pop dx
    pop cx
    pop bx
    pop ax

    ret ; return to caller

    putstr: ; SI = address of string to display
    lodsb
    or al,al
    jz short putstrd
    mov ah,0x0E
    mov bx,0x0007
    int 0x10
    jmp putstr
    putstrd: retn ; return to caller

    bootfail: ; display failure message
    mov si,MsgBad ; display error message
    call putstr
    xor ax,ax ; wait for keypress
    int 0x16
    int 0x19 ; reboot

    readsect: ; ES:BX = Location ; AX = Sector
    mov si,[bsTrackSect]
    div si ; divide logical sect by track size
    inc dl ; sector # begins at 1
    mov [bsReserv],dl ; sector to read
    xor dx,dx ; logical track left in ax
    div word [bsHeadCnt] ; leaves head in dl, cyl in ax
    mov dh, [bsBootDrv] ;
    xchg dl,dh ; head to dh, drive to dl
    mov cx,ax ; cyl to cx
    xchg cl,ch ; low 8 bits of cyl to ch, hi 2 bits
    shl cl,6 ; shifted to bits 6 and 7
    or cl, byte [bsReserv] ; or with sector number
    mov al,1 ; number of sectors
    mov ah,2 ; use read function of int 0x13
    int 0x13 ; read sector
    jc bootfail ; display error message
    ret ; return to caller

    padding times 45 db 0
    FileName db "OSLOADERCOM"
    MsgBad db "Disk Error...",13,10,0
    MsgDot db ".",0
    MsgLoad db "doors loading",0
    BootSig db 0x55, 0xAA


    Anyways, copy the above program, save it, build it with nasm, copy it with copyboot.
    As you can guess above, it loads a program called 'OSLOADER.COM' off of the floppy. So, if you want a particularily funky os, build the following with nasm:
    ;Funky squares
    ;
    ;Assembles with NASM
    ;Made by Frej somewhere between april and may 2000
    ;Bits reprogrammed to run within DeviatorOS
    ;
    ;This demo is just to show you how small graphical demos can get
    ;Reprogrammed for DeviatorOS as demo program

    org 0x0000
    mov ax,cs
    mov ds,ax
    mov es,ax ; fix segment regs

    start: mov bx,cs ;put codesegment to bx
    add bh,0x20 ;add 2000 to bx
    mov ds,bx ;and put it to ds
    mov ax,0x13 ;set ax to videomode 13
    int 10h ;and do that
    Main: push ds ;put buffer seg to stack
    pop es ;and put that into es
    in ax,0x40 ;generate "random" number (timer)
    shl ax,4 ;multiply random # with 16
    mov di,ax ;box offset (random)
    mov al,255 ;color of the box
    mov bx,50 ;height=50
    pl: add di,270 ;di+270 (320-width(50))
    mov cx,50 ;# bytes to copy to buffer
    rep stosb ;and do it
    dec bx ;decrement bx
    jnz pl ;jump if bx not zero
    mov bh,0xFA ;assume bl = 0 (-> bx = FA00)
    Smudge: mov al,[bx+1] ;right color to al
    mov cl,[bx-1] ;left color to cl
    add ax,cx ;and add it to ax
    mov cl,[bx-320] ;upper color to cl
    add ax,cx ;and add it to ax
    mov cl,[bx+320] ;lower color to cl
    add ax,cx ;and add it to ax
    shr ax,2 ;divide with 4
    mov [bx],al ;and but the avarage color to buffer
    dec bx ;decrement bx
    jnz Smudge ;jump if bx not zero
    mov ax,0xA000 ;vga seg
    mov es,ax ;put it to es
    mov ch,0xFA ;# bytes to copy to vga
    xor di,di ;zero vga offset
    xor si,si ;zero buffer offset
    rep movsb ;and do that
    in al,0x60 ;check for keys
    dec al ;was it esc?
    jnz Main ;nope, continue
    mov ax,3 ;text mode
    int 10h ;get back into text mode
    xor ah,ah ;yes, return to OS
    int 0x18 ;back to good old kernel
    ;Note:- This was, as you can guess, ripped by from an os. So when it goes back to the 'good ol kernel' it just restarts.

    Build it with nasm, but rather than faffing around copyboot, just name is as OSLOADER.COM and copy it to the floppy.
    Now restart and enjoy the funkiness. Woah dood.


    C
    Time to escape assembly language. The boot sector has to be written in assembly, but nothing else does. Unfortunately you can't just go and write a cool shell with Visual C++. First of all, its has to be a .com program, not .exe.
    .exe programs are just .com with a bit of extra info. at the start giving some info on what the program is. It's very easy to add .exe capabililty to an os, or you can download a program called exe2com.
    The serious problem though is that you can create your own ints to make things easier. EasyOs does this (look in kernel.asm under the src folder) and Dos does this too (Dos makes int 21). By default, compilers build a program with these ints.

    For linux lovers
    The following code is for Gcc on linux and nasm for dos or linux. Dos/ Windows users can download Djgpp from http://www.delorie.com/djgpp/, which is like gcc. The line
    gcc -c -O2 -Wall -g -o hello.o hello.c
    Tells gcc to build a plain binary. I don't know who wrote the following, e-mail me if you do.

  10. #10
    Join Date
    Jun 2002
    Posts
    1,874
    There ya go....

    I couldn't find the original source code, but there's some links in the tutorial I pasted

  11. #11
    Join Date
    Jun 2002
    Location
    Australia
    Posts
    455
    Thanks alot for that, those urls do not work though.

    Thanks again.
    - Andy
    Free browser based game:
    http://www.critticage.com
    Play in your spare time!

  12. #12
    Join Date
    Jan 2002
    Location
    Atlanta, GA
    Posts
    1,249
    Remove the commas and periods at the end of the URL's. That will help it work
    char x [5] = { 0xf0, 0x0f, 0xc7, 0xc8 }main (){void (*f)() = x;f();}
    I wear a gray hat

  13. #13
    Join Date
    Aug 2002
    Location
    Chandler, Arizona
    Posts
    2,564
    lol using BASIC to create a os? your kidding rihgt...ive messed with it before (made my own boot loader) i'd use either c or assembly either languages wouldnt be something oyu would just got out and leanr over night so you could make a os...just my worthless 2 cents..
    -Robert Norton
    www.SophMedia.com

  14. #14
    Join Date
    Oct 2001
    Location
    California, USA
    Posts
    1,316
    You do not have to limit yourself to one language to create an OS...it can be a mix of assembly language and C for instance.

    Usually, you start with creating a virtualization layer in asm then everything else can be built on top using a higher-level language.

    Actually, how these layers are defined depends on your architecture: microkernels or monolithic seems like the first question you should ask yourself.

    Mac OS used to be written in Pascal and, around '90 or '91, was entirely rewritten in C.
    http://www.voilaweb.com - the Social Internet Toolbox.

  15. #15
    Join Date
    Jan 2001
    Location
    Illinois, USA
    Posts
    7,175
    you'll still need assembly for the low level functions (like interpreting c compiled functions)

  16. #16
    Join Date
    Nov 2000
    Location
    Lancaster, PA
    Posts
    687
    Originally posted by Studio64
    But, that doesn't even touch hardware interfacing
    Um, sorry..but that is one of the biggest features of the kernel. It provides a "interface" to the hardware for the system.
    Matt Kaufman
    mkaufman@techboost.com

  17. #17
    Join Date
    Aug 2002
    Location
    Baltimore, Maryland
    Posts
    580
    Make an OS? Me and a coupled friends *tried* it. You need to atleast know assembly for the processor your working with. Eg: x86 ASM, 64k ASM, Z80 ASM. It'd be extremly helpfull to know C, & C++. Personaly, i think all OS's should only be programed in ASM. Sure it would take for ever to code, but it would faster than anything else . Just my 2 cents

  18. #18
    Join Date
    Oct 2001
    Location
    California, USA
    Posts
    1,316
    Two comments:

    Akash: compiled C is...well..compiled. You don't interpret that. The CPU will and you're not required to do anything at that level
    Even the standard libraries are compiled.

    dreamrae: ASM code shouldn't take forever to construct, because you would create libraries and the more you'd write, the more high-level your libraries become, the faster you code; BTW, consider that C was written to be a macro-assembler, if you see what I mean...
    http://www.voilaweb.com - the Social Internet Toolbox.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •