int tl_event_node_insert(struct tl_event_node * node) {
struct tl_event_node * insertPos;
tl_manage_t tm;
assert(node);
assert(node->m_event.m_tl);
assert(node->m_event.m_tl->m_manage);
tm = node->m_event.m_tl->m_manage;
insertPos = TAILQ_FIRST(&tm->m_event_queue);
while(insertPos != TAILQ_END(&tm->m_event_queue)
&& insertPos->m_execute_time <= node->m_execute_time)
{
insertPos = TAILQ_NEXT(insertPos, m_next);
}
if (insertPos == TAILQ_END(&tm->m_event_queue)) {
TAILQ_INSERT_TAIL(&tm->m_event_queue, node, m_next);
}
else {
TAILQ_INSERT_BEFORE(insertPos, node, m_next);
}
node->m_state = tl_event_node_state_in_event_queue;
return 0;
}
void
pmcstat_image_link(struct pmcstat_process *pp, struct pmcstat_image *image,
uintfptr_t start)
{
struct pmcstat_pcmap *pcm, *pcmnew;
uintfptr_t offset;
assert(image->pi_type != PMCSTAT_IMAGE_UNKNOWN &&
image->pi_type != PMCSTAT_IMAGE_INDETERMINABLE);
if ((pcmnew = malloc(sizeof(*pcmnew))) == NULL)
err(EX_OSERR, "ERROR: Cannot create a map entry");
/*
* Adjust the map entry to only cover the text portion
* of the object.
*/
offset = start - image->pi_vaddr;
pcmnew->ppm_lowpc = image->pi_start + offset;
pcmnew->ppm_highpc = image->pi_end + offset;
pcmnew->ppm_image = image;
assert(pcmnew->ppm_lowpc < pcmnew->ppm_highpc);
/* Overlapped mmap()'s are assumed to never occur. */
TAILQ_FOREACH(pcm, &pp->pp_map, ppm_next)
if (pcm->ppm_lowpc >= pcmnew->ppm_highpc)
break;
if (pcm == NULL)
TAILQ_INSERT_TAIL(&pp->pp_map, pcmnew, ppm_next);
else
TAILQ_INSERT_BEFORE(pcm, pcmnew, ppm_next);
}
void
_waitq_insert(pthread_t pthread)
{
pthread_t tid;
/*
* Make some assertions when debugging is enabled:
*/
_PQ_ASSERT_INACTIVE("_waitq_insert: pq_active");
_PQ_SET_ACTIVE();
_PQ_ASSERT_NOT_QUEUED(pthread, "_waitq_insert: Already in queue");
if (pthread->wakeup_time.tv_sec == -1)
TAILQ_INSERT_TAIL(&_waitingq, pthread, pqe);
else {
tid = TAILQ_FIRST(&_waitingq);
while ((tid != NULL) && (tid->wakeup_time.tv_sec != -1) &&
((tid->wakeup_time.tv_sec < pthread->wakeup_time.tv_sec) ||
((tid->wakeup_time.tv_sec == pthread->wakeup_time.tv_sec) &&
(tid->wakeup_time.tv_nsec <= pthread->wakeup_time.tv_nsec))))
tid = TAILQ_NEXT(tid, pqe);
if (tid == NULL)
TAILQ_INSERT_TAIL(&_waitingq, pthread, pqe);
else
TAILQ_INSERT_BEFORE(tid, pthread, pqe);
}
pthread->flags |= PTHREAD_FLAGS_IN_WAITQ;
_PQ_CLEAR_ACTIVE();
}
static void
timer_list_insert_into_list(struct timer_list *tlist, struct timer_list_entry *new_entry)
{
struct timer_list_entry *entry;
/*
* This can overflow and it's not a problem
*/
new_entry->expire_time = new_entry->epoch + PR_MillisecondsToInterval(new_entry->interval);
entry = TAILQ_FIRST(&tlist->list);
while (entry != NULL) {
if (timer_list_entry_cmp(entry, new_entry, new_entry->epoch) > 0) {
/*
* Insert new entry right before current entry
*/
TAILQ_INSERT_BEFORE(entry, new_entry, entries);
break;
}
entry = TAILQ_NEXT(entry, entries);
}
if (entry == NULL) {
TAILQ_INSERT_TAIL(&tlist->list, new_entry, entries);
}
}
static inline void put_entry_d_sorted(int row, int col, double value, size_t pos, queue_d *queue, cstuff_DirectionMap *obj, entry_d **waiting) {
entry_d *entry, *entry2, *entry3;
entry = waiting[pos];
if (entry) {
TAILQ_REMOVE(queue, entry, hook);
} else {
entry = get_entry_d(row, col, value);
waiting[pos] = entry;
}
entry->row = row;
entry->col = col;
entry->value = value;
obj->map->values[pos] = value;
if (TAILQ_EMPTY(queue) || TAILQ_LAST(queue, _queue_d)->value <= value) {
TAILQ_INSERT_TAIL(queue, entry, hook);
} else if (TAILQ_FIRST(queue)->value > value) {
TAILQ_INSERT_HEAD(queue, entry, hook);
} else {
entry2 = TAILQ_LAST(queue, _queue_d);
TAILQ_FOREACH_REVERSE(entry3, queue, _queue_d, hook) {
if (entry3->value > value) {
entry2 = entry3;
} else {
break;
}
}
TAILQ_INSERT_BEFORE(entry2, entry, hook);
}
}
static JSBool
js_item_moveBefore(JSContext *cx, JSObject *obj,
uintN argc, jsval *argv, jsval *rval)
{
js_item_t *ji = JS_GetPrivate(cx, obj);
js_item_t *before;
if(argc >= 1 && JSVAL_IS_OBJECT(argv[0]) &&
!JSVAL_IS_NULL(argv[0]) &&
JS_GetClass(cx, JSVAL_TO_OBJECT(argv[0])) == &item_class) {
before = JS_GetPrivate(cx, JSVAL_TO_OBJECT(argv[0]));
} else {
before = NULL;
}
TAILQ_REMOVE(&ji->ji_model->jm_items, ji, ji_link);
if(before)
TAILQ_INSERT_BEFORE(before, ji, ji_link);
else
TAILQ_INSERT_TAIL(&ji->ji_model->jm_items, ji, ji_link);
prop_move(ji->ji_root, before ? before->ji_root : NULL);
*rval = JSVAL_VOID;
return JS_TRUE;
}
static void
pq_insert_prio_list(pq_queue_t *pq, int prio)
{
pq_list_t *pql;
/*
* Make some assertions when debugging is enabled:
*/
PQ_ASSERT_ACTIVE(pq, "pq_insert_prio_list: pq_active");
/*
* The priority queue is in descending priority order. Start at
* the beginning of the queue and find the list before which the
* new list should be inserted.
*/
pql = TAILQ_FIRST(&pq->pq_queue);
while ((pql != NULL) && (pql->pl_prio > prio))
pql = TAILQ_NEXT(pql, pl_link);
/* Insert the list: */
if (pql == NULL)
TAILQ_INSERT_TAIL(&pq->pq_queue, &pq->pq_lists[prio], pl_link);
else
TAILQ_INSERT_BEFORE(pql, &pq->pq_lists[prio], pl_link);
/* Mark this list as being in the queue: */
pq->pq_lists[prio].pl_queued = 1;
}
/* Add/insert a new component to the module search path */
static void
addpath(struct pathhead *pathq, char *path, int force, int insert)
{
struct pathentry *pe, *pskip;
char pathbuf[MAXPATHLEN+1];
size_t len;
static unsigned added = 0;
unsigned i;
/*
* If the path exists, use it; otherwise, take the user-specified
* path at face value - may be a removed directory.
*/
if (realpath(path, pathbuf) == NULL)
strlcpy(pathbuf, path, sizeof(pathbuf));
len = strlen(pathbuf);
#ifdef NEED_SLASHTERM
/* slash-terminate, because the kernel linker said so. */
if ((len == 0) || (pathbuf[len-1] != '/')) {
if (len == sizeof(pathbuf) - 1)
errx(1, "path too long: %s", pathbuf);
pathbuf[len] = '/';
}
#else /* NEED_SLASHTERM */
/* remove a terminating slash if present */
if ((len > 0) && (pathbuf[len-1] == '/'))
pathbuf[--len] = '\0';
#endif /* NEED_SLASHTERM */
/* is it already in there? */
TAILQ_FOREACH(pe, pathq, next)
if (!strcmp(pe->path, pathbuf))
break;
if (pe != NULL) {
if (force)
return;
errx(1, "already in the module search path: %s", pathbuf);
}
/* OK, allocate and add it. */
if (((pe = malloc(sizeof(*pe))) == NULL) ||
((pe->path = strdup(pathbuf)) == NULL)) {
errno = ENOMEM;
err(1, "allocating path component");
}
if (!insert) {
TAILQ_INSERT_TAIL(pathq, pe, next);
} else {
for (i = 0, pskip = TAILQ_FIRST(pathq); i < added; i++)
pskip = TAILQ_NEXT(pskip, next);
if (pskip != NULL)
TAILQ_INSERT_BEFORE(pskip, pe, next);
else
TAILQ_INSERT_TAIL(pathq, pe, next);
added++;
}
changed = 1;
}
void
net_send_queue(struct connection *c, void *data, u_int32_t len,
struct spdy_stream *s, int before)
{
u_int8_t *d;
struct netbuf *nb;
u_int32_t avail;
kore_debug("net_send_queue(%p, %p, %d, %p, %d)",
c, data, len, s, before);
d = data;
if (before == NETBUF_LAST_CHAIN) {
nb = TAILQ_LAST(&(c->send_queue), netbuf_head);
if (nb != NULL && !(nb->flags & NETBUF_IS_STREAM) &&
nb->stream == s && nb->b_len < nb->m_len) {
avail = nb->m_len - nb->b_len;
if (len < avail) {
memcpy(nb->buf + nb->b_len, d, len);
nb->b_len += len;
return;
} else if (len > avail) {
memcpy(nb->buf + nb->b_len, d, avail);
nb->b_len += avail;
len -= avail;
d += avail;
if (len == 0)
return;
}
}
}
nb = kore_pool_get(&nb_pool);
nb->flags = 0;
nb->cb = NULL;
nb->owner = c;
nb->s_off = 0;
nb->stream = s;
nb->b_len = len;
nb->type = NETBUF_SEND;
if (nb->b_len < NETBUF_SEND_PAYLOAD_MAX)
nb->m_len = NETBUF_SEND_PAYLOAD_MAX;
else
nb->m_len = nb->b_len;
nb->buf = kore_malloc(nb->m_len);
if (len > 0)
memcpy(nb->buf, d, nb->b_len);
if (before == NETBUF_BEFORE_CHAIN) {
TAILQ_INSERT_BEFORE(c->snb, nb, list);
} else {
TAILQ_INSERT_TAIL(&(c->send_queue), nb, list);
}
}
/*
* Insertion is O(n) due to the priority scan, but optimises to O(1)
* if all priorities are identical.
*
* MPSAFE
*/
eventhandler_tag
eventhandler_register(struct eventhandler_list *list, const char *name,
void *func, void *arg, int priority)
{
struct eventhandler_entry_generic *eg;
struct eventhandler_entry *ep;
lwkt_gettoken(&evlist_token);
/*
* find/create the list as needed
*/
while (list == NULL) {
list = eventhandler_find_list(name);
if (list)
break;
list = kmalloc(sizeof(struct eventhandler_list) + strlen(name) + 1,
M_EVENTHANDLER, M_INTWAIT);
if (eventhandler_find_list(name)) {
kfree(list, M_EVENTHANDLER);
list = NULL;
} else {
list->el_flags = 0;
list->el_name = (char *)list + sizeof(struct eventhandler_list);
strcpy(list->el_name, name);
TAILQ_INSERT_HEAD(&eventhandler_lists, list, el_link);
}
}
if (!(list->el_flags & EHE_INITTED)) {
TAILQ_INIT(&list->el_entries);
list->el_flags = EHE_INITTED;
}
/* allocate an entry for this handler, populate it */
eg = kmalloc(sizeof(struct eventhandler_entry_generic),
M_EVENTHANDLER, M_INTWAIT);
eg->func = func;
eg->ee.ee_arg = arg;
eg->ee.ee_priority = priority;
/* sort it into the list */
for (ep = TAILQ_FIRST(&list->el_entries);
ep != NULL;
ep = TAILQ_NEXT(ep, ee_link)) {
if (eg->ee.ee_priority < ep->ee_priority) {
TAILQ_INSERT_BEFORE(ep, &eg->ee, ee_link);
break;
}
}
if (ep == NULL)
TAILQ_INSERT_TAIL(&list->el_entries, &eg->ee, ee_link);
lwkt_reltoken(&evlist_token);
return(&eg->ee);
}
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;
}
u_int16_t
_name2id(struct n2id_labels *head, const char *name)
{
struct n2id_label *label, *p = NULL;
u_int16_t new_id = 1;
if (!name[0]) {
errno = EINVAL;
return (0);
}
TAILQ_FOREACH(label, head, entry)
if (strcmp(name, label->name) == 0) {
label->ref++;
return (label->id);
}
/*
* to avoid fragmentation, we do a linear search from the beginning
* and take the first free slot we find. if there is none or the list
* is empty, append a new entry at the end.
*/
if (!TAILQ_EMPTY(head))
for (p = TAILQ_FIRST(head); p != NULL &&
p->id == new_id; p = TAILQ_NEXT(p, entry))
new_id = p->id + 1;
if (new_id > IDVAL_MAX) {
errno = ERANGE;
return (0);
}
if ((label = calloc(1, sizeof(struct n2id_label))) == NULL)
return (0);
if ((label->name = strdup(name)) == NULL) {
free(label);
return (0);
}
label->id = new_id;
label->ref++;
if (p != NULL) /* insert new entry before p */
TAILQ_INSERT_BEFORE(p, label, entry);
else /* either list empty or no free slot in between */
TAILQ_INSERT_TAIL(head, label, entry);
return (label->id);
}
/*
* Insert an address entry in the bridge address TAILQ starting to search
* for its place from the position of the first bridge address for the bridge
* interface. Update the first bridge address if necessary.
*/
static void
bridge_addrs_insert_at(struct tp_entries *headp,
struct tp_entry *ta, struct tp_entry **f_tpa)
{
struct tp_entry *t1;
assert(f_tpa != NULL);
for (t1 = *f_tpa;
t1 != NULL && ta->sysindex == t1->sysindex;
t1 = TAILQ_NEXT(t1, tp_e)) {
if (bridge_compare_macs(ta->tp_addr, t1->tp_addr) < 0) {
TAILQ_INSERT_BEFORE(t1, ta, tp_e);
if (*f_tpa == t1)
(*f_tpa) = ta;
return;
}
}
if (t1 == NULL)
TAILQ_INSERT_TAIL(headp, ta, tp_e);
else
TAILQ_INSERT_BEFORE(t1, ta, tp_e);
}
/*
* sleepq_insert:
*
* Insert an LWP into the sleep queue, optionally sorting by priority.
*/
static void
sleepq_insert(sleepq_t *sq, lwp_t *l, syncobj_t *sobj)
{
if ((sobj->sobj_flag & SOBJ_SLEEPQ_SORTED) != 0) {
lwp_t *l2;
const int pri = lwp_eprio(l);
TAILQ_FOREACH(l2, sq, l_sleepchain) {
if (lwp_eprio(l2) < pri) {
TAILQ_INSERT_BEFORE(l2, l, l_sleepchain);
return;
}
}
}
int nr_ice_candidate_pair_insert(nr_ice_cand_pair_head *head,nr_ice_cand_pair *pair)
{
nr_ice_cand_pair *c1;
c1=TAILQ_FIRST(head);
while(c1){
if(c1->priority < pair->priority){
TAILQ_INSERT_BEFORE(c1,pair,entry);
break;
}
c1=TAILQ_NEXT(c1,entry);
}
if(!c1) TAILQ_INSERT_TAIL(head,pair,entry);
return(0);
}
/*
* MPSAFE
*/
void
systimer_add(systimer_t info)
{
struct globaldata *gd = mycpu;
KKASSERT((info->flags & SYSTF_ONQUEUE) == 0);
crit_enter();
if (info->gd == gd) {
systimer_t scan1;
systimer_t scan2;
scan1 = TAILQ_FIRST(&gd->gd_systimerq);
if (scan1 == NULL || (int)(scan1->time - info->time) > 0) {
cputimer_intr_reload(info->time - sys_cputimer->count());
TAILQ_INSERT_HEAD(&gd->gd_systimerq, info, node);
} else {
scan2 = TAILQ_LAST(&gd->gd_systimerq, systimerq);
for (;;) {
if (scan1 == NULL) {
TAILQ_INSERT_TAIL(&gd->gd_systimerq, info, node);
break;
}
if ((int)(scan1->time - info->time) > 0) {
TAILQ_INSERT_BEFORE(scan1, info, node);
break;
}
if ((int)(scan2->time - info->time) <= 0) {
TAILQ_INSERT_AFTER(&gd->gd_systimerq, scan2, info, node);
break;
}
scan1 = TAILQ_NEXT(scan1, node);
scan2 = TAILQ_PREV(scan2, systimerq, node);
}
}
info->flags = (info->flags | SYSTF_ONQUEUE) & ~SYSTF_IPIRUNNING;
info->queue = &gd->gd_systimerq;
} else {
#ifdef SMP
KKASSERT((info->flags & SYSTF_IPIRUNNING) == 0);
info->flags |= SYSTF_IPIRUNNING;
lwkt_send_ipiq(info->gd, (ipifunc1_t)systimer_add, info);
#else
panic("systimer_add: bad gd in info %p", info);
#endif
}
crit_exit();
}
/*
* This function detaches 'con' from its parent and inserts it either before or
* after 'target'.
*
*/
static void insert_con_into(Con *con, Con *target, position_t position) {
Con *parent = target->parent;
/* We need to preserve the old con->parent. While it might still be used to
* insert the entry before/after it, we call the on_remove_child callback
* afterwards which might then close the con if it is empty. */
Con *old_parent = con->parent;
con_detach(con);
con_fix_percent(con->parent);
/* When moving to a workspace, we respect the user’s configured
* workspace_layout */
if (parent->type == CT_WORKSPACE) {
Con *split = workspace_attach_to(parent);
if (split != parent) {
DLOG("Got a new split con, using that one instead\n");
con->parent = split;
con_attach(con, split, false);
DLOG("attached\n");
con->percent = 0.0;
con_fix_percent(split);
con = split;
DLOG("ok, continuing with con %p instead\n", con);
con_detach(con);
}
}
con->parent = parent;
if (position == BEFORE) {
TAILQ_INSERT_BEFORE(target, con, nodes);
TAILQ_INSERT_HEAD(&(parent->focus_head), con, focused);
} else if (position == AFTER) {
TAILQ_INSERT_AFTER(&(parent->nodes_head), target, con, nodes);
TAILQ_INSERT_HEAD(&(parent->focus_head), con, focused);
}
/* Pretend the con was just opened with regards to size percent values.
* Since the con is moved to a completely different con, the old value
* does not make sense anyways. */
con->percent = 0.0;
con_fix_percent(parent);
CALL(old_parent, on_remove_child);
}
/*
* Insert an entry in the bridge interface TAILQ. Keep the
* TAILQ sorted by the bridge's interface name.
*/
static void
bridge_ifs_insert(struct bridge_ifs *headp,
struct bridge_if *b)
{
struct bridge_if *temp;
if ((temp = TAILQ_FIRST(headp)) == NULL ||
strcmp(b->bif_name, temp->bif_name) < 0) {
TAILQ_INSERT_HEAD(headp, b, b_if);
return;
}
TAILQ_FOREACH(temp, headp, b_if)
if(strcmp(b->bif_name, temp->bif_name) < 0)
TAILQ_INSERT_BEFORE(temp, b, b_if);
TAILQ_INSERT_TAIL(headp, b, b_if);
}
/*
* Enqueue a waiting thread to a queue in descending priority order.
*/
static inline void
mutex_queue_enq(pthread_mutex_t mutex, pthread_t pthread)
{
pthread_t tid = TAILQ_LAST(&mutex->m_queue, mutex_head);
PTHREAD_ASSERT_NOT_IN_SYNCQ(pthread);
/*
* For the common case of all threads having equal priority,
* we perform a quick check against the priority of the thread
* at the tail of the queue.
*/
if ((tid == NULL) || (pthread->active_priority <= tid->active_priority))
TAILQ_INSERT_TAIL(&mutex->m_queue, pthread, sqe);
else {
tid = TAILQ_FIRST(&mutex->m_queue);
while (pthread->active_priority <= tid->active_priority)
tid = TAILQ_NEXT(tid, sqe);
TAILQ_INSERT_BEFORE(tid, pthread, sqe);
}
pthread->flags |= PTHREAD_FLAGS_IN_MUTEXQ;
}
/*
* Add an fd to preserve.
*/
int
add_preserved_fd(struct preserved_fd_list *pfds, int fd)
{
struct preserved_fd *pfd, *pfd_new;
debug_decl(add_preserved_fd, SUDO_DEBUG_UTIL)
pfd_new = emalloc(sizeof(*pfd));
pfd_new->lowfd = fd;
pfd_new->highfd = fd;
pfd_new->flags = fcntl(fd, F_GETFD);
if (pfd_new->flags == -1) {
efree(pfd_new);
debug_return_int(-1);
}
TAILQ_FOREACH(pfd, pfds, entries) {
if (fd == pfd->highfd) {
/* already preserved */
sudo_debug_printf(SUDO_DEBUG_DEBUG|SUDO_DEBUG_LINENO,
"fd %d already preserved", fd);
efree(pfd_new);
break;
}
if (fd < pfd->highfd) {
TAILQ_INSERT_BEFORE(pfd, pfd_new, entries);
sudo_debug_printf(SUDO_DEBUG_DEBUG|SUDO_DEBUG_LINENO,
"preserving fd %d", fd);
break;
}
}
if (pfd == NULL) {
TAILQ_INSERT_TAIL(pfds, pfd_new, entries);
sudo_debug_printf(SUDO_DEBUG_DEBUG|SUDO_DEBUG_LINENO,
"preserving fd %d", fd);
}
debug_return_int(0);
}
static int
open_dsts(struct _citrus_iconv_std_dst_list *dl,
const struct _esdb_charset *ec, const struct _esdb *dbdst)
{
struct _citrus_iconv_std_dst *sd, *sdtmp;
unsigned long norm;
int i, ret;
sd = malloc(sizeof(*sd));
if (sd == NULL)
return (errno);
for (i = 0; i < dbdst->db_num_charsets; i++) {
ret = open_csmapper(&sd->sd_mapper, ec->ec_csname,
dbdst->db_charsets[i].ec_csname, &norm);
if (ret == 0) {
sd->sd_csid = dbdst->db_charsets[i].ec_csid;
sd->sd_norm = norm;
/* insert this mapper by sorted order. */
TAILQ_FOREACH(sdtmp, dl, sd_entry) {
if (sdtmp->sd_norm > norm) {
TAILQ_INSERT_BEFORE(sdtmp, sd,
sd_entry);
sd = NULL;
break;
}
}
if (sd)
TAILQ_INSERT_TAIL(dl, sd, sd_entry);
sd = malloc(sizeof(*sd));
if (sd == NULL) {
ret = errno;
close_dsts(dl);
return (ret);
}
} else if (ret != ENOENT) {
/*
* Enqueue a waiting thread to a condition queue in descending priority
* order.
*/
static inline void
cond_queue_enq(pthread_cond_t cond, struct pthread *pthread)
{
struct pthread *tid = TAILQ_LAST(&cond->c_queue, cond_head);
THR_ASSERT(!THR_IN_SYNCQ(pthread),
"cond_queue_enq: thread already queued!");
/*
* For the common case of all threads having equal priority,
* we perform a quick check against the priority of the thread
* at the tail of the queue.
*/
if ((tid == NULL) || (pthread->active_priority <= tid->active_priority))
TAILQ_INSERT_TAIL(&cond->c_queue, pthread, sqe);
else {
tid = TAILQ_FIRST(&cond->c_queue);
while (pthread->active_priority <= tid->active_priority)
tid = TAILQ_NEXT(tid, sqe);
TAILQ_INSERT_BEFORE(tid, pthread, sqe);
}
THR_CONDQ_SET(pthread);
pthread->data.cond = cond;
}
void * mem_pos_insert_alloc(mem_buffer_pos_t pos, size_t n) {
struct mem_buffer_trunk * trunk;
assert(pos);
assert(pos->m_buffer);
if (n <= 0) return NULL;
if (pos->m_trunk == NULL) {
return mem_buffer_alloc(pos->m_buffer, n);
}
if (pos->m_pos_in_trunk == 0) {
/*pos at begin of trunk, alloc a new trunk to store data*/
trunk = mem_trunk_alloc(pos->m_buffer->m_default_allocrator, n);
if (trunk == NULL) {
return NULL;
}
TAILQ_INSERT_BEFORE(pos->m_trunk, trunk, m_next);
pos->m_buffer->m_size += n;
trunk->m_size = n;
return mem_trunk_data(trunk);
}
else if (pos->m_trunk->m_capacity >= pos->m_pos_in_trunk + n) {
/*new data can store in current trunk*/
char * trunkBegin = (char *)mem_trunk_data(pos->m_trunk);
char * result = trunkBegin + pos->m_pos_in_trunk;
/*can`t store all data in current buffer, move overflow data to a new trunk*/
ssize_t appendSize = pos->m_trunk->m_size + n - pos->m_trunk->m_capacity;
if (appendSize > 0) {
trunk = mem_trunk_alloc(pos->m_buffer->m_default_allocrator, appendSize);
if (trunk == NULL) {
return NULL;
}
TAILQ_INSERT_AFTER(&pos->m_buffer->m_trunks, pos->m_trunk, trunk, m_next);
memcpy(
mem_trunk_data(trunk),
trunkBegin + pos->m_trunk->m_size - appendSize,
appendSize);
trunk->m_size = appendSize;
pos->m_trunk->m_size -= appendSize;
}
if (pos->m_pos_in_trunk < pos->m_trunk->m_size) {
memmove(
trunkBegin + pos->m_pos_in_trunk + n,
trunkBegin + pos->m_pos_in_trunk,
pos->m_trunk->m_size - pos->m_pos_in_trunk);
}
else {
}
pos->m_trunk->m_size += pos->m_trunk->m_size - appendSize + n;
pos->m_pos_in_trunk += n;
if (pos->m_pos_in_trunk >= pos->m_trunk->m_size) {
pos->m_pos_in_trunk = pos->m_pos_in_trunk - pos->m_trunk->m_size;
pos->m_trunk = trunk;
}
assert(pos->m_pos_in_trunk < pos->m_trunk->m_size);
assert(pos->m_trunk->m_size <= pos->m_trunk->m_capacity);
pos->m_buffer->m_size += n;
return result;
}
else {
/*new data can not store in current trunk*/
ssize_t moveSize = pos->m_trunk->m_size - pos->m_pos_in_trunk;
trunk = mem_trunk_alloc(pos->m_buffer->m_default_allocrator, n + moveSize);
if (trunk == NULL) {
return NULL;
}
TAILQ_INSERT_AFTER(&pos->m_buffer->m_trunks, pos->m_trunk, trunk, m_next);
assert(moveSize > 0);
memcpy(
(char *)mem_trunk_data(trunk) + n,
(char *)mem_trunk_data(pos->m_trunk) + pos->m_pos_in_trunk,
moveSize);
trunk->m_size = n + moveSize;
pos->m_trunk->m_size = pos->m_pos_in_trunk;
pos->m_trunk = trunk;
pos->m_pos_in_trunk = n;
pos->m_buffer->m_size += n;
return mem_trunk_data(trunk);
}
}
struct ip4_range_list_element *
ip4_range_list_insert_range(ip4_range_list_t *list, const struct ip4_range *range, struct ip4_range_list_element *hint) {
struct ip4_range_list_element *element;
struct ip4_range_list_element *tmp_element;
struct ip4_range_list_element *new_element;
if (list==NULL || range==NULL) { return NULL; }
if (TAILQ_EMPTY(list)) {
new_element = malloc(sizeof(struct ip4_range_list_element));
if (new_element == NULL) {
fprintf(stderr, "Allocation error\n");
exit(-1);
}
new_element->range = *range;
TAILQ_INSERT_HEAD(list, new_element, ip4_range_list_links);
return new_element;
}
tmp_element = TAILQ_LAST(list, ip4_range_list);
if (range->start >= tmp_element->range.start) {
/* Overlapping or adjacent */
if (range->start <= tmp_element->range.end+1) {
tmp_element->range.end = MAX(range->end, tmp_element->range.end);
return tmp_element;
}
/* Separate */
new_element = malloc(sizeof(struct ip4_range_list_element));
if (new_element == NULL) {
fprintf(stderr, "Allocation error\n");
exit(-1);
/* NOTREACHED */
}
new_element->range = *range;
TAILQ_INSERT_TAIL(list, new_element, ip4_range_list_links);
return new_element;
}
if (hint != NULL) {
element = hint;
}
else {
element = TAILQ_FIRST(list);
}
for (;element != NULL; element = TAILQ_NEXT(element, ip4_range_list_links)) {
/* Insert before */
if (range->start <= element->range.start) {
if (range->end+1 >= element->range.start) {
element->range.start = range->start;
element->range.end = MAX(range->end, element->range.end);
return element;
}
new_element = malloc(sizeof(struct ip4_range_list_element));
if (new_element == NULL) {
fprintf(stderr, "Allocation error\n");
exit(-1);
/* NOTREACHED */
}
new_element->range = *range;
TAILQ_INSERT_BEFORE(element, new_element, ip4_range_list_links);
return new_element;
}
}
fprintf(stderr, "*dies*\n");
exit(-1);
/* NOTREACHED */
}
/*
* Find the correct table entry for the given variable. If non exists,
* create one.
*/
static struct entry *
table_find(struct tabwork *work, const struct asn_oid *var)
{
struct entry *e, *e1;
struct work *w, *w1;
u_int i, p, j;
size_t len;
u_char *ptr;
struct asn_oid oid;
/* get index */
asn_slice_oid(&oid, var, work->descr->table.len + 2, var->len);
e = TAILQ_FIRST(work->table);
w = TAILQ_FIRST(&work->worklist);
while (e != NULL) {
if (asn_compare_oid(&w->index, &oid) == 0)
return (e);
e = TAILQ_NEXT(e, link);
w = TAILQ_NEXT(w, link);
}
/* Not found create new one */
if ((e = malloc(work->descr->entry_size)) == NULL) {
seterr(&snmp_client, "no memory for table entry");
return (NULL);
}
if ((w = malloc(sizeof(*w))) == NULL) {
seterr(&snmp_client, "no memory for table entry");
free(e);
return (NULL);
}
w->index = oid;
memset(e, 0, work->descr->entry_size);
/* decode index */
p = work->descr->table.len + 2;
for (i = 0; i < work->descr->index_size; i++) {
switch (work->descr->entries[i].syntax) {
case SNMP_SYNTAX_INTEGER:
if (var->len < p + 1) {
seterr(&snmp_client, "bad index: need integer");
goto err;
}
if (var->subs[p] > INT32_MAX) {
seterr(&snmp_client,
"bad index: integer too large");
goto err;
}
*(int32_t *)(void *)((u_char *)e +
work->descr->entries[i].offset) = var->subs[p++];
break;
case SNMP_SYNTAX_OCTETSTRING:
if (var->len < p + 1) {
seterr(&snmp_client,
"bad index: need string length");
goto err;
}
len = var->subs[p++];
if (var->len < p + len) {
seterr(&snmp_client,
"bad index: string too short");
goto err;
}
if ((ptr = malloc(len + 1)) == NULL) {
seterr(&snmp_client,
"no memory for index string");
goto err;
}
for (j = 0; j < len; j++) {
if (var->subs[p] > UCHAR_MAX) {
seterr(&snmp_client,
"bad index: char too large");
free(ptr);
goto err;
}
ptr[j] = var->subs[p++];
}
ptr[j] = '\0';
*(u_char **)(void *)((u_char *)e +
work->descr->entries[i].offset) = ptr;
*(size_t *)(void *)((u_char *)e +
work->descr->entries[i].offset + sizeof(u_char *))
= len;
break;
case SNMP_SYNTAX_OID:
if (var->len < p + 1) {
seterr(&snmp_client,
"bad index: need oid length");
goto err;
}
oid.len = var->subs[p++];
if (var->len < p + oid.len) {
seterr(&snmp_client,
"bad index: oid too short");
goto err;
}
for (j = 0; j < oid.len; j++)
oid.subs[j] = var->subs[p++];
*(struct asn_oid *)(void *)((u_char *)e +
work->descr->entries[i].offset) = oid;
break;
case SNMP_SYNTAX_IPADDRESS:
if (var->len < p + 4) {
seterr(&snmp_client,
"bad index: need ip-address");
goto err;
}
for (j = 0; j < 4; j++) {
if (var->subs[p] > 0xff) {
seterr(&snmp_client,
"bad index: ipaddress too large");
goto err;
}
((u_char *)e +
work->descr->entries[i].offset)[j] =
var->subs[p++];
}
break;
case SNMP_SYNTAX_GAUGE:
if (var->len < p + 1) {
seterr(&snmp_client,
"bad index: need unsigned");
goto err;
}
if (var->subs[p] > UINT32_MAX) {
seterr(&snmp_client,
"bad index: unsigned too large");
goto err;
}
*(uint32_t *)(void *)((u_char *)e +
work->descr->entries[i].offset) = var->subs[p++];
break;
case SNMP_SYNTAX_COUNTER:
case SNMP_SYNTAX_TIMETICKS:
case SNMP_SYNTAX_COUNTER64:
case SNMP_SYNTAX_NULL:
case SNMP_SYNTAX_NOSUCHOBJECT:
case SNMP_SYNTAX_NOSUCHINSTANCE:
case SNMP_SYNTAX_ENDOFMIBVIEW:
abort();
}
e->found |= (uint64_t)1 << i;
}
/* link into the correct place */
e1 = TAILQ_FIRST(work->table);
w1 = TAILQ_FIRST(&work->worklist);
while (e1 != NULL) {
if (asn_compare_oid(&w1->index, &w->index) > 0)
break;
e1 = TAILQ_NEXT(e1, link);
w1 = TAILQ_NEXT(w1, link);
}
if (e1 == NULL) {
TAILQ_INSERT_TAIL(work->table, e, link);
TAILQ_INSERT_TAIL(&work->worklist, w, link);
} else {
TAILQ_INSERT_BEFORE(e1, e, link);
TAILQ_INSERT_BEFORE(w1, w, link);
}
return (e);
err:
/*
* Error happend. Free all octet string index parts and the entry
* itself.
*/
for (i = 0; i < work->descr->index_size; i++) {
if (work->descr->entries[i].syntax == SNMP_SYNTAX_OCTETSTRING &&
(e->found & ((uint64_t)1 << i)))
free(*(void **)(void *)((u_char *)e +
work->descr->entries[i].offset));
}
free(e);
free(w);
return (NULL);
}
/* Insert a device into a predefined position in VMBUS bus */
void
vmbus_insert_device(struct rte_vmbus_device *exist_vmbus_dev,
struct rte_vmbus_device *new_vmbus_dev)
{
TAILQ_INSERT_BEFORE(exist_vmbus_dev, new_vmbus_dev, next);
}
/*
* manual --
* Search the manuals for the pages.
*/
static int
manual(const char *page, TAG *tag, glob_t *pg)
{
ENTRY *ep, *e_sufp, *e_tag;
TAG *missp, *sufp;
int anyfound, cnt, found;
char *p, buf[MAXPATHLEN];
anyfound = 0;
buf[0] = '*';
/* Expand the search path. */
if (f_all != f_where) {
e_tag = tag == NULL ? NULL : TAILQ_FIRST(&tag->list);
while (e_tag != NULL) {
if (glob(e_tag->s, GLOB_BRACE | GLOB_NOSORT,
NULL, pg)) {
/* No GLOB_NOMATCH here due to {arch,}. */
warn("globbing directories");
(void)cleanup(0);
exit(1);
}
for (cnt = 0; cnt < pg->gl_pathc; cnt++) {
if ((ep = malloc(sizeof(ENTRY))) == NULL ||
(ep->s = strdup(pg->gl_pathv[cnt])) ==
NULL) {
warn(NULL);
(void)cleanup(0);
exit(1);
}
TAILQ_INSERT_BEFORE(e_tag, ep, q);
}
ep = e_tag;
e_tag = TAILQ_NEXT(e_tag, q);
free(ep->s);
TAILQ_REMOVE(&tag->list, ep, q);
free(ep);
globfree(pg);
pg->gl_pathc = 0;
}
}
/* For each element in the list... */
e_tag = tag == NULL ? NULL : TAILQ_FIRST(&tag->list);
for (; e_tag != NULL; e_tag = TAILQ_NEXT(e_tag, q)) {
(void)snprintf(buf, sizeof(buf), "%s/%s.*", e_tag->s, page);
switch (glob(buf, GLOB_APPEND | GLOB_BRACE | GLOB_NOSORT,
NULL, pg)) {
case (0):
break;
case (GLOB_NOMATCH):
continue;
default:
warn("globbing files");
(void)cleanup(0);
exit(1);
}
if (pg->gl_matchc == 0)
continue;
/* Find out if it's really a man page. */
for (cnt = pg->gl_pathc - pg->gl_matchc;
cnt < pg->gl_pathc; ++cnt) {
if (!f_all || !f_where) {
check_companion(pg->gl_pathv + cnt, tag);
if (*pg->gl_pathv[cnt] == '\0')
continue;
}
/*
* Try the _suffix key words first.
*
* XXX
* Older versions of man.conf didn't have the suffix
* key words, it was assumed that everything was a .0.
* We just test for .0 first, it's fast and probably
* going to hit.
*/
(void)snprintf(buf, sizeof(buf), "*/%s.0", page);
if (!fnmatch(buf, pg->gl_pathv[cnt], 0))
goto next;
e_sufp = (sufp = getlist("_suffix")) == NULL ?
NULL : TAILQ_FIRST(&sufp->list);
for (found = 0;
e_sufp != NULL; e_sufp = TAILQ_NEXT(e_sufp, q)) {
(void)snprintf(buf,
sizeof(buf), "*/%s%s", page, e_sufp->s);
if (!fnmatch(buf, pg->gl_pathv[cnt], 0)) {
found = 1;
break;
}
}
if (found)
goto next;
/* Try the _build key words next. */
e_sufp = (sufp = getlist("_build")) == NULL ?
NULL : TAILQ_FIRST(&sufp->list);
for (found = 0;
e_sufp != NULL; e_sufp = TAILQ_NEXT(e_sufp, q)) {
for (p = e_sufp->s;
*p != '\0' && !isspace(*p); ++p);
if (*p == '\0')
continue;
*p = '\0';
(void)snprintf(buf,
sizeof(buf), "*/%s%s", page, e_sufp->s);
if (!fnmatch(buf, pg->gl_pathv[cnt], 0)) {
if (!f_where)
build_page(p + 1,
&pg->gl_pathv[cnt]);
*p = ' ';
found = 1;
break;
}
*p = ' ';
}
if (found) {
next: anyfound = 1;
if (!f_all && !f_where) {
/* Delete any other matches. */
while (++cnt< pg->gl_pathc)
pg->gl_pathv[cnt] = "";
break;
}
continue;
}
/* It's not a man page, forget about it. */
pg->gl_pathv[cnt] = "";
}
if (anyfound && !f_all && !f_where)
break;
}
/* If not found, enter onto the missing list. */
if (!anyfound) {
sigset_t osigs;
sigprocmask(SIG_BLOCK, &blocksigs, &osigs);
if ((missp = getlist("_missing")) == NULL)
missp = addlist("_missing");
if ((ep = malloc(sizeof(ENTRY))) == NULL ||
(ep->s = strdup(page)) == NULL) {
warn(NULL);
(void)cleanup(0);
exit(1);
}
TAILQ_INSERT_TAIL(&missp->list, ep, q);
sigprocmask(SIG_SETMASK, &osigs, NULL);
}
return (anyfound);
}
static inline lagopus_chrono_t
s_do_sched(lagopus_callout_task_t t) {
lagopus_result_t ret = -1LL;
lagopus_result_t r;
lagopus_callout_task_t e;
s_lock_task_q();
{
s_lock_task(t);
{
if (likely(t->m_is_in_timed_q == false)) {
/*
* Firstly (re-)compute the next exeution time of this
* task.
*/
if (t->m_is_first == false && t->m_do_repeat == true) {
t->m_next_abstime = t->m_last_abstime + t->m_interval_time;
} else {
WHAT_TIME_IS_IT_NOW_IN_NSEC(t->m_last_abstime);
t->m_next_abstime = t->m_last_abstime + t->m_initial_delay_time;
}
/*
* Then insert the task into the Q.
*/
e = TAILQ_FIRST(&s_chrono_tsk_q);
if (e != NULL) {
if (e->m_next_abstime > t->m_next_abstime) {
TAILQ_INSERT_HEAD(&s_chrono_tsk_q, t, m_entry);
} else {
for (;
e != NULL && e->m_next_abstime <= t->m_next_abstime;
e = TAILQ_NEXT(e, m_entry)) {
;
}
if (e != NULL) {
TAILQ_INSERT_BEFORE(e, t, m_entry);
} else {
TAILQ_INSERT_TAIL(&s_chrono_tsk_q, t, m_entry);
}
}
} else {
TAILQ_INSERT_TAIL(&s_chrono_tsk_q, t, m_entry);
}
(void)s_set_task_state_in_table(t, TASK_STATE_ENQUEUED);
t->m_status = TASK_STATE_ENQUEUED;
t->m_is_in_timed_q = true;
ret = t->m_next_abstime;
/*
* Fianlly wake the master scheduler.
*/
lagopus_msg_debug(4, "wake the master scheduler up.\n");
/*
* TODO
*
* Re-optimize forcible wake up by timed task submission
* timing and times. See also
* callout.c:s_start_callout_main_loop()
*/
r = lagopus_bbq_wakeup(&s_urgent_tsk_q, 0LL);
if (unlikely(r != LAGOPUS_RESULT_OK)) {
lagopus_perror(r);
lagopus_msg_error("can't wake the callout task master "
"scheduler up.\n");
}
}
}
s_unlock_task(t);
}
s_unlock_task_q();
return ret;
}
/* -----------------------------------------------------------------------------
attach L2TP interface dlil layer
----------------------------------------------------------------------------- */
int l2tp_wan_attach(void *rfc, struct ppp_link **link)
{
int ret;
struct l2tp_wan *wan, *wan1;
struct ppp_link *lk;
u_short unit;
lck_mtx_assert(ppp_domain_mutex, LCK_MTX_ASSERT_OWNED);
// Note : we allocate/find number/insert in queue in that specific order
// because of funnels and race condition issues
MALLOC(wan, struct l2tp_wan *, sizeof(struct l2tp_wan), M_TEMP, M_WAITOK);
if (!wan)
return ENOMEM;
bzero(wan, sizeof(struct l2tp_wan));
// find a unit and where to insert it, keep the list ordered
unit = 0;
wan1 = TAILQ_FIRST(&l2tp_wan_head);
while (wan1) {
if (wan1->link.lk_unit > unit)
break;
unit = wan1->link.lk_unit + 1;
wan1 = TAILQ_NEXT(wan1, next);
}
if (wan1)
TAILQ_INSERT_BEFORE(wan1, wan, next);
else
TAILQ_INSERT_TAIL(&l2tp_wan_head, wan, next);
lk = (struct ppp_link *) wan;
// it's time now to register our brand new link
lk->lk_name = (u_char*)L2TP_NAME;
lk->lk_mtu = L2TP_MTU;
lk->lk_mru = L2TP_MTU;;
lk->lk_type = PPP_TYPE_L2TP;
lk->lk_hdrlen = 80; // ???
l2tp_rfc_command(rfc, L2TP_CMD_GETBAUDRATE, &lk->lk_baudrate);
lk->lk_ioctl = l2tp_wan_ioctl;
lk->lk_output = l2tp_wan_output;
lk->lk_unit = unit;
lk->lk_support = 0;
wan->rfc = rfc;
ret = ppp_link_attach((struct ppp_link *)wan);
if (ret) {
IOLog("L2TP_wan_attach, error = %d, (ld = %p)\n", ret, wan);
TAILQ_REMOVE(&l2tp_wan_head, wan, next);
FREE(wan, M_TEMP);
return ret;
}
//IOLog("L2TP_wan_attach, link index = %d, (ld = %p)\n", lk->lk_index, lk);
*link = lk;
return 0;
}
