GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cpu/x86/smm: Retype variables 

Change-Id: I85750282ab274f52bc176a1ac151ef2f9e0dd15d
Signed-off-by: Arthur Heymans <arthur@aheymans.xyz>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/58697
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: HAOUAS Elyes <ehaouas@noos.fr>
This commit is contained in:
Arthur Heymans 2021-10-28 13:59:54 +02:00 committed by Kyösti Mälkki
parent a0696645b0
commit cfd3224197
3 changed files with 44 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/cpu/x86/mp_init.c
View File

@ -777,7 +777,7 @@ static enum cb_err install_relocation_handler(int num_cpus, size_t real_save_sta
if (mp_state.ops.adjust_smm_params != NULL) if (mp_state.ops.adjust_smm_params != NULL)
mp_state.ops.adjust_smm_params(&smm_params, 0); mp_state.ops.adjust_smm_params(&smm_params, 0);
if (smm_setup_relocation_handler((void *)perm_smbase, &smm_params)) { if (smm_setup_relocation_handler(perm_smbase, &smm_params)) {
printk(BIOS_ERR, "%s: smm setup failed\n", __func__); printk(BIOS_ERR, "%s: smm setup failed\n", __func__);
return CB_ERR; return CB_ERR;
} }
@ -813,7 +813,7 @@ static enum cb_err install_permanent_handler(int num_cpus, uintptr_t smbase,
printk(BIOS_DEBUG, "Installing permanent SMM handler to 0x%08lx\n", smbase); printk(BIOS_DEBUG, "Installing permanent SMM handler to 0x%08lx\n", smbase);
if (smm_load_module((void *)smbase, smsize, &smm_params)) if (smm_load_module(smbase, smsize, &smm_params))
return CB_ERR; return CB_ERR;
adjust_smm_apic_id_map(&smm_params); adjust_smm_apic_id_map(&smm_params);

82
src/cpu/x86/smm/smm_module_loader.c
View File

@ -243,10 +243,10 @@ static int smm_place_entry_code(uintptr_t smbase, unsigned int num_cpus,
* Place stacks in base -> base + size region, but ensure the stacks don't * Place stacks in base -> base + size region, but ensure the stacks don't
* overlap the staggered entry points. * overlap the staggered entry points.
*/ */
static void *smm_stub_place_stacks(char *base, struct smm_loader_params *params) static uintptr_t smm_stub_place_stacks(const uintptr_t base, struct smm_loader_params *params)
{ {
size_t total_stack_size; size_t total_stack_size;
char *stacks_top; uintptr_t stacks_top;
/* If stack space is requested assume the space lives in the lower /* If stack space is requested assume the space lives in the lower
* half of SMRAM. */ * half of SMRAM. */
@ -258,11 +258,11 @@ static void *smm_stub_place_stacks(char *base, struct smm_loader_params *params)
/* There has to be at least one stack user. */ /* There has to be at least one stack user. */
if (params->num_concurrent_stacks < 1) if (params->num_concurrent_stacks < 1)
return NULL; return 0;
/* Stacks extend down to SMBASE */ /* Stacks extend down to SMBASE */
stacks_top = &base[total_stack_size]; stacks_top = base + total_stack_size;
printk(BIOS_DEBUG, "%s: exit, stack_top %p\n", __func__, stacks_top); printk(BIOS_DEBUG, "%s: exit, stack_top %lx\n", __func__, stacks_top);
return stacks_top; return stacks_top;
} }
@ -312,17 +312,17 @@ static int smm_stub_place_staggered_entry_points(char *base,
* by the permanent handler can be used during relocation. This is done via the * by the permanent handler can be used during relocation. This is done via the
* smram_start argument. * smram_start argument.
*/ */
static int smm_module_setup_stub(void *const smbase, const size_t smm_size, static int smm_module_setup_stub(const uintptr_t smbase, const size_t smm_size,
struct smm_loader_params *params, struct smm_loader_params *params,
void *const fxsave_area, void *const fxsave_area,
void *const smram_start) const uintptr_t smram_start)
{ {
size_t total_save_state_size; size_t total_save_state_size;
size_t smm_stub_size; size_t smm_stub_size;
char *smm_stub_loc; uintptr_t smm_stub_loc;
void *stacks_top; uintptr_t stacks_top;
size_t size; size_t size;
char *base; uintptr_t base;
size_t i; size_t i;
struct smm_stub_params *stub_params; struct smm_stub_params *stub_params;
struct rmodule smm_stub; struct rmodule smm_stub;
@ -368,11 +368,10 @@ static int smm_module_setup_stub(void *const smbase, const size_t smm_size,
return -1; return -1;
} }
smm_stub_loc = NULL;
smm_stub_size = rmodule_memory_size(&smm_stub); smm_stub_size = rmodule_memory_size(&smm_stub);
/* Put the stub at the main entry point */ /* Put the stub at the main entry point */
smm_stub_loc = &base[SMM_ENTRY_OFFSET]; smm_stub_loc = base + SMM_ENTRY_OFFSET;
/* Stub is too big to fit. */ /* Stub is too big to fit. */
if (smm_stub_size > (size - SMM_ENTRY_OFFSET)) { if (smm_stub_size > (size - SMM_ENTRY_OFFSET)) {
@ -385,18 +384,18 @@ static int smm_module_setup_stub(void *const smbase, const size_t smm_size,
* of SMRAM which is TSEG base * of SMRAM which is TSEG base
*/ */
stacks_top = smm_stub_place_stacks(smram_start, params); stacks_top = smm_stub_place_stacks(smram_start, params);
if (stacks_top == NULL) { if (stacks_top == 0) {
printk(BIOS_ERR, "%s: error assigning stacks\n", __func__); printk(BIOS_ERR, "%s: error assigning stacks\n", __func__);
return -1; return -1;
} }
params->stack_top = stacks_top; params->stack_top = stacks_top;
/* Load the stub. */ /* Load the stub. */
if (rmodule_load(smm_stub_loc, &smm_stub)) { if (rmodule_load((void *)smm_stub_loc, &smm_stub)) {
printk(BIOS_ERR, "%s: load module failed\n", __func__); printk(BIOS_ERR, "%s: load module failed\n", __func__);
return -1; return -1;
} }
if (!smm_stub_place_staggered_entry_points(base, params, &smm_stub)) { if (!smm_stub_place_staggered_entry_points((void *)base, params, &smm_stub)) {
printk(BIOS_ERR, "%s: staggered entry points failed\n", __func__); printk(BIOS_ERR, "%s: staggered entry points failed\n", __func__);
return -1; return -1;
} }
@ -429,7 +428,7 @@ static int smm_module_setup_stub(void *const smbase, const size_t smm_size,
/* Allow the initiator to manipulate SMM stub parameters. */ /* Allow the initiator to manipulate SMM stub parameters. */
params->stub_params = stub_params; params->stub_params = stub_params;
printk(BIOS_DEBUG, "SMM Module: stub loaded at %p. Will call %p\n", printk(BIOS_DEBUG, "SMM Module: stub loaded at %lx. Will call %p\n",
smm_stub_loc, params->handler); smm_stub_loc, params->handler);
return 0; return 0;
} }
@ -440,9 +439,9 @@ static int smm_module_setup_stub(void *const smbase, const size_t smm_size,
* assumption is that the stub will be entered from the default SMRAM * assumption is that the stub will be entered from the default SMRAM
* location: 0x30000 -> 0x40000. * location: 0x30000 -> 0x40000.
*/ */
int smm_setup_relocation_handler(void * const perm_smram, struct smm_loader_params *params) int smm_setup_relocation_handler(const uintptr_t perm_smram, struct smm_loader_params *params)
{ {
void *smram = (void *)(SMM_DEFAULT_BASE); uintptr_t smram = SMM_DEFAULT_BASE;
printk(BIOS_SPEW, "%s: enter\n", __func__); printk(BIOS_SPEW, "%s: enter\n", __func__);
/* There can't be more than 1 concurrent save state for the relocation /* There can't be more than 1 concurrent save state for the relocation
* handler because all CPUs default to 0x30000 as SMBASE. */ * handler because all CPUs default to 0x30000 as SMBASE. */
@ -489,7 +488,8 @@ int smm_setup_relocation_handler(void * const perm_smram, struct smm_loader_par
* expects a region large enough to encompass the handler and stacks * expects a region large enough to encompass the handler and stacks
* as well as the SMM_DEFAULT_SIZE. * as well as the SMM_DEFAULT_SIZE.
*/ */
int smm_load_module(void *smram, size_t size, struct smm_loader_params *params) int smm_load_module(const uintptr_t smram_base, const size_t smram_size,
struct smm_loader_params *params)
{ {
struct rmodule smm_mod; struct rmodule smm_mod;
struct smm_runtime *handler_mod_params; struct smm_runtime *handler_mod_params;
@ -500,16 +500,16 @@ int smm_load_module(void *smram, size_t size, struct smm_loader_params *params)
size_t fxsave_size; size_t fxsave_size;
void *fxsave_area; void *fxsave_area;
size_t total_size = 0; size_t total_size = 0;
char *base; uintptr_t base; /* The base for the permanent handler */
void *smram_start = smram;
if (size <= SMM_DEFAULT_SIZE) if (smram_size <= SMM_DEFAULT_SIZE)
return -1; return -1;
/* Load main SMI handler at the top of SMRAM /* Load main SMI handler at the top of SMRAM
* everything else will go below * everything else will go below
*/ */
base = smram; base = smram_base;
base += size; base += smram_size;
/* Fail if can't parse the smm rmodule. */ /* Fail if can't parse the smm rmodule. */
if (rmodule_parse(&_binary_smm_start, &smm_mod)) if (rmodule_parse(&_binary_smm_start, &smm_mod))
@ -517,13 +517,13 @@ int smm_load_module(void *smram, size_t size, struct smm_loader_params *params)
/* Clear SMM region */ /* Clear SMM region */
if (CONFIG(DEBUG_SMI)) if (CONFIG(DEBUG_SMI))
memset(smram, 0xcd, size); memset((void *)smram_base, 0xcd, smram_size);
total_stack_size = params->per_cpu_stack_size * total_stack_size = params->per_cpu_stack_size *
params->num_concurrent_stacks; params->num_concurrent_stacks;
total_size += total_stack_size; total_size += total_stack_size;
/* Stacks are the base of SMRAM */ /* Stacks are the base of SMRAM */
params->stack_top = smram + total_stack_size; params->stack_top = smram_base + total_stack_size;
/* MSEG starts at the top of SMRAM and works down */ /* MSEG starts at the top of SMRAM and works down */
if (CONFIG(STM)) { if (CONFIG(STM)) {
@ -534,7 +534,7 @@ int smm_load_module(void *smram, size_t size, struct smm_loader_params *params)
/* FXSAVE goes below MSEG */ /* FXSAVE goes below MSEG */
if (CONFIG(SSE)) { if (CONFIG(SSE)) {
fxsave_size = FXSAVE_SIZE * params->num_concurrent_stacks; fxsave_size = FXSAVE_SIZE * params->num_concurrent_stacks;
fxsave_area = base - fxsave_size; fxsave_area = (char *)base - fxsave_size;
base -= fxsave_size; base -= fxsave_size;
total_size += fxsave_size; total_size += fxsave_size;
} else { } else {
@ -546,8 +546,7 @@ int smm_load_module(void *smram, size_t size, struct smm_loader_params *params)
base -= handler_size; base -= handler_size;
total_size += handler_size; total_size += handler_size;
module_alignment = rmodule_load_alignment(&smm_mod); module_alignment = rmodule_load_alignment(&smm_mod);
alignment_size = module_alignment - alignment_size = module_alignment - (base % module_alignment);
((uintptr_t)base % module_alignment);
if (alignment_size != module_alignment) { if (alignment_size != module_alignment) {
handler_size += alignment_size; handler_size += alignment_size;
base += alignment_size; base += alignment_size;
@ -555,10 +554,10 @@ int smm_load_module(void *smram, size_t size, struct smm_loader_params *params)
printk(BIOS_DEBUG, printk(BIOS_DEBUG,
"%s: total_smm_space_needed %zx, available -> %zx\n", "%s: total_smm_space_needed %zx, available -> %zx\n",
__func__, total_size, size); __func__, total_size, smram_size);
/* Does the required amount of memory exceed the SMRAM region size? */ /* Does the required amount of memory exceed the SMRAM region size? */
if (total_size > size) { if (total_size > smram_size) {
printk(BIOS_ERR, "%s: need more SMRAM\n", __func__); printk(BIOS_ERR, "%s: need more SMRAM\n", __func__);
return -1; return -1;
} }
@ -568,22 +567,20 @@ int smm_load_module(void *smram, size_t size, struct smm_loader_params *params)
return -1; return -1;
} }
if (rmodule_load(base, &smm_mod)) if (rmodule_load((void *)base, &smm_mod))
return -1; return -1;
params->handler = rmodule_entry(&smm_mod); params->handler = rmodule_entry(&smm_mod);
handler_mod_params = rmodule_parameters(&smm_mod); handler_mod_params = rmodule_parameters(&smm_mod);
handler_mod_params->smbase = (uintptr_t)smram; handler_mod_params->smbase = smram_base;
handler_mod_params->smm_size = size; handler_mod_params->smm_size = smram_size;
handler_mod_params->save_state_size = params->real_cpu_save_state_size; handler_mod_params->save_state_size = params->real_cpu_save_state_size;
handler_mod_params->num_cpus = params->num_concurrent_stacks; handler_mod_params->num_cpus = params->num_concurrent_stacks;
handler_mod_params->gnvs_ptr = (uintptr_t)acpi_get_gnvs(); handler_mod_params->gnvs_ptr = (uintptr_t)acpi_get_gnvs();
printk(BIOS_DEBUG, "%s: smram_start: 0x%p\n", printk(BIOS_DEBUG, "%s: smram_start: 0x%lx\n", __func__, smram_base);
__func__, smram); printk(BIOS_DEBUG, "%s: smram_end: %lx\n", __func__, smram_base + smram_size);
printk(BIOS_DEBUG, "%s: smram_end: %p\n", printk(BIOS_DEBUG, "%s: stack_top: %lx\n",
__func__, smram + size);
printk(BIOS_DEBUG, "%s: stack_top: %p\n",
__func__, params->stack_top); __func__, params->stack_top);
printk(BIOS_DEBUG, "%s: handler start %p\n", printk(BIOS_DEBUG, "%s: handler start %p\n",
__func__, params->handler); __func__, params->handler);
@ -610,10 +607,9 @@ int smm_load_module(void *smram, size_t size, struct smm_loader_params *params)
* will be staggered below * will be staggered below
*/ */
base -= SMM_CODE_SEGMENT_SIZE; base -= SMM_CODE_SEGMENT_SIZE;
printk(BIOS_DEBUG, "%s: cpu0 entry: %p\n", printk(BIOS_DEBUG, "%s: cpu0 entry: %lx\n", __func__, base);
__func__, base);
if (!smm_create_map((uintptr_t)base, params->num_concurrent_save_states, params)) { if (!smm_create_map(base, params->num_concurrent_save_states, params)) {
printk(BIOS_ERR, "%s: Error creating CPU map\n", __func__); printk(BIOS_ERR, "%s: Error creating CPU map\n", __func__);
return -1; return -1;
} }
@ -623,5 +619,5 @@ int smm_load_module(void *smram, size_t size, struct smm_loader_params *params)
cpus[i].ss_start + params->per_cpu_save_state_size; cpus[i].ss_start + params->per_cpu_save_state_size;
} }
return smm_module_setup_stub(base, size, params, fxsave_area, smram_start); return smm_module_setup_stub(base, smram_size, params, fxsave_area, smram_base);
} }

6
src/include/cpu/x86/smm.h
View File

@ -135,7 +135,7 @@ static inline bool smm_points_to_smram(const void *ptr, const size_t len)
* handle sparse APIC id space. * handle sparse APIC id space.
*/ */
struct smm_loader_params { struct smm_loader_params {
void *stack_top; uintptr_t stack_top;
size_t per_cpu_stack_size; size_t per_cpu_stack_size;
size_t num_concurrent_stacks; size_t num_concurrent_stacks;
@ -149,8 +149,8 @@ struct smm_loader_params {
}; };
/* Both of these return 0 on success, < 0 on failure. */ /* Both of these return 0 on success, < 0 on failure. */
int smm_setup_relocation_handler(void * const perm_smram, struct smm_loader_params *params); int smm_setup_relocation_handler(const uintptr_t perm_smram, struct smm_loader_params *params);
int smm_load_module(void *smram, size_t size, struct smm_loader_params *params); int smm_load_module(uintptr_t smram_base, size_t smram_size, struct smm_loader_params *params);
u32 smm_get_cpu_smbase(unsigned int cpu_num); u32 smm_get_cpu_smbase(unsigned int cpu_num);