OSDev.org

Code: Select all

char *my_str = "Hello, World!\n";

main()
{
  printf(my_str);
}

Code: Select all

/*global.c*/
#include "type.h"
#include "const.h"
#include "protect.h"
#include "proc.h"
#include "global.h"
#include "proto.h"

struct proc_s			proc_table[3];
char		T_Stack[0x8000 * 3];	// Initialize task stacks;

struct task_s 	task_table[3] = {{process0, 0x8000, "TestA"},
					{process1, 0x8000, "TestB"},
					{process2, 0x8000, "TestC"}};
						
char	a[3]={1,2,3};

Code: Select all

/*global.h*/
.....
struct gate_s idt[256];

unsigned int print_here;

struct     tss_s	    tss;		
struct     proc_s        *    rp;	
extern    struct  proc_s    proc_table[3];
extern    char                 T_Stack[0x8000 * 3];
extern    struct  task_s    task_table[3];

Code: Select all

/*proc.h*/
.....
typedef struct proc_s {
	struct stackframe_s	regs;	/* process' registers saved in stack frame */

	unsigned short    p_ldt_sel;						/* selector in gdt giving ldt base and limit*/
	struct descriptor_s	p_ldt[LDT_SIZE];		/* local descriptors for code and data */
								/* 2 is LDT_SIZE - avoid include protect.h */
	unsigned int       p_id;							/* process id passed in from MM */
	char	p_name[16];				/* name of the process */
};

typedef struct task_s {
	t_pf_task		initial_eip;
	int				stacksize;
	char				name[32];
};

Code: Select all

/*main.c*/
#include "type.h"
#include "const.h"
#include "protect.h"
#include "string.h"
#include "proc.h"
#include "global.h"
#include "proto.h"

//Initialize every process member, which consists of LDT Selector(two of them), LDT Descriptor, Registers, ID and name.
int main()
{
	print("main begins!");
	struct task_s *  t	= task_table;
//	print(task_table[0].name);
	struct proc_s *	p 	= proc_table;
	char 				*	s	= T_Stack + 0x8000 * 3;
	unsigned short	l	= 8 * 5;
	int i;
	for(i=0;i<3;i++){
		strcpy(p->p_name, t->name);
		p->p_id = i;
		p->p_ldt_sel	= l;
/*There are, actually, two items of LDT per process, which are SELECTOR_KERNEL_CS and SELECTOR_KERNEL_DS;
	Initialize both of them now. */
		memcpy(&p->p_ldt[0], &gdt[1], sizeof(struct descriptor_s));
.......

Code: Select all

/*mapfile*/
.......
.data           0x00012060       0x7b
 *(.data .data.* .gnu.linkonce.d.*)
 .data          0x00012060       0x7b kernel/global.o
                0x000120d8                a
                0x00012060                task_table
.......... 
COMMON         0x00013580    0x18150 kernel/global.o
                                  0x0 (size before relaxing)
                0x00013580                T_Stack
                0x0002b580                proc_table
......

Code: Select all

char testa[10]="hello";
int main()
{
char testb[10]="world";
//print(testa);  // Nothing could be printed out when using this procedure.
print(testb);  //when using this one instead, print string "world!"
}

Code: Select all

/*mapfile*/
.............
.data           0x00011000       0x16
 *(.data .data.* .gnu.linkonce.d.*)
 .data          0x00011000        0xa kernel/global.o
                0x00011000                teststring
 *fill*         0x0001100a        0x2 00
 .data          0x0001100c        0xa kernel/main.o
                0x0001100c                testa

.data1
 *(.data1)
..............

Code: Select all

char testa[10] = "hello";

Code: Select all

char *testa = "hello";

Code: Select all

const char testa[10] = "hello";
int main()
{print(testa);
}

Code: Select all

print:
	push	ebp
	mov	ebp, esp
	mov	esi, [ebp + 8]	
	mov	edi, [print_here]
	mov	ah, 0Fh
.I:
	lodsb
	test	al, al
	jz	.II
	mov	[gs:edi], ax
	add	edi, 2
	jmp	.I
.II:
	push	eax
	mov	eax, edi
	mov	bl, 160
	div	bl
	and	eax, 0FFh
	inc	eax
	mov	bl, 160
	mul	bl
	mov	edi, eax
	pop	eax
	mov	[print_here], edi
	pop	ebp
	ret

Code: Select all

.....
gccflags = -I include -c -fno-builtin
entrypoint = 0x10100
.......
objs = kernel/kernel.o kernel/start.o lib/string.o kernel/i8259.o lib/klib.o kernel/protect.o kernel/global.o kernel/main.o
dasmoutput = kernel.bin.asm
sparrowkernel = kernel.bin
........
$(sparrowkernel) : $(objs)
	ld -s -Ttext $(entrypoint) $(objs) -o $(sparrowkernel) -Map mapfile
.......
kernel/main.o: kernel/main.c include/type.h include/const.h include/protect.h include/string.h include/proc.h include/proto.h \
			include/global.h
	gcc $(gccflags) -o $@ $<
......

Code: Select all

/* write.c---write all the files needed into floppy*/
char buf1[512], buf2[1024], buf3[4096];
int floppy, file;
file=open("./boot/boot.bin",O_RDONLY);
read(file,buf1,512);
close(file);
floppy=open("/dev/fd0",O_RDWR);
lseek(floppy,0,SEEK_SET);
write(floppy,buf1,512);
close(floppy);  

file=open("./boot/setup.bin",O_RDONLY);
read(file,buf2,1024);
close(file);
floppy=open("/dev/fd0",O_RDWR);
lseek(floppy,512,SEEK_SET);
write(floppy,buf2,1024);
close(floppy);

//Note that how many bytes it will read from file to buffer gotta be corresponding with how many bytes the buffer defined. 
file=open("./kernel.bin",O_RDONLY);
read(file,buf3,4096);
close(file);
floppy=open("/dev/fd0",O_RDWR);
lseek(floppy,1536,SEEK_SET);
write(floppy,buf3,4096);
close(floppy);

Code: Select all

;boot.asm---read the floppy and load the files into specific location in memory
;	Load setup.bin to 0x90000;
	mov ax, 0202h
	mov cx, 0002h
	mov dx, 0000h
	mov bx, 9000h
	mov es, bx
	mov bx, 0000h
	int 13h

;	Load kernel.bin to 0x80000;
	mov ax, 0208h
	mov cx, 0004h
	mov dx, 0000h
	mov bx, 8000h
	mov es, bx
	mov bx, 0000h
	int 13h

	jmp 9000h:0000h

Code: Select all

;setup.asm---copy each of segment in kernel.bin to corresponding location according to elf header and program header.. And this part is copied from the other executable program, it probably be fine.
InitKernel:
	xor	esi, esi
	mov	cx, word [080000h + 2Ch]		; ┓ ecx <- pELFHdr->e_phnum
	movzx	ecx, cx								; â”›
	mov	esi, [080000h + 1Ch]				; esi <- pELFHdr->e_phoff
	add	esi, 080000h							; esi <- OffsetOfKernel + pELFHdr->e_phoff
.Begin:
	mov	eax, [esi + 0]
	cmp	eax, 0						; PT_NULL
	jz	.NoAction
	push	dword [esi + 010h]		; size	┓
	mov	eax, [esi + 04h]			;	┃
	add	eax, 080000h			;	┣ ::memcpy(	(void*)(pPHdr->p_vaddr),
	push	eax							; src	┃		uchCode + pPHdr->p_offset,
	push	dword [esi + 08h]		; dst	┃		pPHdr->p_filesz;
	
;.test:
;	mov	edi, (80 * 12 + 3) * 2	
;	mov	ah, 0Ch			; 0000: black background    1100: red foreground
;	mov	al, 'x'
;	mov	[gs:edi], ax
	
	call	MemCpy					;	┃
	add	esp, 12						;	â”›
.NoAction:
	add	esi, 020h					; esi += pELFHdr->e_phentsize
	dec	ecx
	jnz	.Begin