int Awstats::executeUpdate(const char * pName) { const char * pWorking = m_sWorkingDir.c_str(); char achBuf[8192]; safe_snprintf( achBuf, 8192, "%s/add-ons/awstats", HttpGlobals::s_pServerRoot ); if ( HttpGlobals::s_psChroot ) pWorking += HttpGlobals::s_psChroot->len(); if ( chdir( achBuf ) == -1 ) { LOG_ERR(( "Cannot change to dir [%s]: %s", achBuf, strerror( errno ) )); return -1; } if ( m_iMode == AWS_STATIC ) { safe_snprintf( achBuf, 8192, "tools/awstats_buildstaticpages.pl -awstatsprog=wwwroot/cgi-bin/awstats.pl" " -dir='%s/html' -update " "-configdir='%s/conf' " "-config='%s' -lang=en", pWorking, pWorking, pName ); } else if ( m_iMode == AWS_DYNAMIC ) { safe_snprintf( achBuf, 8192, "wwwroot/cgi-bin/awstats.pl -update -configdir='%s/conf' -config='%s'", pWorking, pName ); } else { LOG_ERR(( "Unknown update method %d", m_iMode )); return -1; } setpriority( PRIO_PROCESS, 0, getpriority( PRIO_PROCESS, 0) + 4 ); int ret = system( achBuf ); return ret; }
int Awstats::executeUpdate(const char *pName) { const char *pWorking = m_sWorkingDir.c_str(); char achBuf[8192]; ls_snprintf(achBuf, 8192, "%s/add-ons/awstats", MainServerConfig::getInstance().getServerRoot()); if (ServerProcessConfig::getInstance().getChroot() != NULL) pWorking += ServerProcessConfig::getInstance().getChroot()->len(); if (chdir(achBuf) == -1) { LS_ERROR("Cannot change to dir [%s]: %s", achBuf, strerror(errno)); return LS_FAIL; } if (m_iMode == AWS_STATIC) { ls_snprintf(achBuf, 8192, "tools/awstats_buildstaticpages.pl -awstatsprog=wwwroot/cgi-bin/awstats.pl" " -dir='%s/html' -update " "-configdir='%s/conf' " "-config='%s' -lang=en", pWorking, pWorking, pName); } else if (m_iMode == AWS_DYNAMIC) { ls_snprintf(achBuf, 8192, "wwwroot/cgi-bin/awstats.pl -update -configdir='%s/conf' -config='%s'", pWorking, pName); } else { LS_ERROR("Unknown update method %d", m_iMode); return LS_FAIL; } setpriority(PRIO_PROCESS, 0, getpriority(PRIO_PROCESS, 0) + 4); int ret = system(achBuf); return ret; }
static TACommandVerdict getpriority_cmd(TAThread thread,TAInputStream stream) { int which; int who ; int res ; // Prepare which = readInt( & stream ); who = readInt( & stream ); errno = 0; // Execute START_TARGET_OPERATION(thread); res = getpriority( which, who ); END_TARGET_OPERATION(thread); // Response writeInt( thread, res ); writeInt( thread, errno ); sendResponse( thread ); return taDefaultVerdict; }
static void display_thread_sched_attr(char *msg) { int policy, prio; struct sched_param param; prio = getpriority(PRIO_PROCESS, 0); assert(!pthread_getschedparam(pthread_self(), &policy, ¶m)); coremu_print("-- tid[%lu] %s start --", (unsigned long int)coremu_gettid(), msg); coremu_print("policy=%s, priority=%d", (policy == SCHED_FIFO) ? "SCHED_FIFO" : (policy == SCHED_RR) ? "SCHED_RR" : (policy == SCHED_OTHER) ? "SCHED_OTHER" : "???", prio); coremu_print("-- thr[%lu] %s end --\n", (unsigned long int)coremu_gettid(), msg); }
// "normal" invoke through a socket connection static int invoke_remote(int socket_fd, int prog_argc, char **prog_argv, char *prog_name, uint32_t magic_options, bool wait_term, unsigned int respawn_delay, char *splash_file, char *landscape_splash_file) { // Get process priority errno = 0; int prog_prio = getpriority(PRIO_PROCESS, 0); if (errno && prog_prio < 0) { prog_prio = 0; } // Connection with launcher process is established, // send the data. invoker_send_magic(socket_fd, magic_options); invoker_send_name(socket_fd, prog_argv[0]); invoker_send_exec(socket_fd, prog_name); invoker_send_args(socket_fd, prog_argc, prog_argv); invoker_send_prio(socket_fd, prog_prio); invoker_send_delay(socket_fd, respawn_delay); invoker_send_ids(socket_fd, getuid(), getgid()); if (( magic_options & INVOKER_MSG_MAGIC_OPTION_SPLASH_SCREEN ) != 0) invoker_send_splash_file(socket_fd, splash_file); if (( magic_options & INVOKER_MSG_MAGIC_OPTION_LANDSCAPE_SPLASH_SCREEN ) != 0) invoker_send_landscape_splash_file(socket_fd, landscape_splash_file); invoker_send_io(socket_fd); invoker_send_env(socket_fd); invoker_send_end(socket_fd); if (prog_name) { free(prog_name); } int exit_status = wait_for_launched_process_to_exit(socket_fd, wait_term); return exit_status; }
static void print_status(const char *t) { int ret; if ((ret = sched_getscheduler(0)) < 0) { fprintf(stderr, "sched_getscheduler() failed: %s\n", strerror(errno)); return; } printf("%s:\n" "\tSCHED_RESET_ON_FORK: %s\n", t, (ret & SCHED_RESET_ON_FORK) ? "yes" : "no"); if ((ret & ~SCHED_RESET_ON_FORK) == SCHED_RR) { struct sched_param param; if (sched_getparam(0, ¶m) < 0) { fprintf(stderr, "sched_getschedparam() failed: %s\n", strerror(errno)); return; } printf("\tSCHED_RR with priority %i\n", param.sched_priority); } else if ((ret & ~SCHED_RESET_ON_FORK) == SCHED_OTHER) { errno = 0; ret = getpriority(PRIO_PROCESS, 0); if (errno != 0) { fprintf(stderr, "getpriority() failed: %s\n", strerror(errno)); return; } printf("\tSCHED_OTHER with nice level: %i\n", ret); } else fprintf(stderr, "Neither SCHED_RR nor SCHED_OTHER.\n"); }
int os_raiseThreadPriority() { FASTIVA_LATE_IMPL(); return THREAD_NORM_PRIORITY; #if 0 /* Get the priority (the "nice" value) of the current thread. The * getpriority() call can legitimately return -1, so we have to * explicitly test errno. */ errno = 0; int oldThreadPriority = getpriority(PRIO_PROCESS, 0); if (errno != 0) { ALOGI("getpriority(self) failed: %s", strerror(errno)); } else if (oldThreadPriority > ANDROID_PRIORITY_NORMAL) { /* Current value is numerically greater than "normal", which * in backward UNIX terms means lower priority. */ if (oldThreadPriority >= ANDROID_PRIORITY_BACKGROUND) { set_sched_policy(dvmGetSysThreadId(), SP_FOREGROUND); } if (setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_NORMAL) != 0) { ALOGI("Unable to elevate priority from %d to %d", oldThreadPriority, ANDROID_PRIORITY_NORMAL); } else { /* * The priority has been elevated. Return the old value * so the caller can restore it later. */ ALOGV("Elevating priority from %d to %d", oldThreadPriority, ANDROID_PRIORITY_NORMAL); return oldThreadPriority; } } return INT_MAX; #endif }
void os_changeThreadPriority(Thread* thread, int newPriority) { if (newPriority < 1 || newPriority > 10) { ALOGW("bad priority %d", newPriority); newPriority = 5; } int newNice = kNiceValues[newPriority-1]; pid_t pid = thread->systemTid; if (newNice >= ANDROID_PRIORITY_BACKGROUND) { set_sched_policy(dvmGetSysThreadId(), SP_BACKGROUND); } else if (getpriority(PRIO_PROCESS, pid) >= ANDROID_PRIORITY_BACKGROUND) { set_sched_policy(dvmGetSysThreadId(), SP_FOREGROUND); } if (setpriority(PRIO_PROCESS, pid, newNice) != 0) { std::string threadName(dvmGetThreadName(thread)); ALOGI("setPriority(%d) '%s' to prio=%d(n=%d) failed: %s", pid, threadName.c_str(), newPriority, newNice, strerror(errno)); } else { ALOGV("setPriority(%d) to prio=%d(n=%d)", pid, newPriority, newNice); } }
void opticsmountGSP::init() { /////////////////// Set process priorities int prior; int dummy1; /// set process priority of ueye usb daemon to highest possible value char reniceCmd[100]; string processIDofUeyeDeamonStr; int processIDofUeyeDeamon; char pidOfCmd[100]; sprintf(pidOfCmd, "pidof ueyeusbd"); processIDofUeyeDeamonStr = this->execAndReturnSystemOutput(pidOfCmd); processIDofUeyeDeamon = atoi(processIDofUeyeDeamonStr.c_str()); sprintf(reniceCmd, "sudo renice -20 %d", processIDofUeyeDeamon); dummy1 = system(reniceCmd); prior = getpriority(PRIO_PROCESS, processIDofUeyeDeamon); printf("\n ueyeusbd process priority set to: %d\n",prior); /// set process priority of TestProject process to a value slightly lower than ueye usb daemon setpriority(PRIO_PROCESS,0,-15); usleep(10000); prior = getpriority(PRIO_PROCESS,0); printf(" TestProject process priority set to: %d\n",prior); this->useBackgroundTask = false; prevImageTimeStamp = 0; /////////////////// Path Initializations sprintf(this->calibParamDir, "/opt/GogglesOptics/Calib_Params/%s", this->calibParamSetName); /////////////////// Camera Initialization section if (cameras.useCameras) { // Initialize 2 cameras GSPretVal = cameras.initTwoCameras(); // Errors handled within functions if (GSPretVal != 0) { printf("Cameras could not be initialized!\n"); return exit(1); } // Start 2 cameras GSPretVal = cameras.startTwoCameras(); // Errors handled within functions if (GSPretVal != 0) { printf("Cameras could not be started!\n"); return exit(1); } } /////////////////// /////////////////// Image Rectification Initialization GSPretVal = rectifier.calcRectificationMaps(cameras.getImageWidth(), cameras.getImageHeight(), this->calibParamDir); if (GSPretVal != 0) { cout << "Rectification maps could not be processed!" << endl; } /////////////////// Data Storage Initialization datastorage.initDataStorage(this->opticsmountName, this->camera_ID, this->runPath, this->cameras.getImageWidth(), this->cameras.getImageHeight()); if (datastorage.autoImageStorage) { // create image-datastorage thread GSPretVal = pthread_create(&ImageStorageThread, NULL, this->imageStorage_thread_Helper, this); if (GSPretVal != 0) { printf("pthread_create ImageStorageThread failed\n"); return exit(1); } } /////////////////// /////////////////// Initialization of OpenCV Mats with correct Size (depending on cameras.reduceImageSizeTo320x240) leftImage.create(cameras.getImageHeight(), cameras.getImageWidth(), CV_8UC1); rightImage.create(cameras.getImageHeight(), cameras.getImageWidth(), CV_8UC1); /////////////////// }
int main(int argc, char *argv[]) { int efd, retval, prio; uint64_t u; ssize_t s; uid_t uid; fd_set set; char *memcg_path; struct timeval timeout; #ifndef NO_GPL char *pathcopy, *progname, cmdline[1024], *tty; int istty = 1; pid_t pgid; #endif /* maybe save a tiny number of bytes, because we can */ mallopt(M_MXFAST, 0); if(argc > 2) { usage(argv[0]); exit(1); } else if(argc > 1 && argv[1][0] == '-') { /* any attempt at -helpme, etc */ usage(argv[0]); return 1; } uid = getuid(); /* don't monitor root */ if(uid == 0) return 0; /* used for cmdline when this is not a tty */ pgid = getpgrp(); daemonize(); /* be nice */ prio = getpriority(PRIO_PROCESS, getpid()); if(prio < TARGET_NICE) setpriority(PRIO_PROCESS, getpid(), TARGET_NICE); if(argc == 2) memcg_path = strdup(argv[1]); else memcg_path = get_cgroup_path(); /* set cmdline for ps, top, etc. if you're not concerned about GPL */ #ifndef NO_GPL pathcopy = strdup(argv[0]); progname = basename(pathcopy); initproctitle(argc, argv); tty = getenv("SSH_TTY"); if(tty == NULL) { istty = 0; tty = malloc(256); snprintf(tty, 256, "[notty: pgid=%d]", pgid); } snprintf(cmdline, 1024, "%s %s", tty, memcg_path); setproctitle(progname, cmdline); if(!istty) free(tty); free(pathcopy); #endif efd = open_event_fd(memcg_path); free(memcg_path); while(1) { /* Check periodically if the user has other processes. Exit if none exist */ timeout.tv_sec = TIMEOUT_SECONDS; timeout.tv_usec = 0; FD_ZERO(&set); FD_SET(efd, &set); /* check for data in efd (i.e. oom triggered) */ retval = select(FD_SETSIZE, &set, NULL, NULL, &timeout); if(retval == -1) { handle_error("select returned -1"); } else if(retval == 0) { if(!pipe_alive()) return 0; } else { /* select() found data */ s = read(efd, &u, sizeof(uint64_t)); if (s != sizeof(uint64_t)) handle_error("reading from event fd"); /* Wait a moment for the oom-killer to take effect. */ sleep(4); writeToTTY(); } } return 2; }
int start_stop_daemon_main(int argc UNUSED_PARAM, char **argv) { unsigned opt; char *signame; char *startas; char *chuid; #if ENABLE_FEATURE_START_STOP_DAEMON_FANCY // char *retry_arg = NULL; // int retries = -1; char *opt_N; #endif INIT_G(); opt = GETOPT32(argv, "^" "KSbqtma:n:s:u:c:x:p:" IF_FEATURE_START_STOP_DAEMON_FANCY("ovN:R:") /* -K or -S is required; they are mutually exclusive */ /* -p is required if -m is given */ /* -xpun (at least one) is required if -K is given */ /* -xa (at least one) is required if -S is given */ /* -q turns off -v */ "\0" "K:S:K--S:S--K:m?p:K?xpun:S?xa" IF_FEATURE_START_STOP_DAEMON_FANCY("q-v"), LONGOPTS &startas, &cmdname, &signame, &userspec, &chuid, &execname, &pidfile IF_FEATURE_START_STOP_DAEMON_FANCY(,&opt_N) /* We accept and ignore -R <param> / --retry <param> */ IF_FEATURE_START_STOP_DAEMON_FANCY(,NULL) ); if (opt & OPT_s) { signal_nr = get_signum(signame); if (signal_nr < 0) bb_show_usage(); } if (!(opt & OPT_a)) startas = execname; if (!execname) /* in case -a is given and -x is not */ execname = startas; if (execname) { G.execname_sizeof = strlen(execname) + 1; G.execname_cmpbuf = xmalloc(G.execname_sizeof + 1); } // IF_FEATURE_START_STOP_DAEMON_FANCY( // if (retry_arg) // retries = xatoi_positive(retry_arg); // ) //argc -= optind; argv += optind; if (userspec) { user_id = bb_strtou(userspec, NULL, 10); if (errno) user_id = xuname2uid(userspec); } /* Both start and stop need to know current processes */ do_procinit(); if (opt & CTX_STOP) { int i = do_stop(); return (opt & OPT_OKNODO) ? 0 : (i <= 0); } if (G.found_procs) { if (!QUIET) printf("%s is already running\n%u\n", execname, (unsigned)G.found_procs->pid); return !(opt & OPT_OKNODO); } #ifdef OLDER_VERSION_OF_X if (execname) xstat(execname, &G.execstat); #endif *--argv = startas; if (opt & OPT_BACKGROUND) { #if BB_MMU bb_daemonize(DAEMON_DEVNULL_STDIO + DAEMON_CLOSE_EXTRA_FDS + DAEMON_DOUBLE_FORK); /* DAEMON_DEVNULL_STDIO is superfluous - * it's always done by bb_daemonize() */ #else /* Daemons usually call bb_daemonize_or_rexec(), but SSD can do * without: SSD is not itself a daemon, it _execs_ a daemon. * The usual NOMMU problem of "child can't run indefinitely, * it must exec" does not bite us: we exec anyway. */ pid_t pid = xvfork(); if (pid != 0) { /* parent */ /* why _exit? the child may have changed the stack, * so "return 0" may do bad things */ _exit(EXIT_SUCCESS); } /* Child */ setsid(); /* detach from controlling tty */ /* Redirect stdio to /dev/null, close extra FDs */ bb_daemon_helper(DAEMON_DEVNULL_STDIO + DAEMON_CLOSE_EXTRA_FDS); #endif } if (opt & OPT_MAKEPID) { /* User wants _us_ to make the pidfile */ write_pidfile(pidfile); } if (opt & OPT_c) { struct bb_uidgid_t ugid; parse_chown_usergroup_or_die(&ugid, chuid); if (ugid.uid != (uid_t) -1L) { struct passwd *pw = xgetpwuid(ugid.uid); if (ugid.gid != (gid_t) -1L) pw->pw_gid = ugid.gid; /* initgroups, setgid, setuid: */ change_identity(pw); } else if (ugid.gid != (gid_t) -1L) { xsetgid(ugid.gid); setgroups(1, &ugid.gid); } } #if ENABLE_FEATURE_START_STOP_DAEMON_FANCY if (opt & OPT_NICELEVEL) { /* Set process priority */ int prio = getpriority(PRIO_PROCESS, 0) + xatoi_range(opt_N, INT_MIN/2, INT_MAX/2); if (setpriority(PRIO_PROCESS, 0, prio) < 0) { bb_perror_msg_and_die("setpriority(%d)", prio); } } #endif execvp(startas, argv); bb_perror_msg_and_die("can't execute '%s'", startas); }
//static uint8_t Vbuffer[7.0*5.6*3]; //AVDMGenericVideoStream *getFirstVideoFilter( void) // //_____________________________________________________________ void GUI_PlayAvi(bool forceStop) { uint32_t time_e, time_a = 0; uint32_t err = 0, acc = 0; uint32_t max; uint32_t framelen,flags; AVDMGenericVideoStream *filter; vids = 0, auds = 0, dauds = 0; // check we got everything... if (!avifileinfo) return; if((curframe+1)>= avifileinfo->nb_frames-1) { printf("No frame left\n"); return; } if (avifileinfo->fps1000 == 0) return; if (playing || forceStop) { stop_req = 1; return; } uint32_t priorityLevel; originalPriority = getpriority(PRIO_PROCESS, 0); prefs->get(PRIORITY_PLAYBACK,&priorityLevel); setpriority(PRIO_PROCESS, 0, ADM_getNiceValue(priorityLevel)); uint32_t played_frame=0; uint32_t remaining=avifileinfo->nb_frames-curframe; if(getPreviewMode()==ADM_PREVIEW_OUTPUT) { filter=getLastVideoFilter(curframe,remaining); } else { filter=getFirstVideoFilter(curframe,remaining ); } max=filter->getInfo()->nb_frames; // compute how much a frame lasts in ms one_frame = (uint32_t) floor(1000.*1000.*10. / filter->getInfo()->fps1000); err = one_frame % 10; one_frame /= 10; // Duration of a frame in ms, err =leftover in 1/10 ms // go to RealTime... printf("One frame : %lu, err=%lu ms\n", one_frame, err); // prepare 1st frame stop_req = 0; playing = 1; #ifdef HAVE_AUDIO ComputePreload(); #endif //renderStartPlaying(); // reset timer reference resetTime(); admPreview::deferDisplay(1,curframe); admPreview::update(played_frame); do { vids++; admPreview::displayNow(played_frame);; update_status_bar(); if (time_a == 0) time_a = getTime(0); // mark ! //printf("\n Rendering %lu frame\n",curframe); // read frame in chunk if((played_frame)>=(max-1)) { printf("\nEnd met (%lu / %lu )\n",played_frame,max); goto abort_play; } admPreview::update(played_frame+1);; curframe++; played_frame++; #ifdef HAVE_AUDIO FillAudio(); #endif time_e = getTime(1); acc += err; if (acc > 10) { acc -= 10; time_a++; } time_a += one_frame; // delta a is next frame time // time is is current time delta = time_a - time_e; if (delta <= 0) { //if(delta<-19) // allow 19 ms late without warning... // tick seems to be ~ 18 ms //printf("\n Late ....,due : %lu ms / found : %lu \n", // time_a,time_e); // a call to whatever sleep function will last at leat 10 ms // give some time to GTK } else { // a call to whatever sleep function will last at leat 10 ms // give some time to GTK if (delta > 10) GUI_Sleep(delta - 10); } // UI_purge(); if(getPreviewMode()==ADM_PREVIEW_SEPARATE ) { UI_purge(); UI_purge(); } } while (!stop_req); abort_play: // ___________________________________ // Flush buffer // go back to normal display mode //____________________________________ playing = 0; getFirstVideoFilter( ); admPreview::deferDisplay(0,0); UI_purge(); // Updated by expose ? admPreview::update(curframe); UI_purge(); update_status_bar(); #ifdef HAVE_AUDIO if (currentaudiostream) { if (wavbuf) ADM_dealloc(wavbuf); deleteAudioFilter(NULL); currentaudiostream->endDecompress(); AVDM_AudioClose(); } #endif // done. setpriority(PRIO_PROCESS, 0, originalPriority); };
NvResult CNvThreadingLinux::ThreadCreate(Handle *puThreadHandle, U32(*pFunc)(void *pParam), void *pParam, S32 sPriority) { // Assume invalid handle *puThreadHandle = NV_HANDLE_INVALID; // Allocate thread handle CNvThreadData *pThreadData = new CNvThreadData; if (!pThreadData) { return RESULT_OUT_OF_HANDLES; } #if (NV_PROFILE==1) getitimer(ITIMER_PROF, &pThreadData->profTimer); #endif // Store thread parameters pThreadData->pFunc = pFunc; pThreadData->pParam = pParam; pThreadData->pid = 0; // Query policy and priority from calling thread struct sched_param oSched; if (pthread_getschedparam(pthread_self(), &m_iSchedPolicy, &oSched) == 0) { // Set base priority from calling thread if (m_iSchedPolicy == SCHED_OTHER) m_iSchedPriorityBase = getpriority(PRIO_PROCESS, 0); else m_iSchedPriorityBase = oSched.sched_priority; // Set minimum and maximum priority limits m_iSchedPriorityMin = sched_get_priority_min(m_iSchedPolicy); m_iSchedPriorityMax = sched_get_priority_max(m_iSchedPolicy); if (m_iSchedPolicy == SCHED_OTHER) { m_iSchedPriorityMin = -20; // setpriority minimum m_iSchedPriorityMax = 19; // setpriority maximum } } // Initialize thread attributes pthread_attr_init(&pThreadData->thread_attr); // Always inherit scheduling! pthread_attr_setinheritsched(&pThreadData->thread_attr, PTHREAD_INHERIT_SCHED); // Create thread mutex and condition pthread_mutex_init(&pThreadData->mutex, NULL); pthread_cond_init(&pThreadData->condition, NULL); // Create actual thread and add to thread map if (pthread_create(&pThreadData->thread, &pThreadData->thread_attr, ThreadFunc, (void *)pThreadData)) { delete pThreadData; return RESULT_OUT_OF_HANDLES; } // Wait for thread initialization pthread_mutex_lock(&pThreadData->mutex); while (pThreadData->pid == 0) pthread_cond_wait(&pThreadData->condition, &pThreadData->mutex); pthread_mutex_unlock(&pThreadData->mutex); // Set thread priority ThreadPrioritySet(pThreadData, sPriority); // Return pThreadData as casting to Handle *puThreadHandle = reinterpret_cast<Handle>(pThreadData); return RESULT_OK; }
/// Launch the auth server extern int main(int argc, char** argv) { // Command line parsing to get the configuration file name char const* configFile = _TRINITY_REALM_CONFIG; int count = 1; while (count < argc) { if (strcmp(argv[count], "-c") == 0) { if (++count >= argc) { printf("Runtime-Error: -c option requires an input argument\n"); usage(argv[0]); return 1; } else configFile = argv[count]; } ++count; } if (!sConfigMgr->LoadInitial(configFile)) { printf("Invalid or missing configuration file : %s\n", configFile); printf("Verify that the file exists and has \'[authserver]\' written in the top of the file!\n"); return 1; } sLog->outString("%s (authserver)", _FULLVERSION); sLog->outString("<Ctrl-C> to stop.\n"); sLog->outString(" ░ ░"); sLog->outString(" ▄▓▄ ░ ░░░▄▄▄▄▄▄▄▄▄▄░░░░ ░"); sLog->outString(" ▀ ░ ░ ▄▄▄██▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▄▄▄ ░ ░"); sLog->outString(" ▄▄▄██████▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓██████▄▄▄"); sLog->outString(" ▄███▀▀ ▄██▓▓▓▓█████▓▓▓▓▓▓█████▓▓▓▓▓█▄ ▀▀███▄░"); sLog->outString(" ▓█▓ ░ ▀████████████▓▓████████████▀ ░ ░▓█▓░"); sLog->outString(" ▓██▌ ░░ ▒ ▀▀▀██████▓▓▓███████▀▀▀ ▒ ░ ▐██▓░"); sLog->outString(" ▐██▄░░░ ▓▓ ▀▀███▓████▀▀ ▓▓ ░░▄██▌"); sLog->outString(" ░▀██▌ ░░ ▀██▄ ░░ ▄▒█▄ ▄██▀ ░░░▐██▀░"); sLog->outString(" ▄▒▒▒▄▀█▄▄ ░░░░ ░░▄▄▄▓▓▓█▓▓▓▄▄▄▄░░ ░░░ ▄▄▓▀▄▒▒▄▄"); sLog->outString(" ▐▓▓▓▓▓███████▄▄▄▄█▒▓▓▓▓▓███████▓▓▓▓▒▒▒▒▄▄▄▄███████▓▓▓▓▓▌"); sLog->outString(" ░▓█▓▓█████████████████████▀▀ ▀▀▀█████▓▓▓▓▓████████████▓▓▓ ░"); sLog->outString(" ▐█▓▓▓█████▓▓▓█████▓███▀░ ▄▓▄ ░▀████▓██████████████▓▓▌"); sLog->outString(" ▀▀█▒▒▓▓▓▓▀▀░ ▀▀▀██▓█▌░ ░▓█▓██▄ ░▐██▓▓█▀▀▀ ▀▀██▓▓▓▒▒▀▀"); sLog->outString(" ▀ ░░ ▄ ▒█▓▓▓█▄ ▐██▓██▌░▄███▓▓█▒ ▄ ▄ ▀ ░"); sLog->outString(" ▄ ▄ ▄ ▄▄▄▄▄▄▀█▄ ░▓█▓▓▓████▄█▓▓▓█▄██████▓▓█▓░ ▄█▀█▄▄▄▄▄ ▄ ▄ ▄"); sLog->outString(" ▄ ▄ ▄ ▄▄▄▄▄▄▀▄▄ ▀█▓▓▓████████▓██████████▓▓█▀ ▄▄▀▄▄▄▄▄▄ ▄ ▄ ▄"); sLog->outString(" █▀█ ▒▄ ▄▀▀▀▀▀████▓▓████▀▀▀▀▀▄ ▄▒ █▀█"); sLog->outString(" ▓ ▓ ░▓█▓▐██▀▄▄▄ ▄▄ ▄▄▄ ▄▄▄▀▓█▌▓█▓░ ▓ ▓"); sLog->outString(" ▒ ▒ ▐█▒ ▐▓░ ▐▓░ ▐▓░▐█▌ ░▓▌ ▒▌ ▒█▌ ▒ ▒"); sLog->outString(" ░ ░ ▀ ▀ ▄ ▀ ▄ ▀▄ ▀ ▄ ▀ ▄ ▀ ▀ ░ ░"); sLog->outString(" ░ ░ ▀ ░▀ ▀▀ ▀▀▀ ▀░ ▀ ░ ░"); sLog->outString(" ░ ░ ▀▓▓▓▓██████▓▓▀ ░ ░"); sLog->outString(" ReinsCoreWotlk 2016(c) Open-sourced Game Emulation "); sLog->outString(" <https://github.com/ReinsCoreWotlk/Core> ReinsCoreWotlk 3.3.5 "); sLog->outString("Using configuration file %s.", configFile); sLog->outDetail("%s (Library: %s)", OPENSSL_VERSION_TEXT, SSLeay_version(SSLEAY_VERSION)); #if defined (ACE_HAS_EVENT_POLL) || defined (ACE_HAS_DEV_POLL) ACE_Reactor::instance(new ACE_Reactor(new ACE_Dev_Poll_Reactor(ACE::max_handles(), 1), 1), true); #else ACE_Reactor::instance(new ACE_Reactor(new ACE_TP_Reactor(), true), true); #endif sLog->outBasic("Max allowed open files is %d", ACE::max_handles()); // authserver PID file creation std::string pidFile = sConfigMgr->GetStringDefault("PidFile", ""); if (!pidFile.empty()) { if (uint32 pid = CreatePIDFile(pidFile)) sLog->outError("Daemon PID: %u\n", pid); else { sLog->outError("Cannot create PID file %s.\n", pidFile.c_str()); return 1; } } // Initialize the database connection if (!StartDB()) return 1; // Initialize the log database sLog->SetLogDB(false); sLog->SetRealmID(0); // ensure we've set realm to 0 (authserver realmid) // Get the list of realms for the server sRealmList->Initialize(sConfigMgr->GetIntDefault("RealmsStateUpdateDelay", 20)); if (sRealmList->size() == 0) { sLog->outError("No valid realms specified."); return 1; } // Launch the listening network socket RealmAcceptor acceptor; int32 rmport = sConfigMgr->GetIntDefault("RealmServerPort", 3724); if (rmport < 0 || rmport > 0xFFFF) { sLog->outError("Specified port out of allowed range (1-65535)"); return 1; } std::string bind_ip = sConfigMgr->GetStringDefault("BindIP", "0.0.0.0"); ACE_INET_Addr bind_addr(uint16(rmport), bind_ip.c_str()); if (acceptor.open(bind_addr, ACE_Reactor::instance(), ACE_NONBLOCK) == -1) { sLog->outError("Auth server can not bind to %s:%d", bind_ip.c_str(), rmport); return 1; } // Initialize the signal handlers AuthServerSignalHandler SignalINT, SignalTERM; // Register authservers's signal handlers ACE_Sig_Handler Handler; Handler.register_handler(SIGINT, &SignalINT); Handler.register_handler(SIGTERM, &SignalTERM); #if defined(_WIN32) || defined(__linux__) ///- Handle affinity for multiple processors and process priority uint32 affinity = sConfigMgr->GetIntDefault("UseProcessors", 0); bool highPriority = sConfigMgr->GetBoolDefault("ProcessPriority", false); #ifdef _WIN32 // Windows HANDLE hProcess = GetCurrentProcess(); if (affinity > 0) { ULONG_PTR appAff; ULONG_PTR sysAff; if (GetProcessAffinityMask(hProcess, &appAff, &sysAff)) { // remove non accessible processors ULONG_PTR currentAffinity = affinity & appAff; if (!currentAffinity) sLog->outError("server.authserver", "Processors marked in UseProcessors bitmask (hex) %x are not accessible for the authserver. Accessible processors bitmask (hex): %x", affinity, appAff); else if (SetProcessAffinityMask(hProcess, currentAffinity)) sLog->outString("server.authserver", "Using processors (bitmask, hex): %x", currentAffinity); else sLog->outError("server.authserver", "Can't set used processors (hex): %x", currentAffinity); } } if (highPriority) { if (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS)) sLog->outString("server.authserver", "authserver process priority class set to HIGH"); else sLog->outError("server.authserver", "Can't set authserver process priority class."); } #else // Linux if (affinity > 0) { cpu_set_t mask; CPU_ZERO(&mask); for (unsigned int i = 0; i < sizeof(affinity) * 8; ++i) if (affinity & (1 << i)) CPU_SET(i, &mask); if (sched_setaffinity(0, sizeof(mask), &mask)) sLog->outError("server.authserver", "Can't set used processors (hex): %x, error: %s", affinity, strerror(errno)); else { CPU_ZERO(&mask); sched_getaffinity(0, sizeof(mask), &mask); sLog->outString("server.authserver", "Using processors (bitmask, hex): %lx", *(__cpu_mask*)(&mask)); } } if (highPriority) { if (setpriority(PRIO_PROCESS, 0, PROCESS_HIGH_PRIORITY)) sLog->outError("server.authserver", "Can't set authserver process priority class, error: %s", strerror(errno)); else sLog->outString("server.authserver", "authserver process priority class set to %i", getpriority(PRIO_PROCESS, 0)); } #endif #endif // maximum counter for next ping uint32 numLoops = (sConfigMgr->GetIntDefault("MaxPingTime", 30) * (MINUTE * 1000000 / 100000)); uint32 loopCounter = 0; // possibly enable db logging; avoid massive startup spam by doing it here. if (sConfigMgr->GetBoolDefault("EnableLogDB", false)) { sLog->outString("Enabling database logging..."); sLog->SetLogDB(true); } // Wait for termination signal while (!stopEvent) { // dont move this outside the loop, the reactor will modify it ACE_Time_Value interval(0, 100000); if (ACE_Reactor::instance()->run_reactor_event_loop(interval) == -1) break; if ((++loopCounter) == numLoops) { loopCounter = 0; sLog->outDetail("Ping MySQL to keep connection alive"); LoginDatabase.KeepAlive(); } } // Close the Database Pool and library StopDB(); sLog->outString("Halting process..."); return 0; }
void ps_instance_dump(int pid) { char statline[BUFFERSIZE*2]; struct stat stats; process_info psinfo; FILE *ps; struct passwd *pw; int n; memset(&psinfo, 0, sizeof(process_info)); psinfo.pid = pid; snprintf(statline, BUFFERSIZE*2, "/proc/%d", pid); stat(statline, &stats); psinfo.uid = (int) stats.st_uid; pw = getpwuid(stats.st_uid); if(pw == 0) { snprintf(psinfo.owner, 80, "%d", (int)stats.st_uid); } else { strncpy(psinfo.owner, pw->pw_name, 80); } snprintf(statline, BUFFERSIZE*2, "/proc/%d/stat", pid); ps = fopen(statline, "r"); if (ps != 0) { /* Scan rest of string. */ fscanf(ps, "%*d %*s %c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d " "%lu %lu %*d %*d %*d %*d %d %*lu %lu %*lu %ld", &psinfo.status, &psinfo.delta_utime, &psinfo.delta_stime, &psinfo.threadnum, &psinfo.start_time, &psinfo.rss); fclose(ps); } snprintf(statline, BUFFERSIZE*2, "/proc/%d/cmdline", pid); ps = fopen(statline, "r"); if(ps == 0) { n = 0; } else { n = fread(psinfo.name, 1, 80, ps); fclose(ps); if(n < 0) n = 0; } psinfo.name[n] = 0; if(strlen(psinfo.name) == 0) { snprintf(statline, BUFFERSIZE*2, "/proc/%d/stat", pid); ps = fopen(statline, "r"); if(ps!= 0) { n = fscanf(ps, "%d (%s)", &pid, psinfo.name); fclose(ps); if(n == 2) psinfo.name[strlen(psinfo.name)-1] = 0; } } psinfo.nice = getpriority(PRIO_PROCESS, psinfo.pid); if(filter_by_system == 1) { if((strcmp(psinfo.owner, "root") != 0) && (strstr(psinfo.name, "/system/") == 0) && (strstr(psinfo.name, "/sbin/") == 0)) ps_list_add(&psinfo); else ps_system_add(&psinfo); } else { ps_list_add(&psinfo); } }
// deliver data that is already available void datacloud::deliverdata(databuf *hfield,databuf *texture,databuf *fogmap,BOOLINT immediate,int *col,int *row,int *hlod,int *tlod) { float prio,p; jobqueueelem *job,*scan; BOOLINT isavailable; // start periodical tasks if (!immediate) { if (!DELIVERED) { // delete delayed jobs deletedelayedjobs(); // delete delayed tiles deletedelayedtiles(); // delete expired tiles deleteexpiredtiles(); // shrink cache to maximum allowed size shrinkcache(MAXSIZE*1024*1024); } // load pending tiles in the background startthread(); } // check deferred data delivery if (!immediate) if (DELIVERED) // stop deferred data delivery if time is up if (gettime()-DELIVERYSTART>TIMESLOT) { DELIVERED=FALSE; return; } // scan jobs if (!immediate) { prio=0.0f; job=NULL; scan=JOBQUEUETAIL; while (scan!=NULL) { p=0.0f; isavailable=TRUE; // check the availability of all required maps: if (scan->hfield!=NULL) if (!scan->hfield->isavailable) isavailable=FALSE; else p=getpriority(scan->hfield); if (scan->texture!=NULL) if (!scan->texture->isavailable) isavailable=FALSE; if (scan->fogmap!=NULL) if (!scan->fogmap->isavailable) isavailable=FALSE; // check the priority of the job if (isavailable && p>=prio) { prio=p; job=scan; } scan=scan->prev; } } else job=JOBQUEUE; // deferred data delivery if (job!=NULL) { // return maps if (job->hfield!=NULL) *hfield=*(job->hfield->tile); if (job->texture!=NULL) *texture=*(job->texture->tile); if (job->fogmap!=NULL) *fogmap=*(job->fogmap->tile); // return tile position if (col!=NULL) *col=job->col; if (row!=NULL) *row=job->row; // return level of detail if (hlod!=NULL) *hlod=job->hlod; if (tlod!=NULL) *tlod=job->tlod; // check for immediate delivery if (immediate) DELIVERED=FALSE; // remember starting time of deferred delivery else if (!DELIVERED) { DELIVERED=TRUE; DELIVERYSTART=gettime(); } // remove finished job from queue deletejob(job); } else DELIVERED=FALSE; }
uint8_t AVDMGenericAudioStream::buildAudioTimeLine(void) { uint32_t in,d=0,rd=0,ms10,offset=0,index=0; //,left=0,len=0;; uint32_t retry=50; // we do nothing in case of WAV or unhandler stream // that left only MP3 for now ... if (_wavheader->encoding != WAV_MP3 &&_wavheader->encoding != WAV_MP2 ) { return 0; } // in case of mpeg3 we will build a pseudo memory map // one tick is 10 ms // 100*3600*2*4= 360*8*1000=3000 000= 3 meg // for a 2 hour movie // should be acceptable uint32_t originalPriority = getpriority(PRIO_PROCESS, 0); uint32_t priorityLevel; prefs->get(PRIORITY_INDEXING,&priorityLevel); setpriority(PRIO_PROCESS, 0, ADM_getNiceValue(priorityLevel)); goTo(0); //rewind printf("\n scanning timeline\n"); // ms10 is the raw length of 10 ms of uncompressed audio // in sample ms10=_wavheader->frequency/100; if (_audioMap) delete[] _audioMap; _audioMap=new ST_point[100*3600*4]; // 4 hours / 6 Megs ADM_assert(_audioMap); DIA_working *work; work=new DIA_working(QT_TR_NOOP("Building VBR map")); goTo(0); uint32_t Mul=2*_wavheader->channels; uint32_t len,sample; while(offset<_length) { work->update(offset,_length); if(!work->isAlive()) { delete work; work=new DIA_working(QT_TR_NOOP("Building VBR map")); work->update(offset,_length); } // read a packet if(!getPacket(internalBuffer, &len,&sample)) { if(!index && retry) { retry--; continue; } printf("MapVBR:Get packet failed\n"); break; } offset+=len; rd += sample*Mul; _audioMap[index].foffset=offset; _audioMap[index++].woffset=rd; } end: setpriority(PRIO_PROCESS, 0, originalPriority); if(!index) { delete [] _audioMap; _audioMap=NULL; _wavheader->blockalign=1152; // Mark it as VBR delete work; goTo(0); // Purge printf("Build VBR failed!\n"); return 0; } _nbMap=index; _wavheader->blockalign=1152; // Mark it as VBR printf("\n Nb entries in timeline : %lu\n",_nbMap); delete work; goTo(0); // Purge return 1; }
/// Main function int Master::Run() { OpenSSLCrypto::threadsSetup(); BigNumber seed1; seed1.SetRand(16 * 8); TC_LOG_INFO("server.worldserver", "%s (worldserver-daemon)", _FULLVERSION); TC_LOG_INFO("server.worldserver", " "); TC_LOG_INFO("server.worldserver", " A World of Warcraft Cataclsym 4.3.4 Emulator "); TC_LOG_INFO("server.worldserver", " _/_/ _/ _/_/_/ _/_/ _/_/_/ _/_/_/_/ "); TC_LOG_INFO("server.worldserver", " _/ _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/ "); TC_LOG_INFO("server.worldserver", " _/_/_/_/ _/_/ _/_/ _/ _/ _/ _/_/_/ _/_/_/ "); TC_LOG_INFO("server.worldserver", " _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ "); TC_LOG_INFO("server.worldserver", " _/ _/ _/ _/ _/ _/_/_/ _/_/ _/ _/ _/_/_/_/ NG "); TC_LOG_INFO("server.worldserver", " Arkania Community (c) 2017! <http://arkania.net/> "); TC_LOG_INFO("server.worldserver", " "); TC_LOG_INFO("server.worldserver", "<Ctrl-C> to stop.\n"); /// worldserver PID file creation std::string pidFile = sConfigMgr->GetStringDefault("PidFile", ""); if (!pidFile.empty()) { if (uint32 pid = CreatePIDFile(pidFile)) TC_LOG_INFO("server.worldserver", "Daemon PID: %u\n", pid); else { TC_LOG_ERROR("server.worldserver", "Cannot create PID file %s.\n", pidFile.c_str()); return 1; } } ///- Start the databases if (!_StartDB()) return 1; // set server offline (not connectable) LoginDatabase.DirectPExecute("UPDATE realmlist SET flag = (flag & ~%u) | %u WHERE id = '%d'", REALM_FLAG_OFFLINE, REALM_FLAG_INVALID, realmID); ///- Initialize the World sWorld->SetInitialWorldSettings(); ///- Initialize the signal handlers WorldServerSignalHandler signalINT, signalTERM; #ifdef _WIN32 WorldServerSignalHandler signalBREAK; #endif /* _WIN32 */ ///- Register worldserver's signal handlers ACE_Sig_Handler handle; handle.register_handler(SIGINT, &signalINT); handle.register_handler(SIGTERM, &signalTERM); #ifdef _WIN32 handle.register_handler(SIGBREAK, &signalBREAK); #endif ///- Launch WorldRunnable thread ACE_Based::Thread worldThread(new WorldRunnable); worldThread.setPriority(ACE_Based::Highest); ACE_Based::Thread* cliThread = nullptr; #ifdef _WIN32 if (sConfigMgr->GetBoolDefault("Console.Enable", true) && (m_ServiceStatus == -1)/* need disable console in service mode*/) #else if (sConfigMgr->GetBoolDefault("Console.Enable", true)) #endif { ///- Launch CliRunnable thread cliThread = new ACE_Based::Thread(new CliRunnable); } ACE_Based::Thread rarThread(new RARunnable); #if defined(_WIN32) || defined(__linux__) ///- Handle affinity for multiple processors and process priority uint32 affinity = sConfigMgr->GetIntDefault("UseProcessors", 0); bool highPriority = sConfigMgr->GetBoolDefault("ProcessPriority", false); #ifdef _WIN32 // Windows HANDLE hProcess = GetCurrentProcess(); if (affinity > 0) { ULONG_PTR appAff; ULONG_PTR sysAff; if (GetProcessAffinityMask(hProcess, &appAff, &sysAff)) { ULONG_PTR currentAffinity = affinity & appAff; // remove non accessible processors if (!currentAffinity) TC_LOG_ERROR("server.worldserver", "Processors marked in UseProcessors bitmask (hex) %x are not accessible for the worldserver. Accessible processors bitmask (hex): %x", affinity, appAff); else if (SetProcessAffinityMask(hProcess, currentAffinity)) TC_LOG_INFO("server.worldserver", "Using processors (bitmask, hex): %x", currentAffinity); else TC_LOG_ERROR("server.worldserver", "Can't set used processors (hex): %x", currentAffinity); } } if (highPriority) { if (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS)) TC_LOG_INFO("server.worldserver", "worldserver process priority class set to HIGH"); else TC_LOG_ERROR("server.worldserver", "Can't set worldserver process priority class."); } #else // Linux if (affinity > 0) { cpu_set_t mask; CPU_ZERO(&mask); for (unsigned int i = 0; i < sizeof(affinity) * 8; ++i) if (affinity & (1 << i)) CPU_SET(i, &mask); if (sched_setaffinity(0, sizeof(mask), &mask)) TC_LOG_ERROR("server.worldserver", "Can't set used processors (hex): %x, error: %s", affinity, strerror(errno)); else { CPU_ZERO(&mask); sched_getaffinity(0, sizeof(mask), &mask); TC_LOG_INFO("server.worldserver", "Using processors (bitmask, hex): %lx", *(__cpu_mask*)(&mask)); } } if (highPriority) { if (setpriority(PRIO_PROCESS, 0, PROCESS_HIGH_PRIORITY)) TC_LOG_ERROR("server.worldserver", "Can't set worldserver process priority class, error: %s", strerror(errno)); else TC_LOG_INFO("server.worldserver", "worldserver process priority class set to %i", getpriority(PRIO_PROCESS, 0)); } #endif #endif //Start soap serving thread ACE_Based::Thread* soapThread = nullptr; if (sConfigMgr->GetBoolDefault("SOAP.Enabled", false)) { TCSoapRunnable* runnable = new TCSoapRunnable(); runnable->SetListenArguments(sConfigMgr->GetStringDefault("SOAP.IP", "127.0.0.1"), uint16(sConfigMgr->GetIntDefault("SOAP.Port", 7878))); soapThread = new ACE_Based::Thread(runnable); } ///- Start up freeze catcher thread if (uint32 freezeDelay = sConfigMgr->GetIntDefault("MaxCoreStuckTime", 0)) { FreezeDetectorRunnable* fdr = new FreezeDetectorRunnable(); fdr->SetDelayTime(freezeDelay * 1000); ACE_Based::Thread freezeThread(fdr); freezeThread.setPriority(ACE_Based::Highest); } ///- Launch the world listener socket uint16 worldPort = uint16(sWorld->getIntConfig(CONFIG_PORT_WORLD)); std::string bindIp = sConfigMgr->GetStringDefault("BindIP", "0.0.0.0"); if (sWorldSocketMgr->StartNetwork(worldPort, bindIp.c_str()) == -1) { TC_LOG_ERROR("server.worldserver", "Failed to start network"); World::StopNow(ERROR_EXIT_CODE); // go down and shutdown the server } // set server online (allow connecting now) LoginDatabase.DirectPExecute("UPDATE realmlist SET flag = flag & ~%u, population = 0 WHERE id = '%u'", REALM_FLAG_INVALID, realmID); TC_LOG_INFO("server.worldserver", "%s (worldserver-daemon) ready...", _FULLVERSION); #ifdef _DEBUG ASSERT(false); // my debugging stop #endif // when the main thread closes the singletons get unloaded // since worldrunnable uses them, it will crash if unloaded after master worldThread.wait(); rarThread.wait(); if (soapThread) { soapThread->wait(); soapThread->destroy(); delete soapThread; } // set server offline LoginDatabase.DirectPExecute("UPDATE realmlist SET flag = flag | %u WHERE id = '%d'", REALM_FLAG_OFFLINE, realmID); ///- Clean database before leaving ClearOnlineAccounts(); _StopDB(); TC_LOG_INFO("server.worldserver", "Halting process..."); if (cliThread) { #ifdef _WIN32 // this only way to terminate CLI thread exist at Win32 (alt. way exist only in Windows Vista API) //_exit(1); // send keyboard input to safely unblock the CLI thread INPUT_RECORD b[4]; HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE); b[0].EventType = KEY_EVENT; b[0].Event.KeyEvent.bKeyDown = TRUE; b[0].Event.KeyEvent.uChar.AsciiChar = 'X'; b[0].Event.KeyEvent.wVirtualKeyCode = 'X'; b[0].Event.KeyEvent.wRepeatCount = 1; b[1].EventType = KEY_EVENT; b[1].Event.KeyEvent.bKeyDown = FALSE; b[1].Event.KeyEvent.uChar.AsciiChar = 'X'; b[1].Event.KeyEvent.wVirtualKeyCode = 'X'; b[1].Event.KeyEvent.wRepeatCount = 1; b[2].EventType = KEY_EVENT; b[2].Event.KeyEvent.bKeyDown = TRUE; b[2].Event.KeyEvent.dwControlKeyState = 0; b[2].Event.KeyEvent.uChar.AsciiChar = '\r'; b[2].Event.KeyEvent.wVirtualKeyCode = VK_RETURN; b[2].Event.KeyEvent.wRepeatCount = 1; b[2].Event.KeyEvent.wVirtualScanCode = 0x1c; b[3].EventType = KEY_EVENT; b[3].Event.KeyEvent.bKeyDown = FALSE; b[3].Event.KeyEvent.dwControlKeyState = 0; b[3].Event.KeyEvent.uChar.AsciiChar = '\r'; b[3].Event.KeyEvent.wVirtualKeyCode = VK_RETURN; b[3].Event.KeyEvent.wVirtualScanCode = 0x1c; b[3].Event.KeyEvent.wRepeatCount = 1; DWORD numb; WriteConsoleInput(hStdIn, b, 4, &numb); cliThread->wait(); #else cliThread->destroy(); #endif delete cliThread; } // for some unknown reason, unloading scripts here and not in worldrunnable // fixes a memory leak related to detaching threads from the module //UnloadScriptingModule(); OpenSSLCrypto::threadsCleanup(); // Exit the process with specified return value return World::GetExitCode(); }
/** Rebuild frame type by actually decoding them to all videos loaded Use hurry_up flag if the codec is able to do it. */ uint8_t ADM_Composer::rebuildFrameType ( void) { _VIDEOS *vi; uint32_t frames=0,cur=0; uint8_t *compBuffer=NULL; //uint8_t *prepBuffer=NULL; ADMImage *prepBuffer=NULL; ADMImage *prepBufferNoCopy=NULL; ADMImage *tmpImage=NULL; uint32_t bframe; aviInfo info; if(!_nb_video) { GUI_Error_HIG(QT_TR_NOOP("No video loaded"), NULL); return 0; } if(!isIndexable()) { GUI_Error_HIG(QT_TR_NOOP("Not indexable"),QT_TR_NOOP( "DivX 5 + packed?")); return 0; } uint32_t originalPriority = getpriority(PRIO_PROCESS, 0); uint32_t priorityLevel; prefs->get(PRIORITY_INDEXING,&priorityLevel); setpriority(PRIO_PROCESS, 0, ADM_getNiceValue(priorityLevel)); vi=&(_videos[0]); vi->_aviheader->getVideoInfo (&info); compBuffer=new uint8_t[(info.width * info.height * 3)>>1]; ADM_assert(compBuffer); prepBuffer=new ADMImage(info.width ,info.height); prepBufferNoCopy=new ADMImage(info.width ,info.height); ADMCompressedImage img; img.data=compBuffer; ADM_assert(prepBuffer); ADM_assert(prepBufferNoCopy); for(uint32_t i=0;i<_nb_video;i++) { frames+=_videos[i]._nb_video_frames; } DIA_working *work; uint8_t nocopy; work=new DIA_working(QT_TR_NOOP("Rebuilding Frames")); for(uint32_t vid=0;vid<_nb_video;vid++) { // set the decoder in fast mode vi=&(_videos[vid]); vi->_aviheader->getVideoInfo (&info); nocopy=vi->decoder->dontcopy(); if(nocopy) tmpImage=prepBufferNoCopy; else tmpImage=prepBuffer; bframe=0; if(vi->_reorderReady) { cur+=vi->_nb_video_frames; } else { vi->decoder->decodeHeaderOnly(); for(uint32_t j=0;j<vi->_nb_video_frames;j++) { vi->_aviheader->getFrameNoAlloc (j,&img); if(img.dataLength) { vi->decoder->uncompress (&img, tmpImage); } else tmpImage->flags=0; vi->_aviheader->setFlag(j,tmpImage->flags); if(tmpImage->flags & AVI_B_FRAME) bframe++; if(work->update(cur, frames)) { delete work; vi->decoder->decodeFull(); GUI_Error_HIG(QT_TR_NOOP("Aborted"), NULL); delete [] compBuffer; delete prepBuffer; delete prepBufferNoCopy; setpriority(PRIO_PROCESS, 0, originalPriority); return 0; } cur++; } vi->decoder->decodeFull(); // and there is b-frame if(bframe) { vi->_reorderReady=vi->_aviheader->reorder(); } } } delete work; delete [] compBuffer; delete prepBuffer; delete prepBufferNoCopy; setpriority(PRIO_PROCESS, 0, originalPriority); return 1; }
PUBLIC IxPerfProfAccStatus ixPerfProfAccXcycleBaselineRun( UINT32 *numBaselineCycle) { int i, priority ; /* task priority. Value is OS dependent */ UINT32 interruptLockKey; UINT32 temp, startTime, /* used to store start time */ stopTime, /* used to store stop time */ duration; /* difference between stop and start time */ #ifdef __vxworks IxOsalThread threadId; IX_STATUS result; #endif /*error check the parameter*/ if (NULL == numBaselineCycle) { /* report the error */ IX_PERFPROF_ACC_LOG( IX_OSAL_LOG_LVL_ERROR, IX_OSAL_LOG_DEV_STDERR, "ixPerfProfAccXcycleBaselineRun - numBaselineCycle is invalid\n", 0, 0, 0, 0, 0, 0); /* return error */ return IX_PERFPROF_ACC_STATUS_FAIL; } if (IX_PERFPROF_ACC_STATUS_ANOTHER_UTIL_IN_PROGRESS == ixPerfProfAccLock()) { return IX_PERFPROF_ACC_STATUS_ANOTHER_UTIL_IN_PROGRESS; } /* * If the tool is running, then do not allow baselining to progress */ if (ixPerfProfAccXcycleMeasurementInProgress) { ixPerfProfAccUnlock(); return IX_PERFPROF_ACC_STATUS_XCYCLE_MEASUREMENT_IN_PROGRESS; } /* * Find out how many loops is needed to to complete * 1/IX_PERFPROF_ACC_XCYCLE_TIME_SLICES_PER_SEC seconds */ ixNumLoopPerTimeSlice= ixPerfProfAccXcycleComputeLoopsPerSlice(); /* * Disable interrupts so that no ISR can run. We get all the CPU * cycles. */ interruptLockKey = ixOsalIrqLock(); #ifdef __linuxapp priority = getpriority(PRIO_PROCESS,0); if(0 != setpriority( PRIO_PROCESS, 0, IX_PERFPROF_ACC_XCYCLE_LINUXAPP_PRIORITY_HIGHEST ) ) { ixPerfProfAccUnlock(); return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL; } #else result = ixOsalThreadIdGet (&threadId); if (IX_SUCCESS != result) { ixPerfProfAccUnlock(); return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL; } taskPriorityGet (threadId, &priority); result = ixOsalThreadPrioritySet ( &threadId, IX_PERFPROF_ACC_XCYCLE_VXWORKS_PRIORITY_HIGHEST ); if (IX_SUCCESS != result) { return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL; } #endif /* * Perform a measure of time needed for one measurement without * load. */ startTime = ixPerfProfAccXcycleApbTimerGet(); for (i = 0; IX_PERFPROF_ACC_XCYCLE_TIME_SLICES_PER_SEC > i; i++) { temp = ixNumLoopPerTimeSlice; ixPerfProfAccXcycleLoopIter(temp); } stopTime = ixPerfProfAccXcycleApbTimerGet(); /* * Rollover situation is handled through the fact that the different * between start and stop time is a fraction of 32bit storage * The duration of time stored in 32 bits is 65 sec * We expect difference between start and stop time to be * ~ 1 sec */ duration = stopTime - startTime; ixOsalIrqUnlock(interruptLockKey); #ifdef __linuxapp if(setpriority(PRIO_PROCESS, 0, priority) != 0) { ixPerfProfAccUnlock(); return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_RESTORE_FAIL; } #else /* ifdef __linuxapp */ /* * Restore the calling thread to previous priority */ result = ixOsalThreadPrioritySet (&threadId, priority); if (IX_SUCCESS != result) { ixPerfProfAccUnlock(); return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_RESTORE_FAIL; } #endif /* ifdef __linuxapp */ ixPerfProfAccXcycleCurrentBaseline = duration; *numBaselineCycle = duration; ixPerfProfAccUnlock(); return IX_PERFPROF_ACC_STATUS_SUCCESS ; } /* end of ixPerfProfAccXcycleBaselineRun() */
void *http_server (void *arg) { int rc; /* Return code */ int lsock; /* Socket for listening */ int csock; /* Socket for conversation */ struct sockaddr_in server; /* Server address structure */ fd_set selset; /* Read bit map for select */ int optval; /* Argument for setsockopt */ TID httptid; /* Negotiation thread id */ struct timeval timeout; /* timeout value */ UNREFERENCED(arg); http_serv.httpshutdown = TRUE; hdl_adsc("http_shutdown",http_shutdown, NULL); /* Set root mode in order to set priority */ SETMODE(ROOT); /* Set server thread priority; ignore any errors */ if(setpriority(PRIO_PROCESS, 0, sysblk.srvprio)) WRMSG(HHC00136, "W", "setpriority()", strerror(errno)); /* Back to user mode */ SETMODE(USER); /* Display thread started message on control panel */ WRMSG (HHC00100, "I", (u_long)thread_id(), getpriority(PRIO_PROCESS,0), "HTTP server"); /* make sure root path is built */ if ( http_root() == NULL ) goto http_server_stop; /* Obtain a socket */ lsock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); if (lsock < 0) { WRMSG(HHC01800,"E", "socket()", strerror(HSO_errno)); goto http_server_stop; } /* Allow previous instance of socket to be reused */ optval = 1; setsockopt (lsock, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, sizeof(optval)); /* Prepare the sockaddr structure for the bind */ memset (&server, 0, sizeof(server)); server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = http_serv.httpport; server.sin_port = htons(server.sin_port); http_serv.httpbinddone = FALSE; /* Attempt to bind the socket to the port */ while (TRUE) { rc = bind (lsock, (struct sockaddr *)&server, sizeof(server)); if (rc == 0 || HSO_errno != HSO_EADDRINUSE) break; WRMSG(HHC01804, "W", http_serv.httpport); SLEEP(10); } /* end while */ if (rc != 0) { WRMSG(HHC01800,"E", "bind()", strerror(HSO_errno)); goto http_server_stop; } else http_serv.httpbinddone = TRUE; /* Put the socket into listening state */ rc = listen (lsock, 32); if (rc < 0) { WRMSG(HHC01800,"E", "listen()", strerror(HSO_errno)); http_serv.httpbinddone = FALSE; goto http_server_stop; } http_serv.httpshutdown = FALSE; WRMSG(HHC01803, "I", http_serv.httpport); /* Handle http requests */ while ( !http_serv.httpshutdown ) { /* Initialize the select parameters */ FD_ZERO (&selset); FD_SET (lsock, &selset); timeout.tv_sec = 0; timeout.tv_usec = 10000; /* until a better way to implement this use standard windows */ #undef select /* Wait for a file descriptor to become ready use NON-BLOCKING select()*/ rc = select ( lsock+1, &selset, NULL, NULL, &timeout ); if ( rc == 0 || http_serv.httpshutdown ) continue; if (rc < 0 ) { if (HSO_errno == HSO_EINTR) continue; WRMSG(HHC01800, "E", "select()", strerror(HSO_errno)); break; } /* If a http request has arrived then accept it */ if (FD_ISSET(lsock, &selset)) { /* Accept the connection and create conversation socket */ csock = accept (lsock, NULL, NULL); if (csock < 0) { WRMSG(HHC01800, "E", "accept()", strerror(HSO_errno)); continue; } /* Create a thread to execute the http request */ rc = create_thread (&httptid, DETACHED, http_request, (void *)(uintptr_t)csock, "http_request"); if(rc) { WRMSG(HHC00102, "E", strerror(rc)); close_socket (csock); } } /* end if(lsock) */ } /* end while */ /* Close the listening socket */ close_socket (lsock); http_server_stop: if ( !sysblk.shutdown ) hdl_rmsc(http_shutdown, NULL); /* Display thread started message on control panel */ WRMSG(HHC00101, "I", (u_long)thread_id(), getpriority(PRIO_PROCESS,0), "HTTP server"); sysblk.httptid = 0; http_serv.httpbinddone = FALSE; signal_condition(&http_serv.http_wait_shutdown); return NULL; } /* end function http_server */
PUBLIC IxPerfProfAccStatus ixPerfProfAccXcycleStart (UINT32 numMeasurementsRequested) { #ifdef __linuxapp UINT32 result; /* result of thread creation */ int priority; /* used to remember priority of current process */ pthread_attr_t threadAttribute; /* used to setup thread attribute */ #elif defined (__vxworks) IxOsalThreadAttr threadAttr; IX_STATUS retStatus; #endif /* ifdef __linuxapp */ ixPerfProfAccXcycleStopMeasurement = FALSE; /* * Check if baseline had been run. If not, terminate. */ if (0 == ixPerfProfAccXcycleCurrentBaseline) { return IX_PERFPROF_ACC_STATUS_XCYCLE_NO_BASELINE; } /* * Range checking for numMeasurementsRequested */ if (IX_PERFPROF_ACC_XCYCLE_MAX_NUM_OF_MEASUREMENTS < numMeasurementsRequested) { return IX_PERFPROF_ACC_STATUS_XCYCLE_MEASUREMENT_REQUEST_OUT_OF_RANGE; } /* * Check if Xcycle is already running, do not allow another start * if Xcycle is running. */ if (ixPerfProfAccXcycleMeasurementInProgress) { return IX_PERFPROF_ACC_STATUS_XCYCLE_MEASUREMENT_IN_PROGRESS; } /* * Xcycle is not running, set the flag to indicate that * a measurement is in progress */ else { ixPerfProfAccXcycleMeasurementInProgress = TRUE ; } /* * Check to see if any other PMU utilities besides Xcycle is running * If yes, we abort to avoid inaccurate results due to load introduce * by other tools. */ if (IX_PERFPROF_ACC_STATUS_ANOTHER_UTIL_IN_PROGRESS == ixPerfProfAccLock()) { return IX_PERFPROF_ACC_STATUS_ANOTHER_UTIL_IN_PROGRESS; } #ifdef __linuxapp /* * Set current priority to lowest possible */ priority = getpriority(PRIO_PROCESS,0); if(0 != setpriority (PRIO_PROCESS, 0, IX_PERFPROF_ACC_XCYCLE_LINUXAPP_PRIORITY_LOWEST)) { ixPerfProfAccUnlock(); ixPerfProfAccXcycleMeasurementInProgress = FALSE ; return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL; } /* * Preparing to create a new thread of ixPerfProfAccXcycleNumPeriodRun() * Start with setting thread attribute with state DETACHED */ result = pthread_attr_init (&threadAttribute); result |= pthread_attr_setdetachstate (&threadAttribute, PTHREAD_CREATE_DETACHED); result |= pthread_create (&xcycleThreadId, &threadAttribute, (void *) &ixPerfProfAccXcycleNumPeriodRun , (void *)numMeasurementsRequested); if (0 != result) { ixPerfProfAccUnlock(); ixPerfProfAccXcycleMeasurementInProgress = FALSE ; return IX_PERFPROF_ACC_STATUS_XCYCLE_THREAD_CREATE_FAIL; }/* end of if (result) */ /* * Successful in creating a new thread with lowest priority. * Restore priority of calling thread to original level */ if (0 != setpriority (PRIO_PROCESS, 0, priority)) { ixPerfProfAccUnlock(); return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL; } #else /* ifdef __linuxapp */ /* * Create a new thread of ixPerfProfAccXcycleNumPeriodRun() * Set the priority level of new thread to lowest possible * If fail, set ixPerfProfAccXcycleMeasurementInProgress * back to FALSE and return error. */ threadAttr.name = "PerfProf Xcycle thread"; threadAttr.stackSize = 0; threadAttr.priority = IX_PERFPROF_ACC_XCYCLE_VXWORKS_PRIORITY_LOWEST; if ((retStatus = ixOsalThreadCreate( &xcycleThreadId, &threadAttr, (IxOsalVoidFnVoidPtr) ixPerfProfAccXcycleNumPeriodRun, (void*) numMeasurementsRequested)) == IX_SUCCESS) { if ((retStatus = ixOsalThreadStart(&xcycleThreadId)) != IX_SUCCESS) { ixPerfProfAccUnlock(); ixPerfProfAccXcycleMeasurementInProgress = FALSE; return IX_PERFPROF_ACC_STATUS_XCYCLE_THREAD_CREATE_FAIL; } } else { ixPerfProfAccUnlock(); ixPerfProfAccXcycleMeasurementInProgress = FALSE ; return IX_PERFPROF_ACC_STATUS_XCYCLE_THREAD_CREATE_FAIL; } /* end of if (result) */ #endif /* ifdef __linuxapp */ return IX_PERFPROF_ACC_STATUS_SUCCESS; } /* end of ixPerfProfAccXcycleStart() */
int main(int ac, char **av) { int lc; /* loop counter */ char *msg; /* message returned from parse_opts */ int ind; /* counter variable for test case looping */ char *test_desc; /* test specific error message */ int which; /* process priority category */ uid_t who; /* process uid of the test process */ /* Parse standard options given to run the test. */ msg = parse_opts(ac, av, (option_t *) NULL, NULL); if (msg != (char *) NULL) { tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); tst_exit(); } /* Perform global setup for test */ setup(); /* set the expected errnos... */ TEST_EXP_ENOS(exp_enos); /* Check looping state if -i option given */ for (lc = 0; TEST_LOOPING(lc); lc++) { /* Reset Tst_count in case we are looping. */ Tst_count=0; for (ind = 0; ind < TST_TOTAL; ind++) { which = Test_cases[ind].pro_which; who = Test_cases[ind].pro_uid; test_desc = Test_cases[ind].desc; if (who == 0) { /* Get the actual uid of the process */ who = getuid(); } /* * Invoke getpriority with the specified * 'which' and 'who' arguments and verify * that it fails with expected errno. */ TEST(getpriority(which, who)); /* check return code from getpriority(2) */ if (TEST_RETURN < 0) { TEST_ERROR_LOG(TEST_ERRNO); if (TEST_ERRNO == Test_cases[ind].exp_errno) { tst_resm(TPASS, "getpriority(2) fails, " "%s, errno:%d", test_desc, TEST_ERRNO); } else { tst_resm(TFAIL, "getpriority() fails, " "%s, errno:%d, expected errno:" "%d", test_desc, TEST_ERRNO, Test_cases[ind].exp_errno); } } else { tst_resm(TFAIL, "getpriority() returned %d, " "expected -1, errno:%d", TEST_RETURN, Test_cases[ind].exp_errno); } } /* End of TEST CASE LOOPING. */ } /* End for TEST_LOOPING */ /* Call cleanup() to undo setup done for the test. */ cleanup(); /*NOTREACHED*/ return(0); } /* End main */
void threadMain() { while (!boost::this_thread::interruption_requested()) { syscalls::sleep(60 * 60); begin_touch: boost::this_thread::disable_interruption di; boost::this_thread::disable_syscall_interruption dsi; // Fork a process which touches everything in the server instance dir. pid_t pid = syscalls::fork(); if (pid == 0) { // Child int prio, ret, e; closeAllFileDescriptors(2); // Make process nicer. do { prio = getpriority(PRIO_PROCESS, getpid()); } while (prio == -1 && errno == EINTR); if (prio != -1) { prio++; if (prio > 20) { prio = 20; } do { ret = setpriority(PRIO_PROCESS, getpid(), prio); } while (ret == -1 && errno == EINTR); } else { perror("getpriority"); } do { ret = chdir(wo->instanceDir->getPath().c_str()); } while (ret == -1 && errno == EINTR); if (ret == -1) { e = errno; fprintf(stderr, "chdir(\"%s\") failed: %s (%d)\n", wo->instanceDir->getPath().c_str(), strerror(e), e); fflush(stderr); _exit(1); } restoreOomScore(agentsOptions); execlp("/bin/sh", "/bin/sh", "-c", "find . | xargs touch", (char *) 0); e = errno; fprintf(stderr, "Cannot execute 'find . | xargs touch': %s (%d)\n", strerror(e), e); fflush(stderr); _exit(1); } else if (pid == -1) { // Error P_WARN("Could not touch the server instance directory because " "fork() failed. Retrying in 2 minutes..."); boost::this_thread::restore_interruption si(di); boost::this_thread::restore_syscall_interruption rsi(dsi); syscalls::sleep(60 * 2); goto begin_touch; } else { syscalls::waitpid(pid, NULL, 0); } } }
/* * hourly_stats - print some interesting stats */ void write_stats(void) { FILE *fp; double ftemp; #ifdef DOSYNCTODR struct timeval tv; #if !defined(VMS) int prio_set; #endif #ifdef HAVE_GETCLOCK struct timespec ts; #endif int o_prio; /* * Sometimes having a Sun can be a drag. * * The kernel variable dosynctodr controls whether the system's * soft clock is kept in sync with the battery clock. If it * is zero, then the soft clock is not synced, and the battery * clock is simply left to rot. That means that when the system * reboots, the battery clock (which has probably gone wacky) * sets the soft clock. That means ntpd starts off with a very * confused idea of what time it is. It then takes a large * amount of time to figure out just how wacky the battery clock * has made things drift, etc, etc. The solution is to make the * battery clock sync up to system time. The way to do THAT is * to simply set the time of day to the current time of day, but * as quickly as possible. This may, or may not be a sensible * thing to do. * * CAVEAT: settimeofday() steps the sun clock by about 800 us, * so setting DOSYNCTODR seems a bad idea in the * case of us resolution */ #if !defined(VMS) /* * (prr) getpriority returns -1 on error, but -1 is also a valid * return value (!), so instead we have to zero errno before the * call and check it for non-zero afterwards. */ errno = 0; prio_set = 0; o_prio = getpriority(PRIO_PROCESS,0); /* Save setting */ /* * (prr) if getpriority succeeded, call setpriority to raise * scheduling priority as high as possible. If that succeeds * as well, set the prio_set flag so we remember to reset * priority to its previous value below. Note that on Solaris * 2.6 (and beyond?), both getpriority and setpriority will fail * with ESRCH, because sched_setscheduler (called from main) put * us in the real-time scheduling class which setpriority * doesn't know about. Being in the real-time class is better * than anything setpriority can do, anyhow, so this error is * silently ignored. */ if ((errno == 0) && (setpriority(PRIO_PROCESS,0,-20) == 0)) prio_set = 1; /* overdrive */ #endif /* VMS */ #ifdef HAVE_GETCLOCK (void) getclock(TIMEOFDAY, &ts); tv.tv_sec = ts.tv_sec; tv.tv_usec = ts.tv_nsec / 1000; #else /* not HAVE_GETCLOCK */ GETTIMEOFDAY(&tv,(struct timezone *)NULL); #endif /* not HAVE_GETCLOCK */ if (ntp_set_tod(&tv,(struct timezone *)NULL) != 0) msyslog(LOG_ERR, "can't sync battery time: %m"); #if !defined(VMS) if (prio_set) setpriority(PRIO_PROCESS, 0, o_prio); /* downshift */ #endif /* VMS */ #endif /* DOSYNCTODR */ record_sys_stats(); ftemp = fabs(prev_drift_comp - drift_comp); prev_drift_comp = drift_comp; if (ftemp > clock_phi) return; if (stats_drift_file != 0 && drift_file_sw) { /* * When the frequency file is written, initialize the * wander threshold to a configured initial value. * Thereafter reduce it by a factor of 0.5. When it * drops below the frequency wander, write the frequency * file. This adapts to the prevailing wander yet * minimizes the file writes. */ drift_file_sw = FALSE; wander_resid *= 0.5; #ifdef DEBUG if (debug) printf("write_stats: wander %.6lf thresh %.6lf, freq %.6lf\n", clock_stability * 1e6, wander_resid * 1e6, drift_comp * 1e6); #endif if (sys_leap != LEAP_NOTINSYNC && clock_stability > wander_resid) { wander_resid = wander_threshold; if ((fp = fopen(stats_temp_file, "w")) == NULL) { msyslog(LOG_ERR, "frequency file %s: %m", stats_temp_file); return; } fprintf(fp, "%.3f\n", drift_comp * 1e6); (void)fclose(fp); /* atomic */ #ifdef SYS_WINNT if (_unlink(stats_drift_file)) /* rename semantics differ under NT */ msyslog(LOG_WARNING, "Unable to remove prior drift file %s, %m", stats_drift_file); #endif /* SYS_WINNT */ #ifndef NO_RENAME if (rename(stats_temp_file, stats_drift_file)) msyslog(LOG_WARNING, "Unable to rename temp drift file %s to %s, %m", stats_temp_file, stats_drift_file); #else /* we have no rename NFS of ftp in use */ if ((fp = fopen(stats_drift_file, "w")) == NULL) { msyslog(LOG_ERR, "frequency file %s: %m", stats_drift_file); return; } #endif #if defined(VMS) /* PURGE */ { $DESCRIPTOR(oldvers,";-1"); struct dsc$descriptor driftdsc = { strlen(stats_drift_file), 0, 0, stats_drift_file }; while(lib$delete_file(&oldvers, &driftdsc) & 1); } #endif } else { /* XXX: Log a message at INFO level */ } } }
static int getentropy_fallback(void *buf, size_t len) { uint8_t results[SHA512_DIGEST_LENGTH]; int save_errno = errno, e, pgs = sysconf(_SC_PAGESIZE), faster = 0, repeat; static int cnt; struct timespec ts; struct timeval tv; perfstat_cpu_total_t cpustats; #ifdef _AIX61 perfstat_cpu_total_wpar_t cpustats_wpar; #endif perfstat_partition_total_t lparstats; perfstat_disk_total_t diskinfo; perfstat_netinterface_total_t netinfo; struct rusage ru; sigset_t sigset; struct stat st; SHA512_CTX ctx; static pid_t lastpid; pid_t pid; size_t i, ii, m; char *p; pid = getpid(); if (lastpid == pid) { faster = 1; repeat = 2; } else { faster = 0; lastpid = pid; repeat = REPEAT; } for (i = 0; i < len; ) { int j; SHA512_Init(&ctx); for (j = 0; j < repeat; j++) { HX((e = gettimeofday(&tv, NULL)) == -1, tv); if (e != -1) { cnt += (int)tv.tv_sec; cnt += (int)tv.tv_usec; } HX(perfstat_cpu_total(NULL, &cpustats, sizeof(cpustats), 1) == -1, cpustats); #ifdef _AIX61 HX(perfstat_cpu_total_wpar(NULL, &cpustats_wpar, sizeof(cpustats_wpar), 1) == -1, cpustats_wpar); #endif HX(perfstat_partition_total(NULL, &lparstats, sizeof(lparstats), 1) == -1, lparstats); HX(perfstat_disk_total(NULL, &diskinfo, sizeof(diskinfo), 1) == -1, diskinfo); HX(perfstat_netinterface_total(NULL, &netinfo, sizeof(netinfo), 1) == -1, netinfo); for (ii = 0; ii < sizeof(cl)/sizeof(cl[0]); ii++) HX(clock_gettime(cl[ii], &ts) == -1, ts); HX((pid = getpid()) == -1, pid); HX((pid = getsid(pid)) == -1, pid); HX((pid = getppid()) == -1, pid); HX((pid = getpgid(0)) == -1, pid); HX((e = getpriority(0, 0)) == -1, e); if (!faster) { ts.tv_sec = 0; ts.tv_nsec = 1; (void) nanosleep(&ts, NULL); } HX(sigpending(&sigset) == -1, sigset); HX(sigprocmask(SIG_BLOCK, NULL, &sigset) == -1, sigset); HF(getentropy); /* an addr in this library */ HF(printf); /* an addr in libc */ p = (char *)&p; HD(p); /* an addr on stack */ p = (char *)&errno; HD(p); /* the addr of errno */ if (i == 0) { struct sockaddr_storage ss; struct statvfs stvfs; struct termios tios; socklen_t ssl; off_t off; /* * Prime-sized mappings encourage fragmentation; * thus exposing some address entropy. */ struct mm { size_t npg; void *p; } mm[] = { { 17, MAP_FAILED }, { 3, MAP_FAILED }, { 11, MAP_FAILED }, { 2, MAP_FAILED }, { 5, MAP_FAILED }, { 3, MAP_FAILED }, { 7, MAP_FAILED }, { 1, MAP_FAILED }, { 57, MAP_FAILED }, { 3, MAP_FAILED }, { 131, MAP_FAILED }, { 1, MAP_FAILED }, }; for (m = 0; m < sizeof mm/sizeof(mm[0]); m++) { HX(mm[m].p = mmap(NULL, mm[m].npg * pgs, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, (off_t)0), mm[m].p); if (mm[m].p != MAP_FAILED) { size_t mo; /* Touch some memory... */ p = mm[m].p; mo = cnt % (mm[m].npg * pgs - 1); p[mo] = 1; cnt += (int)((long)(mm[m].p) / pgs); } /* Check cnts and times... */ for (ii = 0; ii < sizeof(cl)/sizeof(cl[0]); ii++) { HX((e = clock_gettime(cl[ii], &ts)) == -1, ts); if (e != -1) cnt += (int)ts.tv_nsec; } HX((e = getrusage(RUSAGE_SELF, &ru)) == -1, ru); if (e != -1) { cnt += (int)ru.ru_utime.tv_sec; cnt += (int)ru.ru_utime.tv_usec; } } for (m = 0; m < sizeof mm/sizeof(mm[0]); m++) { if (mm[m].p != MAP_FAILED) munmap(mm[m].p, mm[m].npg * pgs); mm[m].p = MAP_FAILED; } HX(stat(".", &st) == -1, st); HX(statvfs(".", &stvfs) == -1, stvfs); HX(stat("/", &st) == -1, st); HX(statvfs("/", &stvfs) == -1, stvfs); HX((e = fstat(0, &st)) == -1, st); if (e == -1) { if (S_ISREG(st.st_mode) || S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) { HX(fstatvfs(0, &stvfs) == -1, stvfs); HX((off = lseek(0, (off_t)0, SEEK_CUR)) < 0, off); } if (S_ISCHR(st.st_mode)) { HX(tcgetattr(0, &tios) == -1, tios); } else if (S_ISSOCK(st.st_mode)) { memset(&ss, 0, sizeof ss); ssl = sizeof(ss); HX(getpeername(0, (void *)&ss, &ssl) == -1, ss); } } HX((e = getrusage(RUSAGE_CHILDREN, &ru)) == -1, ru); if (e != -1) { cnt += (int)ru.ru_utime.tv_sec; cnt += (int)ru.ru_utime.tv_usec; } } else { /* Subsequent hashes absorb previous result */ HD(results); } HX((e = gettimeofday(&tv, NULL)) == -1, tv); if (e != -1) { cnt += (int)tv.tv_sec; cnt += (int)tv.tv_usec; } HD(cnt); } SHA512_Final(results, &ctx); memcpy((char *)buf + i, results, min(sizeof(results), len - i)); i += min(sizeof(results), len - i); } explicit_bzero(&ctx, sizeof ctx); explicit_bzero(results, sizeof results); if (gotdata(buf, len) == 0) { errno = save_errno; return 0; /* satisfied */ } errno = EIO; return -1; }
/*---------------------------------------------------------------------------*/ static void* hao_thread(void* dummy) { char* msgbuf = NULL; int msgidx = -1; int msgamt = 0; char* msgend = NULL; char svchar = 0; int bufamt = 0; UNREFERENCED(dummy); /* Do not start HAO if no logger is active * the next hao command will restart the thread */ if(!logger_status()) { haotid = 0; return NULL; } WRMSG(HHC00100, "I", (u_long)thread_id(), getpriority(PRIO_PROCESS,0), "Hercules Automatic Operator"); /* Wait for panel thread to engage */ /* Do until shutdown */ while(!sysblk.shutdown && msgamt >= 0) { /* wait for message data */ msgamt = log_read(&msgbuf, &msgidx, LOG_BLOCK); if(msgamt > 0) { /* append to existing data */ if(msgamt > (int)((sizeof(ao_msgbuf) - 1) - bufamt)) msgamt = (int)((sizeof(ao_msgbuf) - 1) - bufamt); strncpy( &ao_msgbuf[bufamt], msgbuf, msgamt ); ao_msgbuf[bufamt += msgamt] = 0; msgbuf = ao_msgbuf; /* process only complete messages */ msgend = strchr(msgbuf,'\n'); while(msgend) { /* null terminate message */ svchar = *(msgend+1); *(msgend+1) = 0; /* process message */ hao_message(msgbuf); /* restore destroyed byte */ *(msgend+1) = svchar; msgbuf = msgend+1; msgend = strchr(msgbuf,'\n'); } /* shift message buffer */ memmove( ao_msgbuf, msgbuf, bufamt -= (msgbuf - ao_msgbuf) ); } } WRMSG(HHC00101, "I", (u_long)thread_id(), getpriority(PRIO_PROCESS,0), "Hercules Automatic Operator"); return NULL; }
int main(int argc,char **argv, char **envp) { struct plugins_list_entry *list; char config_file[SRVBUFLEN]; int logf; /* getopt() stuff */ extern char *optarg; extern int optind, opterr, optopt; int errflag, cp; #if defined HAVE_MALLOPT mallopt(M_CHECK_ACTION, 0); #endif umask(077); compute_once(); memset(cfg_cmdline, 0, sizeof(cfg_cmdline)); memset(&config, 0, sizeof(struct configuration)); memset(&config_file, 0, sizeof(config_file)); log_notifications_init(&log_notifications); config.acct_type = ACCT_PMBGP; find_id_func = NULL; plugins_list = NULL; errflag = 0; rows = 0; /* getting commandline values */ while (!errflag && ((cp = getopt(argc, argv, ARGS_PMBGPD)) != -1)) { cfg_cmdline[rows] = malloc(SRVBUFLEN); switch (cp) { case 'L': strlcpy(cfg_cmdline[rows], "bgp_daemon_ip: ", SRVBUFLEN); strncat(cfg_cmdline[rows], optarg, CFG_LINE_LEN(cfg_cmdline[rows])); rows++; break; case 'l': strlcpy(cfg_cmdline[rows], "bgp_daemon_port: ", SRVBUFLEN); strncat(cfg_cmdline[rows], optarg, CFG_LINE_LEN(cfg_cmdline[rows])); rows++; break; case 'D': strlcpy(cfg_cmdline[rows], "daemonize: true", SRVBUFLEN); rows++; break; case 'd': debug = TRUE; strlcpy(cfg_cmdline[rows], "debug: true", SRVBUFLEN); rows++; break; case 'f': strlcpy(config_file, optarg, sizeof(config_file)); break; case 'F': strlcpy(cfg_cmdline[rows], "pidfile: ", SRVBUFLEN); strncat(cfg_cmdline[rows], optarg, CFG_LINE_LEN(cfg_cmdline[rows])); rows++; break; case 'S': strlcpy(cfg_cmdline[rows], "syslog: ", SRVBUFLEN); strncat(cfg_cmdline[rows], optarg, CFG_LINE_LEN(cfg_cmdline[rows])); rows++; break; case 'h': usage_daemon(argv[0]); exit(0); break; case 'V': version_daemon(PMBGPD_USAGE_HEADER); exit(0); break; default: usage_daemon(argv[0]); exit(1); break; } } /* post-checks and resolving conflicts */ if (strlen(config_file)) { if (parse_configuration_file(config_file) != SUCCESS) exit(1); } else { if (parse_configuration_file(NULL) != SUCCESS) exit(1); } list = plugins_list; while (list) { list->cfg.acct_type = ACCT_PMBGP; set_default_preferences(&list->cfg); if (!strcmp(list->type.string, "core")) { memcpy(&config, &list->cfg, sizeof(struct configuration)); config.name = list->name; config.type = list->type.string; } list = list->next; } if (config.files_umask) umask(config.files_umask); if (config.daemon) { if (debug || config.debug) printf("WARN ( %s/core ): debug is enabled; forking in background. Logging to standard error (stderr) will get lost.\n", config.name); daemonize(); } initsetproctitle(argc, argv, envp); if (config.syslog) { logf = parse_log_facility(config.syslog); if (logf == ERR) { config.syslog = NULL; printf("WARN ( %s/core ): specified syslog facility is not supported. Logging to standard error (stderr).\n", config.name); } else openlog(NULL, LOG_PID, logf); Log(LOG_INFO, "INFO ( %s/core ): Start logging ...\n", config.name); } if (config.logfile) { config.logfile_fd = open_output_file(config.logfile, "a", FALSE); while (list) { list->cfg.logfile_fd = config.logfile_fd ; list = list->next; } } if (config.proc_priority) { int ret; ret = setpriority(PRIO_PROCESS, 0, config.proc_priority); if (ret) Log(LOG_WARNING, "WARN ( %s/core ): proc_priority failed (errno: %d)\n", config.name, errno); else Log(LOG_INFO, "INFO ( %s/core ): proc_priority set to %d\n", config.name, getpriority(PRIO_PROCESS, 0)); } if (strlen(config_file)) { char canonical_path[PATH_MAX], *canonical_path_ptr; canonical_path_ptr = realpath(config_file, canonical_path); if (canonical_path_ptr) Log(LOG_INFO, "INFO ( %s/core ): Reading configuration file '%s'.\n", config.name, canonical_path); } else Log(LOG_INFO, "INFO ( %s/core ): Reading configuration from cmdline.\n", config.name); pm_setproctitle("%s [%s]", "Core Process", config.proc_name); if (config.pidfile) write_pid_file(config.pidfile); /* signal handling we want to inherit to plugins (when not re-defined elsewhere) */ signal(SIGCHLD, startup_handle_falling_child); /* takes note of plugins failed during startup phase */ signal(SIGHUP, reload); /* handles reopening of syslog channel */ signal(SIGUSR1, SIG_IGN); signal(SIGUSR2, reload_maps); /* sets to true the reload_maps flag */ signal(SIGPIPE, SIG_IGN); /* we want to exit gracefully when a pipe is broken */ signal(SIGINT, my_sigint_handler); signal(SIGTERM, my_sigint_handler); if (!config.nfacctd_bgp) config.nfacctd_bgp = BGP_DAEMON_ONLINE; if (!config.nfacctd_bgp_port) config.nfacctd_bgp_port = BGP_TCP_PORT; bgp_prepare_daemon(); skinny_bgp_daemon(); }
// nice command implementation void executeNice(Cmd c) { int which, who, priority; int setCommand = 0; if(c->args[1]!=NULL) { priority = atoi(c->args[1]); if(priority == 0 && strcmp(c->args[1],"0")){ priority = 4; setCommand = 1; } if(priority<-19) { priority = -19; } else if(priority>20) { priority = 20; } } else { printf("No arguments passed for nice command\n"); } int childPID = fork(); if(childPID == 0){ which = PRIO_PROCESS; who = 0; getpriority(which, who); setpriority(which, who, priority); int j = 0; int b = 0; while(j<8) { if(setCommand != 1) { if(!strcmp(c->args[2],builtInCommands[j])) { b = 1; } } else { if(!strcmp(c->args[1],builtInCommands[j])) { b = 1; } } j++; } if(b){ Cmd temp; temp = malloc(sizeof(struct cmd_t)); temp->args = malloc(sizeof(char*)); temp->in = Tnil; temp->out = Tnil; int i = 2; while(c->args[i] != NULL){ temp->args[i-2] = malloc(strlen(c->args[i])); strcpy(temp->args[i-2],c->args[i]); i++; } builtInCmdExecutor(temp); free(temp->args); free(temp); exit(0); } else{ if(setCommand) { if(execvp(c->args[1], c->args+1) == -1){ fprintf(stderr,"%s: command not found\n",c->args[1]); exit(0); } } else { if(execvp(c->args[2], c->args+2) == -1){ fprintf(stderr,"%s: command not found\n",c->args[2]); exit(0); } } } } else{ waitpid(childPID,&status,0); } }
int main(int ac, char **av) { int lc; /* loop counter */ char *msg; /* message returned from parse_opts */ int priority; int new_val = 2; /* lower our priority from 0 to new_val */ /* parse standard options */ if ((msg = parse_opts(ac, av, (option_t *)NULL, NULL)) != (char *)NULL){ tst_brkm(TBROK, tst_exit, "OPTION PARSING ERROR - %s", msg); } setup(); /* global setup */ /* The following loop checks looping state if -i option given */ for (lc = 0; TEST_LOOPING(lc); lc++) { /* reset Tst_count in case we are looping */ Tst_count = 0; /* * Lower the priority of this process from a default of 0 * to a new value of 2. Then read the value using getpriority() * to verify the change. */ /* * We need to be careful here. We could possibly set our * priority lower using PRIO_USER and then have no way * to set it back. So, let's use PRIO_PROCESS and make * sure we affect this test only. */ /* call the system call with the TEST() macro */ TEST(setpriority(PRIO_PROCESS, 0, new_val)); if (TEST_RETURN != 0) { tst_resm(TFAIL, "call failed - errno = %d - " "%s", TEST_ERRNO, strerror(TEST_ERRNO)); continue; } if (STD_FUNCTIONAL_TEST) { /* get the priority that we just set */ priority = getpriority(PRIO_PROCESS, 0); if (errno == -1) { tst_brkm(TBROK, cleanup, "getpriority call " "failed - errno = %d - %s", errno, strerror(errno)); } if (priority == new_val) { tst_resm(TPASS, "functionality is correct"); } else { tst_resm(TFAIL, "current priority (%d) and new " "priority (%d) do not match", priority, new_val); } } else { tst_resm(TPASS, "call succeeded"); } } cleanup(); /*NOTREACHED*/ return(0); }