int pipe;
};
-static char blkiomon_version[] = "0.2";
+static char blkiomon_version[] = "0.3";
static FILE *ifp;
static int interval = -1;
} else
dstat = malloc(sizeof(*dstat));
if (!dstat) {
- perror("blkiomon: could not allocate device statistic");
+ fprintf(stderr,
+ "blkiomon: could not allocate device statistic");
return NULL;
}
- memset(dstat, 0, sizeof(*dstat));
+ blkiomon_stat_init(&dstat->msg.stat);
return dstat;
}
goto out;
dstat->msg.stat.device = device;
- dstat->msg.stat.size_mm.min = -1ULL;
- dstat->msg.stat.d2c_mm.min = -1ULL;
rb_link_node(&dstat->node, search.parent, search.node_ptr);
rb_insert_color(&dstat->node, &dstat_tree[dstat_curr]);
while (1) {
wake.tv_sec += interval;
if (clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &wake, &r)) {
- perror("blkiomon: interrupted sleep");
+ fprintf(stderr, "blkiomon: interrupted sleep");
continue;
}
struct blkiomon_stat *p;
__u64 d2c = (bit_c->time - bit_d->time) / 1000; /* ns -> us */
__u32 size = bit_d->bytes;
+ __u64 thrput = size * 1000 / d2c;
dstat = blkiomon_get_dstat(bit_d->device);
if (!dstat)
return 1;
p = &dstat->msg.stat;
- if (BLK_DATADIR(bit_c->action) & BLK_TC_READ)
- p->read++;
- else if (BLK_DATADIR(bit_c->action) & BLK_TC_WRITE)
- p->write++;
- else
+ if (BLK_DATADIR(bit_c->action) & BLK_TC_READ) {
+ minmax_account(&p->thrput_r, thrput);
+ minmax_account(&p->size_r, size);
+ minmax_account(&p->d2c_r, d2c);
+ } else if (BLK_DATADIR(bit_c->action) & BLK_TC_WRITE) {
+ minmax_account(&p->thrput_w, thrput);
+ minmax_account(&p->size_w, size);
+ minmax_account(&p->d2c_w, d2c);
+ } else
p->bidir++;
histlog2_account(p->size_hist, size, &size_hist);
histlog2_account(p->d2c_hist, d2c, &d2c_hist);
- minmax_account(&p->size_mm, size);
- minmax_account(&p->d2c_mm, d2c);
return 0;
}
}
if (ferror(ifp)) {
clearerr(ifp);
- perror("blkiomon: error while reading trace");
+ fprintf(stderr, "blkiomon: error while reading trace");
break;
}
- if (data_is_native == -1 && check_data_endianness(bit->magic))
+ if (data_is_native == -1 && check_data_endianness(bit->magic)) {
+ fprintf(stderr, "blkiomon: endianess problem\n");
break;
+ }
/* endianess */
trace_to_cpu(bit);
if (verify_trace(bit)) {
- perror("blkiomon: bad trace");
+ fprintf(stderr, "blkiomon: bad trace\n");
break;
}
pdu_buf = realloc(pdu_buf, bit->pdu_len);
if (fread(pdu_buf, bit->pdu_len, 1, ifp) != 1) {
clearerr(ifp);
- perror("blkiomon: could not read payload");
+ fprintf(stderr, "blkiomon: could not read payload\n");
break;
}
}
/* forward low-level device driver trace to other tool */
if (bit->action & BLK_TC_ACT(BLK_TC_DRV_DATA)) {
driverdata++;
- if (blkiomon_dump_drvdata(bit, pdu_buf))
+ if (blkiomon_dump_drvdata(bit, pdu_buf)) {
+ fprintf(stderr, "blkiomon: could not send trace\n");
break;
+ }
continue;
}
/* try to find matching trace and update statistics */
t = blkiomon_do_trace(t);
- if (!t)
+ if (!t) {
+ fprintf(stderr, "blkiomon: could not alloc trace\n");
break;
+ }
bit = &t->bit;
/* t and bit will be recycled for next incoming trace */
}
"-I <interval> | --interval=<interval>\n" \
"[ -h <file> | --human-readable=<file> ]\n" \
"[ -b <file> | --binary=<file> ]\n" \
+ "[ -d <file> | --dump-lldd=<file> ]\n" \
"[ -D <file> | --debug=<file> ]\n" \
- "[ -Q <path name> | --msg-queue-name=<path name>]\n" \
+ "[ -Q <path name> | --msg-queue=<path name>]\n" \
"[ -q <msg queue id> | --msg-queue-id=<msg queue id>]\n" \
"[ -m <msg id> | --msg-id=<msg id>]\n" \
"[ -V | --version ]\n\n" \
return 1;
if (pthread_create(&interval_thread, NULL, blkiomon_interval, NULL)) {
- perror("blkiomon: could not create thread");
+ fprintf(stderr, "blkiomon: could not create thread");
return 1;
}