You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
470 lines
9.9 KiB
470 lines
9.9 KiB
/*
|
|
* This file contains format parsing code for blkparse, allowing you to
|
|
* customize the individual action format and generel output format.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <ctype.h>
|
|
#include <time.h>
|
|
|
|
#include "blktrace.h"
|
|
|
|
#define VALID_SPECS "ABCDFGIMPQRSTUWX"
|
|
|
|
#define HEADER "%D %2c %8s %5T.%9t %5p %2a %3d "
|
|
|
|
static char *override_format[256];
|
|
|
|
static inline int valid_spec(int spec)
|
|
{
|
|
return strchr(VALID_SPECS, spec) != NULL;
|
|
}
|
|
|
|
void set_all_format_specs(char *option)
|
|
{
|
|
char *p;
|
|
|
|
for (p = VALID_SPECS; *p; p++)
|
|
if (override_format[(int)(*p)] == NULL)
|
|
override_format[(int)(*p)] = strdup(option);
|
|
}
|
|
|
|
int add_format_spec(char *option)
|
|
{
|
|
int spec = optarg[0];
|
|
|
|
if (!valid_spec(spec)) {
|
|
fprintf(stderr,"Bad format specifier %c\n", spec);
|
|
return 1;
|
|
}
|
|
if (optarg[1] != ',') {
|
|
fprintf(stderr,"Bad format specifier - need ',' %s\n", option);
|
|
return 1;
|
|
}
|
|
option += 2;
|
|
|
|
override_format[spec] = strdup(option);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void fill_rwbs(char *rwbs, struct blk_io_trace *t)
|
|
{
|
|
int w = t->action & BLK_TC_ACT(BLK_TC_WRITE);
|
|
int a = t->action & BLK_TC_ACT(BLK_TC_AHEAD);
|
|
int s = t->action & BLK_TC_ACT(BLK_TC_SYNC);
|
|
int m = t->action & BLK_TC_ACT(BLK_TC_META);
|
|
int d = t->action & BLK_TC_ACT(BLK_TC_DISCARD);
|
|
int f = t->action & BLK_TC_ACT(BLK_TC_FLUSH);
|
|
int u = t->action & BLK_TC_ACT(BLK_TC_FUA);
|
|
int i = 0;
|
|
|
|
if (f)
|
|
rwbs[i++] = 'F'; /* flush */
|
|
|
|
if (d)
|
|
rwbs[i++] = 'D';
|
|
else if (w)
|
|
rwbs[i++] = 'W';
|
|
else if (t->bytes)
|
|
rwbs[i++] = 'R';
|
|
else
|
|
rwbs[i++] = 'N';
|
|
|
|
if (u)
|
|
rwbs[i++] = 'F'; /* fua */
|
|
if (a)
|
|
rwbs[i++] = 'A';
|
|
if (s)
|
|
rwbs[i++] = 'S';
|
|
if (m)
|
|
rwbs[i++] = 'M';
|
|
|
|
rwbs[i] = '\0';
|
|
}
|
|
|
|
static const char *
|
|
print_time(unsigned long long timestamp)
|
|
{
|
|
static char timebuf[128];
|
|
struct tm *tm;
|
|
time_t sec;
|
|
unsigned long nsec;
|
|
|
|
sec = abs_start_time.tv_sec + SECONDS(timestamp);
|
|
nsec = abs_start_time.tv_nsec + NANO_SECONDS(timestamp);
|
|
if (nsec >= 1000000000) {
|
|
nsec -= 1000000000;
|
|
sec += 1;
|
|
}
|
|
|
|
tm = localtime(&sec);
|
|
snprintf(timebuf, sizeof(timebuf),
|
|
"%02u:%02u:%02u.%06lu",
|
|
tm->tm_hour,
|
|
tm->tm_min,
|
|
tm->tm_sec,
|
|
nsec / 1000);
|
|
return timebuf;
|
|
}
|
|
|
|
static inline int pdu_rest_is_zero(unsigned char *pdu, int len)
|
|
{
|
|
static char zero[4096];
|
|
|
|
return !memcmp(pdu, zero, len);
|
|
}
|
|
|
|
static char *dump_pdu(unsigned char *pdu_buf, int pdu_len)
|
|
{
|
|
static char p[4096];
|
|
int i, len;
|
|
|
|
if (!pdu_buf || !pdu_len)
|
|
return NULL;
|
|
|
|
for (len = 0, i = 0; i < pdu_len; i++) {
|
|
if (i)
|
|
len += sprintf(p + len, " ");
|
|
|
|
len += sprintf(p + len, "%02x", pdu_buf[i]);
|
|
|
|
/*
|
|
* usually dump for cdb dumps where we can see lots of
|
|
* zeroes, stop when the rest is just zeroes and indicate
|
|
* so with a .. appended
|
|
*/
|
|
if (!pdu_buf[i] && pdu_rest_is_zero(pdu_buf + i, pdu_len - i)) {
|
|
sprintf(p + len, " ..");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
#define pdu_start(t) (((void *) (t) + sizeof(struct blk_io_trace)))
|
|
|
|
static unsigned int get_pdu_int(struct blk_io_trace *t)
|
|
{
|
|
__u64 *val = pdu_start(t);
|
|
|
|
return be64_to_cpu(*val);
|
|
}
|
|
|
|
static void get_pdu_remap(struct blk_io_trace *t, struct blk_io_trace_remap *r)
|
|
{
|
|
struct blk_io_trace_remap *__r = pdu_start(t);
|
|
__u64 sector_from = __r->sector_from;
|
|
|
|
r->device_from = be32_to_cpu(__r->device_from);
|
|
r->device_to = be32_to_cpu(__r->device_to);
|
|
r->sector_from = be64_to_cpu(sector_from);
|
|
}
|
|
|
|
static void print_field(char *act, struct per_cpu_info *pci,
|
|
struct blk_io_trace *t, unsigned long long elapsed,
|
|
int pdu_len, unsigned char *pdu_buf, char field,
|
|
int minus, int has_w, int width)
|
|
{
|
|
char format[64];
|
|
|
|
if (has_w) {
|
|
if (minus)
|
|
sprintf(format, "%%-%d", width);
|
|
else
|
|
sprintf(format, "%%%d", width);
|
|
} else
|
|
sprintf(format, "%%");
|
|
|
|
switch (field) {
|
|
case 'a':
|
|
fprintf(ofp, strcat(format, "s"), act);
|
|
break;
|
|
case 'c':
|
|
fprintf(ofp, strcat(format, "d"), pci->cpu);
|
|
break;
|
|
case 'C': {
|
|
char *name = find_process_name(t->pid);
|
|
|
|
fprintf(ofp, strcat(format, "s"), name);
|
|
break;
|
|
}
|
|
case 'd': {
|
|
char rwbs[8];
|
|
|
|
fill_rwbs(rwbs, t);
|
|
fprintf(ofp, strcat(format, "s"), rwbs);
|
|
break;
|
|
}
|
|
case 'D': /* format width ignored */
|
|
fprintf(ofp,"%3d,%-3d", MAJOR(t->device), MINOR(t->device));
|
|
break;
|
|
case 'e':
|
|
fprintf(ofp, strcat(format, "d"), t->error);
|
|
break;
|
|
case 'M':
|
|
fprintf(ofp, strcat(format, "d"), MAJOR(t->device));
|
|
break;
|
|
case 'm':
|
|
fprintf(ofp, strcat(format, "d"), MINOR(t->device));
|
|
break;
|
|
case 'n':
|
|
fprintf(ofp, strcat(format, "u"), t_sec(t));
|
|
break;
|
|
case 'N':
|
|
fprintf(ofp, strcat(format, "u"), t->bytes);
|
|
break;
|
|
case 'p':
|
|
fprintf(ofp, strcat(format, "u"), t->pid);
|
|
break;
|
|
case 'P': { /* format width ignored */
|
|
char *p = dump_pdu(pdu_buf, pdu_len);
|
|
if (p)
|
|
fprintf(ofp, "%s", p);
|
|
break;
|
|
}
|
|
case 's':
|
|
fprintf(ofp, strcat(format, "ld"), t->sequence);
|
|
break;
|
|
case 'S':
|
|
fprintf(ofp, strcat(format, "lu"), t->sector);
|
|
break;
|
|
case 't':
|
|
sprintf(format, "%%0%dlu", has_w ? width : 9);
|
|
fprintf(ofp, format, NANO_SECONDS(t->time));
|
|
break;
|
|
case 'T':
|
|
fprintf(ofp, strcat(format, "d"), SECONDS(t->time));
|
|
break;
|
|
case 'u':
|
|
if (elapsed == -1ULL) {
|
|
fprintf(stderr, "Expecting elapsed value\n");
|
|
exit(1);
|
|
}
|
|
fprintf(ofp, strcat(format, "llu"), elapsed / 1000);
|
|
break;
|
|
case 'U':
|
|
fprintf(ofp, strcat(format, "u"), get_pdu_int(t));
|
|
break;
|
|
case 'z':
|
|
fprintf(ofp, strcat(format, "s"), print_time(t->time));
|
|
break;
|
|
default:
|
|
fprintf(ofp,strcat(format, "c"), field);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static char *parse_field(char *act, struct per_cpu_info *pci,
|
|
struct blk_io_trace *t, unsigned long long elapsed,
|
|
int pdu_len, unsigned char *pdu_buf,
|
|
char *master_format)
|
|
{
|
|
int minus = 0;
|
|
int has_w = 0;
|
|
int width = 0;
|
|
char *p = master_format;
|
|
|
|
if (*p == '-') {
|
|
minus = 1;
|
|
p++;
|
|
}
|
|
if (isdigit(*p)) {
|
|
has_w = 1;
|
|
do {
|
|
width = (width * 10) + (*p++ - '0');
|
|
} while ((*p) && (isdigit(*p)));
|
|
}
|
|
if (*p) {
|
|
print_field(act, pci, t, elapsed, pdu_len, pdu_buf, *p++,
|
|
minus, has_w, width);
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static void process_default(char *act, struct per_cpu_info *pci,
|
|
struct blk_io_trace *t, unsigned long long elapsed,
|
|
int pdu_len, unsigned char *pdu_buf)
|
|
{
|
|
struct blk_io_trace_remap r = { .device_from = 0, };
|
|
char rwbs[8];
|
|
char *name;
|
|
|
|
fill_rwbs(rwbs, t);
|
|
|
|
/*
|
|
* For remaps we have to modify the device using the remap structure
|
|
* passed up.
|
|
*/
|
|
if (act[0] == 'A') {
|
|
get_pdu_remap(t, &r);
|
|
t->device = r.device_to;
|
|
}
|
|
|
|
/*
|
|
* The header is always the same
|
|
*/
|
|
fprintf(ofp, "%3d,%-3d %2d %8d %5d.%09lu %5u %2s %3s ",
|
|
MAJOR(t->device), MINOR(t->device), pci->cpu, t->sequence,
|
|
(int) SECONDS(t->time), (unsigned long) NANO_SECONDS(t->time),
|
|
t->pid, act, rwbs);
|
|
|
|
name = find_process_name(t->pid);
|
|
|
|
switch (act[0]) {
|
|
case 'R': /* Requeue */
|
|
case 'C': /* Complete */
|
|
if (t->action & BLK_TC_ACT(BLK_TC_PC)) {
|
|
char *p = dump_pdu(pdu_buf, pdu_len);
|
|
if (p)
|
|
fprintf(ofp, "(%s) ", p);
|
|
fprintf(ofp, "[%d]\n", t->error);
|
|
} else {
|
|
if (elapsed != -1ULL) {
|
|
if (t_sec(t))
|
|
fprintf(ofp, "%llu + %u (%8llu) [%d]\n",
|
|
(unsigned long long) t->sector,
|
|
t_sec(t), elapsed, t->error);
|
|
else
|
|
fprintf(ofp, "%llu (%8llu) [%d]\n",
|
|
(unsigned long long) t->sector,
|
|
elapsed, t->error);
|
|
} else {
|
|
if (t_sec(t))
|
|
fprintf(ofp, "%llu + %u [%d]\n",
|
|
(unsigned long long) t->sector,
|
|
t_sec(t), t->error);
|
|
else
|
|
fprintf(ofp, "%llu [%d]\n",
|
|
(unsigned long long) t->sector,
|
|
t->error);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'D': /* Issue */
|
|
case 'I': /* Insert */
|
|
case 'Q': /* Queue */
|
|
case 'B': /* Bounce */
|
|
if (t->action & BLK_TC_ACT(BLK_TC_PC)) {
|
|
char *p;
|
|
fprintf(ofp, "%u ", t->bytes);
|
|
p = dump_pdu(pdu_buf, pdu_len);
|
|
if (p)
|
|
fprintf(ofp, "(%s) ", p);
|
|
fprintf(ofp, "[%s]\n", name);
|
|
} else {
|
|
if (elapsed != -1ULL) {
|
|
if (t_sec(t))
|
|
fprintf(ofp, "%llu + %u (%8llu) [%s]\n",
|
|
(unsigned long long) t->sector,
|
|
t_sec(t), elapsed, name);
|
|
else
|
|
fprintf(ofp, "(%8llu) [%s]\n", elapsed,
|
|
name);
|
|
} else {
|
|
if (t_sec(t))
|
|
fprintf(ofp, "%llu + %u [%s]\n",
|
|
(unsigned long long) t->sector,
|
|
t_sec(t), name);
|
|
else
|
|
fprintf(ofp, "[%s]\n", name);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'M': /* Back merge */
|
|
case 'F': /* Front merge */
|
|
case 'G': /* Get request */
|
|
case 'S': /* Sleep request */
|
|
if (t_sec(t))
|
|
fprintf(ofp, "%llu + %u [%s]\n",
|
|
(unsigned long long) t->sector, t_sec(t), name);
|
|
else
|
|
fprintf(ofp, "[%s]\n", name);
|
|
break;
|
|
|
|
case 'P': /* Plug */
|
|
fprintf(ofp, "[%s]\n", name);
|
|
break;
|
|
|
|
case 'U': /* Unplug IO */
|
|
case 'T': /* Unplug timer */
|
|
fprintf(ofp, "[%s] %u\n", name, get_pdu_int(t));
|
|
break;
|
|
|
|
case 'A': /* remap */
|
|
get_pdu_remap(t, &r);
|
|
fprintf(ofp, "%llu + %u <- (%d,%d) %llu\n",
|
|
(unsigned long long) t->sector, t_sec(t),
|
|
MAJOR(r.device_from), MINOR(r.device_from),
|
|
(unsigned long long) r.sector_from);
|
|
break;
|
|
|
|
case 'X': /* Split */
|
|
fprintf(ofp, "%llu / %u [%s]\n", (unsigned long long) t->sector,
|
|
get_pdu_int(t), name);
|
|
break;
|
|
|
|
case 'm': /* Message */
|
|
fprintf(ofp, "%*s\n", pdu_len, pdu_buf);
|
|
break;
|
|
|
|
default:
|
|
fprintf(stderr, "Unknown action %c\n", act[0]);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void process_fmt(char *act, struct per_cpu_info *pci, struct blk_io_trace *t,
|
|
unsigned long long elapsed, int pdu_len,
|
|
unsigned char *pdu_buf)
|
|
{
|
|
char *p = override_format[(int) *act];
|
|
|
|
if (!p) {
|
|
process_default(act, pci, t, elapsed, pdu_len, pdu_buf);
|
|
return;
|
|
}
|
|
|
|
while (*p) {
|
|
switch (*p) {
|
|
case '%': /* Field specifier */
|
|
p++;
|
|
if (*p == '%')
|
|
fprintf(ofp, "%c", *p++);
|
|
else if (!*p)
|
|
fprintf(ofp, "%c", '%');
|
|
else
|
|
p = parse_field(act, pci, t, elapsed,
|
|
pdu_len, pdu_buf, p);
|
|
break;
|
|
case '\\': { /* escape */
|
|
switch (p[1]) {
|
|
case 'b': fprintf(ofp, "\b"); break;
|
|
case 'n': fprintf(ofp, "\n"); break;
|
|
case 'r': fprintf(ofp, "\r"); break;
|
|
case 't': fprintf(ofp, "\t"); break;
|
|
default:
|
|
fprintf(stderr,
|
|
"Invalid escape char in format %c\n",
|
|
p[1]);
|
|
exit(1);
|
|
/*NOTREACHED*/
|
|
}
|
|
p += 2;
|
|
break;
|
|
}
|
|
default:
|
|
fprintf(ofp, "%c", *p++);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|