core: Changed WS from being a flag on a TCP/TLS connection to a protocol in its own...
[sip-router] / counters.c
1 /* 
2  * Copyright (C) 2010 iptelorg GmbH
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16
17 /**
18  * @brief counters/stats
19  * @file
20  * @ingroup: core
21  */
22
23 /*
24  * History:
25  * --------
26  *  2010-08-06  initial version (andrei)
27  *  2010-08-24  counters can be used (inc,add) before prefork_init (andrei)
28 */
29
30 #include "counters.h"
31 #include "str_hash.h"
32 #include "str.h"
33 #include "compiler_opt.h"
34 #include "mem/mem.h"
35 #include "mem/shm_mem.h"
36
37
38 #define CNT_HASH_SIZE   64
39 /* group hash size (rpc use) */
40 #define GRP_HASH_SIZE   16
41 /* initial sorted groups array size (rpc use) */
42 #define GRP_SORTED_SIZE 16
43 /* intial counter id 2 record array size */
44 #define CNT_ID2RECORD_SIZE      64
45
46 #define CACHELINE_PAD 128
47
48
49
50 /* leave space for one flag */
51 #define MAX_COUNTER_ID 32767
52 /* size (number of entries) of the temporary array used for keeping stats
53    pre-prefork init.  Note: if more counters are registered then this size,
54    the array will be dynamically increased (doubled each time). The value
55    here is meant only to optimize startup/memory fragmentation. */
56 #define PREINIT_CNTS_VALS_SIZE 128
57
58 struct counter_record {
59         str group;
60         str name;
61         counter_handle_t h;
62         unsigned short flags;
63         void* cbk_param;
64         counter_cbk_f cbk;
65         struct counter_record* grp_next; /* next in group */
66         str doc;
67 };
68
69
70 struct grp_record {
71         str group;
72         struct counter_record* first;
73 };
74
75
76
77 /** hash table mapping a counter name to an id */
78 static struct str_hash_table cnts_hash_table;
79 /** array maping id 2 record */
80 struct counter_record** cnt_id2record;
81 static int cnt_id2record_size;
82 /** hash table for groups (maps a group name to a counter list) */
83 static struct str_hash_table grp_hash_table;
84 /** array of groups, sorted */
85 static struct grp_record** grp_sorted;
86 static int grp_sorted_max_size;
87 static int grp_sorted_crt_size;
88 static int grp_no; /* number of groups */
89
90 /** counters array. a[proc_no][counter_id] =>
91   _cnst_vals[proc_no*cnts_no+counter_id] */
92 counter_array_t* _cnts_vals;
93 int _cnts_row_len; /* number of elements per row */
94 static int cnts_no; /* number of registered counters */
95 static int cnts_max_rows; /* set to 0 if not yet fully init */
96
97
98
99 /** init the coutner hash table(s).
100  * @return 0 on success, -1 on error.
101  */
102 int init_counters()
103 {
104         if (str_hash_alloc(&cnts_hash_table, CNT_HASH_SIZE) < 0)
105                 goto error;
106         str_hash_init(&cnts_hash_table);
107         if (str_hash_alloc(&grp_hash_table, GRP_HASH_SIZE) < 0)
108                 goto error;
109         str_hash_init(&grp_hash_table);
110         cnts_no = 1; /* start at 1 (0 used only for invalid counters) */
111         cnts_max_rows = 0; /* 0 initially, !=0 after full init
112                                                   (counters_prefork_init()) */
113         grp_no = 0;
114         cnt_id2record_size = CNT_ID2RECORD_SIZE;
115         cnt_id2record = pkg_malloc(sizeof(*cnt_id2record) * cnt_id2record_size);
116         if (cnt_id2record == 0)
117                 goto error;
118         memset(cnt_id2record, 0, sizeof(*cnt_id2record) * cnt_id2record_size);
119         grp_sorted_max_size = GRP_SORTED_SIZE;
120         grp_sorted_crt_size = 0;
121         grp_sorted = pkg_malloc(sizeof(*grp_sorted) * grp_sorted_max_size);
122         if (grp_sorted == 0)
123                 goto error;
124         memset(grp_sorted, 0, sizeof(*grp_sorted) * grp_sorted_max_size);
125         return 0;
126 error:
127         destroy_counters();
128         return -1;
129 }
130
131
132
133 void destroy_counters()
134 {
135         int r;
136         struct str_hash_entry* e;
137         struct str_hash_entry* bak;
138         if (_cnts_vals) {
139                 if (cnts_max_rows)
140                         /* fully init => it is in shm */
141                         shm_free(_cnts_vals);
142                 else
143                         /* partially init (before prefork) => pkg */
144                         pkg_free(_cnts_vals);
145                 _cnts_vals = 0;
146         }
147         if (cnts_hash_table.table) {
148                 for (r=0; r< cnts_hash_table.size; r++) {
149                         clist_foreach_safe(&cnts_hash_table.table[r], e, bak, next) {
150                                 pkg_free(e);
151                         }
152                 }
153                 pkg_free(cnts_hash_table.table);
154         }
155         if (grp_hash_table.table) {
156                 for (r=0; r< grp_hash_table.size; r++) {
157                         clist_foreach_safe(&grp_hash_table.table[r], e, bak, next) {
158                                 pkg_free(e);
159                         }
160                 }
161                 pkg_free(grp_hash_table.table);
162         }
163         if (cnt_id2record)
164                 pkg_free(cnt_id2record);
165         if (grp_sorted)
166                 pkg_free(grp_sorted);
167         cnts_hash_table.table = 0;
168         cnts_hash_table.size = 0;
169         cnt_id2record = 0;
170         grp_sorted = 0;
171         grp_hash_table.table = 0;
172         grp_hash_table.size = 0;
173         grp_sorted_crt_size = 0;
174         grp_sorted_max_size = 0;
175         cnts_no = 0;
176         _cnts_row_len = 0;
177         cnts_max_rows = 0;
178         grp_no = 0;
179 }
180
181
182
183 /** complete counter intialization, when the number of processes is known.
184  * shm must be available.
185  * @return 0 on success, < 0 on error
186  */
187 int counters_prefork_init(int max_process_no)
188 {
189         counter_array_t* old;
190         int size, row_size;
191         counter_handle_t h;
192         /* round cnts_no so that cnts_no * sizeof(counter) it's a CACHELINE_PAD
193            multiple */
194         /* round-up row_size to a CACHELINE_PAD multiple  if needed */
195         row_size = ((sizeof(*_cnts_vals) * cnts_no - 1) / CACHELINE_PAD + 1) *
196                 CACHELINE_PAD;
197         /* round-up the resulted row_siue to a sizeof(*_cnts_vals) multiple */
198         row_size = ((row_size -1) / sizeof(*_cnts_vals) + 1) *
199                                 sizeof(*_cnts_vals);
200         /* get updated cnts_no (row length) */
201         _cnts_row_len = row_size / sizeof(*_cnts_vals);
202         size = max_process_no * row_size;
203         /* replace the temporary pre-fork pkg array (with only 1 row) with
204            the final shm version (with max_process_no rows) */
205         old = _cnts_vals;
206         _cnts_vals = shm_malloc(size);
207         if (_cnts_vals == 0)
208                 return -1;
209         memset(_cnts_vals, 0, size);
210         cnts_max_rows = max_process_no;
211         /* copy prefork values into the newly shm array */
212         if (old) {
213                 for (h.id = 0; h.id < cnts_no; h.id++)
214                         counter_pprocess_val(process_no, h) = old[h.id].v;
215                 pkg_free(old);
216         }
217         return 0;
218 }
219
220
221
222 /** adds new group to the group hash table (no checks, internal version).
223  * @return pointer to new group record on success, 0 on error.
224  */
225 static struct grp_record* grp_hash_add(str* group)
226 {
227         struct str_hash_entry* g;
228         struct grp_record* grp_rec;
229         struct grp_record** r;
230
231         /* grp_rec copied at &g->u.data */
232         g = pkg_malloc(sizeof(struct str_hash_entry) - sizeof(g->u.data) +
233                                         sizeof(*grp_rec) + group->len + 1);
234         if (g == 0)
235                 goto error;
236         grp_rec = (struct grp_record*)&g->u.data[0];
237         grp_rec->group.s = (char*)(grp_rec + 1);
238         grp_rec->group.len = group->len;
239         grp_rec->first = 0;
240         memcpy(grp_rec->group.s, group->s, group->len + 1);
241         g->key = grp_rec->group;
242         g->flags = 0;
243         /* insert group into the sorted group array */
244         if (grp_sorted_max_size <= grp_sorted_crt_size) {
245                 /* must increase the array */
246                 r = pkg_realloc(grp_sorted, 2 * grp_sorted_max_size *
247                                                 sizeof(*grp_sorted));
248                 if (r == 0)
249                         goto error;
250                 grp_sorted= r;
251                 grp_sorted_max_size *= 2;
252                 memset(&grp_sorted[grp_sorted_crt_size], 0,
253                                 (grp_sorted_max_size - grp_sorted_crt_size) *
254                                 sizeof(*grp_sorted));
255         }
256         for (r = grp_sorted; r < (grp_sorted + grp_sorted_crt_size); r++)
257                 if (strcmp(grp_rec->group.s, (*r)->group.s) < 0)
258                         break;
259         if (r != (grp_sorted + grp_sorted_crt_size))
260                 memmove(r+1, r, (int)(long)((char*)(grp_sorted + grp_sorted_crt_size) -
261                                                 (char*)r));
262         grp_sorted_crt_size++;
263         *r = grp_rec;
264         /* insert into the hash only on success */
265         str_hash_add(&grp_hash_table, g);
266         return grp_rec;
267 error:
268         if (g)
269                 pkg_free(g);
270         return 0;
271 }
272
273
274
275 /** lookup a group into the group hash (internal version).
276  * @return pointer to grp_record on success, 0 on failure (not found).
277  */
278 static struct grp_record* grp_hash_lookup(str* group)
279 {
280         struct str_hash_entry* e;
281         e = str_hash_get(&grp_hash_table, group->s, group->len);
282         return e?(struct grp_record*)&e->u.data[0]:0;
283 }
284
285
286
287 /** lookup a group and if not found create a new group record.
288  * @return pointer to grp_record on succes, 0 on failure ( not found and
289  *  failed to create new group record).
290  */
291 static struct grp_record* grp_hash_get_create(str* group)
292 {
293         struct grp_record* ret;
294
295         ret = grp_hash_lookup(group);
296         if (ret)
297                 return ret;
298         return grp_hash_add(group);
299 }
300
301
302
303 /** adds new counter to the hash table (no checks, internal version).
304  * @return pointer to new record on success, 0 on error.
305  */
306 static struct counter_record* cnt_hash_add(
307                                                         str* group, str* name,
308                                                         int flags, counter_cbk_f cbk,
309                                                         void* param, const char* doc)
310 {
311         struct str_hash_entry* e;
312         struct counter_record* cnt_rec;
313         struct grp_record* grp_rec;
314         struct counter_record** p;
315         counter_array_t* v;
316         int doc_len;
317         int n;
318         
319         e = 0;
320         if (cnts_no >= MAX_COUNTER_ID)
321                 /* too many counters */
322                 goto error;
323         grp_rec = grp_hash_get_create(group);
324         if (grp_rec == 0)
325                 /* non existing group an no new one could be created */
326                 goto error;
327         doc_len = doc?strlen(doc):0;
328         /* cnt_rec copied at &e->u.data[0] */
329         e = pkg_malloc(sizeof(struct str_hash_entry) - sizeof(e->u.data) +
330                                         sizeof(*cnt_rec) + name->len + 1 + group->len + 1 +
331                                         doc_len + 1);
332         if (e == 0)
333                 goto error;
334         cnt_rec = (struct counter_record*)&e->u.data[0];
335         cnt_rec->group.s = (char*)(cnt_rec + 1);
336         cnt_rec->group.len = group->len;
337         cnt_rec->name.s = cnt_rec->group.s + group->len + 1;
338         cnt_rec->name.len = name->len;
339         cnt_rec->doc.s = cnt_rec->name.s + name->len +1;
340         cnt_rec->doc.len = doc_len;
341         cnt_rec->h.id = cnts_no++;
342         cnt_rec->flags = flags;
343         cnt_rec->cbk_param = param;
344         cnt_rec->cbk = cbk;
345         cnt_rec->grp_next = 0;
346         memcpy(cnt_rec->group.s, group->s, group->len + 1);
347         memcpy(cnt_rec->name.s, name->s, name->len + 1);
348         if (doc)
349                 memcpy(cnt_rec->doc.s, doc, doc_len + 1);
350         else
351                 cnt_rec->doc.s[0] = 0;
352         e->key = cnt_rec->name;
353         e->flags = 0;
354         /* check to see if it fits in the prefork tmp. vals array.
355            This array contains only one "row", is allocated in pkg and
356            is used only until counters_prefork_init() (after that the
357            array is replaced with a shm version with all the needed rows).
358          */
359         if (cnt_rec->h.id >= _cnts_row_len || _cnts_vals == 0) {
360                 /* array to small or not yet allocated => reallocate/allocate it
361                    (min size PREINIT_CNTS_VALS_SIZE, max MAX_COUNTER_ID)
362                  */
363                 n = (cnt_rec->h.id < PREINIT_CNTS_VALS_SIZE) ?
364                                 PREINIT_CNTS_VALS_SIZE :
365                                 ((2 * (cnt_rec->h.id + (cnt_rec->h.id == 0)) < MAX_COUNTER_ID)?
366                                         (2 * (cnt_rec->h.id + (cnt_rec->h.id == 0))) :
367                                         MAX_COUNTER_ID + 1);
368                 v = pkg_realloc(_cnts_vals, n * sizeof(*_cnts_vals));
369                 if (v == 0)
370                         /* realloc/malloc error */
371                         goto error;
372                 _cnts_vals = v;
373                 /* zero newly allocated memory */
374                 memset(&_cnts_vals[_cnts_row_len], 0,
375                                 (n - _cnts_row_len) * sizeof(*_cnts_vals));
376                 _cnts_row_len = n; /* record new length */
377         }
378         /* add a pointer to it in the records array */
379         if (cnt_id2record_size <= cnt_rec->h.id) {
380                 /* must increase the array */
381                 p = pkg_realloc(cnt_id2record,
382                                                 2 * cnt_id2record_size * sizeof(*cnt_id2record));
383                 if (p == 0)
384                         goto error;
385                 cnt_id2record = p;
386                 cnt_id2record_size *= 2;
387                 memset(&cnt_id2record[cnt_rec->h.id], 0,
388                                 (cnt_id2record_size - cnt_rec->h.id) * sizeof(*cnt_id2record));
389         }
390         cnt_id2record[cnt_rec->h.id] = cnt_rec;
391         /* add into the hash */
392         str_hash_add(&cnts_hash_table, e);
393         /* insert it sorted in the per group list */
394         for (p = &grp_rec->first; *p; p = &((*p)->grp_next))
395                 if (strcmp(cnt_rec->name.s, (*p)->name.s) < 0)
396                         break;
397         cnt_rec->grp_next = *p;
398         *p = cnt_rec;
399         return cnt_rec;
400 error:
401         if (e)
402                 pkg_free(e);
403         return 0;
404 }
405
406
407
408 /** lookup a (group, name) pair into the cnts hash (internal version).
409  * @param group - counter group name. If "" the first matching counter with
410  *                the given name will be returned (k compat).
411  * @param name
412  * @return pointer to counter_record on success, 0 on failure (not found).
413  */
414 static struct counter_record* cnt_hash_lookup(str* group, str* name)
415 {
416         struct str_hash_entry* e;
417         struct str_hash_entry* first;
418         struct counter_record* cnt_rec;
419         e = str_hash_get(&cnts_hash_table, name->s, name->len);
420         /* fast path */
421         if (likely(e)) {
422                 cnt_rec = (struct counter_record*)&e->u.data[0];
423                 if (likely( group->len == 0 ||
424                                 (cnt_rec->group.len == group->len &&
425                                 memcmp(cnt_rec->group.s, group->s, group->len) == 0)))
426                 return cnt_rec;
427         } else
428                 return 0;
429         /* search between records with same name, but different groups */
430         first = e;
431         do {
432                 cnt_rec = (struct counter_record*)&e->u.data[0];
433                 if (cnt_rec->group.len == group->len &&
434                         cnt_rec->name.len  == name->len &&
435                         memcmp(cnt_rec->group.s, group->s, group->len) == 0 &&
436                         memcmp(cnt_rec->name.s, name->s, name->len) == 0)
437                         /* found */
438                         return cnt_rec;
439                 e = e->next;
440         } while(e != first);
441         return 0;
442 }
443
444
445
446 /** lookup a counter and if not found create a new counter record.
447  * @return pointer to counter_record on succes, 0 on failure ( not found and
448  *  failed to create new group record).
449  */
450 static struct counter_record* cnt_hash_get_create(
451                                                                 str* group, str* name,
452                                                                 int flags,
453                                                                 counter_cbk_f cbk,
454                                                                 void* param, const char* doc)
455 {
456         struct counter_record* ret;
457
458         ret = cnt_hash_lookup(group, name);
459         if (ret)
460                 return ret;
461         return cnt_hash_add(group, name, flags, cbk, param, doc);
462 }
463
464
465
466 /** register a new counter.
467  * Can be called only before forking (e.g. from mod_init() or
468  * init_child(PROC_INIT)).
469  * @param handle - result parameter, it will be filled with the counter
470  *                  handle on success (can be null if not needed).
471  * @param group - group name
472  * @param name  - counter name (group.name must be unique).
473  * @param flags  - counter flags: one of CNT_F_*.
474  * @param cbk   - read callback function (if set it will be called each time
475  *                  someone will call counter_get()).
476  * @param cbk_param - callback param.
477  * @param doc       - description/documentation string.
478  * @param reg_flags - register flags: 1 - don't fail if counter already
479  *                    registered (act like counter_lookup(handle, group, name).
480  * @return 0 on succes, < 0 on error (-1 not init or malloc error, -2 already
481  *         registered (and register_flags & 1 == 0).
482  */
483 int counter_register(   counter_handle_t* handle, const char* group,
484                                                 const char* name, int flags,
485                                                 counter_cbk_f cbk, void* cbk_param,
486                                                 const char* doc,
487                                                 int reg_flags)
488 {
489         str grp;
490         str n;
491         struct counter_record* cnt_rec;
492
493         if (unlikely(cnts_max_rows)) {
494                 /* too late */
495                 BUG("late attempt to register counter: %s.%s\n", group, name);
496                 goto error;
497         }
498         n.s = (char*)name;
499         n.len = strlen(name);
500         if (unlikely(group == 0 || *group == 0)) {
501                 BUG("attempt to register counter %s without a group\n", name);
502                 goto error;
503         }
504         grp.s = (char*)group;
505         grp.len = strlen(group);
506         cnt_rec = cnt_hash_lookup(&grp, &n);
507         if (cnt_rec) {
508                 if (reg_flags & 1)
509                         goto found;
510                 else {
511                         if (handle) handle->id = 0;
512                         return -2;
513                 }
514         } else
515                 cnt_rec = cnt_hash_get_create(&grp, &n, flags, cbk, cbk_param, doc);
516         if (unlikely(cnt_rec == 0))
517                 goto error;
518 found:
519         if (handle) *handle = cnt_rec->h;
520         return 0;
521 error:
522         if (handle) handle->id = 0;
523         return -1;
524 }
525
526
527
528 /** fill in the handle of an existing counter (str parameters).
529   * @param handle - filled with the corresp. handle on success.
530   * @param group - counter group name. If "" the first matching
531   *                counter with the given name will be returned
532   *                (k compat).
533   * @param name - counter name.
534  * @return 0 on success, < 0 on error
535  */
536 int counter_lookup_str(counter_handle_t* handle, str* group, str* name)
537 {
538         struct counter_record* cnt_rec;
539
540         cnt_rec = cnt_hash_lookup(group, name);
541         if (likely(cnt_rec)) {
542                 *handle = cnt_rec->h;
543                 return 0;
544         }
545         handle->id = 0;
546         return -1;
547 }
548
549
550
551 /** fill in the handle of an existing counter (asciiz parameters).
552   * @param handle - filled with the corresp. handle on success.
553   * @param group - counter group name. If 0 or "" the first matching
554   *                counter with the given name will be returned
555   *                (k compat).
556   * @param name - counter name.
557  * @return 0 on success, < 0 on error
558  */
559 int counter_lookup(counter_handle_t* handle,
560                                         const char* group, const char* name)
561 {
562         str grp;
563         str n;
564
565         n.s = (char*)name;
566         n.len = strlen(name);
567         grp.s = (char*)group;
568         grp.len = group?strlen(group):0;
569         return counter_lookup_str(handle, &grp, &n);
570 }
571
572
573
574 /** register all the counters declared in a null-terminated array.
575   * @param group - counters group.
576   * @param defs  - null terminated array containing counters definitions.
577   * @return 0 on success, < 0 on error ( - (counter_number+1))
578   */
579 int counter_register_array(const char* group, counter_def_t* defs)
580 {
581         int r;
582         
583         for (r=0; defs[r].name; r++)
584                 if (counter_register(   defs[r].handle,
585                                                                 group, defs[r].name, defs[r].flags,
586                                                                 defs[r].get_cbk, defs[r].get_cbk_param,
587                                                                 defs[r].descr, 0) <0)
588                         return -(r+1); /* return - (idx of bad counter + 1) */
589         return 0;
590 }
591
592
593
594 /** get the value of the counter, bypassing callbacks.
595  * @param handle - counter handle obtained using counter_lookup() or
596  *                 counter_register().
597  * @return counter value.
598  */
599 counter_val_t counter_get_raw_val(counter_handle_t handle)
600 {
601         int r;
602         counter_val_t ret;
603
604         if (unlikely(_cnts_vals == 0)) {
605                 /* not init yet */
606                 BUG("counters not fully initialized yet\n");
607                 return 0;
608         }
609         if (unlikely(handle.id >= cnts_no || (short)handle.id < 0)) {
610                 BUG("invalid counter id %d (max %d)\n", handle.id, cnts_no - 1);
611                 return 0;
612         }
613         ret = 0;
614         for (r = 0; r < cnts_max_rows; r++)
615                 ret += counter_pprocess_val(r, handle);
616         return ret;
617 }
618
619
620
621 /** get the value of the counter, using the callbacks (if defined).
622  * @param handle - counter handle obtained using counter_lookup() or
623  *                 counter_register().
624  * @return counter value. */
625 counter_val_t counter_get_val(counter_handle_t handle)
626 {
627         struct counter_record* cnt_rec;
628
629         if (unlikely(_cnts_vals == 0 || cnt_id2record == 0)) {
630                 /* not init yet */
631                 BUG("counters not fully initialized yet\n");
632                 return 0;
633         }
634         cnt_rec = cnt_id2record[handle.id];
635         if (unlikely(cnt_rec->cbk))
636                 return cnt_rec->cbk(handle, cnt_rec->cbk_param);
637         return counter_get_raw_val(handle);
638 }
639
640
641
642 /** reset the  counter.
643  * Reset a counter, unless it has the CNT_F_NO_RESET flag set.
644  * @param handle - counter handle obtained using counter_lookup() or
645  *                 counter_register().
646  * Note: it's racy.
647  */
648 void counter_reset(counter_handle_t handle)
649 {
650         int r;
651
652         if (unlikely(_cnts_vals == 0 || cnt_id2record == 0)) {
653                 /* not init yet */
654                 BUG("counters not fully initialized yet\n");
655                 return;
656         }
657         if (unlikely(handle.id >= cnts_no)) {
658                 BUG("invalid counter id %d (max %d)\n", handle.id, cnts_no - 1);
659                 return;
660         }
661         if (unlikely(cnt_id2record[handle.id]->flags & CNT_F_NO_RESET))
662                 return;
663         for (r=0; r < cnts_max_rows; r++)
664                 counter_pprocess_val(r, handle) = 0;
665         return;
666 }
667
668
669
670 /** return the name for counter handle.
671  * @param handle - counter handle obtained using counter_lookup() or
672  *                 counter_register().
673  * @return asciiz pointer on success, 0 on error.
674  */
675 char* counter_get_name(counter_handle_t handle)
676 {
677         if (unlikely(_cnts_vals == 0 || cnt_id2record == 0)) {
678                 /* not init yet */
679                 BUG("counters not fully initialized yet\n");
680                 goto error;
681         }
682         if (unlikely(handle.id >= cnts_no)) {
683                 BUG("invalid counter id %d (max %d)\n", handle.id, cnts_no - 1);
684                 goto error;
685         }
686         return cnt_id2record[handle.id]->name.s;
687 error:
688         return 0;
689 }
690
691
692
693 /** return the group name for counter handle.
694  * @param handle - counter handle obtained using counter_lookup() or
695  *                 counter_register().
696  * @return asciiz pointer on success, 0 on error.
697  */
698 char* counter_get_group(counter_handle_t handle)
699 {
700         if (unlikely(_cnts_vals == 0 || cnt_id2record == 0)) {
701                 /* not init yet */
702                 BUG("counters not fully initialized yet\n");
703                 goto error;
704         }
705         if (unlikely(handle.id >= cnts_no)) {
706                 BUG("invalid counter id %d (max %d)\n", handle.id, cnts_no - 1);
707                 goto error;
708         }
709         return cnt_id2record[handle.id]->group.s;
710 error:
711         return 0;
712 }
713
714
715
716 /** return the description (doc) string for a given counter.
717  * @param handle - counter handle obtained using counter_lookup() or
718  *                 counter_register().
719  * @return asciiz pointer on success, 0 on error.
720  */
721 char* counter_get_doc(counter_handle_t handle)
722 {
723         if (unlikely(_cnts_vals == 0 || cnt_id2record == 0)) {
724                 /* not init yet */
725                 BUG("counters not fully initialized yet\n");
726                 goto error;
727         }
728         if (unlikely(handle.id >= cnts_no)) {
729                 BUG("invalid counter id %d (max %d)\n", handle.id, cnts_no - 1);
730                 goto error;
731         }
732         return cnt_id2record[handle.id]->doc.s;
733 error:
734         return 0;
735 }
736
737
738
739 /** iterate on all the counter group names.
740  * @param cbk - pointer to a callback function that will be called for each
741  *              group name.
742  * @param p   - parameter that will be passed to the callback function
743  *              (along the group name).
744  */
745 void counter_iterate_grp_names(void (*cbk)(void* p, str* grp_name), void* p)
746 {
747         int r;
748
749         for (r=0; r < grp_sorted_crt_size; r++)
750                 cbk(p, &grp_sorted[r]->group);
751 }
752
753
754
755 /** iterate on all the variable names in a specified group.
756  * @param group - group name.
757  * @param cbk - pointer to a callback function that will be called for each
758  *              variable name.
759  * @param p   - parameter that will be passed to the callback function
760  *              (along the variable name).
761  */
762 void counter_iterate_grp_var_names(     const char* group,
763                                                                         void (*cbk)(void* p, str* var_name),
764                                                                         void* p)
765 {
766         struct counter_record* r;
767         struct grp_record* g;
768         str grp;
769         
770         grp.s = (char*)group;
771         grp.len = strlen(group);
772         g = grp_hash_lookup(&grp);
773         if (g)
774                 for (r = g->first; r; r = r->grp_next)
775                         cbk(p, &r->name);
776 }
777
778
779
780 /** iterate on all the variable names and handles in a specified group.
781  * @param group - group name.
782  * @param cbk - pointer to a callback function that will be called for each
783  *              [variable name, variable handle] pair.
784  * @param p   - parameter that will be passed to the callback function
785  *              (along the group name, variable name and variable handle).
786  */
787 void counter_iterate_grp_vars(const char* group,
788                                                           void (*cbk)(void* p, str* g, str* n,
789                                                                                         counter_handle_t h),
790                                                           void *p)
791 {
792         struct counter_record* r;
793         struct grp_record* g;
794         str grp;
795         
796         grp.s = (char*)group;
797         grp.len = strlen(group);
798         g = grp_hash_lookup(&grp);
799         if (g)
800                 for (r = g->first; r; r = r->grp_next)
801                         cbk(p, &r->group, &r->name, r->h);
802 }
803
804 /* vi: set ts=4 sw=4 tw=79:ai:cindent: */