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

Import backup from 2004-08-15

Browse Source
This commit is contained in:
Josh Holtrop 2004-08-15 22:00:00 -04:00
parent b9c77827bd
commit 8a8f56decb
16 changed files with 539 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile
View File

@ -7,6 +7,9 @@ FLOPPY_MOUNT=./mnt_flp
FLOPPY_IMAGE=hos.flp
GRUB_IMAGE=grub.flp
# Do not print "Entering directory ..."
MAKEFLAGS += --no-print-directory
all:
make -C kernel
# make -C rmmod

7
kernel/Makefile
View File

@ -18,7 +18,7 @@ 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 console.o devices.o \
conv.o kout.o vconsole.o console.o devices.o \
-o kernel.bin
Asm_Kernel:
@ -32,13 +32,14 @@ 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 char/vconsole.c -o vconsole.o
$(CC) $(CC_FLAGS) -c fs/devices.c -o devices.o
$(CC) $(CC_FLAGS) -c console.c -o console.o
#################################################
# Clean up the source directory of any binaries #
#################################################
clean:
- rm *.o *.bin *.map *.lst *.out *~
- rm *.o *.bin *.map *.lst *.out *~ fs/*~ sys/*~ block/*~ char/*~ lang/*~ mm/*~

207
kernel/char/console.c
View File

@ -1,207 +0,0 @@
// 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;
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)
{
activeConsole = 0;
dev_driver_t *console_driver = New(dev_driver_t);
console_driver->char_write = console_char_write;
devices_register_major('c', MAJOR_CONSOLE, console_driver);
kfree(console_driver);
for (; num > 1; num--)
{
if (( consoles[num] = New(console_t) ))
{
if (( consoles[num]->buffer = kmalloc(width * height) ))
{
consoles[num]->width = width;
consoles[num]->height = height;
consoles[num]->attribute = consoles[num]->foreground = 0x07;
memsetw(consoles[num]->buffer, 0x0720, width * height);
}
else
{
kfree(consoles[num]);
return -2;
}
}
else
return -1;
}
return 0;
}
int console_activate(int num)
{
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:
consoles[id]->attribute |= 0x08;
break;
case 5:
consoles[id]->attribute |= 0x80;
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);
}
}

24
kernel/char/parallel.c
View File

@ -1,15 +1,35 @@
// parallel.c
// Author: Josh Holtrop
// Date: 08/02/04
// Modified: 08/16/04
#include "hos_defines.h"
#include "functions.h"
#include "parallel.h"
#include "char/parallel.h"
#include "fs/devices.h"
#include "mm/vmm.h"
void outparb(int c)
// initialization routine for vconsoles module
int parallel_init(major_t major)
{
dev_driver_t *parallel_driver;
if (( parallel_driver = New(dev_driver_t) ))
{
parallel_driver->char_write = parallel_char_write;
devices_register_major('c', major, parallel_driver);
return 0;
}
return -1;
}
int parallel_char_write(minor_t minor, int c)
{
if (minor == 0)
{
outportb(0x37a, 0xc);
outportb(0x378, c);
outportb(0x37a, 0x1);
}
return 0;
}

4
kernel/char/parallel.h
View File

@ -6,8 +6,10 @@
#define __HOS_PARALLEL__ __HOS_PARALLEL__
#include "hos_defines.h"
#include "fs/devices.h"
void outparb(int c);
int parallel_init(major_t major);
int parallel_char_write(minor_t minor, int c);
#endif

293
kernel/char/vconsole.c Normal file
View File

@ -0,0 +1,293 @@
// vconsole.c
// Author: Josh Holtrop
// Date: 08/02/04
// Modified: 08/07/04
#include "char/vconsole.h"
#include "hos_defines.h"
#include "fs/devices.h"
#include "mm/vmm.h"
#include "lang/asmfuncs.h"
#include "console.h"
vconsole_t *vconsoles[VCONSOLE_MAX]; // pointer to virtual console structs
extern int activeConsole; // console subsystem active virtual console number
void vconsole_put_char(minor_t id, int c);
void vconsole_update_cursor(minor_t id, u16_t position);
void vconsole_update_attribute(minor_t id);
void vconsole_refresh(minor_t id);
// initialization routine for vconsoles module
int vconsole_init(major_t major)
{
dev_driver_t *vconsole_driver;
if (( vconsole_driver = New(dev_driver_t) ))
{
vconsole_driver->char_write = vconsole_char_write;
devices_register_major('c', major, vconsole_driver);
return 0;
}
return -1;
}
// routine to create a new virtual console object
minor_t vconsole_new(int width, int height)
{
int i;
for (i = 1; i < VCONSOLE_MAX; i++)
{
if ( (!vconsoles[i]) && ( vconsoles[i] = kcalloc(1, sizeof(vconsole_t)))) //New(vconsole_t) ) )
{
if (( vconsoles[i]->buffer = kmalloc(width * height * 2) ))
{
vconsoles[i]->width = width;
vconsoles[i]->height = height;
vconsoles[i]->attribute = vconsoles[i]->foreground = 0x07;
memsetw(vconsoles[i]->buffer, 0x0720, width * height);
// register the device as /dev/console%d
return i;
}
else
{
kfree(vconsoles[i]);
return 0;
}
}
}
return 0;
}
// called by console subsystem to draw a virtual console to the screen
int vconsole_draw(minor_t id)
{
if (vconsoles[id])
return console_draw(id, vconsoles[id]->cursorPosition, vconsoles[id]->buffer);
return -1;
}
// called by character device driver when a character is written to device w/ minor #id
int vconsole_char_write(minor_t id, int c)
{
if (!vconsoles[id])
return -1;
int cursorY = vconsoles[id]->cursorPosition / vconsoles[id]->width;
int cursorX = vconsoles[id]->cursorPosition % vconsoles[id]->width;
switch (vconsoles[id]->escapeLevel)
{
case 2:
if (c >= '0' && c <= '9') // c is part of an escape value
{
vconsoles[id]->escapeValue[vconsoles[id]->escapePosition] *= 10;
vconsoles[id]->escapeValue[vconsoles[id]->escapePosition] += c - '0';
return 0;
}
else if (c == ';')
{
if (vconsoles[id]->escapePosition < 7)
vconsoles[id]->escapePosition++;
return 0;
}
switch (c)
{
case 'A': // move cursor up n rows
cursorY -= vconsoles[id]->escapeValue[0];
if (cursorY < 0)
cursorY = 0;
vconsole_update_cursor(id, cursorY * vconsoles[id]->width +
cursorX);
break;
case 'B': // move cursor down n rows
cursorY += vconsoles[id]->escapeValue[0];
if (cursorY >= vconsoles[id]->height)
cursorY = vconsoles[id]->height - 1;
vconsole_update_cursor(id, cursorY * vconsoles[id]->width +
cursorX);
break;
case 'C': // move cursor right n columns
cursorX -= vconsoles[id]->escapeValue[0];
if (cursorX < 0)
cursorX = 0;
vconsole_update_cursor(id, cursorY * vconsoles[id]->width +
cursorX);
break;
case 'D': // move cursor left n columns
cursorX += vconsoles[id]->escapeValue[0];
if (cursorX >= vconsoles[id]->width)
cursorX = vconsoles[id]->width - 1;
vconsole_update_cursor(id, cursorY * vconsoles[id]->width +
cursorX);
break;
case 'H':
case 'f': // move cursor to position (x,y) upper left is (1,1)
cursorX = vconsoles[id]->escapeValue[0] - 1;
cursorY = vconsoles[id]->escapeValue[1] - 1;
if (cursorY < 0)
cursorY = 0;
if (cursorY >= vconsoles[id]->height)
cursorY = vconsoles[id]->height - 1;
if (cursorX < 0)
cursorX = 0;
if (cursorX >= vconsoles[id]->width)
cursorX = vconsoles[id]->width - 1;
vconsole_update_cursor(id, 0);
break;
case 'J': // clear screen, home cursor
memsetw(vconsoles[id]->buffer, 0x0720, vconsoles[id]->width * vconsoles[id]->height);
vconsole_draw(id);
vconsole_update_cursor(id, 0);
break;
case 'K': // erase line from cursor position (including char. under cursor) to end of line
memsetw(vconsoles[id]->buffer +
vconsoles[id]->cursorPosition, 0x0720, vconsoles[id]->width - cursorX);
vconsole_draw(id);
break;
case 's': // push cursor position on an internal stack
if (vconsoles[id]->cursorStackPosition < 16)
vconsoles[id]->cursorStack[vconsoles[id]->cursorStackPosition++] = vconsoles[id]->cursorPosition;
break;
case 'u': // pop cursor position from stack
if (vconsoles[id]->cursorStackPosition > 0)
{
vconsole_update_cursor(id, vconsoles[id]->cursorStack[--vconsoles[id]->cursorStackPosition]);
}
break;
case 'm': // set text attributes
for (; vconsoles[id]->escapePosition; vconsoles[id]->escapePosition--)
{
switch (vconsoles[id]->escapeValue[vconsoles[id]->escapePosition])
{
case 0:
vconsoles[id]->foreground = 0x07;
vconsoles[id]->background = 0x00;
vconsoles[id]->concealed = 0;
vconsoles[id]->reverse = 0;
vconsoles[id]->blink = 0;
vconsoles[id]->bold = 0;
vconsole_update_attribute(id);
break;
case 1:
vconsoles[id]->bold = 1;
vconsole_update_attribute(id);
break;
case 5:
vconsoles[id]->blink = 1;
vconsole_update_attribute(id);
break;
case 7:
vconsoles[id]->reverse = 1;
vconsole_update_attribute(id);
break;
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
vconsoles[id]->foreground = vconsoles[id]->escapeValue[vconsoles[id]->escapePosition] - 30;
vconsole_update_attribute(id);
break;
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
vconsoles[id]->background = vconsoles[id]->escapeValue[vconsoles[id]->escapePosition] - 30;
vconsole_update_attribute(id);
break;
}
}
break;
}
memsetd(vconsoles[id]->escapeValue, 0, 8);
vconsoles[id]->escapePosition = 0;
vconsoles[id]->escapeLevel = 0;
return 0;
case 1:
if (c == '[')
vconsoles[id]->escapeLevel = 2;
break;
vconsoles[id]->escapeLevel = 0;
return 0; // invalid escape sequence
default:
if (c == '\e')
{
vconsoles[id]->escapeLevel = 1;
return 0;
}
vconsole_put_char(id, c);
}
return 0;
}
// write the character to the virtual console
void vconsole_put_char(minor_t id, int c)
{
if (!vconsoles[id]->concealed)
{
switch (c)
{
case '\t':
if (vconsoles[id]->cursorPosition % 8)
vconsoles[id]->cursorPosition += (8 - (vconsoles[id]->cursorPosition % 8));
else
vconsoles[id]->cursorPosition += 8;
if (id == activeConsole)
console_update_cursor(id, vconsoles[id]->cursorPosition);
break;
case '\n':
if (vconsoles[id]->cursorPosition % (vconsoles[id]->width))
vconsoles[id]->cursorPosition += (vconsoles[id]->width - (vconsoles[id]->cursorPosition % vconsoles[id]->width));
else
vconsoles[id]->cursorPosition += vconsoles[id]->width;
if (id == activeConsole)
console_update_cursor(id, vconsoles[id]->cursorPosition);
break;
default:
vconsoles[id]->buffer[vconsoles[id]->cursorPosition << 1] = c | (vconsoles[id]->attribute << 8);
if (id == activeConsole)
console_put_char(id, c | (vconsoles[id]->attribute << 8), vconsoles[id]->cursorPosition);
vconsoles[id]->cursorPosition++;
if (id == activeConsole)
console_update_cursor(id, vconsoles[id]->cursorPosition);
}
}
}
void vconsole_update_cursor(minor_t id, u16_t position)
{
vconsoles[id]->cursorPosition = position;
if (activeConsole == id)
console_update_cursor(id, position);
}
void vconsole_update_attribute(minor_t id)
{
if (vconsoles[id]->reverse)
{
vconsoles[id]->attribute =
vconsoles[id]->blink << 7 |
vconsoles[id]->foreground << 4 |
vconsoles[id]->bold << 3 |
vconsoles[id]->background;
}
else
{
vconsoles[id]->attribute =
vconsoles[id]->blink << 7 |
vconsoles[id]->background << 4 |
vconsoles[id]->bold << 3 |
vconsoles[id]->foreground;
}
}

29
kernel/char/console.h → kernel/char/vconsole.h
View File

@ -1,22 +1,25 @@
// console.h
// vconsole.h
// Author: Josh Holtrop
// Date: 08/02/04
// Modified: 08/03/04
// Modified: 08/07/04
#ifndef __HOS_CONSOLE__
#define __HOS_CONSOLE__ __HOS_CONSOLE__
#ifndef __HOS_VCONSOLE__
#define __HOS_VCONSOLE__ __HOS_VCONSOLE__
#include "hos_defines.h"
#include "fs/devices.h"
#define VCONSOLE_MAX 16
typedef struct
{
u16_t *buffer;
u32_t escapeValue[8];
u16_t cursorPosition;
u16_t width;
u16_t height;
u16_t *buffer;
u16_t cursorStack[16];
u8_t attribute;
u8_t foreground;
u8_t background;
@ -24,14 +27,16 @@ typedef struct
u8_t reverse;
u8_t blink;
u8_t concealed;
u8_t cursorStackPosition;
char escapeLevel;
char escapePosition;
} console_t;
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);
u8_t cursorStackPosition;
u8_t escapeLevel;
u8_t escapePosition;
} vconsole_t;
int vconsole_init(major_t major);
minor_t vconsole_new(int width, int height);
int vconsole_draw(minor_t id);
int vconsole_char_write(minor_t id, int c);
#endif

81
kernel/console.c Normal file
View File

@ -0,0 +1,81 @@
// console.c
// Author: Josh Holtrop
// Date: 08/07/04
#include "fs/devices.h"
#include "char/vconsole.h"
#include "console.h"
#include "lang/asmfuncs.h"
int activeConsole;
int numConsoles;
// initialization routine for console subsystem
int console_init(int num)
{
int i;
activeConsole = 0;
for (i = 0; i < num; i++)
{
minor_t vc = vconsole_new(80, 25);
if (vc)
{
numConsoles++;
if (!activeConsole)
activeConsole = vc;
}
}
if (numConsoles)
return 0;
return -1;
}
// activate a virtual console
int console_activate(minor_t id)
{
if (id > 0 && id <= numConsoles)
{
activeConsole = id;
return vconsole_draw(id);
}
return -1;
}
// routine to refresh a console window
int console_draw(minor_t id, int cursorPosition, u16_t *buffer)
{
if (id == activeConsole)
{
memcpyw((void *)CONSOLE_MEMORY, buffer, 2000);
writeCursorPosition(cursorPosition);
return 0;
}
return -1;
}
// write a character to the screen
int console_put_char(minor_t id, u16_t c, int position)
{
if (id == activeConsole)
{
*(u16_t *)(CONSOLE_MEMORY + (position << 1)) = c;
return 0;
}
return -1;
}
// move the cursor on the screen
int console_update_cursor(minor_t id, int cursorPosition)
{
if (id == activeConsole)
{
writeCursorPosition(cursorPosition);
return 0;
}
return -1;
}

19
kernel/console.h Normal file
View File

@ -0,0 +1,19 @@
// console.h
// Author: Josh Holtrop
// Date: 08/07/04
#ifndef __HOS_CONSOLE__
#define __HOS_CONSOLE__ __HOS_CONSOLE__
#include "hos_defines.h"
#include "fs/devices.h"
int console_init(int num);
int console_activate(minor_t id);
int console_draw(minor_t id, int cursorPosition, u16_t *buffer);
int console_put_char(minor_t id, u16_t c, int position);
int console_update_cursor(minor_t id, int cursorPosition);
#endif

62
kernel/fs/devices.c
View File

@ -1,32 +1,70 @@
// devices.c
// Author: Josh Holtrop
// Date: 08/02/04
// Modified: 08/03/04
// Modified: 08/07/04
#include "fs/devices.h"
#include "kernel.h"
#include "char/parallel.h"
#include "char/vconsole.h"
dev_driver_t drivers[256];
char drivers_registered[256]; //0 (unregistered), 'b', 'c'
dev_driver_t *drivers[2][256];
// initialization routine for devices subsystem
void devices_init()
{
parallel_init(MAJORC_PARALLEL);
vconsole_init(MAJORC_VCONSOLE);
}
int devices_register_major(char type, major_t major, dev_driver_t *dev)
{
if (type == 'b' || type == 'c')
{
if (drivers_registered[major])
return -1; //driver already registered
drivers[major] = *dev;
drivers_registered[major] = type;
return 0;
}
int idx;
if (type == 'b')
idx = 0;
else if (type == 'c')
idx = 1;
else
return -1;
if (drivers[idx][major])
return -2; //driver already registered
drivers[idx][major] = dev;
return 0;
}
int block_read(major_t major, minor_t minor, u32_t blockStart, u32_t blocks, void *buffer)
{
if (drivers[0][major] && drivers[0][major]->block_read)
return drivers[0][major]->block_read(minor, blockStart, blocks, buffer);
return INT_MIN;
}
int block_write(major_t major, minor_t minor, u32_t blockStart, u32_t blocks, void *buffer)
{
if (drivers[0][major] && drivers[0][major]->block_write)
return drivers[0][major]->block_write(minor, blockStart, blocks, buffer);
return INT_MIN;
}
int char_read(major_t major, minor_t minor)
{
if (drivers[1][major] && drivers[1][major]->char_read)
return drivers[1][major]->char_read(minor);
return INT_MIN;
}
int char_write(major_t major, minor_t minor, int c)
{
if (drivers[1][major] && drivers[1][major]->char_write)
return drivers[1][major]->char_write(minor, c);
return INT_MIN;
}

15
kernel/fs/devices.h
View File

@ -1,14 +1,15 @@
// devices.h
// Author: Josh Holtrop
// Date: 08/02/04
// Modified: 08/03/04
// Modified: 08/07/04
#ifndef __HOS_DEVICES_H__
#define __HOS_DEVICES_H__ __HOS_DEVICES_H__
#include "hos_defines.h"
#define MAJOR_CONSOLE 4
#define MAJORC_VCONSOLE 4
#define MAJORC_PARALLEL 6
typedef unsigned char major_t;
typedef unsigned char minor_t;
@ -16,12 +17,18 @@ typedef unsigned char minor_t;
typedef struct {
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);
int (*char_read)(minor_t minor);
int (*char_write)(minor_t minor, int c);
} dev_driver_t;
void devices_init();
int devices_register_major(char type, major_t major, dev_driver_t *dev);
int block_read(major_t major, minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
int block_write(major_t major, minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
int char_read(major_t major, minor_t minor);
int char_write(major_t major, minor_t minor, int c);
#endif

1
kernel/hos_defines.h
View File

@ -15,6 +15,7 @@
#define MAX_MMAP 16
#define NULL 0
#define INT_MIN -42
#define New(x) kcalloc(1, sizeof(x))

29
kernel/kernel.c
View File

@ -9,8 +9,9 @@
#include "char/parallel.h"
#include "kout.h"
#include "lang/conv.h"
#include "char/console.h"
#include "char/vconsole.h"
#include "fs/devices.h"
#include "console.h"
mb_info_t mb_info_block;
mb_mmap_t mb_mmap[MAX_MMAP];
@ -88,9 +89,29 @@ void k_init()
criticalCounter++;
mm_init();
vmm_init();
// test the memory manager
/* char *all;
int size = 1;
u32_t add = 1;
for (;;)
{
all = kmalloc(size);
add = (u32_t)all;
if (!add)
break;
u32_t pte = (add >> 12) & 0x3FF;
u32_t pde = add >> 22;
u32_t mapped = *((u32_t *)(0xFFC00000 | (pde << 12) | (pte << 2)));
kprintf("Got address 0x%x mapped to 0x%x size=%d\n", add, mapped, size);
memset(all, 0, size);
size <<= 1;
}*/
devices_init();
// console_init(6, 80, 25);
// console_activate(1);
console_init(6);
console_activate(1);
kprintf("We can finally see text!\n");
while (1)
(*(u16_t *)CONSOLE_MEMORY)++;
if (real_mode_module)
{
kprintf("Real mode module present\n");
@ -109,7 +130,7 @@ void k_init()
void isr(u32_t num)
{
criticalCounter++;
kprintf("Interrupt #%d!\n", num);
kprintf("Interrupt #%d, CR2 = 0x%x!\n", num, read_cr2());
halt();
switch (num)
{

4
kernel/kout.c
View File

@ -6,6 +6,7 @@
#include "char/parallel.h"
#include "kout.h"
#include "lang/conv.h"
#include "fs/devices.h"
char buffer[64];
@ -13,8 +14,9 @@ char buffer[64];
void putc(int c)
{
#ifdef PARALLEL_DEBUG
outparb(c);
char_write(MAJORC_PARALLEL, 0, c);
#endif
char_write(MAJORC_VCONSOLE, 1, c);
}

2
kernel/mm/mm.c
View File

@ -44,7 +44,7 @@ void mm_init()
}
}
}
mm_preserven(PHYS_LOAD, ((u32_t)&_end - (u32_t)&start) >> 12); //reserve kernel memory
mm_preserven(PHYS_LOAD, (((u32_t)&_end - (u32_t)&start) >> 12) + 1); //reserve kernel memory
int i;
for (i = 0; i < mb_info_block.mods_count; i++) //reserve module memory
{

2
kernel/mm/vmm.c
View File

@ -80,10 +80,12 @@ int vmm_map1(u32_t virt, u32_t physical)
if (!(newpagetable = mm_palloc()))
return -1; //out of physical memory
pageTables[pde] = newpagetable | 0x03;
invlpg_(0xFFFFF000 + (pde << 2));
invlpg_(virt); //in case it was cached, so we can fill page table safely
memsetd((void*)(0xFFC00000 | (pde << 12)), 0, 1024); //zero out new page table
}
*(u32_t *)(0xFFC00000 | (pde << 12) | (pte << 2)) = (physical & 0xFFFFF000) | 0x03;
invlpg_((0xFFC00000 | (pde << 12) | (pte << 2)));
invlpg_(virt);
return 0;
}