Betriebssystem

Ringding

hmmmmm? schrieb:

Er hat geschrieben "Dh. so weit in Assembler das ich meine C Funktionen aufrufen kann???". Und das dauert mit Sicherheit keine 2 Jahre bis man es soweit hat.

Gut, kommt auf die Betrachtungsweise an. Wenn man nur eine Art Assembler stub macht und damit eine C-Funktion aufruft, dann braucht man vielleicht ein paar Tage.

Ich hab's so verstanden, dass er ein OS machen will, für das man in C ein Programm schreiben (und ausführen) kann.

Richtig!

Genau das will ich machen!

spjoe

Hier ein paar tips zum os proggen
1. Guten emulator dfür die platform runterladen fie man will
Bei x86 zu empfelen Bochs
2. Überlegen welches datei format der kern haben soll (Grub und lilo verstehen ELF) binutils mit elf unterstützung runterladen ev. auch crosscompiler notwendig
3. Viel Zeit haben und nicht aufgeben

Bisserl asm code zum einsteigen (für grub bootloader)

.text
.globl start, __k32_startup, _main, ___main, start_gdt
.extern end, edata, etext, _mem_start

start:
__k32_startup:
		lgdt	start_gdt
		ljmp	$8, $xxx

/* gdt info */

.align 4
start_gdt:
	.word	23
	.long	start_gdt
	.word 	0

	.long	0x0000ffff
	.long	0x00CF9A00

	.long	0x0000ffff
	.long	0x00CF9200

.align 4
xxx:
		movl	$0x10, %edx
		mov	%dx, %ds
		mov	%dx, %es
		mov	%dx, %fs
		mov	%dx, %gs
		mov	%dx, %ss

		mov	%eax, (0x600)
		mov	%ebx, (0x604)

		movl	$0xA0000-4, %esp
//		movl	%ebx, %esp
		movl	%esp, %ebp

		pushl	$0
		popfl

	// clear bss
		xorl	%eax, %eax
		movl	$end, %ecx
		movl	$edata, %edi
		subl	%edi, %ecx
		cld
		rep
		stosb

		addl	$0xFFF, %edi
		andl	$0xFFFFF000, %edi
	//	movl	%edi, _mem_start //sollt variabel sein muss fkt schreiben!!!return((mem_start+(PAGE_SIZE-1))&0xFFFFF000);

		call	_main

__k32_end:	jmpl	__k32_end
___main:	ret

// put our GRUB bootloader header code here
.align 4
multiboot_header:
	.long	0x1BADB002			## magic
	.long	0x00000003			## flags[16]
	.long	0-(0x1BADB002 + 0x00000003)	## zero crc of fields 1+2

einfach mit einer datei linken wo main eine c funtkion ist und es gibt keine probleme und einstiegs punkt auf start enden und fixe adress räume verwenden

OUTPUT_FORMAT("elf32-i386")
ENTRY(start)
SECTIONS {
  .text 0x100000 : {
    *(.text)
    _etext = .;
    etext = _etext;
  }
  .data : {
    *(.data)
    _edata = .;
    edata = _edata;
  }
  .bss : {
    *(.bss)
    *(COMMON)
    _end = .;
    end = _end;
  }
}

einfach die datei mit -t bei gcc angeben

good luck

Erstmal danke für die (warscheinlich) gute Antwort!

Da ich beim ersten lesen nur die hälfte verstanden habe werde ich mich jetzt nochmal dadurch wurschteln

spjoe

Hier noch ein paar sachen: sind aber alle gcc spezifisch (hab mit och keinem anderm compiler ein os gmacht sry)

gcc *.c *.s -c -nostdlib -nostdinc++ -nostdinc -Wall -D__KERNEL__ -fsigned-char
aussführen (erzeugt object datein)
ld-elf -X -x -E -e start -Tbootp.ld *.o -o kernel.elf

in der bootp[b].ld steht

OUTPUT_FORMAT("elf32-i386')
ENTRY(start)
SECTIONS {
  .text 0x100000 : {
    *(.text)
    _etext = .;
    etext = _etext;
  }
  .data : {
    *(.data)
    _edata = .;
    edata = _edata;
  }
  .bss : {
    *(.bss)
    *(COMMON)
    _end = .;
    end = _end;
  }
}

Dann solltest du dir ein disketten image vorbereiten wo grub installiert ist
Dann nach jeden neuen comnilieren die datei auf dem image updaten und danach mit bochs das disketten image emulieren
Bochs gibt relativ gut fehlermeldung zurück fals was schief läuft

good luck

wer sich wirklich für osdev interessiert sollte mal beim lowlevel-magazin vorbeischauen, http://lowlevel.brainsware.org/

oder, wenn man schlau ist, schaut man einfach mal in den linux kernel!

Ein einfaches os schreiben das hello world ausgibt ist wirklich simpel.

http://www.osdever.net/tutorials.php?cat=0&sort=1

Einfach tutorial abschreiben und fertig. Hab ich auch schon gemacht, aber kein wort kapiert

Red*C++*

Autsch!
Das ist nicht gut, in einem Turtorial kein Wort verstanden zu haben.
Man sollte sich schon für das, was man macht interessieren!

Aber jedem das Seine

MfG Red

Ich werde mir das Tutorial gleich mal angucken,
danke

Ich weiss jetzt nicht, ob das ihr schon genannt wurde, weil ich hier alles nur kurz überflogen hab.

http://www.mega-tokyo.com/osfaq2/

Steve O.

Hallo

Ich hab zwar keine Ahnung von Assembler-Sprache und im Programmieren auch nicht so viel aber vielleicht müsstest du für deinen C/C++ Code den du nur über den Prozessor ausführen willst einen eigenen Compiler oder Linker bauen (programmieren). Ich weis nicht ob das so richtig ist. Sollte nur so ne Art Denkanstoss sein.

SteveO.

Steve O. schrieb:

Ich hab zwar keine Ahnung von Assembler-Sprache und im Programmieren auch nicht so viel aber vielleicht müsstest du für deinen C/C++ Code den du nur über den Prozessor ausführen willst einen eigenen Compiler oder Linker bauen. Ich weis nicht ob das so richtig ist.[...]

Ähm warum? Den code den jeder C/C++ Compiler für x86 Prozessoren ausspuckt ist ohne umwege vom Prozessor lesbar. Der Binärcode muss lediglich erst einmal in den Arbeitsspeicher geleden werden. Aus bestimmten gründen nimmt man dafür Assembly und meistens für den Rest C.

Walli

leo aka qsch schrieb:

ehrlichgesagt ist es gar nicht so schwer ein os zu schreiben das hallo welt ausgibt ... aber mehr ist auch schon nur eine Illusion

Also mehr als Hello World ist sicher nicht illusorisch. Wenn du mit "mehr" "viel viel mehr" meintest gebe ich dir Recht .

Steve O.

ProgChild schrieb:

Steve O. schrieb:

Ich hab zwar keine Ahnung von Assembler-Sprache und im Programmieren auch nicht so viel aber vielleicht müsstest du für deinen C/C++ Code den du nur über den Prozessor ausführen willst einen eigenen Compiler oder Linker bauen. Ich weis nicht ob das so richtig ist.[...]

Ähm warum? Den code den jeder C/C++ Compiler für x86 Prozessoren ausspuckt ist ohne umwege vom Prozessor lesbar. Der Binärcode muss lediglich erst einmal in den Arbeitsspeicher geleden werden. Aus bestimmten gründen nimmt man dafür Assembly und meistens für den Rest C.

Ich hab ja auch bloss gemeint. Ich hab wirklich Null Ahnung auf dem Gebiet aber ich hätte gedacht das es vieleicht funktioniert. Danke das du mich eines Besseren belehrt hast.

Steve O.

mastamind

@UnwissendUNDDumm
falls du fragen hast oder so, könntest du dich bei mir mit icq melden: 54419178.

björn

Hi!

Also ein OS coden ist nicht unbedingt illusion. Zudem muss man nicht unbedingt der ASM Guru sein. In der Regel besteht nur der Bootsektor aus ASM Code und evtl. ein paar Treiber, wobei die auch grösstenteils aus C bestehen. Das schwirige an einem OS ist dann das programmieren des Compilers/Linkers der entsprechenden Code zum OS erzeugt. Dazu sollte man dann wirklich gute ASM Kenntnisse haben.

Für das kleine OS was Du vorhast kommst Du mit einem Bootsektor und C recht gut klar, solang nicht mehr willst

Mfg xerox

bluecode

hi,

Ich empfehle dir allerdings keinen eigenen Bootsektor zu schreiben sondern GRUB (oder andere Bootloader) zu benutzen, um deinen Kernel zu laden. Ich hab relativ schlechte Erfahrungen mit eigenen Bootloadern gemacht, da ich nicht wirklich der Assemblerguru bin und da es m.E. wenig Sinn hat seine Zeit/Motivation an einem Bootloader zu verschwenden.
Ansonsten brauchst du nur (reinen) Assembler für ein bisschen Startupcode, der dann die main()-Funktion deines Kernels aufruft. Die meisten anderen Sachen (z.B. inb(), outb(), usw.) kannst du mittels inline-Assembler machen.
Ein OS zu programmieren ist keine Illusion, obwohl es manchmal äußerst frustrierend ist (v.a. am Anfang).

camper

irgendwer muss mir irgendwann mal erklären, warum jeder assembler anfänger (und andere auch) unbedingt ein os schreiben will (zumal beides nur bedingt miteinander zu tun hat). :p

spjoe

Das liegt vieleicht daran dass die meisten glauben das os proggen sehr leicht ist. Vom programmtechnischen ist es ja wirklich nicht so schwer weils von jeder Teilbereich schon irgendwann implemtiert wurde unter der source frei herumliegt. und manchen denken sich halt sie nehmen von überall das beste und es wird super os.

Aber die schwirigkeit am os proggen ist ein durchgehent design plan zu haben der absolut keine sicherheits und andere lücken (Wahrscheinlich ist es gar nicht möglich ein perfektes os zu schreiben) aber BSD hat es fast geschaft (zummindest ist das meine Meinung)