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); }