1 /* -*- mode: c; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*-
2 * vim: ts=4 sw=4 noet ai cindent syntax=c
4 * Conky, a system monitor, based on torsmo
6 * Any original torsmo code is licensed under the BSD license
8 * All code written since the fork of torsmo is licensed under the GPL
10 * Please see COPYING for details
12 * Copyright (c) 2005 Adi Zaimi, Dan Piponi <dan@tanelorn.demon.co.uk>,
13 * Dave Clark <clarkd@skynet.ca>
14 * Copyright (c) 2005-2009 Brenden Matthews, Philip Kovacs, et. al.
16 * All rights reserved.
18 * This program is free software: you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation, either version 3 of the License, or
21 * (at your option) any later version.
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program. If not, see <http://www.gnu.org/licenses/>.
35 static unsigned long g_time = 0;
36 static unsigned long long previous_total = 0;
37 static struct process *first_process = 0;
39 struct process *get_first_process(void)
44 void free_all_processes(void)
46 struct process *next = NULL, *pr = first_process;
59 struct process *get_process_by_name(const char *name)
61 struct process *p = first_process;
64 if (!strcmp(p->name, name))
71 static struct process *find_process(pid_t pid)
73 struct process *p = first_process;
84 /* Create a new process object and insert it into the process list */
85 static struct process *new_process(int p)
87 struct process *process;
88 process = (struct process *) malloc(sizeof(struct process));
90 // clean up memory first
91 memset(process, 0, sizeof(struct process));
93 /* Do stitching necessary for doubly linked list */
95 process->previous = 0;
96 process->next = first_process;
98 process->next->previous = process;
100 first_process = process;
103 process->time_stamp = 0;
104 process->previous_user_time = ULONG_MAX;
105 process->previous_kernel_time = ULONG_MAX;
107 process->previous_read_bytes = ULLONG_MAX;
108 process->previous_write_bytes = ULLONG_MAX;
110 process->counted = 1;
112 /* process_find_name(process); */
117 /******************************************
119 ******************************************/
121 /******************************************
122 * Extract information from /proc *
123 ******************************************/
125 /* These are the guts that extract information out of /proc.
126 * Anyone hoping to port wmtop should look here first. */
127 static int process_parse_stat(struct process *process)
129 struct information *cur = &info;
130 char line[BUFFER_LEN] = { 0 }, filename[BUFFER_LEN], procname[BUFFER_LEN];
132 unsigned long user_time = 0;
133 unsigned long kernel_time = 0;
138 char *lparen, *rparen;
140 snprintf(filename, sizeof(filename), PROCFS_TEMPLATE, process->pid);
142 ps = open(filename, O_RDONLY);
144 /* The process must have finished in the last few jiffies! */
148 /* Mark process as up-to-date. */
149 process->time_stamp = g_time;
151 rc = read(ps, line, sizeof(line));
157 /* Extract cpu times from data in /proc filesystem */
158 lparen = strchr(line, '(');
159 rparen = strrchr(line, ')');
160 if(!lparen || !rparen || rparen < lparen)
161 return 1; // this should not happen
163 rc = MIN((unsigned)(rparen - lparen - 1), sizeof(procname) - 1);
164 strncpy(procname, lparen + 1, rc);
166 rc = sscanf(rparen + 1, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %lu "
167 "%lu %*s %*s %*s %d %*s %*s %*s %u %u", &process->user_time,
168 &process->kernel_time, &nice_val, &process->vsize, &process->rss);
172 /* remove any "kdeinit: " */
173 if (procname == strstr(procname, "kdeinit")) {
174 snprintf(filename, sizeof(filename), PROCFS_CMDLINE_TEMPLATE,
177 ps = open(filename, O_RDONLY);
179 /* The process must have finished in the last few jiffies! */
183 endl = read(ps, line, sizeof(line));
186 /* null terminate the input */
188 /* account for "kdeinit: " */
189 if ((char *) line == strstr(line, "kdeinit: ")) {
190 r = ((char *) line) + 9;
197 while (*r && *r != ' ') {
206 process->name = strndup(procname, text_buffer_size);
207 process->rss *= getpagesize();
210 update_total_processes();
213 process->total_cpu_time = process->user_time + process->kernel_time;
214 process->totalmem = (float) (((float) process->rss / cur->memmax) / 10);
215 if (process->previous_user_time == ULONG_MAX) {
216 process->previous_user_time = process->user_time;
218 if (process->previous_kernel_time == ULONG_MAX) {
219 process->previous_kernel_time = process->kernel_time;
222 /* store the difference of the user_time */
223 user_time = process->user_time - process->previous_user_time;
224 kernel_time = process->kernel_time - process->previous_kernel_time;
226 /* backup the process->user_time for next time around */
227 process->previous_user_time = process->user_time;
228 process->previous_kernel_time = process->kernel_time;
230 /* store only the difference of the user_time here... */
231 process->user_time = user_time;
232 process->kernel_time = kernel_time;
238 static int process_parse_io(struct process *process)
240 static const char *read_bytes_str="read_bytes:";
241 static const char *write_bytes_str="write_bytes:";
243 char line[BUFFER_LEN] = { 0 }, filename[BUFFER_LEN];
247 unsigned long long read_bytes, write_bytes;
249 snprintf(filename, sizeof(filename), PROCFS_TEMPLATE_IO, process->pid);
251 ps = open(filename, O_RDONLY);
253 /* The process must have finished in the last few jiffies!
254 * Or, the kernel doesn't support I/O accounting.
259 rc = read(ps, line, sizeof(line));
265 pos = strstr(line, read_bytes_str);
267 /* these should not happen (unless the format of the file changes) */
270 pos += strlen(read_bytes_str);
271 process->read_bytes = strtoull(pos, &endpos, 10);
276 pos = strstr(line, write_bytes_str);
280 pos += strlen(write_bytes_str);
281 process->write_bytes = strtoull(pos, &endpos, 10);
286 if (process->previous_read_bytes == ULLONG_MAX) {
287 process->previous_read_bytes = process->read_bytes;
289 if (process->previous_write_bytes == ULLONG_MAX) {
290 process->previous_write_bytes = process->write_bytes;
293 /* store the difference of the byte counts */
294 read_bytes = process->read_bytes - process->previous_read_bytes;
295 write_bytes = process->write_bytes - process->previous_write_bytes;
297 /* backup the counts for next time around */
298 process->previous_read_bytes = process->read_bytes;
299 process->previous_write_bytes = process->write_bytes;
301 /* store only the difference here... */
302 process->read_bytes = read_bytes;
303 process->write_bytes = write_bytes;
309 /******************************************
310 * Get process structure for process pid *
311 ******************************************/
313 /* This function seems to hog all of the CPU time.
314 * I can't figure out why - it doesn't do much. */
315 static int calculate_stats(struct process *process)
319 /* compute each process cpu usage by reading /proc/<proc#>/stat */
320 rc = process_parse_stat(process);
322 /* rc = process_parse_statm(process); if (rc) return 1; */
325 rc = process_parse_io(process);
330 * Check name against the exclusion list
332 /* if (process->counted && exclusion_expression &&
333 * !regexec(exclusion_expression, process->name, 0, 0, 0))
334 * process->counted = 0; */
339 /******************************************
340 * Update process table *
341 ******************************************/
343 static int update_process_table(void)
346 struct dirent *entry;
348 if (!(dir = opendir("/proc"))) {
354 /* Get list of processes from /proc directory */
355 while ((entry = readdir(dir))) {
359 /* Problem reading list of processes */
364 if (sscanf(entry->d_name, "%d", &pid) > 0) {
367 p = find_process(pid);
369 p = new_process(pid);
372 /* compute each process cpu usage */
382 /******************************************
383 * Destroy and remove a process *
384 ******************************************/
386 static void delete_process(struct process *p)
388 #if defined(PARANOID)
389 assert(p->id == 0x0badfeed);
392 * Ensure that deleted processes aren't reused.
395 #endif /* defined(PARANOID) */
398 * Maintain doubly linked list.
401 p->next->previous = p->previous;
403 p->previous->next = p->next;
405 first_process = p->next;
413 /******************************************
414 * Strip dead process entries *
415 ******************************************/
417 static void process_cleanup(void)
420 struct process *p = first_process;
423 struct process *current = p;
425 #if defined(PARANOID)
426 assert(p->id == 0x0badfeed);
427 #endif /* defined(PARANOID) */
430 /* Delete processes that have died */
431 if (current->time_stamp != g_time) {
432 delete_process(current);
437 /******************************************
438 * Calculate cpu total *
439 ******************************************/
440 #define TMPL_SHORTPROC "%*s %llu %llu %llu %llu"
441 #define TMPL_LONGPROC "%*s %llu %llu %llu %llu %llu %llu %llu %llu"
443 static unsigned long long calc_cpu_total(void)
445 unsigned long long total = 0;
446 unsigned long long t = 0;
449 char line[BUFFER_LEN] = { 0 };
450 unsigned long long cpu = 0;
451 unsigned long long niceval = 0;
452 unsigned long long systemval = 0;
453 unsigned long long idle = 0;
454 unsigned long long iowait = 0;
455 unsigned long long irq = 0;
456 unsigned long long softirq = 0;
457 unsigned long long steal = 0;
458 const char *template =
459 KFLAG_ISSET(KFLAG_IS_LONGSTAT) ? TMPL_LONGPROC : TMPL_SHORTPROC;
461 ps = open("/proc/stat", O_RDONLY);
462 rc = read(ps, line, sizeof(line));
468 sscanf(line, template, &cpu, &niceval, &systemval, &idle, &iowait, &irq,
470 total = cpu + niceval + systemval + idle + iowait + irq + softirq + steal;
472 t = total - previous_total;
473 previous_total = total;
478 /******************************************
479 * Calculate each processes cpu *
480 ******************************************/
482 inline static void calc_cpu_each(unsigned long long total)
484 struct process *p = first_process;
487 p->amount = 100.0 * (cpu_separate ? info.cpu_count : 1) *
488 (p->user_time + p->kernel_time) / (float) total;
495 static void calc_io_each(void)
498 unsigned long long sum = 0;
500 for (p = first_process; p; p = p->next)
501 sum += p->read_bytes + p->write_bytes;
504 sum = 1; /* to avoid having NANs if no I/O occured */
505 for (p = first_process; p; p = p->next)
506 p->io_perc = 100.0 * (p->read_bytes + p->write_bytes) / (float) sum;
510 /******************************************
511 * Find the top processes *
512 ******************************************/
514 /* free a sp_process structure */
515 static void free_sp(struct sorted_process *sp)
520 /* create a new sp_process structure */
521 static struct sorted_process *malloc_sp(struct process *proc)
523 struct sorted_process *sp;
524 sp = malloc(sizeof(struct sorted_process));
525 memset(sp, 0, sizeof(struct sorted_process));
530 /* cpu comparison function for insert_sp_element */
531 static int compare_cpu(struct process *a, struct process *b)
533 if (a->amount < b->amount) {
535 } else if (a->amount > b->amount) {
542 /* mem comparison function for insert_sp_element */
543 static int compare_mem(struct process *a, struct process *b)
545 if (a->totalmem < b->totalmem) {
547 } else if (a->totalmem > b->totalmem) {
554 /* CPU time comparision function for insert_sp_element */
555 static int compare_time(struct process *a, struct process *b)
557 return b->total_cpu_time - a->total_cpu_time;
561 /* I/O comparision function for insert_sp_element */
562 static int compare_io(struct process *a, struct process *b)
564 if (a->io_perc < b->io_perc) {
566 } else if (a->io_perc > b->io_perc) {
574 /* insert this process into the list in a sorted fashion,
575 * or destroy it if it doesn't fit on the list */
576 static int insert_sp_element(struct sorted_process *sp_cur,
577 struct sorted_process **p_sp_head, struct sorted_process **p_sp_tail,
578 int max_elements, int compare_funct(struct process *, struct process *))
581 struct sorted_process *sp_readthru = NULL, *sp_destroy = NULL;
582 int did_insert = 0, x = 0;
584 if (*p_sp_head == NULL) {
589 for (sp_readthru = *p_sp_head, x = 0;
590 sp_readthru != NULL && x < max_elements;
591 sp_readthru = sp_readthru->less, x++) {
592 if (compare_funct(sp_readthru->proc, sp_cur->proc) > 0 && !did_insert) {
593 /* sp_cur is bigger than sp_readthru
594 * so insert it before sp_readthru */
595 sp_cur->less = sp_readthru;
596 if (sp_readthru == *p_sp_head) {
597 /* insert as the new head of the list */
600 /* insert inside the list */
601 sp_readthru->greater->less = sp_cur;
602 sp_cur->greater = sp_readthru->greater;
604 sp_readthru->greater = sp_cur;
605 /* element was inserted, so increase the counter */
609 if (x < max_elements && sp_readthru == NULL && !did_insert) {
610 /* sp_cur is the smallest element and list isn't full,
611 * so insert at the end */
612 (*p_sp_tail)->less = sp_cur;
613 sp_cur->greater = *p_sp_tail;
616 } else if (x >= max_elements) {
617 /* We inserted an element and now the list is too big by one.
618 * Destroy the smallest element */
619 sp_destroy = *p_sp_tail;
620 *p_sp_tail = sp_destroy->greater;
621 (*p_sp_tail)->less = NULL;
625 /* sp_cur wasn't added to the sorted list, so destroy it */
631 /* copy the procs in the sorted list to the array, and destroy the list */
632 static void sp_acopy(struct sorted_process *sp_head, struct process **ar, int max_size)
634 struct sorted_process *sp_cur, *sp_tmp;
638 for (x = 0; x < max_size && sp_cur != NULL; x++) {
639 ar[x] = sp_cur->proc;
641 sp_cur = sp_cur->less;
646 /* ****************************************************************** *
647 * Get a sorted list of the top cpu hogs and top mem hogs. *
648 * Results are stored in the cpu,mem arrays in decreasing order[0-9]. *
649 * ****************************************************************** */
651 void process_find_top(struct process **cpu, struct process **mem,
652 struct process **ptime
654 , struct process **io
658 struct sorted_process *spc_head = NULL, *spc_tail = NULL, *spc_cur = NULL;
659 struct sorted_process *spm_head = NULL, *spm_tail = NULL, *spm_cur = NULL;
660 struct sorted_process *spt_head = NULL, *spt_tail = NULL, *spt_cur = NULL;
662 struct sorted_process *spi_head = NULL, *spi_tail = NULL, *spi_cur = NULL;
664 struct process *cur_proc = NULL;
665 unsigned long long total = 0;
667 if (!top_cpu && !top_mem && !top_time
676 total = calc_cpu_total(); /* calculate the total of the processor */
677 update_process_table(); /* update the table with process list */
678 calc_cpu_each(total); /* and then the percentage for each task */
679 process_cleanup(); /* cleanup list from exited processes */
681 calc_io_each(); /* percentage of I/O for each task */
684 cur_proc = first_process;
686 while (cur_proc != NULL) {
688 spc_cur = malloc_sp(cur_proc);
689 insert_sp_element(spc_cur, &spc_head, &spc_tail, MAX_SP,
693 spm_cur = malloc_sp(cur_proc);
694 insert_sp_element(spm_cur, &spm_head, &spm_tail, MAX_SP,
698 spt_cur = malloc_sp(cur_proc);
699 insert_sp_element(spt_cur, &spt_head, &spt_tail, MAX_SP,
704 spi_cur = malloc_sp(cur_proc);
705 insert_sp_element(spi_cur, &spi_head, &spi_tail, MAX_SP,
709 cur_proc = cur_proc->next;
712 if (top_cpu) sp_acopy(spc_head, cpu, MAX_SP);
713 if (top_mem) sp_acopy(spm_head, mem, MAX_SP);
714 if (top_time) sp_acopy(spt_head, ptime, MAX_SP);
716 if (top_io) sp_acopy(spi_head, io, MAX_SP);
720 int parse_top_args(const char *s, const char *arg, struct text_object *obj)
725 if (obj->data.top.was_parsed) {
728 obj->data.top.was_parsed = 1;
730 if (arg && !obj->data.top.s) {
731 obj->data.top.s = strndup(arg, text_buffer_size);
737 } else if (strcmp(&s[3], "_mem") == EQUAL) {
738 obj->type = OBJ_top_mem;
740 } else if (strcmp(&s[3], "_time") == EQUAL) {
741 obj->type = OBJ_top_time;
744 } else if (strcmp(&s[3], "_io") == EQUAL) {
745 obj->type = OBJ_top_io;
750 NORM_ERR("Must be top, top_mem, top_time or top_io");
752 NORM_ERR("Must be top, top_mem or top_time");
758 NORM_ERR("top needs arguments");
762 if (sscanf(arg, "%63s %i", buf, &n) == 2) {
763 if (strcmp(buf, "name") == EQUAL) {
764 obj->data.top.type = TOP_NAME;
765 } else if (strcmp(buf, "cpu") == EQUAL) {
766 obj->data.top.type = TOP_CPU;
767 } else if (strcmp(buf, "pid") == EQUAL) {
768 obj->data.top.type = TOP_PID;
769 } else if (strcmp(buf, "mem") == EQUAL) {
770 obj->data.top.type = TOP_MEM;
771 } else if (strcmp(buf, "time") == EQUAL) {
772 obj->data.top.type = TOP_TIME;
773 } else if (strcmp(buf, "mem_res") == EQUAL) {
774 obj->data.top.type = TOP_MEM_RES;
775 } else if (strcmp(buf, "mem_vsize") == EQUAL) {
776 obj->data.top.type = TOP_MEM_VSIZE;
778 } else if (strcmp(buf, "io_read") == EQUAL) {
779 obj->data.top.type = TOP_READ_BYTES;
780 } else if (strcmp(buf, "io_write") == EQUAL) {
781 obj->data.top.type = TOP_WRITE_BYTES;
782 } else if (strcmp(buf, "io_perc") == EQUAL) {
783 obj->data.top.type = TOP_IO_PERC;
786 NORM_ERR("invalid type arg for top");
788 NORM_ERR("must be one of: name, cpu, pid, mem, time, mem_res, mem_vsize, "
789 "io_read, io_write, io_perc");
791 NORM_ERR("must be one of: name, cpu, pid, mem, time, mem_res, mem_vsize");
795 if (n < 1 || n > 10) {
796 NORM_ERR("invalid num arg for top. Must be between 1 and 10.");
799 obj->data.top.num = n - 1;
802 NORM_ERR("invalid argument count for top");