void _utspace_split_free(allocman_t *alloc, void *_split, uint32_t cookie, uint32_t size_bits) { utspace_split_t *split = (utspace_split_t*)_split; struct utspace_split_node *node = (struct utspace_split_node*)cookie; struct utspace_split_node *parent = node->parent; /* see if our sibling is also free */ if (parent && !node->sibling->allocated) { /* remove sibling from free list */ _remove_node(&split->heads[size_bits], node->sibling); /* delete both of us */ _delete_node(alloc, node->sibling); _delete_node(alloc, node); /* put the parent back in */ _utspace_split_free(alloc, split, (uint32_t) parent, size_bits + 1); } else { /* just put ourselves back in */ _insert_node(&split->heads[size_bits], node); } }
int _utspace_trickle_add_uts(allocman_t *alloc, void *_trickle, uint32_t num, cspacepath_t *uts, uint32_t *size_bits, uint32_t *paddr) { utspace_trickle_t *trickle = (utspace_trickle_t*) _trickle; struct utspace_trickle_node *nodes[num]; cspacepath_t *uts_copy[num]; int error; int i; for (i = 0; i < num; i++) { nodes[i] = _make_node(alloc, &error); if (error) { for (i--; i >= 0; i--) { _free_node(alloc, nodes[i]); allocman_mspace_free(alloc, uts_copy[i], sizeof(cspacepath_t)); } return error; } uts_copy[i] = allocman_mspace_alloc(alloc, sizeof(cspacepath_t), &error); if (error) { _free_node(alloc, nodes[i]); for (i--; i >= 0; i--) { _free_node(alloc, nodes[i]); allocman_mspace_free(alloc, uts_copy[i], sizeof(cspacepath_t)); } } } for (i = 0; i < num; i++) { *uts_copy[i] = uts[i]; nodes[i]->ut = uts_copy[i]; nodes[i]->offset = 0; nodes[i]->paddr = paddr[i]; nodes[i]->parent_cookie = 0; nodes[i]->next = nodes[i]->prev = NULL; /* Start with only 1 thing free */ nodes[i]->bitmap = BIT(31); nodes[i]->bitmap_bits = 1; _insert_node(&trickle->heads[size_bits[i]], nodes[i]); } return 0; }
static int _refill_pool(allocman_t *alloc, utspace_split_t *split, struct utspace_split_node **heads, size_t size_bits, uintptr_t paddr) { struct utspace_split_node *node; struct utspace_split_node *left, *right; int sel4_error; if (paddr == ALLOCMAN_NO_PADDR) { /* see if pool is actually empty */ if (heads[size_bits]) { return 0; } } else { /* see if the pool has the paddr we want */ for (node = heads[size_bits]; node; node = node->next) { if (node->paddr <= paddr && paddr < node->paddr + BIT(size_bits)) { return 0; } } } /* ensure we are not the highest pool */ if (size_bits >= sizeof(seL4_Word) * 8 - 2) { /* bugger, no untypeds bigger than us */ ZF_LOGV("Failed to refill pool of size %zu, no larger pools", size_bits); return 1; } /* get something from the highest pool */ if (_refill_pool(alloc, split, heads, size_bits + 1, paddr)) { /* could not fill higher pool */ ZF_LOGV("Failed to refill pool of size %zu", size_bits); return 1; } if (paddr == ALLOCMAN_NO_PADDR) { /* use the first node for lack of a better one */ node = heads[size_bits + 1]; } else { for (node = heads[size_bits + 1]; node && !(node->paddr <= paddr && paddr < node->paddr + BIT(size_bits + 1)); node = node->next); /* _refill_pool should not have returned if this wasn't possible */ assert(node); } /* allocate two new nodes */ left = _new_node(alloc); if (!left) { ZF_LOGV("Failed to allocate left node"); return 1; } right = _new_node(alloc); if (!right) { ZF_LOGV("Failed to allocate right node"); _delete_node(alloc, left); return 1; } /* perform the first retype */ sel4_error = seL4_Untyped_Retype(node->ut.capPtr, seL4_UntypedObject, size_bits, left->ut.root, left->ut.dest, left->ut.destDepth, left->ut.offset, 1); if (sel4_error != seL4_NoError) { _delete_node(alloc, left); _delete_node(alloc, right); /* Well this shouldn't happen */ ZF_LOGE("Failed to retype untyped, error %d\n", sel4_error); return 1; } /* perform the second retype */ sel4_error = seL4_Untyped_Retype(node->ut.capPtr, seL4_UntypedObject, size_bits, right->ut.root, right->ut.dest, right->ut.destDepth, right->ut.offset, 1); if (sel4_error != seL4_NoError) { vka_cnode_delete(&left->ut); _delete_node(alloc, left); _delete_node(alloc, right); /* Well this shouldn't happen */ ZF_LOGE("Failed to retype untyped, error %d\n", sel4_error); return 1; } /* all is done. remove the parent and insert the children */ _remove_node(&heads[size_bits + 1], node); left->parent = right->parent = node; left->sibling = right; left->origin_head = &heads[size_bits]; right->origin_head = &heads[size_bits]; right->sibling = left; if (node->paddr != ALLOCMAN_NO_PADDR) { left->paddr = node->paddr; right->paddr = node->paddr + BIT(size_bits); } else { left->paddr = right->paddr = ALLOCMAN_NO_PADDR; } /* insert in this order so that we end up pulling the untypeds off in order of contiugous * physical address. This makes various allocation problems slightly less likely to happen */ _insert_node(&heads[size_bits], right); _insert_node(&heads[size_bits], left); return 0; }
static int _refill_pool(allocman_t *alloc, utspace_split_t *split, uint32_t size_bits) { struct utspace_split_node *node; struct utspace_split_node *left, *right; int sel4_error; /* see if pool is actually empty */ if (split->heads[size_bits]) { return 0; } /* ensure we are not the highest pool */ if (size_bits >= 30) { /* bugger, no untypeds bigger than us */ return 1; } /* get something from the highest pool */ if (_refill_pool(alloc, split, size_bits + 1)) { /* could not fill higher pool */ return 1; } /* use the first node for lack of a better one */ node = split->heads[size_bits + 1]; /* allocate two new nodes */ left = _new_node(alloc); if (!left) { return 1; } right = _new_node(alloc); if (!right) { _delete_node(alloc, left); return 1; } /* perform the first retype */ #if defined(CONFIG_KERNEL_STABLE) sel4_error = seL4_Untyped_RetypeAtOffset(node->ut.capPtr, seL4_UntypedObject, 0, size_bits, left->ut.root, left->ut.dest, left->ut.destDepth, left->ut.offset, 1); #else sel4_error = seL4_Untyped_Retype(node->ut.capPtr, seL4_UntypedObject, size_bits, left->ut.root, left->ut.dest, left->ut.destDepth, left->ut.offset, 1); #endif if (sel4_error != seL4_NoError) { _delete_node(alloc, left); _delete_node(alloc, right); /* Well this shouldn't happen */ return 1; } /* perform the second retype */ #if defined(CONFIG_KERNEL_STABLE) sel4_error = seL4_Untyped_RetypeAtOffset(node->ut.capPtr, seL4_UntypedObject, BIT(size_bits), size_bits, right->ut.root, right->ut.dest, right->ut.destDepth, right->ut.offset, 1); #else sel4_error = seL4_Untyped_Retype(node->ut.capPtr, seL4_UntypedObject, size_bits, right->ut.root, right->ut.dest, right->ut.destDepth, right->ut.offset, 1); #endif if (sel4_error != seL4_NoError) { vka_cnode_delete(&left->ut); _delete_node(alloc, left); _delete_node(alloc, right); /* Well this shouldn't happen */ return 1; } /* all is done. remove the parent and insert the children */ _remove_node(&split->heads[size_bits + 1], node); left->parent = right->parent = node; left->sibling = right; right->sibling = left; if (node->paddr) { left->paddr = node->paddr; right->paddr = node->paddr + BIT(size_bits); } else { left->paddr = right->paddr = 0; } /* insert in this order so that we end up pulling the untypeds off in order of contiugous * physical address. This makes various allocation problems slightly less likely to happen */ _insert_node(&split->heads[size_bits], right); _insert_node(&split->heads[size_bits], left); return 0; }