/* * syscall_stat * * Implementation of the stat system call, which obtains information about a * particular file or directory. You should use this as a guideline for how to * implement the other system calls in assignment 3. */ int syscall_stat(const char *path, struct stat *buf) { /* * Ensure the supplied path name and buffer are valid pointers */ if (!valid_string(path)) return -EFAULT; if (!valid_pointer(buf, sizeof(struct stat))) return -EFAULT; /* * Get the directory_entry object for this path from the filesystem */ directory_entry *entry; int r; char abs[PATH_MAX]; relative_to_absolute(abs, current_process->cwd, path, PATH_MAX); if (0 != (r = get_directory_entry(filesystem, abs, &entry))) return r; /* * Set all fields of the stat buffer */ buf->st_mode = entry->mode; buf->st_uid = 0; buf->st_gid = 0; buf->st_size = entry->size; buf->st_mtime = entry->mtime; return 0; }
QWidget *float2_param_t::do_create_widgets() { QWidget *top = new QWidget(); QrLabel *label = new QrLabel( top); input0_ = new QrDoubleSpinBox( top); input1_ = new QrDoubleSpinBox( top); QSize s = input0_->sizeHint(); label->move( 0, 0); label->resize( ui::inspector_t::Instance().left_margin() - 5, s.height()); label->setAlignment( Qt::AlignRight | Qt::AlignVCenter); label->setText( name().c_str()); int xpos = ui::inspector_t::Instance().left_margin(); float low = absolute_min(); float high = absolute_max(); Imath::V2f v = relative_to_absolute( get_value<Imath::V2f>( *this)); input0_->move( xpos, 0); input0_->resize( s.width(), s.height()); input0_->setRange( low, high); input0_->setStep( step()); input0_->setValue( v.x); input0_->setEnabled( enabled()); connect( input0_, SIGNAL( calculatorValueChanged( double)), this, SLOT( value_changed( double))); connect( input0_, SIGNAL( spinBoxPressed()), this, SLOT( spinbox_pressed())); connect( input0_, SIGNAL( spinBoxMoved( double)), this, SLOT( spinbox_moved( double))); connect( input0_, SIGNAL( spinBoxReleased()), this, SLOT( spinbox_released())); xpos += ( s.width() + 5); input1_->move( xpos, 0); input1_->resize( s.width(), s.height()); input1_->setRange( low, high); input1_->setStep( step()); input1_->setValue( v.y); input1_->setEnabled( enabled()); connect( input1_, SIGNAL( calculatorValueChanged( double)), this, SLOT( value_changed( double))); connect( input1_, SIGNAL( spinBoxPressed()), this, SLOT( spinbox_pressed())); connect( input1_, SIGNAL( spinBoxMoved( double)), this, SLOT( spinbox_moved( double))); connect( input1_, SIGNAL( spinBoxReleased()), this, SLOT( spinbox_released())); xpos += ( s.width() + 2); if( proportional()) { create_proportional_button( top); if( prop_button_) prop_button_->move( xpos, 0); } top->setMinimumSize( ui::inspector_t::Instance().width(), s.height()); top->setMaximumSize( ui::inspector_t::Instance().width(), s.height()); top->setSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed); return top; }
void float2_param_t::do_update_widgets() { if( input0_) { input0_->blockSignals( true); input1_->blockSignals( true); Imath::V2f pair = relative_to_absolute( get_value<Imath::V2f>( *this)); input0_->setValue( pair.x); input1_->setValue( pair.y); input0_->blockSignals( false); input1_->blockSignals( false); } }
int syscall_chdir(const char *path) { if (!valid_string(path)) return -EFAULT; char newcwd[PATH_MAX]; relative_to_absolute(newcwd, current_process->cwd, path, PATH_MAX); int r; directory_entry *entry; if (0 != (r = get_directory_entry(filesystem, newcwd, &entry))) return r; if (TYPE_DIR != entry->type) return -ENOTDIR; memmove(current_process->cwd, newcwd, PATH_MAX); return 0; }
int syscall_open(const char *pathname, int flags) { if (!valid_string(pathname)) return -EFAULT; int fd = -1; for (fd = 0; fd < MAX_FDS; fd++) { if (NULL == current_process->filedesc[fd]) break; } if (MAX_FDS == fd) return -EMFILE; char abspath[PATH_MAX]; relative_to_absolute(abspath, current_process->cwd, pathname, PATH_MAX); directory_entry *entry; int r; if (0 != (r = get_directory_entry(filesystem, abspath, &entry))) return r; if ((flags == OPEN_DIRECTORY) && (entry->type != TYPE_DIR)) return -ENOTDIR; else if ((flags != OPEN_DIRECTORY) && (entry->type == TYPE_DIR)) return -EISDIR; filehandle *fh; if (TYPE_DIR == entry->type) fh = new_file(FH_DIR); else fh = new_file(FH_FILE); fh->entry = entry; fh->pos = 0; fh->entryno = 0; current_process->filedesc[fd] = fh; return fd; }
const char* PROJECT::project_dir_absolute() { if (_project_dir_absolute[0] == 0) { relative_to_absolute(project_dir(), _project_dir_absolute); } return _project_dir_absolute; }
/// Start a task in a slot directory. /// This includes setting up soft links, /// passing preferences, and starting the process. /// /// Current dir is top-level Synecdoche dir. /// /// \post /// - If any error occurs /// - #task_state is #PROCESS_COULDNT_START /// - CLIENT_STATE::report_result_error() is called /// - else /// - #task_state is #PROCESS_EXECUTING /// /// \return 0 on success, nonzero otherwise. int ACTIVE_TASK::start() { char exec_name[256], exec_path[256]; unsigned int i; FILE_REF fref; int retval; // F*** goto, need to define some variables here instead of where they are used! std::ostringstream err_stream; #ifdef _WIN32 std::string cmd_line; std::string slotdirpath; #else // Needs to be defined here because those gotos would skip the // initialization of 'cmdline' and 'argv' if it would be defined later. std::ostringstream cmdline; std::list<std::string> argv; #endif if ((!full_init_done) && (log_flags.task)) { msg_printf(wup->project, MSG_INFO, "Starting %s", result->name ); } if (log_flags.cpu_sched) { msg_printf(wup->project, MSG_INFO, "[cpu_sched] Starting %s%s", result->name, (full_init_done) ? " (resume)" : " (initial)" ); } // Always check if all required files are present. If not, trigger // re-downloads and don't start the science application. FILE_INFO_PSET missing_file_infos; retval = gstate.input_files_available(result, true, &missing_file_infos); if (retval) { for (FILE_INFO_PSET::iterator it = missing_file_infos.begin(); it != missing_file_infos.end(); ++it) { FILE_INFO* fip = *it; if (fip) { err_stream << "Input file " << fip->name << " missing or invalid: " << retval; } else { err_stream << "Input file missing or invalid"; // We can't trigger a new download if we don't have // any file information. Just fail here as before. goto error; } fip->status = FILE_NOT_PRESENT; } } if (!missing_file_infos.empty()) { // Some files are missing and are set for re-transfer. // Update status and return without error. result->set_state(RESULT_FILES_DOWNLOADING, "start"); set_task_state(PROCESS_UNINITIALIZED, "start"); next_scheduler_state = PROCESS_UNINITIALIZED; return 0; } if (!full_init_done) { checkpoint_cpu_time = 0; checkpoint_wall_time = gstate.now; } current_cpu_time = checkpoint_cpu_time; episode_start_cpu_time = checkpoint_cpu_time; debt_interval_start_cpu_time = checkpoint_cpu_time; graphics_request_queue.init(result->name); // reset message queues process_control_queue.init(result->name); if (!app_client_shm.shm) { retval = get_shmem_seg_name(); if (retval) { err_stream << "Can't get shared memory segment name: " << boincerror(retval); goto error; } } // this must go AFTER creating shmem name, // since the shmem name is part of the file // retval = write_app_init_file(); if (retval) { err_stream << "Can't write init file: " << retval; goto error; } // set up applications files // strcpy(exec_name, ""); for (i=0; i<app_version->app_files.size(); i++) { fref = app_version->app_files[i]; FILE_INFO* fip = fref.file_info; std::string file_path = get_pathname(fip); if (fref.main_program) { if (is_image_file(fip->name)) { err_stream << "Main program " << fip->name << " is an image file"; retval = ERR_NO_SIGNATURE; goto error; } if (!fip->executable && !wup->project->anonymous_platform) { err_stream << "Main program " << fip->name << " is not executable"; retval = ERR_NO_SIGNATURE; goto error; } safe_strcpy(exec_name, fip->name.c_str()); safe_strcpy(exec_path, file_path.c_str()); } // anonymous platform may use different files than // when the result was started, so link files even if not first time if ((!full_init_done) || (wup->project->anonymous_platform)) { retval = setup_file(result->project, fip, fref, file_path, slot_dir, true); if (retval) { err_stream << "Can't link input file"; goto error; } } } if (!strlen(exec_name)) { err_stream << "No main program specified"; retval = ERR_NOT_FOUND; goto error; } // set up input, output files if (!full_init_done) { for (i=0; i<wup->input_files.size(); i++) { fref = wup->input_files[i]; const FILE_INFO* fip = fref.file_info; std::string file_path = get_pathname(fref.file_info); retval = setup_file(result->project, fip, fref, file_path, slot_dir, true); if (retval) { err_stream << "Can't link input file"; goto error; } } for (i=0; i<result->output_files.size(); i++) { fref = result->output_files[i]; if (fref.copy_file) continue; const FILE_INFO* fip = fref.file_info; std::string file_path = get_pathname(fref.file_info); retval = setup_file(result->project, fip, fref, file_path, slot_dir, false); if (retval) { err_stream << "Can't link output file"; goto error; } } full_init_done = true; } link_user_files(); if (gstate.exit_before_start) { exit(0); } #ifdef _WIN32 PROCESS_INFORMATION process_info; STARTUPINFO startup_info; LPVOID environment_block = NULL; char error_msg[1024]; char error_msg2[1024]; memset(&process_info, 0, sizeof(process_info)); memset(&startup_info, 0, sizeof(startup_info)); startup_info.cb = sizeof(startup_info); // suppress 2-sec rotating hourglass cursor on startup // startup_info.dwFlags = STARTF_FORCEOFFFEEDBACK; app_client_shm.reset_msgs(); if (config.run_apps_manually) { // fill in core client's PID so we won't think app has exited pid = GetCurrentProcessId(); pid_handle = GetCurrentProcess(); set_task_state(PROCESS_EXECUTING, "start"); return 0; } // NOTE: in Windows, stderr is redirected in boinc_init_diagnostics(); cmd_line = exec_path + std::string(" ") + wup->command_line; if (strlen(app_version->cmdline)) { cmd_line += std::string(" ") + app_version->cmdline; } slotdirpath = relative_to_absolute(slot_dir); bool success = false; for (i=0; i<5; i++) { if (sandbox_account_service_token != NULL) { // Find CreateEnvironmentBlock/DestroyEnvironmentBlock pointers tCEB pCEB = NULL; tDEB pDEB = NULL; HMODULE hUserEnvLib = NULL; hUserEnvLib = LoadLibrary("userenv.dll"); if (hUserEnvLib) { pCEB = (tCEB) GetProcAddress(hUserEnvLib, "CreateEnvironmentBlock"); pDEB = (tDEB) GetProcAddress(hUserEnvLib, "DestroyEnvironmentBlock"); } if (!pCEB(&environment_block, sandbox_account_service_token, FALSE)) { if (log_flags.task) { windows_error_string(error_msg, sizeof(error_msg)); msg_printf(wup->project, MSG_INFO, "Process environment block creation failed: %s", error_msg ); } } if (CreateProcessAsUser( sandbox_account_service_token, exec_path, (LPSTR)cmd_line.c_str(), NULL, NULL, FALSE, CREATE_NEW_PROCESS_GROUP|CREATE_NO_WINDOW|IDLE_PRIORITY_CLASS|CREATE_UNICODE_ENVIRONMENT, environment_block, slotdirpath.c_str(), &startup_info, &process_info )) { success = true; break; } else { windows_error_string(error_msg, sizeof(error_msg)); msg_printf(wup->project, MSG_INTERNAL_ERROR, "Process creation failed: %s", error_msg ); } if (!pDEB(environment_block)) { if (log_flags.task) { windows_error_string(error_msg, sizeof(error_msg2)); msg_printf(wup->project, MSG_INFO, "Process environment block cleanup failed: %s", error_msg2 ); } } if (hUserEnvLib) { pCEB = NULL; pDEB = NULL; FreeLibrary(hUserEnvLib); } } else { if (CreateProcess( exec_path, (LPSTR)cmd_line.c_str(), NULL, NULL, FALSE, CREATE_NEW_PROCESS_GROUP|CREATE_NO_WINDOW|IDLE_PRIORITY_CLASS, NULL, slotdirpath.c_str(), &startup_info, &process_info )) { success = true; break; } else { windows_error_string(error_msg, sizeof(error_msg)); msg_printf(wup->project, MSG_INTERNAL_ERROR, "Process creation failed: %s", error_msg ); } } boinc_sleep(drand()); } if (!success) { err_stream << "CreateProcess() failed - " << error_msg; retval = ERR_EXEC; goto error; } pid = process_info.dwProcessId; pid_handle = process_info.hProcess; CloseHandle(process_info.hThread); // thread handle is not used #else // Unix/Linux/Mac case // Set up core/app shared memory seg if needed // if (!app_client_shm.shm) { if (app_version->api_major_version() >= 6) { // Use mmap() shared memory std::string buf = slot_dir + std::string("/") + std::string(MMAPPED_FILE_NAME); if (g_use_sandbox) { if (!boinc_file_exists(buf.c_str())) { int fd = open(buf.c_str(), O_RDWR | O_CREAT, 0660); if (fd >= 0) { close (fd); #ifdef SANDBOX set_to_project_group(buf.c_str()); #endif } } } retval = create_shmem_mmap( buf.c_str(), sizeof(SHARED_MEM), (void**)&app_client_shm.shm ); } else { // Use shmget() shared memory retval = create_shmem( shmem_seg_name, sizeof(SHARED_MEM), gstate.boinc_project_gid, (void**)&app_client_shm.shm ); if (retval) { needs_shmem = true; destroy_shmem(shmem_seg_name); return retval; } } needs_shmem = false; } app_client_shm.reset_msgs(); #if (defined (__APPLE__) && (defined(__i386__) || defined(__x86_64__))) // PowerPC apps emulated on i386 Macs crash if running graphics powerpc_emulated_on_i386 = ! is_native_i386_app(exec_path); #endif if (config.run_apps_manually) { pid = getpid(); // use the client's PID set_task_state(PROCESS_EXECUTING, "start"); return 0; } // Prepare command line for the science app: cmdline << wup->command_line; if (strlen(app_version->cmdline)) { cmdline << ' ' << app_version->cmdline; } argv = parse_command_line(cmdline.str().c_str()); if (log_flags.task_debug) { debug_print_argv(argv); } pid = fork(); if (pid == -1) { err_stream << "fork() failed: " << strerror(errno); retval = ERR_FORK; goto error; } if (pid == 0) { // from here on we're running in a new process. // If an error happens, // exit nonzero so that the core client knows there was a problem. // don't pass stdout to the app // int fd = open("/dev/null", O_RDWR); dup2(fd, STDOUT_FILENO); close(fd); // add to library path: // - the project dir (../../projects/X) // - the slot dir (.) // - the Synecdoche dir (../..) // We use relative paths in case higher-level dirs // are not readable to the account under which app runs // std::string pdir = get_project_dir(wup->project); std::ostringstream libpath; const char* env_lib_path = getenv("LD_LIBRARY_PATH"); if (env_lib_path) { libpath << env_lib_path << ':'; } libpath << "../../" << pdir << ":.:../.."; setenv("LD_LIBRARY_PATH", libpath.str().c_str(), 1); retval = chdir(slot_dir.c_str()); if (retval) { perror("chdir"); fflush(NULL); _exit(errno); } #if 0 // set stack size limit to the max. // Some BOINC apps have reported problems with exceeding // small stack limits (e.g. 8 MB) // and it seems like the best thing to raise it as high as possible // struct rlimit rlim; #define MIN_STACK_LIMIT 64000000 getrlimit(RLIMIT_STACK, &rlim); if (rlim.rlim_cur != RLIM_INFINITY && rlim.rlim_cur <= MIN_STACK_LIMIT) { if (rlim.rlim_max == RLIM_INFINITY || rlim.rlim_max > MIN_STACK_LIMIT) { rlim.rlim_cur = MIN_STACK_LIMIT; } else { rlim.rlim_cur = rlim.rlim_max; } setrlimit(RLIMIT_STACK, &rlim); } #endif // hook up stderr to a specially-named file // freopen(STDERR_FILE, "a", stderr); // set idle process priority #ifdef HAVE_SETPRIORITY if (setpriority(PRIO_PROCESS, 0, PROCESS_IDLE_PRIORITY)) { perror("setpriority"); } #endif std::string path = std::string("../../") + std::string(exec_path); if (g_use_sandbox) { std::ostringstream switcher_path; switcher_path << "../../" << SWITCHER_DIR << '/' << SWITCHER_FILE_NAME; argv.push_front(exec_name); argv.push_front(path); argv.push_front(SWITCHER_FILE_NAME); // Files written by projects have user boinc_project and group boinc_project, // so they must be world-readable so Synecdoche can read them. umask(2); retval = do_execv(switcher_path.str(), argv); } else { argv.push_front(exec_name); retval = do_execv(path, argv); } msg_printf(wup->project, MSG_INTERNAL_ERROR, "Process creation (%s) failed: %s, errno=%d\n", path.c_str(), boincerror(retval), errno ); perror("execv"); fflush(NULL); _exit(errno); } if (log_flags.task_debug) { msg_printf(wup->project, MSG_INFO, "[task_debug] ACTIVE_TASK::start(): forked process: pid %d\n", pid ); } #endif set_task_state(PROCESS_EXECUTING, "start"); return 0; // go here on error; "error_msg" contains error message, "retval" is nonzero // error: // if something failed, it's possible that the executable was munged. // Verify it to trigger another download. // gstate.input_files_available(result, true); gstate.report_result_error(*result, "%s", err_stream.str().c_str()); set_task_state(PROCESS_COULDNT_START, "start"); return retval; }
/// Write the app init file. /// This is done before starting the app, /// and when project prefs have changed during app execution. /// /// \return 0 on success, #ERR_FOPEN if the file could not be opened. /// /// \todo This function was modified to use ofstream instead of boinc_fopen(). /// This means the error checking and retry mechanisms of boinc_fopen() aren't /// used now. We may need to restore them. --NA int ACTIVE_TASK::write_app_init_file() { APP_INIT_DATA aid; memset(&aid, 0, sizeof(aid)); aid.major_version = BOINC_MAJOR_VERSION; aid.minor_version = BOINC_MINOR_VERSION; aid.release = BOINC_RELEASE; aid.app_version = app_version->version_num; safe_strcpy(aid.app_name, wup->app->name); safe_strcpy(aid.symstore, wup->project->symstore); safe_strcpy(aid.acct_mgr_url, gstate.acct_mgr_info.acct_mgr_url); if (wup->project->project_specific_prefs.length()) { aid.project_preferences = strdup(wup->project->project_specific_prefs.c_str()); } aid.hostid = wup->project->hostid; safe_strcpy(aid.user_name, wup->project->user_name); safe_strcpy(aid.team_name, wup->project->team_name); std::string project_path = relative_to_absolute(get_project_dir(wup->project)); strlcpy(aid.project_dir, project_path.c_str(), sizeof(aid.project_dir)); std::string buf = relative_to_absolute(""); strlcpy(aid.boinc_dir, buf.c_str(), sizeof(aid.boinc_dir)); strcpy(aid.authenticator, wup->project->authenticator); aid.slot = slot; strcpy(aid.wu_name, wup->name); aid.user_total_credit = wup->project->user_total_credit; aid.user_expavg_credit = wup->project->user_expavg_credit; aid.host_total_credit = wup->project->host_total_credit; aid.host_expavg_credit = wup->project->host_expavg_credit; double rrs = gstate.runnable_resource_share(); if (rrs) { aid.resource_share_fraction = wup->project->resource_share/rrs; } else { aid.resource_share_fraction = 1; } aid.rsc_fpops_est = wup->rsc_fpops_est; aid.rsc_fpops_bound = wup->rsc_fpops_bound; aid.rsc_memory_bound = wup->rsc_memory_bound; aid.rsc_disk_bound = wup->rsc_disk_bound; aid.computation_deadline = result->computation_deadline(); aid.checkpoint_period = gstate.ncpus * gstate.global_prefs.disk_interval; aid.fraction_done_start = 0; aid.fraction_done_end = 1; #ifdef _WIN32 strcpy(aid.shmem_seg_name, shmem_seg_name); #else aid.shmem_seg_name = shmem_seg_name; #endif // wu_cpu_time is the CPU time at start of session, // not the checkpoint CPU time // At the start of an episode these are equal, but not in the middle! // aid.wu_cpu_time = episode_start_cpu_time; std::string init_data_path = slot_dir + std::string("/") + std::string(INIT_DATA_FILE); std::ofstream f(init_data_path.c_str(), std::ios::out); if (!f.is_open()) { msg_printf(wup->project, MSG_INTERNAL_ERROR, "Failed to open init file %s", init_data_path.c_str() ); return ERR_FOPEN; } aid.host_info = gstate.host_info; aid.global_prefs = gstate.global_prefs; aid.proxy_info = gstate.proxy_info; write_init_data_file(f, aid); return 0; }