event* zPacket::create_event(event_base* eb, short what, void *arg) const { clear_event(); ev= ::event_new(eb, sock, what, cb_packet, arg); if(ev != NULL) { ::event_add(ev, NULL); } return ev; };
event* zPacket::create_event(event_base* eb, short what, void *arg, unsigned sec, unsigned short msec) const { clear_event(); ev= ::event_new(eb, sock, what, cb_packet, arg); if(ev != NULL) { tmval.tv_sec= sec; tmval.tv_usec=msec*1000; ::event_add(ev, &tmval); } return ev; };
/* * Decide which event to show. Works in a cycle. Clears the display if there is a calendar event outstanding. The phone could * have been offline for some while and hence what is being displayed could be inaccurate. */ void show_next_event() { // Else get processing if (g_max_entries == 0) { clear_event(); } else { g_entry_no++; if (g_entry_no > g_max_entries || g_entry_no > ROT_MAX) g_entry_no = 1; show_event(g_entry_no); } }
/* * Decide which event to show. Works in a cycle. Clears the display if there is a calendar event outstanding. The phone could * have been offline for some while and hence what is being displayed could be inaccurate. */ void show_next_event() { // Don't mess up an alert that is underway if (g_showing_alert) return; // Else get processing if (g_max_entries == 0) { clear_event(); } else { g_entry_no++; if (g_entry_no > g_max_entries || g_entry_no > ROT_MAX) g_entry_no = 1; show_event(g_entry_no); } }
static int mkbp_get_next_event(struct host_cmd_handler_args *args) { static int last; int i, data_size, evt; uint8_t *resp = args->response; const struct mkbp_event_source *src; /* * Find the next event to service. We do this in a round-robin * way to make sure no event gets starved. */ for (i = 0; i < EC_MKBP_EVENT_COUNT; ++i) if (event_is_set((last + i) % EC_MKBP_EVENT_COUNT)) break; if (i == EC_MKBP_EVENT_COUNT) return EC_RES_ERROR; evt = (i + last) % EC_MKBP_EVENT_COUNT; last = evt + 1; /* * Clear the event before retrieving the event data in case the * event source wants to send the same event. */ clear_event(evt); for (src = __mkbp_evt_srcs; src < __mkbp_evt_srcs_end; ++src) if (src->event_type == evt) break; if (src == __mkbp_evt_srcs_end) return EC_RES_ERROR; resp[0] = evt; /* Event type */ data_size = src->get_data(resp + 1); if (data_size < 0) return EC_RES_ERROR; args->response_size = 1 + data_size; if (!events) set_host_interrupt(0); return EC_RES_SUCCESS; }
int main(int argc, char *argv[]) { Event event; Reader reader; /* Init struct */ clear_event(&event); reader_init(&reader, argv[1]); evh_register_handler(&reader, &lostRecordsHandler); /* evh_register_handler(&reader, &backInflightQueueBlockedHandler); evh_register_handler(&reader, &backInflightQueueUnblockedHandler); evh_register_handler(&reader, &frontSharedRingQueueBlockedHandler); evh_register_handler(&reader, &frontSharedRingQueueUnblockedHandler); evh_register_handler(&reader, &frontGrantQueueBlockedHandler); evh_register_handler(&reader, &frontGrantQueueUnblockedHandler); */ evh_register_handler(&reader, &frontRequestQueueBlockedHandler); evh_register_handler(&reader, &frontRequestQueueUnblockedHandler); evh_register_handler(&reader, &backRequestQueueBlockedHandler); evh_register_handler(&reader, &backRequestQueueUnblockedHandler); evh_register_handler(&reader, &frontSharedRingRespQueueBlockedHandler); evh_register_handler(&reader, &frontSharedRingRespQueueUnblockedHandler); evh_register_handler(&reader, &backRequestInterruptSendHandler); evh_register_handler(&reader, &backRequestInterruptReceiveHandler); evh_register_handler(&reader, &backResponseInterruptSendHandler); evh_register_handler(&reader, &backResponseInterruptReceiveHandler); reader_loop(&reader); reader_exit(&reader); return 0; }
int main(int argc, char *argv[]) { Event event; Reader reader; /* Init struct */ clear_event(&event); reader_init(&reader, argv[1]); evh_register_handler(&reader, &lostRecordsHandler); evh_register_handler(&reader, &exitToXenHandler); evh_register_handler(&reader, &exitToGuestHandler); reader_loop(&reader); reader_exit(&reader); return 0; }
int main(int argc, char *argv[]) { Event event; Reader reader; /* Init struct */ clear_event(&event); reader_init(&reader, argv[1]); evh_register_handler(&reader, &switchInfprevHandler); evh_register_handler(&reader, &switchInfnextHandler); evh_register_handler(&reader, &switchSchedHandler); evh_register_handler(&reader, &domainWakeHandler); evh_register_handler(&reader, &lostRecordsHandler); reader_loop(&reader); reader_exit(&reader); return 0; }
/* This function is called (via check_events()) from the top level sieve loops (prime_sieve() etc.). It can assume that it is safe to tighten any sieving parameters other than p_min and p_max. */ void process_events(uint64_t current_prime) { /* event_happened was set last in notify_event(), so clear it first which ensures that if some signal arrives while we are in process_events() it might have to wait until the next sieve iteration to get processed, but it won't be lost. */ event_happened = 0; if (clear_event(initialise_events)) { init_signals(); init_progress_report(current_prime); } if (clear_event(subsequence_eliminated)) remove_eliminated_subsequences(current_prime); if (clear_event(sieve_parameters_changed)) init_progress_report(current_prime); if (clear_event(received_sigterm)) { finish_srsieve("SIGTERM was received",current_prime); signal(SIGTERM,SIG_DFL); raise(SIGTERM); } if (clear_event(received_sigint)) { finish_srsieve("SIGINT was received",current_prime); signal(SIGINT,SIG_DFL); raise(SIGINT); } if (clear_event(report_due)) progress_report(current_prime); if (clear_event(save_due)) write_save_file(current_prime); }
int main(int argc, char *argv[]) { Event event; Reader reader; /* Init struct */ clear_event(&event); reader_init(&reader, argv[1]); evh_register_handler(&reader, &numEventsHandler); evh_register_handler(&reader, &numExceptionsHandler); evh_register_handler(&reader, &numExceptionsInXenHandler); evh_register_handler(&reader, &numInterruptsHandler); evh_register_handler(&reader, &numInterruptsInXenHandler); evh_register_handler(&reader, &numHypercallsHandler); evh_register_handler(&reader, &lostRecordsHandler); reader_loop(&reader); reader_exit(&reader); return 0; }
int main (int argc, char **argv) { pwr_tStatus sts = 1; io_tCtx io_ctx; io_tCtx io_ctx_swap; pwr_sClass_IOHandler *ihp; int swap_io; int close_io; int init_io; qcom_sQid qid = qcom_cNQid; int tmo; char mp[2000]; qcom_sGet get; pwr_tTime now; pwr_tTime next; pwr_tTime after; pwr_tDeltaTime cycle; lst_sEntry *csup_lh; int delay_action = 0; pwr_sNode *nodep; pwr_tBoolean old_emergency_break = 0; if ( argc > 1) { if ( strcmp( argv[1], "-m") == 0) { io_methods_print(); exit(0); } if ( strcmp( argv[1], "-h") == 0) { usage(); exit(0); } } ihp = init(&qid, &csup_lh, &nodep); plc_UtlWaitForPlc(); /* Prepare the swap context */ sts = io_init_swap(io_mProcess_IoComm, pwr_cNObjid, &io_ctx_swap, 1, ihp->CycleTimeBus); for (close_io = swap_io = 0, init_io = 1;;) { if (init_io) { double f; sts = io_init(io_mProcess_IoComm, pwr_cNObjid, &io_ctx, 1, ihp->CycleTimeBus); if ( ODD(sts)) errh_SetStatus( PWR__SRUN); #if defined(OS_ELN) ker$clear_event( &sts, io_comm_terminate); io_dioc_init(); io_dioc_start(); #endif init_io = 0; tmo = ihp->CycleTimeBus * 1000.; f = floor(ihp->CycleTimeBus); cycle.tv_sec = f; cycle.tv_nsec = (ihp->CycleTimeBus - f) * 1.0e9; cycle.tv_nsec++; time_GetTimeMonotonic(&next); time_Aadd(NULL, &next, &cycle); } get.maxSize = sizeof(mp); get.data = mp; qcom_Get(&sts,&qid, &get, tmo); if (sts == QCOM__TMO || sts == QCOM__QEMPTY) { if ( nodep->EmergBreakTrue && !old_emergency_break) sts = io_swap(io_ctx_swap, io_eEvent_IoCommEmergencyBreak); sts = io_read(io_ctx); if (EVEN(sts)) { ihp->IOReadWriteFlag = FALSE; errh_Error("IO read, %m", sts); } sts = io_write(io_ctx); if (EVEN(sts)) { ihp->IOReadWriteFlag = FALSE; errh_Error("IO write, %m", sts); } if ( nodep->EmergBreakTrue && !old_emergency_break) sts = io_swap(io_ctx, io_eEvent_EmergencyBreak); old_emergency_break = nodep->EmergBreakTrue; if (swap_io) { sts = io_swap(io_ctx_swap, io_eEvent_IoCommSwap); } io_ScanSupLst( io_ctx->SupCtx); time_GetTime(&now); time_GetTimeMonotonic(&after); next = after; time_Aadd(NULL, &next, &cycle); delay_action = csup_Exec(&sts, csup_lh, (pwr_tDeltaTime *) &next, (pwr_tDeltaTime *) &after, &now); if (delay_action == 2) ihp->IOReadWriteFlag = FALSE; aproc_TimeStamp(ihp->CycleTimeBus, 5); } else { ini_mEvent new_event; qcom_sEvent *ep = (qcom_sEvent*) get.data; new_event.m = ep->mask; if (new_event.b.oldPlcStop && !swap_io) { swap_io = 1; close_io = 1; errh_SetStatus(PWR__SRVRESTART); } else if (new_event.b.swapDone && swap_io) { swap_io = 0; init_io = 1; } else if (new_event.b.terminate) { exit(0); } if (close_io) { io_close(io_ctx); #if defined(OS_ELN) ker$signal( &sts, io_comm_terminate); #endif close_io = 0; } } } }
/* This function is called (via check_events()) from the top level sieve loops (prime_sieve() etc.). It can assume that it is safe to tighten any sieving parameters other than p_min and p_max. */ void process_events(uint64_t current_prime) { /* event_happened was set last in notify_event(), so clear it first which ensures that if some signal arrives while we are in process_events() it might have to wait until the next sieve iteration to get processed, but it won't be lost. */ event_happened = 0; if (clear_event(initialise_events)) { init_signals(); init_progress_report(current_prime); } if (clear_event(sieve_parameters_changed)) init_progress_report(current_prime); if (clear_event(received_sigterm)) { finish_srsieve("SIGTERM was received",current_prime); signal(SIGTERM,SIG_DFL); raise(SIGTERM); } if (clear_event(received_sigint)) { finish_srsieve("SIGINT was received",current_prime); signal(SIGINT,SIG_DFL); raise(SIGINT); } #ifdef SIGHUP if (clear_event(received_sighup)) { finish_srsieve("SIGHUP was received",current_prime); signal(SIGHUP,SIG_DFL); raise(SIGHUP); } #endif #if HAVE_FORK if (clear_event(received_sigpipe)) { finish_srsieve("SIGPIPE was received",current_prime); signal(SIGPIPE,SIG_DFL); raise(SIGPIPE); } if (clear_event(received_sigchld)) { finish_srsieve("SIGCHLD was received",current_prime); signal(SIGCHLD,SIG_DFL); raise(SIGCHLD); exit(EXIT_FAILURE); } #endif if (clear_event(factor_found)) next_report_due = time(NULL); if (clear_event(report_due)) progress_report(current_prime); if (clear_event(save_due)) { #if SOBISTRATOR_OPT if (sobistrator_opt) sob_write_checkpoint(current_prime); #endif write_checkpoint(current_prime); } }
zPacketThread::~zPacketThread() { clear_event(); clear(); sock=-1; };
//! close file void base_reader::close() { brw::close(); clear_event(); }
zPacket::~zPacket() { clear_ext(); clear_event(); clear_socket(); };
pwr_tUInt32 bck_WaitBackup ( void *context, pwr_tBoolean timeout) { pwr_tUInt32 sts; pwr_tObjid objid; pwr_tInt32 c; pwr_tTime t; pwr_tVaxTime tmo; pwr_tVaxTime tmptime; pwr_sClass_Backup_Conf *backup_confp; /* Backup_Conf object pointer */ $DESCRIPTOR (timeunitdsc, "0 0:0:0.1"); /* 0.1 second units */ int cycletime; #ifdef OS_ELN pwr_tInt32 res; pwr_tVaxTime *tmop; #endif #ifdef OS_VMS $DESCRIPTOR (efcname, BCK_EFC_NAME); #endif /* * Initialize */ #ifdef OS_ELN if (!areas_mapped) { BCK_MAP_AREAS; areas_mapped = TRUE; } #endif /* * Find the local Backup_Conf object */ sts = gdh_GetClassList (pwr_cClass_Backup_Conf, &objid); while (ODD (sts)) { sts = gdh_ObjidToPointer (objid, (pwr_tAddress *)&backup_confp); if (ODD (sts)) break; sts = gdh_GetNextObject (objid, &objid); } if (EVEN (sts)) return sts; /* Something wrong, quit */ /* * Pick up argument information */ if (context == NULL) time_GetTime(&t); else { t = *(pwr_tTime *)context; free (context); } #ifdef OS_ELN tmop = NULL; #else timed_out = FALSE; sts = sys$ascefc (BCK_EFC, &efcname, 0, 0); if (EVEN (sts)) lib$signal (sts); /* BUG */ #endif if (timeout) { cycletime = backup_confp->CycleSlow * 2; if (cycletime == 0) cycletime = BCK_DEFAULT_SLOW * 2; #ifdef OS_ELN tmo = eln$time_value (&timeunitdsc); #else sts = sys$bintim (&timeunitdsc, &tmo); if (EVEN (sts)) lib$signal (sts); /* BUG, should not happen */ #endif lib$mult_delta_time ( &cycletime, /* multiplier */ &tmo); /* delta_time (modified) */ sys$gettim (&tmptime); lib$add_times (&tmo, &tmptime, &tmo); /* Make absolute time */ #ifdef OS_ELN tmop = &tmo; #else sts = sys$setimr (BCK_WRITE_DONE, &tmo, &astrtn, 4711, 0); if (EVEN (sts)) lib$signal (sts); /* BUG */ #endif } /* * Loop, and wait for things to happen */ while (TRUE) { #ifdef OS_ELN ker$clear_event (NULL, bck_write_done); ker$wait_any (NULL, &res, tmop, bck_write_done); /* Check for timeout */ if (res == 0) return SS$_TIMEOUT; #else sts = sys$clref (BCK_WRITE_DONE); if (EVEN (sts)) lib$signal (sts); /* BUG */ sts = sys$waitfr (BCK_WRITE_DONE); if (EVEN (sts)) lib$signal (sts); /* BUG */ /* Check for timeout */ if (timed_out) return SS$_TIMEOUT; #endif /* Check if both cycles done */ if (time_Acomp(&backup_confp->ObjTimeSlow, &t) < 0) continue; if (time_Acomp(&backup_confp->ObjTimeFast, &t) < 0) continue; break; } /* Loop */ #ifdef OS_VMS sys$cantim (4711, 0); #endif return 1; /* Done. */ } /* bck_WaitBackup */
// entry point int main (int argc, char **argv) { int rc = 0; uint64_t seqnum = 0; int opt_index = 0; int c = 0; int fd = 0; char *tmp = NULL; char event_buf[8192]; char event_buf_tmp[8292]; // has to hold event_buf plus an 8-byte sequence number char event_path[PATH_MAX + 1]; bool have_seqnum = false; ssize_t nr = 0; char const *required_fields[] = { "\nSUBSYSTEM=", "\nDEVPATH=", NULL }; char target_queues[PATH_MAX + 1]; // default event queue memset (g_dev_events, 0, PATH_MAX + 1); memset (target_queues, 0, PATH_MAX + 1); memset (event_path, 0, PATH_MAX + 1); strcpy (g_dev_events, DEFAULT_DEV_EVENTS); static struct option opts[] = { {"source-queue", required_argument, 0, 's'}, {"seqnum", required_argument, 0, 'n'}, {"help", no_argument, 0, 'h'}, {0, 0, 0, 0} }; char const *optstr = "n:s:h"; while (rc == 0 && c != -1) { c = getopt_long (argc, argv, optstr, opts, &opt_index); if (c == -1) { break; } switch (c) { case 's': { memset (g_dev_events, 0, PATH_MAX); strncpy (g_dev_events, optarg, PATH_MAX); break; } case 'n': { seqnum = (uint64_t) strtoull (optarg, &tmp, 10); if (seqnum == 0 && (tmp == optarg || *tmp != '\0')) { usage (argv[0]); exit (1); } have_seqnum = true; break; } case 'h': { help (argv[0]); exit (0); } default: { fprintf (stderr, "[ERROR] %s: Unrecognized option '%c'\n", argv[0], c); usage (argv[0]); exit (1); } } } // get the event memset (event_buf, 0, 8192); nr = read_uninterrupted (STDIN_FILENO, event_buf, 8192); if (nr <= 0) { rc = -errno; fprintf (stderr, "[ERROR] %s: Failed to read event from stdin: %s\n", argv[0], strerror (-rc)); exit (1); } // simple sanity check for requirements for (int i = 0; required_fields[i] != NULL; i++) { if (strstr (event_buf, required_fields[i]) == NULL) { // head of line? with no leading '\n'? if (strncmp (event_buf, required_fields[i] + 1, strlen (required_fields[i]) - 1) != 0) { fprintf (stderr, "[ERROR] %s: Missing required field '%s'\n", argv[0], required_fields[i] + 1); fprintf (stderr, "[ERROR] %s: Pass -h for a list of required fields\n", argv[0]); exit (1); } } } // do we have a seqnum? if (!have_seqnum) { char *seqnum_str = strstr (event_buf, "SEQNUM="); // go find it in the device event if (seqnum_str == NULL) { fprintf (stderr, "[ERROR] %s: Missing SEQNUM. Pass -n or include SEQNUM= in the input.\n", argv[0]); exit (1); } // is it a valid seqnum? seqnum = (uint64_t) strtoull (seqnum_str + strlen ("SEQNUM="), &tmp, 10); if (seqnum == 0 && (tmp == seqnum_str + strlen ("SEQNUM=") || *tmp != '\n')) { // invalid seqnum fprintf (stderr, "[ERROR] %s: Invalid SEQNUM. Pass -n or include a valid SEQNUM in the input.\n", argv[0]); exit (1); } } // send it off! make_event_path (seqnum, event_path); fd = open_event (event_path); if (fd < 0) { fprintf (stderr, "[ERROR] %s: Failed to open '%s': %s\n", argv[0], event_path, strerror (-fd)); exit (1); } rc = write_uninterrupted (fd, event_buf, nr); if (rc < 0) { fprintf (stderr, "[ERROR] %s: Failed to write '%s': %s\n", argv[0], event_path, strerror (-fd)); clear_event (event_buf); close (fd); exit (1); } // propagate.... rc = multicast_event (seqnum, event_path); if (rc < 0) { fprintf (stderr, "[ERROR] %s: Failed to multicast '%s': %s\n", argv[0], event_path, strerror (-rc)); clear_event (event_buf); close (fd); exit (1); } // done! clear_event (event_path); close (fd); return 0; }
int main(int argc, char **argv) { SDL_bool ok; char const *root = getenv(ROOTVAR); if (!root || !*root) { fprintf(stderr, "error: environment undefined\n"); fprintf(stderr, "set %s to the installation directory of Fridge Filler\n", ROOTVAR); return 1; } FILE *rp = 0; SDL_bool rp_play = SDL_FALSE; SDL_bool rp_save = SDL_FALSE; if (argc > 1) { if (streq(argv[1], "--save-replay") || streq(argv[1], "-s")) { char const *fname = "replay.txt"; if (argc == 3) { fname = argv[2]; } printf("saving replay to `%s'\n", fname); rp = fopen(fname, "w"); rp_save = SDL_TRUE; } if (streq(argv[1], "--replay") || streq(argv[1], "-r")) { char const *fname = "replay.txt"; if (argc == 3) { fname = argv[2]; } printf("loading replay `%s'\n", fname); rp = fopen(fname, "r"); rp_play = SDL_TRUE; } } session s; game_state gs; ok = init_game(&s, &gs, root); if (!ok) { return 1; } game_event ge; clear_event(&ge); unsigned ticks; unsigned old_ticks = SDL_GetTicks(); int have_ev; SDL_Event event; while (gs.run != MODE_EXIT) { if (!rp_play) { have_ev = SDL_PollEvent(&event); if (have_ev) { process_event(&event, &ge); } unsigned char const *keystate = SDL_GetKeyboardState(0); keystate_to_movement(keystate, &ge.player); } else { have_ev = SDL_PollEvent(&event); if (have_ev) { process_event(&event, &ge); if (ge.exit) { break; } clear_event(&ge); } } ticks = SDL_GetTicks(); if (ticks - old_ticks >= TICK) { if (rp_save) { print_event(rp, &ge); } else if (rp_play) { read_event(rp, &ge); } update_gamestate(&s, &gs, &ge); clear_event(&ge); /* printf("%d\n", ticks - old_ticks); */ old_ticks = ticks; } render(&s, &gs); SDL_Delay(TICK / 4); } int i; for (i = 0; i < NGROUPS; i++) { free(gs.entities[i].e); } destroy_level(&s.level); SDL_DestroyTexture(s.level.background); if (gs.debug.font) { TTF_CloseFont(gs.debug.font); }; if (rp) { fclose(rp); } free(s.msg.msgs); SDL_DestroyRenderer(s.r); SDL_DestroyWindow(s.w); SDL_Quit(); return 0; }