/*
***************************************************************************
* Read next sample statistics. If it's a special record (RESTART or COMMENT)
* then display it if requested. Also fill timestamps structures.
*
* IN:
* @ifd File descriptor
* @action Flags indicating if special records should be displayed or not.
*
* @curr Index in array for current sample statistics.
* @file System activity data file name (name of file being read).
* @rtype Record type (RESTART, COMMENT, etc.)
* @tab Number of tabulations to print.
* @file_actlst List of (known or unknown) activities in file.
* @file_magic System activity file magic header.
* @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.
*
* OUT:
* @rectime Structure where timestamp (expressed in local time or in UTC
* depending on whether options -T/-t have been used or not) has
* been saved for current record.
* @loctime Structure where timestamp (expressed in local time) has been
* saved for current record.
*
* RETURNS:
* TRUE if end of file has been reached.
***************************************************************************
*/
int read_next_sample(int ifd, int action, int curr, char *file, int *rtype, int tab,
struct file_magic *file_magic, struct file_activity *file_actlst,
struct tm *rectime, struct tm *loctime)
{
int eosaf;
/* Read current record */
eosaf = sa_fread(ifd, &record_hdr[curr], RECORD_HEADER_SIZE, SOFT_SIZE);
*rtype = record_hdr[curr].record_type;
if (!eosaf) {
if (*rtype == R_COMMENT) {
if (action & IGNORE_COMMENT) {
/* Ignore COMMENT record */
if (lseek(ifd, MAX_COMMENT_LEN, SEEK_CUR) < MAX_COMMENT_LEN) {
perror("lseek");
}
}
else {
/* Display COMMENT record */
print_special_record(curr, tm_start.use, tm_end.use, *rtype, ifd,
rectime, loctime, file, tab, file_magic);
}
}
else if (*rtype == R_RESTART) {
if (action & IGNORE_RESTART) {
/*
* Ignore RESTART record (don't display it)
* but anyway we have to reallocate volatile
* activities structures (unless we don't want to
* do it now).
*/
if (!(action & DONT_READ_VOLATILE)) {
read_vol_act_structures(ifd, act, file, file_magic,
file_hdr.sa_vol_act_nr);
}
}
else {
/* Display RESTART record */
print_special_record(curr, tm_start.use, tm_end.use, *rtype, ifd,
rectime, loctime, file, tab, file_magic);
}
}
else {
/*
* OK: Previous record was not a special one.
* So read now the extra fields.
*/
read_file_stat_bunch(act, curr, ifd, file_hdr.sa_act_nr,
file_actlst);
sa_get_record_timestamp_struct(flags, &record_hdr[curr], rectime, loctime);
}
}
return eosaf;
}
/*
***************************************************************************
* Read statistics from a system activity data file.
*
* IN:
* @from_file Input file name.
***************************************************************************
*/
void read_stats_from_file(char from_file[])
{
struct file_magic file_magic;
struct file_activity *file_actlst = NULL;
int curr = 1, i, p;
int ifd, rtype;
int rows, eosaf = TRUE, reset = FALSE;
long cnt = 1;
off_t fpos;
/* Get window size */
rows = get_win_height();
/* Read file headers and activity list */
check_file_actlst(&ifd, from_file, act, &file_magic, &file_hdr,
&file_actlst, id_seq, FALSE);
/* Perform required allocations */
allocate_structures(act);
/* Print report header */
print_report_hdr(flags, &rectime, &file_hdr,
act[get_activity_position(act, A_CPU)]->nr);
/* 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 (sa_fread(ifd, &record_hdr[0], RECORD_HEADER_SIZE, SOFT_SIZE))
/* End of sa data file */
return;
rtype = record_hdr[0].record_type;
if ((rtype == R_RESTART) || (rtype == R_COMMENT)) {
sar_print_special(0, tm_start.use, tm_end.use, rtype,
ifd, from_file, &file_magic);
}
else {
/*
* OK: Previous record was not a special one.
* So read now the extra fields.
*/
read_file_stat_bunch(act, 0, ifd, file_hdr.sa_act_nr,
file_actlst);
if (sar_get_record_timestamp_struct(0))
/*
* An error was detected.
* The timestamp hasn't been updated.
*/
continue;
}
}
while ((rtype == R_RESTART) || (rtype == R_COMMENT) ||
(tm_start.use && (datecmp(&rectime, &tm_start) < 0)) ||
(tm_end.use && (datecmp(&rectime, &tm_end) >=0)));
/* Save the first stats collected. Will be used to compute the average */
copy_structures(act, id_seq, record_hdr, 2, 0);
reset = TRUE; /* Set flag to reset last_uptime variable */
/* 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.
* Activities that should be displayed are saved in id_seq[] array.
*/
for (i = 0; i < NR_ACT; i++) {
if (!id_seq[i])
continue;
if ((p = get_activity_position(act, id_seq[i])) < 0) {
/* Should never happen */
PANIC(1);
}
if (!IS_SELECTED(act[p]->options))
continue;
if (!HAS_MULTIPLE_OUTPUTS(act[p]->options)) {
handle_curr_act_stats(ifd, fpos, &curr, &cnt, &eosaf, rows,
act[p]->id, &reset, file_actlst,
from_file, &file_magic);
}
else {
unsigned int optf, msk;
optf = act[p]->opt_flags;
for (msk = 1; msk < 0x10; msk <<= 1) {
if (act[p]->opt_flags & msk) {
act[p]->opt_flags &= msk;
handle_curr_act_stats(ifd, fpos, &curr, &cnt,
&eosaf, rows, act[p]->id,
&reset, file_actlst,
from_file, &file_magic);
act[p]->opt_flags = optf;
}
}
}
}
if (!cnt) {
/* Go to next Linux restart, if possible */
do {
eosaf = sa_fread(ifd, &record_hdr[curr], RECORD_HEADER_SIZE,
SOFT_SIZE);
rtype = record_hdr[curr].record_type;
if (!eosaf && (rtype != R_RESTART) && (rtype != R_COMMENT)) {
read_file_stat_bunch(act, curr, ifd, file_hdr.sa_act_nr,
file_actlst);
}
else if (!eosaf && (rtype == R_COMMENT)) {
/* This was a COMMENT record: print it */
sar_print_special(curr, tm_start.use, tm_end.use, R_COMMENT,
ifd, from_file, &file_magic);
}
}
while (!eosaf && (rtype != R_RESTART));
}
/* The last record we read was a RESTART one: Print it */
if (!eosaf && (record_hdr[curr].record_type == R_RESTART)) {
sar_print_special(curr, tm_start.use, tm_end.use, R_RESTART,
ifd, from_file, &file_magic);
}
}
while (!eosaf);
close(ifd);
free(file_actlst);
}
/*
***************************************************************************
* Read stats for current activity from file and display them.
*
* IN:
* @ifd Input file descriptor.
* @fpos Position in file where reading must start.
* @curr Index in array for current sample statistics.
* @rows Number of rows of screen.
* @act_id Activity to display.
* @file_actlst List of activities in file.
* @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 remaining lines of stats 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 handle_curr_act_stats(int ifd, off_t fpos, int *curr, long *cnt, int *eosaf,
int rows, unsigned int act_id, int *reset,
struct file_activity *file_actlst, char *file,
struct file_magic *file_magic)
{
int p;
unsigned long lines = 0;
unsigned char rtype;
int davg = 0, next, inc = -2;
if (lseek(ifd, fpos, SEEK_SET) < fpos) {
perror("lseek");
exit(2);
}
/*
* 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;
/* Assess number of lines printed */
if ((p = get_activity_position(act, act_id)) >= 0) {
if (act[p]->bitmap) {
inc = count_bits(act[p]->bitmap->b_array,
BITMAP_SIZE(act[p]->bitmap->b_size));
}
else {
inc = act[p]->nr;
}
}
if (inc < 0) {
/* Should never happen */
PANIC(inc);
}
do {
/* Display count lines of stats */
*eosaf = sa_fread(ifd, &record_hdr[*curr],
RECORD_HEADER_SIZE, SOFT_SIZE);
rtype = record_hdr[*curr].record_type;
if (!*eosaf && (rtype != R_RESTART) && (rtype != R_COMMENT)) {
/* Read the extra fields since it's not a special record */
read_file_stat_bunch(act, *curr, ifd, file_hdr.sa_act_nr, file_actlst);
}
if ((lines >= rows) || !lines) {
lines = 0;
dis = 1;
}
else
dis = 0;
if (!*eosaf && (rtype != R_RESTART)) {
if (rtype == R_COMMENT) {
/* Display comment */
next = sar_print_special(*curr, tm_start.use, tm_end.use,
R_COMMENT, ifd, file, file_magic);
if (next) {
/* A line of comment was actually displayed */
lines++;
}
continue;
}
/* next is set to 1 when we were close enough to desired interval */
next = write_stats(*curr, USE_SA_FILE, cnt, tm_start.use, tm_end.use,
*reset, act_id);
if (next && (*cnt > 0)) {
(*cnt)--;
}
if (next) {
davg++;
*curr ^=1;
lines += inc;
}
*reset = FALSE;
}
}
while (*cnt && !*eosaf && (rtype != R_RESTART));
if (davg) {
write_stats_avg(!*curr, USE_SA_FILE, act_id);
}
*reset = TRUE;
}
/*
***************************************************************************
* Display activities for textual (XML-like) formats.
*
* IN:
* @ifd File descriptor of input file.
* @file_actlst List of (known or unknown) activities in file.
* @dfile System activity data file name.
* @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 option -t has 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 textual_display_loop(int ifd, struct file_activity *file_actlst, char *dfile,
struct file_magic *file_magic, __nr_t cpu_nr,
struct tm *rectime, struct tm *loctime)
{
int curr, tab = 0, rtype;
int eosaf = TRUE, next, reset = FALSE;
long cnt = 1;
off_t fpos;
/* Save current file position */
if ((fpos = lseek(ifd, 0, SEEK_CUR)) < 0) {
perror("lseek");
exit(2);
}
/* Print header (eg. XML file header) */
if (*fmt[f_position]->f_header) {
(*fmt[f_position]->f_header)(&tab, F_BEGIN, dfile, 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 = sa_fread(ifd, &record_hdr[0], RECORD_HEADER_SIZE, SOFT_SIZE);
rtype = record_hdr[0].record_type;
if (!eosaf && (rtype != R_RESTART) && (rtype != R_COMMENT)) {
/*
* OK: Previous record was not a special one.
* So read now the extra fields.
*/
read_file_stat_bunch(act, 0, ifd, file_hdr.sa_nr_act,
file_actlst);
sadf_get_record_timestamp_struct(0, rectime, loctime);
}
if (!eosaf && (rtype == R_COMMENT)) {
/*
* Ignore COMMENT record.
* (Unlike RESTART records, COMMENT records have an additional
* comment field).
*/
if (lseek(ifd, MAX_COMMENT_LEN, SEEK_CUR) < MAX_COMMENT_LEN) {
perror("lseek");
}
}
}
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 = sa_fread(ifd, &record_hdr[curr], RECORD_HEADER_SIZE,
SOFT_SIZE);
rtype = record_hdr[curr].record_type;
if (!eosaf && (rtype != R_RESTART) && (rtype != R_COMMENT)) {
/* Read the extra fields since it's not a special record */
read_file_stat_bunch(act, curr, ifd, file_hdr.sa_nr_act,
file_actlst);
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 = write_textual_stats(curr, tm_start.use, tm_end.use, reset,
&cnt, tab, cpu_nr, rectime, loctime);
if (next) {
curr ^= 1;
if (cnt > 0) {
cnt--;
}
}
reset = FALSE;
}
if (!eosaf && (rtype == R_COMMENT)) {
/* Ignore COMMENT record */
if (lseek(ifd, MAX_COMMENT_LEN, SEEK_CUR) < MAX_COMMENT_LEN) {
perror("lseek");
}
}
}
while (cnt && !eosaf && (rtype != R_RESTART));
if (!cnt) {
/* Go to next Linux restart, if possible */
do {
eosaf = sa_fread(ifd, &record_hdr[curr], RECORD_HEADER_SIZE,
SOFT_SIZE);
rtype = record_hdr[curr].record_type;
if (!eosaf && (rtype != R_RESTART) && (rtype != R_COMMENT)) {
read_file_stat_bunch(act, curr, ifd, file_hdr.sa_nr_act,
file_actlst);
}
else if (!eosaf && (rtype == R_COMMENT)) {
/* Ignore COMMENT record */
if (lseek(ifd, MAX_COMMENT_LEN, SEEK_CUR) < MAX_COMMENT_LEN) {
perror("lseek");
}
}
}
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);
}
/* 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);
}
do {
if ((eosaf = sa_fread(ifd, &record_hdr[0], RECORD_HEADER_SIZE,
SOFT_SIZE)) == 0) {
rtype = record_hdr[0].record_type;
if ((rtype != R_RESTART) && (rtype != R_COMMENT)) {
read_file_stat_bunch(act, 0, ifd, file_hdr.sa_nr_act,
file_actlst);
}
if (rtype == R_RESTART) {
write_textual_restarts(0, tm_start.use, tm_end.use, tab,
rectime, loctime);
}
else if (rtype == R_COMMENT) {
/* Ignore COMMENT record */
if (lseek(ifd, MAX_COMMENT_LEN, SEEK_CUR) < MAX_COMMENT_LEN) {
perror("lseek");
}
}
}
}
while (!eosaf);
if (*fmt[f_position]->f_restart) {
(*fmt[f_position]->f_restart)(&tab, F_END, NULL, NULL, FALSE, &file_hdr);
}
/* Rewind file */
if (lseek(ifd, fpos, SEEK_SET) < fpos) {
perror("lseek");
exit(2);
}
/* 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 {
if ((eosaf = sa_fread(ifd, &record_hdr[0], RECORD_HEADER_SIZE,
SOFT_SIZE)) == 0) {
rtype = record_hdr[0].record_type;
if ((rtype != R_RESTART) && (rtype != R_COMMENT)) {
read_file_stat_bunch(act, 0, ifd, file_hdr.sa_nr_act,
file_actlst);
}
if (rtype == R_COMMENT) {
write_textual_comments(0, tm_start.use, tm_end.use,
tab, ifd, 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, dfile, file_magic,
&file_hdr, cpu_nr, act, id_seq);
}
}
/*
***************************************************************************
* Read stats for current activity from file and write them.
*
* 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 option -t has been used or not) can be
* saved for current record.
* @loctime Structure where timestamp (expressed in local time) can be
* saved for current record.
*
* 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)
{
unsigned char rtype;
int next;
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;
do {
/* Display <count> lines of stats */
*eosaf = sa_fread(ifd, &record_hdr[*curr], RECORD_HEADER_SIZE,
SOFT_SIZE);
rtype = record_hdr[*curr].record_type;
if (!*eosaf && (rtype != R_RESTART) && (rtype != R_COMMENT)) {
/* Read the extra fields since it's not a RESTART record */
read_file_stat_bunch(act, *curr, ifd, file_hdr.sa_nr_act,
file_actlst);
}
if (!*eosaf && (rtype != R_RESTART)) {
if (rtype == R_COMMENT) {
sadf_print_special(*curr, tm_start.use, tm_end.use,
R_COMMENT, ifd, rectime, loctime);
continue;
}
next = write_parsable_stats(*curr, *reset, cnt,
tm_start.use, tm_end.use, act_id,
cpu_nr, rectime, loctime);
if (next) {
/*
* next is set to 1 when we were close enough to desired interval.
* In this case, the call to write_parsable_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 activities for non textual formats.
*
* 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 option -t has 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 main_display_loop(int ifd, struct file_activity *file_actlst, __nr_t cpu_nr,
struct tm *rectime, struct tm *loctime)
{
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 (sa_fread(ifd, &record_hdr[0], RECORD_HEADER_SIZE, SOFT_SIZE))
/* End of sa data file */
return;
rtype = record_hdr[0].record_type;
if ((rtype == R_RESTART) || (rtype == R_COMMENT)) {
sadf_print_special(0, tm_start.use, tm_end.use, rtype, ifd,
rectime, loctime);
}
else {
/*
* OK: Previous record was not a special one.
* So read now the extra fields.
*/
read_file_stat_bunch(act, 0, ifd, file_hdr.sa_nr_act,
file_actlst);
sadf_get_record_timestamp_struct(0, rectime, loctime);
}
}
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. Will be used to compute the average */
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);
}
else {
/* For each requested activity... */
for (i = 0; i < NR_ACT; i++) {
if (!id_seq[i])
continue;
if ((p = get_activity_position(act, id_seq[i])) < 0) {
/* Should never happen */
PANIC(1);
}
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);
}
else {
unsigned int optf, msk;
optf = act[p]->opt_flags;
for (msk = 1; msk < 0x10; msk <<= 1) {
if (act[p]->opt_flags & msk) {
act[p]->opt_flags &= msk;
rw_curr_act_stats(ifd, fpos, &curr, &cnt, &eosaf,
act[p]->id, &reset, file_actlst,
cpu_nr, rectime, loctime);
act[p]->opt_flags = optf;
}
}
}
}
}
if (!cnt) {
/* Go to next Linux restart, if possible */
do {
eosaf = sa_fread(ifd, &record_hdr[curr], RECORD_HEADER_SIZE,
SOFT_SIZE);
rtype = record_hdr[curr].record_type;
if (!eosaf && (rtype != R_RESTART) && (rtype != R_COMMENT)) {
read_file_stat_bunch(act, curr, ifd, file_hdr.sa_nr_act,
file_actlst);
}
else if (!eosaf && (rtype == R_COMMENT)) {
/* This was a COMMENT record: print it */
sadf_print_special(curr, tm_start.use, tm_end.use,
R_COMMENT, ifd, rectime, loctime);
}
}
while (!eosaf && (rtype != R_RESTART));
}
/* The last record we read was a RESTART one: Print it */
if (!eosaf && (record_hdr[curr].record_type == R_RESTART)) {
sadf_print_special(curr, tm_start.use, tm_end.use,
R_RESTART, ifd, rectime, loctime);
}
}
while (!eosaf);
}
