/*
***************************************************************************
* Read stats for current activity from file and print them.
* Display at most <count> lines of stats (and possibly comments inserted
* in file) located between two LINUX RESTART messages.
*
* IN:
* @ifd File descriptor of input file.
* @fpos Position in file where reading must start.
* @curr Index in array for current sample statistics.
* @act_id Activity to display, or ~0 for all.
* @file_actlst List of (known or unknown) activities in file.
* @cpu_nr Number of processors for current activity data file.
* @rectime Structure where timestamp (expressed in local time or in UTC
* depending on whether options -T/-t have been used or not) can
* be saved for current record.
* @loctime Structure where timestamp (expressed in local time) can be
* saved for current record.
* @file Name of file being read.
* @file_magic file_magic structure filled with file magic header data.
*
* OUT:
* @curr Index in array for next sample statistics.
* @cnt Number of lines of stats remaining to write.
* @eosaf Set to TRUE if EOF (end of file) has been reached.
* @reset Set to TRUE if last_uptime variable should be
* reinitialized (used in next_slice() function).
***************************************************************************
*/
void rw_curr_act_stats(int ifd, off_t fpos, int *curr, long *cnt, int *eosaf,
unsigned int act_id, int *reset, struct file_activity *file_actlst,
__nr_t cpu_nr, struct tm *rectime, struct tm *loctime,
char *file, struct file_magic *file_magic)
{
int rtype;
int next, reset_cd;
if (lseek(ifd, fpos, SEEK_SET) < fpos) {
perror("lseek");
exit(2);
}
if (DISPLAY_FIELD_LIST(fmt[f_position]->options)) {
/* Print field list */
list_fields(act_id);
}
/*
* Restore the first stats collected.
* Used to compute the rate displayed on the first line.
*/
copy_structures(act, id_seq, record_hdr, !*curr, 2);
*cnt = count;
reset_cd = 1;
do {
/* Display <count> lines of stats */
*eosaf = read_next_sample(ifd, IGNORE_RESTART | DONT_READ_VOLATILE,
*curr, file, &rtype, 0, file_magic,
file_actlst, rectime, loctime);
if (!*eosaf && (rtype != R_RESTART) && (rtype != R_COMMENT)) {
next = logic2_write_stats(*curr, *reset, cnt,
tm_start.use, tm_end.use, act_id,
cpu_nr, rectime, loctime, reset_cd);
reset_cd = 0;
if (next) {
/*
* next is set to 1 when we were close enough to desired interval.
* In this case, the call to logic2_write_stats() has actually
* displayed a line of stats.
*/
*curr ^= 1;
if (*cnt > 0) {
(*cnt)--;
}
}
*reset = FALSE;
}
}
while (*cnt && !*eosaf && (rtype != R_RESTART));
*reset = TRUE;
}
/*
***************************************************************************
* Display file contents in selected format (logic #1).
* Logic #1: Grouped by record type. Sorted by timestamp.
* Formats: XML, JSON
*
* IN:
* @ifd File descriptor of input file.
* @file_actlst List of (known or unknown) activities in file.
* @file System activity data file name (name of file being read).
* @file_magic System activity file magic header.
* @cpu_nr Number of processors for current activity data file.
* @rectime Structure where timestamp (expressed in local time or in UTC
* depending on whether options -T/-t have been used or not) can
* be saved for current record.
* @loctime Structure where timestamp (expressed in local time) can be
* saved for current record.
***************************************************************************
*/
void logic1_display_loop(int ifd, struct file_activity *file_actlst, char *file,
struct file_magic *file_magic, __nr_t cpu_nr,
struct tm *rectime, struct tm *loctime)
{
int curr, tab = 0, rtype;
int eosaf, next, reset = FALSE;
__nr_t save_act_nr[NR_ACT] = {0};
long cnt = 1;
off_t fpos;
/* Save current file position */
if ((fpos = lseek(ifd, 0, SEEK_CUR)) < 0) {
perror("lseek");
exit(2);
}
/* Save number of activities items for current file position */
sr_act_nr(save_act_nr, DO_SAVE);
/* Print header (eg. XML file header) */
if (*fmt[f_position]->f_header) {
(*fmt[f_position]->f_header)(&tab, F_BEGIN, file, file_magic,
&file_hdr, cpu_nr, act, id_seq);
}
/* Process activities */
if (*fmt[f_position]->f_statistics) {
(*fmt[f_position]->f_statistics)(&tab, F_BEGIN);
}
do {
/*
* If this record is a special (RESTART or COMMENT) one,
* skip it and try to read the next record in file.
*/
do {
eosaf = read_next_sample(ifd, IGNORE_COMMENT | IGNORE_RESTART, 0,
file, &rtype, tab, file_magic, file_actlst,
rectime, loctime);
}
while (!eosaf && ((rtype == R_RESTART) || (rtype == R_COMMENT) ||
(tm_start.use && (datecmp(loctime, &tm_start) < 0)) ||
(tm_end.use && (datecmp(loctime, &tm_end) >= 0))));
/* Save the first stats collected. Used for example in next_slice() function */
copy_structures(act, id_seq, record_hdr, 2, 0);
curr = 1;
cnt = count;
reset = TRUE;
if (!eosaf) {
do {
eosaf = read_next_sample(ifd, IGNORE_COMMENT | IGNORE_RESTART, curr,
file, &rtype, tab, file_magic, file_actlst,
rectime, loctime);
if (!eosaf && (rtype != R_COMMENT) && (rtype != R_RESTART)) {
if (*fmt[f_position]->f_statistics) {
(*fmt[f_position]->f_statistics)(&tab, F_MAIN);
}
/* next is set to 1 when we were close enough to desired interval */
next = generic_write_stats(curr, tm_start.use, tm_end.use, reset,
&cnt, &tab, cpu_nr, rectime, loctime,
FALSE, ALL_ACTIVITIES);
if (next) {
curr ^= 1;
if (cnt > 0) {
cnt--;
}
}
reset = FALSE;
}
}
while (cnt && !eosaf && (rtype != R_RESTART));
if (!cnt) {
/* Go to next Linux restart, if possible */
do {
eosaf = read_next_sample(ifd, IGNORE_COMMENT | IGNORE_RESTART, curr,
file, &rtype, tab, file_magic, file_actlst,
rectime, loctime);
}
while (!eosaf && (rtype != R_RESTART));
}
reset = TRUE;
}
}
while (!eosaf);
if (*fmt[f_position]->f_statistics) {
(*fmt[f_position]->f_statistics)(&tab, F_END);
}
/* Rewind file... */
if (lseek(ifd, fpos, SEEK_SET) < fpos) {
perror("lseek");
exit(2);
}
/*
* ... and restore number of items for volatile activities
* for this position in file.
*/
sr_act_nr(save_act_nr, DO_RESTORE);
/* Process now RESTART entries to display restart messages */
if (*fmt[f_position]->f_restart) {
(*fmt[f_position]->f_restart)(&tab, F_BEGIN, NULL, NULL, FALSE,
&file_hdr, 0);
}
do {
eosaf = read_next_sample(ifd, IGNORE_COMMENT, 0,
file, &rtype, tab, file_magic, file_actlst,
rectime, loctime);
}
while (!eosaf);
if (*fmt[f_position]->f_restart) {
(*fmt[f_position]->f_restart)(&tab, F_END, NULL, NULL, FALSE, &file_hdr, 0);
}
/* Rewind file... */
if (lseek(ifd, fpos, SEEK_SET) < fpos) {
perror("lseek");
exit(2);
}
/*
* ... and restore number of items for volatile activities
* for this position in file.
*/
sr_act_nr(save_act_nr, DO_RESTORE);
/* Last, process COMMENT entries to display comments */
if (DISPLAY_COMMENT(flags)) {
if (*fmt[f_position]->f_comment) {
(*fmt[f_position]->f_comment)(&tab, F_BEGIN, NULL, NULL, 0, NULL,
&file_hdr);
}
do {
eosaf = read_next_sample(ifd, IGNORE_RESTART, 0,
file, &rtype, tab, file_magic, file_actlst,
rectime, loctime);
}
while (!eosaf);
if (*fmt[f_position]->f_comment) {
(*fmt[f_position]->f_comment)(&tab, F_END, NULL, NULL, 0, NULL,
&file_hdr);
}
}
/* Print header trailer */
if (*fmt[f_position]->f_header) {
(*fmt[f_position]->f_header)(&tab, F_END, file, file_magic,
&file_hdr, cpu_nr, act, id_seq);
}
}
/*
***************************************************************************
* Read stats for current activity from file and display its SVG graphs.
* At most <count> lines of stats are taken into account.
*
* IN:
* @ifd File descriptor of input file.
* @fpos Position in file where reading must start.
* @curr Index in array for current sample statistics.
* @p Current activity position.
* @file_actlst List of (known or unknown) activities in file.
* @cpu_nr Number of processors for current activity data file.
* @rectime Structure where timestamp (expressed in local time or in UTC
* depending on whether options -T/-t have been used or not) can
* be saved for current record.
* @loctime Structure where timestamp (expressed in local time) can be
* saved for current record.
* @file Name of file being read.
* @file_magic file_magic structure filled with file magic header data.
* @save_act_nr Array where the number of volatile activities are saved
* for current position in file.
* @g_nr Number of graphs already displayed (for all activities).
*
* OUT:
* @cnt Number of lines of stats remaining to write.
* @eosaf Set to TRUE if EOF (end of file) has been reached.
* @reset Set to TRUE if last_uptime variable should be
* reinitialized (used in next_slice() function).
* @g_nr Total number of graphs displayed (including current activity).
***************************************************************************
*/
void display_curr_act_graphs(int ifd, off_t fpos, int *curr, long *cnt, int *eosaf,
int p, int *reset, struct file_activity *file_actlst,
__nr_t cpu_nr, struct tm *rectime, struct tm *loctime,
char *file, struct file_magic *file_magic,
__nr_t save_act_nr[], int *g_nr)
{
struct svg_parm parm;
int rtype;
int next, reset_cd;
/* Rewind file... */
if (lseek(ifd, fpos, SEEK_SET) < fpos) {
perror("lseek");
exit(2);
}
/*
* ... and restore number of items for volatile activities
* for this position in file.
*/
sr_act_nr(save_act_nr, DO_RESTORE);
/*
* Restore the first stats collected.
* Used to compute the rate displayed on the first line.
*/
copy_structures(act, id_seq, record_hdr, !*curr, 2);
parm.graph_no = *g_nr;
parm.record_hdr = &record_hdr[2];
parm.restart = TRUE;
*cnt = count;
reset_cd = 1;
/* Allocate graphs arrays */
(*act[p]->f_svg_print)(act[p], !*curr, F_BEGIN, &parm, 0, &record_hdr[!*curr]);
do {
*eosaf = read_next_sample(ifd, IGNORE_RESTART | IGNORE_COMMENT | SET_TIMESTAMPS,
*curr, file, &rtype, 0, file_magic,
file_actlst, rectime, loctime);
if (!*eosaf && (rtype != R_COMMENT) && (rtype != R_RESTART)) {
next = generic_write_stats(*curr, tm_start.use, tm_end.use, *reset, cnt,
&parm, cpu_nr, rectime, loctime, reset_cd, act[p]->id);
reset_cd = 0;
if (next) {
/*
* next is set to 1 when we were close enough to desired interval.
* In this case, the call to generic_write_stats() has actually
* displayed a line of stats.
*/
parm.restart = FALSE;
*curr ^= 1;
if (*cnt > 0) {
(*cnt)--;
}
}
*reset = FALSE;
}
if (!*eosaf && (rtype == R_RESTART)) {
parm.restart = TRUE;
*reset = TRUE;
/* Go to next statistics record, if possible */
do {
*eosaf = read_next_sample(ifd, IGNORE_RESTART | IGNORE_COMMENT | SET_TIMESTAMPS,
*curr, file, &rtype, 0, file_magic,
file_actlst, rectime, loctime);
}
while (!*eosaf && ((rtype == R_RESTART) || (rtype == R_COMMENT)));
*curr ^= 1;
}
}
while (!*eosaf);
*reset = TRUE;
/* Actually display graphs for current activity */
(*act[p]->f_svg_print)(act[p], *curr, F_END, &parm, 0, &record_hdr[!*curr]);
/* Update total number of graphs already displayed */
*g_nr = parm.graph_no;
}
/*
***************************************************************************
* Compute the number of SVG graphs to display. Each activity selected may
* have several graphs. Moreover we have to take into account volatile
* activities (eg. CPU) for which the number of graphs will depend on the
* highest number of items (eg. maximum number of CPU) saved in the file.
* This number may be higher than the real number of graphs that will be
* displayed since some items have a preallocation constant.
*
* IN:
* @ifd File descriptor of input file.
* @file Name of file being read.
* @file_magic file_magic structure filled with file magic header data.
* @file_actlst List of (known or unknown) activities in file.
* @rectime Structure where timestamp (expressed in local time or in UTC
* depending on whether options -T/-t have been used or not) can
* be saved for current record.
* @loctime Structure where timestamp (expressed in local time) can be
* saved for current record.
*
* RETURNS:
* Total number of graphs to display, taking into account only activities
* to be displayed, and selected period of time (options -s/-e).
***************************************************************************
*/
int get_svg_graph_nr(int ifd, char *file, struct file_magic *file_magic,
struct file_activity *file_actlst, struct tm *rectime,
struct tm *loctime)
{
int i, n, p, eosaf;
int rtype, new_tot_g_nr, tot_g_nr = 0;
off_t fpos;
__nr_t save_act_nr[NR_ACT] = {0};
/* Save current file position and items number */
if ((fpos = lseek(ifd, 0, SEEK_CUR)) < 0) {
perror("lseek");
exit(2);
}
sr_act_nr(save_act_nr, DO_SAVE);
/* Init total number of graphs for each activity */
for (i = 0; i < NR_ACT; i++) {
id_g_nr[i] = 0;
}
/* Look for the first record that will be displayed */
do {
eosaf = read_next_sample(ifd, IGNORE_RESTART | IGNORE_COMMENT | SET_TIMESTAMPS,
0, file, &rtype, 0, file_magic, file_actlst,
rectime, loctime);
if (eosaf)
/* No record to display => no graph too */
return 0;
}
while ((tm_start.use && (datecmp(loctime, &tm_start) < 0)) ||
(tm_end.use && (datecmp(loctime, &tm_end) >= 0)));
do {
new_tot_g_nr = 0;
for (i = 0; i < NR_ACT; i++) {
if (!id_seq[i])
continue;
p = get_activity_position(act, id_seq[i], EXIT_IF_NOT_FOUND);
if (!IS_SELECTED(act[p]->options))
continue;
if (ONE_GRAPH_PER_ITEM(act[p]->options)) {
n = act[p]->g_nr * act[p]->nr;
}
else {
n = act[p]->g_nr;
}
if (n > id_g_nr[i]) {
id_g_nr[i] = n;
}
new_tot_g_nr += n;
}
if (new_tot_g_nr > tot_g_nr) {
tot_g_nr = new_tot_g_nr;
}
do {
eosaf = read_next_sample(ifd, IGNORE_RESTART | IGNORE_COMMENT | SET_TIMESTAMPS,
0, file, &rtype, 0, file_magic, file_actlst,
rectime, loctime);
if (eosaf ||
(tm_end.use && (datecmp(loctime, &tm_end) >= 0)))
/* End of data file or end time exceeded */
break;
}
while (rtype != R_RESTART);
if (eosaf ||
(tm_end.use && (datecmp(loctime, &tm_end) >= 0)))
/*
* End of file, or end time exceeded:
* Current number of graphs is up-to-date.
*/
break;
/*
* If we have found a RESTART record then we have also read the list of volatile
* activities following it, reallocated the structures and changed the number of
* items (act[p]->nr) for those volatile activities. So loop again to compute
* the new total number of graphs.
*/
}
while (rtype == R_RESTART);
/* Rewind file and restore items number */
if (lseek(ifd, fpos, SEEK_SET) < fpos) {
perror("lseek");
exit(2);
}
sr_act_nr(save_act_nr, DO_RESTORE);
return tot_g_nr;
}
/*
***************************************************************************
* Display file contents in selected format (logic #3).
* Logic #3: Special logic for SVG output format.
* Formats: SVG
*
* IN:
* @ifd File descriptor of input file.
* @file_actlst List of (known or unknown) activities in file.
* @cpu_nr Number of processors for current activity data file.
* @rectime Structure where timestamp (expressed in local time or in UTC
* depending on whether options -T/-t have been used or not) can
* be saved for current record.
* @loctime Structure where timestamp (expressed in local time) can be
* saved for current record.
* @file Name of file being read.
* @file_magic file_magic structure filled with file magic header data.
***************************************************************************
*/
void logic3_display_loop(int ifd, struct file_activity *file_actlst, __nr_t cpu_nr,
struct tm *rectime, struct tm *loctime, char *file,
struct file_magic *file_magic)
{
int i, p;
int curr = 1, rtype, g_nr = 0;
int eosaf = TRUE, reset = TRUE;
long cnt = 1;
off_t fpos;
int graph_nr = 0;
__nr_t save_act_nr[NR_ACT] = {0};
/* Use a decimal point to make SVG code locale independent */
setlocale(LC_NUMERIC, "C");
/* Calculate the number of graphs to display */
graph_nr = get_svg_graph_nr(ifd, file, file_magic,
file_actlst, rectime, loctime);
if (!graph_nr)
/* No graph to display */
return;
/* Print SVG header */
if (*fmt[f_position]->f_header) {
(*fmt[f_position]->f_header)(&graph_nr, F_BEGIN + F_MAIN, file, file_magic,
&file_hdr, cpu_nr, act, id_seq);
}
/*
* If this record is a special (RESTART or COMMENT) one, ignore it and
* (try to) get another one.
*/
do {
if (read_next_sample(ifd, IGNORE_RESTART | IGNORE_COMMENT, 0,
file, &rtype, 0, file_magic, file_actlst,
rectime, loctime))
/* End of sa data file */
return;
}
while ((rtype == R_RESTART) || (rtype == R_COMMENT) ||
(tm_start.use && (datecmp(loctime, &tm_start) < 0)) ||
(tm_end.use && (datecmp(loctime, &tm_end) >= 0)));
/* Save the first stats collected. Used for example in next_slice() function */
copy_structures(act, id_seq, record_hdr, 2, 0);
/* Save current file position */
if ((fpos = lseek(ifd, 0, SEEK_CUR)) < 0) {
perror("lseek");
exit(2);
}
/* Save number of activities items for current file position */
sr_act_nr(save_act_nr, DO_SAVE);
/* For each requested activity, display graphs */
for (i = 0; i < NR_ACT; i++) {
if (!id_seq[i])
continue;
p = get_activity_position(act, id_seq[i], EXIT_IF_NOT_FOUND);
if (!IS_SELECTED(act[p]->options) || !act[p]->g_nr)
continue;
if (!HAS_MULTIPLE_OUTPUTS(act[p]->options)) {
display_curr_act_graphs(ifd, fpos, &curr, &cnt, &eosaf,
p, &reset, file_actlst,
cpu_nr, rectime, loctime, file,
file_magic, save_act_nr, &g_nr);
}
else {
unsigned int optf, msk;
optf = act[p]->opt_flags;
for (msk = 1; msk < 0x100; msk <<= 1) {
if ((act[p]->opt_flags & 0xff) & msk) {
act[p]->opt_flags &= (0xffffff00 + msk);
display_curr_act_graphs(ifd, fpos, &curr, &cnt, &eosaf,
p, &reset, file_actlst,
cpu_nr, rectime, loctime, file,
file_magic, save_act_nr, &g_nr);
act[p]->opt_flags = optf;
}
}
}
}
/* Print SVG trailer */
if (*fmt[f_position]->f_header) {
(*fmt[f_position]->f_header)(&graph_nr, F_END, file, file_magic,
&file_hdr, cpu_nr, act, id_seq);
}
}
/*
***************************************************************************
* Display file contents in selected format (logic #2).
* Logic #2: Grouped by activity. Sorted by timestamp. Stop on RESTART
* records.
* Formats: ppc, CSV
*
* IN:
* @ifd File descriptor of input file.
* @file_actlst List of (known or unknown) activities in file.
* @cpu_nr Number of processors for current activity data file.
* @rectime Structure where timestamp (expressed in local time or in UTC
* depending on whether options -T/-t have been used or not) can
* be saved for current record.
* @loctime Structure where timestamp (expressed in local time) can be
* saved for current record.
* @file Name of file being read.
* @file_magic file_magic structure filled with file magic header data.
***************************************************************************
*/
void logic2_display_loop(int ifd, struct file_activity *file_actlst, __nr_t cpu_nr,
struct tm *rectime, struct tm *loctime, char *file,
struct file_magic *file_magic)
{
int i, p;
int curr = 1, rtype;
int eosaf = TRUE, reset = FALSE;
long cnt = 1;
off_t fpos;
/* Read system statistics from file */
do {
/*
* If this record is a special (RESTART or COMMENT) one, print it and
* (try to) get another one.
*/
do {
if (read_next_sample(ifd, IGNORE_NOTHING, 0,
file, &rtype, 0, file_magic, file_actlst,
rectime, loctime))
/* End of sa data file */
return;
}
while ((rtype == R_RESTART) || (rtype == R_COMMENT) ||
(tm_start.use && (datecmp(loctime, &tm_start) < 0)) ||
(tm_end.use && (datecmp(loctime, &tm_end) >= 0)));
/* Save the first stats collected. Used for example in next_slice() function */
copy_structures(act, id_seq, record_hdr, 2, 0);
/* Set flag to reset last_uptime variable. Should be done after a LINUX RESTART record */
reset = TRUE;
/* Save current file position */
if ((fpos = lseek(ifd, 0, SEEK_CUR)) < 0) {
perror("lseek");
exit(2);
}
/* Read and write stats located between two possible Linux restarts */
if (DISPLAY_HORIZONTALLY(flags)) {
/*
* If stats are displayed horizontally, then all activities
* are printed on the same line.
*/
rw_curr_act_stats(ifd, fpos, &curr, &cnt, &eosaf,
ALL_ACTIVITIES, &reset, file_actlst,
cpu_nr, rectime, loctime, file, file_magic);
}
else {
/* For each requested activity... */
for (i = 0; i < NR_ACT; i++) {
if (!id_seq[i])
continue;
p = get_activity_position(act, id_seq[i], EXIT_IF_NOT_FOUND);
if (!IS_SELECTED(act[p]->options))
continue;
if (!HAS_MULTIPLE_OUTPUTS(act[p]->options)) {
rw_curr_act_stats(ifd, fpos, &curr, &cnt, &eosaf,
act[p]->id, &reset, file_actlst,
cpu_nr, rectime, loctime, file,
file_magic);
}
else {
unsigned int optf, msk;
optf = act[p]->opt_flags;
for (msk = 1; msk < 0x100; msk <<= 1) {
if ((act[p]->opt_flags & 0xff) & msk) {
act[p]->opt_flags &= (0xffffff00 + msk);
rw_curr_act_stats(ifd, fpos, &curr, &cnt, &eosaf,
act[p]->id, &reset, file_actlst,
cpu_nr, rectime, loctime, file,
file_magic);
act[p]->opt_flags = optf;
}
}
}
}
}
if (!cnt) {
/* Go to next Linux restart, if possible */
do {
eosaf = read_next_sample(ifd, IGNORE_RESTART | DONT_READ_VOLATILE,
curr, file, &rtype, 0, file_magic,
file_actlst, rectime, loctime);
}
while (!eosaf && (rtype != R_RESTART));
}
/*
* The last record we read was a RESTART one: Print it.
* NB: Unlike COMMENTS records (which are displayed for each
* activity), RESTART ones are only displayed once.
*/
if (!eosaf && (record_hdr[curr].record_type == R_RESTART)) {
print_special_record(&record_hdr[curr], flags, &tm_start, &tm_end,
R_RESTART, ifd, rectime, loctime, file, 0,
file_magic, &file_hdr, act, fmt[f_position]);
}
}
while (!eosaf);
}
