void*
snapWorker(void* arg) {
/* WARNING void* arg (workerArgs) is on the stack of the function below and
* doesn't exist forever. */
WorkerArgs *workerArgs = (WorkerArgs*) arg;
SnapArgs *snapArgs = workerArgs->snapArgs;
tcp_stat_agent* agent = workerArgs->agent;
CwndPeaks* peaks = workerArgs->peaks;
int writeSnap = workerArgs->writeSnap;
// snap log written into every "delay" milliseconds
double delay = ((double) snapArgs->delay) / 1000.0;
while (1) {
pthread_mutex_lock(&mainmutex);
if (workerLoop) {
pthread_cond_broadcast(&maincond);
pthread_mutex_unlock(&mainmutex);
break;
}
pthread_mutex_unlock(&mainmutex);
mysleep(0.01);
}
// Find Congestion window peaks from a web_100 snapshot, if enabled
// Write snap log , if enabled, all in a synchronous manner.
while (1) {
pthread_mutex_lock(&mainmutex);
if (!workerLoop) {
pthread_mutex_unlock(&mainmutex);
break;
}
#if USE_WEB100
web100_snap(snapArgs->snap);
if (peaks) {
findCwndPeaks(agent, peaks, snapArgs->snap);
}
if (writeSnap) {
web100_log_write(snapArgs->log, snapArgs->snap);
}
#elif USE_WEB10G
estats_read_vars(snapArgs->snap, snapArgs->conn, agent);
if (peaks) {
findCwndPeaks(agent, peaks, snapArgs->snap);
}
if (writeSnap) {
estats_record_write_data(snapArgs->log, snapArgs->snap);
}
#endif
pthread_mutex_unlock(&mainmutex);
mysleep(delay);
}
return NULL;
}
int main(int argc, char **argv)
{
estats_error* err = NULL;
struct estats_nl_client* cl = NULL;
estats_val_data* data = NULL;
estats_record* record = NULL;
estats_val val;
char* str;
int cid, i, j;
struct estats_connection_tuple_ascii tuple_ascii;
if (argc < 2) {
usage();
exit(EXIT_FAILURE);
}
cid = atoi(argv[1]);
Chk(estats_nl_client_init(&cl));
Chk(estats_val_data_new(&data));
Chk(estats_record_open(&record, "./test-record", "w"));
Chk(estats_read_vars(data, cid, cl));
printf("Timestamp sec: %u, usec: %u\n", data->tv.sec, data->tv.usec);
Chk(estats_connection_tuple_as_strings(&tuple_ascii, &data->tuple));
printf("Address: %s %s %s %s\n", tuple_ascii.local_addr, tuple_ascii.local_port, tuple_ascii.rem_addr, tuple_ascii.rem_port);
for (i = 0; i < data->length; i++) {
Chk(estats_val_as_string(&str, &data->val[i], estats_var_array[i].valtype));
printf("%s: %s\n", estats_var_array[i].name, str);
free(str);
}
Chk(estats_record_write_data(record, data));
Cleanup:
estats_val_data_free(&data);
estats_record_close(&record);
estats_nl_client_destroy(&cl);
if (err != NULL) {
PRINT_AND_FREE(err);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
void VarTableModel::update()
{
static int first_update = 1;
quint32 index = 0;
estats_val_data* tmp;
estats::Check(estats_read_vars(newdata, cid, nl_client));
for (int i = 0; i < newdata->length; i++) {
ESTATS_VAL_TYPE valtype = estats_var_array[i].valtype;
ESTATS_TYPE type = estats_var_array[i].type;
char* valstr;
estats::Check(estats_val_as_string(&valstr, &newdata->val[i], valtype));
QStandardItem* item = new QStandardItem(valstr);
// QStandardItem* item = new QStandardItem(newdata->val[i]);
setItem(index, 1, item);
free((void*)valstr);
if (!first_update && (type == ESTATS_TYPE_COUNTER32 || type == ESTATS_TYPE_COUNTER64)) {
estats::Check(estats_val_data_delta(deldata, newdata, olddata));
estats::Check(estats_val_as_string(&valstr, &deldata->val[i], valtype));
QStandardItem* item = new QStandardItem(valstr);
// QStandardItem* item = new QStandardItem(QString::number(deldata->val[i]));
setItem(index, 2, item);
free((void*)valstr);
}
index++;
}
tmp = olddata;
olddata = newdata;
newdata = tmp;
if (first_update) first_update = 0;
}
/** Method to start snap worker thread that collects snap logs
* @param snaparg object
* @param tcp_stat_agent Agent
* @param snaplogenabled Is snap logging enabled?
* @param workerlooparg integer used to syncronize writing/reading from snaplog/tcp_stat snapshot
* @param wrkrthreadidarg Thread Id of workera
* @param metafilename value of metafile name
* @param tcp_stat_connection connection pointer
* @param tcp_stat_group group web100_group pointer
*/
void start_snap_worker(SnapArgs *snaparg, tcp_stat_agent* agentarg,
CwndPeaks* peaks, char snaplogenabled,
pthread_t *wrkrthreadidarg, char *metafilename,
tcp_stat_connection conn, tcp_stat_group* group) {
FILE *fplocal;
WorkerArgs workerArgs;
workerArgs.snapArgs = snaparg;
workerArgs.agent = agentarg;
workerArgs.peaks = peaks;
workerArgs.writeSnap = snaplogenabled;
#if USE_WEB100
group = web100_group_find(agentarg, "read");
snaparg->snap = web100_snapshot_alloc(group, conn);
#elif USE_WEB10G
snaparg->conn = conn;
estats_val_data_new(&snaparg->snap);
#endif
if (snaplogenabled) {
// memcpy(metafilevariablename, metafilename, strlen(metafilename));
// The above could have been here, except for a caveat: metafile stores
// just the file name, but full filename is needed to open the log file
fplocal = fopen(get_logfile(), "a");
#if USE_WEB100
snaparg->log = web100_log_open_write(metafilename, conn, group);
#elif USE_WEB10G
estats_record_open(&snaparg->log, metafilename, "w");
#endif
if (fplocal == NULL) {
log_println(
0,
"Unable to open log file '%s', continuing on without logging",
get_logfile());
} else {
log_println(1, "Snaplog file: %s\n", metafilename);
fprintf(fplocal, "Snaplog file: %s\n", metafilename);
fclose(fplocal);
}
}
if (pthread_create(wrkrthreadidarg, NULL, snapWorker,
(void*) &workerArgs)) {
log_println(1, "Cannot create worker thread for writing snap log!");
*wrkrthreadidarg = 0;
}
pthread_mutex_lock(&mainmutex);
workerLoop= 1;
// obtain web100 snap into "snaparg.snap"
#if USE_WEB100
web100_snap(snaparg->snap);
if (snaplogenabled) {
web100_log_write(snaparg->log, snaparg->snap);
}
#elif USE_WEB10G
estats_read_vars(snaparg->snap, conn, agentarg);
if (snaplogenabled) {
estats_record_write_data(snaparg->log, snaparg->snap);
}
#endif
pthread_cond_wait(&maincond, &mainmutex);
pthread_mutex_unlock(&mainmutex);
}
int main(int argc, char **argv)
{
estats_error* err = NULL;
estats_nl_client* cl = NULL;
estats_val_data* data = NULL;
int cid, i, j;
int opt, option;
int stdout_flag = 0;
int header_flag = 0;
int interval = 1000;
char *strmask = NULL;
const char delim = ',';
uint64_t tmpmask;
struct estats_mask mask;
mask.masks[0] = DEFAULT_PERF_MASK;
mask.masks[1] = DEFAULT_PATH_MASK;
mask.masks[2] = DEFAULT_STACK_MASK;
mask.masks[3] = DEFAULT_APP_MASK;
mask.masks[4] = DEFAULT_TUNE_MASK;
for (i = 0; i < MAX_TABLE; i++) {
mask.if_mask[i] = 0;
}
if (argc < 2) {
usage();
exit(EXIT_FAILURE);
}
while ((opt = getopt(argc, argv, "hm:si:")) != -1) {
switch (opt) {
case 'h':
usage();
exit(EXIT_SUCCESS);
break;
case 'm':
strmask = strdup(optarg);
for (j = 0; j < 5; j++) {
char *strtmp;
strtmp = strsep(&strmask, &delim);
if (strtmp && strlen(strtmp)) {
char *str;
str = (str = strchr(strtmp, 'x')) ? str+1 : strtmp;
if (sscanf(str, "%"PRIx64, &tmpmask) == 1) {
mask.masks[j] = tmpmask & mask.masks[j];
mask.if_mask[j] = 1;
}
}
}
option = opt;
break;
case 's':
stdout_flag = 1;
break;
case 'i':
interval = atoi(optarg);
break;
default:
exit(EXIT_FAILURE);
break;
}
}
if ((option == 'm') && (optind+1 > argc)) {
printf("Too few non-option args\n");
exit(EXIT_FAILURE);
}
cid = atoi(argv[optind]);
Chk(estats_nl_client_init(&cl));
Chk(estats_nl_client_set_mask(cl, &mask));
Chk(estats_val_data_new(&data));
while (1) {
Chk(estats_read_vars(data, cid, cl));
if ((stdout_flag) && (!header_flag)) {
printf("sec,usec,");
for (j = 0; j < data->length; j++) {
if (data->val[j].masked) continue;
printf("%s\t", estats_var_array[j].name);
}
printf("\n");
header_flag = 1;
}
if (!stdout_flag)
printf("Timestamp sec: %u, usec: %u\n", data->tv.sec, data->tv.usec);
else
printf("%u,%u,", data->tv.sec, data->tv.usec);
for (j = 0; j < data->length; j++) {
if (!stdout_flag) {
if (j == 0)
printf("\n\n Perf Table\n\n");
if (j == PERF_INDEX_MAX)
printf("\n\n Path Table\n\n");
if (j == PERF_INDEX_MAX+PATH_INDEX_MAX)
printf("\n\n Stack Table\n\n");
if (j == PERF_INDEX_MAX+PATH_INDEX_MAX+STACK_INDEX_MAX)
printf("\n\n App Table\n\n");
if (j == PERF_INDEX_MAX+PATH_INDEX_MAX+STACK_INDEX_MAX+APP_INDEX_MAX)
printf("\n\n Tune Table\n\n");
}
if (data->val[j].masked) continue;
/* I could have had an if in each case statement but that seems like
* it would have been much more expensive - cjr
*/
if (!stdout_flag) {
switch(estats_var_array[j].valtype) {
case ESTATS_UNSIGNED64:
printf("%s=%"PRIu64"\n", estats_var_array[j].name, data->val[j].uv64);
break;
case ESTATS_UNSIGNED32:
printf("%s=%"PRIu32"\n", estats_var_array[j].name, data->val[j].uv32);
break;
case ESTATS_SIGNED32:
printf("%s=%"PRId32"\n", estats_var_array[j].name, data->val[j].sv32);
break;
case ESTATS_UNSIGNED16:
printf("%s=%"PRIu16"\n", estats_var_array[j].name, data->val[j].uv16);
break;
case ESTATS_UNSIGNED8:
printf("%s=%"PRIu8"\n", estats_var_array[j].name, data->val[j].uv8);
break;
default:
break;
}
} else {
switch(estats_var_array[j].valtype) {
case ESTATS_UNSIGNED64:
printf("%"PRIu64",", data->val[j].uv64);
break;
case ESTATS_UNSIGNED32:
printf("%"PRIu32",", data->val[j].uv32);
break;
case ESTATS_SIGNED32:
printf("%"PRId32",", data->val[j].sv32);
break;
case ESTATS_UNSIGNED16:
printf("%"PRIu16",", data->val[j].uv16);
break;
case ESTATS_UNSIGNED8:
printf("%"PRIu8",", data->val[j].uv8);
break;
default:
break;
}
}
}
usleep(interval * 1000);
printf("\n");
if (!stdout_flag)
printf("\n");
}
Cleanup:
estats_val_data_free(&data);
estats_nl_client_destroy(&cl);
if (err != NULL) {
PRINT_AND_FREE(err);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
