static void rx_thread(void) { SYS_LOG_INF("RX thread started"); while (1) { struct net_pkt *pkt; struct net_buf *buf; u8_t specifier; pkt = k_fifo_get(&rx_queue, K_FOREVER); buf = net_buf_frag_last(pkt->frags); SYS_LOG_DBG("Got pkt %p buf %p", pkt, buf); hexdump("SLIP >", buf->data, buf->len); /* TODO: process */ specifier = net_buf_pull_u8(buf); switch (specifier) { case '?': process_request(buf); break; case '!': process_config(pkt); break; default: SYS_LOG_ERR("Unknown message specifier %c", specifier); break; } net_pkt_unref(pkt); k_yield(); } }
/*************************************************************************** Name: get_next_task Description: retrieves tasks for proc_loop() The fist time, we get the task and check task_mode() Input: none Output: none Returns: process status (set to LOGOUT if no tasks found) ***************************************************************************/ static int get_next_task(Arb_connection* dbp) { /* Loop until time to perform a task */ for (;;) { if (logout_requested()) break; /* Check the next scheduled processing task */ if (process_config(dbp) == Failure) { ModLog->batchLog(XPRMOD, XPR_NO_TASK); arb_put_state(dbp, ARB_STATUS_LOGOUT); break; } bWroteCtlRpt = FALSE; Proc_mode = (tProcMode)task_mode(); if (Proc_mode != MOD_PRODUCTION && Proc_mode != MOD_BACKOUT) { ModLog->batchLog(XPRMOD,XPR_FAIL_INFO_INT,(char*)"invalid proc mode:",Proc_mode); arb_put_state(dbp,ARB_STATUS_LOGOUT); break; } if (task_idle_time() <= 0) break; arb_put_state(dbp, ARB_STATUS_IDLE); goto_idle(dbp, task_idle_time()); } return arb_get_current_state(); }
int main() { VolumeManager *vm; CommandListener *cl; NetlinkManager *nm; SLOGI("Vold 2.1 (the revenge) firing up"); mkdir("/dev/block/vold", 0755); /* Create our singleton managers */ if (!(vm = VolumeManager::Instance())) { SLOGE("Unable to create VolumeManager"); exit(1); }; if (!(nm = NetlinkManager::Instance())) { SLOGE("Unable to create NetlinkManager"); exit(1); }; cl = new CommandListener(); vm->setBroadcaster((SocketListener *) cl); nm->setBroadcaster((SocketListener *) cl); if (vm->start()) { SLOGE("Unable to start VolumeManager (%s)", strerror(errno)); exit(1); } if (process_config(vm)) { SLOGE("Error reading configuration (%s)... continuing anyways", strerror(errno)); } if (nm->start()) { SLOGE("Unable to start NetlinkManager (%s)", strerror(errno)); exit(1); } coldboot("/sys/block"); // coldboot("/sys/class/switch"); /* * Now that we're up, we can respond to commands */ if (cl->startListener()) { SLOGE("Unable to start CommandListener (%s)", strerror(errno)); exit(1); } // Eventually we'll become the monitoring thread while(1) { sleep(1000); } SLOGI("Vold exiting"); exit(0); }
void Qt_launchpad::keyPressEvent( QKeyEvent *k ) { //PERR("key pressed"); if(k->key() == Qt::Key_O && nowkey == -1) { nowkey = 31; } if(k->key() == Qt::Key_S && nowkey == 31) { nowkey = 55; } if(k->key() == Qt::Key_5 && nowkey == 55) { nowkey = -1; QList<Child_entry*> child_entries = childrenDockWidgetContents->findChildren<Child_entry*>(QString()); foreach(Child_entry* child_entry, child_entries){ if (child_entry) this->exit_child(child_entry->_launchpad_child); } this->hide(); QList<QToolButton*> toolbuttons = this->findChildren<QToolButton*>(QString()); foreach(QToolButton* toolbutton, toolbuttons){ if (toolbutton) layoutMain->removeWidget(toolbutton); if (toolbutton) layoutTest->removeWidget(toolbutton); if (toolbutton) layout3->removeWidget(toolbutton); toolbutton->deleteLater(); launcherDockWidgetContents->adjustSize(); } layoutMain->deleteLater(); layoutTest->deleteLater(); layout3->deleteLater(); layoutChild->deleteLater(); layoutQuota->deleteLater(); groupBoxMain->deleteLater(); groupBoxTest->deleteLater(); groupBox3->deleteLater(); groupBoxChild->deleteLater(); groupBoxQuota->deleteLater(); TrustONEserver::Connection t; t.trust_one(); loginfinished=false; while(!loginfinished){ Timer::Connection loginwait; loginwait.msleep(1000); if(loginfinished){ process_config(this); launcherDockWidget->setWidget(launcherDockWidgetContents); loginwait.msleep(500); this->show(); } } }
/** Parse configuration from INI-file style config file into memory. * \param filename Name of the config file. * \retval 0 config successfully parsed * \retval <0 error occurred */ int config_read_file(const char *filename) { FILE *f; ConfigSection *curr_section = NULL; int result = 0; report(RPT_NOTICE, "Using Configuration File: %s", filename); f = fopen(filename, "r"); if (f == NULL) { return -1; } #if defined(LCDPROC_CONFIG_READ_STRING) result = process_config(&curr_section, get_next_char_f, filename, f); #else result = process_config(&curr_section, filename, f); #endif fclose(f); return result; }
int config_read_string(const char *sectionname, const char *str) /* All the config parameters are placed in the given section in memory.*/ { int pos = 0; ConfigSection *s; /* We use a nested function to transfer the characters from buffer to parser*/ char get_next_char() { return str[pos++]; } if ((s = find_section(sectionname)) == NULL) s = add_section(sectionname); return process_config(&s, get_next_char, "command line", NULL); }
//--------------------------------------------------------- // // Function: sighandler // Description Handles the signals we care about // Arguments: int signal // // Returns: nothing // //--------------------------------------------------------- void sighandler(int signal) { if (signal == SIGTERM) { loginfo("Received SIGTERM - cleaning up"); check(); free_config(myconfig); free(myconfig); exit(0); } else if (signal == SIGHUP) { loginfo("Received SIGHUP - re-reading configuration file [%s]", myconfig->app_config->conf); process_config(); } else if (signal == SIGINT) { loginfo("Received SIGINT - cleaning up"); check(); free_config(myconfig); free(myconfig); exit(0); } }
const char* read_config(void *mconfig,ngx_pool_t *p,ngx_pool_t *ptemp,const char* filename){ ngx_configfile_t *cfp; ngx_int_t rv; cmd_parms parms; parms = default_parms; parms.pool = p; parms.temp_pool = ptemp; rv = ngx_pcfg_openfile(&cfp, p, filename); if(rv!=NGX_OK){ return ngx_pstrcat(p,"Could not open configuration file: %s",filename,NULL); } parms.config_file = cfp; return process_config(mconfig,&parms,p,ptemp); }
static int load_module(void) { if (process_config(0)) { return AST_MODULE_LOAD_DECLINE; } if (ast_http_uri_link(&test_uri)) { return AST_MODULE_LOAD_DECLINE; } AST_TEST_REGISTER(create_nominal); AST_TEST_REGISTER(retrieve_nominal); AST_TEST_REGISTER(retrieve_etag); AST_TEST_REGISTER(retrieve_expires); AST_TEST_REGISTER(retrieve_etag_expired); AST_TEST_REGISTER(retrieve_cache_control_age); AST_TEST_REGISTER(retrieve_cache_control_directives); ast_test_register_init(CATEGORY, pre_test_cb); return AST_MODULE_LOAD_SUCCESS; }
int ast_ari_config_init(void) { if (aco_info_init(&cfg_info)) { aco_info_destroy(&cfg_info); return -1; } aco_option_register(&cfg_info, "enabled", ACO_EXACT, general_options, "yes", OPT_BOOL_T, 1, FLDSET(struct ast_ari_conf_general, enabled)); aco_option_register_custom(&cfg_info, "pretty", ACO_EXACT, general_options, "no", encoding_format_handler, 0); aco_option_register(&cfg_info, "auth_realm", ACO_EXACT, general_options, "Asterisk REST Interface", OPT_CHAR_ARRAY_T, 0, FLDSET(struct ast_ari_conf_general, auth_realm), ARI_AUTH_REALM_LEN); aco_option_register(&cfg_info, "allowed_origins", ACO_EXACT, general_options, "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_ari_conf_general, allowed_origins)); aco_option_register(&cfg_info, "websocket_write_timeout", ACO_EXACT, general_options, AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT_STR, OPT_INT_T, PARSE_IN_RANGE, FLDSET(struct ast_ari_conf_general, write_timeout), 1, INT_MAX); aco_option_register(&cfg_info, "type", ACO_EXACT, user, NULL, OPT_NOOP_T, 0, 0); aco_option_register(&cfg_info, "read_only", ACO_EXACT, user, "no", OPT_BOOL_T, 1, FLDSET(struct ast_ari_conf_user, read_only)); aco_option_register(&cfg_info, "password", ACO_EXACT, user, "", OPT_CHAR_ARRAY_T, 0, FLDSET(struct ast_ari_conf_user, password), ARI_PASSWORD_LEN); aco_option_register_custom(&cfg_info, "password_format", ACO_EXACT, user, "plain", password_format_handler, 0); return process_config(0); }
int main() { int res, try, retries; char *query_string, *abf_api_url, *api_token; char *log_level = getenv("LOG_LEVEL"); if (init_logger(log_level == NULL ? "INFO" : log_level) < 0) { return 2; } register_thread("Main"); log_printf(LOG_INFO, "Starting DNS check...\n"); res = check_dns(); if (res < 0) { log_printf(LOG_FATAL, "Check DNS failed, can't resolve github.com. Exiting...\n"); return 6; } else { log_printf(LOG_INFO, "Successfuly resolved github. Continuing.\n"); } usergroup omv_mock = get_omv_uid_mock_gid(); if(omv_mock.omv_uid == 0) { log_printf(LOG_FATAL, "User omv doesn't exist. Exiting...\n"); return 7; } if(omv_mock.mock_gid == 0) { log_printf(LOG_FATAL, "Group mock doesn't exist. Exiting...\n"); return 8; } res = process_config(&abf_api_url, &api_token, &query_string); if (res < 0) { log_printf(LOG_FATAL, "Failed to process config, exiting.\n"); return 1; } init_strings(api_token); init_api(abf_api_url, api_token); if(start_statistics_thread(query_string)) { log_printf(LOG_FATAL, "Failed to initialize statistics thread. Exiting...\n"); return 5; } while(1) { char *job; if(api_jobs_shift(&job, query_string)) { sleep(10); continue; } char *build_id, *distrib_type; char **env; int ttl; res = parse_job_description(job, &build_id, &ttl, &distrib_type, &env); free(job); if(res < 0) { sleep(10); continue; } log_printf(LOG_INFO, "Starting build with build_id %s.\n", build_id); log_printf(LOG_INFO, "Sending build start notification to ABF.\n"); retries = 5; try = 0; set_busy_status(1, build_id); int build_start_success = 0; while(retries) { log_printf(LOG_INFO, "Try #%d: Sending data to ABF.\n", try + 1); if(!api_jobs_feedback(build_id, BUILD_STARTED, hostname_payload)) { log_printf(LOG_INFO, "Try #%d: Data sent.\n", try + 1); build_start_success = 1; break; } else { log_printf(LOG_ERROR, "Try #%d: Failed to send data to ABF. Sleeping for %d seconds and retrying...\n", try + 1, 1 << try); } retries--; sleep(1 << try); try++; } if (!build_start_success) { log_printf(LOG_ERROR, "Failed to send build start to ABF, aborting build.\n"); free(build_id); free(distrib_type); for(int i = 0; i < res; i++) { free(env[i]); } free(env); set_busy_status(0, NULL); continue; } child script = exec_build(distrib_type, (char * const *)env, omv_mock); int live_inspector_started = 1; log_printf(LOG_INFO, "Starting live inspector, build's time to live is %d seconds.\n", ttl); if(start_live_inspector(ttl, script.pid, build_id) < 0) { live_inspector_started = 0; log_printf(LOG_WARN, "Live inspector failed to start. Job canceling and timeout will be unavailable.\n"); } int live_logger_started = 1; log_printf(LOG_INFO, "Starting live logger.\n"); if(start_live_logger(build_id, script.read_fd) < 0) { live_logger_started = 0; log_printf(LOG_WARN, "Live logger failed to start. Live log will be unavailable.\n"); } int status, build_status = BUILD_COMPLETED; waitpid(script.pid, &status, 0); int canceled = 0; if (live_inspector_started) { canceled = stop_live_inspector(); } if (live_logger_started) { stop_live_logger(); } int exit_code = 0; if (canceled) { build_status = BUILD_CANCELED; } else if(WIFEXITED(status)) { exit_code = WEXITSTATUS(status); switch(exit_code) { case 0: build_status = BUILD_COMPLETED; break; case 5: build_status = TESTS_FAILED; break; default: build_status = BUILD_FAILED; } } else if(WIFSIGNALED(status)) { exit_code = 255; build_status = BUILD_FAILED; } for(int i = 0; i < res; i++) { free(env[i]); } free(env); free(distrib_type); log_printf(LOG_INFO, "Build is over with status %s.\n", build_statuses_str[build_status]); mkdir(home_output, 0666); system(move_output_cmd); system(upload_cmd); char *container_data = read_file(container_data_path); char *results = read_file("/tmp/results.json"); char *commit_hash = read_file(commit_hash_path); if(commit_hash != NULL) { commit_hash[40] = '\0'; } char *fail_reason = NULL; if (build_status == BUILD_FAILED) { fail_reason = read_file(fail_reason_path); if (fail_reason != NULL) { for (unsigned int i = 0; i < strlen(fail_reason); i++) { if (!isprint(fail_reason[i]) || fail_reason[i] == '"') { fail_reason[i] = ' '; } } } } char *args = xmalloc((container_data ? strlen(container_data) : 0) + (results ? strlen(results) : 0) + 2048); sprintf(args, build_completed_args_fmt, (results ? results : "[]"), \ (container_data ? container_data : "{}"), exit_code, (commit_hash ? commit_hash : ""), (fail_reason ? fail_reason : "")); retries = 5; try = 0; while(retries) { log_printf(LOG_INFO, "Try #%d: Sending data to ABF\n", try + 1); if(!api_jobs_feedback(build_id, build_status, args)) { log_printf(LOG_INFO, "Data sent.\n"); break; } else { log_printf(LOG_ERROR, "Failed to send data to ABF. Sleeping for %d seconds and retrying...\n", 1 << try); } retries--; sleep(1 << try); try++; } set_busy_status(0, NULL); free(args); free(build_id); if(commit_hash) { free(commit_hash); } if(results) { free(results); } if(container_data) { free(container_data); } if(fail_reason) { free(fail_reason); } } return 0; }
int load_config( char* fname) { CONFIG* iter; CONFIG_ITEM* item; int config_ok = 1,inirval; free_filters(); if((inirval = ini_parse(fname,handler,instance.conf)) < 0){ printf("Error parsing configuration file!\n"); if(inirval == -1) printf("Inih file open error.\n"); else if(inirval == -2) printf("inih memory error.\n"); MXS_ERROR("Error parsing configuration file!\n"); config_ok = 0; goto cleanup; } if(instance.verbose){ printf("Configuration loaded from %s\n\n",fname); } if(instance.conf == NULL){ printf("Nothing valid was read from the file.\n"); MXS_NOTICE("Nothing valid was read from the file.\n"); config_ok = 0; goto cleanup; } instance.conf = process_config(instance.conf); if(instance.conf){ if(instance.verbose){ printf("Modules Loaded:\n"); } iter = instance.conf; }else{ printf("No filters found in the configuration file.\n"); MXS_NOTICE("No filters found in the configuration file.\n"); config_ok = 0; goto cleanup; } while(iter){ item = iter->item; while(item){ if(!strcmp("module",item->name)){ if(instance.mod_dir){ char* modstr = malloc(sizeof(char)*(strlen(instance.mod_dir) + strlen(item->value) + 1)); strcpy(modstr,instance.mod_dir); strcat(modstr,"/"); strcat(modstr,item->value); instance.head = load_filter_module(modstr); free(modstr); }else{ instance.head = load_filter_module(item->value); } if(!instance.head || !load_filter(instance.head,instance.conf)){ printf("Error creating filter instance!\nModule: %s\n",item->value); MXS_ERROR("Error creating filter instance!\nModule: %s\n",item->value); config_ok = 0; goto cleanup; }else{ if(instance.verbose){ printf("\t%s\n",iter->section); } } } item = item->next; } iter = iter->next; } while(instance.conf){ item = instance.conf->item; while(item){ item = instance.conf->item; instance.conf->item = instance.conf->item->next; free(item->name); free(item->value); free(item); item = instance.conf->item; } instance.conf = instance.conf->next; } cleanup: while(instance.conf){ iter = instance.conf; instance.conf = instance.conf->next; item = iter->item; while(item){ free(item->name); free(item->value); free(item); iter->item = iter->item->next; item = iter->item; } free(iter); } instance.conf = NULL; return config_ok; }
int main(int argc, char *argv[]) { int fd = -1; pid_t pgid = -1; server_conf_t *conf; int log_priority = LOG_INFO; #ifndef NDEBUG log_priority = LOG_DEBUG; #endif /* NDEBUG */ log_set_file(stderr, log_priority, 0); conf = create_server_conf(); tp_global = conf->tp; process_cmdline(conf, argc, argv); if (!conf->enableForeground) { begin_daemonize(&fd, &pgid); } process_config(conf); setup_coredump(conf); setup_signals(conf); if (!(environ = get_sane_env())) { log_err(ENOMEM, "Unable to create sanitized environment"); } if (conf->enableVerbose) { display_configuration(conf); } if (list_is_empty(conf->objs)) { log_err(0, "Configuration \"%s\" has no consoles defined", conf->confFileName); } if (conf->tStampMinutes > 0) { schedule_timestamp(conf); } create_listen_socket(conf); if (!conf->enableForeground) { if (conf->syslogFacility > 0) { log_set_syslog(argv[0], conf->syslogFacility); } if (conf->logFileName) { open_daemon_logfile(conf); } else { log_set_file(NULL, 0, 0); } end_daemonize(fd); } log_msg(LOG_NOTICE, "Starting ConMan daemon %s (pid %d)", VERSION, (int) getpid()); #if WITH_FREEIPMI ipmi_init(conf->numIpmiObjs); #endif /* WITH_FREEIPMI */ open_objs(conf); mux_io(conf); #if WITH_FREEIPMI ipmi_fini(); #endif /* WITH_FREEIPMI */ destroy_server_conf(conf); if (pgid > 0) { if (kill(-pgid, SIGTERM) < 0) { log_msg(LOG_WARNING, "Unable to terminate process group ID %d: %s", pgid, strerror(errno)); } } log_msg(LOG_NOTICE, "Stopping ConMan daemon %s (pid %d)", VERSION, (int) getpid()); exit(0); }
/*-------------------------------------------------------------------*/ int build_config (const char *hercules_cnf) { int i; /* Array subscript */ int devtmax; /* Max number device threads */ /* From impl.c, using system defaults of: * * LPARNUM 1 # LPAR 1 with LPAR ID 01 * CPUIDFMT 0 # CPU ID format 0 * XPNDSIZE 0 # Expanded storage size */ sysblk.xpndsize = 0; /* Set sysblk.maxcpu to our preferred default value, if possible */ #if (PREF_DEF_MAXCPU <= MAX_CPU_ENGINES) sysblk.maxcpu = PREF_DEF_MAXCPU; #else WARNING( "sysblk.maxcpu reduced from " QSTR( PREF_DEF_MAXCPU ) " to " QSTR( MAX_CPU_ENGINES )) sysblk.maxcpu = MAX_CPU_ENGINES; #endif #ifdef _FEATURE_VECTOR_FACILITY sysblk.numvec = sysblk.maxcpu; #else //!_FEATURE_VECTOR_FACILITY sysblk.numvec = 0; #endif // _FEATURE_VECTOR_FACILITY #if defined(_900) set_archlvl(_ARCH_900_NAME); #elif defined(_390) set_archlvl(_ARCH_390_NAME); #else set_archlvl(_ARCH_370_NAME); #endif devtmax = MAX_DEVICE_THREADS; ptt_trace_init (0, 1); /* Set max number device threads */ sysblk.devtmax = devtmax; sysblk.devtwait = sysblk.devtnbr = sysblk.devthwm = sysblk.devtunavail = 0; #if defined(OPTION_LPP_RESTRICT) /* Default the licence setting */ losc_set(PGM_PRD_OS_RESTRICTED); #endif /* Reset the clock steering registers */ csr_reset(); /* Default CPU type CP */ for (i = 0; i < sysblk.maxcpu; i++) sysblk.ptyp[i] = SCCB_PTYP_CP; /* Default main storage to 2M with one CPU */ configure_storage(2 << (SHIFT_MEBIBYTE - 12)); configure_numcpu(1); if (hercules_cnf && (process_config(hercules_cnf))) return -1; /* Connect each channel set to its home cpu */ for (i = 0; i < sysblk.maxcpu; i++) if (IS_CPU_ONLINE(i)) sysblk.regs[i]->chanset = i < FEATURE_LCSS_MAX ? i : 0xFFFF; return 0; } /* end function build_config */
//--------------------------------------------------------- // Function: main // Description program entry point // Arguments: int // **argv // // Returns: int //--------------------------------------------------------- int main(int argc, char **argv) { s_logger_level level = S_LOGGER_INFO; s_logger_mode mode = S_LOGGER_MODE_SYSLOG; int facility = LOG_LOCAL1; char *config_file; int inert = 0; //arm errno errno = 0; //check arg count if(argc <= 1) { usage(); } //parse command line for logging mode and level along with config file override //-i = inert //-o = stdout //-d = debug //-f = facility [1-7] //-c = configuration file int c; while ((c = getopt(argc, argv, "iodf:c:")) != -1) { switch (c) { case 'i': inert = 1; case 'o': mode = S_LOGGER_MODE_STDOUT; break; case 'd': level = S_LOGGER_DEBUG; break; case 'f': switch (atoi(optarg)) { case 1: facility = LOG_LOCAL1; break; case 2: facility = LOG_LOCAL2; break; case 3: facility = LOG_LOCAL3; break; case 4: facility = LOG_LOCAL4; break; case 5: facility = LOG_LOCAL5; break; case 6: facility = LOG_LOCAL6; break; case 7: facility = LOG_LOCAL7; break; default: usage(); break; } break; case 'c': config_file = optarg; break; default: usage(); } } if (mode == S_LOGGER_MODE_SYSLOG) { initsyslog(level, facility); }else { initstdoutlog(level); } //place our main structure into the heap myconfig = malloc(sizeof(sprinkler_config_t)); if (myconfig <= 0) { logerror("Unable to allocate memory (%d) %s", errno, strerror(errno)); exit(EXIT_FAILURE); } if ((init_config(myconfig)) != EXIT_SUCCESS) { logerror("An error occured while initializing the config, cannot continue\n"); exit(EXIT_FAILURE); } if (config_file != NULL || strcmp(config_file, "") != 0) { myconfig->app_config->conf = config_file; } myconfig->app_config->inert = inert; process_config(); if (mode == S_LOGGER_MODE_SYSLOG) { if (daemonize() != 0) { logerror("Unable to daemonize"); exit(EXIT_FAILURE); } } //set signals signal(SIGTERM, sighandler); signal(SIGHUP, sighandler); signal(SIGINT, sighandler); main_loop(myconfig); //we should never get here return 0; }
/*-------------------------------------------------------------------*/ int build_config (char *hercules_cnf) { int i; /* Array subscript */ int devtmax; /* Max number device threads */ sysblk.xpndsize = 0; sysblk.maxcpu = MAX_CPU_ENGINES; #ifdef _FEATURE_VECTOR_FACILITY sysblk.numvec = sysblk.maxcpu; #else //!_FEATURE_VECTOR_FACILITY sysblk.numvec = 0; #endif // _FEATURE_VECTOR_FACILITY #if defined(_900) set_archlvl(_ARCH_900_NAME); #elif defined(_390) set_archlvl(_ARCH_390_NAME); #else set_archlvl(_ARCH_370_NAME); #endif devtmax = MAX_DEVICE_THREADS; #ifdef OPTION_PTTRACE ptt_trace_init (0, 1); #endif #if defined(OPTION_FISHIO) InitIOScheduler // initialize i/o scheduler... ( sysblk.arch_mode, // (for calling execute_ccw_chain) &sysblk.devprio, // (ptr to device thread priority) MAX_DEVICE_THREAD_IDLE_SECS, // (maximum device thread wait time) devtmax // (maximum #of device threads allowed) ); #else // !defined(OPTION_FISHIO) /* Set max number device threads */ sysblk.devtmax = devtmax; sysblk.devtwait = sysblk.devtnbr = sysblk.devthwm = sysblk.devtunavail = 0; #endif // defined(OPTION_FISHIO) #if defined(OPTION_LPP_RESTRICT) /* Default the licence setting */ losc_set(PGM_PRD_OS_RESTRICTED); #endif /* Reset the clock steering registers */ csr_reset(); /* Default CPU type CP */ for (i = 0; i < sysblk.maxcpu; i++) sysblk.ptyp[i] = SCCB_PTYP_CP; /* Default Storage & NUMCPU */ configure_storage(2); configure_numcpu(1); if (hercules_cnf && (process_config(hercules_cnf))) return -1; return 0; } /* end function build_config */
static int reload_module(void) { return process_config(1); }
int ast_ari_config_reload(void) { return process_config(1); }