Beispiel #1
0
Datei: gdt.c Projekt: mvanga/zion
void gdt_init(void)
{
	gdt_ptr.limit = (sizeof(uint64_t) * 3) - 1;
	gdt_ptr.base  = (uint32_t)&gdt_table;

	gdt_set(0, 0, 0, 0, 0);			/* Null segment */ 
	gdt_set(1, 0, 0xFFFFFFFF, 0x9A, 0xCF);	/* Code segment */ 
	gdt_set(2, 0, 0xFFFFFFFF, 0x92, 0xCF);	/* Data segment */ 

	gdt_write((uint32_t)&gdt_ptr);
}
Beispiel #2
0
void init_gdt()
{
	gdt_ptr.size = (sizeof(gdt_entry_t) * 6) - 1;
	gdt_ptr.base = (u32int)&gdt_entries;

	gdt_set(0, 0, 0, 0, 0);					// Null segment
	gdt_set(1, 0, 0xFFFFFFFF, 0x9A, 0xCF);	// Code segment
	gdt_set(2, 0, 0xFFFFFFFF, 0x92, 0xCF);	// Data segment
	gdt_set(3, 0, 0xFFFFFFFF, 0xFA, 0xCF);	// User mode code segment
	gdt_set(4, 0, 0xFFFFFFFF, 0xF2, 0xCF);	// User mode data segment
	write_tss(5, 0x10, 0x0);

	gdt_flush((u32int)&gdt_ptr);
	tss_flush();
}
Beispiel #3
0
void
gdt_initialize (void)
{
  // Null Descriptor
  set_gate (GDT_NLSEG / sizeof(gdt_entry_t), 0, 0, 0, 0);
  
  // Kernel Code Segment
  set_gate (GDT_KCSEG / sizeof(gdt_entry_t), 0, 0xFFFFFFFF, 0x9A, GDT_FLAGS); 
  
  // Kernel Data Segment
  set_gate (GDT_KDSEG / sizeof(gdt_entry_t), 0, 0xFFFFFFFF, 0x92, GDT_FLAGS);

  // User Code Segment
  set_gate (GDT_UCSEG / sizeof(gdt_entry_t), 0, 0xFFFFFFFF, 0xFA, GDT_FLAGS);
  
  // User Data Segment
  set_gate (GDT_UDSEG / sizeof(gdt_entry_t), 0, 0xFFFFFFFF, 0xF2, GDT_FLAGS);  
  
  // TSS
  // TODO.

  
  gdt_ptr_t gdt_ptr;
  
  gdt_ptr.limit = sizeof(gdt_entry_t) * GDT_NUM_ENTRIES - 1;
  gdt_ptr.base = (uintptr_t) &gdt_entries;
  
  gdt_set ((uintptr_t) &gdt_ptr);
}
Beispiel #4
0
/* Set up and install our three segments */
void gdt_install()
{
	gp.limit = (sizeof(struct gdt_entry) * 3) - 1;
	gp.base = (unsigned long)&gdt;

	gdt_set_entry(0, 0, 0, 0, 0);
	gdt_set_entry(1, 0, 0xFFFFFFFF, 0x9A, 0xCF);
	gdt_set_entry(2, 0, 0xFFFFFFFF, 0x92, 0xCF);

	gdt_set();
}
Beispiel #5
0
void gdt_init()
{
    //Setup the GDT pointer and limit
	gdt_pointer.limit = (sizeof(struct gdt_entry) * GDT_ENTRY_COUNT) - 1;
	gdt_pointer.base  = (unsigned int)&gdt_table;

    //NULL descriptor
	gdt_set(0, 0, 0, 0, 0);

    //Code segment
	gdt_set(1, 0, 0xFFFFFFFF, 0x9A, 0xCF);

    //Data Segment
	gdt_set(2, 0, 0xFFFFFFFF, 0x92, 0xCF);

	gdt_set(3, (unsigned int)&sys_task_state, (unsigned int)&sys_task_state + sizeof(sys_task_state) + 1, 0x89, 0x40);

    //Load the new GDT
	gdt_load();
}
Beispiel #6
0
void gdt_init() {
    gdt_set_entry(0, 0, 0, 0);
    gdt_set_entry(1, 0, 0xFFFFFFFF, 0x9A);
    gdt_set_entry(2, 0, 0xFFFFFFFF, 0x92);
    gdt_set_entry(3, 0, 0xFFFFFFFF, 0xFA);
    gdt_set_entry(4, 0, 0xFFFFFFFF, 0xF2);
    
    ptr.base = (uint32_t) &gdt_tab;
    ptr.limit = (sizeof(struct gdt_info) * GDT_LEN) - 1;
    
    gdt_set(&ptr);
}
Beispiel #7
0
static void write_tss(u32int idx, u32int ss0, u32int esp0)
{
	u32int base = (u32int)&tss_entry;
	u32int limit = base + sizeof(tss_entry_t);

	gdt_set(idx, base, limit, 0xE9, 0x00);

	memset(&tss_entry, 0, sizeof(tss_entry_t));

	tss_entry.ss0 = ss0;
	tss_entry.esp0 = esp0;

	tss_entry.cs = 0x0b;
	tss_entry.ss = tss_entry.ds = tss_entry.es = tss_entry.fs = tss_entry.gs = 0x13;
}