int FAST_FUNC bb_init_module(const char *filename, const char *options) { size_t len = MAXINT(ssize_t); char *image; int rc = ENOENT; #if ENABLE_FEATURE_2_4_MODULES if (get_linux_version_code() < KERNEL_VERSION(2,6,0)) return bb_init_module_24(filename, options); #endif /* Use the 2.6 way */ image = xmalloc_open_zipped_read_close(filename, &len); if (image) { if (init_module(image, len, options) != 0) rc = errno; else rc = 0; free(image); } return rc; }
bool codegen(ast_t* program, pass_opt_t* opt) { PONY_LOG(opt, VERBOSITY_MINIMAL, ("Generating\n")); pony_mkdir(opt->output); compile_t c; memset(&c, 0, sizeof(compile_t)); init_module(&c, program, opt); init_runtime(&c); genprim_reachable_init(&c, program); bool ok; if(c.opt->library) ok = genlib(&c, program); else ok = genexe(&c, program); codegen_cleanup(&c); return ok; }
void restore_scan_state(void) { ScanState *save; init_module(); save = (ScanState *)utarray_back(scan_state); sym = save->sym; str_set(input_buf, save->input_buf); at_bol = save->at_bol; EOL = save->EOL; cs = save->cs; act = save->act; p = save->p >= 0 ? str_data(input_buf) + save->p : NULL; pe = save->pe >= 0 ? str_data(input_buf) + save->pe : NULL; eof = save->eof >= 0 ? str_data(input_buf) + save->eof : NULL; ts = save->ts >= 0 ? str_data(input_buf) + save->ts : NULL; te = save->te >= 0 ? str_data(input_buf) + save->te : NULL; // str_set(sym_string, save->sym_string); expect_opcode = save->expect_opcode; utarray_pop_back(scan_state); }
/*----------------------------------------------------------------------------- * allocate a new module, setup module_start[] and reset ASMPC of all sections, * return new unique ID; make it the current module *----------------------------------------------------------------------------*/ int new_module_id( void ) { Section *section; SectionHashElem *iter; int module_id; init_module(); module_id = get_last_module_id() + 1; /* expand all sections this new ID */ for ( section = get_first_section( &iter ) ; section != NULL ; section = get_next_section( &iter ) ) { section->asmpc = 0; section->opcode_size = 0; (void) section_module_start( section, module_id ); } /* init to default section */ set_cur_section( g_default_section ); return (g_cur_module = module_id); /* assign and return */ }
/* Return: * 0 on success, * -errno on open/read error, * errno on init_module() error */ int FAST_FUNC bb_init_module(const char *filename, const char *options) { size_t image_size; char *image; int rc; bool mmaped; if (!options) options = ""; //TODO: audit bb_init_module_24 to match error code convention #if ENABLE_FEATURE_2_4_MODULES if (get_linux_version_code() < KERNEL_VERSION(2,6,0)) return bb_init_module_24(filename, options); #endif image_size = INT_MAX - 4095; mmaped = 0; image = try_to_mmap_module(filename, &image_size); if (image) { mmaped = 1; } else { errno = ENOMEM; /* may be changed by e.g. open errors below */ image = xmalloc_open_zipped_read_close(filename, &image_size); if (!image) return -errno; } errno = 0; init_module(image, image_size, options); rc = errno; if (mmaped) munmap(image, image_size); else free(image); return rc; }
static int click_modevent(module_t mod, int type, void *data) { int ret; /* Load and unload the VFS part first */ ret = vfs_modevent(mod, type, data); if (ret != 0) { return ret; } switch (type) { case MOD_LOAD: printf("Click module loading\n"); if (init_module()) { ret = EINVAL; break; } ret = 0; break; case MOD_UNLOAD: printf("Click module unloading\n"); cleanup_module(); ret = 0; break; case MOD_SHUTDOWN: printf("Click module shutdown\n"); ret = 0; break; default: printf("Click: unknown module command %d\n", type); ret = EOPNOTSUPP; break; } return ret; }
static int insmod(const char *filename, char *options) { void *module; unsigned size; int ret; module = read_file(filename, &size); if (!module) { #ifdef HAVE_AEE_FEATURE raise_aed_ke("W:insmod:Module \"%s\" not found.\n", filename); #endif return -1; } ret = init_module(module, size, options); #ifdef HAVE_AEE_FEATURE if (ret < 0) { const char *prop; prop = property_get("vold.post_fs_data_done"); if (! prop) { prop = "notset"; } if (EEXIST == errno && *prop == '0') { printf("In encrypt phone, it will trigger_post_fs_data. Threefore skip insmod (File exists) error. \n"); } else { raise_aed_ke("W:insmod:Failed to init module \"%s\" (%s), Check kernel log for more info.\n", filename, strerror(errno)); } } #endif free(module); return ret; }
/* append binary contents of file, whole file if num_bytes < 0 */ void patch_file_contents( FILE *file, int addr, long num_bytes ) { long start_ptr; Byte *buffer; init_module(); /* get bin file size */ if ( num_bytes < 0 ) { start_ptr = ftell( file ); fseek( file, 0, SEEK_END ); /* file pointer to end of file */ num_bytes = ftell( file ) - start_ptr; fseek( file, start_ptr, SEEK_SET ); /* file pointer to original position */ } if ( num_bytes > 0 ) { buffer = alloc_space( addr, num_bytes ); xfget_chars( file, (char *) buffer, num_bytes ); } }
/*----------------------------------------------------------------------------- * Get the next token, fill the corresponding tok* variables *----------------------------------------------------------------------------*/ tokid_t GetSym( void ) { init_module(); init_sym(); /* keep returning TK_NEWLINE until EOL is cleared * NOTE: HACK for inconsistent parser in handling newlines, should be removed */ if ( EOL ) { at_bol = TRUE; sym.tstart = "\n"; sym.tlen = 1; return (sym.tok = TK_NEWLINE); /* assign and return */ } /* loop filling buffer when needed */ do { /* refill buffer if needed, check for end of file */ if ( ! fill_buffer() ) { sym.tok = TK_END; ts = te = p; break; } /* run the state machine */ sym.tok = _scan_get(); } while ( sym.tok == TK_END ); sym.tstart = ts; sym.tlen = te - ts; /* remember token position */ at_bol = EOL = (sym.tok == TK_NEWLINE) ? TRUE : FALSE; return sym.tok; }
void CodeGen_GPU_Host<CodeGen_CPU>::compile(Stmt stmt, string name, const vector<Argument> &args, const vector<Buffer> &images_to_embed) { init_module(); // also set up the child codegenerator - this is set up once per // PTX_Host::compile, and reused across multiple PTX_Dev::compile // invocations for different kernels. cgdev->init_module(); module = get_initial_module_for_target(target, context); // grab runtime helper functions // Fix the target triple debug(1) << "Target triple of initial module: " << module->getTargetTriple() << "\n"; llvm::Triple triple = CodeGen_CPU::get_target_triple(); module->setTargetTriple(triple.str()); debug(1) << "Target triple of initial module: " << module->getTargetTriple() << "\n"; // Pass to the generic codegen CodeGen::compile(stmt, name, args, images_to_embed); // Unset constant flag for embedded image global variables for (size_t i = 0; i < images_to_embed.size(); i++) { string name = images_to_embed[i].name(); GlobalVariable *global = module->getNamedGlobal(name + ".buffer"); global->setConstant(false); } std::vector<char> kernel_src = cgdev->compile_to_src(); Value *kernel_src_ptr = CodeGen_CPU::create_constant_binary_blob(kernel_src, "halide_kernel_src"); // Remember the entry block so we can branch to it upon init success. BasicBlock *entry = &function->getEntryBlock(); // Insert a new block to run initialization at the beginning of the function. BasicBlock *init_kernels_bb = BasicBlock::Create(*context, "init_kernels", function, entry); builder->SetInsertPoint(init_kernels_bb); Value *user_context = get_user_context(); Value *kernel_size = ConstantInt::get(i32, kernel_src.size()); Value *init = module->getFunction("halide_init_kernels"); internal_assert(init) << "Could not find function halide_init_kernels in initial module\n"; Value *result = builder->CreateCall4(init, user_context, get_module_state(), kernel_src_ptr, kernel_size); Value *did_succeed = builder->CreateICmpEQ(result, ConstantInt::get(i32, 0)); CodeGen_CPU::create_assertion(did_succeed, "Failure inside halide_init_kernels"); // Upon success, jump to the original entry. builder->CreateBr(entry); // Optimize the module CodeGen::optimize_module(); }
char *get_map_filename(char *filename) { init_module(); return path_replace_ext(filename, FILEEXT_MAP); }
char *get_lib_filename( char *filename ) { init_module(); return path_replace_ext( filename, FILEEXT_LIB ); }
char *get_err_filename( char *filename ) { init_module(); return path_replace_ext( filename, FILEEXT_ERR ); }
__declspec( dllexport ) void LibInit() { init_module(); }
void set_error_file( char *filename ) { init_module(); errors.filename = strpool_add( filename ); /* may be NULL */ }
void errors_init( void ) { init_module(); }
/*----------------------------------------------------------------------------- * define the next FILE, LINENO, MODULE to use in error messages * error_xxx(), fatal_xxx(), warn_xxx() *----------------------------------------------------------------------------*/ void set_error_null( void ) { init_module(); errors.filename = errors.module = NULL; errors.line = 0; }
/* Called once form pthread_once in timer_init. This initializes the module and ensures that reinit_after_fork will be executed in any child process. */ void __timer_init_once (void) { init_module (); pthread_atfork (0, 0, reinit_after_fork); }
/* This is a handler executed in a child process after a fork() occurs. It reinitializes the module, resetting all of the data structures to their initial state. The mutex is initialized in case it was locked in the parent process. */ static void reinit_after_fork (void) { init_module (); pthread_mutex_init (&__timer_mutex, 0); }
void set_error_module( char *modulename ) { init_module(); errors.module = strpool_add( modulename ); /* may be NULL */ }
char *get_def_filename( char *filename ) { init_module(); return path_replace_ext( filename, FILEEXT_DEF ); }
void set_error_line( int lineno ) { init_module(); errors.line = lineno; }
char *get_bin_filename( char *filename ) { init_module(); return path_replace_ext( filename, FILEEXT_BIN ); }
char *get_error_file(void) { init_module(); return errors.filename; }
char *get_sym_filename( char *filename ) { init_module(); return path_replace_ext( filename, FILEEXT_SYM ); }
int get_error_line(void) { init_module(); return errors.line; }
char *get_reloc_filename(char *filename) { init_module(); return path_replace_ext(filename, FILEEXT_RELOC); }
/*----------------------------------------------------------------------------- * reset count of errors and return current count *----------------------------------------------------------------------------*/ void reset_error_count( void ) { init_module(); errors.count = 0; }
static bool setupFilesystem(char* module) { if (module) { // unmount and rmmod if the module was specified on the commandline, i.e. ensure that the specified module is indeed running shutdownFilesystem(); // if still mounted if (access("/dev/gator/buffer", F_OK) == 0) { logg->logError(__FILE__, __LINE__, "Unable to remove the running gator.ko. Manually remove the module or use the running module by not specifying one on the commandline"); handleException(); } } const int retval = mountGatorFS(); if (retval == 1) { logg->logMessage("Driver already running at startup"); driverRunningAtStart = true; } else if (retval == 0) { logg->logMessage("Driver already mounted at startup"); driverRunningAtStart = driverMountedAtStart = true; } else { char command[256]; // arbitrarily large amount char location[256]; // arbitrarily large amount if (module) { strncpy(location, module, sizeof(location)); } else { // Is the driver co-located in the same directory? if (util->getApplicationFullPath(location, sizeof(location)) != 0) { // allow some buffer space logg->logMessage("Unable to determine the full path of gatord, the cwd will be used"); } strncat(location, "gator.ko", sizeof(location) - strlen(location) - 1); } if (access(location, F_OK) == -1) { if (module == NULL) { // The gator kernel is not already loaded and unable to locate gator.ko in the default location return false; } else { // gator location specified on the command line but it was not found logg->logError(__FILE__, __LINE__, "gator module not found at %s", location); handleException(); } } // Load driver bool success = init_module(location); if (!success) { logg->logMessage("init_module failed, trying insmod"); snprintf(command, sizeof(command), "insmod %s >/dev/null 2>&1", location); if (system(command) != 0) { logg->logMessage("Unable to load gator.ko driver with command: %s", command); logg->logError(__FILE__, __LINE__, "Unable to load (insmod) gator.ko driver:\n >>> gator.ko must be built against the current kernel version & configuration\n >>> See dmesg for more details"); handleException(); } } if (mountGatorFS() == -1) { logg->logError(__FILE__, __LINE__, "Unable to mount the gator filesystem needed for profiling."); handleException(); } } return true; }
int get_num_errors( void ) { init_module(); return errors.count; }