/*
* Copyright (c) 2011, 2012, 2013, 2014, 2015 Jonas 'Sortie' Termansen.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* x86-family/gdt.cpp
* GDT and TSS.
*/
#include <assert.h>
#include <stdint.h>
#include <string.h>
#include <sortix/kernel/cpu.h>
#include <sortix/kernel/registers.h>
#include "gdt.h"
namespace Sortix {
namespace GDT {
struct gdt_entry
{
uint16_t limit_low;
uint16_t base_low;
uint8_t base_middle;
uint8_t access;
uint8_t granularity;
uint8_t base_high;
};
#if defined(__x86_64__)
struct gdt_entry64
{
uint16_t limit_low;
uint16_t base_low;
uint8_t base_middle;
uint8_t access;
uint8_t granularity;
uint8_t base_high;
uint32_t base_highest;
uint32_t reserved0;
};
#endif
#if defined(__i386__)
struct tss_entry
{
uint32_t prev_tss;
uint32_t esp0;
uint32_t ss0;
uint32_t esp1;
uint32_t ss1;
uint32_t esp2;
uint32_t ss2;
uint32_t cr3;
uint32_t eip;
uint32_t eflags;
uint32_t eax;
uint32_t ecx;
uint32_t edx;
uint32_t ebx;
uint32_t esp;
uint32_t ebp;
uint32_t esi;
uint32_t edi;
uint32_t es;
uint32_t cs;
uint32_t ss;
uint32_t ds;
uint32_t fs;
uint32_t gs;
uint32_t ldt;
uint16_t trap;
uint16_t iomap_base;
};
#elif defined(__x86_64__)
struct tss_entry
{
uint32_t reserved0;
uint64_t stack0; /* This is not naturally aligned, so packed is needed. */
uint64_t stack1;
uint64_t stack2;
uint64_t reserved1;
uint64_t ist[7];
uint64_t reserved2;
uint16_t reserved3;
uint16_t iomap_base;
} __attribute__((packed));
#endif
extern "C" {
const size_t STACK_SIZE = 64*1024;
extern size_t stack[STACK_SIZE / sizeof(size_t)];
struct tss_entry tss =
{
#if defined(__i386__)
.prev_tss = 0, /* c++ */
.esp0 = 0 /*(uintptr_t) stack + sizeof(stack)*/,
.ss0 = 0x10 /* Kernel Data Segment */,
.esp1 = 0, /* c++ */
.ss1 = 0, /* c++ */
.esp2 = 0, /* c++ */
.ss2 = 0, /* c++ */
.cr3 = 0, /* c++ */
.eip = 0, /* c++ */
.eflags = 0, /* c++ */
.eax = 0, /* c++ */
.ecx = 0, /* c++ */
.edx = 0, /* c++ */
.ebx = 0, /* c++ */
.esp = 0, /* c++ */
.ebp = 0, /* c++ */
.esi = 0, /* c++ */
.edi = 0, /* c++ */
.es = 0x13 /* Kernel Data Segment */,
.cs = 0x0B /* Kernel Code Segment */,
.ss = 0, /* c++ */
.ds = 0x13 /* Kernel Data Segment */,
.fs = 0x13 /* Kernel Data Segment */,
.gs = 0x13 /* Kernel Data Segment */,
.ldt = 0, /* c++ */
.trap = 0, /* c++ */
.iomap_base = 0, /* c++ */
#elif defined(__x86_64__)
.reserved0 = 0, /* c++ */
.stack0 = 0 /*(uintptr_t) stack + sizeof(stack)*/,
.stack1 = 0, /* c++ */
.stack2 = 0, /* c++ */
.reserved1 = 0, /* c++ */
.ist = { 0, 0, 0, 0, 0, 0, 0},
.reserved2 = 0,
.reserved3 = 0,
.iomap_base = 0,
#endif
};
} /* extern "C" */
#define GRAN_64_BIT_MODE (1 << 5)
#define GRAN_32_BIT_MODE (1 << 6)
#define GRAN_4KIB_BLOCKS (1 << 7)
#define GDT_ENTRY(base, limit, access, granularity) \
{ (limit) & 0xFFFF, /* limit_low */ \
(uint16_t) ((base) >> 0 & 0xFFFF), /* base_low */ \
(uint8_t) ((base) >> 16 & 0xFF), /* base_middle */ \
(access) & 0xFF, /* access */ \
((limit) >> 16 & 0x0F) | ((granularity) & 0xF0), /* granularity */ \
(uint8_t) ((base) >> 24 & 0xFF), /* base_high */ }
#if defined(__x86_64__)
#define GDT_ENTRY64(base, limit, access, granularity) \
{ (limit) & 0xFFFF, /* limit_low */ \
(uint16_t) ((base) >> 0 & 0xFFFF), /* base_low */ \
(uint8_t) ((base) >> 16 & 0xFF), /* base_middle */ \
(access) & 0xFF, /* access */ \
((limit) >> 16 & 0x0F) | ((granularity) & 0xF0), /* granularity */ \
(uint8_t) ((base) >> 24 & 0xFF), /* base_high */ }, \
{ (uint16_t) ((base) >> 32 & 0xFFFF), /* base_highest */ \
(uint16_t) ((base) >> 48 & 0xFFFF), /* base_highest */ \
0, /* reserved0 */ \
0, /* reserved0 */ \
0, /* reserved0 */ \
0, /* reserved0 */ }
#endif
extern "C" {
struct gdt_entry gdt[] =
{
/* 0x00: Null segment */
GDT_ENTRY(0, 0, 0, 0),
#if defined(__i386__)
/* 0x08: Kernel Code Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0x9A, GRAN_32_BIT_MODE | GRAN_4KIB_BLOCKS),
/* 0x10: Kernel Data Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0x92, GRAN_32_BIT_MODE | GRAN_4KIB_BLOCKS),
/* 0x18: User Code Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0xFA, GRAN_32_BIT_MODE | GRAN_4KIB_BLOCKS),
/* 0x20: User Data Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0xF2, GRAN_32_BIT_MODE | GRAN_4KIB_BLOCKS),
/* 0x28: Task Switch Segment. */
GDT_ENTRY(0 /*((uintptr_t) &tss)*/, sizeof(tss) - 1, 0xE9, 0x00),
/* 0x30: F Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0xF2, GRAN_32_BIT_MODE | GRAN_4KIB_BLOCKS),
/* 0x38: G Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0xF2, GRAN_32_BIT_MODE | GRAN_4KIB_BLOCKS),
#elif defined(__x86_64__)
/* 0x08: Kernel Code Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0x9A, GRAN_64_BIT_MODE | GRAN_4KIB_BLOCKS),
/* 0x10: Kernel Data Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0x92, GRAN_64_BIT_MODE | GRAN_4KIB_BLOCKS),
/* 0x18: User Code Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0xFA, GRAN_64_BIT_MODE | GRAN_4KIB_BLOCKS),
/* 0x20: User Data Segment. */
GDT_ENTRY(0, 0xFFFFFFFF, 0xF2, GRAN_64_BIT_MODE | GRAN_4KIB_BLOCKS),
/* 0x28: Task Switch Segment. */
GDT_ENTRY64((uint64_t) 0 /*((uintptr_t) &tss)*/, sizeof(tss) - 1, 0xE9, 0x00),
#endif
};
uint16_t gdt_size_minus_one = sizeof(gdt) - 1;
} /* extern "C" */
uintptr_t GetKernelStack()
{
#if defined(__i386__)
return tss.esp0;
#elif defined(__x86_64__)
return tss.stack0;
#endif
}
void SetKernelStack(uintptr_t stack_pointer)
{
assert((stack_pointer & 0xF) == 0);
#if defined(__i386__)
tss.esp0 = (uint32_t) stack_pointer;
#elif defined(__x86_64__)
tss.stack0 = (uint64_t) stack_pointer;
#endif
}
#if defined(__i386__)
uint32_t GetFSBase()
{
struct gdt_entry* entry = gdt + GDT_FS_ENTRY;
return (uint32_t) entry->base_low << 0 |
(uint32_t) entry->base_middle << 16 |
(uint32_t) entry->base_high << 24;
}
uint32_t GetGSBase()
{
struct gdt_entry* entry = gdt + GDT_GS_ENTRY;
return (uint32_t) entry->base_low << 0 |
(uint32_t) entry->base_middle << 16 |
(uint32_t) entry->base_high << 24;
}
void SetFSBase(uint32_t fsbase)
{
struct gdt_entry* entry = gdt + GDT_FS_ENTRY;
entry->base_low = fsbase >> 0 & 0xFFFF;
entry->base_middle = fsbase >> 16 & 0xFF;
entry->base_high = fsbase >> 24 & 0xFF;
asm volatile ("mov %0, %%fs" : : "r"(GDT_FS_ENTRY << 3 | URPL));
}
void SetGSBase(uint32_t gsbase)
{
struct gdt_entry* entry = gdt + GDT_GS_ENTRY;
entry->base_low = gsbase >> 0 & 0xFFFF;
entry->base_middle = gsbase >> 16 & 0xFF;
entry->base_high = gsbase >> 24 & 0xFF;
asm volatile ("mov %0, %%gs" : : "r"(GDT_GS_ENTRY << 3 | URPL));
}
#endif
} // namespace GDT
} // namespace Sortix