/* * Insert an additional listener in to the sorted list of listeners */ void add_listener(struct Listener_head *listeners, struct Listener *listener) { assert(listeners != NULL); assert(listener != NULL); assert(listener->address != NULL); listener_ref_get(listener); if (SLIST_FIRST(listeners) == NULL || address_compare(listener->address, SLIST_FIRST(listeners)->address) < 0) { SLIST_INSERT_HEAD(listeners, listener, entries); return; } struct Listener *iter; SLIST_FOREACH(iter, listeners, entries) { if (SLIST_NEXT(iter, entries) == NULL || address_compare(listener->address, SLIST_NEXT(iter, entries)->address) < 0) { SLIST_INSERT_AFTER(iter, listener, entries); return; } } }
/* * Unregister all hooks and cookies for that module. Note: doesn't disconnect * any hooks! */ void ng_unregister_module(const struct lmodule *mod) { struct msgreg *m, *m1; struct datareg *d, *d1; m = SLIST_FIRST(&msgreg_list); while (m != NULL) { m1 = SLIST_NEXT(m, link); if (m->mod == mod) { SLIST_REMOVE(&msgreg_list, m, msgreg, link); free(m); } m = m1; } d = SLIST_FIRST(&datareg_list); while (d != NULL) { d1 = SLIST_NEXT(d, link); if (d->mod == mod) { SLIST_REMOVE(&datareg_list, d, datareg, link); free(d); } d = d1; } }
static struct pgt *pop_least_used_from_cache_list(void) { struct pgt *pgt; struct pgt *p_prev = NULL; size_t least_used; pgt = SLIST_FIRST(&pgt_cache_list); if (!pgt) return NULL; if (!pgt->num_used_entries) goto out; least_used = pgt->num_used_entries; while (true) { if (!SLIST_NEXT(pgt, link)) break; if (SLIST_NEXT(pgt, link)->num_used_entries <= least_used) { p_prev = pgt; least_used = SLIST_NEXT(pgt, link)->num_used_entries; } pgt = SLIST_NEXT(pgt, link); } out: if (p_prev) { pgt = SLIST_NEXT(p_prev, link); SLIST_REMOVE_AFTER(p_prev, link); } else { pgt = SLIST_FIRST(&pgt_cache_list); SLIST_REMOVE_HEAD(&pgt_cache_list, link); } return pgt; }
void listeners_reload(struct Listener_head *existing_listeners, struct Listener_head *new_listeners, const struct Table_head *tables, struct ev_loop *loop) { struct Listener *iter_existing = SLIST_FIRST(existing_listeners); struct Listener *iter_new = SLIST_FIRST(new_listeners); while (iter_existing != NULL || iter_new != NULL) { int compare_result; char address[ADDRESS_BUFFER_SIZE]; if (iter_existing == NULL) compare_result = 1; else if (iter_new == NULL) compare_result = -1; else compare_result = address_compare(iter_existing->address, iter_new->address); if (compare_result > 0) { struct Listener *new_listener = iter_new; iter_new = SLIST_NEXT(iter_new, entries); notice("Listener %s added.", display_address(new_listener->address, address, sizeof(address))); SLIST_REMOVE(new_listeners, new_listener, Listener, entries); add_listener(existing_listeners, new_listener); init_listener(new_listener, tables, loop); /* -1 for removing from new_listeners */ listener_ref_put(new_listener); } else if (compare_result == 0) { notice ("Listener %s updated.", display_address(iter_existing->address, address, sizeof(address))); listener_update(iter_existing, iter_new, tables); iter_existing = SLIST_NEXT(iter_existing, entries); iter_new = SLIST_NEXT(iter_new, entries); } else { struct Listener *removed_listener = iter_existing; iter_existing = SLIST_NEXT(iter_existing, entries); notice("Listener %s removed.", display_address(removed_listener->address, address, sizeof(address))); SLIST_REMOVE(existing_listeners, removed_listener, Listener, entries); close_listener(loop, removed_listener); /* -1 for removing from existing_listeners */ listener_ref_put(removed_listener); } } }
void uicb_screen_prev(Uicb cmd) { struct screen *s = SLIST_FIRST(&W->h.screen); (void)cmd; while(SLIST_NEXT(s, next) && SLIST_NEXT(s, next) != s) s = SLIST_NEXT(s, next); screen_select(s); }
void uicb_screen_move_client_prev(Uicb cmd) { struct screen *s = SLIST_FIRST(&W->h.screen); (void)cmd; while(SLIST_NEXT(s, next) && SLIST_NEXT(s, next) != s) s = SLIST_NEXT(s, next); if(W->client) tag_client(s->seltag, W->client); }
int main(int argc, char **argv) { struct head root; SLIST_INIT(&root); addnodes(&root, 2); addnodes(&SLIST_FIRST(&root)->children, 4); addnodes(&SLIST_NEXT(SLIST_FIRST(&root), links)->children, 2); // dumptree output: // // 1 // 3 // 2 // 1 // 0 // 0 // 1 // 0 dumptree(&root, 0); /* free_tree(&root); */ }
/* * Called by UART driver to send out next character. * * Interrupts disabled when nmgr_uart_tx_char/nmgr_uart_rx_char are called. */ static int nmgr_uart_tx_char(void *arg) { struct nmgr_uart_state *nus = (struct nmgr_uart_state *)arg; struct os_mbuf *m; uint8_t ch; if (!nus->nus_tx) { /* * Out of data. Return -1 makes UART stop asking for more. */ return -1; } while (nus->nus_tx->om_len == nus->nus_tx_off) { /* * If no active mbuf, move to next one. */ m = SLIST_NEXT(nus->nus_tx, om_next); os_mbuf_free(nus->nus_tx); nus->nus_tx = m; nus->nus_tx_off = 0; if (!nus->nus_tx) { return -1; } } os_mbuf_copydata(nus->nus_tx, nus->nus_tx_off++, 1, &ch); return ch; }
void hashtable_delete(const char *key, uint32_t klen, struct hash_table *ht) { struct item_slh *bucket; struct item *it, *prev; ASSERT(hashtable_get(key, klen, ht) != NULL); bucket = _get_bucket(key, klen, ht); for (prev = NULL, it = SLIST_FIRST(bucket); it != NULL; prev = it, it = SLIST_NEXT(it, i_sle)) { /* iterate through bucket to find item to be removed */ if ((klen == it->klen) && cc_memcmp(key, item_key(it), klen) == 0) { /* found item */ break; } } if (prev == NULL) { SLIST_REMOVE_HEAD(bucket, i_sle); } else { SLIST_REMOVE_AFTER(prev, i_sle); } --(ht->nhash_item); }
static struct pgt *pop_from_cache_list(vaddr_t vabase, void *ctx) { struct pgt *pgt; struct pgt *p; pgt = SLIST_FIRST(&pgt_cache_list); if (!pgt) return NULL; if (match_pgt(pgt, vabase, ctx)) { SLIST_REMOVE_HEAD(&pgt_cache_list, link); return pgt; } while (true) { p = SLIST_NEXT(pgt, link); if (!p) break; if (match_pgt(p, vabase, ctx)) { SLIST_REMOVE_AFTER(pgt, link); break; } pgt = p; } return p; }
static void readdumptimes(FILE *df) { int i; struct dumptime *dtwalk; for (;;) { dtwalk = (struct dumptime *)calloc(1, sizeof (struct dumptime)); if (getrecord(df, &(dtwalk->dt_value)) < 0) { free(dtwalk); break; } nddates++; SLIST_INSERT_HEAD(&dthead, dtwalk, dt_list); } /* * arrayify the list, leaving enough room for the additional * record that we may have to add to the ddate structure */ ddatev = (struct dumpdates **) calloc((unsigned) (nddates + 1), sizeof (struct dumpdates *)); dtwalk = SLIST_FIRST(&dthead); for (i = nddates - 1; i >= 0; i--, dtwalk = SLIST_NEXT(dtwalk, dt_list)) ddatev[i] = &dtwalk->dt_value; }
ENTRY * hsearch(ENTRY item, ACTION action) { struct internal_head *head; struct internal_entry *ie; uint32_t hashval; size_t len; len = strlen(item.key); hashval = (*__default_hash)(item.key, len); head = &htable[hashval & (htablesize - 1)]; ie = SLIST_FIRST(head); while (ie != NULL) { if (strcmp(ie->ent.key, item.key) == 0) break; ie = SLIST_NEXT(ie, link); } if (ie != NULL) return &ie->ent; else if (action == FIND) return NULL; ie = malloc(sizeof *ie); if (ie == NULL) return NULL; ie->ent.key = item.key; ie->ent.data = item.data; SLIST_INSERT_HEAD(head, ie, link); return &ie->ent; }
/** * \fn order_remove * * \brief order the remove list according to dependency level */ Plisthead * order_remove(Plisthead *deptreehead) { int i, maxlevel = 0; Pkglist *pdp, *next; Plisthead *ordtreehead; /* package removal cannot trust recorded dependencies, reorder */ remove_dep_deepness(deptreehead); SLIST_FOREACH(pdp, deptreehead, next) if (pdp->level > maxlevel) maxlevel = pdp->level; ordtreehead = init_head(); for (i = maxlevel; i >= 0; i--) { pdp = SLIST_FIRST(deptreehead); while (pdp != NULL) { next = SLIST_NEXT(pdp, next); if (pdp->level == i) { SLIST_REMOVE(deptreehead, pdp, Pkglist, next); SLIST_INSERT_HEAD(ordtreehead, pdp, next); } pdp = next; } } return ordtreehead; }
int nffs_dir_read(struct nffs_dir *dir, struct nffs_dirent **out_dirent) { struct nffs_inode_entry *child; int rc; if (dir->nd_dirent.nde_inode_entry == NULL) { child = SLIST_FIRST(&dir->nd_parent_inode_entry->nie_child_list); } else { child = SLIST_NEXT(dir->nd_dirent.nde_inode_entry, nie_sibling_next); rc = nffs_inode_dec_refcnt(dir->nd_dirent.nde_inode_entry); if (rc != 0) { /* XXX: Need to clean up anything? */ return rc; } } dir->nd_dirent.nde_inode_entry = child; if (child == NULL) { *out_dirent = NULL; return FS_ENOENT; } child->nie_refcnt++; *out_dirent = &dir->nd_dirent; return 0; }
void alarmsProcess(void) { // // Note that this code works in the way that neither locking the list // nor disabling interrupts is required // uint32_t now = (uint32_t) getJiffies(); // PRINTF("processAlarms: jiffies=%lu\n", now); Alarm_t **a = &SLIST_FIRST(&alarmListHead); while (*a) { Alarm_t *ap = *a; // the alarm must have valid callback ASSERT(ap->callback != NULL); // PRINTF("processAlarms: ap=%p, ap->jiffies=%lu\n", ap, ap->jiffies); if (timeAfter32(ap->jiffies, now)) { break; } // save next alarm for later reference Alarm_t **next = &SLIST_NEXT(ap, chain); // remove the alarm from the list *a = *next; // call the callback ap->callback(ap->data); // move to the next a = next; } }
void alarmSchedule(Alarm_t *alarm, uint32_t milliseconds) { // we want to avoid inserting local variables in the global alarm list // (but this warning, not an error, because the user function may never return) WARN_ON(isStackAddress(alarm)); // PRINTF("alarmSchedule %p, ms=%lu\n", alarm, milliseconds); alarm->jiffies = (uint32_t)getJiffies() + milliseconds; // locking is required, because both kernel and user threads can be using this function Handle_t h; ATOMIC_START(h); // unschedule the alarm, if it was already scheduled SLIST_REMOVE_SAFE(&alarmListHead, alarm, Alarm_s, chain); // insert it in appropriate position Alarm_t **prev = &SLIST_FIRST(&alarmListHead); Alarm_t *a = *prev; while (a && timeAfter32(alarm->jiffies, a->jiffies)) { prev = &SLIST_NEXT(a, chain); a = *prev; } SLIST_INSERT(prev, alarm, chain); #if USE_THREADS // always reschedule alarm processing in case some alarm was added // that might need to be processed before end of current kernel sleep time processFlags.bits.alarmsProcess = true; // and make sure the kernel thread is awake and ready to deal with it threadWakeup(KERNEL_THREAD_INDEX, THREAD_READY); #endif ATOMIC_END(h); }
/* * Receive a character from UART. */ static int nmgr_uart_rx_char(void *arg, uint8_t data) { struct nmgr_uart_state *nus = (struct nmgr_uart_state *)arg; struct os_mbuf *m; int rc; if (!nus->nus_rx) { m = os_msys_get_pkthdr(SHELL_NLIP_MAX_FRAME, 0); if (!m) { return 0; } nus->nus_rx = OS_MBUF_PKTHDR(m); if (OS_MBUF_TRAILINGSPACE(m) < SHELL_NLIP_MAX_FRAME) { /* * mbuf is too small. */ os_mbuf_free_chain(m); nus->nus_rx = NULL; return 0; } } m = OS_MBUF_PKTHDR_TO_MBUF(nus->nus_rx); if (data == '\n') { /* * Full line of input. Process it outside interrupt context. */ assert(!nus->nus_rx_q); nus->nus_rx_q = nus->nus_rx; nus->nus_rx = NULL; os_eventq_put(g_mgmt_evq, &nus->nus_cb_ev); return 0; } else { rc = os_mbuf_append(m, &data, 1); if (rc == 0) { return 0; } } /* failed */ nus->nus_rx->omp_len = 0; m->om_len = 0; os_mbuf_free_chain(SLIST_NEXT(m, om_next)); SLIST_NEXT(m, om_next) = NULL; return 0; }
static struct scan_entry * find_old_scan(const char *location) { struct scan_entry *e; char *dep, *dep2, *path, *fullpath; int is_current; time_t mtime; e = SLIST_FIRST(&hash_table[hash_entry(location)]); while (e) { if (strcmp(e->location, location) == 0) break; e = SLIST_NEXT(e, hash_link); } if (e == NULL) return NULL; if (e->scan_depends == NULL) return e; is_current = 1; dep2 = dep = xstrdup(e->scan_depends); while ((path = strtok(dep, " ")) != NULL) { dep = NULL; if (*path == '\0') continue; if (*path == '/') { mtime = stat_path(path); if (mtime == -1 || mtime >= scan_mtime) { is_current = 0; break; } continue; } if (strncmp("../../", path, 6) == 0) { const char *s1 = strrchr(location, '/'); const char *s2 = strchr(location, '/'); if (s1 == s2) fullpath = xasprintf("%s/%s", pkgsrc_tree, path + 6); else fullpath = xasprintf("%s/%s/%s", pkgsrc_tree, location, path); } else { fullpath = xasprintf("%s/%s/%s", pkgsrc_tree, location, path); } mtime = stat_path(fullpath); if (mtime == -1 || mtime >= scan_mtime) { is_current = 0; break; } } free(dep2); return is_current ? e : NULL; }
static void flush_ctx_range_from_list(struct pgt_cache *pgt_cache, void *ctx, vaddr_t begin, vaddr_t last) { struct pgt *p; struct pgt *next_p; /* * Do the special case where the first element in the list is * removed first. */ p = SLIST_FIRST(pgt_cache); while (pgt_entry_matches(p, ctx, begin, last)) { flush_pgt_entry(p); SLIST_REMOVE_HEAD(pgt_cache, link); push_to_free_list(p); p = SLIST_FIRST(pgt_cache); } /* * p either points to the first element in the list or it's NULL, * if NULL the list is empty and we're done. */ if (!p) return; /* * Do the common case where the next element in the list is * removed. */ while (true) { next_p = SLIST_NEXT(p, link); if (!next_p) break; if (pgt_entry_matches(next_p, ctx, begin, last)) { flush_pgt_entry(next_p); SLIST_REMOVE_AFTER(p, link); push_to_free_list(next_p); continue; } p = SLIST_NEXT(p, link); } }
/** * Allocate a pdu (chain) for reception. * * @param len * * @return struct os_mbuf* */ struct os_mbuf * ble_ll_rxpdu_alloc(uint16_t len) { uint16_t mb_bytes; struct os_mbuf *m; struct os_mbuf *n; struct os_mbuf *p; struct os_mbuf_pkthdr *pkthdr; p = os_msys_get_pkthdr(len, sizeof(struct ble_mbuf_hdr)); if (!p) { goto rxpdu_alloc_exit; } /* Set packet length */ pkthdr = OS_MBUF_PKTHDR(p); pkthdr->omp_len = len; /* * NOTE: first mbuf in chain will have data pre-pended to it so we adjust * m_data by a word. */ p->om_data += 4; mb_bytes = (p->om_omp->omp_databuf_len - p->om_pkthdr_len - 4); if (mb_bytes < len) { n = p; len -= mb_bytes; while (len) { m = os_msys_get(len, 0); if (!m) { os_mbuf_free_chain(p); p = NULL; goto rxpdu_alloc_exit; } /* Chain new mbuf to existing chain */ SLIST_NEXT(n, om_next) = m; n = m; mb_bytes = m->om_omp->omp_databuf_len; if (mb_bytes >= len) { len = 0; } else { len -= mb_bytes; } } } rxpdu_alloc_exit: if (!p) { STATS_INC(ble_ll_stats, no_bufs); } return p; }
void uicb_screen_next(Uicb cmd) { struct screen *s = SLIST_NEXT(W->screen, next); (void)cmd; if(!s) s = SLIST_FIRST(&W->h.screen); screen_select(s); }
uint16_t chr_end_handle(struct bletiny_svc *svc, struct bletiny_chr *chr) { struct bletiny_chr *next_chr; next_chr = SLIST_NEXT(chr, next); if (next_chr != NULL) { return next_chr->chr.def_handle - 1; } else { return svc->svc.end_handle; } }
void uicb_screen_move_client_next(Uicb cmd) { struct screen *s = SLIST_NEXT(W->screen, next); (void)cmd; if(!s) s = SLIST_FIRST(&W->h.screen); if(W->client) tag_client(s->seltag, W->client); }
void symlist_free(symlist_t *symlist) { symbol_node_t *node1, *node2; node1 = SLIST_FIRST(symlist); while (node1 != NULL) { node2 = SLIST_NEXT(node1, links); free(node1); node1 = node2; } SLIST_INIT(symlist); }
symbol_node_t * symlist_search(symlist_t *symlist, char *symname) { symbol_node_t *curnode; curnode = SLIST_FIRST(symlist); while(curnode != NULL) { if (strcmp(symname, curnode->symbol->name) == 0) break; curnode = SLIST_NEXT(curnode, links); } return (curnode); }
static int rc_sect_free(struct rcsection *rsp) { struct rckey *p,*n; for(p = SLIST_FIRST(&rsp->rs_keys);p;) { n = p; p = SLIST_NEXT(p,rk_next); rc_key_free(n); } free(rsp->rs_name); free(rsp); return 0; }
int rc_close(struct rcfile *rcp) { struct rcsection *p,*n; fclose(rcp->rf_f); for(p = SLIST_FIRST(&rcp->rf_sect);p;) { n = p; p = SLIST_NEXT(p,rs_next); rc_sect_free(n); } free(rcp->rf_name); SLIST_REMOVE(&pf_head, rcp, rcfile, rf_next); free(rcp); return 0; }
static int rc_freesect(struct rcfile *rcp, struct rcsection *rsp) { struct rckey *p,*n; SLIST_REMOVE(&rcp->rf_sect, rsp, rcsection, rs_next); for(p = SLIST_FIRST(&rsp->rs_keys);p;) { n = p; p = SLIST_NEXT(p,rk_next); rc_key_free(n); } free(rsp->rs_name); free(rsp); return 0; }
void print_mbuf(const struct os_mbuf *om) { int colon; colon = 0; while (om != NULL) { if (colon) { console_printf(":"); } else { colon = 1; } print_bytes(om->om_data, om->om_len); om = SLIST_NEXT(om, om_next); } }
static int process_device_object(CborEncoder *device, const char *uuid, const char *rt, int rt_len) { int dev, matches = 0; #ifdef OC_SERVER oc_resource_t *resource; #endif oc_rep_start_object(*device, links); oc_rep_set_text_string(links, di, uuid); oc_rep_set_array(links, links); if (filter_resource(oc_core_get_resource_by_index(OCF_P), rt, rt_len, oc_rep_array(links))) matches++; for (dev = 0; dev < oc_core_get_num_devices(); dev++) { if (filter_resource( oc_core_get_resource_by_index(NUM_OC_CORE_RESOURCES - 1 - dev), rt, rt_len, oc_rep_array(links))) matches++; } #ifdef OC_SERVER for (resource = oc_ri_get_app_resources(); resource; resource = SLIST_NEXT(resource, next)) { if (!(resource->properties & OC_DISCOVERABLE)) { continue; } if (filter_resource(resource, rt, rt_len, oc_rep_array(links))) { matches++; } } #endif #ifdef OC_SECURITY if (filter_resource(oc_core_get_resource_by_index(OCF_SEC_DOXM), rt, rt_len, oc_rep_array(links))) matches++; #endif oc_rep_close_array(links, links); oc_rep_end_object(*device, links); return matches; }