static VubrDev *
vubr_new(const char *path, bool client)
{
VubrDev *dev = (VubrDev *) calloc(1, sizeof(VubrDev));
struct sockaddr_un un;
CallbackFunc cb;
size_t len;
/* Get a UNIX socket. */
dev->sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (dev->sock == -1) {
vubr_die("socket");
}
dev->notifier.fd = -1;
un.sun_family = AF_UNIX;
strcpy(un.sun_path, path);
len = sizeof(un.sun_family) + strlen(path);
if (!client) {
unlink(path);
if (bind(dev->sock, (struct sockaddr *) &un, len) == -1) {
vubr_die("bind");
}
if (listen(dev->sock, 1) == -1) {
vubr_die("listen");
}
cb = vubr_accept_cb;
DPRINT("Waiting for connections on UNIX socket %s ...\n", path);
} else {
if (connect(dev->sock, (struct sockaddr *)&un, len) == -1) {
vubr_die("connect");
}
vu_init(&dev->vudev,
dev->sock,
vubr_panic,
vubr_set_watch,
vubr_remove_watch,
&vuiface);
cb = vubr_receive_cb;
}
dispatcher_init(&dev->dispatcher);
dispatcher_add(&dev->dispatcher, dev->sock, (void *)dev, cb);
return dev;
}
void *dispatcher(void *threadarg) {
assert(threadarg);
struct thread_context *context;
struct thread_context *contexts;
int rv;
struct netmap_ring *rxring;
struct ethernet_pkt *etherpkt;
struct pollfd pfd;
struct dispatcher_data *data;
uint32_t *slots_used, *open_transactions;
uint32_t i, arpd_idx, num_threads;
char *buf;
struct msg_hdr *msg;
struct ether_addr *mac;
context = (struct thread_context *)threadarg;
contexts = context->shared->contexts;
data = context->data;
arpd_idx = context->shared->arpd_idx;
mac = &context->shared->if_info->mac;
num_threads = context->shared->num_threads;
struct transaction *transactions[num_threads];
uint64_t dropped[num_threads];
for (i=0; i < num_threads; i++) {
transactions[i] = NULL;
dropped[i] = 0;
}
rv = dispatcher_init(context);
if (!rv) {
pthread_exit(NULL);
}
rxring = NETMAP_RXRING(data->nifp, 0);
slots_used = bitmap_new(rxring->num_slots);
if (!slots_used)
pthread_exit(NULL);
open_transactions = bitmap_new(num_threads);
if (!open_transactions)
pthread_exit(NULL);
pfd.fd = data->fd;
pfd.events = (POLLIN);
printf("dispatcher[%d]: initialized\n", context->thread_id);
// signal to main() that we are initialized
atomic_store_explicit(&context->initialized, 1, memory_order_release);
for (;;) {
rv = poll(&pfd, 1, POLL_TIMEOUT);
// read all packets from the ring
if (rv > 0) {
for (; rxring->avail > 0; rxring->avail--) {
i = rxring->cur;
rxring->cur = NETMAP_RING_NEXT(rxring, i);
rxring->reserved++;
buf = NETMAP_BUF(rxring, rxring->slot[i].buf_idx);
etherpkt = (struct ethernet_pkt *)(void *)buf;
// TODO: consider pushing this check to the workers
if (!ethernet_is_valid(etherpkt, mac)) {
if (rxring->reserved == 1)
rxring->reserved = 0;
continue;
}
// TODO: dispatch to n workers instead of just 0
switch (etherpkt->h.ether_type) {
case IP4_ETHERTYPE:
rv = tqueue_insert(contexts[0].pkt_recv_q,
&transactions[0], (char *) NULL + i);
switch (rv) {
case TQUEUE_SUCCESS:
bitmap_set(slots_used, i);
bitmap_set(open_transactions, 0);
break;
case TQUEUE_TRANSACTION_FULL:
bitmap_set(slots_used, i);
bitmap_clear(open_transactions, 0);
break;
case TQUEUE_FULL:
// just drop packet and do accounting
dropped[0]++;
if (rxring->reserved == 1)
rxring->reserved = 0;
break;
}
break;
case ARP_ETHERTYPE:
rv = tqueue_insert(contexts[arpd_idx].pkt_recv_q,
&transactions[arpd_idx], (char *) NULL + i);
switch (rv) {
case TQUEUE_SUCCESS:
tqueue_publish_transaction(contexts[arpd_idx].pkt_recv_q,
&transactions[arpd_idx]);
bitmap_set(slots_used, i);
break;
case TQUEUE_TRANSACTION_FULL:
bitmap_set(slots_used, i);
break;
case TQUEUE_FULL:
// just drop packet and do accounting
dropped[arpd_idx]++;
if (rxring->reserved == 1)
rxring->reserved = 0;
break;
}
break;
default:
printf("dispatcher[%d]: unknown/unsupported ethertype %hu\n",
context->thread_id, etherpkt->h.ether_type);
if (rxring->reserved == 1)
rxring->reserved = 0;
} // switch (ethertype)
} // for (rxring)
// publish any open transactions so that the worker can start on it
for (i=0; i < num_threads; i++) {
if (bitmap_get(open_transactions, i))
tqueue_publish_transaction(contexts[i].pkt_recv_q, &transactions[i]);
}
bitmap_clearall(open_transactions, num_threads);
} // if (packets)
// read the message queue
rv = squeue_enter(context->msg_q, 1);
if (!rv)
continue;
while ((msg = squeue_get_next_pop_slot(context->msg_q)) != NULL) {
switch (msg->msg_type) {
case MSG_TRANSACTION_UPDATE:
update_slots_used(context->msg_q, slots_used, rxring);
break;
case MSG_TRANSACTION_UPDATE_SINGLE:
update_slots_used_single((void *)msg, slots_used, rxring);
break;
default:
printf("dispatcher: unknown message %hu\n", msg->msg_type);
}
}
squeue_exit(context->msg_q);
} // for(;;)
pthread_exit(NULL);
}
/*-----------------------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
/* irqload_init();*/
#ifdef WITH_UIP
uip_init();
uip_main_init();
resolv_init();
#ifdef WITH_TFE
cs8900a_init();
#endif /* WITH_TFE */
#ifdef WITH_RS232
rs232dev_init();
#endif /* WITH_RS232 */
#ifdef WITH_TAPDEV
tapdev_init();
#endif /* WITH_TAPDEV */
#endif /* WITH_UIP */
conio_init();
textcolor(1);bgcolor(0);
clrscr();
conio_update();
//joy_load_driver(joy_stddrv);
#if 0
{
int i,j;
clrscr();
textcolor(0);bgcolor(1);
while(1)
{
gotoxy(0,0);
cprintf("%d\n",i++);
conio_update();
if(kbhit())
{
cprintf(" ");
cprintf("%02x",cgetc());
cprintf("\n");
}
else
{
cprintf("pressed: ---------\n");
}
j=joy_read(0);
cprintf("%08x\n",j);
}
}
#endif
ek_init();
dispatcher_init();
ctk_init();
contiki_init();
programs_init();
ctk_redraw();
ek_run();
clrscr();
return 0;
argv = argv;
argc = argc;
}
int
main(int argc, char **argv)
{
msp430_init();
rs232_init(0);
sensors_init();
rs232_print("uip_init()...\n");
uip_init();
/* rs232_print("resolv_init()...\n");
resolv_init();*/
#if 0
uip_ipaddr(addr, 193,10,67,150);
uip_sethostaddr(addr);
/* uip_ipaddr(addr, 193,10,66,195);
resolv_conf(addr);*/
#else
uip_ipaddr(addr, 172,16,0,2);
uip_sethostaddr(addr);
/* uip_ipaddr(addr, 193,10,66,195);
resolv_conf(addr);*/
#endif
rs232_print("dispatcher_init()...\n");
dispatcher_init();
rs232_print("slip_drv_init()...\n");
slip_drv_init(NULL);
rs232_print("ctk_init()...\n");
/* ctk_init();*/
rs232_print("ctk_vncserver_init()...\n");
/* ctk_vncserver_init(NULL); */
rs232_print("program_handler_init()...\n");
/* program_handler_init();*/
/* rs232_print("processes_init()...\n");
processes_init(NULL);*/
rs232_print("webserver_init()...\n");
/* webserver_init(NULL);*/
sensorcheck_init(NULL);
/* program_handler_add(&directory_dsc, "Directory", 1);*/
/* program_handler_add(&about_dsc, "About", 1);*/
/* program_handler_add(&webserver_dsc, "Web server", 1);*/
/* program_handler_add(&www_dsc, "Web browser", 1);*/
/* program_handler_add(&calc_dsc, "Calculator", 0);*/
/* program_handler_add(&processes_dsc, "Processes", 0);*/
rs232_print("program_handler_addd()...\n");
/* program_handler_add(&sensorview_dsc, "Sensors", 1);*/
rs232_print("dispatcher_run()...\n");
beep();
dispatcher_run();
return 0;
argv = argv;
argc = argc;
}
/****************************** Main ******************************/
int main(int argc, char **argv) {
struct config cfg = {
PTHREAD_MUTEX_INITIALIZER,
0, LOG_NOTICE, 0,
0
};
struct music_module core = {
-1,
0, 0, 0,
config_line,
{ 0 }, 0,
0, 0,
(char*)"core",
0
}, *m;
char *ch;
int i, returnValue = 0, pipe_fds[2];
core.core = &core;
core.data = &cfg;
/***** Get program name *****/
for (core.name = ch = *argv; *ch; ++ch) {
if ((*ch=='/' || *ch=='\\') && ch[1] && ch[1]!='/' && ch[1]!='\\') {
core.name = ch + 1;
}
}
/***** Help *****/
if (argc>=2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
fputs("usage: music [ config-file ... ]\n", stdout);
return 0;
}
/***** Read config *****/
if (argc<2) {
argv[1] = (char*)"-";
argc = 2;
}
for (i = 1; i < argc; ++i) {
FILE *fp = strcmp(argv[i], "-") ? fopen(argv[i], "r") : stdin;
char buf[1026];
if (!fp) {
music_log_errno(&core, LOG_FATAL, "open: %s", argv[i]);
return 1;
}
m = &core;
if (ch) *ch = 0;
while (fgets(buf, sizeof buf, fp)) {
int result = !parse_line(buf, &m);
if (result) return result;
}
if (fp!=stdin) {
fclose(fp);
}
}
struct music_module *dispatcher_init();
m = dispatcher_init();
if (!m) {
music_log(&core, LOG_FATAL, "Error initialising song dispatcher");
return 1;
}
m->name = music_strdup_realloc(0, "dispatcher");
m->next = core.next;
m->core = &core;
core.next = m;
if (!sort_modules(&core)) {
return 1;
}
/***** Open log file *****/
if (cfg.logfile && *cfg.logfile) {
i = open(cfg.logfile, O_WRONLY | O_APPEND | O_CREAT, 0600);
if (i==-1) {
music_log_errno(&core, LOG_FATAL, "open: %s", cfg.logfile);
return 1;
}
fflush(stderr);
dup2(i, 2); /* stderr is not logfile */
close(i);
}
music_log(&core, LOG_NOTICE, "starting");
cfg.logboth = 1;
/***** Daemonize *****/
switch (fork()) {
case -1:
music_log_errno(&core, LOG_FATAL, "fork");
return 1;
case 0: break;
default: return 0;
}
setsid();
switch (fork()) {
case -1:
music_log_errno(&core, LOG_FATAL, "fork");
return 1;
case 0: break;
default: return 0;
}
chdir("/");
cfg.logboth = 0;
i = sysconf(_SC_OPEN_MAX);
while (--i > 2) {
close(i);
}
close(0);
open("/dev/null", O_RDWR); /* stdin is /dev/null */
fflush(stdout);
dup2(0, 1); /* stdout is /dev/null */
/***** Create sleep pipe *****/
if (pipe(pipe_fds)) {
music_log_errno(&core, LOG_FATAL, "pipe");
return 1;
}
sleep_pipe_fd = pipe_fds[0];
/***** Register signal handler *****/
signal(SIGHUP, got_sig);
signal(SIGINT, got_sig);
signal(SIGILL, got_sig);
signal(SIGQUIT, got_sig);
signal(SIGSEGV, got_sig);
signal(SIGTERM, got_sig);
signal(SIGALRM, ignore_sig);
/***** Start cache *****/
m = &core;
while (m->next && m->next->type==MUSIC_CACHE) {
struct music_module *prev = m;
m = m->next;
if (sig) {
goto finishSig;
}
music_log(m, LOG_NOTICE, "starting");
if (!m->start || m->start(m)) {
music_log(m, LOG_DEBUG, "this will be our cache");
break;
}
music_log(m, LOG_FATAL + 2, "error starting module");
prev->next = m->next;
if (m->free) m->free(m);
free(m);
m = prev;
}
/* Check cache */
if (m==&core && cfg.requireCache) {
music_log(m, LOG_FATAL, "no cache started");
returnValue = 1;
goto finishNoStop;
}
/* Free rest of the caches */
while (m->next && m->next->type==MUSIC_CACHE) {
struct music_module *next = m->next;
m->next = next->next;
if (next->free) next->free(next);
if (next->name) free(next->name);
free(next);
}
/***** Start other modules *****/
while (m->next) {
struct music_module *prev = m;
m = m->next;
if (sig) {
goto finishSig;
}
music_log(m, LOG_NOTICE, "starting");
if (m->start && !m->start(m)) {
music_log(m, LOG_FATAL, "error starting module");
prev->next = 0;
returnValue = 1;
goto finishNoSig;
}
}
/***** Run *****/
while (music_running) {
pause();
}
/***** Check signal *****/
if (sig) {
finishSig:
music_log(&core, LOG_NOTICE + 2, "got signal %d; exiting", sig);
}
finishNoSig:
/* Stop everything */
write(pipe_fds[1], "B", 1);
for (m = core.next; m; m = m->next) {
music_log(m, LOG_NOTICE + 2, "stopping");
if (m->stop) m->stop(m);
}
finishNoStop:
/* OS will free all resources we were using so no need to do it
ourselfves */
music_log(&core, LOG_NOTICE, "terminated");
return returnValue;
}
int
main(int argc, char *argv[])
{
int arg;
int Fails ;
char *str;
int level;
char *error_file = NULL;
extern char *optarg;
extern int optind;
int opt;
error_init(argv[0], application_end);
optind = 1;
{
char domain_path[MAXPATHLEN];
setlocale(LC_ALL, "");
sprintf(domain_path, SEA_LOCALE_PATH);
bindtextdomain(DOMAIN_MGET, domain_path);
bindtextdomain(DOMAIN_SGET, domain_path);
bindtextdomain(DOMAIN_LIBGET, domain_path);
bindtextdomain(DOMAIN_LGET, domain_path);
bindtextdomain(DOMAIN_FGET, domain_path); /* formatting string */
}
/* parse arguments */
while((opt = getopt(argc,argv,"c:i:hr:m:o:p:a:d:yf:n:?"))!=EOF){
switch(opt){
case 'h':
case '?':
print_usage();
break;
case 'f':
Fails = strtol (optarg, &str, 10) ;
if (optarg == str) {
fprintf (stderr, "Invalid number following the -t option: %s\n", optarg ) ;
print_usage () ;
} else {
SetFailThreshold (Fails) ;
}
break ;
case 'y':
recovery_on=TRUE;
break;
case 'p':
port = strtol(optarg, &str, 10);
if(optarg == str)
{
fprintf(stderr, "Not a valid integer following the -p option: %s\n", optarg);
print_usage();
}
break;
case 'n':
relay_agent_name = strdup(optarg);
if(relay_agent_name == NULL)
{
fprintf(stderr, "%s\n", ERR_MSG_ALLOC);
exit(1);
}
break;
case 'o':
if(optind > argc)
{
fprintf(stderr, "must have the enterprise name-oid file\n");
print_usage();
}
name_oid_file= strdup(optarg);
if(name_oid_file == NULL)
{
fprintf(stderr, "%s\n", ERR_MSG_ALLOC);
exit(1);
}
break;
case 'c':
if(optind > argc)
{
fprintf(stderr, "Must have a configuration directory name following the -c option\n");
print_usage();
}
config_dir = strdup(optarg);
if(config_dir == NULL)
{
fprintf(stderr, "%s\n", ERR_MSG_ALLOC);
exit(1);
}
break;
case 'a':
if(optind > argc)
{
fprintf(stderr, "Must have a access control filename following the -a option\n");
print_usage();
}
sec_config_file = strdup(optarg);
if(sec_config_file == NULL)
{
fprintf(stderr, "%s\n", ERR_MSG_ALLOC);
exit(1);
}
break;
case 'r':
if(optind > argc)
{
fprintf(stderr, "Must have a resource file name following the -r option\n");
print_usage();
}
resource_file = strdup(optarg);
if(resource_file == NULL)
{
fprintf(stderr, "%s\n", ERR_MSG_ALLOC);
exit(1);
}
break;
case 'i':
if(optind > argc)
{
fprintf(stderr, "Must have a pid file name following the -i option\n");
print_usage();
}
pid_file = strdup(optarg);
if(pid_file == NULL)
{
fprintf(stderr, "%s\n", ERR_MSG_ALLOC);
exit(1);
}
break;
case 'd':
if(optind> argc)
{
fprintf(stderr, "Must have a trace-level following the -d option\n");
print_usage();
}
level = strtol(optarg, &str, 10);
if(optarg == str)
{
fprintf(stderr, "Not a valid integer following the -d option: %s\n", optarg);
print_usage();
}
if(trace_set(level, error_label))
{
print_usage();
}
break;
case 'm':
if(optind > argc)
{
fprintf(stderr, "Must have GROUP or SPLIT following the -m option\n");
print_usage();
}
if(strcmp(optarg, "GROUP") == 0)
{
mode = MODE_GROUP;
}
else
if(strcmp(optarg, "SPLIT") == 0)
{
mode = MODE_SPLIT;
}
else
{
fprintf(stderr, "Invalid mode: %s\n", optarg);
print_usage();
}
break;
default:
fprintf(stderr, "Invalid Option: -%c\n", optarg);
print_usage();
break;
}
}
/*
if(error_file == NULL)
{
error_file = default_error_file;
}
error_open(error_file);
*/
if(trace_level == 0)
{
/* run the daemon in backgound */
int pid;
pid = fork();
switch(pid)
{
case -1:
error_exit(ERR_MSG_FORK, errno_string());
break;
case 0: /* child process */
break;
default: /* parent process */
exit(0);
break;
}
}
if(fclose(stdin) == EOF)
{
error(ERR_MSG_FCLOSE, "stdin", errno_string());
}
dispatcher_init();
if(signals_init(signals_sighup, signals_exit, error_label))
{
error_exit("signals_init() failed: %s", error_label);
}
if(trace_level == 0)
{
if(fclose(stdout) == EOF)
{
error(ERR_MSG_FCLOSE, "stdout", errno_string());
}
}
if(trace_level == 0)
{
/* background */
if(chdir("/") == -1)
{
error(ERR_MSG_CHDIR, "/", errno_string());
}
/* set process group ID */
setpgrp();
error_close_stderr();
}
dispatcher_loop();
return (0);
}
RedDispatcher *red_dispatcher_init(QXLInstance *qxl)
{
RedDispatcher *red_dispatcher;
RedWorkerMessage message;
WorkerInitData init_data;
QXLDevInitInfo init_info;
int r;
RedChannel *display_channel;
RedChannel *cursor_channel;
sigset_t thread_sig_mask;
sigset_t curr_sig_mask;
ClientCbs client_cbs = { NULL, };
quic_init();
sw_canvas_init();
#ifdef USE_OPENGL
gl_canvas_init();
#endif // USE_OPENGL
red_dispatcher = spice_new0(RedDispatcher, 1);
ring_init(&red_dispatcher->async_commands);
spice_debug("red_dispatcher->async_commands.next %p", red_dispatcher->async_commands.next);
dispatcher_init(&red_dispatcher->dispatcher, RED_WORKER_MESSAGE_COUNT, NULL);
init_data.qxl = red_dispatcher->qxl = qxl;
init_data.id = qxl->id;
init_data.red_dispatcher = red_dispatcher;
init_data.pending = &red_dispatcher->pending;
init_data.num_renderers = num_renderers;
memcpy(init_data.renderers, renderers, sizeof(init_data.renderers));
pthread_mutex_init(&red_dispatcher->async_lock, NULL);
init_data.image_compression = image_compression;
init_data.jpeg_state = jpeg_state;
init_data.zlib_glz_state = zlib_glz_state;
init_data.streaming_video = streaming_video;
red_dispatcher->base.major_version = SPICE_INTERFACE_QXL_MAJOR;
red_dispatcher->base.minor_version = SPICE_INTERFACE_QXL_MINOR;
red_dispatcher->base.wakeup = qxl_worker_wakeup;
red_dispatcher->base.oom = qxl_worker_oom;
red_dispatcher->base.start = qxl_worker_start;
red_dispatcher->base.stop = qxl_worker_stop;
red_dispatcher->base.update_area = qxl_worker_update_area;
red_dispatcher->base.add_memslot = qxl_worker_add_memslot;
red_dispatcher->base.del_memslot = qxl_worker_del_memslot;
red_dispatcher->base.reset_memslots = qxl_worker_reset_memslots;
red_dispatcher->base.destroy_surfaces = qxl_worker_destroy_surfaces;
red_dispatcher->base.create_primary_surface = qxl_worker_create_primary_surface;
red_dispatcher->base.destroy_primary_surface = qxl_worker_destroy_primary_surface;
red_dispatcher->base.reset_image_cache = qxl_worker_reset_image_cache;
red_dispatcher->base.reset_cursor = qxl_worker_reset_cursor;
red_dispatcher->base.destroy_surface_wait = qxl_worker_destroy_surface_wait;
red_dispatcher->base.loadvm_commands = qxl_worker_loadvm_commands;
qxl->st->qif->get_init_info(qxl, &init_info);
init_data.memslot_id_bits = init_info.memslot_id_bits;
init_data.memslot_gen_bits = init_info.memslot_gen_bits;
init_data.num_memslots = init_info.num_memslots;
init_data.num_memslots_groups = init_info.num_memslots_groups;
init_data.internal_groupslot_id = init_info.internal_groupslot_id;
init_data.n_surfaces = init_info.n_surfaces;
num_active_workers = 1;
sigfillset(&thread_sig_mask);
sigdelset(&thread_sig_mask, SIGILL);
sigdelset(&thread_sig_mask, SIGFPE);
sigdelset(&thread_sig_mask, SIGSEGV);
pthread_sigmask(SIG_SETMASK, &thread_sig_mask, &curr_sig_mask);
if ((r = pthread_create(&red_dispatcher->worker_thread, NULL, red_worker_main, &init_data))) {
spice_error("create thread failed %d", r);
}
pthread_sigmask(SIG_SETMASK, &curr_sig_mask, NULL);
read_message(red_dispatcher->dispatcher.send_fd, &message);
spice_assert(message == RED_WORKER_MESSAGE_READY);
display_channel = red_dispatcher_display_channel_create(red_dispatcher);
if (display_channel) {
client_cbs.connect = red_dispatcher_set_display_peer;
client_cbs.disconnect = red_dispatcher_disconnect_display_peer;
client_cbs.migrate = red_dispatcher_display_migrate;
red_channel_register_client_cbs(display_channel, &client_cbs);
red_channel_set_data(display_channel, red_dispatcher);
red_channel_set_cap(display_channel, SPICE_DISPLAY_CAP_MONITORS_CONFIG);
reds_register_channel(display_channel);
}
cursor_channel = red_dispatcher_cursor_channel_create(red_dispatcher);
if (cursor_channel) {
client_cbs.connect = red_dispatcher_set_cursor_peer;
client_cbs.disconnect = red_dispatcher_disconnect_cursor_peer;
client_cbs.migrate = red_dispatcher_cursor_migrate;
red_channel_register_client_cbs(cursor_channel, &client_cbs);
red_channel_set_data(cursor_channel, red_dispatcher);
reds_register_channel(cursor_channel);
}
qxl->st->qif->attache_worker(qxl, &red_dispatcher->base);
qxl->st->qif->set_compression_level(qxl, calc_compression_level());
red_dispatcher->next = dispatchers;
dispatchers = red_dispatcher;
return red_dispatcher;
}
void rarpd_init(struct rarpd *rarpd)
{
memset(rarpd, 0, sizeof(struct rarpd));
rarpd->nl_ctx.fd = -1;
dispatcher_init(&rarpd->dispatcher);
}
