epita-std/kaneton
Archived
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Use a static variable to store idt

Browse Source
This commit is contained in:
Mercier Pierre-Olivier 2013-02-16 23:11:04 +01:00
parent 592c7d5882
commit 832e42fd0a
6 changed files with 30 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
kaneton/machine/architecture/ia32/educational/idt.c
View File

@ -28,14 +28,10 @@
#include <kaneton.h>
/*
* ---------- externs ---------------------------------------------------------
* ---------- globals ---------------------------------------------------------
*/
/*
* the segment manager which contains the current IDT.
*/
extern m_segment _segment;
at_idte _idt[ARCHITECTURE_IDT_SIZE];
/*
* ---------- functions -------------------------------------------------------
@ -49,31 +45,30 @@ t_error architecture_idt_dump(void)
module_call(console, message,
'#', "IDT: table(0x%08x) size(%u)\n",
_segment.machine.idt.table,
_segment.machine.idt.size);
_idt, ARCHITECTURE_IDT_SIZE);
for (i = 0; i < _segment.machine.idt.size; i++)
for (i = 0; i < ARCHITECTURE_IDT_SIZE; i++)
{
t_privilege privilege;
t_paddr offset;
char* type;
char flag;
if (!(_segment.machine.idt.table[i] & ARCHITECTURE_IDTE_PRESENT))
if (!(_idt[i] & ARCHITECTURE_IDTE_PRESENT))
continue;
offset = ARCHITECTURE_IDTE_OFFSET_GET(_segment.machine.idt.table[i]);
offset = ARCHITECTURE_IDTE_OFFSET_GET(_idt[i]);
privilege = ARCHITECTURE_IDTE_DPL_GET(_segment.machine.idt.table[i]);
privilege = ARCHITECTURE_IDTE_DPL_GET(_idt[i]);
if (_segment.machine.idt.table[i] & ARCHITECTURE_GDTE_32BIT)
if (_idt[i] & ARCHITECTURE_GDTE_32BIT)
flag = 's';
else
flag = '.';
if ((_segment.machine.idt.table[i] & ARCHITECTURE_IDTE_TRAP) == ARCHITECTURE_IDTE_TRAP)
if ((_idt[i] & ARCHITECTURE_IDTE_TRAP) == ARCHITECTURE_IDTE_TRAP)
type = "trap";
else if ((_segment.machine.idt.table[i] & ARCHITECTURE_IDTE_INTERRUPT) == ARCHITECTURE_IDTE_INTERRUPT)
else if ((_idt[i] & ARCHITECTURE_IDTE_INTERRUPT) == ARCHITECTURE_IDTE_INTERRUPT)
type = "interrupt";
else
type = "task";
@ -87,61 +82,23 @@ t_error architecture_idt_dump(void)
MACHINE_LEAVE();
}
t_error architecture_idt_import(as_idt* idt)
{
as_idtr idtr;
if (idt == NULL)
MACHINE_ESCAPE("the 'idt' argument is null");
idtr.base = (t_paddr)idt->table;
idtr.limit = idt->size * sizeof (at_idte);
ARCHITECTURE_LIDT(idtr);
memcpy(&_segment.machine.idt, idt, sizeof (as_idt));
MACHINE_LEAVE();
}
t_error architecture_idt_export(as_idt* idt)
{
as_idtr idtr;
at_idte* source;
at_idte* dest;
if (idt == NULL)
MACHINE_ESCAPE("the 'idt' argument is null");
ARCHITECTURE_SIDT(idtr);
source = (at_idte*)idtr.base;
dest = idt->table;
memcpy(dest, source, idtr.limit);
idt->size = idtr.limit / sizeof (at_idte);
MACHINE_LEAVE();
}
t_error architecture_idt_insert(t_uint16 index,
t_paddr offset,
t_flags flags)
{
if (index >= _segment.machine.idt.size)
if (index >= ARCHITECTURE_IDT_SIZE)
MACHINE_ESCAPE("out-of-bound insertion");
if (_segment.machine.idt.table[index] & ARCHITECTURE_IDTE_PRESENT)
if (_idt[index] & ARCHITECTURE_IDTE_PRESENT)
MACHINE_ESCAPE("the IDT entry to update is already in use");
_segment.machine.idt.table[index] =
/*
_idt[index] =
ARCHITECTURE_IDTE_INTERRUPT |
ARCHITECTURE_IDTE_PRESENT |
ARCHITECTURE_IDTE_OFFSET_SET(offset) |
ARCHITECTURE_IDTE_32BIT |
flags;
*/
MACHINE_LEAVE();
}
@ -156,8 +113,8 @@ t_error architecture_idt_reserve(t_paddr base,
*index = 0;
for (i = 0; i < _segment.machine.idt.size; i++)
if (!(_segment.machine.idt.table[i] & ARCHITECTURE_IDTE_PRESENT))
for (i = 0; i < ARCHITECTURE_IDT_SIZE; i++)
if (!(_idt[i] & ARCHITECTURE_IDTE_PRESENT))
{
*index = i;
@ -172,35 +129,20 @@ t_error architecture_idt_reserve(t_paddr base,
t_error architecture_idt_delete(t_uint16 index)
{
if (index >= _segment.machine.idt.size)
if (index >= ARCHITECTURE_IDT_SIZE)
MACHINE_ESCAPE("out-of-bound insertion");
if (!(_segment.machine.idt.table[index] & ARCHITECTURE_IDTE_PRESENT))
if (!(_idt[index] & ARCHITECTURE_IDTE_PRESENT))
MACHINE_ESCAPE("the IDT entry to delete is not present");
memset(&_segment.machine.idt.table[index], 0x0, sizeof (at_idte));
memset(&_idt[index], 0x0, sizeof (at_idte));
MACHINE_LEAVE();
}
t_error architecture_idt_build(t_paddr base,
t_psize size,
as_idt* idt)
t_error architecture_idt_build()
{
if (idt == NULL)
MACHINE_ESCAPE("the 'idt' argument is null");
if (size > (ARCHITECTURE_IDT_SIZE * sizeof (at_idte)))
MACHINE_ESCAPE("the given size is too large as exceeding the IDT's "
"theoretically maximum capacity");
if (base % sizeof (at_idte))
base += sizeof (at_idte) - (base % sizeof (at_idte));
idt->table = (at_idte*)base;
idt->size = size / sizeof (at_idte);
memset(idt->table, 0x0, idt->size * sizeof (at_idte));
memset(_idt, 0x0, ARCHITECTURE_IDT_SIZE * sizeof (at_idte));
MACHINE_LEAVE();
}

2
kaneton/machine/architecture/ia32/educational/include/handler.h
View File

@ -53,6 +53,8 @@
* ../handler.c
*/
void handler(int num);
/*
* eop

19
kaneton/machine/architecture/ia32/educational/include/idt.h
View File

@ -142,12 +142,6 @@
typedef t_uint64 at_idte;
typedef struct
{
at_idte* table;
t_uint16 size;
} as_idt;
typedef struct
{
t_uint16 limit;
@ -166,16 +160,8 @@ typedef struct
t_error architecture_idt_dump(void);
t_error architecture_idt_build(t_paddr base,
t_psize size,
as_idt* idt);
t_error architecture_idt_import(as_idt* idt);
t_error architecture_idt_export(as_idt* idt);
t_error architecture_idt_insert(t_uint16 index,
t_paddr base,
t_paddr offset,
t_flags flags);
t_error architecture_idt_reserve(t_paddr base,
@ -184,6 +170,9 @@ t_error architecture_idt_reserve(t_paddr base,
t_error architecture_idt_delete(t_uint16 index);
t_error architecture_idt_build();
/*
* eop
*/

14
kaneton/machine/glue/ibm-pc.ia32/educational/event.c
View File

@ -47,15 +47,6 @@ d_event glue_event_dispatch =
/* FIXED at K1 */
/*
* ---------- globals ---------------------------------------------------------
*/
/*
* the init structure.
*/
extern m_segment* _segment;
/*
* ---------- functions -------------------------------------------------------
*/
@ -63,11 +54,8 @@ extern m_segment* _segment;
t_error glue_event_initialize(void)
{
t_uint16 i;
as_idt idt;
if (architecture_idt_build((t_paddr) &_segment->machine.idt,
ARCHITECTURE_IDT_SIZE * sizeof (at_idte),
&idt) != ERROR_OK)
if (architecture_idt_build() != ERROR_OK)
MACHINE_ESCAPE("unable to initialize the IDT");
architecture_idt_insert(i, (t_uint32) &idt_wrapper_0, ARCHITECTURE_IDTE_DPL_SET(ARCHITECTURE_PRIVILEGE_RING0));

7
kaneton/machine/glue/ibm-pc.ia32/educational/include/event.h
View File

@ -75,14 +75,9 @@
* ../event.c
*/
t_error glue_event_reserve(i_event id,
t_type type,
u_event_handler handler,
t_data data);
t_error glue_event_initialize(void);
/*
* eop
*/

1
kaneton/machine/glue/ibm-pc.ia32/educational/include/segment.h
View File

@ -49,7 +49,6 @@
struct \
{ \
as_gdt gdt; \
as_idt idt; \
} machine;
/*