/* -*- mode: c; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*- * vim: ts=4 sw=4 noet ai cindent syntax=c * * Conky, a system monitor, based on torsmo * * Any original torsmo code is licensed under the BSD license * * All code written since the fork of torsmo is licensed under the GPL * * Please see COPYING for details * * Copyright (c) 2005 Adi Zaimi, Dan Piponi , * Dave Clark * Copyright (c) 2005-2009 Brenden Matthews, Philip Kovacs, et. al. * (see AUTHORS) * All rights reserved. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program. If not, see . * */ #include "top.h" #include "logging.h" static unsigned long g_time = 0; static unsigned long long previous_total = 0; static struct process *first_process = 0; /* a simple hash table to speed up find_process() */ struct proc_hash_entry { struct proc_hash_entry *next; struct process *proc; }; static struct proc_hash_entry proc_hash_table[256]; static void hash_process(struct process *p) { struct proc_hash_entry *phe; static char first_run = 1; /* better make sure all next pointers are zero upon first access */ if (first_run) { memset(proc_hash_table, 0, sizeof(struct proc_hash_entry) * 256); first_run = 0; } /* get the bucket head */ phe = &proc_hash_table[p->pid % 256]; /* find the bucket's end */ while (phe->next) phe = phe->next; /* append process */ phe->next = malloc(sizeof(struct proc_hash_entry)); memset(phe->next, 0, sizeof(struct proc_hash_entry)); phe->next->proc = p; } static void unhash_process(struct process *p) { struct proc_hash_entry *phe, *tmp; /* get the bucket head */ phe = &proc_hash_table[p->pid % 256]; /* find the entry pointing to p and drop it */ while (phe->next) { if (phe->next->proc == p) { tmp = phe->next; phe->next = phe->next->next; free(tmp); return; } phe = phe->next; } } static void __unhash_all_processes(struct proc_hash_entry *phe) { if (phe->next) __unhash_all_processes(phe->next); free(phe->next); } static void unhash_all_processes(void) { int i; for (i = 0; i < 256; i++) { __unhash_all_processes(&proc_hash_table[i]); proc_hash_table[i].next = NULL; } } struct process *get_first_process(void) { return first_process; } void free_all_processes(void) { struct process *next = NULL, *pr = first_process; while (pr) { next = pr->next; if (pr->name) { free(pr->name); } free(pr); pr = next; } first_process = NULL; /* drop the whole hash table */ unhash_all_processes(); } struct process *get_process_by_name(const char *name) { struct process *p = first_process; while (p) { if (!strcmp(p->name, name)) return p; p = p->next; } return 0; } static struct process *find_process(pid_t pid) { struct proc_hash_entry *phe; phe = &proc_hash_table[pid % 256]; while (phe->next) { if (phe->next->proc->pid == pid) return phe->next->proc; phe = phe->next; } return 0; } /* Create a new process object and insert it into the process list */ static struct process *new_process(int p) { struct process *process; process = (struct process *) malloc(sizeof(struct process)); // clean up memory first memset(process, 0, sizeof(struct process)); /* Do stitching necessary for doubly linked list */ process->name = 0; process->previous = 0; process->next = first_process; if (process->next) { process->next->previous = process; } first_process = process; process->pid = p; process->time_stamp = 0; process->previous_user_time = ULONG_MAX; process->previous_kernel_time = ULONG_MAX; #ifdef IOSTATS process->previous_read_bytes = ULLONG_MAX; process->previous_write_bytes = ULLONG_MAX; #endif /* IOSTATS */ process->counted = 1; /* process_find_name(process); */ /* add the process to the hash table */ hash_process(process); return process; } /****************************************** * Functions * ******************************************/ /****************************************** * Extract information from /proc * ******************************************/ /* These are the guts that extract information out of /proc. * Anyone hoping to port wmtop should look here first. */ static int process_parse_stat(struct process *process) { char line[BUFFER_LEN] = { 0 }, filename[BUFFER_LEN], procname[BUFFER_LEN]; int ps; unsigned long user_time = 0; unsigned long kernel_time = 0; int rc; char *r, *q; int endl; int nice_val; char *lparen, *rparen; snprintf(filename, sizeof(filename), PROCFS_TEMPLATE, process->pid); ps = open(filename, O_RDONLY); if (ps < 0) { /* The process must have finished in the last few jiffies! */ return 1; } /* Mark process as up-to-date. */ process->time_stamp = g_time; rc = read(ps, line, sizeof(line)); close(ps); if (rc < 0) { return 1; } /* Extract cpu times from data in /proc filesystem */ lparen = strchr(line, '('); rparen = strrchr(line, ')'); if(!lparen || !rparen || rparen < lparen) return 1; // this should not happen rc = MIN((unsigned)(rparen - lparen - 1), sizeof(procname) - 1); strncpy(procname, lparen + 1, rc); procname[rc] = '\0'; rc = sscanf(rparen + 1, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %lu " "%lu %*s %*s %*s %d %*s %*s %*s %u %u", &process->user_time, &process->kernel_time, &nice_val, &process->vsize, &process->rss); if (rc < 5) { NORM_ERR("scaning data for %s failed, got only %d fields", procname, rc); return 1; } /* remove any "kdeinit: " */ if (procname == strstr(procname, "kdeinit")) { snprintf(filename, sizeof(filename), PROCFS_CMDLINE_TEMPLATE, process->pid); ps = open(filename, O_RDONLY); if (ps < 0) { /* The process must have finished in the last few jiffies! */ return 1; } endl = read(ps, line, sizeof(line)); close(ps); /* null terminate the input */ line[endl] = 0; /* account for "kdeinit: " */ if ((char *) line == strstr(line, "kdeinit: ")) { r = ((char *) line) + 9; } else { r = (char *) line; } q = procname; /* stop at space */ while (*r && *r != ' ') { *q++ = *r++; } *q = 0; } if (process->name) { free(process->name); } process->name = strndup(procname, text_buffer_size); process->rss *= getpagesize(); process->total_cpu_time = process->user_time + process->kernel_time; if (process->previous_user_time == ULONG_MAX) { process->previous_user_time = process->user_time; } if (process->previous_kernel_time == ULONG_MAX) { process->previous_kernel_time = process->kernel_time; } /* strangely, the values aren't monotonous */ if (process->previous_user_time > process->user_time) process->previous_user_time = process->user_time; if (process->previous_kernel_time > process->kernel_time) process->previous_kernel_time = process->kernel_time; /* store the difference of the user_time */ user_time = process->user_time - process->previous_user_time; kernel_time = process->kernel_time - process->previous_kernel_time; /* backup the process->user_time for next time around */ process->previous_user_time = process->user_time; process->previous_kernel_time = process->kernel_time; /* store only the difference of the user_time here... */ process->user_time = user_time; process->kernel_time = kernel_time; return 0; } #ifdef IOSTATS static int process_parse_io(struct process *process) { static const char *read_bytes_str="read_bytes:"; static const char *write_bytes_str="write_bytes:"; char line[BUFFER_LEN] = { 0 }, filename[BUFFER_LEN]; int ps; int rc; char *pos, *endpos; unsigned long long read_bytes, write_bytes; snprintf(filename, sizeof(filename), PROCFS_TEMPLATE_IO, process->pid); ps = open(filename, O_RDONLY); if (ps < 0) { /* The process must have finished in the last few jiffies! * Or, the kernel doesn't support I/O accounting. */ return 1; } rc = read(ps, line, sizeof(line)); close(ps); if (rc < 0) { return 1; } pos = strstr(line, read_bytes_str); if (pos == NULL) { /* these should not happen (unless the format of the file changes) */ return 1; } pos += strlen(read_bytes_str); process->read_bytes = strtoull(pos, &endpos, 10); if (endpos == pos) { return 1; } pos = strstr(line, write_bytes_str); if (pos == NULL) { return 1; } pos += strlen(write_bytes_str); process->write_bytes = strtoull(pos, &endpos, 10); if (endpos == pos) { return 1; } if (process->previous_read_bytes == ULLONG_MAX) { process->previous_read_bytes = process->read_bytes; } if (process->previous_write_bytes == ULLONG_MAX) { process->previous_write_bytes = process->write_bytes; } /* store the difference of the byte counts */ read_bytes = process->read_bytes - process->previous_read_bytes; write_bytes = process->write_bytes - process->previous_write_bytes; /* backup the counts for next time around */ process->previous_read_bytes = process->read_bytes; process->previous_write_bytes = process->write_bytes; /* store only the difference here... */ process->read_bytes = read_bytes; process->write_bytes = write_bytes; return 0; } #endif /* IOSTATS */ /****************************************** * Get process structure for process pid * ******************************************/ /* This function seems to hog all of the CPU time. * I can't figure out why - it doesn't do much. */ static int calculate_stats(struct process *process) { int rc; /* compute each process cpu usage by reading /proc//stat */ rc = process_parse_stat(process); if (rc) return 1; /* rc = process_parse_statm(process); if (rc) return 1; */ #ifdef IOSTATS rc = process_parse_io(process); if (rc) return 1; #endif /* IOSTATS */ /* * Check name against the exclusion list */ /* if (process->counted && exclusion_expression && * !regexec(exclusion_expression, process->name, 0, 0, 0)) * process->counted = 0; */ return 0; } /****************************************** * Update process table * ******************************************/ static int update_process_table(void) { DIR *dir; struct dirent *entry; if (!(dir = opendir("/proc"))) { return 1; } ++g_time; /* Get list of processes from /proc directory */ while ((entry = readdir(dir))) { pid_t pid; if (!entry) { /* Problem reading list of processes */ closedir(dir); return 1; } if (sscanf(entry->d_name, "%d", &pid) > 0) { struct process *p; p = find_process(pid); if (!p) { p = new_process(pid); } /* compute each process cpu usage */ calculate_stats(p); } } closedir(dir); return 0; } /****************************************** * Destroy and remove a process * ******************************************/ static void delete_process(struct process *p) { #if defined(PARANOID) assert(p->id == 0x0badfeed); /* * Ensure that deleted processes aren't reused. */ p->id = 0x007babe; #endif /* defined(PARANOID) */ /* * Maintain doubly linked list. */ if (p->next) p->next->previous = p->previous; if (p->previous) p->previous->next = p->next; else first_process = p->next; if (p->name) { free(p->name); } /* remove the process from the hash table */ unhash_process(p); free(p); } /****************************************** * Strip dead process entries * ******************************************/ static void process_cleanup(void) { struct process *p = first_process; while (p) { struct process *current = p; #if defined(PARANOID) assert(p->id == 0x0badfeed); #endif /* defined(PARANOID) */ p = p->next; /* Delete processes that have died */ if (current->time_stamp != g_time) { delete_process(current); } } } /****************************************** * Calculate cpu total * ******************************************/ #define TMPL_SHORTPROC "%*s %llu %llu %llu %llu" #define TMPL_LONGPROC "%*s %llu %llu %llu %llu %llu %llu %llu %llu" static unsigned long long calc_cpu_total(void) { unsigned long long total = 0; unsigned long long t = 0; int rc; int ps; char line[BUFFER_LEN] = { 0 }; unsigned long long cpu = 0; unsigned long long niceval = 0; unsigned long long systemval = 0; unsigned long long idle = 0; unsigned long long iowait = 0; unsigned long long irq = 0; unsigned long long softirq = 0; unsigned long long steal = 0; const char *template = KFLAG_ISSET(KFLAG_IS_LONGSTAT) ? TMPL_LONGPROC : TMPL_SHORTPROC; ps = open("/proc/stat", O_RDONLY); rc = read(ps, line, sizeof(line)); close(ps); if (rc < 0) { return 0; } sscanf(line, template, &cpu, &niceval, &systemval, &idle, &iowait, &irq, &softirq, &steal); total = cpu + niceval + systemval + idle + iowait + irq + softirq + steal; t = total - previous_total; previous_total = total; return t; } /****************************************** * Calculate each processes cpu * ******************************************/ inline static void calc_cpu_each(unsigned long long total) { struct process *p = first_process; while (p) { p->amount = 100.0 * (cpu_separate ? info.cpu_count : 1) * (p->user_time + p->kernel_time) / (float) total; p = p->next; } } #ifdef IOSTATS static void calc_io_each(void) { struct process *p; unsigned long long sum = 0; for (p = first_process; p; p = p->next) sum += p->read_bytes + p->write_bytes; if(sum == 0) sum = 1; /* to avoid having NANs if no I/O occured */ for (p = first_process; p; p = p->next) p->io_perc = 100.0 * (p->read_bytes + p->write_bytes) / (float) sum; } #endif /* IOSTATS */ /****************************************** * Find the top processes * ******************************************/ /* free a sp_process structure */ static void free_sp(struct sorted_process *sp) { free(sp); } /* create a new sp_process structure */ static struct sorted_process *malloc_sp(struct process *proc) { struct sorted_process *sp; sp = malloc(sizeof(struct sorted_process)); memset(sp, 0, sizeof(struct sorted_process)); sp->proc = proc; return sp; } /* cpu comparison function for insert_sp_element */ static int compare_cpu(struct process *a, struct process *b) { if (a->amount < b->amount) { return 1; } else if (a->amount > b->amount) { return -1; } else { return 0; } } /* mem comparison function for insert_sp_element */ static int compare_mem(struct process *a, struct process *b) { if (a->rss < b->rss) { return 1; } else if (a->rss > b->rss) { return -1; } else { return 0; } } /* CPU time comparision function for insert_sp_element */ static int compare_time(struct process *a, struct process *b) { return b->total_cpu_time - a->total_cpu_time; } #ifdef IOSTATS /* I/O comparision function for insert_sp_element */ static int compare_io(struct process *a, struct process *b) { if (a->io_perc < b->io_perc) { return 1; } else if (a->io_perc > b->io_perc) { return -1; } else { return 0; } } #endif /* IOSTATS */ /* insert this process into the list in a sorted fashion, * or destroy it if it doesn't fit on the list */ static int insert_sp_element(struct sorted_process *sp_cur, struct sorted_process **p_sp_head, struct sorted_process **p_sp_tail, int max_elements, int compare_funct(struct process *, struct process *)) { struct sorted_process *sp_readthru = NULL, *sp_destroy = NULL; int did_insert = 0, x = 0; if (*p_sp_head == NULL) { *p_sp_head = sp_cur; *p_sp_tail = sp_cur; return 1; } for (sp_readthru = *p_sp_head, x = 0; sp_readthru != NULL && x < max_elements; sp_readthru = sp_readthru->less, x++) { if (compare_funct(sp_readthru->proc, sp_cur->proc) > 0 && !did_insert) { /* sp_cur is bigger than sp_readthru * so insert it before sp_readthru */ sp_cur->less = sp_readthru; if (sp_readthru == *p_sp_head) { /* insert as the new head of the list */ *p_sp_head = sp_cur; } else { /* insert inside the list */ sp_readthru->greater->less = sp_cur; sp_cur->greater = sp_readthru->greater; } sp_readthru->greater = sp_cur; /* element was inserted, so increase the counter */ did_insert = ++x; } } if (x < max_elements && sp_readthru == NULL && !did_insert) { /* sp_cur is the smallest element and list isn't full, * so insert at the end */ (*p_sp_tail)->less = sp_cur; sp_cur->greater = *p_sp_tail; *p_sp_tail = sp_cur; did_insert = x; } else if (x >= max_elements) { /* We inserted an element and now the list is too big by one. * Destroy the smallest element */ sp_destroy = *p_sp_tail; *p_sp_tail = sp_destroy->greater; (*p_sp_tail)->less = NULL; free_sp(sp_destroy); } if (!did_insert) { /* sp_cur wasn't added to the sorted list, so destroy it */ free_sp(sp_cur); } return did_insert; } /* copy the procs in the sorted list to the array, and destroy the list */ static void sp_acopy(struct sorted_process *sp_head, struct process **ar, int max_size) { struct sorted_process *sp_cur, *sp_tmp; int x; sp_cur = sp_head; for (x = 0; x < max_size && sp_cur != NULL; x++) { ar[x] = sp_cur->proc; sp_tmp = sp_cur; sp_cur = sp_cur->less; free_sp(sp_tmp); } } /* ****************************************************************** * * Get a sorted list of the top cpu hogs and top mem hogs. * * Results are stored in the cpu,mem arrays in decreasing order[0-9]. * * ****************************************************************** */ void process_find_top(struct process **cpu, struct process **mem, struct process **ptime #ifdef IOSTATS , struct process **io #endif /* IOSTATS */ ) { struct sorted_process *spc_head = NULL, *spc_tail = NULL, *spc_cur = NULL; struct sorted_process *spm_head = NULL, *spm_tail = NULL, *spm_cur = NULL; struct sorted_process *spt_head = NULL, *spt_tail = NULL, *spt_cur = NULL; #ifdef IOSTATS struct sorted_process *spi_head = NULL, *spi_tail = NULL, *spi_cur = NULL; #endif /* IOSTATS */ struct process *cur_proc = NULL; unsigned long long total = 0; if (!top_cpu && !top_mem && !top_time #ifdef IOSTATS && !top_io #endif /* IOSTATS */ && !top_running ) { return; } total = calc_cpu_total(); /* calculate the total of the processor */ update_process_table(); /* update the table with process list */ calc_cpu_each(total); /* and then the percentage for each task */ process_cleanup(); /* cleanup list from exited processes */ #ifdef IOSTATS calc_io_each(); /* percentage of I/O for each task */ #endif /* IOSTATS */ cur_proc = first_process; while (cur_proc != NULL) { if (top_cpu) { spc_cur = malloc_sp(cur_proc); insert_sp_element(spc_cur, &spc_head, &spc_tail, MAX_SP, &compare_cpu); } if (top_mem) { spm_cur = malloc_sp(cur_proc); insert_sp_element(spm_cur, &spm_head, &spm_tail, MAX_SP, &compare_mem); } if (top_time) { spt_cur = malloc_sp(cur_proc); insert_sp_element(spt_cur, &spt_head, &spt_tail, MAX_SP, &compare_time); } #ifdef IOSTATS if (top_io) { spi_cur = malloc_sp(cur_proc); insert_sp_element(spi_cur, &spi_head, &spi_tail, MAX_SP, &compare_io); } #endif /* IOSTATS */ cur_proc = cur_proc->next; } if (top_cpu) sp_acopy(spc_head, cpu, MAX_SP); if (top_mem) sp_acopy(spm_head, mem, MAX_SP); if (top_time) sp_acopy(spt_head, ptime, MAX_SP); #ifdef IOSTATS if (top_io) sp_acopy(spi_head, io, MAX_SP); #endif /* IOSTATS */ } struct top_data { int num; int type; int was_parsed; char *s; }; int parse_top_args(const char *s, const char *arg, struct text_object *obj) { struct top_data *td; char buf[64]; int n; if (!arg) { NORM_ERR("top needs arguments"); return 0; } if (obj->data.opaque) { return 1; } if (s[3] == 0) { obj->type = OBJ_top; top_cpu = 1; } else if (strcmp(&s[3], "_mem") == EQUAL) { obj->type = OBJ_top_mem; top_mem = 1; } else if (strcmp(&s[3], "_time") == EQUAL) { obj->type = OBJ_top_time; top_time = 1; #ifdef IOSTATS } else if (strcmp(&s[3], "_io") == EQUAL) { obj->type = OBJ_top_io; top_io = 1; #endif /* IOSTATS */ } else { #ifdef IOSTATS NORM_ERR("Must be top, top_mem, top_time or top_io"); #else /* IOSTATS */ NORM_ERR("Must be top, top_mem or top_time"); #endif /* IOSTATS */ return 0; } obj->data.opaque = td = malloc(sizeof(struct top_data)); memset(td, 0, sizeof(struct top_data)); td->s = strndup(arg, text_buffer_size); if (sscanf(arg, "%63s %i", buf, &n) == 2) { if (strcmp(buf, "name") == EQUAL) { td->type = TOP_NAME; } else if (strcmp(buf, "cpu") == EQUAL) { td->type = TOP_CPU; } else if (strcmp(buf, "pid") == EQUAL) { td->type = TOP_PID; } else if (strcmp(buf, "mem") == EQUAL) { td->type = TOP_MEM; } else if (strcmp(buf, "time") == EQUAL) { td->type = TOP_TIME; } else if (strcmp(buf, "mem_res") == EQUAL) { td->type = TOP_MEM_RES; } else if (strcmp(buf, "mem_vsize") == EQUAL) { td->type = TOP_MEM_VSIZE; #ifdef IOSTATS } else if (strcmp(buf, "io_read") == EQUAL) { td->type = TOP_READ_BYTES; } else if (strcmp(buf, "io_write") == EQUAL) { td->type = TOP_WRITE_BYTES; } else if (strcmp(buf, "io_perc") == EQUAL) { td->type = TOP_IO_PERC; #endif /* IOSTATS */ } else { NORM_ERR("invalid type arg for top"); #ifdef IOSTATS NORM_ERR("must be one of: name, cpu, pid, mem, time, mem_res, mem_vsize, " "io_read, io_write, io_perc"); #else /* IOSTATS */ NORM_ERR("must be one of: name, cpu, pid, mem, time, mem_res, mem_vsize"); #endif /* IOSTATS */ return 0; } if (n < 1 || n > 10) { NORM_ERR("invalid num arg for top. Must be between 1 and 10."); return 0; } else { td->num = n - 1; } } else { NORM_ERR("invalid argument count for top"); return 0; } return 1; } static char *format_time(unsigned long timeval, const int width) { char buf[10]; unsigned long nt; // narrow time, for speed on 32-bit unsigned cc; // centiseconds unsigned nn; // multi-purpose whatever nt = timeval; cc = nt % 100; // centiseconds past second nt /= 100; // total seconds nn = nt % 60; // seconds past the minute nt /= 60; // total minutes if (width >= snprintf(buf, sizeof buf, "%lu:%02u.%02u", nt, nn, cc)) { return strndup(buf, text_buffer_size); } if (width >= snprintf(buf, sizeof buf, "%lu:%02u", nt, nn)) { return strndup(buf, text_buffer_size); } nn = nt % 60; // minutes past the hour nt /= 60; // total hours if (width >= snprintf(buf, sizeof buf, "%lu,%02u", nt, nn)) { return strndup(buf, text_buffer_size); } nn = nt; // now also hours if (width >= snprintf(buf, sizeof buf, "%uh", nn)) { return strndup(buf, text_buffer_size); } nn /= 24; // now days if (width >= snprintf(buf, sizeof buf, "%ud", nn)) { return strndup(buf, text_buffer_size); } nn /= 7; // now weeks if (width >= snprintf(buf, sizeof buf, "%uw", nn)) { return strndup(buf, text_buffer_size); } // well shoot, this outta' fit... return strndup("", text_buffer_size); } void print_top(struct text_object *obj, char *p, int top_name_width) { struct information *cur = &info; struct top_data *td = obj->data.opaque; struct process **needed = 0; if (!td) return; switch (obj->type) { case OBJ_top: needed = cur->cpu; break; case OBJ_top_mem: needed = cur->memu; break; case OBJ_top_time: needed = cur->time; break; #ifdef IOSTATS case OBJ_top_io: needed = cur->io; break; #endif /* IOSTATS */ default: return; } if (needed[td->num]) { char *timeval; switch (td->type) { case TOP_NAME: snprintf(p, top_name_width + 1, "%-*s", top_name_width, needed[td->num]->name); break; case TOP_CPU: snprintf(p, 7, "%6.2f", needed[td->num]->amount); break; case TOP_PID: snprintf(p, 6, "%5i", needed[td->num]->pid); break; case TOP_MEM: /* Calculate a percentage of residential mem from total mem available. * Since rss is bytes and memmax kilobytes, dividing by 10 suffices here. */ snprintf(p, 7, "%6.2f", (float) ((float)needed[td->num]->rss / cur->memmax) / 10); break; case TOP_TIME: timeval = format_time( needed[td->num]->total_cpu_time, 9); snprintf(p, 10, "%9s", timeval); free(timeval); break; case TOP_MEM_RES: human_readable(needed[td->num]->rss, p, 255); break; case TOP_MEM_VSIZE: human_readable(needed[td->num]->vsize, p, 255); break; #ifdef IOSTATS case TOP_READ_BYTES: human_readable(needed[td->num]->read_bytes / update_interval, p, 255); break; case TOP_WRITE_BYTES: human_readable(needed[td->num]->write_bytes / update_interval, p, 255); break; case TOP_IO_PERC: snprintf(p, 7, "%6.2f", needed[td->num]->io_perc); break; #endif } } } void free_top(struct text_object *obj, int internal) { struct top_data *td = obj->data.opaque; if (info.first_process && !internal) { free_all_processes(); info.first_process = NULL; } if (!td) return; if (td->s) free(td->s); free(obj->data.opaque); obj->data.opaque = NULL; }