void removeDSO(pint_t ehFrameBase) {
pthread_rwlock_wrlock(&fdeTreeLock);
Range *n;
n = (Range *)rb_tree_find_node(&dsoTree, &ehFrameBase);
if (n == NULL) {
pthread_rwlock_unlock(&fdeTreeLock);
return;
}
rb_tree_remove_node(&dsoTree, n);
rb_tree_remove_node(&segmentTree, n);
free(n);
pthread_rwlock_unlock(&fdeTreeLock);
}
static void vmap_remove(struct vme *vme)
{
/* ASSERT ISA(vme) XXX: */
rb_tree_remove_node(&vmap_rbtree, (void *) vme);
vmap_size -= vme->size;
free(vme);
}
int rb_tree_remove(RBTree *tree, RBTreeKey key)
{
RBTreeNode *node;
/* Find the node to remove. */
node = rb_tree_lookup_node(tree, key);
if (node == NULL) {
return 0;
}
rb_tree_remove_node(tree, node);
return 1;
}
/*
* Reclaim an nfsnode so that it can be used for other purposes.
*/
int
nfs_reclaim(void *v)
{
struct vop_reclaim_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct nfsnode *np = VTONFS(vp);
struct nfsmount *nmp = VFSTONFS(vp->v_mount);
if (prtactive && vp->v_usecount > 1)
vprint("nfs_reclaim: pushing active", vp);
rw_enter(&nmp->nm_rbtlock, RW_WRITER);
rb_tree_remove_node(&nmp->nm_rbtree, np);
rw_exit(&nmp->nm_rbtlock);
/*
* Free up any directory cookie structures and
* large file handle structures that might be associated with
* this nfs node.
*/
if (vp->v_type == VDIR && np->n_dircache != NULL) {
nfs_invaldircache(vp, NFS_INVALDIRCACHE_FORCE);
hashdone(np->n_dircache, HASH_LIST, nfsdirhashmask);
}
KASSERT(np->n_dirgens == NULL);
if (np->n_fhsize > NFS_SMALLFH)
kmem_free(np->n_fhp, np->n_fhsize);
pool_put(&nfs_vattr_pool, np->n_vattr);
if (np->n_rcred)
kauth_cred_free(np->n_rcred);
if (np->n_wcred)
kauth_cred_free(np->n_wcred);
if (vp->v_type == VREG) {
mutex_destroy(&np->n_commitlock);
}
genfs_node_destroy(vp);
pool_put(&nfs_node_pool, np);
vp->v_data = NULL;
return (0);
}
bool removeFDE(pint_t pcStart, pint_t pcEnd, pint_t fde) {
pthread_rwlock_wrlock(&fdeTreeLock);
Range *n = (Range *)rb_tree_find_node(&segmentTree, &pcStart);
if (n == NULL) {
pthread_rwlock_unlock(&fdeTreeLock);
return false;
}
assert(n->first_pc == pcStart);
assert(n->last_pc == pcEnd);
assert(n->hdr_base == fde);
assert(n->hdr_start == 0);
assert(n->hdr_entries == 0);
assert(n->data_base == 0);
assert(n->ehframe_base == 0);
rb_tree_remove_node(&segmentTree, n);
free(n);
pthread_rwlock_unlock(&fdeTreeLock);
return true;
}
int rb_tree_remove(struct rb_tree* tree, const void* key)
{
return rb_tree_remove_node(tree, key, &null_node_free);
}
/*
* chfs_add_tmp_dnode_to_tree -
* adds a temporary node to the temporary tree
*/
int
chfs_add_tmp_dnode_to_tree(struct chfs_mount *chmp,
struct chfs_readinode_info *rii,
struct chfs_tmp_dnode *newtd)
{
uint64_t end_ofs = newtd->node->ofs + newtd->node->size;
struct chfs_tmp_dnode_info *this;
struct rb_node *node, *prev_node;
struct chfs_tmp_dnode_info *newtdi;
node = rb_tree_find_node(&rii->tdi_root, &newtd->node->ofs);
if (node) {
this = (struct chfs_tmp_dnode_info *)node;
while (this->tmpnode->overlapped) {
prev_node = rb_tree_iterate(&rii->tdi_root, node, RB_DIR_LEFT);
if (!prev_node) {
this->tmpnode->overlapped = 0;
break;
}
node = prev_node;
this = (struct chfs_tmp_dnode_info *)node;
}
}
while (node) {
this = (struct chfs_tmp_dnode_info *)node;
if (this->tmpnode->node->ofs > end_ofs)
break;
struct chfs_tmp_dnode *tmp_td = this->tmpnode;
while (tmp_td) {
if (tmp_td->version == newtd->version) {
/* This is a new version of an old node. */
if (!chfs_check_td_node(chmp, tmp_td)) {
dbg("calling kill td 0\n");
chfs_kill_td(chmp, newtd);
return 0;
} else {
chfs_remove_tmp_dnode_from_tdi(this, tmp_td);
chfs_kill_td(chmp, tmp_td);
chfs_add_tmp_dnode_to_tdi(this, newtd);
return 0;
}
}
if (tmp_td->version < newtd->version &&
tmp_td->node->ofs >= newtd->node->ofs &&
tmp_td->node->ofs + tmp_td->node->size <= end_ofs) {
/* New node entirely overlaps 'this' */
if (chfs_check_td_node(chmp, newtd)) {
dbg("calling kill td 2\n");
chfs_kill_td(chmp, newtd);
return 0;
}
/* ... and is good. Kill 'this' and any subsequent nodes which are also overlapped */
while (tmp_td && tmp_td->node->ofs + tmp_td->node->size <= end_ofs) {
struct rb_node *next = rb_tree_iterate(&rii->tdi_root, this, RB_DIR_RIGHT);
struct chfs_tmp_dnode_info *next_tdi = (struct chfs_tmp_dnode_info *)next;
struct chfs_tmp_dnode *next_td = NULL;
if (tmp_td->next) {
next_td = tmp_td->next;
} else if (next_tdi) {
next_td = next_tdi->tmpnode;
}
if (tmp_td->version < newtd->version) {
chfs_remove_tmp_dnode_from_tdi(this, tmp_td);
chfs_kill_td(chmp, tmp_td);
if (!this->tmpnode) {
rb_tree_remove_node(&rii->tdi_root, this);
chfs_kill_tdi(chmp, this);
this = next_tdi;
}
}
tmp_td = next_td;
}
continue;
}
if (tmp_td->version > newtd->version &&
tmp_td->node->ofs <= newtd->node->ofs &&
tmp_td->node->ofs + tmp_td->node->size >= end_ofs) {
/* New node entirely overlapped by 'this' */
if (!chfs_check_td_node(chmp, tmp_td)) {
dbg("this version: %llu\n",
(unsigned long long)tmp_td->version);
dbg("this ofs: %llu, size: %u\n",
(unsigned long long)tmp_td->node->ofs,
tmp_td->node->size);
dbg("calling kill td 4\n");
chfs_kill_td(chmp, newtd);
return 0;
}
/* ... but 'this' was bad. Replace it... */
chfs_remove_tmp_dnode_from_tdi(this, tmp_td);
chfs_kill_td(chmp, tmp_td);
if (!this->tmpnode) {
rb_tree_remove_node(&rii->tdi_root, this);
chfs_kill_tdi(chmp, this);
}
dbg("calling kill td 5\n");
chfs_kill_td(chmp, newtd);
break;
}
tmp_td = tmp_td->next;
}
node = rb_tree_iterate(&rii->tdi_root, node, RB_DIR_RIGHT);
}
newtdi = chfs_alloc_tmp_dnode_info();
chfs_add_tmp_dnode_to_tdi(newtdi, newtd);
/* We neither completely obsoleted nor were completely
obsoleted by an earlier node. Insert into the tree */
struct chfs_tmp_dnode_info *tmp_tdi = rb_tree_insert_node(&rii->tdi_root, newtdi);
if (tmp_tdi != newtdi) {
chfs_remove_tmp_dnode_from_tdi(newtdi, newtd);
chfs_add_tmp_dnode_to_tdi(tmp_tdi, newtd);
chfs_kill_tdi(chmp, newtdi);
}
/* If there's anything behind that overlaps us, note it */
node = rb_tree_iterate(&rii->tdi_root, node, RB_DIR_LEFT);
if (node) {
while (1) {
this = (struct chfs_tmp_dnode_info *)node;
if (this->tmpnode->node->ofs + this->tmpnode->node->size > newtd->node->ofs) {
newtd->overlapped = 1;
}
if (!this->tmpnode->overlapped)
break;
prev_node = rb_tree_iterate(&rii->tdi_root, node, RB_DIR_LEFT);
if (!prev_node) {
this->tmpnode->overlapped = 0;
break;
}
node = prev_node;
}
}
/* If the new node overlaps anything ahead, note it */
node = rb_tree_iterate(&rii->tdi_root, node, RB_DIR_RIGHT);
this = (struct chfs_tmp_dnode_info *)node;
while (this && this->tmpnode->node->ofs < end_ofs) {
this->tmpnode->overlapped = 1;
node = rb_tree_iterate(&rii->tdi_root, node, RB_DIR_RIGHT);
this = (struct chfs_tmp_dnode_info *)node;
}
return 0;
}
