int
tree_iterfrom(struct tree *t, void **hdl, uint64_t k, uint64_t *id, void **data)
{
struct treeentry *curr = *hdl, key;
if (curr == NULL) {
if (k == 0)
curr = SPLAY_MIN(_tree, &t->tree);
else {
key.id = k;
curr = SPLAY_FIND(_tree, &t->tree, &key);
if (curr == NULL) {
SPLAY_INSERT(_tree, &t->tree, &key);
curr = SPLAY_NEXT(_tree, &t->tree, &key);
SPLAY_REMOVE(_tree, &t->tree, &key);
}
}
} else
curr = SPLAY_NEXT(_tree, &t->tree, curr);
if (curr) {
*hdl = curr;
if (id)
*id = curr->id;
if (data)
*data = curr->data;
return (1);
}
return (0);
}
int
dict_iterfrom(struct dict *d, void **hdl, const char *kfrom, const char **k,
void **data)
{
struct dictentry *curr = *hdl, key;
if (curr == NULL) {
if (kfrom == NULL)
curr = SPLAY_MIN(_dict, &d->dict);
else {
key.key = kfrom;
curr = SPLAY_FIND(_dict, &d->dict, &key);
if (curr == NULL) {
SPLAY_INSERT(_dict, &d->dict, &key);
curr = SPLAY_NEXT(_dict, &d->dict, &key);
SPLAY_REMOVE(_dict, &d->dict, &key);
}
}
} else
curr = SPLAY_NEXT(_dict, &d->dict, curr);
if (curr) {
*hdl = curr;
if (k)
*k = curr->key;
if (data)
*data = curr->data;
return (1);
}
return (0);
}
void i915_gem_context_close(struct drm_device *dev, struct drm_file *file)
{
struct drm_i915_file_private *file_priv = file->driver_priv;
struct i915_ctx_handle *han, *nxt;
for (han = SPLAY_MIN(i915_ctx_tree, &file_priv->ctx_tree); han != NULL;
han = nxt) {
nxt = SPLAY_NEXT(i915_ctx_tree, &file_priv->ctx_tree, han);
context_idr_cleanup(han->handle, han->ctx, NULL);
SPLAY_REMOVE(i915_ctx_tree, &file_priv->ctx_tree, han);
free(han, M_DRM);
}
}
static bool vm_map_insert_entry(vm_map_t *vm_map, vm_map_entry_t *entry) {
rw_assert(&vm_map->rwlock, RW_WLOCKED);
if (!SPLAY_INSERT(vm_map_tree, &vm_map->tree, entry)) {
vm_map_entry_t *next = SPLAY_NEXT(vm_map_tree, &vm_map->tree, entry);
if (next)
TAILQ_INSERT_BEFORE(next, entry, map_list);
else
TAILQ_INSERT_TAIL(&vm_map->list, entry, map_list);
vm_map->nentries++;
return true;
}
return false;
}
void
lfs_deregister_all(struct vnode *vp)
{
struct lbnentry *lbp, *nlbp;
struct lfs_splay *hd;
struct lfs *fs;
struct inode *ip;
ip = VTOI(vp);
fs = ip->i_lfs;
hd = &ip->i_lfs_lbtree;
for (lbp = SPLAY_MIN(lfs_splay, hd); lbp != NULL; lbp = nlbp) {
nlbp = SPLAY_NEXT(lfs_splay, hd, lbp);
lfs_do_deregister(fs, ip, lbp);
}
}
void fs_vnode_cleanup(vnode_t * vnode)
{
struct buf * var, * nxt;
KASSERT(vnode != NULL, "vnode can't be null.");
/* Release associated buffers. */
if (!SPLAY_EMPTY(&vnode->vn_bpo.sroot)) {
for (var = SPLAY_MIN(bufhd_splay, &vnode->vn_bpo.sroot);
var != NULL; var = nxt) {
nxt = SPLAY_NEXT(bufhd_splay, &vnode->vn_bpo.sroot, var);
SPLAY_REMOVE(bufhd_splay, &vnode->vn_bpo.sroot, var);
if (!(var->b_flags & B_DONE))
var->b_flags |= B_DELWRI;
brelse(var);
}
}
}
struct personality *
personality_random(void)
{
extern rand_t *honeyd_rand;
struct personality *pers;
int i;
if (!npersons)
return (NULL);
i = rand_uint32(honeyd_rand) % npersons;
pers = SPLAY_MIN(perstree, &personalities);
while (i--) {
pers = SPLAY_NEXT(perstree, &personalities, pers);
}
return (pers);
}
int
tree_iter(struct tree *t, void **hdl, uint64_t *id, void **data)
{
struct treeentry *curr = *hdl;
if (curr == NULL)
curr = SPLAY_MIN(_tree, &t->tree);
else
curr = SPLAY_NEXT(_tree, &t->tree, curr);
if (curr) {
*hdl = curr;
if (id)
*id = curr->id;
if (data)
*data = curr->data;
return (1);
}
return (0);
}
int
dict_iter(struct dict *d, void **hdl, const char **k, void **data)
{
struct dictentry *curr = *hdl;
if (curr == NULL)
curr = SPLAY_MIN(_dict, &d->dict);
else
curr = SPLAY_NEXT(_dict, &d->dict, curr);
if (curr) {
*hdl = curr;
if (k)
*k = curr->key;
if (data)
*data = curr->data;
return (1);
}
return (0);
}
