/*!
* \brief Insert a new record into transactions table
* \param ruri request uri
* \return 0 on success, -1 on failure
*/
int insert_ts_urecord(str* ruri, ts_urecord_t** _r)
{
ts_entry_t* entry;
int sl;
if (new_ts_urecord(ruri, _r) < 0) {
LM_ERR("creating urecord failed\n");
return -1;
}
sl = ((*_r)->rurihash)&(t_table->size-1);
entry = &t_table->entries[sl];
if (entry->n == 0) {
entry->first = entry->last = *_r;
} else {
(*_r)->prev = entry->last;
entry->last->next = *_r;
entry->last = *_r;
}
entry->n++;
(*_r)->entry = entry;
update_stat(stored_ruris, 1);
update_stat(total_ruris, 1);
LM_DBG("urecord entry %p",entry);
return 0;
}
static int ws_send_reply(sip_msg_t *msg, int code, str *reason, str *hdrs)
{
if (hdrs && hdrs->len > 0)
{
if (add_lump_rpl(msg, hdrs->s, hdrs->len, LUMP_RPL_HDR) == 0)
{
LM_ERR("inserting extra-headers lump\n");
update_stat(ws_failed_handshakes, 1);
return -1;
}
}
if (ws_slb.freply(msg, code, reason) < 0)
{
LM_ERR("sending reply\n");
update_stat(ws_failed_handshakes, 1);
return -1;
}
update_stat(
code == 101 ? ws_successful_handshakes : ws_failed_handshakes,
1);
return 0;
}
static int w_update_stat(struct sip_msg *msg, char *stat_p, char *n)
{
struct stat_or_pv *sopv = (struct stat_or_pv *)stat_p;
pv_value_t pv_val;
stat_var *stat;
if (sopv->stat) {
update_stat( sopv->stat, (long)n);
} else {
if (pv_get_spec_value(msg, sopv->pv, &pv_val)!=0 ||
(pv_val.flags & PV_VAL_STR)==0 ) {
LM_ERR("failed to get pv string value\n");
return -1;
}
stat = get_stat( &(pv_val.rs) );
if ( stat == 0 ) {
LM_ERR("variable <%.*s> not defined\n",
pv_val.rs.len, pv_val.rs.s);
return -1;
}
update_stat( stat, (long)n);
}
return 1;
}
void oneway_nb_test(int iters, int nbytes, int alignment)
{GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t st;
gasnet_handle_t *handles;
int pad = (alignment % PAGESZ);
/* initialize statistics */
init_stat(&st, nbytes, alignment);
handles = (gasnet_handle_t*) test_malloc(sizeof(gasnet_handle_t) * iters);
memset(locbuf+pad, 1, nbytes);
BARRIER();
if (iamsender) {
/* measure the throughput of sending a message */
begin = TIME();
for (i = 0; i < iters; i++) {
handles[i] = gasnet_put_nb_bulk(peerproc, rembuf, locbuf+pad, nbytes);
}
gasnet_wait_syncnb_all(handles, iters);
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "put_nb_bulk throughput", PRINT_THROUGHPUT);
}
/* initialize statistics */
init_stat(&st, nbytes, alignment);
if (iamsender) {
/* measure the throughput of receiving a message */
begin = TIME();
for (i = 0; i < iters; i++) {
handles[i] = gasnet_get_nb_bulk(locbuf, peerproc, rembuf+pad, nbytes);
}
gasnet_wait_syncnb_all(handles, iters);
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "get_nb_bulk throughput", PRINT_THROUGHPUT);
}
test_free(handles);
}
static int km_cb_req_stats(struct sip_msg *msg,
unsigned int flags, void *param)
{
update_stat(rcv_reqs, 1);
if(!IS_SIP(msg))
return 1;
if(msg->first_line.u.request.method_value==METHOD_OTHER)
update_stat(unsupported_methods, 1);
return 1;
}
static int child_init(int rank)
{
if (rank==1) {
/* init stats */
update_stat( max_expires_stat, max_expires );
update_stat( max_contacts_stat, max_contacts );
update_stat( default_expire_stat, default_expires );
}
return 0;
}
static int child_init(int rank) {
int pid;
int k=0;
LM_DBG("Initialization of module in child [%d] \n", rank);
if (rank == PROC_MAIN) {
/* fork notification workers */
for(k=0;k<notification_processes;k++){
pid = fork_process(1001+k,"notification_worker",1);
if (pid==-1){
LM_CRIT("init_notification_worker(): Error on fork() for worker!\n");
return 0;
}
if (pid==0) {
if (cfg_child_init()) return 0;
notification_event_process();
LM_CRIT("init_notification_worker():: worker_process finished without exit!\n");
exit(-1);
}
}
}
if (rank == PROC_MAIN || rank == PROC_TCP_MAIN)
return 0;
if (rank == 1) {
/* init stats */
//TODO if parameters are modified via cfg framework do i change them?
update_stat(max_expires_stat, default_registrar_cfg.max_expires);
update_stat(max_contacts_stat, default_registrar_cfg.max_contacts);
update_stat(default_expire_stat, default_registrar_cfg.default_expires);
}
/* don't do anything for main process and TCP manager process */
/* don't do anything for main process and TCP manager process */
if (rank == PROC_MAIN || rank == PROC_TCP_MAIN)
return 0;
/* Init the user data parser */
if (!parser_init(scscf_user_data_dtd, scscf_user_data_xsd))
return -1;
lock_get(process_lock);
if ((*callback_singleton) == 0) {
*callback_singleton = 1;
cdpb.AAAAddRequestHandler(callback_cdp_request, NULL);
}
lock_release(process_lock);
return 0;
}
void handle_agent_reject(struct cc_call* call, int from_customer, int pickup_time)
{
str un, fid, aid;
str out;
//update_stat( stg_aban_incalls, 1); /*abandon from agent */
update_stat( call->agent->st_aban_incalls, 1);
call->no_rejections++;
/* put call back into queue */
call->state = CC_CALL_QUEUED;
call->setup_time = -1;
lock_get( data->lock );
/* prepare CDR */
prepare_cdr( call, &un, &fid , &aid);
call->agent->state = CC_AGENT_WRAPUP;
call->agent->last_call_end = get_ticks();
/* update last call_end for agent */
cc_db_update_agent_end_call(call->agent);
call->agent->ref_cnt--;
call->agent = NULL;
cc_queue_push_call( data, call, 1/*top*/);
if(from_customer || call->prev_state != CC_CALL_QUEUED) {
out.len = OUT_BUF_LEN(call->flow->recordings[AUDIO_QUEUE].len);
out.s = out_buf;
memcpy( out.s, call->flow->recordings[AUDIO_QUEUE].s, out.len);
}
lock_release( data->lock );
if(from_customer || call->prev_state != CC_CALL_QUEUED) {
/* send call to queue */
if (set_call_leg( NULL, call, &out)< 0 ) {
LM_ERR("failed to set new destination for call\n");
}
LM_DBG("onhold++: agent rejected [%p]\n", call);
if(from_customer)
{
update_stat( stg_onhold_calls, 1);
update_stat( call->flow->st_onhold_calls, 1);
}
}
/* write CDR */
cc_write_cdr( &un, &fid, &aid, -2, call->recv_time,
get_ticks() - call->recv_time, 0 , pickup_time, call->no_rejections-1,
call->fst_flags, call->id);
cc_db_update_call(call);
}
static inline void _wsconn_rm(ws_connection_t *wsc)
{
wsconn_listrm(wsconn_id_hash[wsc->id_hash], wsc, id_next, id_prev);
update_stat(ws_current_connections, -1);
if (wsc->sub_protocol == SUB_PROTOCOL_SIP)
update_stat(ws_sip_current_connections, -1);
else if (wsc->sub_protocol == SUB_PROTOCOL_MSRP)
update_stat(ws_msrp_current_connections, -1);
shm_free(wsc);
}
static int w_update_stat(struct sip_msg *msg, char *stat_p, char *n)
{
struct stat_param *sp = (struct stat_param *)stat_p;
pv_value_t pv_val;
stat_var *stat;
if (sp->type==STAT_PARAM_TYPE_STAT) {
/* we have the statistic */
update_stat( sp->u.stat, (long)n);
return 1;
}
if (sp->type==STAT_PARAM_TYPE_PVAR) {
/* take name from PVAR */
if (pv_get_spec_value(msg, sp->u.pvar, &pv_val)!=0 ||
(pv_val.flags & PV_VAL_STR)==0 ) {
LM_ERR("failed to get pv string value\n");
return -1;
}
} else if (sp->type==STAT_PARAM_TYPE_FMT) {
/* take name from FMT */
if (pv_printf_s( msg, sp->u.format, &(pv_val.rs) )!=0 ) {
LM_ERR("failed to get format string value\n");
return -1;
}
} else if (sp->type==STAT_PARAM_TYPE_NAME) {
/* take name from STRING */
pv_val.rs = *sp->u.name;
}
LM_DBG("needed statistic is <%.*s>\n", pv_val.rs.len, pv_val.rs.s);
/* name is in pv_val.rs -> look for it */
stat = get_stat( &(pv_val.rs) );
if ( stat==NULL ) {
/* stats not found -> create it */
LM_DBG("creating dynamic statistic <%.*s>\n",
pv_val.rs.len, pv_val.rs.s);
if (register_dynamic_stat( &(pv_val.rs), &stat )!=0) {
LM_ERR("failed to create dynamic statistic <%.*s>\n",
pv_val.rs.len, pv_val.rs.s);
return -1;
}
if (sp->type==STAT_PARAM_TYPE_NAME) {
sp->u.stat = stat;
sp->type=STAT_PARAM_TYPE_STAT;
}
}
/* statistic exists ! */
update_stat( stat, (long)n);
return 1;
}
struct hp_block *hp_shm_malloc_init(char *address, unsigned long size,
char *name)
{
struct hp_block *hpb;
hpb = hp_malloc_init(address, size, name);
if (!hpb) {
LM_ERR("failed to initialize shm block\n");
return NULL;
}
#ifdef HP_MALLOC_FAST_STATS
hpb->free_hash[PEEK_HASH_RR(hpb, hpb->first_frag->size)].total_no++;
#endif
hp_frag_attach(hpb, hpb->first_frag);
/* first fragment attach is the equivalent of a split */
if (stats_are_ready()) {
#if defined(STATISTICS) && !defined(HP_MALLOC_FAST_STATS)
update_stat(shm_rused, FRAG_OVERHEAD);
update_stat(shm_frags, 1);
#endif
#if defined(DBG_MALLOC) || defined(STATISTICS)
hpb->real_used += FRAG_OVERHEAD;
hpb->total_fragments++;
#endif
} else {
hpb->real_used += FRAG_OVERHEAD;
hpb->total_fragments++;
}
#ifdef HP_MALLOC_FAST_STATS
#ifdef DBG_MALLOC
hp_stats_lock = hp_shm_malloc_unsafe(hpb, sizeof *hp_stats_lock,
__FILE__, __FUNCTION__, __LINE__);
#else
hp_stats_lock = hp_shm_malloc_unsafe(hpb, sizeof *hp_stats_lock);
#endif
if (!hp_stats_lock) {
LM_ERR("failed to alloc hp statistics lock\n");
return NULL;
}
if (!lock_init(hp_stats_lock)) {
LM_CRIT("could not initialize hp statistics lock\n");
return NULL;
}
#endif
return hpb;
}
void oneway_nbi_test(int iters, int nbytes, int alignment)
{GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t st;
int pad = (alignment % PAGESZ);
/* initialize statistics */
init_stat(&st, nbytes, alignment);
memset(locbuf+pad, 1, nbytes);
BARRIER();
if (iamsender) {
/* measure the throughput of nonblocking implicit bulk put */
begin = TIME();
for (i = 0; i < iters; i++) {
gasnet_put_nbi_bulk(peerproc, rembuf, locbuf+pad, nbytes);
}
gasnet_wait_syncnbi_puts();
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "put_nbi_bulk throughput", PRINT_THROUGHPUT);
}
/* initialize statistics */
init_stat(&st, nbytes, alignment);
if (iamsender) {
/* measure the throughput of nonblocking implicit bulk get */
begin = TIME();
for (i = 0; i < iters; i++) {
gasnet_get_nbi_bulk(locbuf, peerproc, rembuf+pad, nbytes);
}
gasnet_wait_syncnbi_gets();
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "get_nbi_bulk throughput", PRINT_THROUGHPUT);
}
}
static int child_init(int rank)
{
if(sruid_init(&_reg_sruid, '-', "uloc", SRUID_INC)<0)
return -1;
if (rank==1) {
/* init stats */
//TODO if parameters are modified via cfg framework do i change them?
update_stat( max_expires_stat, default_registrar_cfg.max_expires );
update_stat( max_contacts_stat, default_registrar_cfg.max_contacts );
update_stat( default_expire_stat, default_registrar_cfg.default_expires );
}
return 0;
}
/* Take care of the statistics associated with numerical codes and replies */
static inline void update_sl_reply_stat(int code)
{
stat_var *numerical_stat;
/* If stats aren't enabled, just skip over this. */
if (!sl_enable_stats)
return;
/* OpenSIPS already kept track of the total number of 1xx, 2xx, replies.
* There may be setups that still expect these variables to exist, so we
* don't touch them */
if (code < 200 ) {
update_stat( tx_1xx_rpls , 1);
} else if (code<300) {
update_stat( tx_2xx_rpls , 1);
} else if (code<400) {
update_stat( tx_3xx_rpls , 1);
} else if (code<500) {
update_stat( tx_4xx_rpls , 1);
} else if (code<600) {
update_stat( tx_5xx_rpls , 1);
} else {
update_stat( tx_6xx_rpls , 1);
}
update_stat( sent_rpls , 1);
numerical_stat = get_stat_var_from_num_code(code, 1);
if (numerical_stat != NULL)
update_stat(numerical_stat, 1);
}
/*!
* \brief Write through timer, used for WRITE_THROUGH db_mode
*
* Write through timer, used for WRITE_THROUGH db_mode. Process all
* contacts from the record, delete all expired ones from the DB.
* \param _r processed record
* \note currently unused, this mode is also handled by the wb_timer
*/
static inline void wt_timer(urecord_t* _r)
{
ucontact_t* ptr, *t;
ptr = _r->contacts;
while(ptr) {
if (!VALID_CONTACT(ptr, act_time)) {
/* run callbacks for EXPIRE event */
if (exists_ulcb_type(UL_CONTACT_EXPIRE)) {
run_ul_callbacks( UL_CONTACT_EXPIRE, ptr);
}
LM_DBG("Binding '%.*s','%.*s' has expired\n",
ptr->aor->len, ZSW(ptr->aor->s),
ptr->c.len, ZSW(ptr->c.s));
t = ptr;
ptr = ptr->next;
if (db_delete_ucontact(t) < 0) {
LM_ERR("deleting contact from database failed\n");
}
mem_delete_ucontact(_r, t);
update_stat( _r->slot->d->expires, 1);
} else {
ptr = ptr->next;
}
}
}
void init_stats() {
char startup_time[12];
sprintf(startup_time, "%ld", time(NULL));
if (serialize_file && !clear_stats) {
syslog(LOG_DEBUG, "Deserializing stats from file.");
statsd_deserialize(serialize_file);
}
remove_stats_lock();
update_stat( "graphite", "last_flush", startup_time );
update_stat( "messages", "last_msg_seen", startup_time );
update_stat( "messages", "bad_lines_seen", "0" );
}
void bulk_test_nb(int iters) {GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t stput;
gasnet_handle_t *handles;
int payload;
handles = (gasnet_handle_t *) test_malloc(sizeof(gasnet_handle_t) * iters);
for (payload = min_payload; payload <= max_payload && payload > 0; payload *= 2) {
init_stat(&stput, payload);
BARRIER();
if (iamsender) {
/* measure the throughput of sending a message */
begin = TIME();
for (i = 0; i < iters; i++) {
handles[i] = gasnet_memset_nb(peerproc, tgtmem, 0x5a, payload);
}
gasnet_wait_syncnb_all(handles, iters);
end = TIME();
update_stat(&stput, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &stput, "memset_nb throughput", PRINT_THROUGHPUT);
}
}
test_free(handles);
}
void bulk_test(int iters) {GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t stput;
int payload;
for (payload = min_payload; payload <= max_payload && payload > 0; payload *= 2) {
init_stat(&stput, payload);
BARRIER();
if (iamsender) {
/* measure the throughput of sending a message */
begin = TIME();
for (i = 0; i < iters; i++) {
gasnet_memset(peerproc, tgtmem, 0xaa, payload);
}
end = TIME();
update_stat(&stput, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &stput, "memset throughput", PRINT_THROUGHPUT);
}
}
}
void cc_queue_rmv_call( struct cc_data *data, struct cc_call *call)
{
LM_DBG(" QUEUE - removing call %p \n",call);
if ( !is_call_in_queue(data, call) ) {
LM_CRIT(" QUEUE - call not in queue l=%p, h=%p\n",
call->lower_in_queue, call->higher_in_queue);
abort();
}
if (call->lower_in_queue) {
call->lower_in_queue->higher_in_queue =
call->higher_in_queue;
} else {
data->queue.last = call->higher_in_queue;
}
if (call->higher_in_queue) {
call->higher_in_queue->lower_in_queue =
call->lower_in_queue;
} else {
data->queue.first = call->lower_in_queue;
}
call->lower_in_queue = call->higher_in_queue = NULL;
data->queue.calls_no--;
update_stat( call->flow->st_queued_calls, -1 );
}
/*!
* \brief Insert a new transaction structure into urecord
* \param _r urecord
* \param tindex transaction index in tm table
* \param tlabel transaction label in tm table
* \return 0 on success, -1 otherwise
*/
int insert_ts_transaction(struct cell* t, struct sip_msg* msg, struct ts_urecord* _r)
{
ts_transaction_t *ptr, *prev;
ts_transaction_t* ts;
unsigned int tindex;
unsigned int tlabel;
tindex = t->hash_index;
tlabel = t->label;
ptr = prev = 0;
ptr = _r->transactions;
while(ptr) {
if ((ptr->tindex == tindex) && (ptr->tlabel == tlabel)) {
LM_DBG("transaction already inserted\n");
return -1;
}
prev = ptr;
ptr = ptr->next;
}
if ( (ts=new_ts_transaction(tindex, tlabel) ) == 0) {
LM_ERR("failed to create new transaction\n");
return -1;
}
ts->urecord = _r;
/* add the new transaction at the end of the list */
if (prev) {
prev->next = ts;
ts->prev = prev;
} else {
_r->transactions = ts;
}
if (ts_set_tm_callbacks(t, msg, ts) < 0) {
LM_ERR("failed to set transaction %d:%d callbacks\n", tindex, tlabel);
}
update_stat(stored_transactions, 1);
update_stat(total_transactions, 1);
return 0;
}
/*!
* \brief Write-back timer, used for WRITE_BACK db_mode
*
* Write-back timer, used for WRITE_BACK db_mode. Process
* all contacts from the record, delete expired ones from the DB.
* Furthermore it updates changed contacts, and also insert new
* ones in the DB.
* \param _r processed record
*/
static inline void wb_timer(urecord_t* _r)
{
ucontact_t* ptr, *t;
cstate_t old_state;
int op;
ptr = _r->contacts;
while(ptr) {
if (!VALID_CONTACT(ptr, act_time)) {
/* run callbacks for EXPIRE event */
if (exists_ulcb_type(UL_CONTACT_EXPIRE)) {
run_ul_callbacks( UL_CONTACT_EXPIRE, ptr);
}
LM_DBG("Binding '%.*s','%.*s' has expired\n",
ptr->aor->len, ZSW(ptr->aor->s),
ptr->c.len, ZSW(ptr->c.s));
update_stat( _r->slot->d->expires, 1);
t = ptr;
ptr = ptr->next;
/* Should we remove the contact from the database ? */
if (st_expired_ucontact(t) == 1) {
if (db_delete_ucontact(t) < 0) {
LM_ERR("failed to delete contact from the database\n");
}
}
mem_delete_ucontact(_r, t);
} else {
/* Determine the operation we have to do */
old_state = ptr->state;
op = st_flush_ucontact(ptr);
switch(op) {
case 0: /* do nothing, contact is synchronized */
break;
case 1: /* insert */
if (db_insert_ucontact(ptr) < 0) {
LM_ERR("inserting contact into database failed\n");
ptr->state = old_state;
}
break;
case 2: /* update */
if (db_update_ucontact(ptr) < 0) {
LM_ERR("updating contact in db failed\n");
ptr->state = old_state;
}
break;
}
ptr = ptr->next;
}
}
}
static unsigned int update_balloon_stats(struct virtio_balloon *vb)
{
unsigned long events[NR_VM_EVENT_ITEMS];
struct sysinfo i;
unsigned int idx = 0;
long available;
all_vm_events(events);
si_meminfo(&i);
available = si_mem_available();
#ifdef CONFIG_VM_EVENT_COUNTERS
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_IN,
pages_to_bytes(events[PSWPIN]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_OUT,
pages_to_bytes(events[PSWPOUT]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MAJFLT, events[PGMAJFAULT]);
update_stat(vb, idx++, VIRTIO_BALLOON_S_MINFLT, events[PGFAULT]);
#endif
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMFREE,
pages_to_bytes(i.freeram));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMTOT,
pages_to_bytes(i.totalram));
update_stat(vb, idx++, VIRTIO_BALLOON_S_AVAIL,
pages_to_bytes(available));
return idx;
}
/* must be called with unlocked WSCONN_LOCK */
int wsconn_put(ws_connection_t *wsc)
{
int destroy = 0;
LM_DBG("wsconn_put start for [%p] refcnt [%d]\n", wsc, atomic_get(&wsc->refcnt));
if (!wsc)
return -1;
WSCONN_LOCK;
/* refcnt == 0*/
if (wsconn_unref(wsc))
{
/* Remove from the WebSocket used list */
if (wsconn_used_list->head == wsc)
wsconn_used_list->head = wsc->used_next;
if (wsconn_used_list->tail == wsc)
wsconn_used_list->tail = wsc->used_prev;
if (wsc->used_prev)
wsc->used_prev->used_next = wsc->used_next;
if (wsc->used_next)
wsc->used_next->used_prev = wsc->used_prev;
/* remove from wsconn_id_hash */
wsconn_listrm(wsconn_id_hash[wsc->id_hash], wsc, id_next, id_prev);
/* stat */
update_stat(ws_current_connections, -1);
if (wsc->sub_protocol == SUB_PROTOCOL_SIP)
update_stat(ws_sip_current_connections, -1);
else if (wsc->sub_protocol == SUB_PROTOCOL_MSRP)
update_stat(ws_msrp_current_connections, -1);
destroy = 1;
}
WSCONN_UNLOCK;
LM_DBG("wsconn_put end for [%p] refcnt [%d]\n", wsc, atomic_get(&wsc->refcnt));
/* wsc is removed from all lists and can be destroyed safely */
if (destroy)
wsconn_dtor(wsc);
return 0;
}
static inline void nodb_timer(pcontact_t* _c)
{
LM_DBG("Running nodb timer on <%.*s>, "
"Reg state: %s, "
"Expires: %d, "
"Expires in: %d seconds, "
"Received: %.*s:%d, "
"Path: %.*s, "
"Proto: %d, "
"Hash: %u, "
"Slot: %u\n",
_c->aor.len, _c->aor.s,
reg_state_to_string(_c->reg_state),
(int)_c->expires,
(int)(_c->expires - time(NULL)),
_c->received_host.len, _c->received_host.s,
_c->received_port,
_c->path.len, _c->path.s,
_c->received_proto,
_c->aorhash,
_c->sl);
get_act_time();
if ((_c->expires - act_time) + expires_grace <= 0) {//we've allowed some grace time TODO: add as parameter
//if ((_c->expires - act_time) <= -10) {//we've allowed some grace time TODO: add as parameter
LM_DBG("pcscf contact <%.*s> has expired and will be removed\n", _c->aor.len, _c->aor.s);
if (exists_ulcb_type(PCSCF_CONTACT_EXPIRE)) {
run_ul_callbacks(PCSCF_CONTACT_EXPIRE, _c);
}
if (db_mode == WRITE_THROUGH && db_delete_pcontact(_c) != 0) {
LM_ERR("Error deleting ims_usrloc_pcscf record in DB");
}
update_stat(_c->slot->d->expired, 1);
mem_delete_pcontact(_c->slot->d, _c);
return;
}
//TODO: this is just for tmp debugging
// p = _c->head;
// while (p) {
// if (p->is_default)
// LM_DBG("public identity %i (default): <%.*s>\n", i, p->public_identity.len, p->public_identity.s);
// else
// LM_DBG("public identity %i: <%.*s>\n", i, p->public_identity.len, p->public_identity.s);
// i++;
// p=p->next;
// }
//
// LM_DBG("There are %i service routes as follows:\n", _c->num_service_routes);
// for (i=0; i<_c->num_service_routes; i++) {
// LM_DBG("service route %i: <%.*s>\n", i+1, _c->service_routes[i].len, _c->service_routes[i].s);
// }
}
void cc_queue_push_call(struct cc_data *data, struct cc_call *call, int top)
{
struct cc_call *call_it;
int n = 0;
LM_DBG(" QUEUE - adding call %p \n",call);
if ( is_call_in_queue(data, call) ) {
LM_CRIT(" QUEUE - call already in queue \n");
abort();
}
if (top) {
/* add the call in the very top of the queue */
call_it = NULL;
} else {
/* search (priority based) the place in queue */
for(call_it=data->queue.last ; call_it ; call_it=call_it->higher_in_queue){
if (call_it->flow->priority <= call->flow->priority)
break;
n++;
}
}
if (call_it) {
/* add before it */
if (call_it->lower_in_queue) {
call_it->lower_in_queue->higher_in_queue = call;
} else {
data->queue.last = call;
}
call->lower_in_queue = call_it->lower_in_queue;
call->higher_in_queue = call_it;
call_it->lower_in_queue = call;
} else {
/* add in top of the queue */
call->lower_in_queue = data->queue.first;
if (data->queue.first) {
data->queue.first->higher_in_queue = call;
}
else {
data->queue.last = call;
}
call->higher_in_queue = NULL;
data->queue.first = call;
}
data->queue.calls_no++;
update_stat( call->flow->st_queued_calls, +1 );
LM_DBG("adding call on pos %d (already %d calls), l=%p h=%p\n",
n, data->queue.calls_no,
call->lower_in_queue, call->higher_in_queue);
call->ref_cnt++;
if (call->queue_start==0)
call->queue_start = get_ticks();
}
/* Check for completed transfers, and remove their easy handles */
void check_multi_info(struct http_m_global *g)
{
char *eff_url;
CURLMsg *msg;
int msgs_left;
CURL *easy;
CURLcode res;
struct http_m_cell *cell;
LM_DBG("REMAINING: %d\n", g->still_running);
while ((msg = curl_multi_info_read(g->multi, &msgs_left))) {
if (msg->msg == CURLMSG_DONE) {
easy = msg->easy_handle;
res = msg->data.result;
curl_easy_getinfo(easy, CURLINFO_PRIVATE, &cell);
curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url);
LM_DBG("DONE: %s => (%d) %s\n", eff_url, res, cell->error);
cell = http_m_cell_lookup(easy);
if (msg->data.result != 0) {
LM_ERR("handle %p returned error %d: %s\n", easy, res, cell->error);
update_stat(errors, 1);
reply_error(cell);
} else {
cell->reply->error[0] = '\0';
cell->cb(cell->reply, cell->param);
LM_DBG("reply: [%d] %.*s [%d]\n", (int)cell->reply->retcode, cell->reply->result->len, cell->reply->result->s, cell->reply->result->len);
update_stat(replies, 1);
}
if (cell != 0) {
LM_DBG("cleaning up cell %p\n", cell);
unlink_http_m_cell(cell);
free_http_m_cell(cell);
}
LM_DBG("Removing handle %p\n", easy);
curl_multi_remove_handle(g->multi, easy);
curl_easy_cleanup(easy);
}
}
}
/* ------------------------------------------------------------------
* Opens and iterates through a given directory, operating on allowed
* files found within it. . and .. are skipped, as are files beginning
* with . unless it's been enabled in the flags. All other entries,
* both files and directories, are thrown to process_entry to determine
* whether they're a file/directory/link, and to read/explore them if
* appropriate. If threads are being used, they wait for their children
* threads to terminate after they themselves are done with their work.
*
* flags: The usual I/O option flags.
* list_head: A list of already visited directories. Always will have
* the working directory low was called from as the tail,
* and will always have the current directory being explored
* as the head (so the src = list_head->next->path assignment
* is always safe).
* fullpath: The realpath of the current directory being explored.
* dir_depth: Passed to process_entry.
* ------------------------------------------------------------------
*/
int explore_dir(params *P, visited_dir *list_head, char *nextpath,
int dir_depth)
{
DIR *d;
struct dirent *entry;
struct dirent **done;
int len;
if ( (d = opendir(nextpath)) == 0)
{
return print_file_error(P, errno, nextpath);
}
if (((P->max_dir_depth) - dir_depth) > read_stat(P, t_ddepth))
update_stat(P, t_ddepth, ((P->max_dir_depth) - dir_depth));
len = offsetof(struct dirent, d_name) +
pathconf(nextpath, _PC_NAME_MAX) + 1;
if ((entry = malloc(len)) == NULL ||
(done = malloc(sizeof(struct dirent*))) == NULL)
{
fprintf(stderr, "Malloc failed in explore_dir.\n");
return -1;
}
done = &entry;
while ( (readdir_r(d, entry, done)) == 0 && (*done != NULL))
{
/* don't process '.' or '..' in a directory! */
if ( (strcmp(entry->d_name, THIS_DIR) == 0)
|| (strcmp(entry->d_name, PARENT_DIR) == 0))
continue;
/* do all files but ones beginning with a dot,
* unless we've enabled it! */
if (entry->d_name[0] == '.')
{
if (enabled(P, READ_DOT_FILES))
{
process_entry(P, list_head, entry->d_name,
nextpath, dir_depth, 0);
}
else
inc_stat(P, t_dotfiles, 1);
}
else
process_entry(P, list_head, entry->d_name, nextpath,
dir_depth, 0);
}
closedir(d);
wait_for_children(list_head);
free(nextpath);
return 0;
}
void hp_init_rpm_statistics(struct hp_block *hpb)
{
#ifdef DBG_MALLOC
/* reset stats updated by mallocs before this init */
rpm_used->flags &= ~STAT_NO_RESET;
rpm_rused->flags &= ~STAT_NO_RESET;
rpm_frags->flags &= ~STAT_NO_RESET;
reset_stat(rpm_used);
reset_stat(rpm_rused);
reset_stat(rpm_frags);
rpm_used->flags |= STAT_NO_RESET;
rpm_rused->flags |= STAT_NO_RESET;
rpm_frags->flags |= STAT_NO_RESET;
#endif
update_stat(rpm_used, hpb->used);
update_stat(rpm_rused, hpb->real_used);
update_stat(rpm_frags, hpb->total_fragments);
LM_DBG("initializing atomic rpm statistics: "
"[ us: %ld | rus: %ld | frags: %ld ]\n", hpb->used, hpb->real_used, hpb->total_fragments);
}
int mem_insert_pcontact(struct udomain* _d, str* _contact, struct pcontact_info* _ci, struct pcontact** _c){
int sl;
if (new_pcontact(_d->name, _contact, _ci, _c) < 0) {
LM_ERR("creating pcontact failed\n");
return -1;
}
sl = ((*_c)->aorhash) & (_d->size - 1);
slot_add(&_d->table[sl], *_c);
update_stat(_d->contacts, 1);
return 0;
}
static unsigned int update_balloon_stats(struct virtio_balloon *vb)
{
unsigned long events[NR_VM_EVENT_ITEMS];
struct sysinfo i;
unsigned int idx = 0;
long available;
unsigned long caches;
all_vm_events(events);
si_meminfo(&i);
available = si_mem_available();
caches = global_node_page_state(NR_FILE_PAGES);
#ifdef CONFIG_VM_EVENT_COUNTERS
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_IN,
pages_to_bytes(events[PSWPIN]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_OUT,
pages_to_bytes(events[PSWPOUT]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MAJFLT, events[PGMAJFAULT]);
update_stat(vb, idx++, VIRTIO_BALLOON_S_MINFLT, events[PGFAULT]);
#ifdef CONFIG_HUGETLB_PAGE
update_stat(vb, idx++, VIRTIO_BALLOON_S_HTLB_PGALLOC,
events[HTLB_BUDDY_PGALLOC]);
update_stat(vb, idx++, VIRTIO_BALLOON_S_HTLB_PGFAIL,
events[HTLB_BUDDY_PGALLOC_FAIL]);
#endif
#endif
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMFREE,
pages_to_bytes(i.freeram));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMTOT,
pages_to_bytes(i.totalram));
update_stat(vb, idx++, VIRTIO_BALLOON_S_AVAIL,
pages_to_bytes(available));
update_stat(vb, idx++, VIRTIO_BALLOON_S_CACHES,
pages_to_bytes(caches));
return idx;
}
