int store_addressrange(sstr * str, struct in_addr *addr, struct in_addr *msk)
{
sstr *tok;
int sep, i;
tok = sstr_init(0);
sep = sstr_token(str, tok, " /->\r\n", 0);
if(name2addr(tok, addr)==-1) return(-1);
if (sep == '/') {
sep = sstr_token(str, tok, " /->\r\n", 0);
if (sstr_chr(tok, '.')==-1) { /* x.x.x.x/yy */
i = sstr_atoi(tok);
msk->s_addr = htonl(0xFFFFFFFF << (32 - i));
} else
if(name2addr(tok, msk)==-1) return(-1);
} else { /*No mask given */
if (addr->s_addr == INADDR_ANY)
msk->s_addr = INADDR_ANY;
else
msk->s_addr = INADDR_BROADCAST;
}
sstr_free(tok);
return (0);
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION core44xx_name2addr
* @BRIEF retrieve physical address of a register, given its name.
* @RETURNS 0 in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_REG_ACCESS
* @param[in] name: register name
* @param[in,out] addr: register address
* @DESCRIPTION retrieve physical address of a register, given its name.
*//*------------------------------------------------------------------------ */
int core44xx_name2addr(char *name, unsigned int *addr)
{
CHECK_CPU(44xx, OMAPCONF_ERR_CPU);
if (!init_done)
core44xx_regtable_init();
return name2addr(name, addr, prcm_core_reg_table);
}
int u_comparehost(u_buf_t *ubufp, char *hostn, u_port_t port) {
in_addr_t addr;
struct sockaddr_in *remotep;
remotep = (struct sockaddr_in *)ubufp;
if ((port != ntohs(remotep->sin_port)) ||
(name2addr(hostn, &addr) == -1) ||
(memcmp(&(remotep->sin_addr.s_addr), &addr, sizeof(in_addr_t)) != 0))
return 0;
return 1;
}
ssize_t u_sendtohost(int fd, void *buf, size_t nbytes, char *hostn,
u_port_t port) {
struct sockaddr_in remote;
if (name2addr(hostn, &(remote.sin_addr.s_addr)) == -1) {
errno = EINVAL;
return -1;
}
remote.sin_port = htons((short)port);
remote.sin_family = AF_INET;
return u_sendto(fd, buf, nbytes, &remote);
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION sr44xx_name2addr
* @BRIEF retrieve physical address of a register, given its name.
* @RETURNS 0 in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_NOT_AVAILABLE
* @param[in] name: register name
* @param[in,out] addr: register address
* @DESCRIPTION retrieve physical address of a register, given its name.
*//*------------------------------------------------------------------------ */
int sr44xx_name2addr(char *name, unsigned int *addr)
{
int ret;
if (!cpu_is_omap44xx())
return OMAPCONF_ERR_CPU;
if (!init_done)
sr44xx_regtable_init();
ret = name2addr(name, addr, prcm_sr_vc_reg_table);
if (ret == 0)
return ret;
ret = name2addr(name, addr, prcm_sr_vp_mpu_reg_table);
if (ret == 0)
return ret;
ret = name2addr(name, addr, prcm_sr_vp_iva_reg_table);
if (ret == 0)
return ret;
ret = name2addr(name, addr, prcm_sr_vp_core_reg_table);
if (ret == 0)
return ret;
/*
* This function is called on a "omapconf read 'by name'"
* If name is found, then read access will be done.
* In the case of SR, module may be disabled so access will fail.
* Return OMAPCONF_ERR_REG_ACCESS if register not available.
*/
ret = name2addr(name, addr, prcm_sr_mpu_reg_table);
if (ret == 0) {
if (mod44xx_is_accessible(OMAP4_SMARTREFLEX_MPU) == 1)
return 0;
else
return OMAPCONF_ERR_NOT_AVAILABLE;
}
ret = name2addr(name, addr, prcm_sr_iva_reg_table);
if (ret == 0) {
if (mod44xx_is_accessible(OMAP4_SMARTREFLEX_IVA) == 1)
return 0;
else
return OMAPCONF_ERR_NOT_AVAILABLE;
}
ret = name2addr(name, addr, prcm_sr_core_reg_table);
if (ret == 0) {
if (mod44xx_is_accessible(OMAP4_SMARTREFLEX_CORE) == 1)
return 0;
else
return OMAPCONF_ERR_NOT_AVAILABLE;
}
return OMAPCONF_ERR_NOT_AVAILABLE;
}
/*
* u_connect
* Initiate communication with a remote server.
*
* parameters:
* port = well-known port on remote server
* hostn = character string giving the Internet name of remote host
* returns: a communication file descriptor if successful
* -1 on error with errno set
*/
int u_connect(u_port_t port, char *hostn) {
int error;
int retval;
struct sockaddr_in server;
int sock;
fd_set sockset;
if (name2addr(hostn,&(server.sin_addr.s_addr)) == -1) {
errno = EINVAL;
return -1;
}
server.sin_port = htons((short)port);
server.sin_family = AF_INET;
if ((u_ignore_sigpipe() == -1) ||
((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1))
return -1;
if (((retval =
connect(sock, (struct sockaddr *)&server, sizeof(server))) == -1) &&
((errno == EINTR) || (errno == EALREADY))) {
FD_ZERO(&sockset);
FD_SET(sock, &sockset);
while ( ((retval = select(sock+1, NULL, &sockset, NULL, NULL)) == -1) &&
(errno == EINTR) ) {
FD_ZERO(&sockset);
FD_SET(sock, &sockset);
}
}
if (retval == -1) {
error = errno;
while ((close(sock) == -1) && (errno == EINTR));
errno = error;
return -1;
}
return sock;
}
/**
* Function: counters44xx_perf
* Role: trace OMAP performance (CPU Load, OPP & memory bandwidth usage).
* Parameters:
* capture_time: capture (trace) duration
* Return:
* 0 in case of success
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_NOT_AVAILABLE
* OMAPCONF_ERR_UNEXPECTED
*/
int counters44xx_count(unsigned int capture_time)
{
unsigned int i;
unsigned int sample_cnt;
int ret;
unsigned int addr, data, l2_disabled_prior = 0;
unsigned int *trace_buf[TRACE_CFG_ENABLED_OPTIONS_MAX];
unsigned short emif;
unsigned int sample;
FILE *fp = NULL;
char s[16];
char table[TABLE_MAX_ROW][TABLE_MAX_COL][TABLE_MAX_ELT_LEN];
unsigned int row = 0;
char name[64];
char tmp_name[64];
char option[64];
unsigned int temp, avg, min, max;
/* Configure EMIF counters */
ret = 0;
if (trace_state[TRACE_CFG_EMIF0_CNT0_FILTER] >= 0)
ret = emif44xx_perf_cnt_configure(EMIF44XX_0, 0,
trace_state[TRACE_CFG_EMIF0_CNT0_FILTER],
trace_state[TRACE_CFG_EMIF0_CNT0_ID],
trace_state[TRACE_CFG_EMIF0_CNT0_ADDRSPACE]);
if (trace_state[TRACE_CFG_EMIF1_CNT0_FILTER] >= 0)
ret |= emif44xx_perf_cnt_configure(EMIF44XX_1, 0,
trace_state[TRACE_CFG_EMIF1_CNT0_FILTER],
trace_state[TRACE_CFG_EMIF1_CNT0_ID],
trace_state[TRACE_CFG_EMIF1_CNT0_ADDRSPACE]);
if (trace_state[TRACE_CFG_EMIF0_CNT1_FILTER] >= 0)
ret |= emif44xx_perf_cnt_configure(EMIF44XX_0, 1,
trace_state[TRACE_CFG_EMIF0_CNT1_FILTER],
trace_state[TRACE_CFG_EMIF0_CNT1_ID],
trace_state[TRACE_CFG_EMIF0_CNT1_ADDRSPACE]);
if (trace_state[TRACE_CFG_EMIF1_CNT1_FILTER] >= 0)
ret |= emif44xx_perf_cnt_configure(EMIF44XX_1, 1,
trace_state[TRACE_CFG_EMIF1_CNT1_FILTER],
trace_state[TRACE_CFG_EMIF1_CNT1_ID],
trace_state[TRACE_CFG_EMIF1_CNT1_ADDRSPACE]);
if (ret != 0) {
fprintf(stderr, "%s(): error while configuring EMIF perf. "
"counters!\n", __func__);
ret = OMAPCONF_ERR_NOT_AVAILABLE;
goto counters44xx_count_err;
}
/* Configure L2CC counters */
/* Do this regardless whether enabled or disabled (at this point.) */
if (trace_state[TRACE_CFG_L2CC_CNT0_FILTER] >= 0)
ret = l2cc44xx_perf_cnt_configure(0, trace_state[TRACE_CFG_L2CC_CNT0_FILTER], 1); /* for last entry, should use boolean 'true' */
if (trace_state[TRACE_CFG_L2CC_CNT1_FILTER] >= 0)
ret = l2cc44xx_perf_cnt_configure(1, trace_state[TRACE_CFG_L2CC_CNT1_FILTER], 1); /* for last entry, should use boolean 'true' */
/*
// if (ret != 0) {
// fprintf(stderr, "%s(): error while configuring L2CC perf. "
// "counters!\n", __func__);
// ret = OMAPCONF_ERR_NOT_AVAILABLE;
// goto counters44xx_count_err;
// }
*/
/* Allocate buffer to store sampled data, unless continuous capture is enabled */
if (capture_time > 0) {
if (sampling_rate > 0) {
sample_cnt = 1 + ((capture_time * 1000) / sampling_rate);
} else {
/* If smaple rate of 0, trace as fast as possible for the capture time. */
sample_cnt = 1 + ((capture_time * 1000));
}
} else {
/* Hack. If capture_time == 0, capture continuous. Need room for at least 2 samples. */
sample_cnt = 2;
if (trace_state[TRACE_CFG_LONG_HEADER] == 1) {
printf("#\n");
printf("# ----------------- OMAP4430 Performance Trace+ ----------"
"--------------------------------------------------------------"
"-----\n");
printf("#\n");
/* printf("# NB:\n"); */
printf("# * This is an intrusive trace (counters polling).\n");
printf("# Idle C-States usage was altered.\n");
printf("# Limted additional CPU & EMIFs loads generated.\n");
printf("#\n");
/* printf("# * If CPU1 Load = -5.0, it means CPU1 is OFFLINE.\n"); */
/* printf("#\n"); */
/* printf("# * CPU LOADS CANNOT be directly converted to Mhz.\n"); */
/* printf("# OPP may have changed during the audit.\n"); */
/* printf("#\n"); */
printf("# ----------------------- Trace FORMAT -------------------"
"--------------------------------------------------------------"
"-----\n");
printf("#\n");
printf("# Trace Length: %us\n", capture_time);
printf("#\n");
printf("# Trace Sampling Rate: %ums\n",
sampling_rate);
printf("#\n");
printf("# Number of samples: %u\n", sample_cnt - 1);
printf("#\n");
printf("# %10.10s ", "Timestamp(s)");
};
for (i = 0; i < TRACE_CFG_ENABLED_OPTIONS_MAX; i++) {
if (trace_state[i] >= 0) {/* Traces state is enabled if non-zero state value. */
ret = value2name(i, name, trace_config_options_table);
printf("\t%10.10s", name);
switch (i) {
case TRACE_CFG_EMIF0_CNT0_FILTER:
case TRACE_CFG_EMIF1_CNT0_FILTER:
case TRACE_CFG_EMIF0_CNT1_FILTER:
case TRACE_CFG_EMIF1_CNT1_FILTER:
ret = value2name(trace_state[i], name, emif_event_counters);
ret = snprintf(tmp_name, 64, "%s%s", ".", name);
ret = snprintf(name, 64, "%s", tmp_name);
break;
case TRACE_CFG_L2CC_CNT0_FILTER:
case TRACE_CFG_L2CC_CNT1_FILTER:
ret = value2name(trace_state[i], name, l2cc_event_counters_table);
ret = snprintf(tmp_name, 64, "%s%s", ".", name);
ret = snprintf(name, 64, "%s", tmp_name);
break;
default:
strcpy(name, " ");
break;
} /* end switch */
printf("%s ", name);
}
}
printf("\n");
if (trace_state[TRACE_CFG_LONG_HEADER] == 1) {
printf("#\n");
printf("# ----------------------- Trace START --------------------"
"--------------------------------------------------------------"
"-----\n");
}
}
dprintf("%s(): capture_time=%us, sample_cnt=%u\n", __func__,
capture_time, sample_cnt);
for (i = 0; i < TRACE_CFG_ENABLED_OPTIONS_MAX; i++) {
if (trace_state[i] >= 0) {/* Traces state is enabled if non-zero state value. */
/* Add three sample entries to hold min, avg, max */
trace_buf[i] = malloc((sample_cnt+3) * sizeof(unsigned int));
if (trace_buf[i] == NULL) {
ret = value2name(i, name, trace_config_options_table);
fprintf(stderr, "%s(): could not allocate %s!\n",
__func__, name);
ret = OMAPCONF_ERR_NOT_AVAILABLE;
goto counters44xx_count_err;
}
}
} /* end for i < TRACE_CFG_ENABLED_OPTIONS_MAX */
/* Enable L2CC counters */
ret = l2cc44xx_perf_cnt_enable();
/* Sample performance indicators periodically */
printf("\n");
printf("Sampling OMAP Counters for %us, please wait...\n",
capture_time);
for (sample = 0; sample < sample_cnt; sample++) {
/*
// This could be a big for loop and 'switch' statemenet...
// Get CPU runtime execution stats
// Get EMIF cnt0, cnt1 & total mclk cycle counts as enabled
// skorson
// Being lazy and doing these two one after the other. I suppose code could be written
// to convert a for 0 to 1 loop but with only two, this is OK.
*/
emif = 0;
if (trace_state[TRACE_CFG_EMIF0_CNT0_FILTER] >= 0) {
trace_buf[TRACE_CFG_EMIF0_CNT0_FILTER][sample] = emif44xx_perf_cnt_get_count(
emif, EMIF44XX_PERF_CNT_0);
dprintf("%s(): EMIF0 counter 0 value=%u\n", __func__,
trace_buf[TRACE_CFG_EMIF0_CNT0_FILTER][sample]);
}
if (trace_state[TRACE_CFG_EMIF0_CNT1_FILTER] >= 0) {
trace_buf[TRACE_CFG_EMIF0_CNT1_FILTER][sample] = emif44xx_perf_cnt_get_count(
emif, EMIF44XX_PERF_CNT_1);
dprintf("%s(): EMIF0 counter 1 value=%u\n", __func__,
trace_buf[TRACE_CFG_EMIF0_CNT1_FILTER][sample]);
}
if (trace_state[TRACE_CFG_EMIF0_MCLK_CYCLES] >= 0) {
trace_buf[TRACE_CFG_EMIF0_MCLK_CYCLES][sample] = emif44xx_perf_cnt_get_time(emif);
}
emif = 1;
if (trace_state[TRACE_CFG_EMIF1_CNT0_FILTER] >= 0) {
trace_buf[TRACE_CFG_EMIF1_CNT0_FILTER][sample] = emif44xx_perf_cnt_get_count(
emif, EMIF44XX_PERF_CNT_0);
dprintf("%s(): EMIF1 counter 0 value=%u\n", __func__,
trace_buf[TRACE_CFG_EMIF1_CNT0_FILTER][sample]);
}
if (trace_state[TRACE_CFG_EMIF1_CNT1_FILTER] >= 0) {
trace_buf[TRACE_CFG_EMIF1_CNT1_FILTER][sample] = emif44xx_perf_cnt_get_count(
emif, EMIF44XX_PERF_CNT_1);
dprintf("%s(): EMIF1 counter 1 value=%u\n", __func__,
trace_buf[TRACE_CFG_EMIF1_CNT1_FILTER][sample]);
}
if (trace_state[TRACE_CFG_EMIF1_MCLK_CYCLES] >= 0) {
trace_buf[TRACE_CFG_EMIF1_MCLK_CYCLES][sample] = emif44xx_perf_cnt_get_time(emif);
dprintf("%s(): EMIF1 MCLK cycles=%u\n", __func__,
trace_buf[TRACE_CFG_EMIF1_MCLK_CYCLES][sample]);
}
/*
// FIXME: There is a bug where the L2 Counters are being disabled. Until this is known, enable the following
// block to determine if the counter has been disabled during a run. Print appropriate ERROR to screen...
*/
if ((trace_state[TRACE_CFG_L2CC_CNT0_FILTER] >= 0) || (trace_state[TRACE_CFG_L2CC_CNT1_FILTER] >= 0)) {
/* check if counter is still enabled.... */
ret = name2addr("EVENT_COUNTER_CONTROL", &addr,
(reg_table *) omap4_mpuss_pl310_reg_table);
ret = mem_read(addr, &data);
dprintf("EVENT COUNTER VALUE: 0x%x 0x%x\n", addr, data);
if (ret != 0) {
fprintf(stderr, "%s(): error reading L2CC (PL310) EVENT_COUNTER_CONTROL reg!\n",
__func__);
return OMAPCONF_ERR_REG_ACCESS;
}
if (data == 0 && l2_disabled_prior == 0) {
l2_disabled_prior = 1;
fprintf(stderr, "%s(): WARNING:L2CC (PL310) EVENT_COUNTER_CONTROL was DISABLED during a run!!!\n",
__func__);
fprintf(stderr, "%s(): WARNING: Counter values will be invalid (zero) after this point.\n",
__func__);
}
}
/* END FIXME */
if (trace_state[TRACE_CFG_L2CC_CNT0_FILTER] >= 0) {
trace_buf[TRACE_CFG_L2CC_CNT0_FILTER][sample] =
(unsigned int) l2cc44xx_get_perf_cnt(0);
dprintf("%s(): l2_event_cnt[0] sample %d = 0x%x %d\n", __func__, sample,
trace_buf[TRACE_CFG_L2CC_CNT0_FILTER][sample], trace_buf[TRACE_CFG_L2CC_CNT0_FILTER][sample]);
}
if (trace_state[TRACE_CFG_L2CC_CNT1_FILTER] >= 0) {
trace_buf[TRACE_CFG_L2CC_CNT1_FILTER][sample] =
(unsigned int) l2cc44xx_get_perf_cnt(1);
dprintf("%s(): l2_event_cnt[1] sample %d = 0x%x %d\n", __func__, sample,
trace_buf[TRACE_CFG_L2CC_CNT1_FILTER][sample], trace_buf[TRACE_CFG_L2CC_CNT1_FILTER][sample]);
}
if (trace_state[TRACE_CFG_TIMER_32K_SYNC] >= 0) {
addr = T32KSYNCNT_CR;
ret = mem_read(addr, &data);
trace_buf[TRACE_CFG_TIMER_32K_SYNC][sample] = data;
dprintf("%s(): 32K CLK cycles=%u\n", __func__,
trace_buf[TRACE_CFG_TIMER_32K_SYNC][sample]);
}
dprintf("\n");
/* Sleep for some [minimum] time before sampling again */
if ((capture_time == 0) && (sample > 0)) {
/* Save timestamp */
printf("[unix time stamp here]");
for (i = 0; i < TRACE_CFG_ENABLED_OPTIONS_MAX; i++) {
if (trace_state[i] >= 0) {
sprintf(s, "%u", count32_delta(trace_buf[i][0],
trace_buf[i][1]));
printf("\t%10.10s", s);
} /* if state >= 0 */
} /* for i to TRACE_CFG_ENABLED_OPTIONS_MAX */
printf("\n");
/* Now move sample[1] to sample[0] */
for (i = 0; i < TRACE_CFG_ENABLED_OPTIONS_MAX; i++) {
if (trace_state[i] >= 0) {
trace_buf[i][0] = trace_buf[i][1];
} /* if state >= 0 */
} /* for i to TRACE_CFG_ENABLED_OPTIONS_MAX */
sample = 0;
}
/* SLeep onyl if a sampling rate is set. */
/* Sampling rate of 0 is as fast as possible... */
if (sampling_rate > 0)
usleep(sampling_rate * 1000);
}
/* Disable L2CC counters */
/* Do regardless of whether enabled for tracing or not. */
ret = l2cc44xx_perf_cnt_disable();
printf("Sampling done, processing and saving data...\n");
/* Open trace output file */
fp = workdir_fopen(trace_perf_file, "w");
if (fp == NULL) {
fprintf(stderr, "%s(): could not create %s!\n",
__func__, trace_perf_file);
ret = OMAPCONF_ERR_NOT_AVAILABLE;
goto counters44xx_count_err;
}
dprintf("INFO: TRACE_CFG_LONG_HEADER %d\n", trace_state[TRACE_CFG_LONG_HEADER]);
if (trace_state[TRACE_CFG_LONG_HEADER] == 1) {
fprintf(fp, "#\n");
fprintf(fp, "# ----------------- OMAP4430 Performance Trace+ ----------"
"--------------------------------------------------------------"
"-----\n");
fprintf(fp, "#\n");
/* fprintf(fp, "# NB:\n"); */
fprintf(fp, "# * This is an intrusive trace (counters polling).\n");
fprintf(fp, "# Idle C-States usage was altered.\n");
fprintf(fp, "# Limted additional CPU & EMIFs loads generated.\n");
fprintf(fp, "#\n");
/* fprintf(fp, "# * If CPU1 Load = -5.0, it means CPU1 is OFFLINE.\n"); */
/* fprintf(fp, "#\n"); */
/* fprintf(fp, "# * CPU LOADS CANNOT be directly converted to Mhz.\n"); */
/* fprintf(fp, "# OPP may have changed during the audit.\n"); */
/* fprintf(fp, "#\n"); */
fprintf(fp, "# ----------------------- Trace FORMAT -------------------"
"--------------------------------------------------------------"
"-----\n");
fprintf(fp, "#\n");
fprintf(fp, "# Trace Length: %us\n", capture_time);
fprintf(fp, "#\n");
fprintf(fp, "# Trace Sampling Rate: %ums\n",
sampling_rate);
fprintf(fp, "#\n");
fprintf(fp, "# Number of samples: %u\n", sample_cnt - 1);
fprintf(fp, "#\n");
fprintf(fp, "# %10.10s ", "Timestamp(s)");
};
for (i = 0; i < TRACE_CFG_ENABLED_OPTIONS_MAX; i++) {
if (trace_state[i] >= 0) {/* Traces state is enabled if non-zero state value. */
ret = value2name(i, name, trace_config_options_table);
fprintf(fp, "\t%10.10s", name);
switch (i) {
case TRACE_CFG_EMIF0_CNT0_FILTER:
case TRACE_CFG_EMIF1_CNT0_FILTER:
case TRACE_CFG_EMIF0_CNT1_FILTER:
case TRACE_CFG_EMIF1_CNT1_FILTER:
ret = value2name(trace_state[i], name, emif_event_counters);
ret = snprintf(tmp_name, 64, "%s%s", ".", name);
ret = snprintf(name, 64, "%s", tmp_name);
break;
case TRACE_CFG_L2CC_CNT0_FILTER:
case TRACE_CFG_L2CC_CNT1_FILTER:
ret = value2name(trace_state[i], name, l2cc_event_counters_table);
ret = snprintf(tmp_name, 64, "%s%s", ".", name);
ret = snprintf(name, 64, "%s", tmp_name);
break;
default:
strcpy(name, " ");
break;
} /* end switch */
fprintf(fp, "%s ", name);
}
}
fprintf(fp, "\n");
if (trace_state[TRACE_CFG_LONG_HEADER] == 1) {
fprintf(fp, "#\n");
fprintf(fp, "# ----------------------- Trace START --------------------"
"--------------------------------------------------------------"
"-----\n");
}
dprintf ("I'm here 0\n");
/* Note: dropping first sample (or using it to normalize data to 0) */
for (sample = 1; sample < sample_cnt; sample++) {
if (sampling_rate > 0) {
/* Save timestamp */
sprintf(s, "%.3lf", (double)
(sample * sampling_rate) / 1000.0);
fprintf(fp, "%10.10s", s);
} else {
sprintf(s, "%.3lf", (double)
(sample));
fprintf(fp, "%10.10s", s);
}
dprintf ("I'm here 1.%d\n", sample);
for (i = 0; i < TRACE_CFG_ENABLED_OPTIONS_MAX; i++) {
if (trace_state[i] >= 0) {
/*
// For now, treating this timer as a counter - its easier to perform calculations
// (std. dev, mean, error etc.)
// if ( i == TRACE_CFG_TIMER_32K_SYNC ) {
// // These don't need offset adjusted like counters
// sprintf(s, "%u", count32_delta(trace_buf[i][0],
// trace_buf[i][sample]) );
// fprintf(fp, "\t%10.10s", s);
// continue;
// }
*/
dprintf("INFO: Current Sample %d Value %d Previous %d\n",
sample, trace_buf[i][sample], trace_buf[i][sample - 1]);
sprintf(s, "%u",
count32_delta(trace_buf[i][sample - 1],
trace_buf[i][sample]));
fprintf(fp, "\t%10.10s", s);
} /* if state >= 0 */
} /* for i to TRACE_CFG_ENABLED_OPTIONS_MAX */
dprintf ("I'm here 2\n");
fprintf(fp, "\n");
} /* for sample < sample_cnt */
if (trace_state[TRACE_CFG_LONG_HEADER]) {
fprintf(fp, "# ------------------------ Trace END ---------------------"
"--------------------------------------------------------------"
"-----\n");
};
fclose(fp);
printf("Performance trace saved into \"%s\" file.\n",
trace_perf_file);
/* Calculate Averages/Statistics*/
fp = workdir_fopen(trace_perf_stats_file, "w");
if (fp == NULL) {
fprintf(stderr, "%s(): could not create %s!\n",
__func__, trace_perf_stats_file);
ret = OMAPCONF_ERR_NOT_AVAILABLE;
goto counters44xx_count_err;
}
dprintf ("I'm here 2\n");
autoadjust_table_init(table);
row = 0;
strncpy(table[row][0], "Performance Statistics", TABLE_MAX_ELT_LEN);
strncpy(table[row][1], "Option", TABLE_MAX_ELT_LEN);
strncpy(table[row][2], "Min", TABLE_MAX_ELT_LEN);
strncpy(table[row][3], "Max", TABLE_MAX_ELT_LEN);
strncpy(table[row][4], "Average", TABLE_MAX_ELT_LEN);
row++;
/* Note: sample_cnt+0 = min, +1=avg, +2 = max */
min = sample_cnt;
avg = sample_cnt+1;
max = sample_cnt+2;
dprintf ("I'm here 3\n");
for (i = 0; i < TRACE_CFG_ENABLED_OPTIONS_MAX; i++) {
/* Whats the 'if' below for? Will always be true... */
if (trace_state[i] >= 0) {
trace_buf[i][min] = ~0;
trace_buf[i][max] = 0;
trace_buf[i][avg] = 0;
dprintf ("I'm here 3.%d\n", i);
ret = value2name(i, name, trace_config_options_table);
dprintf ("Name: %s MIN: %d MAX: %d AVG: %d\n", name, trace_buf[i][min], trace_buf[i][max], trace_buf[i][avg]);
for (sample = 1; sample < sample_cnt; sample++) {
dprintf ("I'm here 3.%d.%d\n", i, sample);
temp = count32_delta(trace_buf[i][sample - 1],
trace_buf[i][sample]);
dprintf ("I'm here 3.%d.%d !FREQ %d\n", i, sample, temp);
if (temp > trace_buf[i][max])
trace_buf[i][max] = temp;
if (temp < trace_buf[i][min])
trace_buf[i][min] = temp;
trace_buf[i][avg] = (unsigned int) avg_recalc((double) trace_buf[i][avg],
(double) temp, sample - 1);
ret = value2name(i, name, trace_config_options_table);
dprintf ("Name: %s MIN: %d MAX: %d AVG: %d\n", name, trace_buf[i][min], trace_buf[i][max], trace_buf[i][avg]);
} /* for sample < sample_cnt */
dprintf ("I'm here 4.%d\n", i);
/* Save statistics */
ret = value2name(i, name, trace_config_options_table);
dprintf ("Name: %s MIN: %d MAX: %d AVG: %d\n", name, trace_buf[i][min], trace_buf[i][max], trace_buf[i][avg]);
strncpy(table[row][0], name, TABLE_MAX_ELT_LEN);
strcpy (option, "");
switch (i) {
case TRACE_CFG_EMIF0_CNT0_FILTER:
case TRACE_CFG_EMIF1_CNT0_FILTER:
case TRACE_CFG_EMIF0_CNT1_FILTER:
case TRACE_CFG_EMIF1_CNT1_FILTER:
ret = value2name(trace_state[i], option, emif_event_counters);
break;
case TRACE_CFG_L2CC_CNT0_FILTER:
case TRACE_CFG_L2CC_CNT1_FILTER:
ret = value2name(trace_state[i], option, l2cc_event_counters_table);
break;
default:
break;
} /* end switch */
strncpy(table[row][1], option, TABLE_MAX_ELT_LEN);
snprintf(table[row][2], TABLE_MAX_ELT_LEN, "%.2d", trace_buf[i][min]);
snprintf(table[row][3], TABLE_MAX_ELT_LEN, "%.2d", trace_buf[i][max]);
snprintf(table[row][4], TABLE_MAX_ELT_LEN, "%.2d", trace_buf[i][avg]);
row++;
} /* if (trace_state[i] >= 0 */
} /* for i to TRACE_CFG_ENABLED_OPTIONS_MAX */
dprintf ("I'm here 5\n");
autoadjust_table_fprint(fp, table, row, 4);
fclose(fp);
printf("Performance statistics saved into \"%s\" file.\n\n",
trace_perf_stats_file);
dprintf ("I'm here 6\n");
autoadjust_table_print(table, row, 4);
dprintf ("I'm here 7\n");
return ret;
counters44xx_count_err:
/* Free allocated buffers */
for (i = 0; i < TRACE_CFG_ENABLED_OPTIONS_MAX; i++) {
if (trace_state[i] >= 0) {/* Traces state is enabled if non-neg state value. */
if (trace_buf[i] != NULL) {
free(trace_buf[i]);
}
}
} /* end for i < TRACE_CFG_ENABLED_OPTIONS_MAX */
return ret;
}
int set_opt(struct option_array *opt, sstr * str)
{
sstr *tok;
int sep;
if (rereading && !opt->reloadable)
return (0);
tok = sstr_init(0);
sstr_ncat2(str, "\n", 1); /*For sstr_token */
opt->essential = FALSE;
switch (opt->type) {
case BOOL:
sstr_token(str, tok, " \t\r\n", 0);
if (!sstr_casecmp2(tok, "yes"))
*(int *) opt->var = TRUE;
else if (!sstr_casecmp2(tok, "no"))
*(int *) opt->var = FALSE;
else
return (-1);
break;
case FILENAME:
case STRING:
sstr_token(str, tok, " \t\r\n", SSTR_QTOK);
*(char **) opt->var = strdup(sstr_buf(tok));
break;
case DIRECTRY:
sstr_token(str, tok, " \t\r\n", SSTR_QTOK);
if (sstr_getchar(tok, sstr_len(tok) - 1) != '/')
sstr_ncat2(tok, "/", 1);
*(char **) opt->var = strdup(sstr_buf(tok));
break;
case ADDRESS:
sstr_token(str, tok, " \t\r\n", 0);
return name2addr(tok, (struct in_addr *) opt->var);
break;
case ADDRPRT:
sep = sstr_token(str, tok, " :\t\r\n", 0);
if( name2addr(tok, &((struct sockaddr_in *) opt->var)->sin_addr)==-1)
return(-1);
if (sep == ':')
((struct sockaddr_in *) opt->var)->sin_port
= ntohs(sstr_atoi(str));
((struct sockaddr_in *) opt->var)->sin_family = AF_INET;
break;
case INT:
sstr_token(str, tok, " \t\r\n", 0);
*(int *) opt->var = sstr_atoi(tok);
break;
case PRTRNGE:
sstr_token(str, tok, " \t-,\r\n", 0);
((int *) opt->var)[0] = sstr_atoi(tok);
((int *) opt->var)[1] = sstr_atoi(str);
if(!valid_uint16(((int *) opt->var)[0]) ||
!valid_uint16(((int *) opt->var)[1])) {
fprintf(stderr, "Port out of range\n");
return -1;
}
if(((int *) opt->var)[0] >= ((int *) opt->var)[1]) {
fprintf(stderr, "Port range is inverted\n");
return -1;
}
break;
case ACL:
return store_acl(str, (struct acl_list *) opt->var);
break;
case SUBSECT:
return store_subsect(str, (struct subsect_list *) opt->var);
}
sstr_free(tok);
return (0);
}
