r23780: Find and fix more GPL2 -> GPL3.
[bbaumbach/samba-autobuild/.git] / 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, write to the Free Software
19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 #include "perf.h"
23
24 sig_atomic_t keep_running = TRUE;
25
26 /* allocates memory and gets numCPUs, total memory, and PerfFreq, number of disks... */
27 void get_constants(PERF_DATA_BLOCK *data)
28 {
29     data->cpuInfo.numCPUs = sysconf(_SC_NPROCESSORS_ONLN) > 0 ? sysconf(_SC_NPROCESSORS_ONLN) : 1;
30     data->PerfFreq = sysconf(_SC_CLK_TCK);
31     init_mem_data(data);
32     init_cpu_data(data);
33     init_process_data(data);
34     init_disk_data(data);
35
36     return;
37 }
38
39 void output_num_instances(PerfCounter obj, int numInst, RuntimeSettings rt)
40 {
41     char key[NAME_LEN];
42     char sdata[NAME_LEN];
43
44     make_key(key, NAME_LEN, obj.index, "inst");
45     memset(sdata, 0, NAME_LEN);
46     sprintf(sdata, "%d", numInst);
47     add_key(rt.cnames, key, sdata, TDB_INSERT);
48
49     return;
50 }
51
52 void output_perf_desc(PerfCounter counter, RuntimeSettings rt)
53 {
54     char key[NAME_LEN];
55     char sdata[NAME_LEN];
56
57     /* First insert the counter name */
58     make_key(key, NAME_LEN, counter.index, NULL);
59     add_key(rt.cnames, key, counter.name, TDB_INSERT);
60     /* Add the help string */
61     make_key(key, NAME_LEN, counter.index + 1, NULL);
62     add_key(rt.cnames, key, counter.help, TDB_INSERT);
63     /* Add the relationships */
64     make_key(key, NAME_LEN, counter.index, "rel");
65     add_key(rt.cnames, key, counter.relationships, TDB_INSERT);
66     /* Add type data if not PERF_OBJECT or PERF_INSTANCE */
67     if(counter.record_type == PERF_COUNTER)
68     {
69         make_key(key, NAME_LEN, counter.index, "type");
70         memset(sdata, 0, NAME_LEN);
71         sprintf(sdata, "%d", counter.counter_type);
72         add_key(rt.cnames, key, sdata, TDB_INSERT);
73     }
74
75     return;
76 }
77
78 void initialize(PERF_DATA_BLOCK *data, RuntimeSettings *rt, int argc, char **argv)
79 {
80     memset(data, 0, sizeof(*data));
81     memset(rt, 0, sizeof(*data));
82
83     parse_flags(rt, argc, argv);
84     setup_file_paths(rt);
85
86     get_constants(data);
87
88     if(rt->dflag == TRUE)
89         daemonize(rt);
90
91     output_mem_desc(data, *rt);
92     output_cpu_desc(data, *rt);
93     output_process_desc(data, *rt);
94     output_disk_desc(data, *rt);
95
96     return;
97 }
98
99 void refresh_perf_data_block(PERF_DATA_BLOCK *data, RuntimeSettings rt)
100 {
101     data->PerfTime100nSec = 0;
102     get_meminfo(data);
103     get_cpuinfo(data);
104     get_processinfo(data);
105     get_diskinfo(data);
106     return;
107 }
108
109 void output_perf_counter(PerfCounter counter, unsigned long long data,
110                          RuntimeSettings rt, int tdb_flags)
111 {
112     char key[NAME_LEN];
113     char sdata[NAME_LEN];
114     unsigned int size_mask;
115
116     make_key(key, NAME_LEN, counter.index, NULL);
117     memset(sdata, 0, NAME_LEN);
118
119     size_mask = counter.counter_type & PERF_SIZE_VARIABLE_LEN;
120
121     if(size_mask == PERF_SIZE_DWORD)
122         sprintf(sdata, "%d", (unsigned int)data);
123     else if(size_mask == PERF_SIZE_LARGE)
124         sprintf(sdata, "%Lu", data);
125
126     add_key(rt.cdata, key, sdata, tdb_flags);
127
128     return;
129 }
130
131 void output_perf_instance(int parentObjInd,
132                           int instanceInd,
133                           void *instData,
134                           size_t dsize,
135                           char *name,
136                           RuntimeSettings rt,
137                           int tdb_flags)
138 {
139     char key[NAME_LEN];
140     char sdata[NAME_LEN];
141
142     memset(key, 0, NAME_LEN);
143     sprintf(key, "%di%d", parentObjInd, instanceInd);
144     add_key_raw(rt.cdata, key, instData, dsize, tdb_flags);
145
146     /* encode name */
147     memset(key, 0, NAME_LEN);
148     sprintf(key, "%di%dname", parentObjInd, instanceInd);
149     add_key(rt.cnames, key, name, tdb_flags);
150
151     return;
152 }
153
154 void output_global_data(PERF_DATA_BLOCK *data, RuntimeSettings rt, int tdb_flags)
155 {
156     int i;
157     char key[NAME_LEN];
158     char sdata[NAME_LEN];
159     
160      /* Initialize BaseIndex */
161     make_key(key, NAME_LEN, 1, NULL);
162     memset(sdata, 0, NAME_LEN);
163     sprintf(sdata, "%d", data->num_counters);
164     add_key(rt.cnames, key, sdata, tdb_flags);
165     /* Initialize PerfTime, PerfFreq and PerfTime100nSec */
166     memset(sdata, 0, NAME_LEN);
167     make_key(key, NAME_LEN, 0, "PerfTime");
168     sprintf(sdata, "%Lu", data->PerfTime);
169     add_key(rt.cdata, key, sdata, tdb_flags);
170     make_key(key, NAME_LEN, 0, "PerfTime100nSec");
171     memset(sdata, 0, NAME_LEN);
172     sprintf(sdata, "%Lu", data->PerfTime100nSec);
173     add_key(rt.cdata, key, sdata, tdb_flags);
174     memset(sdata, 0, NAME_LEN);
175     make_key(key, NAME_LEN, 0, "PerfFreq");
176     sprintf(sdata, "%Lu", data->PerfFreq);
177     add_key(rt.cnames, key, sdata, tdb_flags);
178
179     return;
180 }
181
182 void output_perf_data_block(PERF_DATA_BLOCK *data, RuntimeSettings rt, int tdb_flags)
183 {
184     output_global_data(data, rt, tdb_flags);
185     output_meminfo(data, rt, tdb_flags);
186     output_cpuinfo(data, rt, tdb_flags);
187     output_processinfo(data, rt, tdb_flags);
188     output_diskinfo(data, rt, tdb_flags);
189     return;
190 }
191
192 void update_counters(PERF_DATA_BLOCK *data, RuntimeSettings rt)
193 {
194     refresh_perf_data_block(data, rt);
195     output_perf_data_block(data, rt, TDB_REPLACE);
196
197     return;
198 }
199
200 int main(int argc, char **argv)
201 {
202     PERF_DATA_BLOCK data;
203     RuntimeSettings rt;
204
205     initialize(&data, &rt, argc, argv);
206
207     while(keep_running)
208     {
209         update_counters(&data, rt);
210         sleep(1);
211     }
212     
213     return 0;
214 }