int hvm_mmio_intercept(ioreq_t *p) { struct vcpu *v = current; int i; for ( i = 0; i < HVM_MMIO_HANDLER_NR; i++ ) { hvm_mmio_check_t check_handler = hvm_mmio_handlers[i]->check_handler; if ( check_handler(v, p->addr) ) { if ( unlikely(p->count > 1) && !check_handler(v, unlikely(p->df) ? p->addr - (p->count - 1L) * p->size : p->addr + (p->count - 1L) * p->size) ) p->count = 1; return hvm_mmio_access( v, p, hvm_mmio_handlers[i]->read_handler, hvm_mmio_handlers[i]->write_handler); } } return X86EMUL_UNHANDLEABLE; }
/** * Forks and runs the given application, waits for a maximum of timeout seconds for process to finish. * * @param argv The arguments values, the first one is the application path or name */ void bb_run_fork_wait(char** argv, int timeout) { check_handler(); // Fork and attempt to run given application pid_t ret = fork(); if (ret == 0) { // Fork went ok, child process replace bb_run_exec(argv); } else { if (ret > 0) { // Fork went ok, parent process continues bb_log(LOG_DEBUG, "Process %s started, PID %i.\n", argv[0], ret); pidlist_add(ret); //sleep until process finishes or timeout reached int i = 0; while (bb_is_running(ret) && ((i < timeout) || (timeout == 0)) && dowait) { usleep(1000000); i++; } //make a single attempt to kill the process if timed out, without waiting if (bb_is_running(ret)) { bb_stop(ret); } } else { // Fork failed bb_log(LOG_ERR, "Process %s could not be started. fork() failed.\n", argv[0]); return; } } return; }
void instruction_count::start() { m_count = 0; #ifdef _WINDOWS check_handler(); QTCP_proc(GetCurrentThread(), &m_count); #endif }
int main(void) { int32_t res; int r1 = install_handler(); if (r1!=0) { return r1; } if (!DidInitRun()) { fprintf(stderr, "ERROR: buildmode=c-archive init should run\n"); return 2; } if (DidMainRun()) { fprintf(stderr, "ERROR: buildmode=c-archive should not run main\n"); return 2; } int r2 = check_handler(); if (r2!=0) { return r2; } res = FromPkg(); if (res != 1024) { fprintf(stderr, "ERROR: FromPkg()=%d, want 1024\n", res); return 2; } CheckArgs(); fprintf(stderr, "PASS\n"); return 0; }
double instruction_count::get_num_instructions() { unsigned long long current = 0; #ifdef _WINDOWS check_handler(); QTCP_proc(GetCurrentThread(), ¤t); #endif return static_cast<double>(current - m_count); }
int find_partition_2d(cloud_2d* data, specs_2d* specs, handler_2d* callback) { int return_code = code_success; if ( return_code = check_specs(specs) ) goto exit; if ( return_code = check_handler(callback) ) goto exit; double x_min, x_max, y_min, y_max; double* min_max[4] = {&x_min, &x_max, &y_min, &y_max}; if ( return_code = check_data(data, min_max) ) goto exit; treegrid_2d* grid; if ( return_code = treegrid_2d_new(&grid, NULL) ) // TODO: define necessary args goto exit; int num_cells_total = insert_all_points(grid, data); if ( num_cells_total < 0) { return_code = num_cells_total; goto clean_grid; } double *x_reduc = NULL, *y_reduc = NULL; if ( return_code = alloc_output_buffer(&x_reduc, &y_reduc, num_cells_total) ) goto clean_array; add_to_output_buffer(data, grid, x_reduc, y_reduc); void* context = callback->use_data_context; return_code = callback->use_data(context, x_reduc, y_reduc, num_cells_total); clean_array: if (x_reduc) free(x_reduc); if (y_reduc) free(y_reduc); clean_grid: return_code = treegrid_2d_clean(grid); exit: return return_code; }
/** * Forks and runs the given application, using an optional LD_LIBRARY_PATH. The * function then returns immediately. * stderr and stdout of the ran application is redirected to the parameter redirect. * stdin is redirected to /dev/null always. * * @param argv The arguments values, the first one is the program * @param ldpath The library path to be used if any (may be NULL) * @param redirect The file descriptor to redirect stdout/stderr to. Must be valid and open. * @return The childs process ID */ pid_t bb_run_fork_ld_redirect(char **argv, char *ldpath, int redirect) { check_handler(); // Fork and attempt to run given application pid_t ret = fork(); if (ret == 0) { if (ldpath && *ldpath) { char *current_path = getenv("LD_LIBRARY_PATH"); /* Fork went ok, set environment if necessary */ if (current_path) { char *ldpath_new = malloc(strlen(ldpath) + 1 + strlen(current_path) + 1); if (ldpath_new) { strcpy(ldpath_new, ldpath); strcat(ldpath_new, ":"); strcat(ldpath_new, current_path); setenv("LD_LIBRARY_PATH", ldpath_new, 1); free(ldpath_new); } else { bb_log(LOG_WARNING, "Could not allocate memory for LD_LIBRARY_PATH\n"); } } else { setenv("LD_LIBRARY_PATH", ldpath, 1); } } //open /dev/null for stdin redirect int devnull = open("/dev/null", O_RDWR); //fail silently on error, nothing we can do about it anyway... if (devnull >= 0){dup2(devnull, STDIN_FILENO);} //redirect stdout and stderr to the given filenum. dup2(redirect, STDOUT_FILENO); dup2(redirect, STDERR_FILENO); close(devnull); //ok, all ready, now actually execute bb_run_exec(argv); } else { if (ret > 0) { // Fork went ok, parent process continues bb_log(LOG_DEBUG, "Process %s started, PID %i.\n", argv[0], ret); pidlist_add(ret); } else { // Fork failed bb_log(LOG_ERR, "Process %s could not be started. fork() failed.\n", argv[0]); return 0; } } return ret; }
/** * Forks and runs the given application and waits for the process to finish * * @param argv The arguments values, the first one is the program * @param detached non-zero if the std in/output must be redirected to /dev/null, zero otherwise * @return Exit code of the program (between 0 and 255) or -1 on failure */ int bb_run_fork(char **argv, int detached) { int exitcode = -1; check_handler(); /* Fork and attempt to run given application */ pid_t pid = fork(); if (pid == 0) { /* child process after fork */ if (detached) { bb_run_exec_detached(argv); } else { bb_run_exec(argv); } } else if (pid > 0) { /* parent process after fork */ int status = 0; bb_log(LOG_DEBUG, "Process %s started, PID %i.\n", argv[0], pid); pidlist_add(pid); if (waitpid(pid, &status, 0) != -1) { if (WIFEXITED(status)) { /* program exited normally, return status */ exitcode = WEXITSTATUS(status); } else if (WIFSIGNALED(status)) { /* program was terminated by a signal */ exitcode = 128 + WTERMSIG(status); } } else { bb_log(LOG_ERR, "waitpid(%i) faild with %s\n", pid, strerror(errno)); } pidlist_remove(pid); } else { /* Fork failed */ bb_log(LOG_ERR, "Process %s could not be started. fork() failed.\n", argv[0]); } /* could not determine return value */ return exitcode; }
/** * Forks and runs the given application, using an optional LD_LIBRARY_PATH. The * function then returns immediately * * @param argv The arguments values, the first one is the program * @param ldpath The library path to be used if any (may be NULL) * @return The childs process ID */ pid_t bb_run_fork_ld(char **argv, char *ldpath) { check_handler(); // Fork and attempt to run given application pid_t ret = fork(); if (ret == 0) { if (ldpath && *ldpath) { char *current_path = getenv("LD_LIBRARY_PATH"); /* Fork went ok, set environment if necessary */ if (current_path) { char *ldpath_new = malloc(strlen(ldpath) + 1 + strlen(current_path) + 1); if (ldpath_new) { strcpy(ldpath_new, ldpath); strcat(ldpath_new, ":"); strcat(ldpath_new, current_path); setenv("LD_LIBRARY_PATH", ldpath_new, 1); free(ldpath_new); } else { bb_log(LOG_WARNING, "Could not allocate memory for LD_LIBRARY_PATH\n"); } } else { setenv("LD_LIBRARY_PATH", ldpath, 1); } } bb_run_exec(argv); } else { if (ret > 0) { // Fork went ok, parent process continues bb_log(LOG_INFO, "Process %s started, PID %i.\n", argv[0], ret); pidlist_add(ret); } else { // Fork failed bb_log(LOG_ERR, "Process %s could not be started. fork() failed.\n", argv[0]); return 0; } } return ret; }
/** * @brief load all handlers found in the ::HANDLERS_DIR * @returns 0 on success, -1 on error. */ int load_handlers() { DIR *d; struct dirent *de; handler *h; char *path, *cwd; void *handle; size_t len; len = 50; cwd = malloc(len); while(cwd && len < PATH_MAX) { if(getcwd(cwd, len)) break; if(errno != ERANGE) { print( ERROR, "getcwd: %s", strerror(errno)); free(cwd); return -1; } len += 50; cwd = realloc(cwd, len); } if(!cwd) { print( ERROR, "malloc(%d): %s", len, strerror(errno)); return -1; } d = opendir(HANDLERS_DIR); if(!d) { print( ERROR, "opendir: %s", strerror(errno) ); free(cwd); return -1; } while((de=readdir(d))) { if(!strncmp(de->d_name, ".", 2) || !strncmp(de->d_name, "..", 3)) { continue; } len = strlen(de->d_name); if(strncmp(de->d_name + (len - 3), ".so", 3)) continue; if(asprintf(&path, "%s/" HANDLERS_DIR "/%s", cwd, de->d_name) == -1) { print( ERROR, "asprintf: %s", strerror(errno) ); continue; } if(!(handle = dlopen(path, RTLD_NOW))) { print( ERROR, "dlopen: %s", dlerror() ); free(path); continue; } if(!(h = (handler *)dlsym(handle, "handler_info"))) { print( ERROR, "\"%s\": undefined reference to 'handler_info'", path ); goto close; } if(check_handler(h)) { goto close; } h->dl_handle = handle; list_add(&(handlers), (node *) h); free(path); continue; close: if(dlclose(handle)) print( ERROR, "dlclose(\"%s\"): %s", path, dlerror() ); free(path); } closedir(d); free(cwd); if(!handlers.head) { print( ERROR, "no handlers found" ); return -1; } return 0; }