/*
* Read counts of page faults from a string.
* choice: 1 - minor, 2 - major
*/
unsigned long get_page_fault_from_string(char * string, int choice) {
#ifndef __APPLE__
struct proc_stats statsData; // Stat for storing information from the /proc/pid/stat file
int self = getpid(); // Process ID
// First write string to a file.
FILE *fp = fopen("temp", "wb+"); // Use a temporary file.
if (fp != NULL)
{
fputs(string, fp);
if (fp) {
fclose(fp);
}
} else {
printf("Error opening a temp file.\n");
}
// Read data from the stats file
read_stat("temp", self, &statsData);
// Return the count of detected page faults.
if (choice == 1) {
return statsData.minflt;
} else {
return statsData.majflt;
}
#else
return -1;
#endif
}
static int do_sbufl_fill_from_file(struct sbuf *sb, FILE *fp, gzFile zp,
int phase1, struct cntr *cntr)
{
int ars;
struct iobuf rbuf;
//free_sbufl(sb);
iobuf_init(&rbuf);
if((ars=read_stat(NULL /* no async */,
&rbuf, fp, zp, sb, cntr))) return ars;
if((ars=read_fp(fp, zp, &rbuf))) return ars;
iobuf_copy(&sb->path, &rbuf);
if(sbuf_is_link(sb))
{
if((ars=read_fp(fp, zp, &rbuf))) return ars;
iobuf_copy(&sb->link, &rbuf);
if(!cmd_is_link(rbuf.cmd))
return unexpected(&rbuf, __func__);
}
else if(!phase1 && sbuf_is_filedata(sb))
{
if((ars=read_fp(fp, zp, &rbuf))) return ars;
iobuf_copy(&(sb->burp1->endfile), &rbuf);
if(!cmd_is_endfile(rbuf.cmd))
return unexpected(&rbuf, __func__);
}
return 0;
}
static int64_t
read_bd_stat(int device, int domid, const char *str)
{
static const char *paths[] = {
"/sys/bus/xen-backend/devices/vbd-%d-%d/statistics/%s",
"/sys/bus/xen-backend/devices/tap-%d-%d/statistics/%s",
"/sys/devices/xen-backend/vbd-%d-%d/statistics/%s",
"/sys/devices/xen-backend/tap-%d-%d/statistics/%s"
};
int i;
char *path;
int64_t r;
for (i = 0; i < ARRAY_CARDINALITY(paths); ++i) {
if (virAsprintf(&path, paths[i], domid, device, str) < 0) {
virReportOOMError();
return -1;
}
r = read_stat(path);
VIR_FREE(path);
if (r >= 0) {
return r;
}
}
return -1;
}
static void poll()
{
uint8_t stat;
do
stat = read_stat(sel_base_port);
while ((stat & BSY) != 0); // TODO: Error detection
}
static void check_drive(uint16_t base, uint8_t master_or_slave)
{
if (sel_base_port != 0) // Check if we've already found a drive
return;
outb(base + DRIVE_SELECT, master_or_slave); // select the drive
// Zero out these 4 ports
outb(base + SECTOR_COUNT, 0);
outb(base + LBA_LOW, 0);
outb(base + LBA_MID, 0);
outb(base + LBA_HIGH, 0);
outb(base + COM_STAT, IDENTIFY); // Send IDENTIFY command
uint8_t stat = read_stat(base);
if (stat == 0) // The drive does not exist
return;
// It exists! Retrieve some status info
while ((stat & BSY) != 0) // Poll status port until BSY clears
stat = read_stat(base);
// TODO: check for ATAPI at this point
while ((stat & DRQ) == 0 && (stat & ERR) == 0)
stat = read_stat(base);
if ((stat & ERR) != 0) // Something's wrong. Maybe it's ATAPI or SATA
return;
// The drive is ready to send us 256 (16-bit) words of data
uint16_t drive_data[256];
for (size_t i = 0; i < 256; i++)
drive_data[i] = inw(base + DATA);
max_sector = drive_data[MAX_28LBA_SECTORS] |
drive_data[MAX_28LBA_SECTORS + 1] << 16;
// This drive seems to work, so let's select it
sel_base_port = base;
sel_master_or_slave = master_or_slave;
}
int main(int argc, char *argv[])
{
args list;
int fd;
pid_t pid;
int size = 0;
int i = 1;
int nodes_num = 0;
char sz[25];
char pipe_path[30];
if(process_c_args(argc, argv, &list))
{
return -1;
}
size = strtol(list.file_name, NULL, 10);
snprintf(sz, 25, "%d", size);
if(mkfifo ("/tmp/1_p",0666) == -1)
{
perror("Error creating named pipe");
}
pid = fork();
if(pid == 0) //child
{
//SM node arguments: lower bound, upper bound, sorting attribute, file name, node number, current depth, max depth
execl("smnode", "smnode", "0", sz, list.attrib, list.file_name, "1", "0", list.depth, (char *)0);
fflush(stdout);
perror("Can't execute smnode\n");
} else if (pid < 0) //fork failed
{
perror("Fork error!\n");
} else //parent
{
fd = open("/tmp/1_p", O_RDONLY);
read_fifo(fd,size);
close(fd);
}
printf("\n\n ======================= Sorting Statistics ======================= \n\n");
read_stat();
printf("\n\n ================================================================== \n\n");
//remove the pipes when finished
nodes_num = (int)(pow(2,atoi(list.depth)+1)) - 1;
for(i = 1; i <= nodes_num; i++)
{
snprintf(pipe_path, 30, "/tmp/%d_p", i);
unlink(pipe_path);
}
return 0;
}
/* ------------------------------------------------------------------
* Opens and iterates through a given directory, operating on allowed
* files found within it. . and .. are skipped, as are files beginning
* with . unless it's been enabled in the flags. All other entries,
* both files and directories, are thrown to process_entry to determine
* whether they're a file/directory/link, and to read/explore them if
* appropriate. If threads are being used, they wait for their children
* threads to terminate after they themselves are done with their work.
*
* flags: The usual I/O option flags.
* list_head: A list of already visited directories. Always will have
* the working directory low was called from as the tail,
* and will always have the current directory being explored
* as the head (so the src = list_head->next->path assignment
* is always safe).
* fullpath: The realpath of the current directory being explored.
* dir_depth: Passed to process_entry.
* ------------------------------------------------------------------
*/
int explore_dir(params *P, visited_dir *list_head, char *nextpath,
int dir_depth)
{
DIR *d;
struct dirent *entry;
struct dirent **done;
int len;
if ( (d = opendir(nextpath)) == 0)
{
return print_file_error(P, errno, nextpath);
}
if (((P->max_dir_depth) - dir_depth) > read_stat(P, t_ddepth))
update_stat(P, t_ddepth, ((P->max_dir_depth) - dir_depth));
len = offsetof(struct dirent, d_name) +
pathconf(nextpath, _PC_NAME_MAX) + 1;
if ((entry = malloc(len)) == NULL ||
(done = malloc(sizeof(struct dirent*))) == NULL)
{
fprintf(stderr, "Malloc failed in explore_dir.\n");
return -1;
}
done = &entry;
while ( (readdir_r(d, entry, done)) == 0 && (*done != NULL))
{
/* don't process '.' or '..' in a directory! */
if ( (strcmp(entry->d_name, THIS_DIR) == 0)
|| (strcmp(entry->d_name, PARENT_DIR) == 0))
continue;
/* do all files but ones beginning with a dot,
* unless we've enabled it! */
if (entry->d_name[0] == '.')
{
if (enabled(P, READ_DOT_FILES))
{
process_entry(P, list_head, entry->d_name,
nextpath, dir_depth, 0);
}
else
inc_stat(P, t_dotfiles, 1);
}
else
process_entry(P, list_head, entry->d_name, nextpath,
dir_depth, 0);
}
closedir(d);
wait_for_children(list_head);
free(nextpath);
return 0;
}
/*
* Read information from the /proc/stat file.
*/
struct proc_stats get_page_fault_file() {
struct proc_stats statsData; // Struct to hold data from the /proc/pid/stat file
int self = getpid(); // Process ID
char buf[256]; // Buffer for reading in content of the file
// Read data from the stats file
sprintf(buf, "/proc/%d/stat", self);
read_stat(buf, self, &statsData);
return statsData;
}
/* ------------------------------------------------------------------
* Interface for threads to call explore_dir from, pretty much.
* ------------------------------------------------------------------
*/
void* thread_dir_setup(void *info)
{
dir_info *d = (dir_info*) info;
params *P = d->parameters;
inc_stat(P, t_threadsmade, 1);
pthread_mutex_lock(&stats_mutex);
(P->threads_left) -= 1;
pthread_mutex_unlock(&stats_mutex);
inc_stat(P, current_tcount,1);
if (read_stat(P, current_tcount) > read_stat(P, t_threadssim))
update_stat(P, t_threadssim, read_stat(P, current_tcount));
explore_dir(P, d->list, d->path, d->dir_d);
pthread_mutex_lock(&stats_mutex);
(P->threads_left) += 1;
pthread_mutex_unlock(&stats_mutex);
inc_stat(P, current_tcount, -1);
free_dir_info(info);
return 0;
}
int
main (int argc, char **argv)
{
unsigned int length = 1;
unsigned int current = 0;
while (1) {
if (read_stat (¤t, &length) == 0)
/* print message in form [P 0.xxxxx]\n */
printf ("[P %f]\n", (double) current / (double) length);
usleep (PRINTOUT_INTERVAL * 1000000);
}
}
int statement()
{
int es = 0;
if (es == 0 && strcmp(token, "if") == 0) es = if_stat();//<IF语句>
if (es == 0 && strcmp(token, "while") == 0) es = while_stat();//<while语句>
if (es == 0 && strcmp(token, "for") == 0) es = for_stat();//<for语句>
//可在此处添加do语句调用
if (es == 0 && strcmp(token, "read") == 0) es = read_stat();//<read语句>
if (es == 0 && strcmp(token, "write") == 0) es = write_stat();//<write语句>
if (es == 0 && strcmp(token, "{") == 0) es = compound_stat();//<复合语句>
if (es == 0 && (strcmp(token, "ID") == 0 || strcmp(token, "NUM") == 0 || strcmp(token, "(") == 0)) es = expression_stat();//<表达式语句>
return(es);
}
void stat(){
if (lookahead == INTEGER || lookahead == STRING || lookahead == BOOLEAN || lookahead == TABLE)
def_stat();
else if (lookahead == ID)
assign_stat();
else if (lookahead == IF)
if_stat();
else if (lookahead == WHILE)
while_stat();
else if (lookahead == READ)
read_stat();
else //(lookahead == WRITE)
write_stat();
}
/* Library finalizer function */
static void __attribute__((destructor)) interpose_fini(void) {
/* Look for descriptors not explicitly closed */
for(int i=0; i<max_descriptors; i++) {
trace_close(i);
}
read_exe();
read_status();
read_stat();
read_io();
tprintf("stop: %lf\n", get_time());
/* Close trace file */
tclose();
}
int get_stat_result(int fd, const char *path, int is_lstat, int *exists, struct stat *buf)
{
int result;
char buffer[MAX_PATH_LEN+1];
char cache_name[MAX_PATH_LEN+3];
char *newpath;
int use_cache = (opts & OPT_SHMCACHE) && (shm_cachesize > 0);
int found_file = 0;
if (use_cache) {
debug_printf2("Looking up %sstat for %s in shared cache\n", is_lstat ? "l" : "", path);
get_cache_name(path, is_lstat ? "**" : "*", cache_name);
cache_name[sizeof(cache_name)-1] = '\0';
found_file = fetch_from_cache(cache_name, &newpath);
}
if (!found_file) {
result = send_stat_request(fd, (char *) path, is_lstat, buffer);
if (result == -1) {
*exists = 0;
return -1;
}
newpath = buffer[0] != '\0' ? buffer : NULL;
if (use_cache)
shmcache_update(cache_name, newpath);
}
if (newpath == NULL) {
*exists = 0;
return 0;
}
*exists = 1;
test_log(newpath);
result = read_stat(newpath, buf);
if (result == -1) {
err_printf("Failed to read stat info for %s from %s\n", path, newpath);
*exists = 0;
return -1;
}
return 0;
}
/*Genera il codice per il nodo stat_list e crea lo scope del programma*/
Code stat_list(Pnode stat_list_node){
//Definisco la variabile che contiene il codice da ritornare
Code stat_list_code;
stat_list_code.head = NULL;
stat_list_code.tail = NULL;
stat_list_code.size = 0;
//Creo l'ambiente del programma
push_environment();
//Punto al primo stat
Pnode stat_node = stat_list_node->child;
//Ciclo lungo tutti gli stat_node
while (stat_node!=NULL){
//Creo il codice dello stat_node
Code stat_code;
switch (stat_node->type){
case(N_DEF_STAT): stat_code = def_stat(stat_node);break;
case(N_ASSIGN_STAT): stat_code = assign_stat(stat_node);break;
case(N_IF_STAT): stat_code = if_stat(stat_node);break;
case(N_WHILE_STAT): stat_code = while_stat(stat_node);break;
case(N_READ_STAT): stat_code = read_stat(stat_node);break;
case(N_WRITE_STAT): stat_code = write_stat(stat_node);break;
}
//Appendo il codice a stat_list_code
stat_list_code = appcode(stat_list_code,stat_code);
//Punto al fratello successivo
stat_node = stat_node->brother;
}
//Appendo il codice per fare il pop dell'environment a stat_list_code
if(numobj_in_current_env()!=0)
stat_list_code = appcode(stat_list_code,makecode1(T_POP,numobj_in_current_env()));
//elimino l'ambiente creato (elimina già le variabili dall'ambiente)
pop_environment();
return stat_list_code;
}
static int do_sbufl_fill_from_net(struct sbuf *sb, struct asfd *asfd,
struct cntr *cntr)
{
int ars;
static struct iobuf *rbuf=NULL;
rbuf=asfd->rbuf;
iobuf_free_content(rbuf);
if((ars=read_stat(asfd, rbuf, NULL, NULL, sb, cntr))
|| (ars=asfd->read(asfd))) return ars;
iobuf_copy(&sb->path, rbuf);
rbuf->buf=NULL;
if(sbuf_is_link(sb))
{
if((ars=asfd->read(asfd))) return ars;
iobuf_copy(&sb->link, rbuf);
rbuf->buf=NULL;
if(!cmd_is_link(rbuf->cmd))
return unexpected(rbuf, __func__);
}
return 0;
}
Code stat(Pnode p)
{
switch (p->type)
{
case N_DEF_STAT:
return def_stat(p);
case N_ASSIGN_STAT:
return assign_stat(p);
case N_IF_STAT:
return if_stat(p);
case N_WHILE_STAT:
return while_stat(p);
case N_READ_STAT:
return read_stat(p);
case N_WRITE_STAT:
return write_stat(p);
default:
noderror(p);
}
return endcode();
}
main(int argc,char *argv[])
{
int k=-1; /* kill threshold in CPU seconds */
override_type *override_list;
struct dirent *dir_entry_p;
DIR *dir_p;
int uid;
int opt;
while ((opt=getopt(argc,argv,"k:h"))!=-1)
switch (opt)
{
case 'k': /* kill threshold in CPU seconds */
if ((k=atoi(optarg))>0)
break;
case '?': /* miscellaneous error condition */
case 'h': /* help! */
fprintf(stderr,"downboy2 [-k kill_threshold_in_CPU_seconds]\n");
exit(-1);
}
if ((dir_p=opendir(PROC_ROOT))==NULL)
fprintf(stderr,"Error: failed to open '%s'!\n",PROC_ROOT);
else
{
override_list=load_override(OVERRIDE_FILE);
while ((dir_entry_p=readdir(dir_p))!=NULL)
if (COUNT_DIGITS(dir_entry_p->d_name)==strlen(dir_entry_p->d_name)
&& (uid=get_owner(dir_entry_p->d_name))!=0) /* if not root */
read_stat(dir_entry_p->d_name,find_override(override_list,uid),
k,uid);
closedir(dir_p);
}
}
int main (int argc, char** argv) {
int stat_fd;
int led_fd;
int led_trigger_fd;
int idle;
int blink_delay = base_delay;
int tblink = blink_delay; /* time until next blink */
int tupdate = update_delay; /* time until next update */
/* Disable led triggers to get us free access to the led */
led_trigger_fd = open(led_trigger_path, O_WRONLY);
assert(led_trigger_fd >= 0);
write(led_trigger_fd, "none\n", 5);
close(led_trigger_fd);
stat_fd = open(procstat, O_RDONLY);
assert(stat_fd >= 0);
led_fd = open(led_control_path, O_WRONLY|O_TRUNC);
assert(led_fd >= 0);
while(1) {
idle = read_stat(stat_fd);
tblink -= blink_delay;
blink_delay = (min_delay * 100 + (base_delay - min_delay) * idle) / 100;
tblink += blink_delay;
tblink = tblink < 0 ? 0 : tblink;
while (tblink < tupdate) {
usleep(tblink);
tupdate -= tblink;
tblink = blink_delay;
blink(led_fd);
}
usleep (tupdate);
tblink -= tupdate;
tupdate = update_delay;
}
}
int
main( int argc, char *argv[] )
{
DirectResult ret;
FusionWorld *world;
FusionCall call = {0};
FusionSHMPoolShared *pool;
void *buffer;
int i, max_busy = 0, active = 1;
long long t1 = 0, t2;
long long start = 0;
long long bytes = 0;
long long last_bytes = 0;
unsigned long blocks = 0;
unsigned long last_blocks = 0;
unsigned long last_busy = 0;
u32 checksum = 0;
bool produce = true;
int delay = 66000;
if (parse_cmdline( argc, argv ))
return -1;
if (bit_rate) {
int blocks_per_sec = (bit_rate * 1024 / 8) / block_size;
if (blocks_per_sec < 100)
delay = 900000 / blocks_per_sec - 2000;
else
delay = 300000 * 100 / blocks_per_sec;
num_blocks = bit_rate * 1024 / 8 / block_size * delay / 900000;
if (num_blocks > MAX_NUM_BLOCKS)
num_blocks = MAX_NUM_BLOCKS;
if (!num_blocks) {
num_blocks = 1;
delay = 970 * block_size / (bit_rate * 1024 / 8) * 1000 - 2000;
}
}
sync();
if (run_busy) {
pthread_create( &busy_thread, NULL, busy_loop, NULL );
printf( "Calibrating...\n" );
pthread_mutex_lock( &busy_lock );
for (i=0; i<7; i++) {
int busy_rate;
busy_count = 0;
t1 = get_millis();
pthread_mutex_unlock( &busy_lock );
usleep( 300000 );
pthread_mutex_lock( &busy_lock );
t2 = get_millis();
busy_rate = busy_count * 1000 / (t2 - t1);
if (busy_rate > max_busy)
max_busy = busy_rate;
}
printf( "Calibrating done. (%d busy counts/sec)\n", max_busy );
}
ret = fusion_enter( -1, 23, FER_MASTER, &world );
if (ret)
return ret;
ret = fusion_call_init( &call, call_handler, NULL, world );
if (ret)
return ret;
ret = fusion_shm_pool_create( world, "Stream Buffer", block_size + 8192, false, &pool );
if (ret)
return ret;
ret = fusion_shm_pool_allocate( pool, block_size, false, true, &buffer );
if (ret)
return ret;
/*
* Do the fork() magic!
*/
if (do_fork) {
fusion_world_set_fork_action( world, FFA_FORK );
switch (fork()) {
case -1:
D_PERROR( "fork() failed!\n" );
return -1;
case 0:
/* child continues as the producer */
run_busy = false;
break;
default:
/* parent is the consumer (callback in Fusion Dispatch thread) */
produce = false;
usleep( 50000 );
}
fusion_world_set_fork_action( world, FFA_CLOSE );
}
start = t1 = get_millis();
if (run_busy) {
busy_count = 0;
pthread_mutex_unlock( &busy_lock );
}
#ifdef LINUX_2_4
delay -= 10000;
#endif
do {
if (bit_rate || !produce) {
if (delay > 10)
usleep( delay );
}
if (produce) {
for (i=0; i<num_blocks; i++) {
int n;
u32 retsum;
u32 *values = buffer;
for (n=0; n<block_size/4; n++) {
values[n] = n;
checksum += n;
}
bytes += block_size;
fusion_call_execute( &call, do_thread ? FCEF_NODIRECT : FCEF_NONE,
0, buffer, (int*) &retsum );
if (retsum != checksum)
D_ERROR( "Checksum returned by consumer (0x%08x) does not match 0x%08x!\n", retsum, checksum );
}
blocks += num_blocks;
}
t2 = get_millis();
if (t2 - t1 > 2000) {
if (produce) {
long long kbits = 0, avgkbits, total_time, diff_time, diff_bytes;
printf( "\n\n\n" );
total_time = t2 - start;
diff_time = t2 - t1;
diff_bytes = bytes - last_bytes;
avgkbits = (long long)bytes * 8LL * 1000LL / (long long)total_time / 1024LL;
if (diff_time)
kbits = (long long)diff_bytes * 8LL * 1000LL / (long long)diff_time / 1024LL;
printf( "Total Time: %7lld ms\n", total_time );
printf( "Stream Size: %7lld kb\n", bytes / 1024 );
printf( "Stream Rate: %7lld kb/sec -> %lld.%03lld MBit (avg. %lld.%03lld MBit)\n",
kbits / 8,
(kbits * 1000 / 1024) / 1000, (kbits * 1000 / 1024) % 1000,
(avgkbits * 1000 / 1024) / 1000, (avgkbits * 1000 / 1024) % 1000 );
printf( "\n" );
if (last_bytes && bit_rate) {
long long diff_bytes = (bytes - last_bytes) * 1000 / (t2 - t1);
long long need_bytes = bit_rate * 1024 / 8;
if (diff_bytes) {
int new_blocks = (num_blocks * need_bytes + diff_bytes/2) / diff_bytes;
num_blocks = (new_blocks + num_blocks + 1) / 2;
if (num_blocks > MAX_NUM_BLOCKS)
num_blocks = MAX_NUM_BLOCKS;
}
}
read_stat();
if (ftotal != ctotal && dtotal) {
int load, aload;
load = 1000 - didle * 1000 / dtotal;
aload = 1000 - (cidle - fidle) * 1000 / (ctotal - ftotal);
printf( "Overall Stats\n" );
printf( " Total Time: %7lld ms\n", t2 - start );
printf( " Block Size: %7ld\n", block_size );
printf( " Blocks/cycle: %7ld\n", num_blocks );
printf( " Blocks/second: %7lld\n", (blocks - last_blocks) * 1000 / diff_time );
printf( " Delay: %7d\n", delay );
printf( " CPU Load: %5d.%d %% (avg. %d.%d %%)\n",
load / 10, load % 10, aload / 10, aload % 10 );
}
last_bytes = bytes;
last_blocks = blocks;
}
if (run_busy) {
pthread_mutex_lock( &busy_lock );
if (last_busy) {
int busy_diff;
int busy_rate, busy_load;
int abusy_rate, abusy_load;
busy_diff = busy_count - last_busy;
busy_rate = max_busy - (busy_diff * 1000 / (t2 - t1));
busy_load = busy_rate * 1000 / max_busy;
abusy_rate = max_busy - (busy_count * 1000 / (t2 - start));
abusy_load = abusy_rate * 1000 / max_busy;
printf( " Real CPU Load: %5d.%d %% (avg. %d.%d %%)\n",
busy_load / 10, busy_load % 10,
abusy_load / 10, abusy_load % 10 );
}
last_busy = busy_count;
pthread_mutex_unlock( &busy_lock );
}
t1 = t2;
}
} while (active > 0);
if (run_busy) {
busy_alive = 0;
pthread_join( busy_thread, NULL );
}
return -1;
}
static void
poll_cpu (SpHostinfoSource *self)
{
gchar cpu[64] = { 0 };
glong user;
glong sys;
glong nice;
glong idle;
glong iowait;
glong irq;
glong softirq;
glong steal;
glong guest;
glong guest_nice;
glong user_calc;
glong system_calc;
glong nice_calc;
glong idle_calc;
glong iowait_calc;
glong irq_calc;
glong softirq_calc;
glong steal_calc;
glong guest_calc;
glong guest_nice_calc;
glong total;
gchar *line;
gint ret;
gint id;
if (read_stat (self))
{
line = self->stat_buf;
for (gsize i = 0; self->stat_buf[i]; i++)
{
if (self->stat_buf[i] == '\n')
{
self->stat_buf[i] = '\0';
if (strncmp (line, "cpu", 3) == 0)
{
if (isdigit (line[3]))
{
CpuInfo *cpu_info;
user = nice = sys = idle = id = 0;
ret = sscanf (line, "%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld",
cpu, &user, &nice, &sys, &idle,
&iowait, &irq, &softirq, &steal, &guest, &guest_nice);
if (ret != 11)
goto next;
ret = sscanf(cpu, "cpu%d", &id);
if (ret != 1 || id < 0 || id >= self->n_cpu)
goto next;
cpu_info = &g_array_index (self->cpu_info, CpuInfo, id);
user_calc = user - cpu_info->last_user;
nice_calc = nice - cpu_info->last_nice;
system_calc = sys - cpu_info->last_system;
idle_calc = idle - cpu_info->last_idle;
iowait_calc = iowait - cpu_info->last_iowait;
irq_calc = irq - cpu_info->last_irq;
softirq_calc = softirq - cpu_info->last_softirq;
steal_calc = steal - cpu_info->last_steal;
guest_calc = guest - cpu_info->last_guest;
guest_nice_calc = guest_nice - cpu_info->last_guest_nice;
total = user_calc + nice_calc + system_calc + idle_calc + iowait_calc + irq_calc + softirq_calc + steal_calc + guest_calc + guest_nice_calc;
cpu_info->total = ((total - idle_calc) / (gdouble)total) * 100.0;
cpu_info->last_user = user;
cpu_info->last_nice = nice;
cpu_info->last_idle = idle;
cpu_info->last_system = sys;
cpu_info->last_iowait = iowait;
cpu_info->last_irq = irq;
cpu_info->last_softirq = softirq;
cpu_info->last_steal = steal;
cpu_info->last_guest = guest;
cpu_info->last_guest_nice = guest_nice;
}
}
else
{
/* CPU info comes first. Skip further lines. */
break;
}
next:
line = &self->stat_buf[i + 1];
}
}
}
}
static void read_procs(void) {
DIR *proc_dir, *task_dir;
struct dirent *pid_dir, *tid_dir;
char filename[64];
FILE *file;
int proc_num;
struct proc_info *proc;
pid_t pid, tid;
int i;
proc_dir = opendir("/proc");
if (!proc_dir) die("Could not open /proc.\n");
new_procs = calloc(INIT_PROCS * (threads ? THREAD_MULT : 1), sizeof(struct proc_info *));
num_new_procs = INIT_PROCS * (threads ? THREAD_MULT : 1);
file = fopen("/proc/stat", "r");
if (!file) die("Could not open /proc/stat.\n");
fscanf(file, "cpu %lu %lu %lu %lu %lu %lu %lu", &new_cpu.utime, &new_cpu.ntime, &new_cpu.stime,
&new_cpu.itime, &new_cpu.iowtime, &new_cpu.irqtime, &new_cpu.sirqtime);
fclose(file);
proc_num = 0;
while ((pid_dir = readdir(proc_dir))) {
if (!isdigit(pid_dir->d_name[0]))
continue;
pid = atoi(pid_dir->d_name);
struct proc_info cur_proc;
if (!threads) {
proc = alloc_proc();
proc->pid = proc->tid = pid;
sprintf(filename, "/proc/%d/stat", pid);
read_stat(filename, proc);
sprintf(filename, "/proc/%d/cmdline", pid);
read_cmdline(filename, proc);
sprintf(filename, "/proc/%d/status", pid);
read_status(filename, proc);
read_policy(pid, proc);
proc->num_threads = 0;
} else {
sprintf(filename, "/proc/%d/cmdline", pid);
read_cmdline(filename, &cur_proc);
sprintf(filename, "/proc/%d/status", pid);
read_status(filename, &cur_proc);
proc = NULL;
}
sprintf(filename, "/proc/%d/task", pid);
task_dir = opendir(filename);
if (!task_dir) continue;
while ((tid_dir = readdir(task_dir))) {
if (!isdigit(tid_dir->d_name[0]))
continue;
if (threads) {
tid = atoi(tid_dir->d_name);
proc = alloc_proc();
proc->pid = pid; proc->tid = tid;
sprintf(filename, "/proc/%d/task/%d/stat", pid, tid);
read_stat(filename, proc);
read_policy(tid, proc);
strcpy(proc->name, cur_proc.name);
proc->uid = cur_proc.uid;
proc->gid = cur_proc.gid;
add_proc(proc_num++, proc);
} else {
proc->num_threads++;
}
}
closedir(task_dir);
if (!threads)
add_proc(proc_num++, proc);
}
for (i = proc_num; i < num_new_procs; i++)
new_procs[i] = NULL;
closedir(proc_dir);
}
