/* * test_list - Do some basic list manipulations and output to log for * script comparison. Only testing the macros we use. */ static void test_list(void) { PTEST_LIST_NODE pNode = NULL; struct TestList head = LIST_HEAD_INITIALIZER(head); LIST_INIT(&head); UT_ASSERT_rt(LIST_EMPTY(&head)); pNode = MALLOC(sizeof(struct TEST_LIST_NODE)); pNode->dummy = 0; LIST_INSERT_HEAD(&head, pNode, ListEntry); UT_ASSERTeq_rt(1, get_list_count(&head)); dump_list(&head); /* Remove one node */ LIST_REMOVE(pNode, ListEntry); UT_ASSERTeq_rt(0, get_list_count(&head)); dump_list(&head); free(pNode); /* Add a bunch of nodes */ for (int i = 1; i < 10; i++) { pNode = MALLOC(sizeof(struct TEST_LIST_NODE)); pNode->dummy = i; LIST_INSERT_HEAD(&head, pNode, ListEntry); } UT_ASSERTeq_rt(9, get_list_count(&head)); dump_list(&head); /* Remove all of them */ while (!LIST_EMPTY(&head)) { pNode = (PTEST_LIST_NODE)LIST_FIRST(&head); LIST_REMOVE(pNode, ListEntry); free(pNode); } UT_ASSERTeq_rt(0, get_list_count(&head)); dump_list(&head); }
#include <sys/kernel.h> #include <sys/mbuf.h> #include <sys/proc.h> #include <sys/socketvar.h> #include <sys/systm.h> #include <netbt/bluetooth.h> #include <netbt/hci.h> #include <netbt/sco.h> /**************************************************************************** * * SCO - Upper Protocol API */ struct sco_pcb_list sco_pcb = LIST_HEAD_INITIALIZER(sco_pcb); /* * sco_attach(handle, proto, upper) * * Attach a new instance of SCO pcb to handle */ int sco_attach(struct sco_pcb **handle, const struct btproto *proto, void *upper) { struct sco_pcb *pcb; KASSERT(handle != NULL); KASSERT(proto != NULL); KASSERT(upper != NULL);
#define USB_MEM_BLOCK (USB_MEM_SMALL * USB_MEM_CHUNKS) /* This struct is overlayed on free fragments. */ struct usb_frag_dma { usb_dma_block_t *block; u_int offs; LIST_ENTRY(usb_frag_dma) next; }; static bus_dmamap_callback_t usbmem_callback; static usbd_status usb_block_allocmem(bus_dma_tag_t, size_t, size_t, usb_dma_block_t **); static void usb_block_freemem(usb_dma_block_t *); static LIST_HEAD(, usb_dma_block) usb_blk_freelist = LIST_HEAD_INITIALIZER(usb_blk_freelist); static int usb_blk_nfree = 0; /* XXX should have different free list for different tags (for speed) */ static LIST_HEAD(, usb_frag_dma) usb_frag_freelist = LIST_HEAD_INITIALIZER(usb_frag_freelist); static void usbmem_callback(void *arg, bus_dma_segment_t *segs, int nseg, int error) { int i; usb_dma_block_t *p = arg; if (error == EFBIG) { printf("usb: mapping to large\n"); return; }
int ifqmaxlen = IFQ_MAXLEN; struct ifnethead ifnet; /* depend on static init XXX */ #ifdef INET6 /* * XXX: declare here to avoid to include many inet6 related files.. * should be more generalized? */ extern void nd6_setmtu __P((struct ifnet *)); #endif struct if_clone *if_clone_lookup __P((const char *, int *)); int if_clone_list __P((struct if_clonereq *)); LIST_HEAD(, if_clone) if_cloners = LIST_HEAD_INITIALIZER(if_cloners); int if_cloners_count; /* * Network interface utility routines. * * Routines with ifa_ifwith* names take sockaddr *'s as * parameters. */ /* ARGSUSED*/ void ifinit(dummy) void *dummy; { #ifdef DEBUG_IFINIT struct ifnet *ifp;
#include <sys/conf.h> #include <sys/kernel.h> #include <sys/malloc.h> #include <sys/module.h> #include <sys/queue.h> #include <sys/fbio.h> #include <machine/bus.h> #include <dev/vt/vt.h> #include <dev/vt/hw/fb/vt_fb.h> #include "fb_if.h" LIST_HEAD(fb_list_head_t, fb_list_entry) fb_list_head = LIST_HEAD_INITIALIZER(fb_list_head); struct fb_list_entry { struct fb_info *fb_info; struct cdev *fb_si; LIST_ENTRY(fb_list_entry) fb_list; }; struct fbd_softc { device_t sc_dev; struct fb_info *sc_info; }; static void fbd_evh_init(void *); /* SI_ORDER_SECOND, just after EVENTHANDLERs initialized. */ SYSINIT(fbd_evh_init, SI_SUB_CONFIGURE, SI_ORDER_SECOND, fbd_evh_init, NULL);
#include <fcntl.h> #include <string.h> #include <unistd.h> #include "tmux.h" /* * Job scheduling. Run queued commands in the background and record their * output. */ void job_callback(struct bufferevent *, short, void *); /* All jobs list. */ struct joblist all_jobs = LIST_HEAD_INITIALIZER(all_jobs); /* Start a job running, if it isn't already. */ struct job * job_run(const char *cmd, void (*callbackfn)(struct job *), void (*freefn)(void *), void *data) { struct job *job; struct environ env; pid_t pid; int nullfd, out[2]; if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, out) != 0) return (NULL); environ_init(&env);
}; struct g_class g_md_class = { .name = "MD", .version = G_VERSION, .init = g_md_init, .fini = g_md_fini, .start = g_md_start, .access = g_md_access, .dumpconf = g_md_dumpconf, }; DECLARE_GEOM_CLASS(g_md_class, g_md); static LIST_HEAD(, md_s) md_softc_list = LIST_HEAD_INITIALIZER(md_softc_list); #define NINDIR (PAGE_SIZE / sizeof(uintptr_t)) #define NMASK (NINDIR-1) static int nshift; static int md_vnode_pbuf_freecnt; struct indir { uintptr_t *array; u_int total; u_int used; u_int shift; }; struct md_s {
static void disk_probe(struct disk *dp, int reprobe); static void _setdiskinfo(struct disk *disk, struct disk_info *info); static void bioqwritereorder(struct bio_queue_head *bioq); static void disk_cleanserial(char *serno); static int disk_debug(int, char *, ...) __printflike(2, 3); static cdev_t _disk_create_named(const char *name, int unit, struct disk *dp, struct dev_ops *raw_ops, int clone); static d_open_t diskopen; static d_close_t diskclose; static d_ioctl_t diskioctl; static d_strategy_t diskstrategy; static d_psize_t diskpsize; static d_dump_t diskdump; static LIST_HEAD(, disk) disklist = LIST_HEAD_INITIALIZER(&disklist); static struct lwkt_token disklist_token; static struct dev_ops disk_ops = { { "disk", 0, D_DISK | D_MPSAFE | D_TRACKCLOSE }, .d_open = diskopen, .d_close = diskclose, .d_read = physread, .d_write = physwrite, .d_ioctl = diskioctl, .d_strategy = diskstrategy, .d_dump = diskdump, .d_psize = diskpsize, }; static struct objcache *disk_msg_cache;
/* * The vnode of the system's root (/ in the filesystem, without chroot * active.) */ struct vnode *rootvnode; char *rootdevnames[2] = {NULL, NULL}; struct root_hold_token { const char *who; LIST_ENTRY(root_hold_token) list; }; static LIST_HEAD(, root_hold_token) root_holds = LIST_HEAD_INITIALIZER(root_holds); enum action { A_CONTINUE, A_PANIC, A_REBOOT, A_RETRY }; static enum action root_mount_onfail = A_CONTINUE; static int root_mount_mddev; static int root_mount_complete; /* By default wait up to 3 seconds for devices to appear. */ static int root_mount_timeout = 3;
* allocate more. */ #define SNOOP_MAXLEN (64*1024) /* This one also,64K enough * If we grow more,something * really bad in this world.. */ static MALLOC_DEFINE(M_SNP, "snp", "Snoop device data"); /* * The number of the "snoop" line discipline. This gets determined at * module load time. */ static int snooplinedisc; static LIST_HEAD(, snoop) snp_sclist = LIST_HEAD_INITIALIZER(&snp_sclist); static struct tty *snpdevtotty (cdev_t dev); static int snp_detach (struct snoop *snp); static int snp_down (struct snoop *snp); static int snp_in (struct snoop *snp, char *buf, int n); static int snp_modevent (module_t mod, int what, void *arg); static int snplclose(struct tty *tp, int flag) { struct snoop *snp; int error; lwkt_gettoken(&tty_token); snp = tp->t_sc;
#if defined(VMEM_SANITY) static void vmem_check(vmem_t *); #else /* defined(VMEM_SANITY) */ #define vmem_check(vm) /* nothing */ #endif /* defined(VMEM_SANITY) */ #define VMEM_HASHSIZE_MIN 1 /* XXX */ #define VMEM_HASHSIZE_MAX 65536 /* XXX */ #define VMEM_HASHSIZE_INIT 1 #define VM_FITMASK (VM_BESTFIT | VM_INSTANTFIT) #if defined(_KERNEL) static bool vmem_bootstrapped = false; static kmutex_t vmem_list_lock; static LIST_HEAD(, vmem) vmem_list = LIST_HEAD_INITIALIZER(vmem_list); #endif /* defined(_KERNEL) */ /* ---- misc */ #define VMEM_LOCK(vm) mutex_enter(&vm->vm_lock) #define VMEM_TRYLOCK(vm) mutex_tryenter(&vm->vm_lock) #define VMEM_UNLOCK(vm) mutex_exit(&vm->vm_lock) #define VMEM_LOCK_INIT(vm, ipl) mutex_init(&vm->vm_lock, MUTEX_DEFAULT, ipl) #define VMEM_LOCK_DESTROY(vm) mutex_destroy(&vm->vm_lock) #define VMEM_ASSERT_LOCKED(vm) KASSERT(mutex_owned(&vm->vm_lock)) #define VMEM_ALIGNUP(addr, align) \ (-(-(addr) & -(align))) #define VMEM_CROSS_P(addr1, addr2, boundary) \
if (pg->flags & PG_WANTED) wakeup(pg); TAILQ_REMOVE(&uobj->memq, pg, listq.queue); kmem_free((void *)pg->uanon, PAGE_SIZE); kmem_free(pg, sizeof(*pg)); } struct rumpva { vaddr_t addr; struct vm_page *pg; LIST_ENTRY(rumpva) entries; }; static LIST_HEAD(, rumpva) rvahead = LIST_HEAD_INITIALIZER(rvahead); static kmutex_t rvamtx; void rumpvm_enterva(vaddr_t addr, struct vm_page *pg) { struct rumpva *rva; rva = kmem_alloc(sizeof(struct rumpva), KM_SLEEP); rva->addr = addr; rva->pg = pg; mutex_enter(&rvamtx); LIST_INSERT_HEAD(&rvahead, rva, entries); mutex_exit(&rvamtx); }
return (NULL); return (strcpy(xalloc(strlen(s) + 1), s)); } /************************************************************ * * Input stack */ struct input { FILE *fp; u_int lno; char *fname; char *path; LIST_ENTRY(input) link; }; LIST_HEAD(, input) inputs = LIST_HEAD_INITIALIZER(inputs); struct input *input = NULL; int pbchar = -1; #if !defined(MAX_PATHS) #define MAX_PATHS 100 #endif static const char *paths[MAX_PATHS + 1] = { #if defined(DEFSDIR) DEFSDIR, #endif #if defined(LOCAL_DEFSDIR) LOCAL_DEFSDIR, #endif NULL
#include <eal_private.h> #define NS_PER_US 1000 #define US_PER_MS 1000 #define MS_PER_S 1000 #define US_PER_S (US_PER_MS * MS_PER_S) struct alarm_entry { LIST_ENTRY(alarm_entry) next; struct timeval time; rte_eal_alarm_callback cb_fn; void *cb_arg; volatile int executing; }; static LIST_HEAD(alarm_list, alarm_entry) alarm_list = LIST_HEAD_INITIALIZER(); static rte_spinlock_t alarm_list_lk = RTE_SPINLOCK_INITIALIZER; static struct rte_intr_handle intr_handle = {.fd = -1 }; static int handler_registered = 0; static void eal_alarm_callback(struct rte_intr_handle *hdl, void *arg); int rte_eal_alarm_init(void) { intr_handle.type = RTE_INTR_HANDLE_ALARM; /* create a timerfd file descriptor */ intr_handle.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK); if (intr_handle.fd == -1) goto error;
#include <compat/ndis/pe_var.h> #include <compat/ndis/cfg_var.h> #include <compat/ndis/resource_var.h> #include <compat/ndis/ntoskrnl_var.h> #include <compat/ndis/ndis_var.h> #include <compat/ndis/hal_var.h> #include <compat/ndis/usbd_var.h> #ifdef __amd64__ struct fpu_cc_ent { struct fpu_kern_ctx *ctx; LIST_ENTRY(fpu_cc_ent) entries; }; static LIST_HEAD(fpu_ctx_free, fpu_cc_ent) fpu_free_head = LIST_HEAD_INITIALIZER(fpu_free_head); static LIST_HEAD(fpu_ctx_busy, fpu_cc_ent) fpu_busy_head = LIST_HEAD_INITIALIZER(fpu_busy_head); static struct mtx fpu_free_mtx; static struct mtx fpu_busy_mtx; #endif static struct mtx drvdb_mtx; static STAILQ_HEAD(drvdb, drvdb_ent) drvdb_head; static driver_object fake_pci_driver; /* serves both PCI and cardbus */ static driver_object fake_pccard_driver; #ifdef __i386__ static void x86_oldldt(void *); static void x86_newldt(void *);
#include <sys/param.h> #include <sys/device.h> #include <sys/ioctl.h> #include <sys/malloc.h> #include <sys/queue.h> #include <sys/systm.h> #include <dev/biovar.h> struct bio_mapping { LIST_ENTRY(bio_mapping) bm_link; struct device *bm_dev; int (*bm_ioctl)(struct device *, u_long, caddr_t); }; LIST_HEAD(, bio_mapping) bios = LIST_HEAD_INITIALIZER(bios); void bioattach(int); int bioclose(dev_t, int, int, struct proc *); int bioioctl(dev_t, u_long, caddr_t, int, struct proc *); int bioopen(dev_t, int, int, struct proc *); int bio_delegate_ioctl(struct bio_mapping *, u_long, caddr_t); struct bio_mapping *bio_lookup(char *); int bio_validate(void *); void bioattach(int nunits) { }
static db_cmdfcn_t db_halt; static db_cmdfcn_t db_kill; static db_cmdfcn_t db_reset; static db_cmdfcn_t db_stack_trace; static db_cmdfcn_t db_stack_trace_all; static db_cmdfcn_t db_watchdog; /* * 'show' commands */ static struct command db_show_all_cmds[] = { { "trace", db_stack_trace_all, 0, 0 }, }; struct command_table db_show_all_table = LIST_HEAD_INITIALIZER(db_show_all_table); static struct command db_show_cmds[] = { { "all", 0, 0, &db_show_all_table }, { "registers", db_show_regs, 0, 0 }, { "breaks", db_listbreak_cmd, 0, 0 }, { "threads", db_show_threads, 0, 0 }, }; struct command_table db_show_table = LIST_HEAD_INITIALIZER(db_show_table); static struct command db_cmds[] = { { "print", db_print_cmd, 0, 0 }, { "p", db_print_cmd, 0, 0 }, { "examine", db_examine_cmd, CS_SET_DOT, 0 }, { "x", db_examine_cmd, CS_SET_DOT, 0 }, { "search", db_search_cmd, CS_OWN|CS_SET_DOT, 0 },
#include <net80211/ieee80211_var.h> #include <net80211/ieee80211_sysctl.h> #include <net/bpf.h> #ifdef INET #include <netinet/in.h> #include <net/if_ether.h> #endif const struct ieee80211_channel ieee80211_channel_anyc = { 0, 0 }; struct ieee80211com_head ieee80211com_head = LIST_HEAD_INITIALIZER(ieee80211com_head); const char *ieee80211_phymode_name[] = { "auto", /* IEEE80211_MODE_AUTO */ "11a", /* IEEE80211_MODE_11A */ "11b", /* IEEE80211_MODE_11B */ "11g", /* IEEE80211_MODE_11G */ "FH", /* IEEE80211_MODE_FH */ "turboA", /* IEEE80211_MODE_TURBO_A */ "turboG", /* IEEE80211_MODE_TURBO_G */ }; /* list of all instances */ SLIST_HEAD(ieee80211_list, ieee80211com); static struct ieee80211_list ieee80211_list = SLIST_HEAD_INITIALIZER(ieee80211_list);
static size_t pud_putter_waitcount(void *); static int pud_putter_close(void *); struct putter_ops pud_putter = { .pop_getout = pud_putter_getout, .pop_releaseout = pud_putter_releaseout, .pop_waitcount = pud_putter_waitcount, .pop_dispatch = pud_putter_dispatch, .pop_close = pud_putter_close, }; extern struct bdevsw pud_bdevsw; extern struct cdevsw pud_cdevsw; kmutex_t pud_mtx; static LIST_HEAD(, pud_dev) pudlist = LIST_HEAD_INITIALIZER(pudlist); static uint64_t nextreq(struct pud_dev *pd) { uint64_t rv; mutex_enter(&pd->pd_mtx); rv = pd->pd_nextreq++; mutex_exit(&pd->pd_mtx); return rv; } static int pud_putter_getout(void *this, size_t maxsize, int nonblock,
* be at least 'sizeof(struct fl)', so that blocks can be used as structures * when on the free list. */ /* * Memory lists. */ struct ml { unsigned size; LIST_ENTRY(ml) list; }; /* XXX - this is from NetBSD */ #define LIST_HEAD_INITIALIZER(head) { NULL } LIST_HEAD(, ml) freelist = LIST_HEAD_INITIALIZER(freelist); LIST_HEAD(, ml) allocatedlist = LIST_HEAD_INITIALIZER(allocatedlist); #define OVERHEAD ALIGN(sizeof (struct ml)) /* shorthand */ void * alloc(size) unsigned size; { struct ml *f, *bestf; unsigned bestsize = 0xffffffff; /* greater than any real size */ char *help; int failed; #ifdef ALLOC_TRACE printf("alloc(%u)", size);
#include <rte_ether.h> #include <rte_flow.h> #include <rte_interrupts.h> #include <rte_kvargs.h> #include <rte_malloc.h> #include <rte_mbuf.h> #include "mlx4.h" #include "mlx4_glue.h" #include "mlx4_flow.h" #include "mlx4_mr.h" #include "mlx4_rxtx.h" #include "mlx4_utils.h" struct mlx4_dev_list mlx4_mem_event_cb_list = LIST_HEAD_INITIALIZER(mlx4_mem_event_cb_list); rte_rwlock_t mlx4_mem_event_rwlock = RTE_RWLOCK_INITIALIZER; /** Configuration structure for device arguments. */ struct mlx4_conf { struct { uint32_t present; /**< Bit-field for existing ports. */ uint32_t enabled; /**< Bit-field for user-enabled ports. */ } ports; }; /* Available parameters list. */ const char *pmd_mlx4_init_params[] = { MLX4_PMD_PORT_KVARG, NULL,
struct tramp_info_page_entry *next_free; void *func; }; void *arg1; void *arg2; }; _Static_assert(TRAMP_INFO_PAGE_ENTRY_SIZE == sizeof(struct tramp_info_page_entry), "TRAMP_INFO_PAGE_ENTRY_SIZE"); _Static_assert(sizeof(struct tramp_info_page_header) + TRAMPOLINES_PER_PAGE * sizeof(struct tramp_info_page_entry) <= _PAGE_SIZE, "header+entries too big"); static pthread_mutex_t tramp_mutex = PTHREAD_MUTEX_INITIALIZER; LIST_HEAD(tramp_info_page_list, tramp_info_page_header) tramp_free_page_list = LIST_HEAD_INITIALIZER(tramp_info_page_list); extern char remap_start[]; static int get_trampoline(void *func, void *arg1, void *arg2, void *tramp_ptr) { int ret, rerrno = 0; pthread_mutex_lock(&tramp_mutex); struct tramp_info_page_header *header = LIST_FIRST(&tramp_free_page_list); if (!header) { if (PAGE_SIZE > _PAGE_SIZE) substitute_panic("%s: strange PAGE_SIZE %lx\n", __func__, (long) PAGE_SIZE); void *new_pages = mmap(NULL, _PAGE_SIZE * 2, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0); if (new_pages == MAP_FAILED) {
#if defined(HAVE_CURSES_H) #include <curses.h> #elif defined(HAVE_NCURSES_H) #include <ncurses.h> #endif #include <fnmatch.h> #include <stdlib.h> #include <string.h> #include <term.h> #include "tmux.h" static void tty_term_override(struct tty_term *, const char *); static char *tty_term_strip(const char *); struct tty_terms tty_terms = LIST_HEAD_INITIALIZER(tty_terms); enum tty_code_type { TTYCODE_NONE = 0, TTYCODE_STRING, TTYCODE_NUMBER, TTYCODE_FLAG, }; struct tty_code { enum tty_code_type type; union { char *string; int number; int flag; } value;
int pxd_unit; /* kq shizz */ struct selinfo pxd_rsel; struct mutex pxd_rsel_mtx; struct selinfo pxd_wsel; struct mutex pxd_wsel_mtx; /* queue of packets for userland to service - protected by splnet */ struct ifqueue pxd_svcq; int pxd_waiting; LIST_HEAD(,pppx_if) pxd_pxis; }; struct rwlock pppx_devs_lk = RWLOCK_INITIALIZER("pppxdevs"); LIST_HEAD(, pppx_dev) pppx_devs = LIST_HEAD_INITIALIZER(&pppx_devs); struct pool *pppx_if_pl; struct pppx_dev *pppx_dev_lookup(int); struct pppx_dev *pppx_dev2pxd(int); struct pppx_if_key { int pxik_session_id; int pxik_protocol; }; int pppx_if_cmp(struct pppx_if *, struct pppx_if *); struct pppx_if { struct pppx_if_key pxi_key; /* must be first in the struct */
#include <dev/utopia/idtphy.h> #include <dev/utopia/utopia.h> #include <dev/utopia/utopia_priv.h> /* known chips */ extern const struct utopia_chip utopia_chip_idt77155; extern const struct utopia_chip utopia_chip_idt77105; extern const struct utopia_chip utopia_chip_lite; extern const struct utopia_chip utopia_chip_ultra; extern const struct utopia_chip utopia_chip_622; /* * Global list of all registered interfaces */ static struct mtx utopia_list_mtx; static LIST_HEAD(, utopia) utopia_list = LIST_HEAD_INITIALIZER(utopia_list); #define UTP_RLOCK_LIST() mtx_lock(&utopia_list_mtx) #define UTP_RUNLOCK_LIST() mtx_unlock(&utopia_list_mtx) #define UTP_WLOCK_LIST() mtx_lock(&utopia_list_mtx) #define UTP_WUNLOCK_LIST() mtx_unlock(&utopia_list_mtx) #define UTP_LOCK(UTP) mtx_lock((UTP)->lock) #define UTP_UNLOCK(UTP) mtx_unlock((UTP)->lock) #define UTP_LOCK_ASSERT(UTP) mtx_assert((UTP)->lock, MA_OWNED) static struct proc *utopia_kproc; static void utopia_dump(struct utopia *) __unused; /*
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "variant.h" #include "entry.h" #include "db.h" #include "container.h" #include <stdio.h> #include <stdlib.h> static struct variant_head variant_list = LIST_HEAD_INITIALIZER(&variant_list); static struct variant_head disabled_list = LIST_HEAD_INITIALIZER(&disabled_list); static struct tupid_entries variant_root = RB_INITIALIZER(&variant_root); static struct tupid_entries variant_dt_root = RB_INITIALIZER(&variant_dt_root); static int load_cb(void *arg, struct tup_entry *tent) { if(arg) {} if(variant_add(tent, 1, NULL) < 0) return -1; return 0; } int variant_load(void) {
#define SEM_PREFIX "/tmp/SEMD" #define SEM_MAGIC ((u_int32_t)0x73656d31) struct sem_nameinfo { int open_count; char *name; dev_t dev; ino_t ino; sem_t *sem; LIST_ENTRY(sem_nameinfo) next; }; static pthread_once_t once = PTHREAD_ONCE_INIT; static pthread_mutex_t sem_llock; static LIST_HEAD(,sem_nameinfo) sem_list = LIST_HEAD_INITIALIZER(sem_list); static void sem_prefork() { _pthread_mutex_lock(&sem_llock); } static void sem_postfork() { _pthread_mutex_unlock(&sem_llock); } static void
.kelvin = 3600, .label = "wave", .power = LGTD_LIFX_POWER_ON, .tags = 0 }, .gw = &gw_bulb_1 }; static struct lgtd_router_device device_1 = { .device = &bulb_1 }; SLIST_INSERT_HEAD(&devices, &device_1, link); SLIST_INSERT_HEAD(&device_1_only, &device_1, link); struct lgtd_lifx_tag *gw_2_tag_1 = lgtd_tests_insert_mock_tag("vapor"); struct lgtd_lifx_tag *gw_2_tag_2 = lgtd_tests_insert_mock_tag("d^-^b"); struct lgtd_lifx_tag *gw_2_tag_3 = lgtd_tests_insert_mock_tag("wave~"); static struct lgtd_lifx_gateway gw_bulb_2 = { .bulbs = LIST_HEAD_INITIALIZER(&gw_bulb_2.bulbs), .tag_ids = 0x7 }; lgtd_tests_add_tag_to_gw(gw_2_tag_1, &gw_bulb_2, 0); lgtd_tests_add_tag_to_gw(gw_2_tag_2, &gw_bulb_2, 1); lgtd_tests_add_tag_to_gw(gw_2_tag_3, &gw_bulb_2, 2); static struct lgtd_lifx_bulb bulb_2 = { .addr = { 5, 4, 3, 2, 1 }, .state = { .hue = 0x0000, .saturation = 0x0000, .brightness = 0xffff, .kelvin = 4000, .label = "", .power = LGTD_LIFX_POWER_OFF, .tags = 0x3
#include <sys/sysctl.h> #include <sys/proc.h> #include <sys/kthread.h> #include <sys/lock.h> #include <sys/mutex.h> #include <sys/errno.h> #include <sys/sbuf.h> #include <geom/geom.h> #include <geom/geom_int.h> #include <machine/stdarg.h> #ifdef DDB #include <ddb/ddb.h> #endif struct class_list_head g_classes = LIST_HEAD_INITIALIZER(g_classes); static struct g_tailq_head geoms = TAILQ_HEAD_INITIALIZER(geoms); char *g_wait_event, *g_wait_up, *g_wait_down, *g_wait_sim; struct g_hh00 { struct g_class *mp; int error; int post; }; /* * This event offers a new class a chance to taste all preexisting providers. */ static void g_load_class(void *arg, int flag) {
struct random_algorithm random_alg_context = { .ra_ident = "Dummy", .ra_reseed = dummy_random, .ra_seeded = (random_alg_seeded_t *)dummy_random_zero, .ra_pre_read = dummy_random, .ra_read = (random_alg_read_t *)dummy_random_zero, .ra_post_read = dummy_random, .ra_write = (random_alg_write_t *)dummy_random_zero, .ra_event_processor = NULL, .ra_poolcount = 0, }; #else /* !defined(RANDOM_DUMMY) */ LIST_HEAD(sources_head, random_sources); static struct sources_head source_list = LIST_HEAD_INITIALIZER(source_list); static u_int read_rate; #endif /* defined(RANDOM_DUMMY) */ static struct selinfo rsel; /* * This is the read uio(9) interface for random(4). */ /* ARGSUSED */ static int randomdev_read(struct cdev *dev __unused, struct uio *uio, int flags) { uint8_t *random_buf; int c, error;