VarTableModel::VarTableModel(QObject *parent, estats_nl_client *nl_client, int cid)
: EstatsTableModel(parent, nl_client)
{
this->cid = cid;
this->nl_client = nl_client;
estats::Check(estats_val_data_new(&newdata));
estats::Check(estats_val_data_new(&olddata));
estats::Check(estats_val_data_new(&deldata));
initialize();
}
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;
}
/** 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;
struct estats_nl_client* cl = NULL;
estats_val_data* data = NULL; // TODO(aka) currently not used
// The MIB is generated in the DLKM with the following code:
/*
hdr = genlmsg_put(msg, 0, 0, &genl_estats_family, 0, TCPE_CMD_INIT);
if (nla_put_u32(msg, NLE_ATTR_NUM_TABLES, MAX_TABLE))
if (nla_put_u32(msg, NLE_ATTR_NUM_VARS, TOTAL_NUM_VARS))
for (tblnum = 0; tblnum < MAX_TABLE; tblnum++) {
switch (tblnum) {
case PERF_TABLE:
nest[tblnum] = nla_nest_start(msg,
NLE_ATTR_PERF_VARS | NLA_F_NESTED);
break;
case PATH_TABLE:
nest[tblnum] = nla_nest_start(msg,
NLE_ATTR_PATH_VARS | NLA_F_NESTED);
break;
case STACK_TABLE:
nest[tblnum] = nla_nest_start(msg,
NLE_ATTR_STACK_VARS | NLA_F_NESTED);
break;
case APP_TABLE:
nest[tblnum] = nla_nest_start(msg,
NLE_ATTR_APP_VARS | NLA_F_NESTED);
break;
case TUNE_TABLE:
nest[tblnum] = nla_nest_start(msg,
NLE_ATTR_TUNE_VARS | NLA_F_NESTED);
break;
case EXTRAS_TABLE:
nest[tblnum] = nla_nest_start(msg,
NLE_ATTR_EXTRAS_VARS | NLA_F_NESTED);
break;
}
if (!nest[tblnum])
goto nla_put_failure;
for (i=0; i < estats_max_index[tblnum]; i++) {
entry_nest = nla_nest_start(msg,
NLE_ATTR_VAR | NLA_F_NESTED);
if (nla_put_string(msg, NEA_VAR_NAME,
estats_var_array[tblnum][i].name))
goto nla_put_failure;
if (nla_put_u32(msg, NEA_VAR_TYPE,
estats_var_array[tblnum][i].vartype))
goto nla_put_failure;
nla_nest_end(msg, entry_nest);
}
nla_nest_end(msg, nest[tblnum]);
}
genlmsg_end(msg, hdr);
*/
Chk(estats_nl_client_init(&cl));
Chk(estats_val_data_new(&data));
Chk(estats_get_mib(data, cl)); // the MIB is printed out in estats_get_mib()
Cleanup:
estats_val_data_free(&data);
estats_nl_client_destroy(&cl);
if (err != NULL) {
PRINT_AND_FREE(err);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
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;
}
