aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

additional support for type qualifier for the stats api

Browse Source
remotes/origin/master-1.0.x
Anoop Saldanha 16 years ago committed by Victor Julien
parent 630a58b719
commit 8af9f902e8
9 changed files with 639 additions and 113 deletions
Show Stats Download Patch File Download Diff File

563
src/counters.c
Unescape Escape View File

@ -208,7 +208,8 @@ void * PerfWakeupThread(void *arg)
* \retval the counter id * \retval the counter id
*/ */
u_int32_t PerfRegisterCounter(char *cname, char *tm_name, int type, u_int32_t PerfRegisterCounter(char *cname, char *tm_name, int type,
char *desc, PerfContext *pctx) char *desc, PerfContext *pctx, int type_q,
int disp)
{ {
PerfCounter **head = &pctx->head; PerfCounter **head = &pctx->head;
PerfCounter *temp = NULL; PerfCounter *temp = NULL;
@ -216,13 +217,17 @@ u_int32_t PerfRegisterCounter(char *cname, char *tm_name, int type,
PerfCounter *pc = NULL; PerfCounter *pc = NULL;
if (cname == NULL || tm_name == NULL || pctx == NULL) { if (cname == NULL || tm_name == NULL || pctx == NULL) {
#ifdef DEBUG
printf("counter name, tm name null or PerfContext NULL\n"); printf("counter name, tm name null or PerfContext NULL\n");
#endif
return 0; return 0;
} }
/* (TYPE_MAX - 1) because we still haven't implemented TYPE_STR */ /* (TYPE_MAX - 1) because we still haven't implemented TYPE_STR */
if ((type >= (TYPE_MAX - 1)) || (type < 0)) { if ((type >= (TYPE_MAX - 1)) || (type < 0)) {
#ifdef DEBUG
printf("Error: Counters of type %d can't be registered\n", type); printf("Error: Counters of type %d can't be registered\n", type);
#endif
return 0; return 0;
} }
@ -294,9 +299,234 @@ u_int32_t PerfRegisterCounter(char *cname, char *tm_name, int type,
if (desc != NULL) if (desc != NULL)
pc->desc = strdup(desc); pc->desc = strdup(desc);
pc->type_q = type_q;
pc->disp = disp;
return pc->id; return pc->id;
} }
/**
* \brief Increments the local counter
*
* \param id Index of the counter in the counter array
* \param pca Counter array that holds the local counters for this TM
*/
inline void PerfCounterIncr(u_int64_t id, PerfCounterArray *pca)
{
if (!pca) {
#ifdef DEBUG
printf("counterarray is NULL\n");
#endif
return;
}
if ((id < 1) || (id > pca->size)) {
#ifdef DEBUG
printf("counter doesn't exist\n");
#endif
return;
}
switch (pca->head[id].pc->value->type) {
case TYPE_UINT64:
pca->head[id].ui64_cnt++;
break;
case TYPE_DOUBLE:
pca->head[id].d_cnt++;
break;
}
if (pca->head[id].syncs == ULONG_MAX) {
pca->head[id].syncs = 0;
pca->head[id].wrapped_syncs++;
}
pca->head[id].syncs++;
return;
}
/**
* \brief Adds a value of type u_int64_t to the local counter.
*
* \param id ID of the counter as set by the API
* \param pca Counter array that holds the local counter for this TM
* \param x Value to add to this local counter
*/
inline void PerfCounterAddUI64(u_int64_t id, PerfCounterArray *pca, u_int64_t x)
{
if (!pca) {
#ifdef DEBUG
printf("counterarray is NULL\n");
#endif
return;
}
if ((id < 1) || (id > pca->size)) {
#ifdef DEBUG
printf("counter doesn't exist\n");
#endif
return;
}
switch (pca->head[id].pc->value->type) {
case TYPE_UINT64:
pca->head[id].ui64_cnt += x;
break;
case TYPE_DOUBLE:
pca->head[id].d_cnt += x;
break;
}
if (pca->head[id].syncs == ULONG_MAX) {
pca->head[id].syncs = 0;
pca->head[id].wrapped_syncs++;
}
pca->head[id].syncs++;
return;
}
/**
* \brief Adds a value of type double to the local counter
*
* \param id ID of the counter as set by the API
* \param pca Counter array that holds the local counter for this TM
* \param x Value to add to this local counter
*/
inline void PerfCounterAddDouble(u_int64_t id, PerfCounterArray *pca, double x)
{
if (!pca) {
#ifdef DEBUG
printf("counterarray is NULL\n");
#endif
return;
}
if ((id < 1) || (id > pca->size)) {
#ifdef DEBUG
printf("counter doesn't exist\n");
#endif
return;
}
/* incase you are trying to add a double to a counter of type TYPE_UINT64
it will be truncated */
switch (pca->head[id].pc->value->type) {
case TYPE_UINT64:
pca->head[id].ui64_cnt += x;
break;
case TYPE_DOUBLE:
pca->head[id].d_cnt += x;
break;
}
if (pca->head[id].syncs == ULONG_MAX) {
pca->head[id].syncs = 0;
pca->head[id].wrapped_syncs++;
}
pca->head[id].syncs++;
return;
}
/**
* \brief Sets a local counter to an arg of type double
*
* \param id Index of the local counter in the counter array
* \param pca Pointer to the PerfCounterArray
* \param x The value to set for the counter
*/
inline void PerfCounterSetUI64(u_int64_t id, PerfCounterArray *pca,
u_int64_t x)
{
if (!pca) {
#ifdef DEBUG
printf("counterarray is NULL\n");
#endif
return;
}
if ((id < 1) || (id > pca->size)) {
#ifdef DEBUG
printf("counter doesn't exist\n");
#endif
return;
}
switch (pca->head[id].pc->value->type) {
case TYPE_UINT64:
if (pca->head[id].pc->type_q & TYPE_Q_MAXIMUM) {
if (x > pca->head[id].ui64_cnt)
pca->head[id].ui64_cnt = x;
} else if (pca->head[id].pc->type_q & TYPE_Q_NONE)
pca->head[id].ui64_cnt = x;
break;
case TYPE_DOUBLE:
if (pca->head[id].pc->type_q & TYPE_Q_MAXIMUM) {
if (x > pca->head[id].d_cnt)
pca->head[id].d_cnt = x;
} else if (pca->head[id].pc->type_q & TYPE_Q_NONE)
pca->head[id].d_cnt = x;
break;
}
if (pca->head[id].syncs == ULONG_MAX) {
pca->head[id].syncs = 0;
pca->head[id].wrapped_syncs++;
}
pca->head[id].syncs++;
return;
}
/**
* \brief Sets a local counter to an arg of type double
*
* \param id Index of the local counter in the counter array
* \param pca Pointer to the PerfCounterArray
* \param x The value to set for the counter
*/
inline void PerfCounterSetDouble(u_int64_t id, PerfCounterArray *pca,
double x)
{
if (!pca) {
#ifdef DEBUG
printf("counterarray is NULL\n");
#endif
return;
}
if ((id < 1) || (id > pca->size)) {
#ifdef DEBUG
printf("counter doesn't exist\n");
#endif
return;
}
switch (pca->head[id].pc->value->type) {
case TYPE_UINT64:
if (pca->head[id].pc->type_q & TYPE_Q_MAXIMUM) {
if (x > pca->head[id].ui64_cnt)
pca->head[id].ui64_cnt = x;
} else if (pca->head[id].pc->type_q & TYPE_Q_NONE)
pca->head[id].ui64_cnt = x;
break;
case TYPE_DOUBLE:
if (pca->head[id].pc->type_q & TYPE_Q_MAXIMUM) {
if (x > pca->head[id].d_cnt)
pca->head[id].d_cnt = x;
} else if (pca->head[id].pc->type_q & TYPE_Q_NONE)
pca->head[id].d_cnt = x;
break;
}
if (pca->head[id].syncs == ULONG_MAX) {
pca->head[id].syncs = 0;
pca->head[id].wrapped_syncs++;
}
pca->head[id].syncs++;
return;
}
/** /**
* \brief Adds a TM to the clubbed TM table. Multiple instances of the same TM * \brief Adds a TM to the clubbed TM table. Multiple instances of the same TM
* are stacked together in a PCTMI container * are stacked together in a PCTMI container
@ -356,7 +586,8 @@ void PerfAddToClubbedTMTable(char *tm_name, PerfContext *pctx)
return; return;
} }
pctmi->head = realloc(pctmi->head, (pctmi->size + 1) * sizeof(PerfContext **)); pctmi->head = realloc(pctmi->head, (pctmi->size + 1) *
sizeof(PerfContext **));
hpctx = pctmi->head; hpctx = pctmi->head;
hpctx[pctmi->size] = pctx; hpctx[pctmi->size] = pctx;
@ -388,26 +619,35 @@ void PerfAddToClubbedTMTable(char *tm_name, PerfContext *pctx)
PerfCounterArray * PerfGetCounterArrayRange(u_int32_t s_id, u_int32_t e_id, PerfCounterArray * PerfGetCounterArrayRange(u_int32_t s_id, u_int32_t e_id,
PerfContext *pctx) PerfContext *pctx)
{ {
PerfCounter *pc = NULL;
PerfCounterArray *pca = NULL; PerfCounterArray *pca = NULL;
u_int32_t i = 0; u_int32_t i = 0;
if (pctx == NULL) { if (pctx == NULL) {
#ifdef DEBUG
printf("pctx is NULL\n"); printf("pctx is NULL\n");
#endif
return NULL; return NULL;
} }
if (s_id < 1 || e_id < 1 || s_id > e_id) { if (s_id < 1 || e_id < 1 || s_id > e_id) {
#ifdef DEBUG
printf("error with the counter ids\n"); printf("error with the counter ids\n");
#endif
return NULL; return NULL;
} }
if (e_id > pctx->curr_id) { if (e_id > pctx->curr_id) {
#ifdef DEBUG
printf("end id is greater than the max id for this tv\n"); printf("end id is greater than the max id for this tv\n");
#endif
return NULL; return NULL;
} }
if (pctx == NULL) { if (pctx == NULL) {
#ifdef DEBUG
printf("perfcontext is NULL\n"); printf("perfcontext is NULL\n");
#endif
return NULL; return NULL;
} }
@ -423,9 +663,15 @@ PerfCounterArray * PerfGetCounterArrayRange(u_int32_t s_id, u_int32_t e_id,
} }
memset(pca->head, 0, sizeof(PCAElem) * (e_id - s_id + 2)); memset(pca->head, 0, sizeof(PCAElem) * (e_id - s_id + 2));
pc = pctx->head;
while (pc->id != s_id)
pc = pc->next;
i = 1; i = 1;
while (s_id <= e_id) { while ((pc != NULL) && (pc->id <= e_id)) {
pca->head[i].id = s_id++; pca->head[i].pc = pc;
pca->head[i].id = pc->id;
pc = pc->next;
i++; i++;
} }
pca->size = i - 1; pca->size = i - 1;
@ -434,7 +680,8 @@ PerfCounterArray * PerfGetCounterArrayRange(u_int32_t s_id, u_int32_t e_id,
} }
/** /**
* \brief Returns a counter array for all counters registered for this tm instance * \brief Returns a counter array for all counters registered for this tm
* instance
* *
* \param pctx Pointer to the tv's PerfContext * \param pctx Pointer to the tv's PerfContext
* *
@ -463,18 +710,25 @@ int PerfUpdateCounter(char *cname, char *tm_name, u_int32_t id, void *value,
PerfCounter *pc = NULL; PerfCounter *pc = NULL;
if (pctx == NULL) { if (pctx == NULL) {
#ifdef DEBUG
printf("pctx null inside PerfUpdateCounter\n"); printf("pctx null inside PerfUpdateCounter\n");
#endif
return 0; return 0;
} }
if ((cname == NULL || tm_name == NULL) && (id > pctx->curr_id || id < 1)) { if ((cname == NULL || tm_name == NULL) && (id > pctx->curr_id || id < 1)) {
#ifdef DEBUG
printf("id supplied doesn't exist. Please supply cname and " printf("id supplied doesn't exist. Please supply cname and "
"tm_name instead\n"); "tm_name instead\n");
#endif
return 0; return 0;
} }
if (value == NULL) { if (value == NULL) {
printf("Pointer to counter(value) supplied to PerfUpdateCounter is NULL\n"); #ifdef DEBUG
printf("Pointer to counter(value) supplied to PerfUpdateCounter is "
"NULL\n");
#endif
return 0; return 0;
} }
@ -492,13 +746,59 @@ int PerfUpdateCounter(char *cname, char *tm_name, u_int32_t id, void *value,
} }
if (pc == NULL) { if (pc == NULL) {
#ifdef DEBUG
printf("this counter isn't registered in this tm\n"); printf("this counter isn't registered in this tm\n");
#endif
return 0; return 0;
} }
return 1; return 1;
} }
static void PerfCopyCounterValue(PCAElem *pcae, int reset_lc)
{
PerfCounter *pc = NULL;
double d_temp = 0;
u_int64_t ui64_temp = 0;
int i = 0;
pc = pcae->pc;
switch (pc->value->type) {
case TYPE_UINT64:
ui64_temp = pcae->ui64_cnt;
if (pc->type_q & TYPE_Q_AVERAGE) {
for (i = 0; i < pcae->wrapped_syncs; i++)
ui64_temp /= ULONG_MAX;
if (pcae->syncs != 0)
ui64_temp /= pcae->syncs;
}
memcpy(pc->value->cvalue, &ui64_temp, pc->value->size);
if (reset_lc)
pcae->ui64_cnt = 0;
break;
case TYPE_DOUBLE:
d_temp = pcae->d_cnt;
if (pc->type_q & TYPE_Q_AVERAGE) {
for (i = 0; i < pcae->wrapped_syncs; i++)
d_temp /= ULONG_MAX;
if (pcae->syncs != 0)
d_temp /= pcae->syncs;
}
memcpy(pc->value->cvalue, &d_temp, pc->value->size);
if (reset_lc)
pcae->d_cnt = 0;
break;
}
return;
}
/** /**
* \brief Syncs the counter array with the global counter variables * \brief Syncs the counter array with the global counter variables
* *
@ -506,14 +806,17 @@ int PerfUpdateCounter(char *cname, char *tm_name, u_int32_t id, void *value,
* \param pctx Pointer the the tv's PerfContext * \param pctx Pointer the the tv's PerfContext
* \param reset_lc Indicates whether the local counter has to be reset or not * \param reset_lc Indicates whether the local counter has to be reset or not
*/ */
int PerfUpdateCounterArray(PerfCounterArray *pca, PerfContext *pctx, int reset_lc) int PerfUpdateCounterArray(PerfCounterArray *pca, PerfContext *pctx,
int reset_lc)
{ {
PerfCounter *pc = NULL; PerfCounter *pc = NULL;
PCAElem *pcae = NULL; PCAElem *pcae = NULL;
u_int32_t i = 0; u_int32_t i = 0;
if (pca == NULL || pctx == NULL) { if (pca == NULL || pctx == NULL) {
#ifdef DEBUG
printf("pca or pctx is NULL inside PerfUpdateCounterArray\n"); printf("pca or pctx is NULL inside PerfUpdateCounterArray\n");
#endif
return -1; return -1;
} }
@ -528,13 +831,10 @@ int PerfUpdateCounterArray(PerfCounterArray *pca, PerfContext *pctx, int reset_l
continue; continue;
} }
memcpy(pc->value->cvalue, &(pcae[i].cnt), pc->value->size); PerfCopyCounterValue(&pcae[i], reset_lc);
pc->updated++; pc->updated++;
if (reset_lc)
pcae[i].cnt = 0;
pc = pc->next; pc = pc->next;
break; break;
} }
@ -580,7 +880,11 @@ int PerfOutputCounterFileIface()
PerfCounter **pc_heads; PerfCounter **pc_heads;
u_int64_t *ui64_cvalue = NULL; u_int64_t *ui64_cvalue = NULL;
u_int64_t result = 0; u_int64_t ui64_result = 0;
double *double_cvalue = NULL;
double double_result = 0;
struct timeval tval; struct timeval tval;
struct tm *tms; struct tm *tms;
@ -589,7 +893,9 @@ int PerfOutputCounterFileIface()
int flag; int flag;
if (perf_op_ctx->fp == NULL) { if (perf_op_ctx->fp == NULL) {
#ifdef DEBUG
printf("perf_op_ctx->fp is NULL"); printf("perf_op_ctx->fp is NULL");
#endif
return 0; return 0;
} }
@ -601,7 +907,8 @@ int PerfOutputCounterFileIface()
fprintf(perf_op_ctx->fp, "-------------------------------------------------" fprintf(perf_op_ctx->fp, "-------------------------------------------------"
"------------------\n"); "------------------\n");
fprintf(perf_op_ctx->fp, "%d/%d/%04d -- %02d:%02d:%02d\n", tms->tm_mday, fprintf(perf_op_ctx->fp, "%d/%d/%04d -- %02d:%02d:%02d\n", tms->tm_mday,
tms->tm_mon, tms->tm_year + 1900, tms->tm_hour, tms->tm_min, tms->tm_sec); tms->tm_mon, tms->tm_year + 1900, tms->tm_hour, tms->tm_min,
tms->tm_sec);
fprintf(perf_op_ctx->fp, "-------------------------------------------------" fprintf(perf_op_ctx->fp, "-------------------------------------------------"
"------------------\n"); "------------------\n");
fprintf(perf_op_ctx->fp, "%-25s | %-25s | %-s\n", "Counter", "TM Name", fprintf(perf_op_ctx->fp, "%-25s | %-25s | %-s\n", "Counter", "TM Name",
@ -618,11 +925,18 @@ int PerfOutputCounterFileIface()
pc = tv->pctx.head; pc = tv->pctx.head;
while (pc != NULL) { while (pc != NULL) {
if (pc->disp == 0) {
pc = pc->next;
continue;
}
ui64_cvalue = (u_int64_t *)pc->value->cvalue; ui64_cvalue = (u_int64_t *)pc->value->cvalue;
fprintf(perf_op_ctx->fp, "%-25s | %-25s | %-llu\n", fprintf(perf_op_ctx->fp, "%-25s | %-25s | %-llu\n",
pc->name->cname, pc->name->tm_name, *ui64_cvalue); pc->name->cname, pc->name->tm_name, *ui64_cvalue);
//printf("%-10d %-10d %-10s %-llu\n", pc->name->tid, pc->id, #ifdef DEBUG
// pc->name->cname, *ui64_cvalue); printf("%-10d %-10d %-10s %-llu\n", pc->name->tid, pc->id,
pc->name->cname, *ui64_cvalue);
#endif
pc = pc->next; pc = pc->next;
} }
@ -637,7 +951,7 @@ int PerfOutputCounterFileIface()
pctmi = perf_op_ctx->pctmi; pctmi = perf_op_ctx->pctmi;
while (pctmi != NULL) { while (pctmi != NULL) {
if ( (pc_heads = malloc(pctmi->size * sizeof(PerfCounter **))) == NULL) { if ( (pc_heads = malloc(pctmi->size * sizeof(PerfCounter *))) == NULL) {
printf("error allocating memory\n"); printf("error allocating memory\n");
exit(0); exit(0);
} }
@ -654,11 +968,20 @@ int PerfOutputCounterFileIface()
flag = 1; flag = 1;
while(flag) { while(flag) {
result = 0; ui64_result = 0;
double_result = 0;
pc = pc_heads[0]; pc = pc_heads[0];
for (i = 0; i < pctmi->size; i++) { for (i = 0; i < pctmi->size; i++) {
switch (pc->value->type) {
case TYPE_UINT64:
ui64_cvalue = pc_heads[i]->value->cvalue; ui64_cvalue = pc_heads[i]->value->cvalue;
result += *ui64_cvalue; ui64_result += *ui64_cvalue;
break;
case TYPE_DOUBLE:
double_cvalue = pc_heads[i]->value->cvalue;
double_result += *double_cvalue;
break;
}
pc_heads[i] = pc_heads[i]->next; pc_heads[i] = pc_heads[i]->next;
@ -666,11 +989,24 @@ int PerfOutputCounterFileIface()
strcmp(pctmi->tm_name, pc_heads[0]->name->tm_name)) strcmp(pctmi->tm_name, pc_heads[0]->name->tm_name))
flag = 0; flag = 0;
} }
fprintf(perf_op_ctx->fp, "%-25s | %-25s | %-llu\n",
pc->name->cname, pctmi->tm_name, result);
//printf("%-25s | %-25s | %-llu\n", pc->name->cname,
// pctmi->tm_name, result);
if (pc->disp == 0)
continue;
switch (pc->value->type) {
case TYPE_UINT64:
fprintf(perf_op_ctx->fp, "%-25s | %-25s | %-llu\n",
pc->name->cname, pctmi->tm_name, ui64_result);
break;
case TYPE_DOUBLE:
fprintf(perf_op_ctx->fp, "%-25s | %-25s | %-lf\n",
pc->name->cname, pctmi->tm_name, double_result);
break;
}
#ifdef DEBUG
printf("%-25s | %-25s | %-llu\n", pc->name->cname,
pctmi->tm_name, result);
#endif
} }
for (i = 0; i < pctmi->size; i++) for (i = 0; i < pctmi->size; i++)
pthread_mutex_unlock(&pctmi->head[i]->m); pthread_mutex_unlock(&pctmi->head[i]->m);
@ -770,7 +1106,7 @@ static int PerfTestCounterReg01()
memset(&pctx, 0, sizeof(PerfContext)); memset(&pctx, 0, sizeof(PerfContext));
return PerfRegisterCounter("t1", "c1", 5, NULL, &pctx); return PerfRegisterCounter("t1", "c1", 5, NULL, &pctx, TYPE_Q_NONE, 1);
} }
static int PerfTestCounterReg02() static int PerfTestCounterReg02()
@ -779,7 +1115,8 @@ static int PerfTestCounterReg02()
memset(&pctx, 0, sizeof(PerfContext)); memset(&pctx, 0, sizeof(PerfContext));
return PerfRegisterCounter(NULL, NULL, TYPE_UINT64, NULL, &pctx); return PerfRegisterCounter(NULL, NULL, TYPE_UINT64, NULL, &pctx,
TYPE_Q_NONE, 1);
} }
static int PerfTestCounterReg03() static int PerfTestCounterReg03()
@ -789,7 +1126,8 @@ static int PerfTestCounterReg03()
memset(&pctx, 0, sizeof(PerfContext)); memset(&pctx, 0, sizeof(PerfContext));
result = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &pctx); result = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &pctx,
TYPE_Q_NONE, 1);
PerfReleasePerfCounterS(pctx.head); PerfReleasePerfCounterS(pctx.head);
@ -803,11 +1141,12 @@ static int PerfTestCounterReg04()
memset(&pctx, 0, sizeof(PerfContext)); memset(&pctx, 0, sizeof(PerfContext));
PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &pctx); PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &pctx); PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("t3", "c3", TYPE_UINT64, NULL, &pctx); PerfRegisterCounter("t3", "c3", TYPE_UINT64, NULL, &pctx, TYPE_Q_NONE, 1);
result = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &pctx); result = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &pctx,
TYPE_Q_NONE, 1);
PerfReleasePerfCounterS(pctx.head); PerfReleasePerfCounterS(pctx.head);
@ -821,7 +1160,8 @@ static int PerfTestGetCntArray05()
memset(&tv, 0, sizeof(ThreadVars)); memset(&tv, 0, sizeof(ThreadVars));
id = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx); id = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
tv.pca = PerfGetAllCountersArray(NULL); tv.pca = PerfGetAllCountersArray(NULL);
@ -836,7 +1176,8 @@ static int PerfTestGetCntArray06()
memset(&tv, 0, sizeof(ThreadVars)); memset(&tv, 0, sizeof(ThreadVars));
id = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx); id = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
tv.pca = PerfGetAllCountersArray(&tv.pctx); tv.pca = PerfGetAllCountersArray(&tv.pctx);
@ -858,8 +1199,10 @@ static int PerfTestCntArraySize07()
pca = (PerfCounterArray *)&tv.pca; pca = (PerfCounterArray *)&tv.pca;
PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx); PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx, TYPE_Q_NONE,
PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &tv.pctx); 1);
PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &tv.pctx, TYPE_Q_NONE,
1);
pca = PerfGetAllCountersArray(&tv.pctx); pca = PerfGetAllCountersArray(&tv.pctx);
@ -883,14 +1226,15 @@ static int PerfTestUpdateCounter08()
memset(&tv, 0, sizeof(ThreadVars)); memset(&tv, 0, sizeof(ThreadVars));
id = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx); id = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
pca = PerfGetAllCountersArray(&tv.pctx); pca = PerfGetAllCountersArray(&tv.pctx);
PerfCounterIncr(id, pca); PerfCounterIncr(id, pca);
PerfCounterAdd(id, pca, 100); PerfCounterAddUI64(id, pca, 100);
result = pca->head[id].cnt; result = pca->head[id].ui64_cnt;
PerfReleasePerfCounterS(tv.pctx.head); PerfReleasePerfCounterS(tv.pctx.head);
PerfReleasePCA(pca); PerfReleasePCA(pca);
@ -907,18 +1251,23 @@ static int PerfTestUpdateCounter09()
memset(&tv, 0, sizeof(ThreadVars)); memset(&tv, 0, sizeof(ThreadVars));
id1 = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx); id1 = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx,
PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &tv.pctx); TYPE_Q_NONE, 1);
PerfRegisterCounter("t3", "c3", TYPE_UINT64, NULL, &tv.pctx); PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &tv.pctx,
PerfRegisterCounter("t4", "c4", TYPE_UINT64, NULL, &tv.pctx); TYPE_Q_NONE, 1);
id2 = PerfRegisterCounter("t5", "c5", TYPE_UINT64, NULL, &tv.pctx); PerfRegisterCounter("t3", "c3", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
PerfRegisterCounter("t4", "c4", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
id2 = PerfRegisterCounter("t5", "c5", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
pca = PerfGetAllCountersArray(&tv.pctx); pca = PerfGetAllCountersArray(&tv.pctx);
PerfCounterIncr(id2, pca); PerfCounterIncr(id2, pca);
PerfCounterAdd(id2, pca, 100); PerfCounterAddUI64(id2, pca, 100);
result = (pca->head[id1].cnt == 0) && (pca->head[id2].cnt == 101); result = (pca->head[id1].ui64_cnt == 0) && (pca->head[id2].ui64_cnt == 101);
PerfReleasePerfCounterS(tv.pctx.head); PerfReleasePerfCounterS(tv.pctx.head);
PerfReleasePCA(pca); PerfReleasePCA(pca);
@ -937,15 +1286,18 @@ static int PerfTestUpdateGlobalCounter10()
memset(&tv, 0, sizeof(ThreadVars)); memset(&tv, 0, sizeof(ThreadVars));
id1 = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx); id1 = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx,
id2 = PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &tv.pctx); TYPE_Q_NONE, 1);
id3 = PerfRegisterCounter("t3", "c3", TYPE_UINT64, NULL, &tv.pctx); id2 = PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
id3 = PerfRegisterCounter("t3", "c3", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
pca = PerfGetAllCountersArray(&tv.pctx); pca = PerfGetAllCountersArray(&tv.pctx);
PerfCounterIncr(id1, pca); PerfCounterIncr(id1, pca);
PerfCounterAdd(id2, pca, 100); PerfCounterAddUI64(id2, pca, 100);
PerfCounterIncr(id3, pca); PerfCounterIncr(id3, pca);
PerfCounterAdd(id3, pca, 100); PerfCounterAddUI64(id3, pca, 100);
PerfUpdateCounterArray(pca, &tv.pctx, 0); PerfUpdateCounterArray(pca, &tv.pctx, 0);
@ -975,17 +1327,21 @@ static int PerfTestCounterValues11()
memset(&tv, 0, sizeof(ThreadVars)); memset(&tv, 0, sizeof(ThreadVars));
id1 = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx); id1 = PerfRegisterCounter("t1", "c1", TYPE_UINT64, NULL, &tv.pctx,
id2 = PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &tv.pctx); TYPE_Q_NONE, 1);
id3 = PerfRegisterCounter("t3", "c3", TYPE_UINT64, NULL, &tv.pctx); id2 = PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &tv.pctx,
id4 = PerfRegisterCounter("t4", "c4", TYPE_UINT64, NULL, &tv.pctx); TYPE_Q_NONE, 1);
id3 = PerfRegisterCounter("t3", "c3", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
id4 = PerfRegisterCounter("t4", "c4", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_NONE, 1);
pca = PerfGetAllCountersArray(&tv.pctx); pca = PerfGetAllCountersArray(&tv.pctx);
PerfCounterIncr(id1, pca); PerfCounterIncr(id1, pca);
PerfCounterAdd(id2, pca, 256); PerfCounterAddUI64(id2, pca, 256);
PerfCounterAdd(id3, pca, 257); PerfCounterAddUI64(id3, pca, 257);
PerfCounterAdd(id4, pca, 16843024); PerfCounterAddUI64(id4, pca, 16843024);
PerfUpdateCounterArray(pca, &tv.pctx, 0); PerfUpdateCounterArray(pca, &tv.pctx, 0);
@ -1019,6 +1375,101 @@ static int PerfTestCounterValues11()
return result; return result;
} }
static int PerfTestAverageQual12()
{
ThreadVars tv;
PerfCounterArray *pca = NULL;
u_int64_t *ui64_temp = NULL;
double *d_temp = NULL;
int result = 1;
int id1, id2;
memset(&tv, 0, sizeof(ThreadVars));
id1 = PerfRegisterCounter("t1", "c1", TYPE_DOUBLE, NULL, &tv.pctx,
TYPE_Q_AVERAGE, 1);
id2 = PerfRegisterCounter("t2", "c2", TYPE_UINT64, NULL, &tv.pctx,
TYPE_Q_AVERAGE, 1);
pca = PerfGetAllCountersArray(&tv.pctx);
PerfCounterAddDouble(id1, pca, 1);
PerfCounterAddDouble(id1, pca, 2);
PerfCounterAddDouble(id1, pca, 3);
PerfCounterAddDouble(id1, pca, 4);
PerfCounterAddDouble(id1, pca, 5);
PerfCounterAddDouble(id1, pca, 6);
PerfUpdateCounterArray(pca, &tv.pctx, 0);
result &= (21 == pca->head[1].d_cnt);
result &= (6 == pca->head[1].syncs);
result &= (0 == pca->head[1].wrapped_syncs);
d_temp = tv.pctx.head->value->cvalue;
result &= (3.5 == *d_temp);
PerfCounterAddUI64(id2, pca, 1.635);
PerfCounterAddUI64(id2, pca, 2.12);
PerfCounterAddUI64(id2, pca, 3.74);
PerfCounterAddUI64(id2, pca, 4.23);
PerfCounterAddUI64(id2, pca, 5.76);
PerfCounterAddDouble(id2, pca, 6.99999);
PerfUpdateCounterArray(pca, &tv.pctx, 0);
result &= (21 == pca->head[2].ui64_cnt);
result &= (6 == pca->head[2].syncs);
result &= (0 == pca->head[2].wrapped_syncs);
ui64_temp = tv.pctx.head->next->value->cvalue;
result &= (3 == *ui64_temp);
return result;
}
static int PerfTestMaxQual13()
{
ThreadVars tv;
PerfCounterArray *pca = NULL;
double *p;
int result = 1;
int id1;
memset(&tv, 0, sizeof(ThreadVars));
id1 = PerfRegisterCounter("t1", "c1", TYPE_DOUBLE, NULL, &tv.pctx,
TYPE_Q_MAXIMUM, 1);
p = tv.pctx.head->value->cvalue;
pca = PerfGetAllCountersArray(&tv.pctx);
PerfCounterSetDouble(id1, pca, 1.352);
PerfCounterSetDouble(id1, pca, 5.12412);
PerfCounterSetDouble(id1, pca, 4.1234);
PerfCounterSetDouble(id1, pca, 5.13562);
PerfCounterSetDouble(id1, pca, 1.2342);
PerfUpdateCounterArray(pca, &tv.pctx, 0);
result &= (5.13562 == *p);
PerfCounterSetDouble(id1, pca, 8);
PerfCounterSetDouble(id1, pca, 7);
PerfUpdateCounterArray(pca, &tv.pctx, 0);
result &= (8 == *p);
PerfCounterSetDouble(id1, pca, 6);
PerfCounterSetUI64(id1, pca, 10);
PerfCounterSetDouble(id1, pca, 9.562);
PerfUpdateCounterArray(pca, &tv.pctx, 0);
result &= (10 == *p);
return result;
}
void PerfRegisterTests() void PerfRegisterTests()
{ {
UtRegisterTest("PerfTestCounterReg01", PerfTestCounterReg01, 0); UtRegisterTest("PerfTestCounterReg01", PerfTestCounterReg01, 0);
@ -1033,6 +1484,8 @@ void PerfRegisterTests()
UtRegisterTest("PerfTestUpdateGlobalCounter10", UtRegisterTest("PerfTestUpdateGlobalCounter10",
PerfTestUpdateGlobalCounter10, 1); PerfTestUpdateGlobalCounter10, 1);
UtRegisterTest("PerfTestCounterValues11", PerfTestCounterValues11, 1); UtRegisterTest("PerfTestCounterValues11", PerfTestCounterValues11, 1);
UtRegisterTest("PerfTestAverageQual12", PerfTestAverageQual12, 1);
UtRegisterTest("PerfTestMaxQual13", PerfTestMaxQual13, 1);
return; return;
} }

74
src/counters.h
Unescape Escape View File

@ -11,32 +11,7 @@
/* Time interval at which the mgmt thread o/p the stats */ /* Time interval at which the mgmt thread o/p the stats */
#define MGMTT_TTS 8 #define MGMTT_TTS 8
/* These 2 macros can only be used when all the registered counters for the tm, /* Type of counter */
* are in the counter array */
#define PerfCounterIncr(id, pca) do { \
if (!pca) { \
printf("counterarray is NULL\n"); \
break; \
} \
if ((id < 1) || (id > pca->size)) { \
printf("counter doesn't exist\n"); \
break; \
} \
pca->head[id].cnt++; \
} while(0)
#define PerfCounterAdd(id, pca, x) do { \
if (!pca) { \
printf("counterarray is NULL\n"); \
break; \
} \
if ((id < 1) || (id > pca->size)) { \
printf("counter doesn't exist\n"); \
break; \
} \
pca->head[id].cnt += x; \
} while(0)
enum { enum {
TYPE_UINT64, TYPE_UINT64,
TYPE_DOUBLE, TYPE_DOUBLE,
@ -44,6 +19,16 @@ enum {
TYPE_MAX, TYPE_MAX,
}; };
/* Qualifier for the counter */
enum {
TYPE_Q_NONE = 0x01,
TYPE_Q_AVERAGE = 0x02,
TYPE_Q_MAXIMUM = 0x04,
TYPE_Q_TIMEBASED = 0x08,
TYPE_Q_MAX = 0x10,
};
/* Output interfaces */
enum { enum {
IFACE_FILE, IFACE_FILE,
IFACE_CONSOLE, IFACE_CONSOLE,
@ -54,7 +39,7 @@ enum {
typedef struct _PerfCounterName { typedef struct _PerfCounterName {
char *cname; char *cname;
char *tm_name; char *tm_name;
int tid; pthread_t tid;
} PerfCounterName; } PerfCounterName;
typedef struct _PerfCounterValue { typedef struct _PerfCounterValue {
@ -69,13 +54,19 @@ typedef struct _PerfCounter {
PerfCounterValue *value; PerfCounterValue *value;
/* local id for this counter in this tm*/ /* local id for this counter in this tm*/
pthread_t id; u_int64_t id;
char *desc; char *desc;
/* no of times the local counter has been synced with this counter */ /* no of times the local counter has been synced with this counter */
u_int64_t updated; u_int64_t updated;
/* flag that indicates if this counter should be displayed or not */
int disp;
/* counter qualifier */
int type_q;
/* the next perfcounter for this tv's tm instance */ /* the next perfcounter for this tv's tm instance */
struct _PerfCounter *next; struct _PerfCounter *next;
} PerfCounter; } PerfCounter;
@ -94,8 +85,18 @@ typedef struct _PerfContext {
/* PerfCounterArray(PCA) Node*/ /* PerfCounterArray(PCA) Node*/
typedef struct _PCAElem { typedef struct _PCAElem {
u_int32_t id; PerfCounter *pc;
u_int64_t cnt; u_int64_t id;
union {
u_int64_t ui64_cnt;
double d_cnt;
};
/* no of times the local counter has been updated */
u_int64_t syncs;
/* indicates the times syncs has overflowed */
u_int64_t wrapped_syncs;
} PCAElem; } PCAElem;
/* The PerfCounterArray */ /* The PerfCounterArray */
@ -142,7 +143,18 @@ void * PerfMgmtThread(void *);
void * PerfWakeupThread(void *); void * PerfWakeupThread(void *);
u_int32_t PerfRegisterCounter(char *, char *, int, char *, PerfContext *); u_int32_t PerfRegisterCounter(char *, char *, int, char *, PerfContext *, int,
int);
inline void PerfCounterIncr(u_int64_t, PerfCounterArray *);
inline void PerfCounterAddUI64(u_int64_t, PerfCounterArray *, u_int64_t);
inline void PerfCounterAddDouble(u_int64_t, PerfCounterArray *, double);
inline void PerfCounterSetUI64(u_int64_t, PerfCounterArray *, u_int64_t);
inline void PerfCounterSetDouble(u_int64_t, PerfCounterArray *, double);
void PerfAddToClubbedTMTable(char *, PerfContext *); void PerfAddToClubbedTMTable(char *, PerfContext *);

13
src/detect.c
Unescape Escape View File

@ -578,10 +578,21 @@ int Detect(ThreadVars *t, Packet *p, void *data, PacketQueue *pq) {
if (r >= 0) { if (r >= 0) {
return 0; return 0;
} }
// PerfCounterIncr(COUNTER_DETECT_ALERTS, t->pca);
return 1; return 1;
} }
int DetectThreadInit(ThreadVars *t, void *initdata, void **data) { int DetectThreadInit(ThreadVars *t, void *initdata, void **data)
{
PerfRegisterCounter("detect.alert", "Detect", TYPE_UINT64, "NULL",
&t->pctx, TYPE_Q_NONE, 1);
t->pca = PerfGetAllCountersArray(&t->pctx);
PerfAddToClubbedTMTable("Detect", &t->pctx);
return PatternMatcherThreadInit(t,initdata,data); return PatternMatcherThreadInit(t,initdata,data);
} }

2
src/detect.h
Unescape Escape View File

@ -6,6 +6,8 @@
#include "util-hash.h" #include "util-hash.h"
#include "util-hashlist.h" #include "util-hashlist.h"
#define COUNTER_DETECT_ALERTS 1
/* /*
* DETECT ADDRESS * DETECT ADDRESS
*/ */

37
src/source-nfq.c
Unescape Escape View File

@ -108,7 +108,7 @@ void TmModuleVerdictNFQRegister (void) {
void TmModuleDecodeNFQRegister (void) { void TmModuleDecodeNFQRegister (void) {
tmm_modules[TMM_DECODENFQ].name = "DecodeNFQ"; tmm_modules[TMM_DECODENFQ].name = "DecodeNFQ";
tmm_modules[TMM_DECODENFQ].Init = NULL; tmm_modules[TMM_DECODENFQ].Init = DecodeNFQThreadInit;
tmm_modules[TMM_DECODENFQ].Func = DecodeNFQ; tmm_modules[TMM_DECODENFQ].Func = DecodeNFQ;
tmm_modules[TMM_DECODENFQ].ExitPrintStats = NULL; tmm_modules[TMM_DECODENFQ].ExitPrintStats = NULL;
tmm_modules[TMM_DECODENFQ].Deinit = NULL; tmm_modules[TMM_DECODENFQ].Deinit = NULL;
@ -460,6 +460,9 @@ int DecodeNFQ(ThreadVars *t, Packet *p, void *data, PacketQueue *pq)
printf("DecodeNFQ\n"); printf("DecodeNFQ\n");
#endif #endif
PerfCounterIncr(COUNTER_DECODER_PKTS, t->pca);
PerfCounterAddUI64(COUNTER_DECODER_BYTES, t->pca, p->pktlen);
if (IPV4_GET_RAW_VER(ip4h) == 4) { if (IPV4_GET_RAW_VER(ip4h) == 4) {
printf("DecodeNFQ ip4\n"); printf("DecodeNFQ ip4\n");
DecodeIPV4(t, p, p->pkt, p->pktlen, pq); DecodeIPV4(t, p, p->pkt, p->pktlen, pq);
@ -473,5 +476,37 @@ int DecodeNFQ(ThreadVars *t, Packet *p, void *data, PacketQueue *pq)
return 0; return 0;
} }
int DecodeNFQThreadInit(ThreadVars *tv, void *initdata, void **data)
{
PerfRegisterCounter("decoder.pkts", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.bytes", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ipv4", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ipv6", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ethernet", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.sll", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.tcp", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.udp", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.icmpv4", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.icmpv6", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ppp", "DecodeNFQ", TYPE_UINT64, "NULL",
&tv->pctx, TYPE_Q_NONE, 1);
tv->pca = PerfGetAllCountersArray(&tv->pctx);
PerfAddToClubbedTMTable("DecodeNFQ", &tv->pctx);
return 0;
}
#endif /* NFQ */ #endif /* NFQ */

24
src/source-pcap-file.c
Unescape Escape View File

@ -166,7 +166,7 @@ int ReceivePcapFileThreadDeinit(ThreadVars *tv, void *data) {
int DecodePcapFile(ThreadVars *t, Packet *p, void *data, PacketQueue *pq) int DecodePcapFile(ThreadVars *t, Packet *p, void *data, PacketQueue *pq)
{ {
PerfCounterIncr(COUNTER_DECODER_PKTS, t->pca); PerfCounterIncr(COUNTER_DECODER_PKTS, t->pca);
PerfCounterAdd(COUNTER_DECODER_BYTES, t->pca, p->pktlen); PerfCounterAddUI64(COUNTER_DECODER_BYTES, t->pca, p->pktlen);
/* call the decoder */ /* call the decoder */
pcap_g.Decoder(t,p,p->pkt,p->pktlen,pq); pcap_g.Decoder(t,p,p->pkt,p->pktlen,pq);
@ -176,27 +176,27 @@ int DecodePcapFile(ThreadVars *t, Packet *p, void *data, PacketQueue *pq)
int DecodePcapFileThreadInit(ThreadVars *tv, void *initdata, void **data) int DecodePcapFileThreadInit(ThreadVars *tv, void *initdata, void **data)
{ {
PerfRegisterCounter("decoder.pkts", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.pkts", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.bytes", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.bytes", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ipv4", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.ipv4", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ipv6", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.ipv6", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ethernet", "DecodePcapFile", TYPE_UINT64, PerfRegisterCounter("decoder.ethernet", "DecodePcapFile", TYPE_UINT64,
"NULL", &tv->pctx); "NULL", &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.sll", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.sll", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.tcp", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.tcp", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.udp", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.udp", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.icmpv4", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.icmpv4", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.icmpv6", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.icmpv6", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ppp", "DecodePcapFile", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.ppp", "DecodePcapFile", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
tv->pca = PerfGetAllCountersArray(&tv->pctx); tv->pca = PerfGetAllCountersArray(&tv->pctx);

24
src/source-pcap.c
Unescape Escape View File

@ -286,7 +286,7 @@ int ReceivePcapThreadDeinit(ThreadVars *tv, void *data) {
int DecodePcap(ThreadVars *t, Packet *p, void *data, PacketQueue *pq) int DecodePcap(ThreadVars *t, Packet *p, void *data, PacketQueue *pq)
{ {
PerfCounterIncr(COUNTER_DECODER_PKTS, t->pca); PerfCounterIncr(COUNTER_DECODER_PKTS, t->pca);
PerfCounterAdd(COUNTER_DECODER_BYTES, t->pca, p->pktlen); PerfCounterAddUI64(COUNTER_DECODER_BYTES, t->pca, p->pktlen);
/* call the decoder */ /* call the decoder */
switch(p->pcap_v.datalink) { switch(p->pcap_v.datalink) {
@ -310,27 +310,27 @@ int DecodePcap(ThreadVars *t, Packet *p, void *data, PacketQueue *pq)
int DecodePcapThreadInit(ThreadVars *tv, void *initdata, void **data) int DecodePcapThreadInit(ThreadVars *tv, void *initdata, void **data)
{ {
PerfRegisterCounter("decoder.pkts", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.pkts", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.bytes", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.bytes", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ipv4", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.ipv4", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ipv6", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.ipv6", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ethernet", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.ethernet", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.sll", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.sll", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.tcp", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.tcp", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.udp", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.udp", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.icmpv4", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.icmpv4", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.icmpv6", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.icmpv6", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
PerfRegisterCounter("decoder.ppp", "DecodePcap", TYPE_UINT64, "NULL", PerfRegisterCounter("decoder.ppp", "DecodePcap", TYPE_UINT64, "NULL",
&tv->pctx); &tv->pctx, TYPE_Q_NONE, 1);
tv->pca = PerfGetAllCountersArray(&tv->pctx); tv->pca = PerfGetAllCountersArray(&tv->pctx);

11
src/stream-tcp.c
Unescape Escape View File

@ -31,6 +31,7 @@
#include "stream-tcp-reassemble.h" #include "stream-tcp-reassemble.h"
#include "stream.h" #include "stream.h"
#include "stream-tcp.h"
int StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *); int StreamTcp (ThreadVars *, Packet *, void *, PacketQueue *);
int StreamTcpThreadInit(ThreadVars *, void *, void **); int StreamTcpThreadInit(ThreadVars *, void *, void **);
@ -980,6 +981,8 @@ int StreamTcp (ThreadVars *tv, Packet *p, void *data, PacketQueue *pq)
{ {
StreamTcpThread *stt = (StreamTcpThread *)data; StreamTcpThread *stt = (StreamTcpThread *)data;
//PerfCounterAddUI64(COUNTER_STREAMTCP_STREAMS, tv->pca, a);
if (!(PKT_IS_TCP(p))) if (!(PKT_IS_TCP(p)))
return 0; return 0;
@ -1017,6 +1020,14 @@ int StreamTcpThreadInit(ThreadVars *t, void *initdata, void **data)
/* XXX */ /* XXX */
*data = (void *)stt; *data = (void *)stt;
PerfRegisterCounter("streamTcp.tcp_streams", "StreamTcp", TYPE_DOUBLE, "NULL",
&t->pctx, TYPE_Q_AVERAGE, 1);
t->pca = PerfGetAllCountersArray(&t->pctx);
PerfAddToClubbedTMTable("StreamTcp", &t->pctx);
return 0; return 0;
} }

2
src/stream-tcp.h
Unescape Escape View File

@ -3,6 +3,8 @@
#ifndef __STREAM_TCP_H__ #ifndef __STREAM_TCP_H__
#define __STREAM_TCP_H__ #define __STREAM_TCP_H__
#define COUNTER_STREAMTCP_STREAMS 1
void TmModuleStreamTcpRegister (void); void TmModuleStreamTcpRegister (void);
#endif /* __STREAM_TCP_H__ */ #endif /* __STREAM_TCP_H__ */

Write Preview
Loading…
Cancel
Save