schme/hiload
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gather information about module.. again

Browse Source
This commit is contained in:
Kasper
2025-04-14 00:56:41 +03:00
parent 5beac7bdd8
commit 54b9ec7404
10 changed files with 212 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/hiload.c
View File

@@ -5,6 +5,7 @@
#include "filewatcher/filewatcher.h"
#include "logger/logger.h"
#include "memory.h"
#include "moduler/moduler.h"
#include "string/string.h"
#include "symbols.h"
#include "types.h"
@@ -18,22 +19,6 @@
#include <stdlib.h>
#include <string.h>
sc_array_def(uptr, uptr);
enum HiModuleState {
HI_MODULE_STATE_CLEAN = 0,
HI_MODULE_STATE_DIRTY,
};
typedef struct {
struct sc_array_str names; // Array of library names
struct sc_array_ptr handles; // Array of library handles
struct sc_array_uptr addresses; // Array of library base addresses
struct sc_array_syms symbols; // Symbol info for modules
u8 state[256]; // Flag for when module needs to be changed
size_t count; // Number of modules
} ModuleInfos;
typedef struct {
struct sc_array_memreg memory_regions;
struct sc_array_str enabled_modules;
@@ -60,7 +45,7 @@ static int gather_module_infos_callback(struct dl_phdr_info *info, size_t size,
sc_array_add(&mod_infos->handles, handle);
sc_array_add(&mod_infos->addresses, info->dlpi_addr);
log_debugv(" size: %u\n", size);
log_debugv(" header size: %u\n", size);
log_debugv(" handle: %p\n", sc_array_last(&mod_infos->handles));
log_debugv(" dlpi_addr: %p\n", info->dlpi_addr);
log_debugv(" dlpi_tls_modid: %zu\n", info->dlpi_tls_modid);
@@ -190,12 +175,6 @@ static i32 get_string_index(const char *needle,
return index;
}
static HiloadResult reload_module(ModuleInfos *modinfos, u8 modindex) {
modinfos->state[modindex] = HI_MODULE_STATE_CLEAN;
return HILOAD_OK;
}
static HiloadResult reload_dirty_modules(HiloadContext *context) {
HiloadResult ret = HILOAD_OK;
@@ -211,7 +190,8 @@ static HiloadResult reload_dirty_modules(HiloadContext *context) {
if (module_index != -1) {
log_info("Reloading %s...\n", module_name);
if (reload_module(context->loaded_modules, i) != HILOAD_OK) {
if (moduler_reload(context->loaded_modules, &context->memory_regions,
i) != HILOAD_OK) {
ret = HILOAD_FAIL;
log_error("Failed loading: %s\n", module_name);
}

2
src/logger/logger.c
View File

@@ -2,7 +2,7 @@
#include <stdatomic.h>
_Atomic bool hiload_verbose_log = false;
_Atomic bool hiload_verbose_log = true;
void log_set_verbose(bool value) {
atomic_store_explicit(&hiload_verbose_log, value, memory_order_relaxed);

33
src/memory.c
View File

@@ -9,9 +9,8 @@ static inline int ptr_in_range(uptr ptr, uptr start, uptr end) {
return ptr >= start && ptr <= end;
}
HiloadResult memory_find_pointer(uptr ptr,
struct sc_array_memreg *const regions,
size_t *index) {
HiloadResult memory_find_region(uptr ptr, struct sc_array_memreg *const regions,
size_t *index) {
for (size_t i = 0; i < sc_array_size(regions); i++) {
uptr start = regions->elems[i].region_start;
// we assume a sorted region by start address, so we can do a quick discard
@@ -35,7 +34,7 @@ HiloadResult read_memory_maps_self(struct sc_array_memreg *regions) {
sc_array_clear(regions);
sc_array_init(regions);
char* maps_str = hi_file_to_str_dyn("/proc/self/maps");
char *maps_str = hi_file_to_str_dyn("/proc/self/maps");
if (!maps_str)
return HILOAD_FAIL;
@@ -85,3 +84,29 @@ HiloadResult read_memory_maps_self(struct sc_array_memreg *regions) {
return HILOAD_OK;
}
MemoryRegionSpan
memory_get_module_span(const struct sc_array_memreg *const regions,
const char module_name[static 1]) {
uptr start = ~0ull;
uptr end = 0;
for (size_t i = 0; i < sc_array_size(regions); i++) {
const MemoryRegion *reg = &sc_array_at(regions, i);
if (reg->pathname && strcmp(reg->pathname, module_name) == 0) {
if (reg->region_start < start) {
start = reg->region_start;
}
if (reg->region_end > end) {
end = reg->region_end;
}
} else {
// we passed the module regions
if (end > 0) break;
}
}
assert(start < ~0ull && end > 0);
return (MemoryRegionSpan){.region_start = start, .region_end = end};
}

8
src/memory.h
View File

@@ -14,6 +14,11 @@ typedef enum {
HI_MEMORY_PRIVATE = 1 << 4
} MemoryPermissions;
typedef struct {
uptr region_start;
uptr region_end;
} MemoryRegionSpan;
typedef struct {
uptr region_start;
uptr region_end;
@@ -34,4 +39,7 @@ HiloadResult memory_find_pointer(uptr ptr,
struct sc_array_memreg *const regions,
size_t *index);
MemoryRegionSpan memory_get_module_span(const struct sc_array_memreg *const regions,
const char module_name[static 1]);
#endif // MEMORY_H_

3
src/moduler/elf.c Normal file
View File

@@ -0,0 +1,3 @@
#include "elf.h"
#include <libelf.h>

84
src/moduler/elf.h Normal file
View File

@@ -0,0 +1,84 @@
#ifndef ELF_H_
#define ELF_H_
#include <libelf.h>
static inline const char *dyn_type_to_str(unsigned type) {
// clang-format off
switch (type) {
case DT_NULL: return "NULL";
case DT_NEEDED: return "NEEDED";
case DT_PLTRELSZ: return "PLTRELSZ";
case DT_PLTGOT: return "PLTGOT";
case DT_HASH: return "HASH";
case DT_STRTAB: return "STRTAB";
case DT_SYMTAB: return "SYMTAB";
case DT_RELA: return "RELA";
case DT_RELASZ: return "RELASZ";
case DT_RELAENT: return "RELAENT";
case DT_STRSZ: return "STRSZ";
case DT_SYMENT: return "SYMENT";
case DT_INIT: return "INIT";
case DT_FINI: return "FINI";
case DT_SONAME: return "SONAME";
case DT_RPATH: return "RPATH";
case DT_SYMBOLIC: return "SYMBOLIC";
case DT_REL: return "REL";
case DT_RELSZ: return "RELSZ";
case DT_RELENT: return "RELENT";
case DT_PLTREL: return "PLTREL";
case DT_DEBUG: return "DEBUG";
case DT_TEXTREL: return "TEXTREL";
case DT_JMPREL: return "JMPREL";
case DT_BIND_NOW: return "BIND_NOW";
case DT_INIT_ARRAY: return "INIT_ARRAY";
case DT_FINI_ARRAY: return "FINI_ARRAY";
case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
case DT_RUNPATH: return "RUNPATH";
case DT_FLAGS: return "FLAGS";
case DT_PREINIT_ARRAY: return "ENCODING/PREINIT_ARRAY";
case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
case DT_RELRSZ: return "RELRSZ";
case DT_RELR: return "RELR";
case DT_RELRENT: return "RELRENT";
case DT_NUM: return "NUM";
case DT_LOOS: return "LOOS";
case DT_HIOS: return "HIOS";
case DT_LOPROC: return "LOPROC";
case DT_HIPROC: return "HIPROC";
case DT_PROCNUM: return "PROCNUM";
default: return "UNKNOWN";
}
// clang-format on
}
static inline const char *segment_type_to_str(unsigned type) {
// clang-format off
switch (type) {
case PT_NULL: return "NULL";
case PT_LOAD: return "LOAD";
case PT_DYNAMIC: return "DYNAMIC";
case PT_INTERP: return "INTERP";
case PT_NOTE: return "NOTE";
case PT_SHLIB: return "SHLIB";
case PT_PHDR: return "PHDR";
case PT_TLS: return "TLS";
case PT_NUM: return "NUM";
case PT_LOOS: return "LOOS";
case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
case PT_GNU_STACK: return "GNU_STACK";
case PT_GNU_RELRO: return "GNU_RELRO";
case PT_GNU_PROPERTY: return "GNU_PROPERTY";
case PT_LOSUNW: return "LOSUNW/SUNWBSS";
case PT_SUNWSTACK: return "SUNWSTACK";
case PT_HIOS: return "HIOS";
case PT_LOPROC: return "LOPROC";
case PT_HIPROC: return "HIPROC";
default: return "UNKNOWN";
}
// clang-format on
}
#endif

48
src/moduler/moduler.c Normal file
View File

@@ -0,0 +1,48 @@
#include "moduler.h"
#include "logger/logger.h"
#include "moduler/elf.h"
#include "memory.h"
#include "types.h"
HiloadResult moduler_reload(ModuleInfos *modinfos,
const struct sc_array_memreg *const memregs,
int modindex) {
const char *modname = sc_array_at(&modinfos->names, modindex);
MemoryRegionSpan memspan = memory_get_module_span(memregs, modname);
log_debugv("Module: %s - [%p, %p]\n", modname, memspan.region_start,
memspan.region_end);
Elf *elf = elf_memory((void*)memspan.region_start, memspan.region_end - memspan.region_start);
int err = elf_errno();
if (err) {
log_error("%s\n", elf_errmsg(err));
}
void *module_address = (void*)sc_array_at(&modinfos->addresses, modindex);
size_t phdrnum = 0;
err = elf_getphdrnum(elf, &phdrnum);
Elf64_Phdr *phdr = elf64_getphdr(elf);
for (size_t i = 0; i < phdrnum; ++i) {
Elf64_Phdr *p = phdr + i;
log_debugv("segment type: %s\n", segment_type_to_str(p->p_type));
size_t segment_size = p->p_memsz;
void *segment_start = module_address + p->p_vaddr;
void *segment_end = module_address + p->p_vaddr + segment_size;
if (p->p_type == PT_DYNAMIC) {
Elf64_Dyn *dyn = (Elf64_Dyn*)segment_start;
while ((void*)dyn < segment_end) {
log_debugv(" dyn type: %s\n", dyn_type_to_str(dyn->d_tag));
++dyn;
}
}
}
modinfos->state[modindex] = HI_MODULE_STATE_CLEAN;
return HILOAD_OK;
}

31
src/moduler/moduler.h Normal file
View File

@@ -0,0 +1,31 @@
#ifndef MODULER_H_
#define MODULER_H_
#include "array/array.h"
#include "memory.h"
#include "symbols.h"
#include "types.h"
struct HiloadContext;
sc_array_def(uptr, uptr);
enum HiModuleState {
HI_MODULE_STATE_CLEAN = 0,
HI_MODULE_STATE_DIRTY,
};
typedef struct {
struct sc_array_str names; // Array of library names
struct sc_array_ptr handles; // Array of library handles
struct sc_array_uptr addresses; // Array of library base addresses
struct sc_array_syms symbols; // Symbol info for modules
u8 state[256]; // Flag for when module needs to be changed
size_t count; // Number of modules
} ModuleInfos;
HiloadResult moduler_reload(ModuleInfos *modinfos,
const struct sc_array_memreg *const memregs,
int modindex);
#endif // MODULER_H_

4
src/symbols.c
View File

@@ -4,11 +4,7 @@
void hi_free_symbol_info(SymbolInfos *symbols) {
for (size_t i = 0; i < symbols->names.size; i++) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
free((void *)symbols->names.elems[i]);
#pragma GCC diagnostic pop
}
sc_array_term(&symbols->names);