1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
|
/* (C) 2009-2017 by Harald Welte <laforge@gnumonks.org>
*
* All Rights Reserved
*
* SPDX-License-Identifier: GPL-2.0+
*
* 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 of the License, 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
/*! \addtogroup rate_ctr
* @{
* Counters about events and their event rates.
*
* As \ref osmo_counter and \ref osmo_stat_item are concerned only with
* a single given value that may be increased/decreased, or the difference
* to one given previous value, this module adds some support for keeping
* long term information about a given event rate.
*
* A \ref rate_ctr keeps information on the amount of events per second,
* per minute, per hour and per day.
*
* \ref rate_ctr come in groups: An application describes a group of counters
* with their names and identities once in a (typically const) \ref
* rate_ctr_group_desc.
*
* As objects (such as e.g. a subscriber or a PDP context) are
* allocated dynamically at runtime, the application calls \ref
* rate_ctr_group_alloc with a refernce to the \ref
* rate_ctr_group_desc, which causes the library to allocate one set of
* \ref rate_ctr: One for each in the group.
*
* The application then uses functions like \ref rate_ctr_add or \ref
* rate_ctr_inc to increment the value as certain events (e.g. location
* update) happens.
*
* The library internally keeps a timer once per second which iterates
* over all registered counters and which updates the per-second,
* per-minute, per-hour and per-day averages based on the current
* value.
*
* The counters can be reported using \ref stats or by VTY
* introspection, as well as by any application-specific code accessing
* the \ref rate_ctr.intv array directly.
*
* \file rate_ctr.c */
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <osmocom/core/utils.h>
#include <osmocom/core/linuxlist.h>
#include <osmocom/core/talloc.h>
#include <osmocom/core/timer.h>
#include <osmocom/core/rate_ctr.h>
#include <osmocom/core/logging.h>
static LLIST_HEAD(rate_ctr_groups);
static void *tall_rate_ctr_ctx;
static bool rate_ctrl_group_desc_validate(const struct rate_ctr_group_desc *desc)
{
unsigned int i;
const struct rate_ctr_desc *ctr_desc;
if (!desc) {
LOGP(DLGLOBAL, LOGL_ERROR, "NULL is not a valid counter group descriptor\n");
return false;
}
ctr_desc = desc->ctr_desc;
DEBUGP(DLGLOBAL, "validating counter group %p(%s) with %u counters\n", desc,
desc->group_name_prefix, desc->num_ctr);
if (!osmo_identifier_valid(desc->group_name_prefix)) {
LOGP(DLGLOBAL, LOGL_ERROR, "'%s' is not a valid counter group identifier\n",
desc->group_name_prefix);
return false;
}
for (i = 0; i < desc->num_ctr; i++) {
if (!osmo_identifier_valid(ctr_desc[i].name)) {
LOGP(DLGLOBAL, LOGL_ERROR, "'%s' is not a valid counter identifier\n",
ctr_desc[i].name);
return false;
}
}
return true;
}
/* return 'in' if it doesn't contain any '.'; otherwise allocate a copy and
* replace all '.' with ':' */
static char *mangle_identifier_ifneeded(const void *ctx, const char *in)
{
char *out;
unsigned int i;
bool modified = false;
if (!in)
return NULL;
if (!strchr(in, '.'))
return (char *)in;
out = talloc_strdup(ctx, in);
OSMO_ASSERT(out);
for (i = 0; i < strlen(out); i++) {
if (out[i] == '.') {
out[i] = ':';
modified = true;
}
}
if (modified)
LOGP(DLGLOBAL, LOGL_NOTICE, "counter group name mangled: '%s' -> '%s'\n",
in, out);
return out;
}
/* "mangle" a rate counter group descriptor, i.e. replace any '.' with ':' */
static struct rate_ctr_group_desc *
rate_ctr_group_desc_mangle(void *ctx, const struct rate_ctr_group_desc *desc)
{
struct rate_ctr_group_desc *desc_new = talloc_zero(ctx, struct rate_ctr_group_desc);
int i;
OSMO_ASSERT(desc_new);
LOGP(DLGLOBAL, LOGL_INFO, "Needed to mangle counter group '%s' names: it is still using '.' as "
"separator, which is not allowed. please consider updating the application\n",
desc->group_name_prefix);
/* mangle the name_prefix but copy/keep the rest */
desc_new->group_name_prefix = mangle_identifier_ifneeded(desc_new, desc->group_name_prefix);
desc_new->group_description = desc->group_description;
desc_new->class_id = desc->class_id;
desc_new->num_ctr = desc->num_ctr;
desc_new->ctr_desc = talloc_array(desc_new, struct rate_ctr_desc, desc_new->num_ctr);
OSMO_ASSERT(desc_new->ctr_desc);
for (i = 0; i < desc->num_ctr; i++) {
struct rate_ctr_desc *ctrd_new = (struct rate_ctr_desc *) desc_new->ctr_desc;
const struct rate_ctr_desc *ctrd = desc->ctr_desc;
if (!ctrd[i].name) {
LOGP(DLGLOBAL, LOGL_ERROR, "counter group '%s'[%d] == NULL, aborting\n",
desc->group_name_prefix, i);
goto err_free;
}
ctrd_new[i].name = mangle_identifier_ifneeded(desc_new->ctr_desc, ctrd[i].name);
ctrd_new[i].description = ctrd[i].description;
}
if (!rate_ctrl_group_desc_validate(desc_new)) {
/* simple mangling of identifiers ('.' -> ':') was not sufficient to render a valid
* descriptor, we have to bail out */
LOGP(DLGLOBAL, LOGL_ERROR, "counter group '%s' still invalid after mangling\n",
desc->group_name_prefix);
goto err_free;
}
return desc_new;
err_free:
talloc_free(desc_new);
return NULL;
}
/*! Find an unused index for this rate counter group.
* \param[in] name Name of the counter group
* \returns the largest used index number + 1, or 0 if none exist yet. */
static unsigned int rate_ctr_get_unused_name_idx(const char *name)
{
unsigned int idx = 0;
struct rate_ctr_group *ctrg;
llist_for_each_entry(ctrg, &rate_ctr_groups, list) {
if (!ctrg->desc)
continue;
if (strcmp(ctrg->desc->group_name_prefix, name))
continue;
if (idx <= ctrg->idx)
idx = ctrg->idx + 1;
}
return idx;
}
/*! Allocate a new group of counters according to description
* \param[in] ctx parent talloc context
* \param[in] desc Rate counter group description
* \param[in] idx Index of new counter group
*/
struct rate_ctr_group *rate_ctr_group_alloc(void *ctx,
const struct rate_ctr_group_desc *desc,
unsigned int idx)
{
unsigned int size;
struct rate_ctr_group *group;
if (rate_ctr_get_group_by_name_idx(desc->group_name_prefix, idx)) {
unsigned int new_idx = rate_ctr_get_unused_name_idx(desc->group_name_prefix);
LOGP(DLGLOBAL, LOGL_ERROR, "counter group '%s' already exists for index %u,"
" instead using index %u. This is a software bug that needs fixing.\n",
desc->group_name_prefix, idx, new_idx);
idx = new_idx;
}
size = sizeof(struct rate_ctr_group) +
desc->num_ctr * sizeof(struct rate_ctr);
if (!ctx)
ctx = tall_rate_ctr_ctx;
group = talloc_zero_size(ctx, size);
if (!group)
return NULL;
/* attempt to mangle all '.' in identifiers to ':' for backwards compat */
if (!rate_ctrl_group_desc_validate(desc)) {
desc = rate_ctr_group_desc_mangle(group, desc);
if (!desc) {
talloc_free(group);
return NULL;
}
}
group->desc = desc;
group->idx = idx;
llist_add(&group->list, &rate_ctr_groups);
return group;
}
/*! Free the memory for the specified group of counters */
void rate_ctr_group_free(struct rate_ctr_group *grp)
{
if (!grp)
return;
if (!llist_empty(&grp->list))
llist_del(&grp->list);
talloc_free(grp);
}
/*! Add a number to the counter */
void rate_ctr_add(struct rate_ctr *ctr, int inc)
{
ctr->current += inc;
}
/*! Return the counter difference since the last call to this function */
int64_t rate_ctr_difference(struct rate_ctr *ctr)
{
int64_t result = ctr->current - ctr->previous;
ctr->previous = ctr->current;
return result;
}
/* TODO: support update intervals > 1s */
/* TODO: implement this as a special stats reporter */
static void interval_expired(struct rate_ctr *ctr, enum rate_ctr_intv intv)
{
/* calculate rate over last interval */
ctr->intv[intv].rate = ctr->current - ctr->intv[intv].last;
/* save current counter for next interval */
ctr->intv[intv].last = ctr->current;
/* update the rate of the next bigger interval. This will
* be overwritten when that next larger interval expires */
if (intv + 1 < ARRAY_SIZE(ctr->intv))
ctr->intv[intv+1].rate += ctr->intv[intv].rate;
}
static struct osmo_timer_list rate_ctr_timer;
static uint64_t timer_ticks;
/* The one-second interval has expired */
static void rate_ctr_group_intv(struct rate_ctr_group *grp)
{
unsigned int i;
for (i = 0; i < grp->desc->num_ctr; i++) {
struct rate_ctr *ctr = &grp->ctr[i];
interval_expired(ctr, RATE_CTR_INTV_SEC);
if ((timer_ticks % 60) == 0)
interval_expired(ctr, RATE_CTR_INTV_MIN);
if ((timer_ticks % (60*60)) == 0)
interval_expired(ctr, RATE_CTR_INTV_HOUR);
if ((timer_ticks % (24*60*60)) == 0)
interval_expired(ctr, RATE_CTR_INTV_DAY);
}
}
static void rate_ctr_timer_cb(void *data)
{
struct rate_ctr_group *ctrg;
/* Increment number of ticks before we calculate intervals,
* as a counter value of 0 would already wrap all counters */
timer_ticks++;
llist_for_each_entry(ctrg, &rate_ctr_groups, list)
rate_ctr_group_intv(ctrg);
osmo_timer_schedule(&rate_ctr_timer, 1, 0);
}
/*! Initialize the counter module. Call this once from your application.
* \param[in] tall_ctx Talloc context from which rate_ctr_group will be allocated
* \returns 0 on success; negative on error */
int rate_ctr_init(void *tall_ctx)
{
tall_rate_ctr_ctx = tall_ctx;
osmo_timer_setup(&rate_ctr_timer, rate_ctr_timer_cb, NULL);
osmo_timer_schedule(&rate_ctr_timer, 1, 0);
return 0;
}
/*! Search for counter group based on group name and index
* \param[in] name Name of the counter group you're looking for
* \param[in] idx Index inside the counter group
* \returns \ref rate_ctr_group or NULL in case of error */
struct rate_ctr_group *rate_ctr_get_group_by_name_idx(const char *name, const unsigned int idx)
{
struct rate_ctr_group *ctrg;
llist_for_each_entry(ctrg, &rate_ctr_groups, list) {
if (!ctrg->desc)
continue;
if (!strcmp(ctrg->desc->group_name_prefix, name) &&
ctrg->idx == idx) {
return ctrg;
}
}
return NULL;
}
/*! Search for counter based on group + name
* \param[in] ctrg pointer to \ref rate_ctr_group
* \param[in] name name of counter inside group
* \returns \ref rate_ctr or NULL in case of error
*/
const struct rate_ctr *rate_ctr_get_by_name(const struct rate_ctr_group *ctrg, const char *name)
{
int i;
const struct rate_ctr_desc *ctr_desc;
if (!ctrg->desc)
return NULL;
for (i = 0; i < ctrg->desc->num_ctr; i++) {
ctr_desc = &ctrg->desc->ctr_desc[i];
if (!strcmp(ctr_desc->name, name)) {
return &ctrg->ctr[i];
}
}
return NULL;
}
/*! Iterate over each counter in group and call function
* \param[in] ctrg counter group over which to iterate
* \param[in] handle_counter function pointer
* \param[in] data Data to hand transparently to handle_counter()
* \returns 0 on success; negative otherwise
*/
int rate_ctr_for_each_counter(struct rate_ctr_group *ctrg,
rate_ctr_handler_t handle_counter, void *data)
{
int rc = 0;
int i;
for (i = 0; i < ctrg->desc->num_ctr; i++) {
struct rate_ctr *ctr = &ctrg->ctr[i];
rc = handle_counter(ctrg,
ctr, &ctrg->desc->ctr_desc[i], data);
if (rc < 0)
return rc;
}
return rc;
}
/*! Iterate over all counter groups
* \param[in] handle_group function pointer of callback function
* \param[in] data Data to hand transparently to handle_group()
* \returns 0 on success; negative otherwise
*/
int rate_ctr_for_each_group(rate_ctr_group_handler_t handle_group, void *data)
{
struct rate_ctr_group *statg;
int rc = 0;
llist_for_each_entry(statg, &rate_ctr_groups, list) {
rc = handle_group(statg, data);
if (rc < 0)
return rc;
}
return rc;
}
/*! @} */
|