/*

** ATOP - System & Process Monitor

**

** The program 'atop' offers the possibility to view the activity of

** the system on system-level as well as process-level.

**

** This program concatenates several raw logfiles into one output stream,

** to be stored as new file or to be passed via a pipe to atop/atopsar directly.

** ==========================================================================

** Author: Gerlof Langeveld

** E-mail: gerlof.langeveld@atoptool.nl

** Initial: March 2020

** --------------------------------------------------------------------------

** Copyright (C) 2020 Gerlof Langeveld

**

** 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, 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, write to the Free Software

** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

** --------------------------------------------------------------------------

*/

#include <sys/types.h>

#include <sys/param.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <time.h>

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <sys/utsname.h>

#include <unistd.h>

#include "atop.h"

#include "rawlog.h"

char *convepoch(time_t);

void prusage(char *);

int

main(int argc, char *argv[])

{

int i, fd, n, c;

int firstfile, beverbose=0, dryrun=0;

struct rawheader rh;

struct rawrecord rr;

char *infile, *sstat, *pstat, *cstat, *istat;

unsigned short aversion;

// verify the command line arguments: input filename(s)

//

if (argc < 2)

prusage(argv[0]);

while ((c = getopt(argc, argv, "?hvd")) != EOF)

{

switch (c)

{

case '?': // usage wanted?

case 'h': // usage wanted?

prusage(argv[0]);

break;

case 'v': // verbosity wanted?

beverbose = 1;

break;

case 'd': // dry run wanted?

dryrun = 1;

break;

default:

prusage(argv[0]);

}

}

if ( isatty(fileno(stdout)) && !dryrun)

{

fprintf(stderr,

"this program produces binary output on stdout "

"that should be redirected\nto a file or pipe!\n");

exit(1);

}

// open all input files one-by-one

//

for (i=optind, firstfile=1; i < argc; i++, firstfile=0)

{

infile = argv[i];

// open raw file for reading

//

if ( (fd = open(infile, O_RDONLY)) == -1)

{

fprintf(stderr, "%s - ", infile);

perror("open for reading");

exit(2);

}

// read the raw header

//

if ( read(fd, &rh, sizeof rh) < sizeof rh)

{

fprintf(stderr, "%s: cannot read raw header\n", infile);

close(fd);

exit(3);

}

// verify if this is a correct rawlog file

//

if (rh.magic != MYMAGIC)

{

fprintf(stderr, "%s: not a valid rawlog file "

"(wrong magic number)\n", infile);

close(fd);

exit(4);

}

// only for the first file, store the version number and write

// the raw header for the entire stream

//

// for the next files, be sure that the version is the same

// as the first file

//

if (firstfile)

{

aversion = rh.aversion;

if (!dryrun)

{

if ( write(1, &rh, sizeof rh) < sizeof rh)

{

fprintf(stderr,

"can not write raw header\n");

exit(10);

}

}

if (beverbose)

{

fprintf(stderr,

"Logs created by atop version %d.%d\n\n",

(rh.aversion >> 8) & 0x7f,

rh.aversion & 0xff);

fprintf(stderr, "%-10s %-8s %12s %8s %9s %8s %8s\n",

"date", "time", "interval",

"comprsys", "comprproc", "comprcgr", "comppids");

}

}

else // subsequent file

{

if (aversion != rh.aversion)

{

fprintf(stderr,

"Version of file %s is unequal to "

"version of first file\n", infile);

close(fd);

exit(5);

}

}

// read every raw record followed by the compressed

// system-level stats, process-level stats,

// cgroup-level stats and pidlist.

//

while ( read(fd, &rr, sizeof rr) == sizeof rr )

{

if (beverbose)

{

fprintf(stderr, "%19s %12u %8u %9u %8u %8u %s\n",

convepoch(rr.curtime),

rr.interval, rr.scomplen, rr.pcomplen,

rr.ccomplen, rr.icomplen,

rr.flags&RRBOOT ? "boot" : "");

}

// dynamically allocate space to read stats

//

if ( (sstat = malloc(rr.scomplen)) == NULL)

{

fprintf(stderr, "malloc failed for sstat\n");

exit(7);

}

if ( (pstat = malloc(rr.pcomplen)) == NULL)

{

fprintf(stderr, "malloc failed for pstat\n");

exit(7);

}

if ( (cstat = malloc(rr.ccomplen)) == NULL)

{

fprintf(stderr, "malloc failed for cstat\n");

exit(7);

}

if ( (istat = malloc(rr.icomplen)) == NULL)

{

fprintf(stderr, "malloc failed for istat\n");

exit(7);

}

// read system-level stats

//

if ((n = read(fd, sstat, rr.scomplen)) != rr.scomplen)

{

if (n == -1)

{

fprintf(stderr, "read file %s", infile);

perror("");

exit(8);

}

else

{

fprintf(stderr,

"file %s incomplete!\n", infile);

free(sstat);

free(pstat);

free(cstat);

free(istat);

break;

}

}

// read process-level stats

//

if ((n = read(fd, pstat, rr.pcomplen)) != rr.pcomplen)

{

if (n == -1)

{

fprintf(stderr, "read file %s", infile);

perror("");

exit(8);

}

else

{

fprintf(stderr,

"file %s incomplete!\n", infile);

free(sstat);

free(pstat);

free(cstat);

free(istat);

break;

}

}

// read cgroup-level stats

//

if ((n = read(fd, cstat, rr.ccomplen)) != rr.ccomplen)

{

if (n == -1)

{

fprintf(stderr, "read file %s", infile);

perror("");

exit(8);

}

else

{

fprintf(stderr,

"file %s incomplete!\n", infile);

free(sstat);

free(pstat);

free(cstat);

free(istat);

break;

}

}

// read compressed pidlist

//

if ((n = read(fd, istat, rr.icomplen)) != rr.icomplen)

{

if (n == -1)

{

fprintf(stderr, "read file %s", infile);

perror("");

exit(8);

}

else

{

fprintf(stderr,

"file %s incomplete!\n", infile);

free(sstat);

free(pstat);

free(cstat);

free(istat);

break;

}

}

if (!dryrun)

{

// write raw record followed by the compressed

// system-level stats, process-level stats,

// cgroup-level stats and pidlist

//

if ( write(1, &rr, sizeof rr) < sizeof rr)

{

fprintf(stderr, "can not write raw record\n");

exit(11);

}

if ( write(1, sstat, rr.scomplen) < rr.scomplen)

{

fprintf(stderr, "can not write sstat\n");

exit(11);

}

if ( write(1, pstat, rr.pcomplen) < rr.pcomplen)

{

fprintf(stderr, "can not write pstat\n");

exit(11);

}

if ( write(1, cstat, rr.ccomplen) < rr.ccomplen)

{

fprintf(stderr, "can not write cstat\n");

exit(11);

}

if ( write(1, istat, rr.icomplen) < rr.icomplen)

{

fprintf(stderr, "can not write istat\n");

exit(11);

}

}

// free dynamically allocated buffers

//

free(sstat);

free(pstat);

free(cstat);

free(istat);

}

close(fd);

}

return 0;

}

// Function to convert an epoch time to date-time format

//

char *

convepoch(time_t utime)

{

struct tm *tt;

static char datetime[64];

tt = localtime(&utime);

sprintf(datetime, "%04d/%02d/%02d %02d:%02d:%02d",

tt->tm_year+1900, tt->tm_mon+1, tt->tm_mday,

tt->tm_hour, tt->tm_min, tt->tm_sec);

return datetime;

}

// Function that shows the usage message

//

void

prusage(char *name)

{

fprintf(stderr, "Usage: %s [-dv] rawfile [rawfile]...\n", name);

fprintf(stderr, "\t-d\tdry run (no raw output generated)\n");

fprintf(stderr, "\t-v\tbe verbose\n");

exit(1);

}