int
main(int argc, char *argv[])
{
register int i;
int c;
char *p;
struct rlimit rlim;
/*
** since priviliged actions will be done later on, at this stage
** the root-priviliges are dropped by switching effective user-id
** to real user-id (security reasons)
*/
if (! droprootprivs() )
{
fprintf(stderr, "not possible to drop root privs\n");
exit(42);
}
/*
** preserve command arguments to allow restart of other version
*/
argvp = argv;
/*
** read defaults-files /etc/atoprc en $HOME/.atoprc (if any)
*/
readrc("/etc/atoprc");
if ( (p = getenv("HOME")) )
{
char path[1024];
snprintf(path, sizeof path, "%s/.atoprc", p);
readrc(path);
}
/*
** check if we are supposed to behave as 'atopsar'
** i.e. system statistics only
*/
if ( (p = strrchr(argv[0], '/')))
p++;
else
p = argv[0];
if ( memcmp(p, "atopsar", 7) == 0)
return atopsar(argc, argv);
/*
** interpret command-line arguments & flags
*/
if (argc > 1)
{
/*
** gather all flags for visualization-functions
**
** generic flags will be handled here;
** unrecognized flags are passed to the print-routines
*/
i = 0;
while (i < MAXFL-1 && (c=getopt(argc, argv, allflags)) != EOF)
{
switch (c)
{
case '?': /* usage wanted ? */
prusage(argv[0]);
break;
case 'V': /* version wanted ? */
printf("%s\n", getstrvers());
exit(0);
case 'w': /* writing of raw data ? */
if (optind >= argc)
prusage(argv[0]);
strncpy(rawname, argv[optind++], RAWNAMESZ-1);
vis.show_samp = rawwrite;
break;
case 'r': /* reading of raw data ? */
if (optind < argc && *(argv[optind]) != '-')
strncpy(rawname, argv[optind++],
RAWNAMESZ-1);
rawreadflag++;
break;
case 'S': /* midnight limit ? */
midnightflag++;
break;
case 'a': /* all processes per sample ? */
deviatonly=0;
break;
case 'b': /* begin time ? */
if ( !hhmm2secs(optarg, &begintime) )
prusage(argv[0]);
break;
case 'e': /* end time ? */
if ( !hhmm2secs(optarg, &endtime) )
prusage(argv[0]);
break;
case 'j': /* show disk partitions statistics */
diskpartview = 1;
break;
case 'P': /* parseable output? */
if ( !parsedef(optarg) )
prusage(argv[0]);
vis.show_samp = parseout;
break;
case 'L': /* line length */
if ( !numeric(optarg) )
prusage(argv[0]);
linelen = atoi(optarg);
break;
default: /* gather other flags */
flaglist[i++] = c;
}
}
/*
** get optional interval-value and optional number of samples
*/
if (optind < argc && optind < MAXFL)
{
if (!numeric(argv[optind]))
prusage(argv[0]);
interval = atoi(argv[optind]);
optind++;
if (optind < argc)
{
if (!numeric(argv[optind]) )
prusage(argv[0]);
if ( (nsamples = atoi(argv[optind])) < 1)
prusage(argv[0]);
}
}
}
/*
** determine the name of this node (without domain-name)
** and the kernel-version
*/
(void) uname(&utsname);
if ( (p = strchr(utsname.nodename, '.')) )
*p = '\0';
utsnodenamelen = strlen(utsname.nodename);
sscanf(utsname.release, "%d.%d.%d", &osrel, &osvers, &ossub);
/*
** determine the clock rate and memory page size for this machine
*/
hertz = sysconf(_SC_CLK_TCK);
pagesize = sysconf(_SC_PAGESIZE);
/*
** check if raw data from a file must be viewed
*/
if (rawreadflag)
{
rawread();
cleanstop(0);
}
/*
** determine start-time for gathering current statistics
*/
curtime = getboot() / hertz;
/*
** catch signals for proper close-down
*/
signal(SIGHUP, cleanstop);
signal(SIGTERM, cleanstop);
/*
** regain the root-priviliges that we dropped at the beginning
** to do some priviliged work
*/
regainrootprivs();
/*
** lock ATOP in memory to get reliable samples (also when
** memory is low);
** ignored if not running under superuser priviliges!
*/
rlim.rlim_cur = RLIM_INFINITY;
rlim.rlim_max = RLIM_INFINITY;
(void) setrlimit(RLIMIT_MEMLOCK, &rlim);
(void) mlockall(MCL_CURRENT|MCL_FUTURE);
/*
** increment CPU scheduling-priority to get reliable samples (also
** during heavy CPU load);
** ignored if not running under superuser priviliges!
*/
if ( nice(-20) == -1)
;
/*
** switch-on the process-accounting mechanism to register the
** (remaining) resource-usage by processes which have finished
*/
acctreason = acctswon();
/*
** determine properties (like speed) of all interfaces
*/
initifprop();
/*
** open socket to the IP layer to issue getsockopt() calls later on
*/
netatop_ipopen();
/*
** since priviliged activities are finished now, there is no
** need to keep running under root-priviliges, so switch
** effective user-id to real user-id
*/
if (! droprootprivs() )
cleanstop(42);
/*
** start the engine now .....
*/
engine();
cleanstop(0);
return 0; /* never reached */
}
/*
** calculate the system-activity during the last sample
*/
void
deviatsyst(struct sstat *cur, struct sstat *pre, struct sstat *dev)
{
register int i, j;
size_t size;
count_t *cdev, *ccur, *cpre;
if (cur->cpu.nrcpu != dev->cpu.nrcpu)
{
size = cur->cpu.nrcpu * sizeof(struct percpu);
dev->cpu.cpu = (struct percpu *)realloc(dev->cpu.cpu, size);
ptrverify(dev->cpu.cpu, "deviatsyst cpus [%ld]", (long)size);
}
if (cur->cpu.nrcpu > pre->cpu.nrcpu)
{
free(pre->cpu.cpu);
size = cur->cpu.nrcpu * sizeof(struct percpu);
pre->cpu.cpu = (struct percpu *)calloc(1, size);
ptrverify(pre->cpu.cpu, "deviatsyst precpus [%ld]", (long)size);
}
dev->cpu.nrcpu = cur->cpu.nrcpu;
dev->cpu.devint = subcount(cur->cpu.devint, pre->cpu.devint);
dev->cpu.csw = subcount(cur->cpu.csw, pre->cpu.csw);
dev->cpu.nprocs = subcount(cur->cpu.nprocs, pre->cpu.nprocs);
dev->cpu.all.stime = subcount(cur->cpu.all.stime, pre->cpu.all.stime);
dev->cpu.all.utime = subcount(cur->cpu.all.utime, pre->cpu.all.utime);
dev->cpu.all.ntime = subcount(cur->cpu.all.ntime, pre->cpu.all.ntime);
dev->cpu.all.itime = subcount(cur->cpu.all.itime, pre->cpu.all.itime);
dev->cpu.all.wtime = subcount(cur->cpu.all.wtime, pre->cpu.all.wtime);
dev->cpu.all.Itime = subcount(cur->cpu.all.Itime, pre->cpu.all.Itime);
dev->cpu.all.Stime = subcount(cur->cpu.all.Stime, pre->cpu.all.Stime);
dev->cpu.all.steal = subcount(cur->cpu.all.steal, pre->cpu.all.steal);
dev->cpu.all.guest = subcount(cur->cpu.all.guest, pre->cpu.all.guest);
for (i=0; i < dev->cpu.nrcpu; i++)
{
count_t ticks;
dev->cpu.cpu[i].cpunr = cur->cpu.cpu[i].cpunr;
dev->cpu.cpu[i].stime = subcount(cur->cpu.cpu[i].stime,
pre->cpu.cpu[i].stime);
dev->cpu.cpu[i].utime = subcount(cur->cpu.cpu[i].utime,
pre->cpu.cpu[i].utime);
dev->cpu.cpu[i].ntime = subcount(cur->cpu.cpu[i].ntime,
pre->cpu.cpu[i].ntime);
dev->cpu.cpu[i].itime = subcount(cur->cpu.cpu[i].itime,
pre->cpu.cpu[i].itime);
dev->cpu.cpu[i].wtime = subcount(cur->cpu.cpu[i].wtime,
pre->cpu.cpu[i].wtime);
dev->cpu.cpu[i].Itime = subcount(cur->cpu.cpu[i].Itime,
pre->cpu.cpu[i].Itime);
dev->cpu.cpu[i].Stime = subcount(cur->cpu.cpu[i].Stime,
pre->cpu.cpu[i].Stime);
dev->cpu.cpu[i].steal = subcount(cur->cpu.cpu[i].steal,
pre->cpu.cpu[i].steal);
dev->cpu.cpu[i].guest = subcount(cur->cpu.cpu[i].guest,
pre->cpu.cpu[i].guest);
ticks = cur->cpu.cpu[i].freqcnt.ticks;
dev->cpu.cpu[i].freqcnt.maxfreq =
cur->cpu.cpu[i].freqcnt.maxfreq;
dev->cpu.cpu[i].freqcnt.cnt = ticks ?
subcount(cur->cpu.cpu[i].freqcnt.cnt,
pre->cpu.cpu[i].freqcnt.cnt)
: cur->cpu.cpu[i].freqcnt.cnt;
dev->cpu.cpu[i].freqcnt.ticks = ticks ?
subcount(cur->cpu.cpu[i].freqcnt.ticks,
pre->cpu.cpu[i].freqcnt.ticks)
: cur->cpu.cpu[i].freqcnt.ticks;
}
dev->cpu.lavg1 = cur->cpu.lavg1;
dev->cpu.lavg5 = cur->cpu.lavg5;
dev->cpu.lavg15 = cur->cpu.lavg15;
dev->mem.physmem = cur->mem.physmem;
dev->mem.freemem = cur->mem.freemem;
dev->mem.buffermem = cur->mem.buffermem;
dev->mem.slabmem = cur->mem.slabmem;
dev->mem.slabreclaim = cur->mem.slabreclaim;
dev->mem.committed = cur->mem.committed;
dev->mem.commitlim = cur->mem.commitlim;
dev->mem.cachemem = cur->mem.cachemem;
dev->mem.cachedrt = cur->mem.cachedrt;
dev->mem.totswap = cur->mem.totswap;
dev->mem.freeswap = cur->mem.freeswap;
dev->mem.shmem = cur->mem.shmem;
dev->mem.shmrss = cur->mem.shmrss;
dev->mem.shmswp = cur->mem.shmswp;
dev->mem.tothugepage = cur->mem.tothugepage;
dev->mem.freehugepage = cur->mem.freehugepage;
dev->mem.hugepagesz = cur->mem.hugepagesz;
dev->mem.vmwballoon = cur->mem.vmwballoon;
dev->mem.swouts = subcount(cur->mem.swouts, pre->mem.swouts);
dev->mem.swins = subcount(cur->mem.swins, pre->mem.swins);
dev->mem.pgscans = subcount(cur->mem.pgscans, pre->mem.pgscans);
dev->mem.pgsteal = subcount(cur->mem.pgsteal, pre->mem.pgsteal);
dev->mem.allocstall = subcount(cur->mem.allocstall,
pre->mem.allocstall);
/*
** structures with network-related counters are considered
** as tables of frequency-counters that have to be subtracted;
** values that do not represent a frequency are corrected afterwards
*/
for (cdev = (count_t *)&dev->net.ipv4,
ccur = (count_t *)&cur->net.ipv4,
cpre = (count_t *)&pre->net.ipv4,
i = 0;
i < (sizeof dev->net.ipv4 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
dev->net.ipv4.Forwarding = cur->net.ipv4.Forwarding;
dev->net.ipv4.DefaultTTL = cur->net.ipv4.DefaultTTL;
/* ------------- */
for (cdev = (count_t *)&dev->net.icmpv4,
ccur = (count_t *)&cur->net.icmpv4,
cpre = (count_t *)&pre->net.icmpv4,
i = 0;
i < (sizeof dev->net.icmpv4 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.udpv4,
ccur = (count_t *)&cur->net.udpv4,
cpre = (count_t *)&pre->net.udpv4,
i = 0;
i < (sizeof dev->net.udpv4 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.ipv6,
ccur = (count_t *)&cur->net.ipv6,
cpre = (count_t *)&pre->net.ipv6,
i = 0;
i < (sizeof dev->net.ipv6 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.icmpv6,
ccur = (count_t *)&cur->net.icmpv6,
cpre = (count_t *)&pre->net.icmpv6,
i = 0;
i < (sizeof dev->net.icmpv6 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.udpv6,
ccur = (count_t *)&cur->net.udpv6,
cpre = (count_t *)&pre->net.udpv6,
i = 0;
i < (sizeof dev->net.udpv6 / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
/* ------------- */
for (cdev = (count_t *)&dev->net.tcp,
ccur = (count_t *)&cur->net.tcp,
cpre = (count_t *)&pre->net.tcp,
i = 0;
i < (sizeof dev->net.tcp / sizeof(count_t));
cdev++, ccur++, cpre++, i++)
*cdev = *ccur - *cpre;
dev->net.tcp.RtoAlgorithm = cur->net.tcp.RtoAlgorithm;
dev->net.tcp.RtoMin = cur->net.tcp.RtoMin;
dev->net.tcp.RtoMax = cur->net.tcp.RtoMax;
dev->net.tcp.MaxConn = cur->net.tcp.MaxConn;
dev->net.tcp.CurrEstab = cur->net.tcp.CurrEstab;
/*
** calculate deviations for interfaces
*/
if (cur->intf.nrintf != dev->intf.nrintf)
{
size = (cur->intf.nrintf + 1) * sizeof(struct perintf);
dev->intf.intf = (struct perintf *)realloc(dev->intf.intf, size);
ptrverify(dev->intf.intf, "deviatsyst intf [%ld]\n", (long)size);
}
if (pre->intf.nrintf < cur->intf.nrintf) /* first sample? */
{
struct ifprop ifprop;
free(pre->intf.intf);
size = (cur->intf.nrintf + 1) * sizeof(struct perintf);
pre->intf.intf = (struct perintf *)calloc(1, size);
ptrverify(pre->intf.intf, "deviatsyst preintf [%ld]\n", size);
for (i=0; cur->intf.intf[i].name[0]; i++)
{
strcpy(pre->intf.intf[i].name, cur->intf.intf[i].name);
strcpy(ifprop.name, cur->intf.intf[i].name);
getifprop(&ifprop);
pre->intf.intf[i].speed = ifprop.speed;
pre->intf.intf[i].duplex = ifprop.fullduplex;
}
pre->intf.intf[i].name[0] = '\0';
}
for (i=0; cur->intf.intf && cur->intf.intf[i].name[0]; i++)
{
/*
** check if an interface has been added or removed;
** in that case, skip further handling for this sample
*/
if (strcmp(cur->intf.intf[i].name, pre->intf.intf[i].name) != 0)
{
int j;
struct ifprop ifprop;
/*
** take care that interface properties are
** corrected for future samples
*/
initifprop(); /* refresh interface info */
for (j=0; cur->intf.intf[j].name[0]; j++)
{
strcpy(ifprop.name, cur->intf.intf[j].name);
getifprop(&ifprop);
cur->intf.intf[j].speed = ifprop.speed;
cur->intf.intf[j].duplex = ifprop.fullduplex;
}
break;
}
/*
** calculate interface deviations for this sample
*/
strcpy(dev->intf.intf[i].name, cur->intf.intf[i].name);
dev->intf.intf[i].rbyte = subcount(cur->intf.intf[i].rbyte,
pre->intf.intf[i].rbyte);
dev->intf.intf[i].rpack = subcount(cur->intf.intf[i].rpack,
pre->intf.intf[i].rpack);
dev->intf.intf[i].rerrs = subcount(cur->intf.intf[i].rerrs,
pre->intf.intf[i].rerrs);
dev->intf.intf[i].rdrop = subcount(cur->intf.intf[i].rdrop,
pre->intf.intf[i].rdrop);
dev->intf.intf[i].rfifo = subcount(cur->intf.intf[i].rfifo,
pre->intf.intf[i].rfifo);
dev->intf.intf[i].rframe= subcount(cur->intf.intf[i].rframe,
pre->intf.intf[i].rframe);
dev->intf.intf[i].rcompr= subcount(cur->intf.intf[i].rcompr,
pre->intf.intf[i].rcompr);
dev->intf.intf[i].rmultic=subcount(cur->intf.intf[i].rmultic,
pre->intf.intf[i].rmultic);
dev->intf.intf[i].sbyte = subcount(cur->intf.intf[i].sbyte,
pre->intf.intf[i].sbyte);
dev->intf.intf[i].spack = subcount(cur->intf.intf[i].spack,
pre->intf.intf[i].spack);
dev->intf.intf[i].serrs = subcount(cur->intf.intf[i].serrs,
pre->intf.intf[i].serrs);
dev->intf.intf[i].sdrop = subcount(cur->intf.intf[i].sdrop,
pre->intf.intf[i].sdrop);
dev->intf.intf[i].sfifo = subcount(cur->intf.intf[i].sfifo,
pre->intf.intf[i].sfifo);
dev->intf.intf[i].scollis= subcount(cur->intf.intf[i].scollis,
pre->intf.intf[i].scollis);
dev->intf.intf[i].scarrier= subcount(cur->intf.intf[i].scarrier,
pre->intf.intf[i].scarrier);
dev->intf.intf[i].scompr= subcount(cur->intf.intf[i].scompr,
pre->intf.intf[i].scompr);
dev->intf.intf[i].speed = pre->intf.intf[i].speed;
dev->intf.intf[i].duplex = pre->intf.intf[i].duplex;
/*
** save interface properties for next interval
*/
cur->intf.intf[i].speed = pre->intf.intf[i].speed;
cur->intf.intf[i].duplex = pre->intf.intf[i].duplex;
}
dev->intf.intf[i].name[0] = '\0';
dev->intf.nrintf = i;
/*
** calculate deviations for disks
*/
if (cur->dsk.ndsk != dev->dsk.ndsk)
{
size = (cur->dsk.ndsk + 1) * sizeof(struct perdsk);
dev->dsk.dsk = (struct perdsk *)realloc(dev->dsk.dsk, size);
ptrverify(dev->dsk.dsk, "deviatsyst disk [%ld]\n", (long)size);
}
for (i=j=0; cur->dsk.dsk && cur->dsk.dsk[i].name[0]; i++)
{
int realj = j;
/*
** check if disk has been added or removed since
** previous interval
*/
if (pre->dsk.dsk[j].name[0] == '\0' ||
strcmp(cur->dsk.dsk[i].name, pre->dsk.dsk[j].name) != 0)
{
for (j=0; pre->dsk.dsk[j].name[0]; j++)
{
if ( strcmp(cur->dsk.dsk[i].name,
pre->dsk.dsk[j].name) == 0)
break;
}
/*
** either the corresponding entry has been found
** in the case that a disk has been removed, or
** an empty entry has been found (all counters
** on zero) in the case that a disk has been added
** during the last sample
*/
}
strcpy(dev->dsk.dsk[i].name, cur->dsk.dsk[i].name);
dev->dsk.dsk[i].nread = subcount(cur->dsk.dsk[i].nread,
pre->dsk.dsk[j].nread);
dev->dsk.dsk[i].nwrite = subcount(cur->dsk.dsk[i].nwrite,
pre->dsk.dsk[j].nwrite);
dev->dsk.dsk[i].nrsect = subcount(cur->dsk.dsk[i].nrsect,
pre->dsk.dsk[j].nrsect);
dev->dsk.dsk[i].nwsect = subcount(cur->dsk.dsk[i].nwsect,
pre->dsk.dsk[j].nwsect);
dev->dsk.dsk[i].io_ms = subcount(cur->dsk.dsk[i].io_ms,
pre->dsk.dsk[j].io_ms);
dev->dsk.dsk[i].avque = subcount(cur->dsk.dsk[i].avque,
pre->dsk.dsk[j].avque);
/*
** determine new j
*/
if (pre->dsk.dsk[j].name[0] != '\0') // existing matching entry
j++;
else
j = realj; // empty entry: stick to old j
}
dev->dsk.dsk[i].name[0] = '\0';
dev->dsk.ndsk = i;
/*
** calculate deviations for multiple devices
*/
if (cur->dsk.nmdd != dev->dsk.nmdd)
{
size = (cur->dsk.nmdd + 1) * sizeof(struct perdsk);
dev->dsk.mdd = (struct perdsk *)realloc(dev->dsk.mdd, size);
ptrverify(dev->dsk.mdd, "deviatsyst mdd [%ld]\n", (long)size);
}
for (i=j=0; cur->dsk.mdd && cur->dsk.mdd[i].name[0]; i++)
{
int realj = j;
/*
** check if md has been added or removed since
** previous interval
*/
if (pre->dsk.mdd[j].name[0] == '\0' ||
strcmp(cur->dsk.mdd[i].name, pre->dsk.mdd[j].name) != 0)
{
for (j=0; pre->dsk.mdd[j].name[0]; j++)
{
if ( strcmp(cur->dsk.mdd[i].name,
pre->dsk.mdd[j].name) == 0)
break;
}
/*
** either the corresponding entry has been found
** in the case that a md has been removed, or
** an empty entry has been found (all counters
** on zero) in the case that a md has been added
** during the last sample
*/
}
strcpy(dev->dsk.mdd[i].name, cur->dsk.mdd[i].name);
dev->dsk.mdd[i].nread = subcount(cur->dsk.mdd[i].nread,
pre->dsk.mdd[j].nread);
dev->dsk.mdd[i].nwrite = subcount(cur->dsk.mdd[i].nwrite,
pre->dsk.mdd[j].nwrite);
dev->dsk.mdd[i].nrsect = subcount(cur->dsk.mdd[i].nrsect,
pre->dsk.mdd[j].nrsect);
dev->dsk.mdd[i].nwsect = subcount(cur->dsk.mdd[i].nwsect,
pre->dsk.mdd[j].nwsect);
dev->dsk.mdd[i].io_ms = subcount(cur->dsk.mdd[i].io_ms,
pre->dsk.mdd[j].io_ms);
dev->dsk.mdd[i].avque = subcount(cur->dsk.mdd[i].avque,
pre->dsk.mdd[j].avque);
/*
** determine new j
*/
if (pre->dsk.mdd[j].name[0] != '\0') // existing matching entry
j++;
else
j = realj; // empty entry: stick to old j
}
dev->dsk.mdd[i].name[0] = '\0';
dev->dsk.nmdd = i;
/*
** calculate deviations for LVM logical volumes
*/
if (cur->dsk.nlvm != dev->dsk.nlvm)
{
size = (cur->dsk.nlvm + 1) * sizeof(struct perdsk);
dev->dsk.lvm = (struct perdsk *)realloc(dev->dsk.lvm, size);
ptrverify(dev->dsk.lvm, "deviatsyst lvm [%ld]\n", (long)size);
}
for (i=j=0; cur->dsk.lvm && cur->dsk.lvm[i].name[0]; i++)
{
int realj = j;
/*
** check if logical volume has been added or removed since
** previous interval
*/
if (pre->dsk.lvm[j].name[0] == '\0' ||
strcmp(cur->dsk.lvm[i].name, pre->dsk.lvm[j].name) != 0)
{
for (j=0; pre->dsk.lvm[j].name[0]; j++)
{
if ( strcmp(cur->dsk.lvm[i].name,
pre->dsk.lvm[j].name) == 0)
break;
}
/*
** either the corresponding entry has been found
** in the case that a logical volume has been removed,
** or an empty entry has been found (all counters
** on zero) in the case that a logical volume has
** been added during the last sample
*/
}
strcpy(dev->dsk.lvm[i].name, cur->dsk.lvm[i].name);
dev->dsk.lvm[i].nread = subcount(cur->dsk.lvm[i].nread,
pre->dsk.lvm[j].nread);
dev->dsk.lvm[i].nwrite = subcount(cur->dsk.lvm[i].nwrite,
pre->dsk.lvm[j].nwrite);
dev->dsk.lvm[i].nrsect = subcount(cur->dsk.lvm[i].nrsect,
pre->dsk.lvm[j].nrsect);
dev->dsk.lvm[i].nwsect = subcount(cur->dsk.lvm[i].nwsect,
pre->dsk.lvm[j].nwsect);
dev->dsk.lvm[i].io_ms = subcount(cur->dsk.lvm[i].io_ms,
pre->dsk.lvm[j].io_ms);
dev->dsk.lvm[i].avque = subcount(cur->dsk.lvm[i].avque,
pre->dsk.lvm[j].avque);
/*
** determine new j
*/
if (pre->dsk.lvm[j].name[0] != '\0') // existing matching entry
j++;
else
j = realj; // empty entry: stick to old j
}
dev->dsk.lvm[i].name[0] = '\0';
dev->dsk.nlvm = i;
/*
** application-specific counters
*/
if (cur->www.uptime >= pre->www.uptime)
{
dev->www.accesses = subcount(cur->www.accesses,
pre->www.accesses);
dev->www.totkbytes = subcount(cur->www.totkbytes,
pre->www.totkbytes);
}
else
{
dev->www.accesses = cur->www.accesses;
dev->www.totkbytes = cur->www.totkbytes;
}
dev->www.bworkers = cur->www.bworkers;
dev->www.iworkers = cur->www.iworkers;
}
int
main(int argc, char *argv[])
{
register int i;
int c;
char *p;
char path[MAXPATHLEN];
pmOptions opts = {
.short_options = allflags,
.flags = PM_OPTFLAG_BOUNDARIES,
};
/*
** preserve command arguments to allow restart of other version
*/
argvp = argv;
/*
** read defaults-files /etc/atoprc en $HOME/.atoprc (if any)
*/
readrc("/etc/atoprc", 1);
if ( (p = getenv("HOME")) )
{
snprintf(path, sizeof(path), "%s/.atoprc", p);
path[sizeof(path)-1] = '\0';
readrc(path, 0);
}
/*
** check if we are supposed to behave as 'atopsar'
** i.e. system statistics only
*/
__pmSetProgname(argv[0]);
if (strcmp(pmProgname, "pcp-atopsar") == 0)
return atopsar(argc, argv);
__pmStartOptions(&opts);
if (opts.narchives > 0)
rawreadflag++;
/*
** interpret command-line arguments & flags
*/
if (argc > 1)
{
/*
** gather all flags for visualization-functions
**
** generic flags will be handled here;
** unrecognized flags are passed to the print-routines
*/
i = 0;
while (i < MAXFL-1 && (c = pmgetopt_r(argc, argv, &opts)) != EOF)
{
switch (c)
{
case '?': /* usage wanted ? */
prusage(pmProgname);
break;
case 'V': /* version wanted ? */
printf("%s\n", getstrvers());
exit(0);
case 'w': /* writing of raw data ? */
rawname = opts.optarg;
rawwriteflag++;
break;
case 'r': /* reading of raw data ? */
rawarchive(&opts, opts.optarg);
rawreadflag++;
break;
case 'S': /* midnight limit ? */
midnightflag++;
break;
case 'a': /* all processes per sample ? */
deviatonly = 0;
break;
case 'R': /* all processes per sample ? */
calcpss = 1;
break;
case 'b': /* begin time ? */
opts.start_optarg = abstime(opts.optarg);
break;
case 'e': /* end time ? */
opts.finish_optarg = abstime(opts.optarg);
break;
case 'P': /* parseable output? */
if ( !parsedef(opts.optarg) )
prusage(pmProgname);
vis.show_samp = parseout;
break;
case 'L': /* line length */
if ( !numeric(opts.optarg) )
prusage(pmProgname);
linelen = atoi(opts.optarg);
break;
default: /* gather other flags */
flaglist[i++] = c;
}
}
/*
** get optional interval-value and optional number of samples
*/
if (opts.optind < argc && opts.optind < MAXFL)
{
char *endnum, *arg;
arg = argv[opts.optind++];
if (pmParseInterval(arg, &opts.interval, &endnum) < 0)
{
pmprintf(
"%s: %s option not in pmParseInterval(3) format:\n%s\n",
pmProgname, arg, endnum);
free(endnum);
opts.errors++;
}
else
interval = opts.interval;
if (opts.optind < argc)
{
arg = argv[opts.optind];
if (!numeric(arg))
prusage(pmProgname);
if ((opts.samples = atoi(arg)) < 1)
prusage(pmProgname);
nsamples = opts.samples;
}
}
}
__pmEndOptions(&opts);
if (opts.errors)
prusage(pmProgname);
/*
** find local host details (no privileged access required)
*/
setup_globals(&opts);
/*
** check if we are in data recording mode
*/
if (rawwriteflag)
{
rawwrite(&opts, rawname, &interval, nsamples, midnightflag);
cleanstop(0);
}
/*
** catch signals for proper close-down
*/
signal(SIGHUP, cleanstop);
signal(SIGTERM, cleanstop);
/*
** switch-on the process-accounting mechanism to register the
** (remaining) resource-usage by processes which have finished
*/
acctreason = acctswon();
/*
** determine properties (like speed) of all interfaces
*/
initifprop();
/*
** open socket to the IP layer to issue getsockopt() calls later on
*/
netatop_ipopen();
/*
** start the engine now .....
*/
engine();
cleanstop(0);
return 0; /* never reached */
}
