/*
* 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;
