739
739
* Compute the uptime of the system in jiffies (1/100ths of a second
741
741
* Machine uptime is multiplied by the number of processors here.
742
* Note that overflow is not so far away: ULONG_MAX is 4294967295 on
743
* 32 bit systems. Overflow happens when machine uptime is:
744
* 497 days on a monoprocessor machine,
745
* 248 days on a bi processor,
746
* 124 days on a quad processor...
748
743
file_stats.uptime = file_stats.cpu_user + file_stats.cpu_nice +
749
744
file_stats.cpu_system + file_stats.cpu_idle +
777
772
/* else additional CPUs have been dynamically registered in /proc/stat */
774
if (!proc_nb && !file_stats.uptime0)
781
776
* Compute uptime reduced to one proc using proc#0.
782
* Assume that proc#0 can never be offlined.
777
* Done if /proc/uptime was unavailable.
784
779
file_stats.uptime0 = cc_user + cc_nice + cc_system +
785
780
cc_idle + cc_iowait + cc_steal;
882
877
if (dsk < disk_nr) {
883
878
st_disk_i = st_disk + dsk++;
884
st_disk_i->major = v_major;
885
st_disk_i->minor = v_index;
886
st_disk_i->nr_ios = v_tmp[0];
879
st_disk_i->major = v_major;
880
st_disk_i->minor = v_index;
881
st_disk_i->nr_ios = v_tmp[0];
887
882
st_disk_i->rd_sect = v_tmp[2];
888
883
st_disk_i->wr_sect = v_tmp[4];
945
940
void read_proc_meminfo(void)
948
static char line[128];
950
if ((fp = fopen(MEMINFO, "r")) == NULL)
942
struct meminf st_mem;
944
memset(&st_mem, 0, sizeof(struct meminf));
946
if (readp_meminfo(&st_mem))
953
while (fgets(line, 128, fp) != NULL) {
955
if (!strncmp(line, "MemTotal:", 9))
956
/* Read the total amount of memory in kB */
957
sscanf(line + 9, "%lu", &(file_stats.tlmkb));
958
else if (!strncmp(line, "MemFree:", 8))
959
/* Read the amount of free memory in kB */
960
sscanf(line + 8, "%lu", &(file_stats.frmkb));
962
else if (!strncmp(line, "Buffers:", 8))
963
/* Read the amount of buffered memory in kB */
964
sscanf(line + 8, "%lu", &(file_stats.bufkb));
966
else if (!strncmp(line, "Cached:", 7))
967
/* Read the amount of cached memory in kB */
968
sscanf(line + 7, "%lu", &(file_stats.camkb));
970
else if (!strncmp(line, "SwapCached:", 11))
971
/* Read the amount of cached swap in kB */
972
sscanf(line + 11, "%lu", &(file_stats.caskb));
974
else if (!strncmp(line, "SwapTotal:", 10))
975
/* Read the total amount of swap memory in kB */
976
sscanf(line + 10, "%lu", &(file_stats.tlskb));
978
else if (!strncmp(line, "SwapFree:", 9))
979
/* Read the amount of free swap memory in kB */
980
sscanf(line + 9, "%lu", &(file_stats.frskb));
949
file_stats.tlmkb = st_mem.tlmkb;
950
file_stats.frmkb = st_mem.frmkb;
951
file_stats.bufkb = st_mem.bufkb;
952
file_stats.camkb = st_mem.camkb;
953
file_stats.caskb = st_mem.caskb;
954
file_stats.tlskb = st_mem.tlskb;
955
file_stats.frskb = st_mem.frskb;
1469
1441
/* Unused device: ignore it */
1471
1443
st_disk_i = st_disk + dsk++;
1472
st_disk_i->major = major;
1473
st_disk_i->minor = minor;
1474
st_disk_i->nr_ios = rd_ios + wr_ios;
1475
st_disk_i->rd_sect = rd_sec;
1476
st_disk_i->wr_sect = wr_sec;
1477
st_disk_i->rd_ticks = rd_ticks;
1478
st_disk_i->wr_ticks = wr_ticks;
1444
st_disk_i->major = major;
1445
st_disk_i->minor = minor;
1446
st_disk_i->nr_ios = rd_ios + wr_ios;
1447
st_disk_i->rd_sect = rd_sec;
1448
st_disk_i->wr_sect = wr_sec;
1449
st_disk_i->rd_ticks = rd_ticks;
1450
st_disk_i->wr_ticks = wr_ticks;
1479
1451
st_disk_i->tot_ticks = tot_ticks;
1480
st_disk_i->rq_ticks = rq_ticks;
1452
st_disk_i->rq_ticks = rq_ticks;
1482
file_stats.dk_drive += rd_ios + wr_ios;
1483
file_stats.dk_drive_rio += rd_ios;
1454
file_stats.dk_drive += rd_ios + wr_ios;
1455
file_stats.dk_drive_rio += rd_ios;
1484
1456
file_stats.dk_drive_rblk += (unsigned int) rd_sec;
1485
file_stats.dk_drive_wio += wr_ios;
1457
file_stats.dk_drive_wio += wr_ios;
1486
1458
file_stats.dk_drive_wblk += (unsigned int) wr_sec;
1530
1502
if (ioc_iswhole(major, minor)) {
1531
1503
/* OK: it's a device and not a partition */
1532
1504
st_disk_i = st_disk + dsk++;
1533
st_disk_i->major = major;
1534
st_disk_i->minor = minor;
1535
st_disk_i->nr_ios = rd_ios + wr_ios;
1536
st_disk_i->rd_sect = rd_sec;
1537
st_disk_i->wr_sect = wr_sec;
1538
st_disk_i->rd_ticks = rd_ticks;
1539
st_disk_i->wr_ticks = wr_ticks;
1505
st_disk_i->major = major;
1506
st_disk_i->minor = minor;
1507
st_disk_i->nr_ios = rd_ios + wr_ios;
1508
st_disk_i->rd_sect = rd_sec;
1509
st_disk_i->wr_sect = wr_sec;
1510
st_disk_i->rd_ticks = rd_ticks;
1511
st_disk_i->wr_ticks = wr_ticks;
1540
1512
st_disk_i->tot_ticks = tot_ticks;
1541
st_disk_i->rq_ticks = rq_ticks;
1513
st_disk_i->rq_ticks = rq_ticks;
1543
file_stats.dk_drive += rd_ios + wr_ios;
1544
file_stats.dk_drive_rio += rd_ios;
1515
file_stats.dk_drive += rd_ios + wr_ios;
1516
file_stats.dk_drive_rio += rd_ios;
1545
1517
file_stats.dk_drive_rblk += (unsigned int) rd_sec;
1546
file_stats.dk_drive_wio += wr_ios;
1518
file_stats.dk_drive_wio += wr_ios;
1547
1519
file_stats.dk_drive_wblk += (unsigned int) wr_sec;
1571
1543
void read_stats(unsigned int *flags)
1546
* Init uptime0. So if /proc/uptime cannot fill it,
1547
* this will be done by /proc/stat.
1548
* If cpu_nr = 1, force /proc/stat to fill it.
1549
* If cpu_nr = 0, uptime0 and uptime are equal.
1550
* NB: uptime0 is always filled.
1552
file_stats.uptime0 = 0;
1554
readp_uptime(&(file_stats.uptime0));
1573
1555
read_proc_stat(*flags);
1557
file_stats.uptime0 = file_stats.uptime;
1574
1558
read_proc_meminfo();
1575
1559
read_proc_loadavg();
1576
1560
read_proc_vmstat();
1617
1601
* Init file_stats structure. Every record of other structures
1618
1602
* is set when reading corresponding stat file (records are set
1619
1603
* to 0 if there are not enough data to fill the structure).
1604
* Exception for individual CPU's structures which must not be
1605
* init'ed to keep values for CPU before they were disabled.
1621
1607
memset(&file_stats, 0, FILE_STATS_SIZE);
added
removed
sadc.c
