mirror of https://github.com/sipwise/kamailio.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
499 lines
11 KiB
499 lines
11 KiB
/*
|
|
*
|
|
* $Id$
|
|
*
|
|
*
|
|
* Copyright (C) 2001-2003 FhG Fokus
|
|
*
|
|
* This file is part of ser, a free SIP server.
|
|
*
|
|
* ser 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
|
|
*
|
|
* For a license to use the ser software under conditions
|
|
* other than those described here, or to purchase support for this
|
|
* software, please contact iptel.org by e-mail at the following addresses:
|
|
* info@iptel.org
|
|
*
|
|
* ser 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "../../sr_module.h"
|
|
#include "../../mem/shm_mem.h"
|
|
#include "../../globals.h"
|
|
#include "../../config.h"
|
|
#include "../../pt.h"
|
|
#include "sl_stats.h"
|
|
#include "../../lib/kcore/kstats_wrapper.h"
|
|
#include <strings.h>
|
|
#include <stdio.h>
|
|
|
|
|
|
static struct sl_stats** sl_stats;
|
|
|
|
|
|
static void add_sl_stats( struct sl_stats *t, struct sl_stats *i)
|
|
{
|
|
enum reply_type rt;
|
|
|
|
for (rt=0; rt<RT_END; rt++) {
|
|
t->err[rt]+=i->err[rt];
|
|
t->all_replies+=i->err[rt];
|
|
}
|
|
t->failures+=i->failures;
|
|
t->filtered_acks+=i->filtered_acks;
|
|
}
|
|
|
|
|
|
static const char* rpc_stats_doc[2] = {
|
|
"Print reply statistics.",
|
|
0
|
|
};
|
|
|
|
static void rpc_stats(rpc_t* rpc, void* c)
|
|
{
|
|
void* st;
|
|
struct sl_stats total;
|
|
int p;
|
|
int procs_no;
|
|
|
|
memset(&total, 0, sizeof(struct sl_stats));
|
|
if (dont_fork) {
|
|
add_sl_stats(&total, &(*sl_stats)[0]);
|
|
} else{
|
|
procs_no=get_max_procs();
|
|
for (p=0; p < procs_no; p++)
|
|
add_sl_stats(&total, &(*sl_stats)[p]);
|
|
}
|
|
|
|
if (rpc->add(c, "{", &st) < 0) return;
|
|
|
|
rpc->struct_add(st, "ddd",
|
|
"200", total.err[RT_200],
|
|
"202", total.err[RT_202],
|
|
"2xx", total.err[RT_2xx]);
|
|
|
|
rpc->struct_add(st, "ddd",
|
|
"300", total.err[RT_300],
|
|
"301", total.err[RT_301],
|
|
"302", total.err[RT_302],
|
|
"3xx", total.err[RT_3xx]);
|
|
|
|
rpc->struct_add(st, "dddddddd",
|
|
"400", total.err[RT_400],
|
|
"401", total.err[RT_401],
|
|
"403", total.err[RT_403],
|
|
"404", total.err[RT_404],
|
|
"407", total.err[RT_407],
|
|
"408", total.err[RT_408],
|
|
"483", total.err[RT_483],
|
|
"4xx", total.err[RT_4xx]);
|
|
|
|
rpc->struct_add(st, "dd",
|
|
"500", total.err[RT_500],
|
|
"5xx", total.err[RT_5xx]);
|
|
|
|
rpc->struct_add(st, "d", "6xx", total.err[RT_6xx]);
|
|
rpc->struct_add(st, "d", "xxx", total.err[RT_xxx]);
|
|
}
|
|
|
|
|
|
void sl_stats_destroy(void)
|
|
{
|
|
if (!sl_stats) return;
|
|
if (*sl_stats) shm_free(*sl_stats);
|
|
shm_free(sl_stats);
|
|
}
|
|
|
|
int init_sl_stats(void)
|
|
{
|
|
sl_stats = (struct sl_stats**)shm_malloc(sizeof(struct sl_stats*));
|
|
if (!sl_stats) {
|
|
ERR("Unable to allocated shared memory for sl statistics\n");
|
|
return -1;
|
|
}
|
|
*sl_stats = 0;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int init_sl_stats_child(void)
|
|
{
|
|
int len;
|
|
|
|
len = sizeof(struct sl_stats) * get_max_procs();
|
|
*sl_stats = shm_malloc(len);
|
|
if (*sl_stats == 0) {
|
|
ERR("No shmem\n");
|
|
shm_free(sl_stats);
|
|
return -1;
|
|
}
|
|
memset(*sl_stats, 0, len);
|
|
return 0;
|
|
}
|
|
|
|
|
|
void update_sl_failures( void )
|
|
{
|
|
(*sl_stats)[process_no].failures++;
|
|
}
|
|
|
|
void update_sl_err_replies( void )
|
|
{
|
|
(*sl_stats)[process_no].err_replies++;
|
|
}
|
|
|
|
void update_sl_filtered_acks( void )
|
|
{
|
|
(*sl_stats)[process_no].filtered_acks++;
|
|
}
|
|
|
|
void update_sl_stats( int code )
|
|
{
|
|
|
|
struct sl_stats *my_stats;
|
|
|
|
my_stats=&(*sl_stats)[process_no];
|
|
|
|
if (code >=700 || code <200 ) {
|
|
my_stats->err[RT_xxx]++;
|
|
} else if (code>=600) {
|
|
my_stats->err[RT_6xx]++;
|
|
} else if (code>=500) {
|
|
switch(code) {
|
|
case 500: my_stats->err[RT_500]++;
|
|
break;
|
|
default: my_stats->err[RT_5xx]++;
|
|
break;
|
|
}
|
|
} else if (code>=400) {
|
|
switch(code) {
|
|
case 400: my_stats->err[RT_400]++;
|
|
break;
|
|
case 401: my_stats->err[RT_401]++;
|
|
break;
|
|
case 403: my_stats->err[RT_403]++;
|
|
break;
|
|
case 404: my_stats->err[RT_404]++;
|
|
break;
|
|
case 407: my_stats->err[RT_407]++;
|
|
break;
|
|
case 408: my_stats->err[RT_408]++;
|
|
break;
|
|
case 483: my_stats->err[RT_483]++;
|
|
break;
|
|
default: my_stats->err[RT_4xx]++;
|
|
break;
|
|
}
|
|
} else if (code>=300) {
|
|
switch(code) {
|
|
case 300: my_stats->err[RT_300]++;
|
|
break;
|
|
case 301: my_stats->err[RT_301]++;
|
|
break;
|
|
case 302: my_stats->err[RT_302]++;
|
|
break;
|
|
default: my_stats->err[RT_3xx]++;
|
|
break;
|
|
}
|
|
} else { /* 2xx */
|
|
switch(code) {
|
|
case 200: my_stats->err[RT_200]++;
|
|
break;
|
|
case 202: my_stats->err[RT_202]++;
|
|
break;
|
|
default: my_stats->err[RT_2xx]++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
rpc_export_t sl_rpc[] = {
|
|
{"sl.stats", rpc_stats, rpc_stats_doc, 0},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
#ifdef STATISTICS
|
|
|
|
/* k statistics */
|
|
|
|
unsigned long sl_stats_RT_1xx(void);
|
|
unsigned long sl_stats_RT_200(void);
|
|
unsigned long sl_stats_RT_202(void);
|
|
unsigned long sl_stats_RT_2xx(void);
|
|
unsigned long sl_stats_RT_300(void);
|
|
unsigned long sl_stats_RT_301(void);
|
|
unsigned long sl_stats_RT_302(void);
|
|
unsigned long sl_stats_RT_3xx(void);
|
|
unsigned long sl_stats_RT_400(void);
|
|
unsigned long sl_stats_RT_401(void);
|
|
unsigned long sl_stats_RT_403(void);
|
|
unsigned long sl_stats_RT_404(void);
|
|
unsigned long sl_stats_RT_407(void);
|
|
unsigned long sl_stats_RT_408(void);
|
|
unsigned long sl_stats_RT_483(void);
|
|
unsigned long sl_stats_RT_4xx(void);
|
|
unsigned long sl_stats_RT_500(void);
|
|
unsigned long sl_stats_RT_5xx(void);
|
|
unsigned long sl_stats_RT_6xx(void);
|
|
unsigned long sl_stats_RT_xxx(void);
|
|
|
|
unsigned long sl_stats_sent_rpls(void);
|
|
unsigned long sl_stats_sent_err_rpls(void);
|
|
unsigned long sl_stats_failures(void);
|
|
unsigned long sl_stats_rcv_acks(void);
|
|
|
|
static stat_export_t mod_stats[] = {
|
|
{"1xx_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_1xx },
|
|
{"200_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_200 },
|
|
{"202_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_202 },
|
|
{"2xx_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_2xx },
|
|
{"300_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_300 },
|
|
{"301_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_301 },
|
|
{"302_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_302 },
|
|
{"3xx_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_3xx },
|
|
{"400_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_400 },
|
|
{"401_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_401 },
|
|
{"403_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_403 },
|
|
{"404_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_404 },
|
|
{"407_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_407 },
|
|
{"408_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_408 },
|
|
{"483_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_483 },
|
|
{"4xx_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_4xx },
|
|
{"500_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_500 },
|
|
{"5xx_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_5xx },
|
|
{"6xx_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_6xx },
|
|
{"xxx_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_RT_xxx },
|
|
|
|
{"sent_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_sent_rpls },
|
|
{"sent_err_replies" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_sent_err_rpls },
|
|
{"failures" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_failures },
|
|
{"received_ACKs" , STAT_IS_FUNC,
|
|
(stat_var**)sl_stats_rcv_acks },
|
|
{0,0,0}
|
|
};
|
|
|
|
|
|
static struct sl_stats _sl_stats_total;
|
|
static ticks_t _sl_stats_tm = 0;
|
|
|
|
static void sl_stats_update(void)
|
|
{
|
|
int p;
|
|
int procs_no;
|
|
ticks_t t;
|
|
|
|
t = get_ticks();
|
|
if(t==_sl_stats_tm)
|
|
return;
|
|
_sl_stats_tm = t;
|
|
|
|
memset(&_sl_stats_total, 0, sizeof(struct sl_stats));
|
|
if (dont_fork) {
|
|
add_sl_stats(&_sl_stats_total, &(*sl_stats)[0]);
|
|
} else{
|
|
procs_no=get_max_procs();
|
|
for (p=0; p < procs_no; p++)
|
|
add_sl_stats(&_sl_stats_total, &(*sl_stats)[p]);
|
|
}
|
|
}
|
|
|
|
unsigned long sl_stats_tx_1xx_rpls(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_1xx];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_1xx(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_1xx];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_200(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_200];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_202(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_202];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_2xx(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_2xx];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_300(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_300];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_301(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_301];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_302(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_302];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_3xx(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_3xx];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_400(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_400];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_401(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_401];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_403(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_403];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_404(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_404];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_407(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_407];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_408(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_408];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_483(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_483];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_4xx(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_4xx];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_500(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_500];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_5xx(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_5xx];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_6xx(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_6xx];
|
|
}
|
|
|
|
unsigned long sl_stats_RT_xxx(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err[RT_xxx];
|
|
}
|
|
|
|
|
|
unsigned long sl_stats_sent_rpls(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.all_replies;
|
|
}
|
|
|
|
unsigned long sl_stats_sent_err_rpls(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.err_replies;
|
|
}
|
|
|
|
unsigned long sl_stats_failures(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.failures;
|
|
}
|
|
|
|
unsigned long sl_stats_rcv_acks(void)
|
|
{
|
|
sl_stats_update();
|
|
return _sl_stats_total.filtered_acks;
|
|
}
|
|
|
|
#endif
|
|
|
|
int sl_register_kstats(void)
|
|
{
|
|
#ifdef STATISTICS
|
|
/* register statistics */
|
|
if (register_module_stats("sl", mod_stats)!=0 ) {
|
|
LM_ERR("failed to register statistics\n");
|
|
return -1;
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|