void gen_assert_discr_fun(z3_wrapper *z3, const clone *clone, const pred *pred, int fun_arity) {
gen_header(z3);
/* the basis of the clone */
struct pred *pred_list;
uint64_t num_preds;
clone_get_predicates(clone, &pred_list, &num_preds);
/* write a definition for all predicates */
Z3_func_decl preds[num_preds];
for(int i = 0; i < num_preds; ++i) {
char name[8];
sprintf(name, "p%d", i);
preds[i] = gen_pred(z3, name, &pred_list[i]);
}
Z3_func_decl p = gen_pred(z3, "p", pred);
/* declare a discriminating function */
Z3_func_decl f = gen_fun(z3, "f", fun_arity);
z3->fun = f;
/* write assertions about function preservation */
for(int i = 0; i < num_preds; ++i) {
gen_preserve(z3, 0, f, fun_arity, preds[i], pred_list[i].arity);
}
gen_preserve(z3, 1, f, fun_arity, p, pred->arity);
free(pred_list);
}
static
void gen_new_order_single(fix_message_data* data)
{
data->hdr.MsgType = 'D';
gen_header(&data->hdr);
gen_random_string(data->order.Account, sizeof(data->order.Account));
gen_random_string(data->order.ClOrdID, sizeof(data->order.ClOrdID));
gen_timestamp(&data->order.TransactTime);
data->order.HandlInst = CHAR_FROM("123");
data->order.OrdType = CHAR_FROM("123456789DEGIJKLMP");
data->order.Side = CHAR_FROM("123456789ABCDEFG");
data->order.TimeInForce = CHAR_FROM("1234567");
data->order.Price = gen_price();
}
// generate header
void idaapi header(void)
{
gen_header(GH_PRINT_ALL_BUT_BYTESEX, NULL, device);
char buf[MAXSTR];
const char *n = ptype_str();
// print the processor directive .m32r, or .m32rx
if ( n != NULL )
{
qsnprintf(buf, sizeof(buf), COLSTR(".%s", SCOLOR_ASMDIR), n);
MakeLine(buf,0);
}
}
static int receive(struct sr_output *o, const struct sr_dev_inst *sdi,
const struct sr_datafeed_packet *packet, GString **out)
{
struct context *ctx;
const struct sr_datafeed_meta *meta;
const struct sr_datafeed_logic *logic;
const struct sr_config *src;
GSList *l;
unsigned int i, j;
uint8_t c;
*out = NULL;
if (!o || !o->sdi)
return SR_ERR_ARG;
ctx = o->internal;
switch (packet->type) {
case SR_DF_META:
meta = packet->payload;
for (l = meta->config; l; l = l->next) {
src = l->data;
if (src->key == SR_CONF_SAMPLERATE)
ctx->samplerate = g_variant_get_uint64(src->data);
}
break;
case SR_DF_LOGIC:
logic = packet->payload;
if (ctx->num_samples == 0) {
/* First logic packet in the feed. */
*out = gen_header(sdi, ctx);
} else
*out = g_string_sized_new(512);
for (i = 0; i <= logic->length - logic->unitsize; i += logic->unitsize) {
for (j = 0; j < logic->unitsize; j++) {
/* The OLS format wants the samples presented MSB first. */
c = *((uint8_t *)logic->data + i + logic->unitsize - 1 - j);
g_string_append_printf(*out, "%02x", c);
}
g_string_append_printf(*out, "@%"PRIu64"\n", ctx->num_samples++);
}
break;
}
return SR_OK;
}
static HCFileInfo*
parse_configs(const char* fname)
{
FILE *fd;
char buf[64*1024]; /* Way huge, but wth */
HCFileInfo *head_finfo = NULL, *finfo = NULL, *prev_finfo = NULL;
if (NULL == (fd = fopen(fname, "r")))
return NULL;
while (!feof(fd)) {
char *str, *save;
int state = 0;
char *ok=NULL, *miss=NULL, *mime=NULL;
prev_finfo = finfo;
finfo = TSmalloc(sizeof(HCFileInfo));
memset(finfo, 0, sizeof(HCFileInfo));
if (NULL == head_finfo)
head_finfo = finfo;
if (prev_finfo)
prev_finfo->_next = finfo;
fread(buf, sizeof(buf), 1, fd);
str = strtok_r(buf, "\t", &save);
while (NULL != str) {
if (strlen(str) > 0) {
switch (state) {
case 0:
if ('/' == *str)
++str;
strncpy(finfo->path, str, MAX_PATH_LEN - 1);
finfo->p_len = strlen(finfo->path);
break;
case 1:
strncpy(finfo->fname, str, MAX_FILENAME_LEN - 1);
finfo->basename = strrchr(finfo->fname, '/');
if (finfo->basename)
++(finfo->basename);
break;
case 2:
mime = str;
break;
case 3:
ok = str;
break;
case 4:
miss = str;
break;
}
++state;
}
str = strtok_r(NULL, "\t", &save);
}
finfo->ok = gen_header(ok, mime, &finfo->o_len);
finfo->miss = gen_header(miss, mime, &finfo->m_len);
finfo->data = TSmalloc(sizeof(HCFileData));
memset(finfo->data, 0, sizeof(HCFileData));
reload_status_file(finfo, finfo->data);
}
fclose(fd);
return head_finfo;
}
//--------------------------------------------------------------------------
void idaapi header(void)
{
gen_header(GH_PRINT_ALL);
}
static int receive(const struct sr_output *o, const struct sr_datafeed_packet *packet,
GString **out)
{
const struct sr_datafeed_meta *meta;
const struct sr_datafeed_logic *logic;
const struct sr_config *src;
GSList *l;
struct context *ctx;
int idx, pos, offset;
uint64_t i, j;
gchar *p;
*out = NULL;
if (!o || !o->sdi)
return SR_ERR_ARG;
if (!(ctx = o->priv))
return SR_ERR_ARG;
switch (packet->type) {
case SR_DF_META:
meta = packet->payload;
for (l = meta->config; l; l = l->next) {
src = l->data;
if (src->key != SR_CONF_SAMPLERATE)
continue;
ctx->samplerate = g_variant_get_uint64(src->data);
}
break;
case SR_DF_TRIGGER:
ctx->trigger = ctx->spl_cnt;
break;
case SR_DF_LOGIC:
if (!ctx->header_done) {
*out = gen_header(o);
ctx->header_done = TRUE;
} else
*out = g_string_sized_new(512);
logic = packet->payload;
for (i = 0; i <= logic->length - logic->unitsize; i += logic->unitsize) {
ctx->spl_cnt++;
pos = ctx->spl_cnt & 7;
for (j = 0; j < ctx->num_enabled_channels; j++) {
idx = ctx->channel_index[j];
p = logic->data + i + idx / 8;
ctx->sample_buf[j] <<= 1;
if (*p & (1 << (idx % 8)))
ctx->sample_buf[j] |= 1;
if (ctx->spl_cnt && pos == 0) {
/* Buffered a byte's worth, output hex. */
g_string_append_printf(ctx->lines[j], "%.2x ",
ctx->sample_buf[j]);
ctx->sample_buf[j] = 0;
}
if (ctx->spl_cnt == ctx->spl) {
/* Flush line buffers. */
g_string_append_len(*out, ctx->lines[j]->str, ctx->lines[j]->len);
g_string_append_c(*out, '\n');
if (j == ctx->num_enabled_channels - 1 && ctx->trigger > -1) {
offset = ctx->trigger + ctx->trigger / 8;
g_string_append_printf(*out, "T:%*s^ %d\n", offset, "", ctx->trigger);
ctx->trigger = -1;
}
g_string_printf(ctx->lines[j], "%s:", ctx->channel_names[j]);
}
}
if (ctx->spl_cnt == ctx->spl)
/* Line buffers were already flushed. */
ctx->spl_cnt = 0;
}
break;
case SR_DF_END:
if (ctx->spl_cnt) {
/* Line buffers need flushing. */
*out = g_string_sized_new(512);
for (i = 0; i < ctx->num_enabled_channels; i++) {
if (ctx->spl_cnt & 7)
g_string_append_printf(ctx->lines[i], "%.2x ",
ctx->sample_buf[i] << (8 - (ctx->spl_cnt & 7)));
g_string_append_len(*out, ctx->lines[i]->str, ctx->lines[i]->len);
g_string_append_c(*out, '\n');
}
}
break;
}
return SR_OK;
}
//--------------------------------------------------------------------------
void idaapi header(void)
{
gen_header(GH_PRINT_PROC_ASM_AND_BYTESEX);
}
void* gen_xop_set(BoundBuffer* boundbuffer)
{
uint32_t random = 0;
void* pages = VirtualAlloc(
NULL,
BLOCK_SIZE,
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
if (pages == NULL)
return NULL;
uint8_t* nextfree = (uint8_t*)pages;
nextfree += gen_header((void*)nextfree);
while (nextfree < (uint8_t*)pages + BLOCK_SIZE - MAX_GEN_SIZE - 1)
{
boundbuffer->bounds[boundbuffer->free] = (void*)nextfree;
rand_s(&random);
random &= 0x0f;
switch (random)
{
case 0x0f:
nextfree += gen_input((void*)nextfree);
break;
case 0x00:
nextfree += gen_output((void*)nextfree);
break;
case 0x01:
nextfree += gen_xop_vprot((void*)nextfree);
break;
case 0x02:
nextfree += gen_xop_vpcom((void*)nextfree);
nextfree += gen_xop_vpcmov((void*)nextfree);
break;
case 0x03:
if (boundbuffer->count > MIN_LOOP_SIZE * 4)
{
nextfree += gen_sse41_ptest((void*)nextfree);
nextfree += gen_jcc((void*)nextfree, boundbuffer);
break;
}
default:
nextfree += gen_xop_vpperm((void*)nextfree);
break;
}
if (boundbuffer->count < BOUND_BUFFER_SIZE)
boundbuffer->count++;
boundbuffer->free = ++boundbuffer->free & BOUND_BUFFER_MASK;
}
// return pointer to end of output ...
// mov rax, rdx
// ret
*((uint32_t*)nextfree++) = 0xc3c28b48u;
nextfree--;
while (!*++nextfree
&& nextfree < (uint8_t*)pages + BLOCK_SIZE - 1)
{
*nextfree = 0xcc;
}
return pages;
}
//--------------------------------------------------------------------------
// generate start of the disassembly
void idaapi header(void)
{
gen_header(GH_PRINT_ALL_BUT_BYTESEX);
}
//--------------------------------------------------------------------------
void idaapi header(void)
{
gen_header(GH_PRINT_PROC | GH_PRINT_HEADER);
MakeNull();
}
int main(int argc, char **argv)
{
char *proc_name, *buf;
char *in_fname, *out_fname = NULL, *hdr_fname = NULL;
char *fname, *prefix = NULL;
int opt, help = 0;
int loop, siz;
FILE *in_file, *out_file, *hdr_file;
yadac_t *tree;
/* store name of process */
proc_name = strrchr(*argv, '/');
proc_name = (proc_name ? (proc_name + 1) : *argv);
/* check for explicit usage request */
if((argc > 1) && !strcmp(argv[1], "--help"))
help++;
else
{
/* parse arguments */
opterr = 0;
while((opt = getopt(argc, argv, "h:o:p:V")) != EOF)
{
switch(opt)
{
case('h'):
hdr_fname = optarg;
break;
case('o'):
out_fname = optarg;
break;
case('p'):
prefix = optarg;
break;
case('V'):
printf("yadac, version %s $Rev: 190 $\n", YADA_VERSION_STR);
return(EX_OK);
case('?'):
fprintf(stderr, "invalid option -- %c\n", optopt);
help++;
break;
} /* switch(opt) */
} /* foreach(option) */
} /* else(!help) */
if(help || (argc < 2))
{
printf("usage: %s [options] <in_file>\n", proc_name);
printf("options:\n");
printf(" -h file : header filename\n");
printf(" -o file : output filename\n");
printf(" -p name : prefix for output functions\n");
printf(" -V display version information\n");
return(EX_USAGE);
}
/* determine input filename */
in_fname = argv[optind];
/* input filename without path */
fname = strrchr(in_fname, '/');
fname = (fname ? (fname + 1) : in_fname);
/* determine output filename */
if(!out_fname)
{
/* derive out_fname from fname */
siz = strlen(fname);
if(!(out_fname = malloc(siz + 3)))
{
fprintf(stderr, "memory allocation error: (%s)\n", strerror(errno));
return(EX_OSERR);
}
strcpy(out_fname, fname);
strcpy((out_fname + siz), ".c");
}
/* determine header filename */
if(!hdr_fname)
{
/* derive hdr_fname from out_fname */
siz = strlen(out_fname);
if((siz >= 2) && !strcmp((out_fname + siz - 2), ".c"))
siz -= 2;
if(!(hdr_fname = malloc(siz + 3)))
{
fprintf(stderr, "memory allocation error: (%s)\n", strerror(errno));
return(EX_OSERR);
}
strcpy(hdr_fname, out_fname);
strcpy((hdr_fname + siz), ".h");
}
/* determine prefix */
if(!prefix)
{
/* derive prefix from input file name */
if(!(prefix = strdup(fname)))
{
fprintf(stderr, "memory allocation error: (%s)\n", strerror(errno));
return(EX_OSERR);
}
/* check for last usable character */
siz = strlen(prefix);
for(loop=0; loop<siz; loop++)
{
if(!(isalnum(prefix[loop]) || (prefix[loop] == '_')))
{
prefix[loop] = 0;
break;
}
}
} /* if(need_prefix) */
printf(" infile: %s\n", in_fname);
printf("outfile: %s\n", out_fname);
printf(" header: %s\n", hdr_fname);
printf(" prefix: %s\n", prefix);
/* open input file */
if(!(in_file = fopen(in_fname, "r")))
{
fprintf(stderr, "error opening %s: (%s)\n", in_fname, strerror(errno));
return(EX_NOINPUT);
}
/* open output and header files */
if(!(out_file = fopen(out_fname, "w")))
{
fprintf(stderr, "error creating %s: (%s)\n", out_fname, strerror(errno));
return(EX_CANTCREAT);
}
if(!(hdr_file = fopen(hdr_fname, "w")))
{
fprintf(stderr, "error creating %s: (%s)\n", hdr_fname, strerror(errno));
return(EX_CANTCREAT);
}
/* find size of source file */
fseek(in_file, 0, SEEK_END);
siz = ftell(in_file);
rewind(in_file);
/* allocate space for file */
if(!(buf = malloc(siz)))
{
fprintf(stderr, "memory allocation error: (%s)\n", strerror(errno));
return(EX_OSERR);
}
/* load file into memory */
if(!fread(buf, siz, 1, in_file))
{
fprintf(stderr, "error reading %s: (%s)\n", in_fname, strerror(errno));
return(EX_DATAERR);
}
fclose(in_file);
/* parse source file */
if(!(tree = yadac_parse(buf, siz)))
{
fprintf(stderr, "error parsing %s\n", in_fname);
return(EX_DATAERR);
}
free(buf);
/* generate output */
if(!(buf = gen_source(tree, &siz, in_fname, out_fname, hdr_fname, prefix)) ||
(fwrite(buf, 1, siz, out_file) != siz))
{
fprintf(stderr, "error generating %s: (%s)\n", out_fname, strerror(errno));
return(EX_UNAVAILABLE);
}
free(buf);
fclose(out_file);
/* generate header */
if(!(buf = gen_header(tree, &siz, in_fname, hdr_fname, prefix)) ||
(fwrite(buf, 1, siz, hdr_file) != siz))
{
fprintf(stderr, "error generating %s: (%s)\n", hdr_fname, strerror(errno));
return(EX_UNAVAILABLE);
}
free(buf);
fclose(hdr_file);
yadac_free(tree);
return(EX_OK);
}
/*
* logger -- read and log utility
*
* Reads from an input and arranges to write the result on the system
* log.
*/
int main(int argc, char **argv)
{
int LogSock;
int ch, pri = LOG_NOTICE;
char *tag = NULL;
uint16_t port = 0;
char buf[MAX_LNE_LEN];
int prilen, hdrlen;
static const struct option longopts[] = {
{ "priority", required_argument, 0, 'p' },
{ "tag", required_argument, 0, 't' },
{ "port", required_argument, 0, 'P' },
{ "help", no_argument, 0, 'h' },
{ NULL, 0, 0, 0 }
};
while ((ch = getopt_long(argc, argv, "p:st:P:Vh", longopts, NULL)) != -1) {
int iport = 0;
switch (ch) {
case 'p': /* priority */
pri = pencode(optarg);
break;
case 't': /* tag */
tag = optarg;
if(strlen(tag) > MAX_TAG_LEN)
errx(EXIT_FAILURE,
"tag must be no longer than %d", MAX_TAG_LEN);
break;
case 'P':
iport = atoi(optarg);
if(iport > (uint16_t)-1 || iport <= 0)
errx(EXIT_FAILURE, "Invalid port");
port = iport;
break;
case 'h':
usage(stdout);
exit(EXIT_SUCCESS);
case '?':
default:
usage(stderr);
exit(EXIT_FAILURE);
}
}
argc -= optind;
argv += optind;
if(port == 0)
errx(EXIT_FAILURE, "port is required.");
if(tag == NULL)
errx(EXIT_FAILURE, "tag is required.");
if (argc > 0)
errx(EXIT_FAILURE, "extra command line arguments.");
/* setup for logging */
LogSock = inet_socket(port);
gen_header(buf, pri, tag, &prilen, &hdrlen);
log_from_stdin(LogSock, buf, prilen, hdrlen);
close(LogSock);
return EXIT_SUCCESS;
}
/* Main execution loop in live mode. Builds the list of processes,
* collects statistics, and prints using curses. Repeats after some
* delay, also catching key presses.
*/
static int live_mode(struct process_list* proc_list, screen_t* screen)
{
WINDOW* help_win = NULL;
WINDOW* error_win = NULL;
fd_set fds;
struct process** p;
int num_iter = 0;
int with_colors = 0;
int pos;
/* start curses */
initscr();
cbreak();
noecho();
keypad(stdscr, TRUE);
/* Prepare help window */
help_win = prepare_help_win(screen);
if (has_colors()) {
/* initialize curses colors */
with_colors = 1;
start_color();
init_pair(1, COLOR_BLACK, COLOR_WHITE);
init_pair(2, COLOR_WHITE, COLOR_BLACK);
init_pair(3, COLOR_GREEN, COLOR_BLACK);
init_pair(4, COLOR_YELLOW, COLOR_BLACK);
init_pair(5, COLOR_RED, COLOR_BLACK);
attron(COLOR_PAIR(0));
}
tv.tv_sec = 0;
tv.tv_usec = 200000; /* 200 ms for first iteration */
header = gen_header(screen, &options, COLS - 1, active_col);
pos = screen_pos(screen);
for(num_iter=0; !options.max_iter || num_iter<options.max_iter; num_iter++) {
int i, zz, printed, num_fd, num_dead;
/* print various info */
erase();
mvprintw(0, 0, "tiptop -");
if ((num_errors() > 0) && (COLS >= 37))
mvprintw(LINES-1, 30, "[errors]");
if ((options.config_file == 1) && (COLS >= 60))
mvprintw(0, COLS-60, "[conf]");
if ((options.euid == 0) && (COLS >= 54))
mvprintw(0, COLS-54, "[root]");
if ((options.watch_uid != -1) && (COLS >= 48))
mvprintw(0, COLS-48, "[uid]");
if ((options.only_pid || options.only_name) && (COLS >= 43))
mvprintw(0, COLS-43, "[pid]");
if (options.show_kernel && (COLS >= 38))
mvprintw(0, COLS-38, "[kernel]");
if (options.sticky && (COLS >= 30))
mvprintw(0, COLS-30, "[sticky]");
if (options.show_threads && (COLS >= 22))
mvprintw(0, COLS-22, "[threads]");
if (options.idle && (COLS >= 13))
mvprintw(0, COLS-13, "[idle]");
if (options.debug && (COLS >= 7))
mvprintw(0, COLS-7, "[debug]");
if (options.show_epoch && (COLS >= 18))
mvprintw(LINES-1, COLS-18, "Epoch: %u", time(NULL));
if (options.show_timestamp)
mvprintw(LINES-1, 0, "Iteration: %u", num_iter);
/* print main header */
if (with_colors)
attron(COLOR_PAIR(1));
mvprintw(3, 0, "%s", header);
for(zz=strlen(header); zz < COLS-1; zz++)
printw(" ");
printw("\n");
if (with_colors)
attroff(COLOR_PAIR(1));
/* update the list of processes/threads and accumulate info if needed */
num_dead = update_proc_list(proc_list, screen, &options);
if (!options.show_threads)
accumulate_stats(proc_list);
p = proc_list->proc_ptrs;
/* prepare for select */
FD_ZERO(&fds);
FD_SET(STDIN_FILENO, &fds);
/* generate the text version of all rows */
build_rows(proc_list, screen, COLS - 1);
/* sort by %CPU */
qsort(p, proc_list->num_tids, sizeof(struct process*), sorting_fun);
printed = 0;
/* Iterate over all threads */
for(i=0; i < proc_list->num_tids; i++) {
if (p[i]->skip)
continue;
/* highlight watched process, if any */
if (with_colors) {
if (p[i]->dead) {
attron(COLOR_PAIR(5));
}
else if ((p[i]->tid == options.watch_pid) ||
(options.watch_name && options.show_cmdline &&
strstr(p[i]->cmdline, options.watch_name)) ||
(options.watch_name && !options.show_cmdline &&
strstr(p[i]->name, options.watch_name)))
attron(COLOR_PAIR(3));
}
if (options.show_threads || (p[i]->pid == p[i]->tid)) {
printw("%s\n", p[i]->txt);
printed++;
}
if (with_colors)
attroff(COLOR_PAIR(3));
if (printed >= LINES - 5) /* stop printing at bottom of window */
break;
}
mvprintw(1, 0, "Tasks: %3d total, %3d displayed",
proc_list->num_tids, printed);
if (options.sticky)
printw(", %3d dead", num_dead);
/* print the screen name, make sure it fits, or truncate */
if (with_colors)
attron(COLOR_PAIR(4));
if (35 + 20 + 11 + strlen(screen->name) < COLS) {
mvprintw(1, COLS - 11 - strlen(screen->name),
"screen %2d: %s\n", pos, screen->name);
}
else if (COLS >= 35 + 20 + 11) {
char screen_str[50] = { 0 };
snprintf(screen_str, sizeof(screen_str) - 1, "%s\n", screen->name);
screen_str[COLS - 35 - 20 - 11] = '\0'; /* truncate */
mvprintw(1, 35+20, "screen %2d: %s", pos, screen_str);
}
if (with_colors)
attroff(COLOR_PAIR(4));
/* print message if any */
if (message) {
if (with_colors)
attron(COLOR_PAIR(1));
mvprintw(2, 0, "%s", message);
if (with_colors)
attroff(COLOR_PAIR(1));
message = NULL; /* reset message */
}
refresh(); /* display everything */
if (options.error) {
if (options.error == 1) {
options.error = 2;
show_error_win(error_win, printed);
}
else
show_error_win(error_win, -1);
}
if (options.help)
show_help_win(help_win, screen);
if ((num_dead) && (!options.sticky))
compact_proc_list(proc_list);
/* wait some delay, or until a key is pressed */
num_fd = select(1 + STDIN_FILENO, &fds, NULL, NULL, &tv);
if (num_fd > 0) {
int c = handle_key();
if (c == 'q')
break;
if (c == '>') {
if (active_col < screen->num_columns )
active_col++;
free(header);
header = gen_header(screen, &options, COLS - 1, active_col);
}
if (c == '<') {
if (active_col > -1)
active_col--;
free(header);
header = gen_header(screen, &options, COLS - 1, active_col);
}
if (c == 'H') {
if (options.show_threads) {
reset_values(proc_list);
message = "Show threads On";
}
else
message = "Show threads Off";
}
if (c == 'U') {
free(header);
header = gen_header(screen, &options, COLS - 1, active_col);
}
if ((c == '+') || (c == '-') || (c == KEY_LEFT) || (c == KEY_RIGHT))
return c;
if ((c == 'u') || (c == 'K') || (c == 'p')) /* need to rebuild tasks list */
return c;
if (c == 'e') {
if (options.error > 0) {
options.error = 0;
delwin(error_win);
error_win = NULL;
}
else
options.error = 1;
}
}
tv.tv_sec = options.delay;
tv.tv_usec = (options.delay - tv.tv_sec) * 1000000.0;
}
free(header);
delwin(help_win);
endwin(); /* stop curses */
return 'q';
}
/* Main execution loop in batch mode. Builds the list of processes,
* collects statistics, and prints. Repeats after some delay.
*/
static void batch_mode(struct process_list* proc_list, screen_t* screen)
{
int num_iter = 0;
int num_printed;
int pos;
FILE* out = options.out;
struct process** p;
tv.tv_sec = 0;
tv.tv_usec = 200000; /* 200 ms for first iteration */
/* Print various information about this run */
fprintf(out, "tiptop - ");
fflush(out);
{ /* uptime */
FILE* f;
float val1, val5, val15, up;
int days, hours, minutes, n;
f = fopen("/proc/loadavg", "r");
n = fscanf(f, "%f %f %f", &val1, &val5, &val15);
if (n != 3)
val1 = val5 = val15 = 0.0; /* something went wrong, no sure what */
fclose(f);
f = fopen("/proc/uptime", "r");
n = fscanf(f, "%f", &up);
if (n != 1)
up = 0.0;
fclose(f);
days = up / 86400;
hours = (up - days*86400) / 3600;
minutes = (up - days*86400 - hours*3600) / 60;
fprintf(out, "up %d days, %d:%02d, load average: %.2f, %.2f, %.2f\n",
days, hours, minutes, val1, val5, val15);
}
{ /* date */
char outstr[200];
time_t t = time(NULL);
struct tm *tmp = localtime(&t);
if (tmp) {
strftime(outstr, sizeof(outstr), "%a %b %e %H:%M:%S %Z %Y", tmp);
fprintf(out, "%s\n", outstr);
}
}
pos = screen_pos(screen);
fprintf(out, "delay: %.2f idle: %d threads: %d\n",
options.delay, (int)options.idle, (int)options.show_threads);
if (options.watch_pid)
fprintf(out, "watching pid %d\n", options.watch_pid);
else if (options.watch_name)
fprintf(out, "watching pid '%s'\n", options.watch_name);
if (options.only_pid)
fprintf(out, "only pid %d\n", options.only_pid);
else if (options.only_name)
fprintf(out, "only pid '%s'\n", options.only_name);
if (options.watch_uid != -1) {
struct passwd* passwd = getpwuid(options.watch_uid);
assert(passwd);
fprintf(out, "watching uid %d '%s'\n", options.watch_uid, passwd->pw_name);
}
header = gen_header(screen, &options, TXT_LEN - 1, active_col);
fprintf(out, "Screen %d: %s\n", pos, screen->name);
fprintf(out, "\n%s\n", header);
for(num_iter=0; !options.max_iter || num_iter<options.max_iter; num_iter++) {
unsigned int epoch = 0;
int i, num_dead;
/* update the list of processes/threads and accumulate info if needed */
if (options.show_epoch)
epoch = time(NULL);
num_dead = update_proc_list(proc_list, screen, &options);
if (!options.show_threads)
accumulate_stats(proc_list);
p = proc_list->proc_ptrs;
/* generate the text version of all rows */
build_rows(proc_list, screen, -1);
/* sort by %CPU */
qsort(p, proc_list->num_tids, sizeof(struct process*), sorting_fun);
num_printed = 0;
for(i=0; i < proc_list->num_tids; i++) {
if (p[i]->skip)
continue;
if (options.show_threads || (p[i]->pid == p[i]->tid)) {
if (options.show_timestamp)
fprintf(out, "%6d ", num_iter);
if (options.show_epoch)
fprintf(out, "%10u ", epoch);
fprintf(out, "%s%s", p[i]->txt, p[i]->dead ? " DEAD" : "");
/* if the process is being watched */
if ((p[i]->tid == options.watch_pid) ||
(options.watch_name && options.show_cmdline &&
strstr(p[i]->cmdline, options.watch_name)) ||
(options.watch_name && !options.show_cmdline &&
strstr(p[i]->name, options.watch_name)))
fprintf(out, " <---");
fprintf(out, "\n");
num_printed++;
}
}
if (num_printed)
fprintf(out, "\n");
fflush(out);
if (options.command_done && options.sticky)
break;
if ((num_dead) && (!options.sticky))
compact_proc_list(proc_list);
/* Wait some delay. Note that this syscall may be interrupted when
we receive a signal, such as SICHLD. This is ok, it will force
a refresh. */
select(0, NULL, NULL, NULL, &tv);
/* prepare for next select */
tv.tv_sec = options.delay;
tv.tv_usec = (options.delay - tv.tv_sec) * 1000000.0;
}
free(header);
}
