examples/perfcounter/perf_writer.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Performance Counter Daemon
   4  *
   5  *  Copyright (C) Marcin Krzysztof Porwit    2005
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "perf.h"
  22
  23 sig_atomic_t keep_running = TRUE;
  24
  25 /* allocates memory and gets numCPUs, total memory, and PerfFreq, number of disks... */
  26 void get_constants(PERF_DATA_BLOCK *data)
  27 {
  28     data->cpuInfo.numCPUs = sysconf(_SC_NPROCESSORS_ONLN) > 0 ? sysconf(_SC_NPROCESSORS_ONLN) : 1;
  29     data->PerfFreq = sysconf(_SC_CLK_TCK);
  30     init_mem_data(data);
  31     init_cpu_data(data);
  32     init_process_data(data);
  33     init_disk_data(data);
  34
  35     return;
  36 }
  37
  38 void output_num_instances(PerfCounter obj, int numInst, RuntimeSettings rt)
  39 {
  40     char key[NAME_LEN];
  41     char sdata[NAME_LEN];
  42
  43     make_key(key, NAME_LEN, obj.index, "inst");
  44     memset(sdata, 0, NAME_LEN);
  45     sprintf(sdata, "%d", numInst);
  46     add_key(rt.cnames, key, sdata, TDB_INSERT);
  47
  48     return;
  49 }
  50
  51 void output_perf_desc(PerfCounter counter, RuntimeSettings rt)
  52 {
  53     char key[NAME_LEN];
  54     char sdata[NAME_LEN];
  55
  56     /* First insert the counter name */
  57     make_key(key, NAME_LEN, counter.index, NULL);
  58     add_key(rt.cnames, key, counter.name, TDB_INSERT);
  59     /* Add the help string */
  60     make_key(key, NAME_LEN, counter.index + 1, NULL);
  61     add_key(rt.cnames, key, counter.help, TDB_INSERT);
  62     /* Add the relationships */
  63     make_key(key, NAME_LEN, counter.index, "rel");
  64     add_key(rt.cnames, key, counter.relationships, TDB_INSERT);
  65     /* Add type data if not PERF_OBJECT or PERF_INSTANCE */
  66     if(counter.record_type == PERF_COUNTER)
  67     {
  68         make_key(key, NAME_LEN, counter.index, "type");
  69         memset(sdata, 0, NAME_LEN);
  70         sprintf(sdata, "%d", counter.counter_type);
  71         add_key(rt.cnames, key, sdata, TDB_INSERT);
  72     }
  73
  74     return;
  75 }
  76
  77 void initialize(PERF_DATA_BLOCK *data, RuntimeSettings *rt, int argc, char **argv)
  78 {
  79     memset(data, 0, sizeof(*data));
  80     memset(rt, 0, sizeof(*data));
  81
  82     parse_flags(rt, argc, argv);
  83     setup_file_paths(rt);
  84
  85     get_constants(data);
  86
  87     if(rt->dflag == TRUE)
  88         daemonize(rt);
  89
  90     output_mem_desc(data, *rt);
  91     output_cpu_desc(data, *rt);
  92     output_process_desc(data, *rt);
  93     output_disk_desc(data, *rt);
  94
  95     return;
  96 }
  97
  98 void refresh_perf_data_block(PERF_DATA_BLOCK *data, RuntimeSettings rt)
  99 {
 100     data->PerfTime100nSec = 0;
 101     get_meminfo(data);
 102     get_cpuinfo(data);
 103     get_processinfo(data);
 104     get_diskinfo(data);
 105     return;
 106 }
 107
 108 void output_perf_counter(PerfCounter counter, unsigned long long data,
 109                          RuntimeSettings rt, int tdb_flags)
 110 {
 111     char key[NAME_LEN];
 112     char sdata[NAME_LEN];
 113     unsigned int size_mask;
 114
 115     make_key(key, NAME_LEN, counter.index, NULL);
 116     memset(sdata, 0, NAME_LEN);
 117
 118     size_mask = counter.counter_type & PERF_SIZE_VARIABLE_LEN;
 119
 120     if(size_mask == PERF_SIZE_DWORD)
 121         sprintf(sdata, "%d", (unsigned int)data);
 122     else if(size_mask == PERF_SIZE_LARGE)
 123         sprintf(sdata, "%Lu", data);
 124
 125     add_key(rt.cdata, key, sdata, tdb_flags);
 126
 127     return;
 128 }
 129
 130 void output_perf_instance(int parentObjInd,
 131                           int instanceInd,
 132                           void *instData,
 133                           size_t dsize,
 134                           char *name,
 135                           RuntimeSettings rt,
 136                           int tdb_flags)
 137 {
 138     char key[NAME_LEN];
 139     char sdata[NAME_LEN];
 140
 141     memset(key, 0, NAME_LEN);
 142     sprintf(key, "%di%d", parentObjInd, instanceInd);
 143     add_key_raw(rt.cdata, key, instData, dsize, tdb_flags);
 144
 145     /* encode name */
 146     memset(key, 0, NAME_LEN);
 147     sprintf(key, "%di%dname", parentObjInd, instanceInd);
 148     add_key(rt.cnames, key, name, tdb_flags);
 149
 150     return;
 151 }
 152
 153 void output_global_data(PERF_DATA_BLOCK *data, RuntimeSettings rt, int tdb_flags)
 154 {
 155     int i;
 156     char key[NAME_LEN];
 157     char sdata[NAME_LEN];
 158
 159      /* Initialize BaseIndex */
 160     make_key(key, NAME_LEN, 1, NULL);
 161     memset(sdata, 0, NAME_LEN);
 162     sprintf(sdata, "%d", data->num_counters);
 163     add_key(rt.cnames, key, sdata, tdb_flags);
 164     /* Initialize PerfTime, PerfFreq and PerfTime100nSec */
 165     memset(sdata, 0, NAME_LEN);
 166     make_key(key, NAME_LEN, 0, "PerfTime");
 167     sprintf(sdata, "%Lu", data->PerfTime);
 168     add_key(rt.cdata, key, sdata, tdb_flags);
 169     make_key(key, NAME_LEN, 0, "PerfTime100nSec");
 170     memset(sdata, 0, NAME_LEN);
 171     sprintf(sdata, "%Lu", data->PerfTime100nSec);
 172     add_key(rt.cdata, key, sdata, tdb_flags);
 173     memset(sdata, 0, NAME_LEN);
 174     make_key(key, NAME_LEN, 0, "PerfFreq");
 175     sprintf(sdata, "%Lu", data->PerfFreq);
 176     add_key(rt.cnames, key, sdata, tdb_flags);
 177
 178     return;
 179 }
 180
 181 void output_perf_data_block(PERF_DATA_BLOCK *data, RuntimeSettings rt, int tdb_flags)
 182 {
 183     output_global_data(data, rt, tdb_flags);
 184     output_meminfo(data, rt, tdb_flags);
 185     output_cpuinfo(data, rt, tdb_flags);
 186     output_processinfo(data, rt, tdb_flags);
 187     output_diskinfo(data, rt, tdb_flags);
 188     return;
 189 }
 190
 191 void update_counters(PERF_DATA_BLOCK *data, RuntimeSettings rt)
 192 {
 193     refresh_perf_data_block(data, rt);
 194     output_perf_data_block(data, rt, TDB_REPLACE);
 195
 196     return;
 197 }
 198
 199 int main(int argc, char **argv)
 200 {
 201     PERF_DATA_BLOCK data;
 202     RuntimeSettings rt;
 203
 204     initialize(&data, &rt, argc, argv);
 205
 206     while(keep_running)
 207     {
 208         update_counters(&data, rt);
 209         sleep(1);
 210     }
 211
 212     return 0;
 213 }