List* list_new_entry(const Entry* entry)
{
ListData data;
assert(entry_is_valid(entry));
data.entry = entry_copy(entry);
return list_new(LIST_ENTRY, &data);
}
void list_insert_entry(List* list, const Entry* entry)
{
ListData data;
assert(list_is_valid(list));
assert(entry_is_valid(entry));
assert(list->type == LIST_ENTRY);
data.entry = entry_copy(entry);
list_insert_data(list, &data);
}
/* Entry is eaten.
* No check is done if entry->tuple is a member of sym->set !
* This has to be done before.
*/
void symbol_add_entry(Symbol* sym, Entry* entry)
{
const Tuple* tuple;
assert(symbol_is_valid(sym));
assert(entry_is_valid(entry));
assert(sym->used <= sym->size);
if (sym->used == sym->size)
{
sym->size += sym->extend;
sym->extend += sym->extend;
sym->entry = realloc(
sym->entry, (size_t)sym->size * sizeof(*sym->entry));
assert(sym->entry != NULL);
}
assert(sym->used < sym->size);
tuple = entry_get_tuple(entry);
/* There is no index set for the internal symbol.
*/
assert(!strcmp(sym->name, SYMBOL_NAME_INTERNAL) || set_lookup(sym->set, tuple));
if (hash_has_entry(sym->hash, tuple))
{
if (stmt_trigger_warning(166))
{
fprintf(stderr, "--- Warning 166: Duplicate element ");
tuple_print(stderr, tuple);
fprintf(stderr, " for symbol %s rejected\n", sym->name);
}
entry_free(entry);
}
else
{
/* Falls noch nicht geschehen, legen wir hier den Typ des
* Symbols fest.
*/
if ((sym->type == SYM_ERR) && (sym->used == 0))
sym->type = entry_get_type(entry);
assert(sym->type != SYM_ERR);
hash_add_entry(sym->hash, entry);
sym->entry[sym->used] = entry;
sym->used++;
}
}
/*
* To be called after the EFI page tables have been populated. If a memory
* attributes table is available, its contents will be used to update the
* mappings with tightened permissions as described by the table.
* This requires the UEFI memory map to have already been populated with
* virtual addresses.
*/
int __init efi_memattr_apply_permissions(struct mm_struct *mm,
efi_memattr_perm_setter fn)
{
efi_memory_attributes_table_t *tbl;
int i, ret;
if (tbl_size <= sizeof(*tbl))
return 0;
/*
* We need the EFI memory map to be setup so we can use it to
* lookup the virtual addresses of all entries in the of EFI
* Memory Attributes table. If it isn't available, this
* function should not be called.
*/
if (WARN_ON(!efi_enabled(EFI_MEMMAP)))
return 0;
tbl = memremap(efi.mem_attr_table, tbl_size, MEMREMAP_WB);
if (!tbl) {
pr_err("Failed to map EFI Memory Attributes table @ 0x%lx\n",
efi.mem_attr_table);
return -ENOMEM;
}
if (efi_enabled(EFI_DBG))
pr_info("Processing EFI Memory Attributes table:\n");
for (i = ret = 0; ret == 0 && i < tbl->num_entries; i++) {
efi_memory_desc_t md;
unsigned long size;
bool valid;
char buf[64];
valid = entry_is_valid((void *)tbl->entry + i * tbl->desc_size,
&md);
size = md.num_pages << EFI_PAGE_SHIFT;
if (efi_enabled(EFI_DBG) || !valid)
pr_info("%s 0x%012llx-0x%012llx %s\n",
valid ? "" : "!", md.phys_addr,
md.phys_addr + size - 1,
efi_md_typeattr_format(buf, sizeof(buf), &md));
if (valid)
ret = fn(mm, &md);
}
memunmap(tbl);
return ret;
}
void hash_add_entry(Hash* hash, const Entry* entry)
{
HElem* he = blk_alloc(sizeof(*he));
const Tuple* tuple;
unsigned int hcode;
assert(hash_is_valid(hash));
assert(entry_is_valid(entry));
assert(hash->type == HASH_ENTRY);
assert(he != NULL);
tuple = entry_get_tuple(entry);
hcode = tuple_hash(tuple) % hash->size;
he->value.entry = entry;
he->next = hash->bucket[hcode];
hash->bucket[hcode] = he;
hash->elems++;
}
/* Liefert NULL wenn nicht gefunden.
*/
const Entry* hash_lookup_entry(const Hash* hash, const Tuple* tuple)
{
unsigned int hcode = tuple_hash(tuple) % hash->size;
HElem* he;
assert(hash_is_valid(hash));
assert(tuple_is_valid(tuple));
for(he = hash->bucket[hcode]; he != NULL; he = he->next)
if (!entry_cmp(he->value.entry, tuple))
break;
if (he == NULL)
return NULL;
assert(he != NULL);
assert(entry_is_valid(he->value.entry));
return he->value.entry;
}
