static int start_monitoring(struct devfreq *df) { int ret, mbyte; ret = request_threaded_irq(l2pm_irq, NULL, mon_intr_handler, IRQF_ONESHOT | IRQF_SHARED, "cpubw_hwmon", df); if (ret) { pr_err("Unable to register interrupt handler\n"); return ret; } mon_init(); mon_disable(RD_MON); mon_disable(WR_MON); mbyte = (df->previous_freq * io_percent) / (2 * 100); prev_r_start_val = mon_set_limit_mbyte(RD_MON, mbyte); prev_w_start_val = mon_set_limit_mbyte(WR_MON, mbyte); prev_ts = ktime_get(); prev_ab = 0; mon_irq_enable(RD_MON, true); mon_irq_enable(WR_MON, true); mon_enable(RD_MON); mon_enable(WR_MON); global_mon_enable(true); return 0; }
void mpoly_randtest(mpoly_t rop, flint_rand_t state, long d, long N, const ctx_t ctx) { long i, n = rop->n; mpoly_zero(rop, ctx); for (i = 0; i < N; i++) { int ins; mon_t m1, m2; char *c1; void *c2; mon_init(m1); mon_randtest(m1, state, n, d); c1 = malloc(ctx->size); ctx->init(ctx, c1); ctx->randtest_not_zero(ctx, c1, state); ins = RBTREE_INSERT(mpoly, &m2, &c2, rop->dict, m1, c1, &mon_cmp); if (ins) { mon_clear(m2); ctx->clear(ctx, c2); free(c2); } } }
/****************************************************************************** **函数名称: main **功 能: 监控主程序 **输入参数: NONE **输出参数: NONE **返 回: 0:成功 !0:失败 **实现描述: ** 1. 初始化菜单环境 ** 2. 加载子菜单 ** 3. 启动菜单功能 **注意事项: **作 者: # Qifeng.zou # 2014.12.27 # ******************************************************************************/ int main(int argc, char *argv[]) { mon_opt_t opt; mon_cntx_t *ctx; memset(&opt, 0, sizeof(opt)); umask(0); mem_ref_init(); set_fd_limit(65535); signal(SIGPIPE, SIG_IGN); /* > 解析输入参数 */ if (mon_getopt(argc, argv, &opt)) { return mon_usage(argv[0]); } /* > 初始化全局信息 */ ctx = mon_init(opt.conf_path); if (NULL == ctx) { fprintf(stderr, "Initialize monitor failed!\n"); return -1; } /* > 启动菜单模块 */ if (menu_run(ctx->menu)) { fprintf(stderr, "Startup menu failed!\n"); return -1; } return 0; }
/* Returns MBps of read/writes for the sampling window. */ static int mon_get_mbps(int n, u32 start_val, unsigned int us) { u32 overflow, count; long long beats; count = get_l2_indirect_reg(L2PMnEVCNTR(n)); overflow = get_l2_indirect_reg(L2PMOVSR); if (overflow & BIT(n)) beats = 0xFFFFFFFF - start_val + count; else beats = count - start_val; beats *= USEC_PER_SEC; beats *= bytes_per_beat; do_div(beats, us); beats = DIV_ROUND_UP_ULL(beats, MBYTE); pr_debug("EV%d ov: %x, cnt: %x\n", n, overflow, count); return beats; } static void do_bw_sample(struct work_struct *work); static DECLARE_DEFERRED_WORK(bw_sample, do_bw_sample); static struct workqueue_struct *bw_sample_wq; static DEFINE_MUTEX(bw_lock); static ktime_t prev_ts; static u32 prev_r_start_val; static u32 prev_w_start_val; static struct msm_bus_paths bw_levels[] = { BW(0), BW(200), }; static struct msm_bus_scale_pdata bw_data = { .usecase = bw_levels, .num_usecases = ARRAY_SIZE(bw_levels), .name = "cpubw-krait", .active_only = 1, }; static u32 bus_client; static void compute_bw(int mbps); static irqreturn_t mon_intr_handler(int irq, void *dev_id); #define START_LIMIT 100 /* MBps */ static int start_monitoring(void) { int mb_limit; int ret; bw_sample_wq = alloc_workqueue("cpubw-krait", WQ_HIGHPRI, 0); if (!bw_sample_wq) { pr_err("Unable to alloc workqueue\n"); return -ENOMEM; } ret = request_threaded_irq(MON_INT, NULL, mon_intr_handler, IRQF_ONESHOT | IRQF_SHARED | IRQF_TRIGGER_RISING, "cpubw_krait", mon_intr_handler); if (ret) { pr_err("Unable to register interrupt handler\n"); return ret; } bus_client = msm_bus_scale_register_client(&bw_data); if (!bus_client) { pr_err("Unable to register bus client\n"); ret = -ENODEV; goto bus_reg_fail; } compute_bw(START_LIMIT); mon_init(); mon_disable(0); mon_disable(1); mb_limit = mult_frac(START_LIMIT, sample_ms, MSEC_PER_SEC); mb_limit /= 2; prev_r_start_val = mon_set_limit_mbyte(0, mb_limit); prev_w_start_val = mon_set_limit_mbyte(1, mb_limit); prev_ts = ktime_get(); set_l2_indirect_reg(L2PMINTENSET, BIT(0)); set_l2_indirect_reg(L2PMINTENSET, BIT(1)); mon_enable(0); mon_enable(1); global_mon_enable(true); queue_delayed_work(bw_sample_wq, &bw_sample, msecs_to_jiffies(sample_ms)); return 0; bus_reg_fail: destroy_workqueue(bw_sample_wq); disable_irq(MON_INT); free_irq(MON_INT, mon_intr_handler); return ret; }
int main(void) { CLKPR = (1<<7); CLKPR = 0; /* Disable watchdog timer */ MCUSR = 0; wdt_disable(); /* Start the multi-threading kernel */ init_kernel(STACK_MAIN); /* Timer */ TCCR2B = 0x03; /* Pre-scaler for timer0 */ TCCR2A = 1<<WGM21; /* CTC mode */ TIMSK2 = 1<<OCIE2A; /* Interrupt on compare match */ OCR2A = (SCALED_F_CPU / 32 / 2400) - 1; TRACE_INIT; sei(); t_stackErrorHandler(stackOverflow); fbuf_errorHandler(bufferOverflow); reset_params(); /* HDLC and AFSK setup */ mon_init(&cdc_outstr); adf7021_init(); inframes = hdlc_init_decoder( afsk_init_decoder() ); outframes = hdlc_init_encoder( afsk_init_encoder() ); digipeater_init(); /* Activate digipeater in ui thread */ /* USB */ usb_init(); THREAD_START(usbSerListener, STACK_USBLISTENER); ui_init(); /* GPS and tracking */ gps_init(&cdc_outstr); tracker_init(); TRACE(1); while(1) { lbeep(); if (t_is_idle()) { /* Enter idle mode or sleep mode here */ powerdown_handler(); sleep_mode(); } else t_yield(); } }
/* Returns the monomial in $n$ variables given by the string \code{str}, where the string is simply a space-separated list of exponents. */ static mon_t mpoly_mon_set_str(const char * str, int n) { mon_t rop; int i; size_t off; mon_init(rop); off = 0; for (i = 0; i < n; i++) { exp_t e = atoi(str + off); mon_set_exp(rop, i, e); off += 1 + (e >= 0) + (e >= 10) + (e >= 100); } return rop; }
psim_init(psim *system) { int cpu_nr; /* scrub the monitor */ mon_init(system->monitor, system->nr_cpus); /* trash any pending events */ event_queue_init(system->events); /* if needed, schedule a halt event. FIXME - In the future this will be replaced by a more generic change to psim_command(). A new command `schedule NNN halt' being added. */ if (tree_find_property(system->devices, "/openprom/options/max-iterations")) { event_queue_schedule(system->events, tree_find_integer_property(system->devices, "/openprom/options/max-iterations") - 2, psim_max_iterations_exceeded, system); } /* scrub all the cpus */ for (cpu_nr = 0; cpu_nr < system->nr_cpus; cpu_nr++) cpu_init(system->processors[cpu_nr]); /* init all the devices (which updates the cpus) */ tree_init(system->devices, system); /* and the emulation (which needs an initialized device tree) */ os_emul_init(system->os_emulation, system->nr_cpus); /* now sync each cpu against the initialized state of its registers */ for (cpu_nr = 0; cpu_nr < system->nr_cpus; cpu_nr++) { cpu *processor = system->processors[cpu_nr]; cpu_synchronize_context(processor, cpu_get_program_counter(processor)); cpu_page_tlb_invalidate_all(processor); } /* force loop to start with first cpu */ system->last_cpu = -1; }
int main(void) { int i, result; flint_rand_t state; ctx_t ctx; printf("add_coeff... "); fflush(stdout); _randinit(state); ctx_init_mpq(ctx); for (i = 0; i < 1000; i++) { mpoly_t a; long n, d, N; mon_t m; char *x, *y, *z; n = n_randint(state, MON_MAX_VARS) + 1; d = n_randint(state, 50) + 1; N = n_randint(state, 50) + 1; mon_init(m); mon_randtest(m, state, n, d); x = malloc(ctx->size); y = malloc(ctx->size); z = malloc(ctx->size); ctx->init(ctx, x); ctx->init(ctx, y); ctx->init(ctx, z); ctx->randtest(ctx, x, state); mpoly_init(a, n, ctx); mpoly_randtest(a, state, d, N, ctx); mpoly_get_coeff(y, a, m, ctx); ctx->add(ctx, y, y, x); mpoly_add_coeff(a, m, x, ctx); mpoly_get_coeff(z, a, m, ctx); result = (ctx->equal(ctx, y, z)); if (!result) { printf("FAIL:\n"); mpoly_print(a, ctx); printf("\n"); ctx->print(ctx, x); printf("\n"); ctx->print(ctx, y); printf("\n"); ctx->print(ctx, z); printf("\n"); abort(); } mpoly_clear(a, ctx); mon_clear(m); ctx->clear(ctx, x); ctx->clear(ctx, y); ctx->clear(ctx, z); free(x); free(y); free(z); } _randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { int i; int run; char *cfg; ini_sct_t *sct; if (argc == 2) { if (str_isarg1 (argv[1], "--help")) { prt_help(); return (0); } else if (str_isarg1 (argv[1], "--version")) { prt_version(); return (0); } } cfg = NULL; run = 0; pce_log_init(); pce_log_add_fp (stderr, 0, MSG_INF); par_cfg = ini_sct_new (NULL); if (par_cfg == NULL) { return (1); } i = 1; while (i < argc) { if (str_isarg2 (argv[i], "-v", "--verbose")) { pce_log_set_level (stderr, MSG_DEB); } else if (str_isarg2 (argv[i], "-q", "--quiet")) { pce_log_set_level (stderr, MSG_ERR); } else if (str_isarg2 (argv[i], "-c", "--config")) { i += 1; if (i >= argc) { return (1); } cfg = argv[i]; } else if (str_isarg2 (argv[i], "-l", "--log")) { i += 1; if (i >= argc) { return (1); } pce_log_add_fname (argv[i], MSG_DEB); } else if (str_isarg2 (argv[i], "-r", "--run")) { run = 1; } else { printf ("%s: unknown option (%s)\n", argv[0], argv[i]); return (1); } i += 1; } pce_log (MSG_INF, "pce sim6502 version " PCE_VERSION_STR "\n" "Copyright (C) 1995-2012 Hampa Hug <*****@*****.**>\n" ); if (pce_load_config (par_cfg, cfg)) { return (1); } sct = ini_next_sct (par_cfg, NULL, "sim6502"); if (sct == NULL) { pce_log (MSG_ERR, "*** section 'sim6502' not found in config file\n"); return (1); } par_sim = s6502_new (sct); e6502_set_hook_undef_fct (par_sim->cpu, par_sim, s6502_hook_undef); signal (SIGINT, &sig_int); signal (SIGSEGV, &sig_segv); #ifdef SIGPIPE signal (SIGPIPE, SIG_IGN); #endif pce_console_init (stdin, stdout); mon_init (&par_mon); mon_set_cmd_fct (&par_mon, s6502_do_cmd, par_sim); mon_set_msg_fct (&par_mon, NULL, par_sim); mon_set_get_mem_fct (&par_mon, par_sim->mem, mem_get_uint8); mon_set_set_mem_fct (&par_mon, par_sim->mem, mem_set_uint8); mon_set_memory_mode (&par_mon, 0); cmd_init (par_sim, cmd_get_sym, cmd_set_sym); mon_cmd_add (&par_mon, par_cmd, sizeof (par_cmd) / sizeof (par_cmd[0])); mon_cmd_add_bp (&par_mon); s6502_reset (par_sim); if (run) { s6502_run (par_sim); if (par_sim->brk != PCE_BRK_ABORT) { fputs ("\n", stdout); } } else { pce_log (MSG_INF, "type 'h' for help\n"); } if (par_sim->brk != PCE_BRK_ABORT) { mon_run (&par_mon); } s6502_del (par_sim); mon_free (&par_mon); pce_console_done(); pce_log_done(); return (0); }
int mpoly_set_str(mpoly_t rop, const char * str, const ctx_t ctx) { int i, j, n, num; const size_t len = strlen(str); /* Step 1. Set the number of variables */ n = atoi(str); mpoly_clear(rop, ctx); mpoly_init(rop, n, ctx); /* Step 2. Count the number of terms */ num = 1; for (i = 0; i < len; i++) { if (num > 0 && str[i] == '[') num = -num - 1; else if (num < 0 && str[i] == ']') num = -num; } num = num - 1; if (num < 0) { printf("ERROR (mpoly_set_str). num = %d\n", num); abort(); } if (num == 0) return 1; /* Step 3. Process the terms one after the other */ /* Read past the first integer, and skip following white space */ j = 0; while (str[j] != ' ') j++; while (str[j] == ' ') j++; for (i = 0; i < num; i++) { char *s; int ins, jclose; mon_t m, m2; char *c; void *c2; /* First we set the coefficient and the monomial separately, moving the index j just one past the closing bracket ']' of the monomial. */ mon_init(m); c = malloc(ctx->size); ctx->init(ctx, c); while (str[j] != '(' && str[j] != '[') j++; if (str[j] == '(') { jclose = mpoly_str_find_close(str, j, '(', ')'); s = mpoly_str_substr(str, j + 1, jclose); ctx->set_str(ctx, c, s); free(s); j = jclose + 1; while (str[j] != '[') j++; } else { ctx->one(ctx, c); } jclose = mpoly_str_find_close(str, j, '[', ']'); s = mpoly_str_substr(str, j + 1, jclose); m = mpoly_mon_set_str(s, n); free(s); j = jclose + 1; /* Now we insert the new node */ ins = RBTREE_INSERT(mpoly, &m2, &c2, rop->dict, m, c, &mon_cmp); if (ins) { printf("ERROR (mpoly_set_str). Duplicate monomial.\n"); abort(); } } return 1; }
void main_init(int argc, char *argv[]) { bool override_hw = false; if (argc > 1) { if (strcmp(argv[1], "calibrate") == 0) calibrate = true; else override_hw = true; } /* init data structures: */ memset(&pos_in, 0, sizeof(pos_in_t)); vec3_init(&pos_in.acc); /* init SCL subsystem: */ syslog(LOG_INFO, "initializing signaling and communication link (SCL)"); if (scl_init("pilot") != 0) { syslog(LOG_CRIT, "could not init scl module"); die(); } /* init params subsystem: */ syslog(LOG_INFO, "initializing opcd interface"); opcd_params_init("pilot.", 1); /* initialize logger: */ syslog(LOG_INFO, "opening logger"); if (logger_open() != 0) { syslog(LOG_CRIT, "could not open logger"); die(); } syslog(LOG_CRIT, "logger opened"); LOG(LL_INFO, "initializing platform"); if (arcade_quad_init(&platform, override_hw) < 0) { LOG(LL_ERROR, "could not initialize platform"); die(); } acc_mag_cal_init(); cmc_init(); const size_t array_len = sizeof(float) * platform.n_motors; setpoints = malloc(array_len); ASSERT_NOT_NULL(setpoints); memset(setpoints, 0, array_len); rpm_square = malloc(array_len); ASSERT_NOT_NULL(rpm_square); memset(rpm_square, 0, array_len); LOG(LL_INFO, "initializing model/controller"); pos_init(); ne_speed_ctrl_init(REALTIME_PERIOD); att_ctrl_init(); yaw_ctrl_init(); u_ctrl_init(); u_speed_init(); navi_init(); LOG(LL_INFO, "initializing command interface"); cmd_init(); motors_state_init(); blackbox_init(); /* init flight logic: */ flight_logic_init(); /* init calibration data: */ cal_init(&gyro_cal, 3, 1000); cal_ahrs_init(); flight_state_init(50, 150, 4.0); piid_init(REALTIME_PERIOD); interval_init(&gyro_move_interval); gps_data_init(&gps_data); mag_decl_init(); cal_init(&rc_cal, 3, 500); tsfloat_t acc_fg; opcd_param_t params[] = { {"acc_fg", &acc_fg}, OPCD_PARAMS_END }; opcd_params_apply("main.", params); filter1_lp_init(&lp_filter, tsfloat_get(&acc_fg), 0.06, 3); cm_init(); mon_init(); LOG(LL_INFO, "entering main loop"); }
/// The Unix version of the function which actually runs and audits the /// child command. The child command is run via fork/exec/wait while /// this process sticks around to become the "monitor". /// The monitor waits for the child to exit and in the meantime it /// processes audit reports sent from exiting subordinate commands. /// @param[in] exe the path to this program (not the audited program) /// @param[in] argv a standard arg vector such as is passed to main() /// @param[in] logfile the name of a file to which log data is written, or NULL /// @return 0 on success, nonzero otherwise int run_cmd(CCS exe, CS *argv, CCS logfile) { CS path; pid_t childpid; int reuseaddr = 1; struct timeval master_timeout, timeout; int64_t session_timeout, last_heartbeat, heartbeat_interval; int sockmin = 3, sockmax = 0; int *listeners; unsigned long ports; fd_set listen_fds; fd_set master_read_fds; int sret; char *pdir; char *shlibdir = NULL; int sync_pipe[2]; int wstat = 0; unsigned int i; path = argv[0]; ports = prop_get_ulong(P_MONITOR_LISTENERS); listeners = putil_malloc(ports * sizeof(int)); // If a logfile is requested, fork a "tee" and connect // stdout and stderr to it. This requires that we trust // tee to go away when its stdin is closed. // Note: we could put this on the child side of the fork // and see only the "real" build messages, but this way // is more compatible with Windows and potentially more // informative. Kind of mind-bending though. if (logfile) { const char *loglevel; loglevel = prop_get_str(P_SERVER_LOG_LEVEL); if (loglevel && !strcmp(loglevel, "OFF")) { if (!(logfp = fopen(logfile, "w"))) { putil_syserr(2, logfile); } } else { char *tcmd, *tsf; tsf = prop_is_true(P_LOG_TIME_STAMP) ? " --log-time-stamp" : ""; if (asprintf(&tcmd, "%s --log-file \"%s\" --log-tee%s", exe, logfile, tsf) >= 0) { if (!(logfp = popen(tcmd, "w"))) { putil_syserr(2, logfile); } putil_free(tcmd); } } if (logfp) { if ((dup2(fileno(logfp), fileno(stdout)) == -1)) { putil_syserr(2, logfile); } if ((dup2(fileno(logfp), fileno(stderr)) == -1)) { putil_syserr(2, logfile); } } // Show the initial command and start time iff output is to a logfile. if (vb_bitmatch(VB_STD)) { CCS cmdline; time_t now; cmdline = util_requote_argv(argv); fprintf(vb_get_stream(), "+ %s\n", cmdline); putil_free(cmdline); time(&now); vb_printf(VB_ON, "STARTED: %s", util_strtrim(ctime(&now))); } } // This property allows the entire auditing process to be dummied out; // we simply run the specified command, wait for it, and return. if (prop_is_true(P_EXECUTE_ONLY)) { if ((childpid = fork()) < 0) { putil_syserr(2, "fork"); } else if (childpid == 0) { execvp(path, argv); putil_syserr(2, path); } else { if (waitpid(childpid, &wstat, 0) == -1) { putil_syserr(0, path); ExitStatus = 5; } else if (WIFEXITED(wstat)) { ExitStatus = WEXITSTATUS(wstat); } else { ExitStatus = 2; } return ExitStatus; } } // The heartbeat interval is the number of seconds allowed // before we send a server heartbeat ping to keep the server // HTTP session alive. The Tomcat default is 30 minutes // but there's no standard default, so we set the default // expicitly in the server's web.xml file. This allows us to // assume that default via HTTP_SESSION_TIMEOUT_SECS_DEFAULT. master_timeout.tv_sec = prop_get_ulong(P_MONITOR_TIMEOUT_SECS); master_timeout.tv_usec = 0; session_timeout = prop_get_ulong(P_SESSION_TIMEOUT_SECS); if (session_timeout) { if ((session_timeout / 4 < master_timeout.tv_sec)) { master_timeout.tv_sec = session_timeout / 4; } heartbeat_interval = session_timeout / 2; } else { heartbeat_interval = HTTP_SESSION_TIMEOUT_SECS_DEFAULT / 2; } // This is really only required on Windows. util_socket_lib_init(); // The grandparent dir of this exe becomes the base where // we look for the preloaded library. if (!(pdir = putil_dirname(exe)) || !(shlibdir = putil_dirname(pdir))) { putil_syserr(2, "dirname(exe)"); } putil_free(pdir); // Special case for truly "raw" output. There's no need // for a monitor process here; just inject and exec. if (shlibdir && prop_is_true(P_NO_MONITOR)) { libinterposer_preload_on(AUDITOR, shlibdir); execvp(path, argv); putil_syserr(2, path); } // This pipe will be used to ensure that the child doesn't get rolling // before the parent process is ready for its audits. if (pipe(sync_pipe) == -1) { putil_syserr(2, "pipe(sync_pipe)"); } { struct sockaddr_in addr; socklen_t addrlen; char *portstr; size_t len; u_short port; // Max digits needed to represent a 32-bit value plus ':' is 11. len = ports * 11; portstr = putil_calloc(len, 1); for (i = 0; i < ports; i++) { if ((listeners[i] = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) { putil_syserr(2, "socket()"); } if (setsockopt(listeners[i], SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr)) == SOCKET_ERROR) { putil_syserr(2, "SO_REUSEADDR"); } addrlen = sizeof(addr); memset(&addr, 0, addrlen); addr.sin_family = PF_INET; addr.sin_addr.s_addr = INADDR_ANY; addr.sin_port = htons(0); if (bind(listeners[i], (struct sockaddr *)&addr, addrlen)) { putil_syserr(2, "bind()"); } if (getsockname(listeners[i], (struct sockaddr *)&addr, &addrlen)) { putil_syserr(2, "getsockname"); } port = ntohs(addr.sin_port); snprintf(endof(portstr), len - strlen(portstr), "%u:", port); } prop_override_str(P_MONITOR_PORT, portstr); putil_free(portstr); } if ((childpid = fork()) < 0) { putil_syserr(2, "fork"); } else if (childpid == 0) { char sync_buf[2]; struct sockaddr_in dest_addr; int nfd; /***************************************************************** * CHILD *****************************************************************/ // Not needed on child side. for (i = 0; i < ports; i++) { fcntl(listeners[i], F_SETFD, fcntl(listeners[i], F_GETFD) | FD_CLOEXEC); } // We must wait till the parent has established its socket // before letting the build run. Otherwise we might try to // connect to it before it's ready. close(sync_pipe[1]); read(sync_pipe[0], sync_buf, 1); close(sync_pipe[0]); // Turn on the auditor. if (shlibdir) { libinterposer_preload_on(AUDITOR, shlibdir); putil_free(shlibdir); } // Run the command under control of the audit lib. execvp(path, argv); // Give an error if we were unable to exec at all. putil_die("%s: %s", path, strerror(errno)); // The parent will be blocking on the first listening socket and needs // to hear from us on exec error. Send a special code telling // it to shut down gracefully. if ((nfd = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) { putil_syserr(2, "socket()"); } memset(&dest_addr, 0, sizeof(dest_addr)); dest_addr.sin_family = PF_INET; dest_addr.sin_addr.s_addr = inet_addr(prop_get_str(P_MONITOR_HOST)); dest_addr.sin_port = htons(strtoul(prop_get_str(P_MONITOR_PORT), NULL, 0)); if ((connect(nfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr))) == -1) { putil_syserr(2, "connect()"); } // Tell the parent to abort the mission. write(nfd, "!\n", 2); close(nfd); _exit(2); } putil_free(shlibdir); /********************************************************************* * PARENT *********************************************************************/ _sig_setup(); last_heartbeat = time(NULL); // Bump the number of allowed file descriptors to the maximum, // because the monitor is likely to use a fair number. There // is no real bound on fds in use since the monitor may behave // asynchronously with respect to both audited child processes // and HTTP connections to the server. _maximize_fds(); // Perform any one-time initializations related to the monitor. mon_init(); // This pipe is used as a belt-and-suspenders method for letting // the monitor know that the build is done. if (pipe(done_pipe) == -1) { putil_syserr(2, "pipe(done_pipe)"); } FD_ZERO(&master_read_fds); FD_ZERO(&listen_fds); // Add the read end of the self-pipe to the master set. FD_SET(done_pipe[0], &master_read_fds); sockmax = done_pipe[0]; for (i = 0; i < ports; i++) { // Set up these sockets as listeners. if (listen(listeners[i], SOMAXCONN) == SOCKET_ERROR) { putil_syserr(2, "listen"); } // Add the listening sockets to the master set. FD_SET(listeners[i], &master_read_fds); // And to the listener set FD_SET(listeners[i], &listen_fds); // Keep track of the highest-numbered live socket. sockmax = (listeners[i] > sockmax) ? listeners[i] : sockmax; } // Alert the child that we're ready to roll. close(sync_pipe[0]); close(sync_pipe[1]); // The select loop. // Some network gurus argue that select should never be used // with blocking descriptors, but that's what we do here. Never looked // into why they say so but this should be run past an expert. while (!doneflag) { int fd; fd_set read_fds; // We have to reset the timeout because some implementations // of select modify it. This could cause it to busy-wait // as the timeout becomes zero. timeout = master_timeout; // Initialize the read fdset to its top-of-loop state. read_fds = master_read_fds; sret = select(sockmax + 1, &read_fds, NULL, NULL, &timeout); if (sret == SOCKET_ERROR) { #if defined(EINTR) if (errno == EINTR) { continue; } #endif /*!EINTR*/ putil_syserr(2, "select"); } else { // We like to ping the server once in a while, partly // to make sure it's still there but primarily to keep // its session alive. if (prop_has_value(P_SERVER)) { int64_t now; now = time(NULL); if ((now - last_heartbeat) >= heartbeat_interval) { http_heartbeat(now - last_heartbeat); last_heartbeat = now; } } // Continue on select timeout. if (sret == 0) { continue; } } for (i = 0; i < ports; i++) { int found = 0; if (FD_ISSET(listeners[i], &read_fds)) { SOCKET newfd; // Accept a new connection. if ((newfd = accept(listeners[i], NULL, NULL)) == INVALID_SOCKET) { putil_syserr(2, "accept"); } // Add it to the master set FD_SET(newfd, &master_read_fds); // Keep track of the highest numbered socket if (newfd > sockmax) { sockmax = newfd; } found++; } if (found) continue; } // This can be turned on with a signal. if (dumpflag) { mon_dump(); dumpflag = 0; } // Run through existing connections looking for data for (fd = sockmin; fd <= sockmax; fd++) { CS buffer, buftmp, line; if (FD_ISSET(fd, &listen_fds) || !FD_ISSET(fd, &read_fds)) { continue; } buffer = _read_available(fd); for (buftmp = buffer, line = util_strsep(&buftmp, "\n"); line && *line; line = util_strsep(&buftmp, "\n")) { if (!strcmp(line, DONE_TOKEN)) { // If the top-level process has ended, we have // to be finished. vb_printf(VB_MON, "DONE: %lu", childpid); doneflag = 1; } else { unsigned monrc; CCS winner; monrc = mon_record(line, &ExitStatus, NULL, &winner); if (monrc & MON_NEXT) { // Nothing more to do - hit me again. } else if (monrc & MON_ERR) { // Nothing more to do - error already handled. } else if (monrc & MON_CANTRUN) { // This means the top-level process was unable // to run at all. doneflag = 1; break; } else if (monrc & MON_SOA) { char ack[ACK_BUFFER_SIZE]; if (monrc & MON_RECYCLED) { // Tell auditor we recycled so it can exit. snprintf(ack, sizeof(ack), "%s\n", winner); } else if (monrc & MON_STRICT) { // Tell auditor we failed a requirement. snprintf(ack, sizeof(ack), "%s\n", ACK_FAILURE); ExitStatus = 3; } else if (monrc & MON_AGG) { // Tell auditor this command is aggregated. snprintf(ack, sizeof(ack), "%s\n", ACK_OK_AGG); } else { // No special message - carry on. snprintf(ack, sizeof(ack), "%s\n", ACK_OK); } if (util_send_all(fd, ack, strlen(ack), 0) == -1) { putil_syserr(0, "send(ack)"); } if (monrc & MON_TOP) { if (Started) { mon_ptx_end(ExitStatus, logfile); } mon_ptx_start(); Started = 1; } } else if (monrc & MON_EOA) { // Nothing more to do - end processing handled elsewhere } else { putil_warn("unrecognized line '%s'", line); } } } // We've reached EOF on a particular delivery; // close the socket, remove it from the select mask, and // return to the loop. close(fd); FD_CLR(fd, &master_read_fds); putil_free(buffer); } http_async_transfer(0); } // Wait for ending child, reap its exit code. if (waitpid(childpid, &wstat, 0) == -1) { putil_syserr(0, path); ExitStatus = 5; } if (WIFEXITED(wstat)) { if (ExitStatus == 0) { ExitStatus = WEXITSTATUS(wstat); } } else { if (WIFSIGNALED(wstat)) { #if defined(__hpux) // HACK - no strsignal on HPUX 11.00 putil_error("%s: %s%s", path, "", WCOREDUMP(wstat) ? " (coredump)" : ""); #else /*__hpux*/ putil_error("%s: %s%s", path, strsignal(WTERMSIG(wstat)), WCOREDUMP(wstat) ? " (coredump)" : ""); #endif /*__hpux*/ } ExitStatus = 2; } mon_ptx_end(ExitStatus, logfile); mon_fini(); for (i = 0; i < ports; i++) { if (close(listeners[i]) == SOCKET_ERROR) { putil_syserr(0, "close(socket)"); } } util_socket_lib_fini(); return ExitStatus; }
int main(void) { int i, result; flint_rand_t state; ctx_t ctx; printf("mul_mon... "); fflush(stdout); _randinit(state); ctx_init_mpq(ctx); /* Check aliasing of a and b */ for (i = 0; i < 1000; i++) { mpoly_t a, b; mon_t m; long n, d, N; n = n_randint(state, MON_MAX_VARS) + 1; d = n_randint(state, 50) + 1; N = n_randint(state, 50) + 1; mon_init(m); mon_randtest(m, state, n, d); mpoly_init(a, n, ctx); mpoly_init(b, n, ctx); mpoly_randtest(a, state, d, N, ctx); mpoly_mul_mon(b, a, m, ctx); mpoly_mul_mon(a, a, m, ctx); result = (mpoly_equal(a, b, ctx)); if (!result) { printf("FAIL:\n"); mpoly_print(a, ctx); printf("\n"); mpoly_print(b, ctx); printf("\n"); mon_print(m, n); printf("\n"); abort(); } mpoly_clear(a, ctx); mpoly_clear(b, ctx); mon_clear(m); } /* Check (b*c) + (b*d) = b*(c+d) */ for (i = 0; i < 1000; i++) { mpoly_t a1, a2, c1, c2; mon_t b; long n, d, N; n = n_randint(state, MON_MAX_VARS) + 1; d = n_randint(state, 50) + 1; N = n_randint(state, 50) + 1; mon_init(b); mon_randtest(b, state, n, d); mpoly_init(a1, n, ctx); mpoly_init(a2, n, ctx); mpoly_init(c1, n, ctx); mpoly_init(c2, n, ctx); mpoly_randtest(c1, state, d, N, ctx); mpoly_randtest(c2, state, d, N, ctx); mpoly_mul_mon(a1, c1, b, ctx); mpoly_mul_mon(a2, c2, b, ctx); mpoly_add(a1, a1, a2, ctx); mpoly_add(c1, c1, c2, ctx); mpoly_mul_mon(a2, c1, b, ctx); result = (mpoly_equal(a1, a2, ctx)); if (!result) { printf("FAIL:\n"); mpoly_print(a1, ctx); printf("\n"); mpoly_print(a2, ctx); printf("\n"); mon_print(b, n); printf("\n"); mpoly_print(c1, ctx); printf("\n"); mpoly_print(c2, ctx); printf("\n"); abort(); } mpoly_clear(a1, ctx); mpoly_clear(a2, ctx); mpoly_clear(c1, ctx); mpoly_clear(c2, ctx); mon_clear(b); } _randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
bool InitAll(const char *vmdir) { // Check ROM version if (!CheckROM()) { ErrorAlert(STR_UNSUPPORTED_ROM_TYPE_ERR); return false; } #if EMULATED_68K // Set CPU and FPU type (UAE emulation) switch (ROMVersion) { case ROM_VERSION_64K: case ROM_VERSION_PLUS: case ROM_VERSION_CLASSIC: CPUType = 0; FPUType = 0; TwentyFourBitAddressing = true; break; case ROM_VERSION_II: CPUType = PrefsFindInt32("cpu"); if (CPUType < 2) CPUType = 2; if (CPUType > 4) CPUType = 4; FPUType = PrefsFindBool("fpu") ? 1 : 0; if (CPUType == 4) FPUType = 1; // 68040 always with FPU TwentyFourBitAddressing = true; break; case ROM_VERSION_32: CPUType = PrefsFindInt32("cpu"); if (CPUType < 2) CPUType = 2; if (CPUType > 4) CPUType = 4; FPUType = PrefsFindBool("fpu") ? 1 : 0; if (CPUType == 4) FPUType = 1; // 68040 always with FPU TwentyFourBitAddressing = false; break; } CPUIs68060 = false; #endif // Load XPRAM XPRAMInit(vmdir); // Load XPRAM default values if signature not found if (XPRAM[0x0c] != 0x4e || XPRAM[0x0d] != 0x75 || XPRAM[0x0e] != 0x4d || XPRAM[0x0f] != 0x63) { D(bug("Loading XPRAM default values\n")); memset(XPRAM, 0, 0x100); XPRAM[0x0c] = 0x4e; // "NuMc" signature XPRAM[0x0d] = 0x75; XPRAM[0x0e] = 0x4d; XPRAM[0x0f] = 0x63; XPRAM[0x01] = 0x80; // InternalWaitFlags = DynWait (don't wait for SCSI devices upon bootup) XPRAM[0x10] = 0xa8; // Standard PRAM values XPRAM[0x11] = 0x00; XPRAM[0x12] = 0x00; XPRAM[0x13] = 0x22; XPRAM[0x14] = 0xcc; XPRAM[0x15] = 0x0a; XPRAM[0x16] = 0xcc; XPRAM[0x17] = 0x0a; XPRAM[0x1c] = 0x00; XPRAM[0x1d] = 0x02; XPRAM[0x1e] = 0x63; XPRAM[0x1f] = 0x00; XPRAM[0x08] = 0x13; XPRAM[0x09] = 0x88; XPRAM[0x0a] = 0x00; XPRAM[0x0b] = 0xcc; XPRAM[0x76] = 0x00; // OSDefault = MacOS XPRAM[0x77] = 0x01; } // Set boot volume int16 i16 = PrefsFindInt32("bootdrive"); XPRAM[0x78] = i16 >> 8; XPRAM[0x79] = i16 & 0xff; i16 = PrefsFindInt32("bootdriver"); XPRAM[0x7a] = i16 >> 8; XPRAM[0x7b] = i16 & 0xff; // Init drivers SonyInit(); DiskInit(); CDROMInit(); SCSIInit(); #if SUPPORTS_EXTFS // Init external file system ExtFSInit(); #endif // Init serial ports SerialInit(); // Init network EtherInit(); // Init Time Manager TimerInit(); // Init clipboard ClipInit(); // Init ADB ADBInit(); // Init audio AudioInit(); // Init video if (!VideoInit(ROMVersion == ROM_VERSION_64K || ROMVersion == ROM_VERSION_PLUS || ROMVersion == ROM_VERSION_CLASSIC)) return false; // Set default video mode in XPRAM XPRAM[0x56] = 0x42; // 'B' XPRAM[0x57] = 0x32; // '2' const monitor_desc &main_monitor = *VideoMonitors[0]; XPRAM[0x58] = uint8(main_monitor.depth_to_apple_mode(main_monitor.get_current_mode().depth)); XPRAM[0x59] = 0; #if EMULATED_68K // Init 680x0 emulation (this also activates the memory system which is needed for PatchROM()) if (!Init680x0()) return false; #endif // Install ROM patches if (!PatchROM()) { ErrorAlert(STR_UNSUPPORTED_ROM_TYPE_ERR); return false; } #if ENABLE_MON // Initialize mon mon_init(); mon_read_byte = mon_read_byte_b2; mon_write_byte = mon_write_byte_b2; #endif return true; }
int main(int argc, char *argv[]) { mon_t m, m1, m2, *list; long i, len; char *out, *out1, *out2; printf("t-all\n"); printf("=====\n"); fflush(stdout); /* INIT, FROM_STRING, CLEAR */ mon_init(m); mon_set_str(m, "3 1 1 1"); out = mon_get_str(m, 3); printf("m = {%s}\n", out); free(out); mon_clear(m); /* GENERATE_BY_DEGREE */ printf("Generating all monomials in X, Y, Z of degree 6\n"); list = mon_generate_by_degree(&len, 3, 6); for (i = 0; i < len; i++) { out = mon_get_str_pretty(list[i], 3, NULL); printf(" %s\n", out); free(out); } for (i = 0; i < len; i++) mon_clear(list[i]); free(list); printf("Generating all monomials in X, Y, Z of degree 6\n"); list = mon_generate_by_degree_invlex(&len, 3, 6); for (i = 0; i < len; i++) { out = mon_get_str_pretty(list[i], 3, NULL); printf(" %lu - %s\n", list[i], out); free(out); } for (i = 0; i < len; i++) mon_clear(list[i]); free(list); /* IS_ONE, DEGREE */ mon_init(m); mon_set_str(m, "3 2 0 1"); out = mon_get_str_pretty(m, 3, "XYZ"); printf("Is %s equal to one? %d\n", out, mon_is_one(m)); printf("Degree: %d\n", mon_degree(m)); free(out); mon_clear(m); mon_init(m); mon_set_str(m, "3 0 0 0"); out = mon_get_str_pretty(m, 3, "XYZ"); printf("Is %s equal to one? %d\n", out, mon_is_one(m)); printf("Degree: %d\n", mon_degree(m)); free(out); mon_clear(m); /* MUL, DIVIDES, INVLEX */ mon_init(m); mon_init(m1); mon_init(m2); mon_set_str(m1, "3 2 0 1"); mon_set_str(m2, "3 0 1 0"); mon_mul(m, m1, m2); out = mon_get_str_pretty(m, 3, "XYZ"); printf("Product is [2 0 1] [0 1 0] = %s\n", out); free(out); printf("Divides? %d\n", mon_divides(m1, m2)); printf("INVLEX: %d\n", mon_cmp_invlex(m1, m2)); mon_clear(m1); mon_clear(m2); mon_clear(m); /* DIVIDES, DIV, INVLEX */ mon_init(m); mon_init(m1); mon_init(m2); mon_set_str(m1, "3 1 0 1"); mon_set_str(m2, "3 1 1 3"); mon_mul(m, m1, m2); out = mon_get_str_pretty(m, 3, "XYZ"); printf("Product is [1 0 1] [1 1 3] = %s\n", out); free(out); printf("Divides? %d\n", mon_divides(m1, m2)); mon_div(m, m2, m1); out = mon_get_str_pretty(m, 3, "XYZ"); printf("Quotient: %s\n", out); free(out); printf("INVLEX: %d\n", mon_cmp_invlex(m1, m2)); mon_clear(m1); mon_clear(m2); mon_clear(m); /* INVLEX */ mon_set_str(m1, "3 6 0 0"); mon_set_str(m2, "3 0 0 6"); out1 = mon_get_str_pretty(m1, 3, NULL); out2 = mon_get_str_pretty(m2, 3, NULL); printf("CMP_INVLEX(%s, %s) = %d\n", out1, out2, mon_cmp_invlex(m1, m2)); free(out1); free(out2); printf("... "); printf("PASS\n"); fflush(stdout); return EXIT_SUCCESS; }
mon_t * mon_generate_by_degree_invlex(long * len, int n, int d) { mon_t * st; /* Stack (from the bottom), list (from the top) */ int * sums; int * inds; int i; /* Pointer to the top of the stack */ int j; /* Pointer to the bottom of the list */ int N; /* $\binom{n-1+d}{d}$ */ int sum, ind; mon_t m; exp_t exp; /* Special case d == 0 */ if (d == 0) { st = malloc(sizeof(mon_t)); if (!st) { printf("ERROR (mon_generate_by_degree_invlex). Memory allocation failed.\n"); abort(); } mon_init(st[0]); *len = 1; return st; } N = mon_binom(n - 1 + d, d); st = malloc(N * sizeof(mon_t)); sums = malloc(N * sizeof(int)); inds = malloc(N * sizeof(int)); if (!st || !sums || !inds) { printf("ERROR (mon_generate_by_degree_invlex). Memory allocation failed.\n"); abort(); } for (i = 0; i < N; i++) mon_init(st[i]); mon_init(m); i = 0; sums[0] = 0; inds[0] = n - 1; j = N; while (i >= 0) { mon_set(m, st[i]); ind = inds[i]; sum = sums[i]; i--; if (ind > 0) { for (exp = 0; exp <= d - sum; exp++) { i++; mon_set(st[i], m); mon_inc_exp(st[i], ind, exp); inds[i] = ind - 1; sums[i] = sum + exp; } } else { j--; mon_set(st[j], m); mon_inc_exp(st[j], ind, d - sum); } } mon_clear(m); free(sums); free(inds); *len = N; return st; }
int main(int argc, char **argv) { char str[256]; int16 i16; HANDLE rom_fh; const char *rom_path; uint32 rom_size; DWORD actual; uint8 *rom_tmp; // Initialize variables RAMBase = 0; // Print some info printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR); printf(" %s\n", GetString(STR_ABOUT_TEXT2)); // Read preferences PrefsInit(NULL, argc, argv); // Parse command line arguments for (int i=1; i<argc; i++) { if (strcmp(argv[i], "--help") == 0) { usage(argv[0]); } else if (argv[i][0] == '-') { fprintf(stderr, "Unrecognized option '%s'\n", argv[i]); usage(argv[0]); } } // Check we are using a Windows NT kernel >= 4.0 OSVERSIONINFO osvi; ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); if (!GetVersionEx(&osvi)) { ErrorAlert("Could not determine OS type"); QuitEmulator(); } win_os = osvi.dwPlatformId; win_os_major = osvi.dwMajorVersion; if (win_os != VER_PLATFORM_WIN32_NT || win_os_major < 4) { ErrorAlert(GetString(STR_NO_WIN32_NT_4)); QuitEmulator(); } // Check that drivers are installed if (!check_drivers()) QuitEmulator(); // Load win32 libraries KernelInit(); // FIXME: default to DIB driver if (getenv("SDL_VIDEODRIVER") == NULL) putenv("SDL_VIDEODRIVER=windib"); // Initialize SDL system int sdl_flags = 0; #ifdef USE_SDL_VIDEO sdl_flags |= SDL_INIT_VIDEO; #endif #ifdef USE_SDL_AUDIO sdl_flags |= SDL_INIT_AUDIO; #endif assert(sdl_flags != 0); if (SDL_Init(sdl_flags) == -1) { char str[256]; sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError()); ErrorAlert(str); goto quit; } atexit(SDL_Quit); #ifdef ENABLE_MON // Initialize mon mon_init(); #endif // Install SIGSEGV handler for CPU emulator if (!sigsegv_install_handler(sigsegv_handler)) { sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno)); ErrorAlert(str); goto quit; } // Initialize VM system vm_init(); // Get system info PVR = 0x00040000; // Default: 604 CPUClockSpeed = 100000000; // Default: 100MHz BusClockSpeed = 100000000; // Default: 100MHz TimebaseSpeed = 25000000; // Default: 25MHz PVR = 0x000c0000; // Default: 7400 (with AltiVec) D(bug("PVR: %08x (assumed)\n", PVR)); // Init system routines SysInit(); // Show preferences editor if (!PrefsFindBool("nogui")) if (!PrefsEditor()) goto quit; // Create areas for Kernel Data if (!kernel_data_init()) goto quit; kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE); emulator_data = &kernel_data->ed; KernelDataAddr = KERNEL_DATA_BASE; D(bug("Kernel Data at %p (%08x)\n", kernel_data, KERNEL_DATA_BASE)); D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed))); // Create area for DR Cache if (vm_mac_acquire(DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) { sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } dr_emulator_area_mapped = true; if (vm_mac_acquire(DR_CACHE_BASE, DR_CACHE_SIZE) < 0) { sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } dr_cache_area_mapped = true; DRCacheAddr = (uint32)Mac2HostAddr(DR_CACHE_BASE); D(bug("DR Cache at %p (%08x)\n", DRCacheAddr, DR_CACHE_BASE)); // Create area for SheepShaver data if (!SheepMem::Init()) { sprintf(str, GetString(STR_SHEEP_MEM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } // Create area for Mac ROM if (vm_mac_acquire(ROM_BASE, ROM_AREA_SIZE) < 0) { sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } ROMBase = ROM_BASE; ROMBaseHost = Mac2HostAddr(ROMBase); rom_area_mapped = true; D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROMBase)); // Create area for Mac RAM RAMSize = PrefsFindInt32("ramsize"); if (RAMSize < 8*1024*1024) { WarningAlert(GetString(STR_SMALL_RAM_WARN)); RAMSize = 8*1024*1024; } RAMBase = 0; if (vm_mac_acquire(RAMBase, RAMSize) < 0) { sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } RAMBaseHost = Mac2HostAddr(RAMBase); ram_area_mapped = true; D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase)); if (RAMBase > ROMBase) { ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR)); goto quit; } // Load Mac ROM rom_path = PrefsFindString("rom"); rom_fh = CreateFile(rom_path && *rom_path ? rom_path : ROM_FILE_NAME, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (rom_fh == INVALID_HANDLE_VALUE) { rom_fh = CreateFile(ROM_FILE_NAME2, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (rom_fh == INVALID_HANDLE_VALUE) { ErrorAlert(GetString(STR_NO_ROM_FILE_ERR)); goto quit; } } printf(GetString(STR_READING_ROM_FILE)); rom_size = GetFileSize(rom_fh, NULL); rom_tmp = new uint8[ROM_SIZE]; ReadFile(rom_fh, (void *)rom_tmp, ROM_SIZE, &actual, NULL); CloseHandle(rom_fh); // Decode Mac ROM if (!DecodeROM(rom_tmp, actual)) { if (rom_size != 4*1024*1024) { ErrorAlert(GetString(STR_ROM_SIZE_ERR)); goto quit; } else { ErrorAlert(GetString(STR_ROM_FILE_READ_ERR)); goto quit; } } delete[] rom_tmp; // Initialize native timers timer_init(); // Initialize everything if (!InitAll(NULL)) goto quit; D(bug("Initialization complete\n")); // Write protect ROM vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ); // Start 60Hz thread tick_thread_cancel = false; tick_thread_active = ((tick_thread = create_thread(tick_func)) != NULL); SetThreadPriority(tick_thread, THREAD_PRIORITY_ABOVE_NORMAL); D(bug("Tick thread installed (%ld)\n", tick_thread)); // Start NVRAM watchdog thread memcpy(last_xpram, XPRAM, XPRAM_SIZE); nvram_thread_cancel = false; nvram_thread_active = ((nvram_thread = create_thread(nvram_func, NULL)) != NULL); SetThreadPriority(nvram_thread, THREAD_PRIORITY_BELOW_NORMAL); D(bug("NVRAM thread installed (%ld)\n", nvram_thread)); // Get my thread ID and jump to ROM boot routine emul_thread = GetCurrentThread(); D(bug("Jumping to ROM\n")); #ifdef _MSC_VER __try { #endif jump_to_rom(ROMBase + 0x310000); #ifdef _MSC_VER } __except (main_exception_filter(GetExceptionInformation())) {} #endif D(bug("Returned from ROM\n")); quit: Quit(); return 0; }
/*------------------------------------------------------------------------ * sysinit -- initialize all Xinu data structeres and devices *------------------------------------------------------------------------ */ LOCAL sysinit() { static long currsp; int i,j, avail; struct pentry *pptr; struct sentry *sptr; struct mblock *mptr; SYSCALL pfintr(); /*********************/ set_evec(14, pfintr); pptr = &proctab[NULLPROC]; /* initialize null process entry */ /*********************/ numproc = 0; /* initialize system variables */ nextproc = NPROC-1; nextsem = NSEM-1; nextqueue = NPROC; /* q[0..NPROC-1] are processes */ /* initialize free memory list */ /* PC version has to pre-allocate 640K-1024K "hole" */ if (maxaddr+1 > HOLESTART) { memlist.mnext = mptr = (struct mblock *) roundmb(&end); mptr->mnext = (struct mblock *)HOLEEND; mptr->mlen = (int) truncew(((unsigned) HOLESTART - (unsigned)&end)); mptr->mlen -= 4; mptr = (struct mblock *) HOLEEND; mptr->mnext = 0; mptr->mlen = (int) truncew((unsigned)maxaddr - HOLEEND - NULLSTK); /* mptr->mlen = (int) truncew((unsigned)maxaddr - (4096 - 1024 ) * 4096 - HOLEEND - NULLSTK); */ } else { /* initialize free memory list */ memlist.mnext = mptr = (struct mblock *) roundmb(&end); mptr->mnext = 0; mptr->mlen = (int) truncew((unsigned)maxaddr - (int)&end - NULLSTK); } for (i=0 ; i<NPROC ; i++) /* initialize process table */ proctab[i].pstate = PRFREE; #ifdef MEMMARK _mkinit(); /* initialize memory marking */ #endif #ifdef RTCLOCK clkinit(); /* initialize r.t.clock */ #endif mon_init(); /* init monitor */ #ifdef NDEVS for (i=0 ; i<NDEVS ; i++ ) { init_dev(i); } #endif pptr = &proctab[NULLPROC]; /* initialize null process entry */ pptr->pstate = PRCURR; for (j=0; j<7; j++) pptr->pname[j] = "prnull"[j]; pptr->plimit = (WORD)(maxaddr + 1) - NULLSTK; pptr->pbase = (WORD) maxaddr - 3; /* pptr->plimit = (WORD)(maxaddr + 1) - NULLSTK - (4096 - 1024 )*4096; pptr->pbase = (WORD) maxaddr - 3 - (4096-1024)*4096; */ pptr->pesp = pptr->pbase-4; /* for stkchk; rewritten before used */ *( (int *)pptr->pbase ) = MAGIC; pptr->paddr = (WORD) nulluser; pptr->pargs = 0; pptr->pprio = 0; currpid = NULLPROC; for (i=0 ; i<NSEM ; i++) { /* initialize semaphores */ (sptr = &semaph[i])->sstate = SFREE; sptr->sqtail = 1 + (sptr->sqhead = newqueue()); } rdytail = 1 + (rdyhead=newqueue());/* initialize ready list */ init_bsm(); init_frm(); kprintf("initialize page tables for null process\n"); init_glb_pgs(glb_pg_tbl_frm_mapping); // init pg dir for proc 0 frame_t *pg_dir = get_free_frame(); init_pg_dir(pg_dir, NULLPROC); pptr->pdbr = pg_dir->frm_num; pptr->pd = pg_dir; return(OK); }
/*------------------------------------------------------------------------ * sysinit -- initialize all Xinu data structeres and devices *------------------------------------------------------------------------ */ LOCAL int sysinit() { int i,j; struct pentry *pptr; struct sentry *sptr; struct mblock *mptr; numproc = 0; /* initialize system variables */ nextproc = NPROC-1; nextsem = NSEM-1; nextqueue = NPROC; /* q[0..NPROC-1] are processes */ /* initialize free memory list */ /* PC version has to pre-allocate 640K-1024K "hole" */ if (maxaddr+1 > (char *)HOLESTART) { memlist.mnext = mptr = (struct mblock *) roundmb(&end); mptr->mnext = (struct mblock *)HOLEEND; mptr->mlen = (int) truncew(((unsigned) HOLESTART - (unsigned)&end)); mptr->mlen -= 4; mptr = (struct mblock *) HOLEEND; mptr->mnext = 0; mptr->mlen = (int) truncew((unsigned)maxaddr - HOLEEND - NULLSTK); } else { /* initialize free memory list */ memlist.mnext = mptr = (struct mblock *) roundmb(&end); mptr->mnext = 0; mptr->mlen = (int) truncew((unsigned)maxaddr - (int)&end - NULLSTK); } for (i=0 ; i<NPROC ; i++) /* initialize process table */ proctab[i].pstate = PRFREE; pptr = &proctab[NULLPROC]; /* initialize null process entry */ pptr->pstate = PRCURR; for (j=0; j<7; j++) pptr->pname[j] = "prnull"[j]; pptr->plimit = (WORD)(maxaddr + 1) - NULLSTK; pptr->pbase = (WORD) maxaddr - 3; pptr->pesp = pptr->pbase-4; /* for stkchk; rewritten before used */ *( (int *)pptr->pbase ) = MAGIC; pptr->paddr = (WORD) nulluser; pptr->pargs = 0; pptr->pprio = 0; currpid = NULLPROC; for (i=0 ; i<NSEM ; i++) { /* initialize semaphores */ (sptr = &semaph[i])->sstate = SFREE; sptr->sqtail = 1 + (sptr->sqhead = newqueue()); } rdytail = 1 + (rdyhead=newqueue());/* initialize ready list */ #ifdef MEMMARK _mkinit(); /* initialize memory marking */ #endif #ifdef RTCLOCK clkinit(); /* initialize r.t.clock */ #endif pci_init(); /* PCI */ mon_init(); /* init monitor */ // ripinit(); #ifdef NDEVS for (i=0 ; i<NDEVS ; i++ ) { init_dev(i); } #endif buf_init(); return(OK); }
int main (int argc, char *argv[]) { int r; char **optarg; int run, nomon; unsigned drive; char *cfg; ini_sct_t *sct; cfg = NULL; run = 0; nomon = 0; pce_log_init(); pce_log_add_fp (stderr, 0, MSG_INF); par_cfg = ini_sct_new (NULL); if (par_cfg == NULL) { return (1); } ini_str_init (&par_ini_str); while (1) { r = pce_getopt (argc, argv, &optarg, opts); if (r == GETOPT_DONE) { break; } if (r < 0) { return (1); } switch (r) { case '?': print_help(); return (0); case 'V': print_version(); return (0); case 'b': par_disk_delay_valid |= 1; par_disk_delay[0] = (unsigned) strtoul (optarg[0], NULL, 0); break; case 'B': drive = strtoul (optarg[0], NULL, 0); if ((drive < 1) || (drive >= SONY_DRIVES)) { fprintf (stderr, "%s: bad drive number (%u)\n", argv[0], drive ); return (1); } drive -= 1; par_disk_delay_valid |= 1U << drive; par_disk_delay[drive] = (unsigned) strtoul (optarg[1], NULL, 0); break; case 'c': cfg = optarg[0]; break; case 'd': pce_path_set (optarg[0]); break; case 'i': if (ini_read_str (par_cfg, optarg[0])) { fprintf (stderr, "%s: error parsing ini string (%s)\n", argv[0], optarg[0] ); return (1); } break; case 'I': ini_str_add (&par_ini_str, optarg[0], "\n", NULL); break; case 'l': pce_log_add_fname (optarg[0], MSG_DEB); break; case 'p': ini_str_add (&par_ini_str, "cpu.model = \"", optarg[0], "\"\n" ); break; case 'q': pce_log_set_level (stderr, MSG_ERR); break; case 'r': run = 1; break; case 'R': nomon = 1; break; case 's': ini_str_add (&par_ini_str, "cpu.speed = ", optarg[0], "\n" ); break; case 't': par_terminal = optarg[0]; break; case 'v': pce_log_set_level (stderr, MSG_DEB); break; case 0: fprintf (stderr, "%s: unknown option (%s)\n", argv[0], optarg[0] ); return (1); default: return (1); } } mac_log_banner(); if (pce_load_config (par_cfg, cfg)) { return (1); } sct = ini_next_sct (par_cfg, NULL, "macplus"); if (sct == NULL) { sct = par_cfg; } if (ini_str_eval (&par_ini_str, sct, 1)) { return (1); } atexit (mac_atexit); #ifdef PCE_ENABLE_SDL SDL_Init (0); #endif pce_path_ini (sct); signal (SIGINT, &sig_int); signal (SIGSEGV, &sig_segv); signal (SIGTERM, &sig_term); pce_console_init (stdin, stdout); par_sim = mac_new (sct); mon_init (&par_mon); mon_set_cmd_fct (&par_mon, mac_cmd, par_sim); mon_set_msg_fct (&par_mon, mac_set_msg, par_sim); mon_set_get_mem_fct (&par_mon, par_sim->mem, mem_get_uint8); mon_set_set_mem_fct (&par_mon, par_sim->mem, mem_set_uint8); mon_set_memory_mode (&par_mon, 0); cmd_init (par_sim, cmd_get_sym, cmd_set_sym); mac_cmd_init (par_sim, &par_mon); mac_reset (par_sim); if (nomon) { while (par_sim->brk != PCE_BRK_ABORT) { mac_run (par_sim); } } else if (run) { mac_run (par_sim); if (par_sim->brk != PCE_BRK_ABORT) { pce_puts ("\n"); } } else { pce_puts ("type 'h' for help\n"); } if (par_sim->brk != PCE_BRK_ABORT) { mon_run (&par_mon); } mac_del (par_sim); #ifdef PCE_ENABLE_SDL SDL_Quit(); #endif mon_free (&par_mon); pce_console_done(); pce_log_done(); return (0); }