perfmonger 0.6.1 → 0.7.0

data/ext/perfmonger/sysstat/mpstat.c

@@ -1,953 +0,0 @@
-/*
- * mpstat: per-processor statistics
- * (C) 2000-2010 by Sebastien GODARD (sysstat <at> orange.fr)
- *
- ***************************************************************************
- * 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 2 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 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, write to the Free Software Foundation, Inc., *
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA                   *
- ***************************************************************************
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <signal.h>
-#include <errno.h>
-#include <ctype.h>
-#include <sys/utsname.h>
-
-#include "mpstat.h"
-#include "common.h"
-#include "rd_stats.h"
-
-#ifdef USE_NLS
-#include <locale.h>
-#include <libintl.h>
-#define _(string) gettext(string)
-#else
-#define _(string) (string)
-#endif
-
-unsigned long long uptime[3] = {0, 0, 0};
-unsigned long long uptime0[3] = {0, 0, 0};
-
-/* NOTE: Use array of _char_ for bitmaps to avoid endianness problems...*/
-unsigned char *cpu_bitmap;	/* Bit 0: Global; Bit 1: 1st proc; etc. */
-
-/* Structures used to store stats */
-struct stats_cpu *st_cpu[3];
-struct stats_irq *st_irq[3];
-struct stats_irqcpu *st_irqcpu[3];
-struct stats_irqcpu *st_softirqcpu[3];
-
-struct tm mp_tstamp[3];
-
-/* Activity flag */
-unsigned int actflags = 0;
-// unsigned int flags = 0;
-
-/* Interval and count parameters */
-extern long interval;
-long count = 0;
-
-/* Nb of processors on the machine */
-extern int cpu_nr;
-/* Nb of interrupts per processor */
-int irqcpu_nr = 0;
-/* Nb of soft interrupts per processor */
-int softirqcpu_nr = 0;
-
-/*
- ***************************************************************************
- * Allocate stats structures and cpu bitmap.
- *
- * IN:
- * @nr_cpus	Number of CPUs. This is the real number of available CPUs + 1
- * 		because we also have to allocate a structure for CPU 'all'.
- ***************************************************************************
- */
-void salloc_mp_struct(int nr_cpus)
-{
-	int i;
-
-	for (i = 0; i < 3; i++) {
-
-		if ((st_cpu[i] = (struct stats_cpu *) malloc(STATS_CPU_SIZE * nr_cpus))
-		    == NULL) {
-			perror("malloc");
-			exit(4);
-		}
-		memset(st_cpu[i], 0, STATS_CPU_SIZE * nr_cpus);
-
-		if ((st_irq[i] = (struct stats_irq *) malloc(STATS_IRQ_SIZE * nr_cpus))
-		    == NULL) {
-			perror("malloc");
-			exit(4);
-		}
-		memset(st_irq[i], 0, STATS_IRQ_SIZE * nr_cpus);
-
-		if ((st_irqcpu[i] = (struct stats_irqcpu *) malloc(STATS_IRQCPU_SIZE * nr_cpus * irqcpu_nr))
-		    == NULL) {
-			perror("malloc");
-			exit(4);
-		}
-		memset(st_irqcpu[i], 0, STATS_IRQCPU_SIZE * nr_cpus * irqcpu_nr);
-
-		if ((st_softirqcpu[i] = (struct stats_irqcpu *) malloc(STATS_IRQCPU_SIZE * nr_cpus * softirqcpu_nr))
-		     == NULL) {
-			perror("malloc");
-			exit(4);
-		}
-		memset(st_softirqcpu[i], 0, STATS_IRQCPU_SIZE * nr_cpus * softirqcpu_nr);
-	}
-
-	if ((cpu_bitmap = (unsigned char *) malloc((nr_cpus >> 3) + 1)) == NULL) {
-		perror("malloc");
-		exit(4);
-	}
-	memset(cpu_bitmap, 0, (nr_cpus >> 3) + 1);
-}
-
-/*
- ***************************************************************************
- * Free structures and bitmap.
- ***************************************************************************
- */
-void sfree_mp_struct(void)
-{
-	int i;
-
-	for (i = 0; i < 3; i++) {
-
-		if (st_cpu[i]) {
-			free(st_cpu[i]);
-		}
-		if (st_irq[i]) {
-			free(st_irq[i]);
-		}
-		if (st_irqcpu[i]) {
-			free(st_irqcpu[i]);
-		}
-		if (st_softirqcpu[i]) {
-			free(st_softirqcpu[i]);
-		}
-	}
-
-	if (cpu_bitmap) {
-		free(cpu_bitmap);
-	}
-}
-
-/*
- ***************************************************************************
- * Display per CPU statistics.
- *
- * IN:
- * @st_ic	Array for per-CPU statistics.
- * @ic_nr	Number of interrupts (hard or soft) per CPU.
- * @dis		TRUE if a header line must be printed.
- * @itv		Interval value.
- * @prev	Position in array where statistics used	as reference are.
- *		Stats used as reference may be the previous ones read, or
- *		the very first ones when calculating the average.
- * @curr	Position in array where current statistics will be saved.
- * @prev_string	String displayed at the beginning of a header line. This is
- * 		the timestamp of the previous sample, or "Average" when
- * 		displaying average stats.
- * @curr_string	String displayed at the beginning of current sample stats.
- * 		This is the timestamp of the current sample, or "Average"
- * 		when displaying average stats.
- ***************************************************************************
- */
-/* void write_irqcpu_stats(struct stats_irqcpu *st_ic[], int ic_nr, int dis, */
-/* 			unsigned long long itv, int prev, int curr, */
-/* 			char *prev_string, char *curr_string) */
-/* { */
-/* 	int j = 0, offset, cpu; */
-/* 	struct stats_irqcpu *p, *q, *p0, *q0; */
-
-/* 	/\* */
-/* 	* Check if number of interrupts has changed. */
-/* 	* NB: A null interval value indicates that we are */
-/* 	 * displaying statistics since system startup. */
-/* 	 *\/ */
-/* 	if (!dis && interval) { */
-/* 		do { */
-/* 			p0 = st_ic[curr] + j; */
-/* 			if (p0->irq_name[0] != '\0') { */
-/* 				q0 = st_ic[prev] + j; */
-/* 				if (strcmp(p0->irq_name, q0->irq_name)) { */
-/* 					/\* These are two different irq *\/ */
-/* 					j = -2; */
-/* 				} */
-/* 			} */
-/* 			j++; */
-/* 		} */
-/* 		while ((j > 0) && (j <= ic_nr)); */
-/* 	} */
-
-/* 	if (dis || (j < 0)) { */
-/* 		/\* Print header *\/ */
-/* 		printf("\n%-11s  CPU", prev_string); */
-/* 		for (j = 0; j < ic_nr; j++) { */
-/* 			p0 = st_ic[curr] + j; */
-/* 			if (p0->irq_name[0] != '\0') {	/\* Nb of irq per proc may have varied... *\/ */
-/* 				printf(" %8s/s", p0->irq_name); */
-/* 			} */
-/* 		} */
-/* 		printf("\n"); */
-/* 	} */
-
-/* 	for (cpu = 1; cpu <= cpu_nr; cpu++) { */
-
-/* 		/\* */
-/* 		* Check if we want stats about this CPU. */
-/* 		 * CPU must have been explicitly selected using option -P, */
-/* 		 * else we display every CPU. */
-/* 		 *\/ */
-/* 		if (!(*(cpu_bitmap + (cpu >> 3)) & (1 << (cpu & 0x07))) && USE_P_OPTION(flags)) */
-/* 			continue; */
-
-/* 		printf("%-11s  %3d", curr_string, cpu - 1); */
-
-/* 		for (j = 0; j < ic_nr; j++) { */
-/* 			p0 = st_ic[curr] + j;	/\* irq field set only for proc #0 *\/ */
-/* 			/\* */
-/* 			 * An empty string for irq name means it is a remaining interrupt */
-/* 			 * which is no longer used, for example because the */
-/* 			 * number of interrupts has decreased in /proc/interrupts. */
-/* 			 *\/ */
-/* 			if (p0->irq_name[0] != '\0') { */
-/* 				q0 = st_ic[prev] + j; */
-/* 				offset = j; */
-
-/* 				/\* */
-/* 				 * If we want stats for the time since system startup, */
-/* 				 * we have p0->irq != q0->irq, since q0 structure is */
-/* 				 * completely set to zero. */
-/* 				 *\/ */
-/* 				if (strcmp(p0->irq_name, q0->irq_name) && interval) { */
-/* 					if (j) */
-/* 						offset = j - 1; */
-/* 					q0 = st_ic[prev] + offset; */
-/* 					if (strcmp(p0->irq_name, q0->irq_name) && (j + 1 < ic_nr)) */
-/* 						offset = j + 1; */
-/* 					q0 = st_ic[prev] + offset; */
-/* 				} */
-
-/* 				if (!strcmp(p0->irq_name, q0->irq_name) || !interval) { */
-/* 					p = st_ic[curr] + (cpu - 1) * ic_nr + j; */
-/* 					q = st_ic[prev] + (cpu - 1) * ic_nr + offset; */
-/* 					printf(" %10.2f", */
-/* 					       S_VALUE(q->interrupt, p->interrupt, itv)); */
-/* 				} */
-/* 				else */
-/* 					printf("        N/A"); */
-/* 			} */
-/* 		} */
-/* 		printf("\n"); */
-/* 	} */
-/* } */
-
-/*
- ***************************************************************************
- * Core function used to display statistics
- *
- * IN:
- * @prev	Position in array where statistics used	as reference are.
- *		Stats used as reference may be the previous ones read, or
- *		the very first ones when calculating the average.
- * @curr	Position in array where statistics for current sample are.
- * @dis		TRUE if a header line must be printed.
- * @prev_string	String displayed at the beginning of a header line. This is
- * 		the timestamp of the previous sample, or "Average" when
- * 		displaying average stats.
- * @curr_string	String displayed at the beginning of current sample stats.
- * 		This is the timestamp of the current sample, or "Average"
- * 		when displaying average stats.
- ***************************************************************************
- */
-/* void write_stats_core(int prev, int curr, int dis, */
-/* 		      char *prev_string, char *curr_string) */
-/* { */
-/* 	struct stats_cpu *scc, *scp; */
-/* 	unsigned long long itv, pc_itv, g_itv; */
-/* 	int cpu; */
-
-/* 	/\* Test stdout *\/ */
-/* 	TEST_STDOUT(STDOUT_FILENO); */
-
-/* 	/\* Compute time interval *\/ */
-/* 	g_itv = get_interval(uptime[prev], uptime[curr]); */
-
-/* 	/\* Reduce interval value to one processor *\/ */
-/* 	if (cpu_nr > 1) { */
-/* 		itv = get_interval(uptime0[prev], uptime0[curr]); */
-/* 	} */
-/* 	else { */
-/* 		itv = g_itv; */
-/* 	} */
-
-/* 	/\* Print CPU stats *\/ */
-/* 	if (DISPLAY_CPU(actflags)) { */
-/* 		if (dis) { */
-/* 			printf("\n%-11s  CPU    %%usr   %%nice    %%sys %%iowait    %%irq   " */
-/* 			       "%%soft  %%steal  %%guest   %%idle\n", */
-/* 			       prev_string); */
-/* 		} */
-
-/* 		/\* Check if we want global stats among all proc *\/ */
-/* 		if (*cpu_bitmap & 1) { */
-
-/* 			printf("%-11s  all", curr_string); */
-
-/* 			printf("  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f\n", */
-/* 			       (st_cpu[curr]->cpu_user - st_cpu[curr]->cpu_guest) < */
-/* 			       (st_cpu[prev]->cpu_user - st_cpu[prev]->cpu_guest) ? */
-/* 			       0.0 : */
-/* 			       ll_sp_value(st_cpu[prev]->cpu_user - st_cpu[prev]->cpu_guest, */
-/* 					   st_cpu[curr]->cpu_user - st_cpu[curr]->cpu_guest, */
-/* 					   g_itv), */
-/* 			       ll_sp_value(st_cpu[prev]->cpu_nice, */
-/* 					   st_cpu[curr]->cpu_nice, */
-/* 					   g_itv), */
-/* 			       ll_sp_value(st_cpu[prev]->cpu_sys, */
-/* 					   st_cpu[curr]->cpu_sys, */
-/* 					   g_itv), */
-/* 			       ll_sp_value(st_cpu[prev]->cpu_iowait, */
-/* 					   st_cpu[curr]->cpu_iowait, */
-/* 					   g_itv), */
-/* 			       ll_sp_value(st_cpu[prev]->cpu_hardirq, */
-/* 					   st_cpu[curr]->cpu_hardirq, */
-/* 					   g_itv), */
-/* 			       ll_sp_value(st_cpu[prev]->cpu_softirq, */
-/* 					   st_cpu[curr]->cpu_softirq, */
-/* 					   g_itv), */
-/* 			       ll_sp_value(st_cpu[prev]->cpu_steal, */
-/* 					   st_cpu[curr]->cpu_steal, */
-/* 					   g_itv), */
-/* 			       ll_sp_value(st_cpu[prev]->cpu_guest, */
-/* 					   st_cpu[curr]->cpu_guest, */
-/* 					   g_itv), */
-/* 			       (st_cpu[curr]->cpu_idle < st_cpu[prev]->cpu_idle) ? */
-/* 			       0.0 : */
-/* 			       ll_sp_value(st_cpu[prev]->cpu_idle, */
-/* 					   st_cpu[curr]->cpu_idle, */
-/* 					   g_itv)); */
-/* 		} */
-
-/* 		for (cpu = 1; cpu <= cpu_nr; cpu++) { */
-
-/* 			scc = st_cpu[curr] + cpu; */
-/* 			scp = st_cpu[prev] + cpu; */
-
-/* 			/\* Check if we want stats about this proc *\/ */
-/* 			if (!(*(cpu_bitmap + (cpu >> 3)) & (1 << (cpu & 0x07)))) */
-/* 				continue; */
-			
-/* 			printf("%-11s %4d", curr_string, cpu - 1); */
-
-/* 			/\* */
-/* 			 * If the CPU is offline then it is omited from /proc/stat */
-/* 			 * and the sum of all values is zero. */
-/* 			 * (Remember that guest time is already included in user mode.) */
-/* 			 *\/ */
-/* 			if ((scc->cpu_user    + scc->cpu_nice + scc->cpu_sys   + */
-/* 			     scc->cpu_iowait  + scc->cpu_idle + scc->cpu_steal + */
-/* 			     scc->cpu_hardirq + scc->cpu_softirq) == 0) { */
-/* 				/\* */
-/* 				 * Set current struct fields (which have been set to zero) */
-/* 				 * to values from previous iteration. Hence their values won't */
-/* 				 * jump from zero when the CPU comes back online. */
-/* 				 *\/ */
-/* 				*scc = *scp; */
-
-/* 				printf("  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f" */
-/* 				       "  %6.2f  %6.2f  %6.2f\n", */
-/* 				       0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); */
-/* 				continue; */
-/* 			} */
-
-/* 			/\* Recalculate itv for current proc *\/ */
-/* 			pc_itv = get_per_cpu_interval(scc, scp); */
-			
-/* 			if (!pc_itv) { */
-/* 				/\* */
-/* 				 * If the CPU is tickless then there is no change in CPU values */
-/* 				 * but the sum of values is not zero. */
-/* 				 *\/ */
-/* 				printf("  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f" */
-/* 				       "  %6.2f  %6.2f  %6.2f\n", */
-/* 				       0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 100.0); */
-/* 			} */
-
-/* 			else { */
-/* 				printf("  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f" */
-/* 				       "  %6.2f  %6.2f  %6.2f\n", */
-/* 				       (scc->cpu_user - scc->cpu_guest) < (scp->cpu_user - scp->cpu_guest) ? */
-/* 				       0.0 : */
-/* 				       ll_sp_value(scp->cpu_user - scp->cpu_guest, */
-/* 						   scc->cpu_user - scc->cpu_guest, */
-/* 						   pc_itv), */
-/* 				       ll_sp_value(scp->cpu_nice, */
-/* 						   scc->cpu_nice, */
-/* 						   pc_itv), */
-/* 				       ll_sp_value(scp->cpu_sys, */
-/* 						   scc->cpu_sys, */
-/* 						   pc_itv), */
-/* 				       ll_sp_value(scp->cpu_iowait, */
-/* 						   scc->cpu_iowait, */
-/* 						   pc_itv), */
-/* 				       ll_sp_value(scp->cpu_hardirq, */
-/* 						   scc->cpu_hardirq, */
-/* 						   pc_itv), */
-/* 				       ll_sp_value(scp->cpu_softirq, */
-/* 						   scc->cpu_softirq, */
-/* 						   pc_itv), */
-/* 				       ll_sp_value(scp->cpu_steal, */
-/* 						   scc->cpu_steal, */
-/* 						   pc_itv), */
-/* 				       ll_sp_value(scp->cpu_guest, */
-/* 						   scc->cpu_guest, */
-/* 						   pc_itv), */
-/* 				       (scc->cpu_idle < scp->cpu_idle) ? */
-/* 				       0.0 : */
-/* 				       ll_sp_value(scp->cpu_idle, */
-/* 						   scc->cpu_idle, */
-/* 						   pc_itv)); */
-/* 			} */
-/* 		} */
-/* 	} */
-
-/* 	/\* Print total number of interrupts per processor *\/ */
-/* 	if (DISPLAY_IRQ_SUM(actflags)) { */
-/* 		struct stats_irq *sic, *sip; */
-
-/* 		if (dis) { */
-/* 			printf("\n%-11s  CPU    intr/s\n", prev_string); */
-/* 		} */
-
-/* 		if (*cpu_bitmap & 1) { */
-/* 			printf("%-11s  all %9.2f\n", curr_string, */
-/* 			       ll_s_value(st_irq[prev]->irq_nr, st_irq[curr]->irq_nr, itv)); */
-/* 		} */
-
-/* 		for (cpu = 1; cpu <= cpu_nr; cpu++) { */
-
-/* 			sic = st_irq[curr] + cpu; */
-/* 			sip = st_irq[prev] + cpu; */
-
-/* 			scc = st_cpu[curr] + cpu; */
-/* 			scp = st_cpu[prev] + cpu; */
-
-/* 			/\* Check if we want stats about this proc *\/ */
-/* 			if (!(*(cpu_bitmap + (cpu >> 3)) & (1 << (cpu & 0x07)))) */
-/* 				continue; */
-
-/* 			printf("%-11s %4d", curr_string, cpu - 1); */
-
-/* 			/\* Recalculate itv for current proc *\/ */
-/* 			pc_itv = get_per_cpu_interval(scc, scp); */
-
-/* 			if (!pc_itv) { */
-/* 				/\* Current CPU is offline *\/ */
-/* 				printf(" %9.2f\n", 0.0); */
-/* 			} */
-/* 			else { */
-/* 				printf(" %9.2f\n", */
-/* 				       ll_s_value(sip->irq_nr, sic->irq_nr, itv)); */
-/* 			} */
-/* 		} */
-/* 	} */
-
-/* 	if (DISPLAY_IRQ_CPU(actflags)) { */
-/* 		write_irqcpu_stats(st_irqcpu, irqcpu_nr, dis, itv, prev, curr, */
-/* 				   prev_string, curr_string); */
-/* 	} */
-
-/* 	if (DISPLAY_SOFTIRQS(actflags)) { */
-/* 		write_irqcpu_stats(st_softirqcpu, softirqcpu_nr, dis, itv, prev, curr, */
-/* 				   prev_string, curr_string); */
-/* 	} */
-/* } */
-
-/*
- ***************************************************************************
- * Print statistics average
- *
- * IN:
- * @curr	Position in array where statistics for current sample are.
- * @dis		TRUE if a header line must be printed.
- ***************************************************************************
- */
-/* void write_stats_avg(int curr, int dis) */
-/* { */
-/* 	char string[16]; */
-
-/* 	strncpy(string, _("Average:"), 16); */
-/* 	string[15] = '\0'; */
-/* 	write_stats_core(2, curr, dis, string, string); */
-/* } */
-
-/*
- ***************************************************************************
- * Print statistics
- *
- * IN:
- * @curr	Position in array where statistics for current sample are.
- * @dis		TRUE if a header line must be printed.
- ***************************************************************************
- */
-/* void write_stats(int curr, int dis) */
-/* { */
-/* 	char cur_time[2][16]; */
-
-/* 	/\* Get previous timestamp *\/ */
-/* 	strftime(cur_time[!curr], 16, "%X", &(mp_tstamp[!curr])); */
-
-/* 	/\* Get current timestamp *\/ */
-/* 	strftime(cur_time[curr], 16, "%X", &(mp_tstamp[curr])); */
-
-/* 	write_stats_core(!curr, curr, dis, cur_time[!curr], cur_time[curr]); */
-/* } */
-
-/*
- ***************************************************************************
- * Read stats from /proc/interrupts or /proc/softirqs.
- *
- * IN:
- * @file	/proc file to read (interrupts or softirqs).
- * @ic_nr	Number of interrupts (hard or soft) per CPU.
- * @curr	Position in array where current statistics will be saved.
- *
- * OUT:
- * @st_ic	Array for per-CPU statistics.
- ***************************************************************************
- */
-void read_interrupts_stat(char *file, struct stats_irqcpu *st_ic[], int ic_nr, int curr)
-{
-	FILE *fp;
-	struct stats_irq *st_irq_i;
-	struct stats_irqcpu *p;
-	char *line = NULL;
-	unsigned long irq = 0;
-	unsigned int cpu;
-	int cpu_index[cpu_nr], index = 0, dgt, len;
-	char *cp, *next;
-
-	for (cpu = 0; cpu < cpu_nr; cpu++) {
-		st_irq_i = st_irq[curr] + cpu + 1;
-		st_irq_i->irq_nr = 0;
-	}
-
-	if ((fp = fopen(file, "r")) != NULL) {
-
-		SREALLOC(line, char, INTERRUPTS_LINE + 11 * cpu_nr);
-
-		/*
-		 * Parse header line to see which CPUs are online
-		 */
-		while (fgets(line, INTERRUPTS_LINE + 11 * cpu_nr, fp) != NULL) {
-			next = line;
-			while (((cp = strstr(next, "CPU")) != NULL) && (index < cpu_nr)) {
-				cpu = strtol(cp + 3, &next, 10);
-				cpu_index[index++] = cpu;
-			}
-			if (index)
-				/* Header line found */
-				break;
-		}
-
-		while ((fgets(line, INTERRUPTS_LINE + 11 * cpu_nr, fp) != NULL) &&
-		       (irq < ic_nr)) {
-
-			/* Skip over "<irq>:" */
-			if ((cp = strchr(line, ':')) == NULL)
-				continue;
-			cp++;
-
-			p = st_ic[curr] + irq;
-			len = strcspn(line, ":");
-			if (len >= MAX_IRQ_LEN) {
-				len = MAX_IRQ_LEN - 1;
-			}
-			strncpy(p->irq_name, line, len);
-			p->irq_name[len] = '\0';
-			dgt = isdigit(line[len - 1]);
-
-			for (cpu = 0; cpu < index; cpu++) {
-				p = st_ic[curr] + cpu_index[cpu] * ic_nr + irq;
-				st_irq_i = st_irq[curr] + cpu_index[cpu] + 1;
-				/*
-				 * No need to set (st_irqcpu + cpu * irqcpu_nr)->irq:
-				 * This is the same as st_irqcpu->irq.
-				 */
-				p->interrupt = strtoul(cp, &next, 10);
-				if (dgt) {
-					/* Sum only numerical irq (and not NMI, LOC, etc.) */
-					st_irq_i->irq_nr += p->interrupt;
-				}
-				cp = next;
-			}
-			irq++;
-		}
-
-		fclose(fp);
-		
-		if (line) {
-			free(line);
-		}
-	}
-
-	while (irq < ic_nr) {
-		/* Nb of interrupts per processor has changed */
-		p = st_ic[curr] + irq;
-		p->irq_name[0] = '\0';	/* This value means this is a dummy interrupt */
-		irq++;
-	}
-}
-
-/*
- ***************************************************************************
- * Main loop: Read stats from the relevant sources, and display them.
- *
- * IN:
- * @dis_hdr	Set to TRUE if the header line must always be printed.
- * @rows	Number of rows of screen.
- ***************************************************************************
- */
-void rw_mpstat_loop(int dis_hdr, int rows)
-{
-	struct stats_cpu *scc;
-	int cpu;
-	int curr = 1, dis = 1;
-	unsigned long lines = rows;
-
-	/* Dont buffer data if redirected to a pipe */
-	setbuf(stdout, NULL);
-
-	/* Read stats */
-	if (cpu_nr > 1) {
-		/*
-		 * Init uptime0. So if /proc/uptime cannot fill it,
-		 * this will be done by /proc/stat.
-		 */
-		uptime0[0] = 0;
-		read_uptime(&(uptime0[0]));
-	}
-	read_stat_cpu(st_cpu[0], cpu_nr + 1, &(uptime[0]), &(uptime0[0]));
-
-	if (DISPLAY_IRQ_SUM(actflags)) {
-		read_stat_irq(st_irq[0], 1);
-	}
-
-	if (DISPLAY_IRQ_SUM(actflags) || DISPLAY_IRQ_CPU(actflags)) {
-		/* Read this file to display int per CPU or total nr of int per CPU */
-		read_interrupts_stat(INTERRUPTS, st_irqcpu, irqcpu_nr, 0);
-	}
-	
-	if (DISPLAY_SOFTIRQS(actflags)) {
-            read_interrupts_stat(SOFTIRQS, st_softirqcpu, softirqcpu_nr, 0);
-	}
-
-	if (!interval) {
-		/* Display since boot time */
-		mp_tstamp[1] = mp_tstamp[0];
-		memset(st_cpu[1], 0, STATS_CPU_SIZE * (cpu_nr + 1));
-		memset(st_irq[1], 0, STATS_IRQ_SIZE * (cpu_nr + 1));
-		memset(st_irqcpu[1], 0, STATS_IRQCPU_SIZE * (cpu_nr + 1) * irqcpu_nr);
-		if (DISPLAY_SOFTIRQS(actflags)) {
-			memset(st_softirqcpu[1], 0, STATS_IRQCPU_SIZE * (cpu_nr + 1) * softirqcpu_nr);
-		}
-		/* write_stats(0, DISP_HDR); */
-		exit(0);
-	}
-
-	/* Set a handler for SIGALRM */
-	/* alarm_handler(0); */
-
-	/* Save the first stats collected. Will be used to compute the average */
-	mp_tstamp[2] = mp_tstamp[0];
-	uptime[2] = uptime[0];
-	uptime0[2] = uptime0[0];
-	memcpy(st_cpu[2], st_cpu[0], STATS_CPU_SIZE * (cpu_nr + 1));
-	memcpy(st_irq[2], st_irq[0], STATS_IRQ_SIZE * (cpu_nr + 1));
-	memcpy(st_irqcpu[2], st_irqcpu[0], STATS_IRQCPU_SIZE * (cpu_nr + 1) * irqcpu_nr);
-	if (DISPLAY_SOFTIRQS(actflags)) {
-		memcpy(st_softirqcpu[2], st_softirqcpu[0],
-		       STATS_IRQCPU_SIZE * (cpu_nr + 1) * softirqcpu_nr);
-	}
-
-	pause();
-
-	do {
-		/*
-		 * Resetting the structure not needed since every fields will be set.
-		 * Exceptions are per-CPU structures: Some of them may not be filled
-		 * if corresponding processor is disabled (offline). We set them to zero
-		 * to be able to distinguish between offline and tickless CPUs.
-		 */
-		for (cpu = 1; cpu <= cpu_nr; cpu++) {
-			scc = st_cpu[curr] + cpu;
-			memset(scc, 0, STATS_CPU_SIZE);
-		}
-
-		/* Get time */
-		get_localtime(&(mp_tstamp[curr]));
-
-		/* Read stats */
-		if (cpu_nr > 1) {
-			uptime0[curr] = 0;
-			read_uptime(&(uptime0[curr]));
-		}
-		read_stat_cpu(st_cpu[curr], cpu_nr + 1, &(uptime[curr]), &(uptime0[curr]));
-
-		if (DISPLAY_IRQ_SUM(actflags)) {
-			read_stat_irq(st_irq[curr], 1);
-		}
-
-		if (DISPLAY_IRQ_SUM(actflags) || DISPLAY_IRQ_CPU(actflags)) {
-			read_interrupts_stat(INTERRUPTS, st_irqcpu, irqcpu_nr, curr);
-		}
-
-		if (DISPLAY_SOFTIRQS(actflags)) {
-			read_interrupts_stat(SOFTIRQS, st_softirqcpu, softirqcpu_nr, curr);
-		}
-
-		/* Write stats */
-		if (!dis_hdr) {
-			dis = lines / rows;
-			if (dis) {
-				lines %= rows;
-			}
-			lines++;
-		}
-		/* write_stats(curr, dis); */
-
-		if (count > 0) {
-			count--;
-		}
-		if (count) {
-			curr ^= 1;
-			pause();
-		}
-	}
-	while (count);
-
-	/* Write stats average */
-	/* write_stats_avg(curr, dis_hdr); */
-}
-
-/*
- ***************************************************************************
- * Main entry to the program
- ***************************************************************************
- */
-/* int main(int argc, char **argv) */
-/* { */
-/* 	int opt = 0, i, actset = FALSE; */
-/* 	struct utsname header; */
-/* 	int dis_hdr = -1; */
-/* 	int rows = 23; */
-/* 	char *t; */
-
-/* #ifdef USE_NLS */
-/* 	/\* Init National Language Support *\/ */
-/* 	init_nls(); */
-/* #endif */
-
-/* 	/\* Get HZ *\/ */
-/* 	get_HZ(); */
-
-/* 	/\* How many processors on this machine ? *\/ */
-/* 	cpu_nr = get_cpu_nr(~0); */
-	
-/* 	/\* Calculate number of interrupts per processor *\/ */
-/* 	irqcpu_nr = get_irqcpu_nr(INTERRUPTS, NR_IRQS, cpu_nr) + */
-/* 		    NR_IRQCPU_PREALLOC; */
-/* 	/\* Calculate number of soft interrupts per processor *\/ */
-/* 	softirqcpu_nr = get_irqcpu_nr(SOFTIRQS, NR_IRQS, cpu_nr) + */
-/* 			NR_IRQCPU_PREALLOC; */
-
-/* 	/\* */
-/* 	 * cpu_nr: a value of 2 means there are 2 processors (0 and 1). */
-/* 	 * In this case, we have to allocate 3 structures: global, proc0 and proc1. */
-/* 	 *\/ */
-/* 	salloc_mp_struct(cpu_nr + 1); */
-
-/* 	while (++opt < argc) { */
-
-/* 		if (!strcmp(argv[opt], "-I")) { */
-/* 			if (argv[++opt]) { */
-/* 				actset = TRUE; */
-/* 				if (!strcmp(argv[opt], K_SUM)) { */
-/* 					/\* Display total number of interrupts per CPU *\/ */
-/* 					actflags |= M_D_IRQ_SUM; */
-/* 				} */
-/* 				else if (!strcmp(argv[opt], K_CPU)) { */
-/* 					/\* Display interrupts per CPU *\/ */
-/* 					actflags |= M_D_IRQ_CPU; */
-/* 				} */
-/* 				else if (!strcmp(argv[opt], K_SCPU)) { */
-/* 					/\* Display soft interrupts per CPU *\/ */
-/* 					actflags |= M_D_SOFTIRQS; */
-/* 				} */
-/* 				else if (!strcmp(argv[opt], K_ALL)) { */
-/* 					actflags |= M_D_IRQ_SUM + M_D_IRQ_CPU + M_D_SOFTIRQS; */
-/* 				} */
-/* 				else { */
-/* 					usage(argv[0]); */
-/* 				} */
-/* 			} */
-/* 			else { */
-/* 				usage(argv[0]); */
-/* 			} */
-/* 		} */
-
-/* 		else if (!strcmp(argv[opt], "-P")) { */
-/* 			/\* '-P ALL' can be used on UP machines *\/ */
-/* 			if (argv[++opt]) { */
-/* 				flags |= F_P_OPTION; */
-/* 				dis_hdr++; */
-				
-/* 				for (t = strtok(argv[opt], ","); t; t = strtok(NULL, ",")) { */
-/* 					if (!strcmp(t, K_ALL)) { */
-/* 						if (cpu_nr) { */
-/* 							dis_hdr = 9; */
-/* 						} */
-/* 						/\* */
-/* 						 * Set bit for every processor. */
-/* 						 * Also indicate to display stats for CPU 'all'. */
-/* 						 *\/ */
-/* 						memset(cpu_bitmap, 0xff, ((cpu_nr + 1) >> 3) + 1); */
-/* 					} */
-/* 					else { */
-/* 						if (strspn(t, DIGITS) != strlen(t)) { */
-/* 							usage(argv[0]); */
-/* 						} */
-/* 						i = atoi(t);	/\* Get cpu number *\/ */
-/* 						if (i >= cpu_nr) { */
-/* 							fprintf(stderr, _("Not that many processors!\n")); */
-/* 							exit(1); */
-/* 						} */
-/* 						i++; */
-/* 						*(cpu_bitmap + (i >> 3)) |= 1 << (i & 0x07); */
-/* 					} */
-/* 				} */
-/* 			} */
-/* 			else { */
-/* 				usage(argv[0]); */
-/* 			} */
-/* 		} */
-
-/* 		else if (!strncmp(argv[opt], "-", 1)) { */
-/* 			for (i = 1; *(argv[opt] + i); i++) { */
-
-/* 				switch (*(argv[opt] + i)) { */
-
-/* 				case 'A': */
-/* 					actflags |= M_D_CPU + M_D_IRQ_SUM + M_D_IRQ_CPU + M_D_SOFTIRQS; */
-/* 					actset = TRUE; */
-/* 					/\* Select all processors *\/ */
-/* 					flags |= F_P_OPTION; */
-/* 					memset(cpu_bitmap, 0xff, ((cpu_nr + 1) >> 3) + 1); */
-/* 					break; */
-					
-/* 				case 'u': */
-/* 					/\* Display CPU *\/ */
-/* 					actflags |= M_D_CPU; */
-/* 					break; */
-
-/* 				case 'V': */
-/* 					/\* Print version number *\/ */
-/* 					print_version(); */
-/* 					break; */
-
-/* 				default: */
-/* 					usage(argv[0]); */
-/* 				} */
-/* 			} */
-/* 		} */
-
-/* 		else if (interval < 0) { */
-/* 			/\* Get interval *\/ */
-/* 			if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) { */
-/* 				usage(argv[0]); */
-/* 			} */
-/* 			interval = atol(argv[opt]); */
-/* 			if (interval < 0) { */
-/* 				usage(argv[0]); */
-/* 			} */
-/* 			count = -1; */
-/* 		} */
-
-/* 		else if (count <= 0) { */
-/* 			/\* Get count value *\/ */
-/* 			if ((strspn(argv[opt], DIGITS) != strlen(argv[opt])) || */
-/* 			    !interval) { */
-/* 				usage(argv[0]); */
-/* 			} */
-/* 			count = atol(argv[opt]); */
-/* 			if (count < 1) { */
-/* 				usage(argv[0]); */
-/* 			} */
-/* 		} */
-
-/* 		else { */
-/* 			usage(argv[0]); */
-/* 		} */
-/* 	} */
-
-/* 	/\* Default: Display CPU *\/ */
-/* 	if (!actset) { */
-/* 		actflags |= M_D_CPU; */
-/* 	} */
-
-/* 	if (count_bits(&actflags, sizeof(unsigned int)) > 1) { */
-/* 		dis_hdr = 9; */
-/* 	} */
-	
-/* 	if (!USE_P_OPTION(flags)) { */
-/* 		/\* Option -P not used: Set bit 0 (global stats among all proc) *\/ */
-/* 		*cpu_bitmap = 1; */
-/* 	} */
-/* 	if (dis_hdr < 0) { */
-/* 		dis_hdr = 0; */
-/* 	} */
-/* 	if (!dis_hdr) { */
-/* 		/\* Get window size *\/ */
-/* 		rows = get_win_height(); */
-/* 	} */
-/* 	if (interval < 0) { */
-/* 		/\* Interval not set => display stats since boot time *\/ */
-/* 		interval = 0; */
-/* 	} */
-
-/* 	/\* Get time *\/ */
-/* 	get_localtime(&(mp_tstamp[0])); */
-
-/* 	/\* Get system name, release number and hostname *\/ */
-/* 	uname(&header); */
-/* 	print_gal_header(&(mp_tstamp[0]), header.sysname, header.release, */
-/* 			 header.nodename, header.machine, cpu_nr); */
-
-/* 	/\* Main loop *\/ */
-/* 	rw_mpstat_loop(dis_hdr, rows); */
-
-/* 	/\* Free structures *\/ */
-/* 	sfree_mp_struct(); */
-
-/* 	return 0; */
-/* } */