josh/hos
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

Import backup from 2004-08-03

Browse Source
This commit is contained in:
Josh Holtrop 2004-08-03 22:00:00 -04:00
parent a50c2a1233
commit cd02211b21
12 changed files with 270 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
kernel/Makefile
View File

@ -18,7 +18,8 @@ LD_FLAGS=-nodefaultlibs -nostdlib --no-demangle -T link.ld
all: Asm_Kernel C_Kernel
$(LD) $(LD_FLAGS) -Map kernel.map boot.o \
kernel.o asmfuncs.o mm.o vmm.o parallel.o \
conv.o kout.o -o kernel.bin
conv.o kout.o console.o devices.o \
-o kernel.bin
Asm_Kernel:
$(NASM) $(NASM_FLAGS) -l boot.lst boot.asm -o boot.o
@ -31,6 +32,8 @@ C_Kernel:
$(CC) $(CC_FLAGS) -c char/parallel.c -o parallel.o
$(CC) $(CC_FLAGS) -c lang/conv.c -o conv.o
$(CC) $(CC_FLAGS) -c kout.c -o kout.o
$(CC) $(CC_FLAGS) -c char/console.c -o console.o
$(CC) $(CC_FLAGS) -c fs/devices.c -o devices.o
#################################################
# Clean up the source directory of any binaries #

8
kernel/block/rd.c
View File

@ -10,7 +10,7 @@ void rd_init()
}
int rd_register(byte *ramdisk, u32_t size)
int rd_register(byte *ramdisk, u32_t size)
{
int i;
for (i = 0; i < 256; i++)
@ -26,7 +26,7 @@ int rd_register(byte *ramdisk, u32_t size)
return -1;
}
int rd_remove(minor_t minor)
int rd_remove(minor_t minor)
{
if (rd_refs[minor] <= 0)
return -1;
@ -35,7 +35,7 @@ int rd_remove(minor_t minor)
free(ramdisks[minor].start);
}
int rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
int rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
{
if (rd_refs[minor] <= 0)
return -1;
@ -45,7 +45,7 @@ int rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
}
int rd_write_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
int rd_write_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer)
{
}

10
kernel/block/rd.h
View File

@ -11,11 +11,11 @@ typedef struct {
u32_t size;
} ramdisk_t;
void rd_init();
int rd_register(byte *ramdisk, u32_t size);
int rd_remove(minor_t minor);
int rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer);
int rd_write_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer);
void rd_init();
int rd_register(byte *ramdisk, u32_t size);
int rd_remove(minor_t minor);
int rd_read_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer);
int rd_write_block(minor_t minor, u32_t blockNum, u32_t count, byte *buffer);
#endif

211
kernel/char/console.c
View File

@ -1,44 +1,211 @@
// console.c
// Author: Josh Holtrop
// Date: 08/02/04
// Modified: 08/03/04
#include "char/console.h"
#include "hos_defines.h"
#include "fs/devices.h"
#include "mm/vmm.h"
#include "lang/asmfuncs.h"
console_t *consoles[256];
int activeConsole;
int console_new(minor_t minor)
void console_put_char(minor_t id, int c);
void console_write_cursor(minor_t id, u16_t position);
void console_refresh();
// initialization routine for consoles module
int console_init(u32_t num, int width, int height)
{
if (consoles[minor])
return -1; // minor already taken
if ( consoles[minor] = kmalloc(sizeof(console_t)) )
activeConsole = 0;
dev_driver_t *console_driver = New(dev_driver_t);
console_driver->block_read = NULL;
console_driver->block_write = NULL;
console_driver->char_read = NULL;
console_driver->char_write = console_char_write;
devices_register_major('c', MAJOR_CONSOLE, console_driver);
kfree(console_driver);
for (; num > 1; num--)
{
consoles[minor]->cursorPosition = 0;
consoles[minor]->width = 80;
consoles[minor]->height = 25;
consoles[minor]->attribute = 0x07;
if (consoles[minor]->buffer = kmalloc(4000))
if (( consoles[num] = New(console_t) ))
{
memsetw(consoles[minor]->buffer, 0, 2000);
if (( consoles[num]->buffer = kmalloc(width * height) ))
{
consoles[num]->cursorPosition = 0;
consoles[num]->width = width;
consoles[num]->height = height;
consoles[num]->cursorStackPosition = 0;
consoles[num]->escapeLevel = 0;
consoles[num]->escapePosition = 0;
memsetd(consoles[num]->escapeValue, 0, 8);
consoles[num]->attribute = 0x07;
memsetw(consoles[num]->buffer, 0x0720, width * height);
}
else
{
kfree(consoles[num]);
return -2;
}
}
else
{
kfree (consoles[minor]);
consoles[minor] = 0;
return -3; // couldn't allocate memory
}
return -1;
return 0;
}
else
return -2; // couldn't allocate memory
return 0;
}
void console_outb(minor_t id, int c)
int console_activate(int num)
{
if (!consoles[minor])
return;
if (consoles[num])
{
activeConsole = num;
memcpyw((void*)CONSOLE_MEMORY, consoles[num]->buffer, consoles[num]->width * consoles[num]->height);
writeCursorPosition(consoles[num]->cursorPosition);
}
return -1;
}
int console_char_write(minor_t id, u64_t position, int c)
{
if (!consoles[id])
return -1;
int cursorY = consoles[id]->cursorPosition / consoles[id]->width;
int cursorX = consoles[id]->cursorPosition % consoles[id]->width;
switch (consoles[id]->escapeLevel)
{
case 2:
if (c >= '0' && c <= '9') // c is part of an escape value
{
consoles[id]->escapeValue[consoles[id]->escapePosition] *= 10;
consoles[id]->escapeValue[consoles[id]->escapePosition] += c - '0';
return 0;
}
else if (c == ';')
{
if (consoles[id]->escapePosition < 7)
consoles[id]->escapePosition++;
return 0;
}
switch (c)
{
case 'A': // move cursor up n rows
cursorY -= consoles[id]->escapeValue[0];
if (cursorY < 0)
cursorY = 0;
console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
break;
case 'B': // move cursor down n rows
cursorY += consoles[id]->escapeValue[0];
if (cursorY >= consoles[id]->height)
cursorY = consoles[id]->height - 1;
console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
break;
case 'C': // move cursor right n columns
cursorX -= consoles[id]->escapeValue[0];
if (cursorX < 0)
cursorX = 0;
console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
break;
case 'D': // move cursor left n columns
cursorX += consoles[id]->escapeValue[0];
if (cursorX >= consoles[id]->width)
cursorX = consoles[id]->width - 1;
console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
break;
case 'H':
case 'f': // move cursor to position (x,y) upper left is (1,1)
cursorX = consoles[id]->escapeValue[0] - 1;
cursorY = consoles[id]->escapeValue[1] - 1;
if (cursorY < 0)
cursorY = 0;
if (cursorY >= consoles[id]->height)
cursorY = consoles[id]->height - 1;
if (cursorX < 0)
cursorX = 0;
if (cursorX >= consoles[id]->width)
cursorX = consoles[id]->width - 1;
console_write_cursor(id, 0);
break;
case 'J': // clear screen, home cursor
memsetw(consoles[id]->buffer, 0x0720, consoles[id]->width * consoles[id]->height);
console_refresh();
console_write_cursor(id, 0);
break;
case 'K': // erase line from cursor position (including char. under cursor) to end of line
memsetw(consoles[id]->buffer + consoles[id]->cursorPosition, 0x0720, consoles[id]->width - cursorX);
console_refresh();
break;
case 's': // push cursor position on an internal stack
if (consoles[id]->cursorStackPosition < 16)
consoles[id]->cursorStack[consoles[id]->cursorStackPosition++] = consoles[id]->cursorPosition;
break;
case 'u': // pop cursor position from stack
if (consoles[id]->cursorStackPosition > 0)
consoles[id]->cursorPosition = consoles[id]->cursorStack[--consoles[id]->cursorStackPosition];
break;
case 'm': // set text attributes
for (; consoles[id]->escapePosition >= 0; consoles[id]->escapePosition--)
{
switch (consoles[id]->escapeValue[consoles[id]->escapePosition])
{
case 0:
consoles[id]->attribute = 0x07;
break;
case 1:
case 5:
case 7:
case 30:
}
}
break;
}
memsetd(consoles[id]->escapeValue, 0, 8);
consoles[id]->escapePosition = 0;
consoles[id]->escapeLevel = 0;
return 0;
case 1:
if (c == '[')
consoles[id]->escapeLevel = 2;
break;
consoles[id]->escapeLevel = 0;
return 0; // invalid escape sequence
default:
if (c == '\e')
{
consoles[id]->escapeLevel = 1;
return 0;
}
console_put_char(id, c);
}
return 0;
}
void console_put_char(minor_t id, int c)
{
}
void console_write_cursor(minor_t id, u16_t position)
{
consoles[id]->cursorPosition = position;
if (activeConsole == id)
writeCursorPosition(position);
}
void console_refresh()
{
if (activeConsole > 0)
{
memcpyw((void*)CONSOLE_MEMORY, consoles[activeConsole]->buffer, consoles[activeConsole]->width * consoles[activeConsole]->height);
writeCursorPosition(consoles[activeConsole]->cursorPosition);
}
}

15
kernel/char/console.h
View File

@ -1,6 +1,7 @@
// console.h
// Author: Josh Holtrop
// Date: 08/02/04
// Modified: 08/03/04
#ifndef __HOS_CONSOLE__
#define __HOS_CONSOLE__ __HOS_CONSOLE__
@ -10,15 +11,21 @@
typedef struct
{
u32_t cursorPosition;
u32_t escapeValue[8];
u16_t cursorPosition;
u16_t width;
u16_t height;
u8_t attribute;
u16_t *buffer;
u16_t cursorStack[16];
u8_t attribute;
u8_t cursorStackPosition;
char escapeLevel;
char escapePosition;
} console_t;
int console_new(minor_t minor);
void console_outb(minor_t id, int c);
int console_init(u32_t num, int width, int height);
int console_activate(int num);
int console_char_write(minor_t id, u64_t position, int c);
#endif

19
kernel/fs/devices.c
View File

@ -1,6 +1,7 @@
// devices.c
// Author: Josh Holtrop
// Date: 08/02/04
// Modified: 08/03/04
#include "fs/devices.h"
@ -10,16 +11,22 @@ dev_driver_t drivers[256];
char drivers_registered[256]; //0 (unregistered), 'b', 'c'
void dev_init()
void devices_init()
{
}
int dev_register_major(major_t major, dev_driver_t *dev)
int devices_register_major(char type, major_t major, dev_driver_t *dev)
{
if (registered[major])
return -1; //driver already registered
drivers[major] = *dev;
return 0;
if (type == 'b' || type == 'c')
{
if (drivers_registered[major])
return -1; //driver already registered
drivers[major] = *dev;
drivers_registered[major] = type;
return 0;
}
return -1;
}

18
kernel/fs/devices.h
View File

@ -1,23 +1,27 @@
// devices.h
// Author: Josh Holtrop
// Date: 08/02/04
// Modified: 08/03/04
#ifndef __HOS_DEVICES_H__
#define __HOS_DEVICES_H__ __HOS_DEVICES_H__
#include "hos_defines.h"
#define MAJOR_CONSOLE 4
typedef unsigned char major_t;
typedef unsigned char minor_t;
typedef struct {
int (*block_read)(u32_t blockStart, u32_t blocks, void *buffer);
int (*block_write)(u32_t blockStart, u32_t blocks, void *buffer);
int (*char_read)(u64_t position);
int (*char_write)(u64_t position, int value);
int (*block_read)(minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
int (*block_write)(minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
int (*char_read)(minor_t minor, u64_t position);
int (*char_write)(minor_t minor, u64_t position, int value);
} dev_driver_t;
void dev_init();
int dev_register_major(major_t major, dev_driver_t *dev);
void devices_init();
int devices_register_major(char type, major_t major, dev_driver_t *dev);
#endif

2
kernel/hos_defines.h
View File

@ -16,6 +16,8 @@
#define NULL 0
#define New(x) kmalloc(sizeof(x))
typedef unsigned long long u64_t;
typedef unsigned int u32_t;
typedef unsigned short u16_t;

35
kernel/kernel.c
View File

@ -9,6 +9,8 @@
#include "char/parallel.h"
#include "kout.h"
#include "lang/conv.h"
#include "char/console.h"
#include "fs/devices.h"
mb_info_t mb_info_block;
mb_mmap_t mb_mmap[MAX_MMAP];
@ -83,42 +85,17 @@ int k_mbsave(mb_info_t *mbinfo, unsigned int mb_magic)
/* Main kernel initialization routine */
void k_init()
{
kprintf("k_init()\n");
k_enter_critical();
criticalCounter++;
mm_init();
vmm_init();
devices_init();
console_init(6, 80, 25);
console_activate(1);
if (real_mode_module)
{
kprintf("Real mode module present\n");
}
u32_t alloc_size = 1;
void *addresses[32];
memsetd(addresses, 0, 32);
void *address;
int i;
for (i = -5; i < 5; i++)
{
kprintf("Counting down... %d\t0x%x\t%u\n", i, i, i);
}
for (i = 0; i < 32; i++)
{
kprintf("\e[31mAllocating %u (0x%x) bytes\e[0m,\tmm_freepages = %u...\n", alloc_size, alloc_size, mm_freepages);
address = kmalloc(alloc_size);
if (!address)
break;
addresses[i] = address;
alloc_size <<= 1;
}
for (i = 0; i < 32; i++)
{
if (!addresses[i])
break;
kprintf("\e[32mFreeing 0x%x\e[0m,\tmm_freepages = %u...\n", addresses[i], mm_freepages);
kfree(addresses[i]);
}
// dev_init();
kprintf("End of k_init()\n");
criticalCounter--;
}

2
kernel/kout.h
View File

@ -7,7 +7,7 @@
#include "hos_defines.h"
void printf(char *fmt, ...);
void kprintf(char *fmt, ...);
void putHex(u32_t number);
void kio_putBCD(u32_t bcd);
void putc(int c);

23
kernel/lang/asmfuncs.asm
View File

@ -134,6 +134,29 @@ _memcpy:
ret
;copies memory of n words (n*2 bytes) from src to destination
;void memcpyw(void *dest, void *src, dword n);
[global _memcpyw]
_memcpyw:
push ebp
mov ebp, esp
push esi
push edi
push ecx
mov edi, [ebp+8]
mov esi, [ebp+12]
mov ecx, [ebp+16]
cld
rep movsw
pop ecx
pop edi
pop esi
pop ebp
ret
;copies memory of n dwords (n*4 bytes) from src to destination
;void memcpyd(void *dest, void *src, dword n);
[global _memcpyd]

1
kernel/lang/asmfuncs.h
View File

@ -15,6 +15,7 @@ void writeCursorPosition(u32_t pos);
u32_t getCursorPosition();
void strcpy(char *dest, const char *src);
void memcpy(void *dest, const void *src, u32_t n);
void memcpyw(void *dest, const void *src, u32_t n);
void memcpyd(void *dest, const void *src, u32_t n);
void *memset(void *buffer, int c, int num);
void *memsetw(void *buffer, int c, int num);