void settimes() { #ifdef BSDTIMES struct sysrusage ruch; #ifdef convex memset(&ru0, 0, sizeof(ru0)); memset(&ruch, 0, sizeof(ruch)); #endif /* convex */ (void) gettimeofday(&time0, NULL); (void) getrusage(RUSAGE_SELF, (struct rusage *) &ru0); (void) getrusage(RUSAGE_CHILDREN, (struct rusage *) &ruch); ruadd(&ru0, &ruch); #else # ifdef _SEQUENT_ struct process_stats ruch; (void) get_process_stats(&time0, PS_SELF, &ru0, &ruch); ruadd(&ru0, &ruch); # else /* _SEQUENT_ */ # ifndef COHERENT time0 = times(×0); # else /* !COHERENT */ time0 = HZ * time(NULL); times(×0); # endif /* !COHERENT */ times0.tms_stime += times0.tms_cstime; times0.tms_utime += times0.tms_cutime; times0.tms_cstime = 0; times0.tms_cutime = 0; # endif /* _SEQUENT_ */ #endif /* BSDTIMES */ }
int tee_status_handler(request_rec *r, int flags) { global_snapshot *global_snap = get_global_stats(r->pool, r); if (flags & AP_STATUS_SHORT) { write_stats_auto(r, global_snap); } else { process_snapshot **process_snap_array = get_process_stats(r->pool); write_stats_full(r, global_snap, process_snap_array); } return OK; }
int gettimeofday( struct timeval *tvp ) { /* * hi, this is Sequents sneak path to get to a clock * this is also the most logical syscall for such a function */ return (get_process_stats(tvp, PS_SELF, (struct procstats *) 0, (struct procstats *) 0)); }
void log_process_stats(void) { int stat; timeval_t tv; struct process_stats myproc, mychildren; emit(ERRLOC, POLL_STATS_SET1); emit(ERRLOC, POLL_STATS_SET2); emit(ERRLOC, POLL_STATS_SET1); stat = get_process_stats( &tv, PS_SELF, &myproc, &mychildren); if ( stat == -1 ) return; emit(ERRLOC, POLL_STATS_SET3, myproc.ps_utime.tv_sec, myproc.ps_utime.tv_usec); emit(ERRLOC, POLL_STATS_SET4, myproc.ps_stime.tv_sec, myproc.ps_stime.tv_usec); emit(ERRLOC, POLL_STATS_SET5, myproc.ps_maxrss); emit(ERRLOC, POLL_STATS_SET6, myproc.ps_pagein); emit(ERRLOC, POLL_STATS_SET7, myproc.ps_reclaim); emit(ERRLOC, POLL_STATS_SET8, myproc.ps_zerofill); emit(ERRLOC, POLL_STATS_SET9, myproc.ps_pffincr); emit(ERRLOC, POLL_STATS_SET10, myproc.ps_pffdecr); emit(ERRLOC, POLL_STATS_SET11, myproc.ps_swap); emit(ERRLOC, POLL_STATS_SET12, myproc.ps_syscall); emit(ERRLOC, POLL_STATS_SET13, myproc.ps_volcsw); emit(ERRLOC, POLL_STATS_SET14, myproc.ps_involcsw); emit(ERRLOC, POLL_STATS_SET15, myproc.ps_signal); emit(ERRLOC, POLL_STATS_SET16, myproc.ps_lread); emit(ERRLOC, POLL_STATS_SET17, myproc.ps_lwrite); emit(ERRLOC, POLL_STATS_SET18, myproc.ps_bread); emit(ERRLOC, POLL_STATS_SET19, myproc.ps_bwrite); emit(ERRLOC, POLL_STATS_SET20, myproc.ps_phread); emit(ERRLOC, POLL_STATS_SET21, myproc.ps_phwrite); emit(ERRLOC, POLL_STATS_SET1); }
void f_rusage (void) { struct process_stats ps; mapping_t *m; int utime, stime, maxrss; if (get_process_stats(NULL, PS_SELF, &ps, NULL) == -1) m = allocate_mapping(0); else { utime = ps.ps_utime.tv_sec * 1000 + ps.ps_utime.tv_usec / 1000; stime = ps.ps_stime.tv_sec * 1000 + ps.ps_stime.tv_usec / 1000; maxrss = ps.ps_maxrss * getpagesize() / 1024; m = allocate_mapping(19); add_mapping_pair(m, "utime", utime); add_mapping_pair(m, "stime", stime); add_mapping_pair(m, "maxrss", maxrss); add_mapping_pair(m, "pagein", ps.ps_pagein); add_mapping_pair(m, "reclaim", ps.ps_reclaim); add_mapping_pair(m, "zerofill", ps.ps_zerofill); add_mapping_pair(m, "pffincr", ps.ps_pffincr); add_mapping_pair(m, "pffdecr", ps.ps_pffdecr); add_mapping_pair(m, "swap", ps.ps_swap); add_mapping_pair(m, "syscall", ps.ps_syscall); add_mapping_pair(m, "volcsw", ps.ps_volcsw); add_mapping_pair(m, "involcsw", ps.ps_involcsw); add_mapping_pair(m, "signal", ps.ps_signal); add_mapping_pair(m, "lread", ps.ps_lread); add_mapping_pair(m, "lwrite", ps.ps_lwrite); add_mapping_pair(m, "bread", ps.ps_bread); add_mapping_pair(m, "bwrite", ps.ps_bwrite); add_mapping_pair(m, "phread", ps.ps_phread); add_mapping_pair(m, "phwrite", ps.ps_phwrite); } push_refed_mapping(m); }
int gettimeofday (struct timeval *tp, void *tzp) { return get_process_stats (tp, PS_SELF, 0, 0); }
/* * Find the process with the largest oom_score and kill it. * See trigger_kernel_oom() for the reason why this is done in userspace. */ static void userspace_kill(DIR *procdir, int sig, int ignore_oom_score_adj) { struct dirent * d; char buf[256]; int pid; int victim_pid = 0; int victim_badness = 0; unsigned long victim_vm_rss = 0; char name[PATH_MAX]; struct procinfo p; int badness; rewinddir(procdir); while(1) { errno = 0; d = readdir(procdir); if(d == NULL) { if(errno != 0) perror("readdir returned error"); break; } // proc contains lots of directories not related to processes, // skip them if(!isnumeric(d->d_name)) continue; pid = strtoul(d->d_name, NULL, 10); if(pid == 1) // Let's not kill init. continue; get_process_stats(pid, &p); if(p.exited == 1) // Process may have died in the meantime continue; badness = p.oom_score; if(ignore_oom_score_adj && p.oom_score_adj > 0) badness -= p.oom_score_adj; if(enable_debug) printf("pid %5d: badness %3d vm_rss %6lu\n", pid, badness, p.vm_rss); if(badness > victim_badness) { victim_pid = pid; victim_badness = badness; if(enable_debug) printf(" ^ new victim (higher badness)\n"); } else if(badness == victim_badness && p.vm_rss > victim_vm_rss) { victim_pid = pid; victim_vm_rss = p.vm_rss; if(enable_debug) printf(" ^ new victim (higher vm_rss)\n"); } } if(victim_pid == 0) { fprintf(stderr, "Error: Could not find a process to kill. Sleeping 10 seconds.\n"); sleep(10); return; } name[0]=0; snprintf(buf, sizeof(buf), "%d/stat", victim_pid); FILE * stat = fopen(buf, "r"); fscanf(stat, "%*d %s", name); fclose(stat); if(sig != 0) fprintf(stderr, "Killing process %d %s\n", victim_pid, name); if(kill(victim_pid, sig) != 0) { perror("Could not kill process"); // Killing the process may have failed because we are not running as root. // In that case, trying again in 100ms will just yield the same error. // Throttle ourselves to not spam the log. fprintf(stderr, "Sleeping 10 seconds\n"); sleep(10); } }
/* * Find the process with the largest oom_score and kill it. * See trigger_kernel_oom() for the reason why this is done in userspace. */ static void userspace_kill(DIR *procdir, int sig, int ignore_oom_score_adj) { struct dirent * d; char buf[256]; int pid; int victim_pid = 0; int victim_points = 0; char name[PATH_MAX]; struct procinfo p; int badness; #define CMDLINE_MAX 250 char cmdline[CMDLINE_MAX]; int len; rewinddir(procdir); while(1) { d = readdir(procdir); if(d == NULL) break; if(!isnumeric(d->d_name)) continue; pid = strtoul(d->d_name, NULL, 10); p = get_process_stats(pid); if(p.exited == 1) // Process may have died in the meantime continue; badness = p.oom_score; if(ignore_oom_score_adj && p.oom_score_adj > 0) badness -= p.oom_score_adj; if(enable_debug) printf("pid %5d: badness %3d\n", pid, badness); // We don't need to check this, but it is a good optimization, reducing the number of files that will be read. if(badness > victim_points) { // If the process is marked as excluded, then reduce its score. snprintf(buf, PATH_MAX, "%d/cmdline", pid); len = read_contents_of_file(buf, cmdline, CMDLINE_MAX-1); convert_nulls_to_spaces(cmdline, len); if (regexec(&excluded_cmdlines_regexp, cmdline, (size_t)0, NULL, 0) == 0) { //fprintf(stderr, "Process is EXCLUDED! %i %s\n", pid, cmdline); badness /= 32; } } if(badness > victim_points) { victim_pid = pid; victim_points = badness; if(enable_debug) printf(" ^ new victim\n"); } } if(victim_pid == 0) { fprintf(stderr, "Error: Could not find a process to kill\n"); exit(9); } if (!enable_debug) { name[0]=0; snprintf(buf, sizeof(buf), "%d/stat", victim_pid); FILE * stat = fopen(buf, "r"); fscanf(stat, "%*d %s", name); fclose(stat); } else { // In debug mode, instead of the process name, we display the whole cmdline (i.e. the name and the arguments passed). snprintf(buf, PATH_MAX, "%d/cmdline", victim_pid); len = read_contents_of_file(buf, name, PATH_MAX-1); convert_nulls_to_spaces(name, len); } if(sig != 0) fprintf(stderr, "Killing process %d %s\n", victim_pid, name); if(kill(victim_pid, sig) != 0) perror("Could not kill process"); }