自学教程：C++ update_stat函数代码示例

/*! * /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;}