int init_syscall_trace() { fprintf(stderr, "Init syscall trace\n"); if(init_syscalls(ANDROID_SYSCALL_NUM, android_syscalls, ANDROID_SYSCALL_HEADER, ANDROID_SYSCALL_PARAM_HEADER)) return -1; syscall_initialized = 1; return 0; }
void kmain(uint32_t magic, multiboot_info_t *mboot, uintptr_t ebp) { monitor_clear(); printf("Booting Dionysus!\n"); ASSERT(magic == MULTIBOOT_BOOTLOADER_MAGIC && "Not booted with multiboot."); ASSERT(mboot->flags & MULTIBOOT_INFO_MEMORY && "No memory info."); ASSERT(mboot->flags & MULTIBOOT_INFO_MEM_MAP && "No memory map."); printf("Initializing GDT\n"); init_gdt(); printf("Initializing IDT\n"); init_idt(); // Check for modules if (mboot->flags & MULTIBOOT_INFO_MODS && mboot->mods_count) { multiboot_module_t *mods = (multiboot_module_t *)mboot->mods_addr; placement_address = mods[mboot->mods_count - 1].mod_end + KERNEL_BASE; } printf("Setting up paging\n"); init_paging(mboot->mem_lower + mboot->mem_upper, mboot->mmap_addr, mboot->mmap_length); printf("Initializing timers\n"); init_time(); init_timer(); printf("Starting task scheduling\n"); init_tasking(ebp); init_syscalls(); printf("Initializing vfs\n"); init_vfs(); printf("Initializing driver subsystem\n"); init_blockdev(); init_chardev(); init_term(); printf("Enumerating PCI bus(ses)\n"); init_pci(); dump_pci(); init_devfs(); ASSERT(mount(NULL, "/dev", "devfs", 0) == 0); init_ide(); halt(); }
/* This is the C kernel entry point */ void kmain(struct multiboot *mboot_header, addr_t initial_stack) { /* Store passed values, and initiate some early things * We want serial log output as early as possible */ kernel_state_flags=0; mtboot = mboot_header; i_stack = initial_stack; parse_kernel_elf(mboot_header, &kernel_elf); #if CONFIG_MODULES init_kernel_symbols(); #endif init_serial(); console_init_stage1(); load_tables(); puts("~ SeaOS Version "); char ver[32]; get_kernel_version(ver); puts(ver); puts(" Booting Up ~\n\r"); #if CONFIG_MODULES init_module_system(); #endif init_syscalls(); load_initrd(mtboot); install_timer(1000); pm_init(placement, mtboot); init_main_cpu_1(); /* Now get the management stuff going */ printk(1, "[kernel]: Starting system management\n"); init_memory(mtboot); init_main_cpu_2(); console_init_stage2(); parse_kernel_cmd((char *)(addr_t)mtboot->cmdline); init_multitasking(); init_cache(); init_dm(); init_vfs(); /* Load the rest... */ process_initrd(); init_kern_task(); get_timed(&kernel_start_time); printk(KERN_MILE, "[kernel]: Kernel is setup (%2.2d:%2.2d:%2.2d, %s, kv=%d, ts=%d bytes: ok)\n", kernel_start_time.tm_hour, kernel_start_time.tm_min, kernel_start_time.tm_sec, kernel_name, KVERSION, sizeof(task_t)); assert(!set_int(1)); if(!fork()) init(); sys_setsid(); enter_system(255); kernel_idle_task(); }
void kernel_main(void) { output_clear_screen(); kprint("Starting main kernel init\n"); init_syscalls(); init_exceptions(); init_irqs(); enable_nmi(); sti(); kprintf("printf() call test\n%d %s %X %p", 42, "Hello", 0xFF, IDT); for(;;); // <-- runs up to here without problems /* This is an old KupOS functionality ;) */ /*clear_buf(); clear_screen(); puts("Kupec Operation System (KupOS)\nBeta-version 0.1\n"); void* buffer = alloc_page(); while (1) { puts("-> "); read_string((char**)(&buffer)); putenter(); perform(); }*/ }
bool judge(const char *input_file, const char *output_file_std, const char *stdout_file_executive, const char *stderr_file_executive) { rusage rused{}; pid_t executor = fork(); // create a child process for executor if (executor < 0) { FM_LOG_FATAL("fork executor failed: %s", strerror(errno)); exit(EXIT_PRE_JUDGE); } else if (executor == 0) { // child process log_add_info("executor"); off_t fsize = file_size(output_file_std); // io redirect, must before set_security_option() io_redirect(input_file, stdout_file_executive, stderr_file_executive); // chroot & setuid set_security_option(); // set memory, time and file size limit etc. set_limit(fsize); // must after set_security_option() FM_LOG_DEBUG("time limit: %d, time limit addtion: %d", oj_solution.time_limit, time_limit_addtion); uint64_t real_time_limit = oj_solution.time_limit + time_limit_addtion; // time fix // set real time alarm if (EXIT_SUCCESS != malarm(ITIMER_REAL, real_time_limit)) { FM_LOG_FATAL("malarm for executor failed: %s", strerror(errno)); exit(EXIT_PRE_JUDGE); } FM_LOG_TRACE("begin execute"); if (ptrace(PTRACE_TRACEME, 0, NULL, NULL) < 0) { FM_LOG_FATAL("Trace executor failed: %s", strerror(errno)); exit(EXIT_PRE_JUDGE_PTRACE); } // load program if (oj_solution.lang == LANG_JAVA) { print_executor(EXEC_J); execvp(EXEC_J[0], (char *const *) EXEC_J); } else if (oj_solution.lang == LANG_KOTLIN) { print_executor(EXEC_KT); execvp(EXEC_KT[0], (char *const *) EXEC_KT); } else if (oj_solution.lang == LANG_PYTHON27) { print_executor(EXEC_PY27); #ifdef FAST_JUDGE execvp(EXEC_PY27[0], (char * const *) EXEC_PY27); #else execv(EXEC_PY27[0], (char *const *) EXEC_PY27); #endif } else if (oj_solution.lang == LANG_PYTHON3) { print_executor(EXEC_PY3); #ifdef FAST_JUDGE execvp(EXEC_PY3[0], (char * const *) EXEC_PY3); #else execv(EXEC_PY3[0], (char *const *) EXEC_PY3); #endif } else { execl("./Main", "./Main", NULL); } // exec error FM_LOG_FATAL("exec error"); exit(EXIT_PRE_JUDGE_EXECLP); } else { // Judger int status = 0; user_regs_struct regs{}; stderr = freopen("error.txt", "a+", stderr); init_syscalls(oj_solution.lang); while (true) { if (wait4(executor, &status, 0, &rused) < 0) { FM_LOG_FATAL("wait4 executor failed: %s", strerror(errno)); kill(executor, SIGKILL); exit(EXIT_JUDGE); } if (WIFEXITED(status)) { if ((oj_solution.lang != LANG_JAVA && oj_solution.lang != LANG_KOTLIN) || WEXITSTATUS(status) == EXIT_SUCCESS) { // AC PE WA FM_LOG_TRACE("normal quit"); int result; if (oj_solution.spj) { // use SPJ result = oj_compare_output_spj(input_file, output_file_std, stdout_file_executive, oj_solution.spj_exe_file); } else { // compare file result = oj_compare_output(output_file_std, stdout_file_executive); } // WA if (result == OJ_WA) { oj_solution.result = OJ_WA; } else if (oj_solution.result != OJ_PE) { // previous case is AC oj_solution.result = result; // AC or PE } else /* (oj_solution.result == OJ_PE) */ { // previous case is PE oj_solution.result = OJ_PE; } FM_LOG_NOTICE("case result: %d, problem result: %d", result, oj_solution.result); } else { // not return 0 oj_solution.result = OJ_RE; FM_LOG_NOTICE("abnormal quit, exit_code: %d", WEXITSTATUS(status)); } break; } // RE/TLE/OLE if (WIFSIGNALED(status) || (WIFSTOPPED(status) && WSTOPSIG(status) != SIGTRAP)) { int signo = 0; if (WIFSIGNALED(status)) { signo = WTERMSIG(status); FM_LOG_NOTICE("child process killed by signal %d, %s", signo, strsignal(signo)); } else { signo = WSTOPSIG(status); FM_LOG_NOTICE("child process stopped by signal %d, %s", signo, strsignal(signo)); } switch (signo) { // Ignore case SIGCHLD: oj_solution.result = OJ_AC; break; // TLE case SIGALRM: // alarm() and setitimer(ITIMER_REAL) case SIGVTALRM: // setitimer(ITIMER_VIRTUAL) case SIGXCPU: // exceeds soft processor limit oj_solution.result = OJ_TLE; FM_LOG_TRACE("Time Limit Exceeded: %s", strsignal(signo)); break; // OLE case SIGXFSZ: // exceeds file size limit oj_solution.result = OJ_OLE; FM_LOG_TRACE("Output Limit Exceeded"); break; // RE case SIGSEGV: // segmentation violation case SIGFPE: // any arithmetic exception case SIGBUS: // the process incurs a hardware fault case SIGABRT: // abort() function case SIGKILL: // exceeds hard processor limit default: oj_solution.result = OJ_RE; FILE *fp = fopen(stderr_file_executive, "a+"); if (fp == nullptr) { fprintf(stderr, "%s\n", strsignal(signo)); FM_LOG_WARNING("Runtime Error: %s", strsignal(signo)); } else { fprintf(fp, "%s\n", strsignal(signo)); fclose(fp); } break; } // end of swtich kill(executor, SIGKILL); break; } // end of "if (WIFSIGNALED(status) ...)" oj_solution.memory_usage = std::max(oj_solution.memory_usage, (unsigned long) rused.ru_maxrss); // TODO(power): check why memory exceed too much if (oj_solution.memory_usage > oj_solution.memory_limit) { oj_solution.result = OJ_MLE; kill(executor, SIGKILL); break; } // check syscall if (ptrace(PTRACE_GETREGS, executor, NULL, ®s) < 0) { FM_LOG_FATAL("ptrace(PTRACE_GETREGS) failed: %s", strerror(errno)); kill(executor, SIGKILL); exit(EXIT_JUDGE); } int syscall_id = 0; #ifdef __i386__ syscall_id = (int)regs.orig_eax; #else syscall_id = (int) regs.orig_rax; #endif if (syscall_id > 0 && !is_valid_syscall(syscall_id)) { oj_solution.result = OJ_RF; FM_LOG_FATAL("restricted function, syscall_id: %d", syscall_id); kill(executor, SIGKILL); break; } if (ptrace(PTRACE_SYSCALL, executor, NULL, NULL) < 0) { FM_LOG_FATAL("ptrace(PTRACE_SYSCALL) failed: %s", strerror(errno)); kill(executor, SIGKILL); exit(EXIT_JUDGE); } } // end of while } // end of fork for judge process oj_solution.memory_usage = std::max(oj_solution.memory_usage, (unsigned long) rused.ru_maxrss); if (oj_solution.memory_usage > oj_solution.memory_limit) { oj_solution.result = OJ_MLE; FM_LOG_NOTICE("memory limit exceeded: %d (fault: %d * %d)", oj_solution.memory_usage, rused.ru_minflt, page_size); } oj_solution.time_usage = std::max(oj_solution.time_usage, (unsigned long) rused.ru_utime.tv_sec * 1000 + rused.ru_utime.tv_usec / 1000); if (oj_solution.time_usage > oj_solution.time_limit) { oj_solution.result = OJ_TLE; FM_LOG_TRACE("Time Limit Exceeded"); } if (oj_solution.result != OJ_AC) { if (oj_solution.judge_type == ACM) { FM_LOG_NOTICE("not AC/PE, no need to continue"); } if (oj_solution.result == OJ_TLE) { oj_solution.time_usage = oj_solution.time_limit; } else if (oj_solution.result == OJ_WA) { if (oj_solution.lang == LANG_JAVA) { // TODO: kotlin fix_java_result(stdout_file_executive, stderr_file_executive); } else if ((oj_solution.lang == LANG_PYTHON27 || oj_solution.lang == LANG_PYTHON3) && file_size(stderr_file_executive)) { oj_solution.result = OJ_RE; FM_LOG_TRACE("Runtime Error"); } } return false; } return true; }
int main(int argc, char* argv[]) { int ret = EXIT_SUCCESS; int childstatus; pid_t pid; const char taskname[13]="trinity-main"; outputstd("Trinity " VERSION " Dave Jones <*****@*****.**>\n"); progname = argv[0]; initpid = getpid(); page_size = getpagesize(); num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN); max_children = num_online_cpus; /* possibly overridden in params. */ if (init_random() == FALSE) exit(EXIT_FAILURE); set_seed(0); select_syscall_tables(); create_shm(); /* We do this before the parse_args because --fds will need to * operate on it when implemented. */ setup_fd_providers(); parse_args(argc, argv); init_uids(); change_tmp_dir(); init_logging(); init_shm(); kernel_taint_initial = check_tainted(); if (kernel_taint_initial != 0) output(0, "Kernel was tainted on startup. Will ignore flags that are already set.\n"); if (munge_tables() == FALSE) { ret = EXIT_FAILURE; goto out; } if (show_syscall_list == TRUE) { dump_syscall_tables(); goto out; } init_syscalls(); if (show_ioctl_list == TRUE) { dump_ioctls(); goto out; } do_uid0_check(); if (do_specific_domain == TRUE) find_specific_domain(specific_domain_optarg); setup_initial_mappings(); parse_devices(); pids_init(); setup_main_signals(); /* check if we ctrl'c or something went wrong during init. */ if (shm->exit_reason != STILL_RUNNING) goto cleanup_fds; init_watchdog(); /* do an extra fork so that the watchdog and the children don't share a common parent */ fflush(stdout); pid = fork(); if (pid == 0) { shm->mainpid = getpid(); setup_main_signals(); no_bind_to_cpu = RAND_BOOL(); output(0, "Main thread is alive.\n"); prctl(PR_SET_NAME, (unsigned long) &taskname); set_seed(0); if (open_fds() == FALSE) { if (shm->exit_reason != STILL_RUNNING) panic(EXIT_FD_INIT_FAILURE); // FIXME: Later, push this down to multiple EXIT's. exit_main_fail(); } if (dropprivs == TRUE) //FIXME: Push down into child processes later. drop_privs(); main_loop(); shm->mainpid = 0; _exit(EXIT_SUCCESS); } /* wait for main loop process to exit. */ (void)waitpid(pid, &childstatus, 0); /* wait for watchdog to exit. */ waitpid(watchdog_pid, &childstatus, 0); output(0, "Ran %ld syscalls. Successes: %ld Failures: %ld\n", shm->stats.total_syscalls_done - 1, shm->stats.successes, shm->stats.failures); cleanup_fds: close_sockets(); destroy_initial_mappings(); shutdown_logging(); ret = set_exit_code(shm->exit_reason); out: exit(ret); }
int main() { // Initialize system. init_syscalls(); // Set up the LED ports. vtInitLED(); // Set up hardware. setupHardware(); // Buffer for events messages. char eventsMsg[QUEUE_BUF_LEN_LCD]; // LCD task. startTaskLCD(&dataLCD, LCD_TASK_PRIORITY); startTimerLCD(&dataLCD); // Debug - initialize base. sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, "Initializing system", portMAX_DELAY); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, "Initializing LEDs", portMAX_DELAY); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, "Initializing hardware", portMAX_DELAY); sprintf(eventsMsg, "Starting %s", taskNameLCD); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); sprintf(eventsMsg, "Starting %s", timerNameLCD); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); // I2C task. sprintf(eventsMsg, "Starting %s", taskNameI2C); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); if(vtI2CInit(&vtI2C0, 0, MONITOR_TASK_PRIORITY, I2C_BITRATE) != vtI2CInitSuccess) { sprintf(eventsMsg, "Unable to create queue for %s", taskNameI2C); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); VT_HANDLE_FATAL_ERROR(0); } // Command task. sprintf(eventsMsg, "Starting %s", taskNameCommand); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); startTaskCommand(&dataCommand, COMMAND_TASK_PRIORITY, &vtI2C0, &dataLCD); sprintf(eventsMsg, "Starting %s", timerNameCommand); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); startTimerCommand(&dataCommand); // Locate task. sprintf(eventsMsg, "Starting %s", taskNameLocate); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); startTaskLocate(&dataLocate, SENSOR_TASK_PRIORITY, &dataLCD, &dataCommand); sprintf(eventsMsg, "Starting %s", timerNameLocate); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); startTimerLocate(&dataLocate); // Sensors task. sprintf(eventsMsg, "Starting %s", taskNameSensors); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); startTaskSensors(&dataSensors, SENSOR_TASK_PRIORITY, &vtI2C0, &dataLCD, &dataLocate); sprintf(eventsMsg, "Starting %s", timerNameSensors); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); startTimerSensors(&dataSensors); // Conductor task. sprintf(eventsMsg, "Starting %s", taskNameConductor); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); startTaskConductor(&dataConductor, CONDUCTOR_TASK_PRIORITY, &vtI2C0, &dataLCD, &dataSensors, &dataLocate); // Schedlar task. sprintf(eventsMsg, "Starting %s", taskNameScheduler); sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY); vTaskStartScheduler(); // Shouldn't reach this part unless insufficient memory. for(;;); }
int main(int ac, char **av) { struct sigaction sa; struct trussinfo *trussinfo; char *fname; char **command; pid_t pid; int c; fname = NULL; /* Initialize the trussinfo struct */ trussinfo = (struct trussinfo *)calloc(1, sizeof(struct trussinfo)); if (trussinfo == NULL) errx(1, "calloc() failed"); pid = 0; trussinfo->outfile = stderr; trussinfo->strsize = 32; trussinfo->curthread = NULL; LIST_INIT(&trussinfo->proclist); init_syscalls(); while ((c = getopt(ac, av, "p:o:facedDs:SH")) != -1) { switch (c) { case 'p': /* specified pid */ pid = atoi(optarg); /* make sure i don't trace me */ if (pid == getpid()) { errx(2, "attempt to grab self."); } break; case 'f': /* Follow fork()'s */ trussinfo->flags |= FOLLOWFORKS; break; case 'a': /* Print execve() argument strings. */ trussinfo->flags |= EXECVEARGS; break; case 'c': /* Count number of system calls and time. */ trussinfo->flags |= (COUNTONLY | NOSIGS); break; case 'e': /* Print execve() environment strings. */ trussinfo->flags |= EXECVEENVS; break; case 'd': /* Absolute timestamps */ trussinfo->flags |= ABSOLUTETIMESTAMPS; break; case 'D': /* Relative timestamps */ trussinfo->flags |= RELATIVETIMESTAMPS; break; case 'o': /* Specified output file */ fname = optarg; break; case 's': /* Specified string size */ trussinfo->strsize = atoi(optarg); break; case 'S': /* Don't trace signals */ trussinfo->flags |= NOSIGS; break; case 'H': trussinfo->flags |= DISPLAYTIDS; break; default: usage(); } } ac -= optind; av += optind; if ((pid == 0 && ac == 0) || (pid != 0 && ac != 0)) usage(); if (fname != NULL) { /* Use output file */ /* * Set close-on-exec ('e'), so that the output file is not * shared with the traced process. */ if ((trussinfo->outfile = fopen(fname, "we")) == NULL) err(1, "cannot open %s", fname); } /* * If truss starts the process itself, it will ignore some signals -- * they should be passed off to the process, which may or may not * exit. If, however, we are examining an already-running process, * then we restore the event mask on these same signals. */ if (pid == 0) { /* Start a command ourselves */ command = av; setup_and_wait(trussinfo, command); signal(SIGINT, SIG_IGN); signal(SIGTERM, SIG_IGN); signal(SIGQUIT, SIG_IGN); } else { sa.sa_handler = restore_proc; sa.sa_flags = 0; sigemptyset(&sa.sa_mask); sigaction(SIGINT, &sa, NULL); sigaction(SIGQUIT, &sa, NULL); sigaction(SIGTERM, &sa, NULL); start_tracing(trussinfo, pid); } /* * At this point, if we started the process, it is stopped waiting to * be woken up, either in exit() or in execve(). */ if (LIST_FIRST(&trussinfo->proclist)->abi == NULL) { /* * If we are not able to handle this ABI, detach from the * process and exit. If we just created a new process to * run a command, kill the new process rather than letting * it run untraced. */ if (pid == 0) kill(LIST_FIRST(&trussinfo->proclist)->pid, SIGKILL); ptrace(PT_DETACH, LIST_FIRST(&trussinfo->proclist)->pid, NULL, 0); return (1); } ptrace(PT_SYSCALL, LIST_FIRST(&trussinfo->proclist)->pid, (caddr_t)1, 0); /* * At this point, it's a simple loop, waiting for the process to * stop, finding out why, printing out why, and then continuing it. * All of the grunt work is done in the support routines. */ clock_gettime(CLOCK_REALTIME, &trussinfo->start_time); eventloop(trussinfo); if (trussinfo->flags & COUNTONLY) print_summary(trussinfo); fflush(trussinfo->outfile); return (0); }
int main(int argc, char* argv[]) { int ret = EXIT_SUCCESS; int childstatus; unsigned int i; outputstd("Trinity v" __stringify(VERSION) " Dave Jones <*****@*****.**>\n"); progname = argv[0]; initpid = getpid(); page_size = getpagesize(); num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN); select_syscall_tables(); if (create_shm()) exit(EXIT_FAILURE); parse_args(argc, argv); outputstd("Done parsing arguments.\n"); if (kernel_taint_mask != (int)0xFFFFFFFF) { outputstd("Custom kernel taint mask has been specified: 0x%08x (%d).\n", kernel_taint_mask, kernel_taint_mask); } if (user_specified_children != 0) max_children = user_specified_children; else max_children = sysconf(_SC_NPROCESSORS_ONLN); if (max_children > MAX_NR_CHILDREN) { outputerr("Increase MAX_NR_CHILDREN!\n"); exit(EXIT_FAILURE); } setup_shm_postargs(); if (logging == TRUE) open_logfiles(); if (munge_tables() == FALSE) { ret = EXIT_FAILURE; goto out; } if (show_syscall_list == TRUE) { dump_syscall_tables(); goto out; } init_syscalls(); if (show_ioctl_list == TRUE) { dump_ioctls(); goto out; } if (getuid() == 0) { if (dangerous == TRUE) { outputstd("DANGER: RUNNING AS ROOT.\n"); outputstd("Unless you are running in a virtual machine, this could cause serious problems such as overwriting CMOS\n"); outputstd("or similar which could potentially make this machine unbootable without a firmware reset.\n\n"); outputstd("ctrl-c now unless you really know what you are doing.\n"); for (i = 10; i > 0; i--) { outputstd("Continuing in %d seconds.\r", i); (void)fflush(stdout); sleep(1); } } else { outputstd("Don't run as root (or pass --dangerous if you know what you are doing).\n"); exit(EXIT_FAILURE); } } if (do_specific_proto == TRUE) find_specific_proto(specific_proto_optarg); init_buffers(); parse_devices(); pids_init(); setup_main_signals(); kernel_taint_initial = check_tainted(); if (kernel_taint_initial != 0) { output(0, "Kernel was tainted on startup. Will ignore flags that are already set.\n"); } change_tmp_dir(); /* check if we ctrl'c or something went wrong during init. */ if (shm->exit_reason != STILL_RUNNING) goto cleanup_fds; init_watchdog(); do_main_loop(); /* Shutting down. */ waitpid(watchdog_pid, &childstatus, 0); output(0, "\nRan %ld syscalls. Successes: %ld Failures: %ld\n", shm->total_syscalls_done - 1, shm->successes, shm->failures); ret = EXIT_SUCCESS; cleanup_fds: close_sockets(); destroy_global_mappings(); if (logging == TRUE) close_logfiles(); out: exit(ret); }
int main( void ) { /* MTJ: initialize syscalls -- *must* be first */ // syscalls.c contains the files upon which the standard (and portable) C libraries rely init_syscalls(); // Set up the LED ports and turn them off vtInitLED(); /* Configure the hardware for use by this demo. */ prvSetupHardware(); #if USE_FREERTOS_DEMO == 1 /* Start the standard demo tasks. These are just here to exercise the kernel port and provide examples of how the FreeRTOS API can be used. */ vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartQueuePeekTasks(); vStartRecursiveMutexTasks(); vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY ); #endif #if USE_WEB_SERVER == 1 // Not a standard demo -- but also not one of mine (MTJ) /* Create the uIP task. The WEB server runs in this task. */ xTaskCreate( vuIP_Task, ( signed char * ) "uIP", mainBASIC_WEB_STACK_SIZE, ( void * ) NULL, mainUIP_TASK_PRIORITY, NULL ); #endif #if USE_MTJ_LCD == 1 // MTJ: My LCD demonstration task StartLCDTask(&vtLCDdata,mainLCD_TASK_PRIORITY); // LCD Task creates a queue to receive messages -- what it does with those messages will depend on how the task is configured (see LCDtask.c) // Here we set up a timer that will send messages to the LCD task. You don't have to have this timer for the LCD task, it is just showing // how to use a timer and how to send messages from that timer. //Commented out by Matthew Ibarra 2/2/2013 //startTimerForLCD(&vtLCDdata); #endif #if USE_MTJ_V4Temp_Sensor == 1 // MTJ: My i2cTemp demonstration task // First, start up an I2C task and associate it with the I2C0 hardware on the ARM (there are 3 I2C devices, we need this one) // See vtI2C.h & vtI2C.c for more details on this task and the API to access the task // Initialize I2C0 for I2C0 at an I2C clock speed of 100KHz if (vtI2CInit(&vtI2C0,0,mainI2CMONITOR_TASK_PRIORITY,100000) != vtI2CInitSuccess) { VT_HANDLE_FATAL_ERROR(0); } // Now, start up the task that is going to handle the temperature sensor sampling (it will talk to the I2C task and LCD task using their APIs) #if USE_MTJ_LCD == 1 vStarti2cTempTask(&tempSensorData,mainI2CTEMP_TASK_PRIORITY,&vtI2C0,&vtLCDdata); #else vStarti2cTempTask(&tempSensorData,mainI2CTEMP_TASK_PRIORITY,&vtI2C0,NULL); #endif // Here we set up a timer that will send messages to the Temperature sensing task. The timer will determine how often the sensor is sampled startTimerForTemperature(&tempSensorData); // start up a "conductor" task that will move messages around vStartConductorTask(&conductorData,mainCONDUCTOR_TASK_PRIORITY,&vtI2C0,&tempSensorData); #endif /* Create the USB task. MTJ: This routine has been modified from the original example (which is not a FreeRTOS standard demo) */ #if USE_MTJ_USE_USB == 1 initUSB(); // MTJ: This is my routine used to make sure we can do printf() with USB xTaskCreate( vUSBTask, ( signed char * ) "USB", configMINIMAL_STACK_SIZE, ( void * ) NULL, mainUSB_TASK_PRIORITY, NULL ); #endif /* Start the scheduler. */ // IMPORTANT: Once you start the scheduler, any variables on the stack from main (local variables in main) can be (will be...) written over // because the stack is used by the interrupt handler vTaskStartScheduler(); /* Will only get here if there was insufficient memory to create the idle task. The idle task is created within vTaskStartScheduler(). */ for( ;; ); }
int main( void ) { /* MTJ: initialize syscalls -- *must* be first */ // syscalls.c contains the files upon which the standard (and portable) C libraries rely init_syscalls(); // Set up the LED ports and turn them off vtInitLED(); /* Configure the hardware for use by this demo. */ prvSetupHardware(); #if USE_FREERTOS_DEMO == 1 /* Start the standard demo tasks. These are just here to exercise the kernel port and provide examples of how the FreeRTOS API can be used. */ vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartQueuePeekTasks(); vStartRecursiveMutexTasks(); vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY ); #endif // Not a standard demo -- but also not one of mine (MTJ) /* Create the uIP task. The WEB server runs in this task. */ xTaskCreate( vuIP_Task, ( signed char * ) "uIP", mainBASIC_WEB_STACK_SIZE, ( void * ) NULL, mainUIP_TASK_PRIORITY, NULL ); // MTJ: My LCD demonstration task #if USE_MTJ_LCD == 1 vStartLCDTask( mainLCD_TASK_PRIORITY,&vtLCDdata); #endif // MTJ: My i2cTemp demonstration task #if USE_MTJ_V4Temp_Sensor == 1 vtI2C0.devNum = 0; vtI2C0.taskPriority = mainI2CMONITOR_TASK_PRIORITY; // Initialize I2C0 int retVal; if ((retVal = vtI2CInit(&vtI2C0,100000)) != vtI2CInitSuccess) { VT_HANDLE_FATAL_ERROR(retVal); } tempSensorParams.dev = &vtI2C0; #if USE_MTJ_LCD == 1 tempSensorParams.lcdData = &vtLCDdata; #else tempSensorParams.lcdData = NULL; #endif //vStarti2cTempTask(mainI2CTEMP_TASK_PRIORITY,&tempSensorParams); vStartSomeTask(mainI2CTEMP_TASK_PRIORITY, &tempSensorParams); #endif /* Create the USB task. MTJ: This routine has been modified from the original example (which is not a FreeRTOS standard demo) */ #if USE_MTJ_USE_USB == 1 initUSB(); // MTJ: This is my routine used to make sure we can do printf() with USB xTaskCreate( vUSBTask, ( signed char * ) "USB", configMINIMAL_STACK_SIZE, ( void * ) NULL, mainUSB_TASK_PRIORITY, NULL ); #endif /* Start the scheduler. */ // IMPORTANT: Once you start the scheduler, any variables on the stack from main (local variables in main) can be (will be...) writtenover // because the stack is used by the interrupt handler vTaskStartScheduler(); /* Will only get here if there was insufficient memory to create the idle task. The idle task is created within vTaskStartScheduler(). */ for( ;; ); }
int main( void ) { /* MTJ: initialize syscalls -- *must* be first */ // syscalls.c contains the files upon which the standard (and portable) C libraries rely init_syscalls(); // Set up the LED ports and turn them off vtInitLED(); /* Configure the hardware for use by this demo. */ prvSetupHardware(); #if USE_WEB_SERVER == 1 // Not a standard demo -- but also not one of mine (MTJ) /* Create the uIP task. The WEB server runs in this task. */ xTaskCreate( vuIP_Task, ( signed char * ) "uIP", mainBASIC_WEB_STACK_SIZE, ( void * ) NULL, mainUIP_TASK_PRIORITY, NULL ); #endif vStartLCDTask(&vtLCDdata,mainLCD_TASK_PRIORITY); // LCD Task creates a queue to receive messages -- what it does with those messages will depend on how the task is configured (see LCDtask.c) // Here we set up a timer that will send messages to the LCD task. You don't have to have this timer for the LCD task, it is just showing // how to use a timer and how to send messages from that timer. // First, start up an I2C task and associate it with the I2C0 hardware on the ARM (there are 3 I2C devices, we need this one) // See vtI2C.h & vtI2C.c for more details on this task and the API to access the task // Initialize I2C0 for I2C0 at an I2C clock speed of 100KHz if (vtI2CInit(&vtI2C0,0,mainI2CMONITOR_TASK_PRIORITY,100000) != vtI2CInitSuccess) { VT_HANDLE_FATAL_ERROR(0); } // start up a "conductor" task that will move messages around vStartConductorTask(&conductorData,mainCONDUCTOR_TASK_PRIORITY,&vtI2C0,&i2cData,&motorControl,&irData,&speedData,&powerData,&vtLCDdata); // Start the I2C task starti2cTask(&i2cData,mainI2C_TASK_PRIORITY,&vtI2C0); // Start the Motor Control task vStartMotorControlTask(&motorControl,mainMOTOR_CONTROL_TASK_PRIORITY,&i2cData,&webData,&vtLCDdata); // Start the Navigation task vStartNavigationTask(&navData,mainNAVIGATION_TASK_PRIORITY,&motorControl,&vtLCDdata); // Start the IR Control task vStartIRTask(&irData,mainIR_CONTROL_TASK_PRIORITY,&navData); // Start the Speed Limit task vStartSpeedLimitTask(&speedData,mainSPEED_LIMIT_TASK_PRIORITY,&motorControl,&navData,&webData); startTimerFori2c(&i2cData); //startTimerForMotor(&motorControl); /* Create the USB task. MTJ: This routine has been modified from the original example (which is not a FreeRTOS standard demo) */ #if USE_MTJ_USE_USB == 1 initUSB(); // MTJ: This is my routine used to make sure we can do printf() with USB xTaskCreate( vUSBTask, ( signed char * ) "USB", configMINIMAL_STACK_SIZE, ( void * ) NULL, mainUSB_TASK_PRIORITY, NULL ); #endif /* Start the scheduler. */ // IMPORTANT: Once you start the scheduler, any variables on the stack from main (local variables in main) can be (will be...) written over // because the stack is used by the interrupt handler vTaskStartScheduler(); /* Will only get here if there was insufficient memory to create the idle task. The idle task is created within vTaskStartScheduler(). */ for( ;; ); }
int main(int argc, char* argv[]) { int ret = EXIT_SUCCESS; const char taskname[13]="trinity-main"; outputstd("Trinity " VERSION " Dave Jones <*****@*****.**>\n"); progname = argv[0]; mainpid = getpid(); page_size = getpagesize(); num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN); max_children = num_online_cpus; /* possibly overridden in params. */ if (init_random() == FALSE) exit(EXIT_FAILURE); select_syscall_tables(); create_shm(); /* We do this before the parse_args because --fds will need to * operate on the providers list when implemented. */ setup_fd_providers(); parse_args(argc, argv); init_uids(); change_tmp_dir(); init_logging(); init_shm(); kernel_taint_initial = check_tainted(); if (kernel_taint_initial != 0) output(0, "Kernel was tainted on startup. Will ignore flags that are already set.\n"); if (munge_tables() == FALSE) { ret = EXIT_FAILURE; goto out; } if (show_syscall_list == TRUE) { dump_syscall_tables(); goto out; } if (show_ioctl_list == TRUE) { dump_ioctls(); goto out; } if (show_unannotated == TRUE) { show_unannotated_args(); goto out; } init_syscalls(); do_uid0_check(); if (do_specific_domain == TRUE) find_specific_domain(specific_domain_optarg); pids_init(); init_object_lists(OBJ_GLOBAL); setup_initial_mappings(); parse_devices(); /* FIXME: Some better object construction method needed. */ create_futexes(); create_sysv_shms(); setup_main_signals(); no_bind_to_cpu = RAND_BOOL(); prctl(PR_SET_NAME, (unsigned long) &taskname); if (open_fds() == FALSE) { if (shm->exit_reason != STILL_RUNNING) panic(EXIT_FD_INIT_FAILURE); // FIXME: Later, push this down to multiple EXIT's. _exit(EXIT_FAILURE); } if (dropprivs == TRUE) //FIXME: Push down into child processes later. drop_privs(); main_loop(); destroy_global_objects(); output(0, "Ran %ld syscalls. Successes: %ld Failures: %ld\n", shm->stats.total_syscalls_done - 1, shm->stats.successes, shm->stats.failures); shutdown_logging(); ret = set_exit_code(shm->exit_reason); out: exit(ret); }