matos/core/stack.c
2024-01-26 22:53:39 +01:00

140 lines
4.6 KiB
C

#include "stack.h"
#include "elf.h"
#include "klibc.h"
#include "paging.h"
#include "types.h"
/** Defined in linker.ld script **/
extern char __multiboot_data_start;
extern char __multiboot_data_end;
static size_t multibootDataSize;
static size_t multibootUsage;
/** Initialized at 'StackSymbolSetup'. */
static Elf32_Sym_t *elfSymtab;
static size_t elfSymtabSize;
static const char *elfStrtab;
static size_t elfStrtabSize;
static void *stackSaveSection(const void *addr, size_t size, const char *sectionName)
{
if (size > (multibootDataSize - multibootUsage)) {
printf("No enough room to store %s (%d/%d). Increase multiboot_data section size",
sectionName, size, (multibootDataSize - multibootUsage));
return NULL;
}
void *destAddr = (void *)&__multiboot_data_start + multibootUsage;
memcpy((void *)destAddr, addr, size);
multibootUsage += size;
return destAddr;
}
/**
* Copy the symbols table and string table from a multiboot information.
* We need to copy them as they are loaded by the bootloader and could be override as soon
* as we play with memory around our loaded kernel.
* As special ELF section is allocated for this purpose.
*/
void stackSymbolSetup(multiboot_info_t *mbi)
{
/** Get the section header table as an array of section headers. */
Elf32_Shdr_t *sht = (Elf32_Shdr_t *)mbi->u.elf_sec.addr;
size_t sec_len = (size_t)mbi->u.elf_sec.num;
assert(mbi->u.elf_sec.size == sizeof(Elf32_Shdr_t));
multibootDataSize = &__multiboot_data_end - &__multiboot_data_start;
multibootUsage = 0;
/**
* The section header at index 'shndx' in the table is a meta section
* header. It contains a list of section header names in the table. We
* should look for section header names ".symtab" & ".strtab".
*/
const char *sh_names = (const char *)sht[mbi->u.elf_sec.shndx].sh_addr;
/** Loop through the table and look for ".symtab" & ".strtab". */
for (size_t i = 0; i < sec_len; ++i) {
const char *name = sh_names + sht[i].sh_name;
if (strcmp(name, ".symtab") == 0) {
assert(sht[i].sh_type == SHT_SYMTAB);
elfSymtab = stackSaveSection((void *)sht[i].sh_addr, sht[i].sh_size, name);
if (elfSymtab)
elfSymtabSize = sht[i].sh_size;
} else if (strcmp(name, ".strtab") == 0) {
assert(sht[i].sh_type == SHT_STRTAB);
elfStrtab = stackSaveSection((void *)sht[i].sh_addr, sht[i].sh_size, name);
if (elfStrtab)
elfStrtabSize = sht[i].sh_size;
}
}
}
/** Look up an address in symbols map and return its function name or NULL. */
const char *lookupSymbolName(uint32_t addr)
{
size_t symtab_len = elfSymtabSize / sizeof(Elf32_Sym_t);
for (size_t i = 0; i < symtab_len; ++i) {
if ((ELF_SYM_TYPE(elfSymtab[i].st_info) == ELF_SYM_TYPE_FUNC) &&
(addr >= elfSymtab[i].st_value) &&
(addr <= elfSymtab[i].st_value + elfSymtab[i].st_size)) {
return elfStrtab + elfSymtab[i].st_name;
}
}
return NULL;
}
void printStackTrace(unsigned int maxFrames)
{
#ifdef DEBUG
// Now on Stack:
// ( potential second function argument )
// first function argument (maxFrames)
// return address from caller
// EBP (Extended Base Pointer) of calling function
//
// retrace function from address could done by optaining function address with gdb or
// objdump -S kernel
unsigned int *ebp = __builtin_frame_address(0);
for (unsigned int frame = 0; frame < maxFrames; frame++) {
unsigned int eip = *(ebp + 1);
if (eip == 0) {
// No caller on stack
break;
}
unsigned int *arguments = ebp + 2;
const char *functionName = lookupSymbolName(eip);
if (functionName != NULL) {
printf("[%d] %s (", frame, functionName);
} else {
printf("[%d] 0x%x (", frame, eip);
}
int nbArg = 0;
do {
if ((_stack_bottom <= (vaddr_t)arguments) && ((vaddr_t)arguments <= _stack_top)) {
printf(" 0x%x", *arguments);
arguments += 1;
} else {
break;
}
nbArg++;
if (nbArg >= 4) {
break;
}
} while (1);
printf(")\n");
ebp = (unsigned int *)(ebp[0]);
}
#else
printf("Must be compiled with -fno-omit-frame-pointer for full stack\n");
unsigned int *ebp = &maxFrames - 2;
unsigned int *eip = ebp + sizeof(unsigned int);
printf("[0] 0x%x\n", (unsigned int)eip);
#endif
}