projects / blktrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] fix a divide by zero error
[blktrace.git] / blkparse.c
CommitLineData
d956a2cd
JA		 1/*
2 * block queue tracing parse application
3 *
4 * Copyright (C) 2005 Jens Axboe <axboe@suse.de>
46e37c55 5 * Copyright (C) 2006 Jens Axboe <axboe@kernel.dk>
d956a2cd
JA		 6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 */
d0ca268b
JA		 22#include <sys/types.h>
23#include <sys/stat.h>
24#include <unistd.h>
25#include <stdio.h>
26#include <fcntl.h>
27#include <stdlib.h>
8fc0abbc 28#include <string.h>
d5396421 29#include <getopt.h>
412819ce
JA		 30#include <errno.h>
31#include <signal.h>
d69db225 32#include <locale.h>
6e0073ed 33#include <libgen.h>
d0ca268b 34
8fc0abbc
JA		 35#include "blktrace.h"
36#include "rbtree.h"
bf0720af 37#include "jhash.h"
d0ca268b 38
d84dec8e 39static char blkparse_version[] = "0.99.2";
52724a0e 40
492da111
AB		 41struct skip_info {
42 unsigned long start, end;
43 struct skip_info *prev, *next;
44};
45
e7c9f3ff 46struct per_dev_info {
f7bd1a9b 47 dev_t dev;
e7c9f3ff
NS		 48 char *name;
49
50 int backwards;
51 unsigned long long events;
20ed6177 52 unsigned long long first_reported_time;
e7c9f3ff 53 unsigned long long last_reported_time;
287fa3d6 54 unsigned long long last_read_time;
e7c9f3ff 55 struct io_stats io_stats;
2990e589
JA		 56 unsigned long skips;
57 unsigned long long seq_skips;
649c7b66
JA		 58 unsigned int max_depth[2];
59 unsigned int cur_depth[2];
e7c9f3ff 60
f7bd1a9b
JA		 61 struct rb_root rb_track;
62
73877e12 63 int nfiles;
e7c9f3ff 64 int ncpus;
824c2b39
JA		 65
66 unsigned long *cpu_map;
67 unsigned int cpu_map_max;
68
e7c9f3ff
NS		 69 struct per_cpu_info *cpus;
70};
71
2990e589
JA		 72/*
73 * some duplicated effort here, we can unify this hash and the ppi hash later
74 */
75struct process_pid_map {
76 pid_t pid;
77 char comm[16];
78 struct process_pid_map *hash_next, *list_next;
79};
80
81#define PPM_HASH_SHIFT (8)
82#define PPM_HASH_SIZE (1 << PPM_HASH_SHIFT)
83#define PPM_HASH_MASK (PPM_HASH_SIZE - 1)
84static struct process_pid_map *ppm_hash_table[PPM_HASH_SIZE];
85
152f6476 86struct per_process_info {
2990e589 87 struct process_pid_map *ppm;
152f6476
JA		 88 struct io_stats io_stats;
89 struct per_process_info *hash_next, *list_next;
715d8021 90 int more_than_one;
50adc0ba
JA		 91
92 /*
93 * individual io stats
94 */
b9d40d6f
JA		 95 unsigned long long longest_allocation_wait[2];
96 unsigned long long longest_dispatch_wait[2];
97 unsigned long long longest_completion_wait[2];
d0ca268b
JA		 98};
99
152f6476 100#define PPI_HASH_SHIFT (8)
bf0720af
JA		 101#define PPI_HASH_SIZE (1 << PPI_HASH_SHIFT)
102#define PPI_HASH_MASK (PPI_HASH_SIZE - 1)
103static struct per_process_info *ppi_hash_table[PPI_HASH_SIZE];
152f6476 104static struct per_process_info *ppi_list;
886ecf0e 105static int ppi_list_entries;
152f6476 106
234db09d 107#define S_OPTS "a:A:b:D:d:f:F:hi:o:Oqstw:vV"
d5396421 108static struct option l_opts[] = {
98f8386b
AB		 109 {
110 .name = "act-mask",
111 .has_arg = required_argument,
112 .flag = NULL,
113 .val = 'a'
114 },
115 {
116 .name = "set-mask",
117 .has_arg = required_argument,
118 .flag = NULL,
119 .val = 'A'
120 },
d5396421 121 {
234db09d 122 .name = "batch",
428683db 123 .has_arg = required_argument,
d5396421 124 .flag = NULL,
234db09d 125 .val = 'b'
d5396421
JA		 126 },
127 {
234db09d 128 .name = "input-directory",
428683db 129 .has_arg = required_argument,
d5396421 130 .flag = NULL,
234db09d 131 .val = 'D'
d5396421 132 },
79f19470 133 {
234db09d 134 .name = "dump-binary",
428683db 135 .has_arg = required_argument,
79f19470 136 .flag = NULL,
234db09d 137 .val = 'd'
79f19470 138 },
152f6476 139 {
234db09d
AB		 140 .name = "format",
141 .has_arg = required_argument,
152f6476 142 .flag = NULL,
234db09d 143 .val = 'f'
152f6476 144 },
7997c5b0 145 {
234db09d
AB		 146 .name = "format-spec",
147 .has_arg = required_argument,
7997c5b0 148 .flag = NULL,
234db09d 149 .val = 'F'
7997c5b0 150 },
1e1c60f1 151 {
234db09d 152 .name = "hash-by-name",
428683db 153 .has_arg = no_argument,
1e1c60f1 154 .flag = NULL,
234db09d 155 .val = 'h'
1e1c60f1 156 },
46e6968b 157 {
234db09d 158 .name = "input",
428683db 159 .has_arg = required_argument,
46e6968b 160 .flag = NULL,
234db09d 161 .val = 'i'
46e6968b 162 },
ab197ca7 163 {
234db09d 164 .name = "output",
428683db 165 .has_arg = required_argument,
ab197ca7 166 .flag = NULL,
234db09d 167 .val = 'o'
ab197ca7
AB		 168 },
169 {
234db09d
AB		 170 .name = "no-text-output",
171 .has_arg = no_argument,
ab197ca7 172 .flag = NULL,
234db09d 173 .val = 'O'
ab197ca7 174 },
bf0720af 175 {
234db09d 176 .name = "quiet",
bf0720af
JA		 177 .has_arg = no_argument,
178 .flag = NULL,
234db09d 179 .val = 'q'
bf0720af 180 },
7d1c0411 181 {
234db09d 182 .name = "per-program-stats",
7d1c0411
JA		 183 .has_arg = no_argument,
184 .flag = NULL,
234db09d 185 .val = 's'
7d1c0411 186 },
52724a0e 187 {
234db09d 188 .name = "track-ios",
52724a0e
JA		 189 .has_arg = no_argument,
190 .flag = NULL,
234db09d 191 .val = 't'
52724a0e 192 },
d1d7f15f 193 {
234db09d 194 .name = "stopwatch",
d1d7f15f
JA		 195 .has_arg = required_argument,
196 .flag = NULL,
234db09d 197 .val = 'w'
d1d7f15f 198 },
a2594911 199 {
234db09d
AB		 200 .name = "verbose",
201 .has_arg = no_argument,
a2594911 202 .flag = NULL,
234db09d
AB		 203 .val = 'v'
204 },
205 {
206 .name = "version",
207 .has_arg = no_argument,
208 .flag = NULL,
209 .val = 'V'
a2594911 210 },
71ef8b7c
JA		 211 {
212 .name = NULL,
213 }
d5396421
JA		 214};
215
7997c5b0
JA		 216/*
217 * for sorting the displayed output
218 */
8fc0abbc
JA		 219struct trace {
220 struct blk_io_trace *bit;
221 struct rb_node rb_node;
cb2a1a62 222 struct trace *next;
a43c1c17 223 unsigned long read_sequence;
8fc0abbc
JA		 224};
225
cb2a1a62 226static struct rb_root rb_sort_root;
a649216c
JA		 227static unsigned long rb_sort_entries;
228
cb2a1a62
JA		 229static struct trace *trace_list;
230
d36421e4
JA		 231/*
232 * allocation cache
233 */
234static struct blk_io_trace *bit_alloc_list;
235static struct trace *t_alloc_list;
236
7997c5b0
JA		 237/*
238 * for tracking individual ios
239 */
240struct io_track {
241 struct rb_node rb_node;
242
2990e589 243 struct process_pid_map *ppm;
7997c5b0 244 __u64 sector;
95c15013 245 unsigned long long allocation_time;
7997c5b0
JA		 246 unsigned long long queue_time;
247 unsigned long long dispatch_time;
248 unsigned long long completion_time;
249};
250
e7c9f3ff
NS		 251static int ndevices;
252static struct per_dev_info *devices;
253static char *get_dev_name(struct per_dev_info *, char *, int);
210824c3 254static int trace_rb_insert_last(struct per_dev_info *, struct trace *);
d0ca268b 255
71d5d4c9 256FILE *ofp = NULL;
e7c9f3ff 257static char *output_name;
d1d7f15f 258static char *input_dir;
e7c9f3ff
NS		 259
260static unsigned long long genesis_time;
287fa3d6 261static unsigned long long last_allowed_time;
46e6968b 262static unsigned long long stopwatch_start; /* start from zero by default */
bc171579 263static unsigned long long stopwatch_end = -1ULL; /* "infinity" */
a43c1c17 264static unsigned long read_sequence;
152f6476
JA		 265
266static int per_process_stats;
cbc927b6 267static int per_device_and_cpu_stats = 1;
7997c5b0 268static int track_ios;
bf0720af 269static int ppi_hash_by_pid = 1;
57ea8602 270static int verbose;
98f8386b 271static unsigned int act_mask = -1U;
cbc927b6 272static int stats_printed;
86368eb5 273int data_is_native = -1;
d0ca268b 274
346d8a74 275static FILE *dump_fp;
a2594911
AB		 276static char *dump_binary;
277
1d24fc14
JA		 278static unsigned int t_alloc_cache;
279static unsigned int bit_alloc_cache;
280
7d747d22 281#define RB_BATCH_DEFAULT (512)
e820abd7 282static unsigned int rb_batch = RB_BATCH_DEFAULT;
79f19470 283
e7c9f3ff 284static int pipeline;
67076cbc 285static char *pipename;
e7c9f3ff 286
234db09d
AB		 287static int text_output = 1;
288
412819ce
JA		 289#define is_done() (*(volatile int *)(&done))
290static volatile int done;
291
7bd4fd0a
OK		 292struct timespec abs_start_time;
293static unsigned long long start_timestamp;
294
bf0720af
JA		 295#define JHASH_RANDOM (0x3af5f2ee)
296
824c2b39
JA		 297#define CPUS_PER_LONG (8 * sizeof(unsigned long))
298#define CPU_IDX(cpu) ((cpu) / CPUS_PER_LONG)
299#define CPU_BIT(cpu) ((cpu) & (CPUS_PER_LONG - 1))
300
a2594911
AB		 301static void output_binary(void *buf, int len)
302{
303 if (dump_binary) {
346d8a74
AB		 304 size_t n = fwrite(buf, len, 1, dump_fp);
305 if (n != 1) {
a2594911 306 perror(dump_binary);
346d8a74 307 fclose(dump_fp);
a2594911
AB		 308 dump_binary = NULL;
309 }
310 }
311}
312
210824c3
JA		 313static void resize_cpu_info(struct per_dev_info *pdi, int cpu)
314{
315 struct per_cpu_info *cpus = pdi->cpus;
316 int ncpus = pdi->ncpus;
317 int new_count = cpu + 1;
318 int new_space, size;
319 char *new_start;
320
321 size = new_count * sizeof(struct per_cpu_info);
322 cpus = realloc(cpus, size);
323 if (!cpus) {
324 char name[20];
325 fprintf(stderr, "Out of memory, CPU info for device %s (%d)\n",
326 get_dev_name(pdi, name, sizeof(name)), size);
327 exit(1);
328 }
329
330 new_start = (char *)cpus + (ncpus * sizeof(struct per_cpu_info));
331 new_space = (new_count - ncpus) * sizeof(struct per_cpu_info);
332 memset(new_start, 0, new_space);
333
334 pdi->ncpus = new_count;
335 pdi->cpus = cpus;
336
337 for (new_count = 0; new_count < pdi->ncpus; new_count++) {
338 struct per_cpu_info *pci = &pdi->cpus[new_count];
339
340 if (!pci->fd) {
341 pci->fd = -1;
342 memset(&pci->rb_last, 0, sizeof(pci->rb_last));
343 pci->rb_last_entries = 0;
344 pci->last_sequence = -1;
345 }
346 }
347}
348
349static struct per_cpu_info *get_cpu_info(struct per_dev_info *pdi, int cpu)
350{
351 struct per_cpu_info *pci;
352
353 if (cpu >= pdi->ncpus)
354 resize_cpu_info(pdi, cpu);
355
356 pci = &pdi->cpus[cpu];
357 pci->cpu = cpu;
358 return pci;
359}
360
361
362static int resize_devices(char *name)
363{
364 int size = (ndevices + 1) * sizeof(struct per_dev_info);
365
366 devices = realloc(devices, size);
367 if (!devices) {
368 fprintf(stderr, "Out of memory, device %s (%d)\n", name, size);
369 return 1;
370 }
371 memset(&devices[ndevices], 0, sizeof(struct per_dev_info));
372 devices[ndevices].name = name;
373 ndevices++;
374 return 0;
375}
376
377static struct per_dev_info *get_dev_info(dev_t dev)
378{
379 struct per_dev_info *pdi;
380 int i;
381
382 for (i = 0; i < ndevices; i++) {
383 if (!devices[i].dev)
384 devices[i].dev = dev;
385 if (devices[i].dev == dev)
386 return &devices[i];
387 }
388
389 if (resize_devices(NULL))
390 return NULL;
391
392 pdi = &devices[ndevices - 1];
393 pdi->dev = dev;
394 pdi->first_reported_time = 0;
395 pdi->last_read_time = 0;
210824c3
JA		 396
397 return pdi;
398}
399
66930177 400static void insert_skip(struct per_cpu_info *pci, unsigned long start,
492da111
AB		 401 unsigned long end)
402{
403 struct skip_info *sip;
404
66930177 405 for (sip = pci->skips_tail; sip != NULL; sip = sip->prev) {
492da111
AB		 406 if (end == (sip->start - 1)) {
407 sip->start = start;
408 return;
409 } else if (start == (sip->end + 1)) {
410 sip->end = end;
411 return;
412 }
413 }
414
415 sip = malloc(sizeof(struct skip_info));
416 sip->start = start;
417 sip->end = end;
418 sip->prev = sip->next = NULL;
66930177
JA		 419 if (pci->skips_tail == NULL)
420 pci->skips_head = pci->skips_tail = sip;
492da111 421 else {
66930177
JA		 422 sip->prev = pci->skips_tail;
423 pci->skips_tail->next = sip;
424 pci->skips_tail = sip;
492da111
AB		 425 }
426}
427
66930177 428static void remove_sip(struct per_cpu_info *pci, struct skip_info *sip)
492da111
AB		 429{
430 if (sip->prev == NULL) {
431 if (sip->next == NULL)
66930177 432 pci->skips_head = pci->skips_tail = NULL;
492da111 433 else {
66930177 434 pci->skips_head = sip->next;
492da111
AB		 435 sip->next->prev = NULL;
436 }
437 } else if (sip->next == NULL) {
66930177 438 pci->skips_tail = sip->prev;
492da111
AB		 439 sip->prev->next = NULL;
440 } else {
441 sip->prev->next = sip->next;
442 sip->next->prev = sip->prev;
443 }
444
445 sip->prev = sip->next = NULL;
446 free(sip);
447}
448
449#define IN_SKIP(sip,seq) (((sip)->start <= (seq)) && ((seq) <= sip->end))
66930177 450static int check_current_skips(struct per_cpu_info *pci, unsigned long seq)
492da111
AB		 451{
452 struct skip_info *sip;
453
66930177
JA		 454 for (sip = pci->skips_tail; sip != NULL; sip = sip->prev) {
455 if (IN_SKIP(sip, seq)) {
492da111
AB		 456 if (sip->start == seq) {
457 if (sip->end == seq)
66930177 458 remove_sip(pci, sip);
492da111
AB		 459 else
460 sip->start += 1;
461 } else if (sip->end == seq)
462 sip->end -= 1;
463 else {
464 sip->end = seq - 1;
66930177 465 insert_skip(pci, seq + 1, sip->end);
492da111
AB		 466 }
467 return 1;
468 }
469 }
66930177 470
492da111
AB		 471 return 0;
472}
473
474static void collect_pdi_skips(struct per_dev_info *pdi)
475{
476 struct skip_info *sip;
66930177 477 int cpu;
492da111
AB		 478
479 pdi->skips = 0;
480 pdi->seq_skips = 0;
66930177
JA		 481
482 for (cpu = 0; cpu < pdi->ncpus; cpu++) {
483 struct per_cpu_info *pci = &pdi->cpus[cpu];
484
485 for (sip = pci->skips_head; sip != NULL; sip = sip->next) {
486 pdi->skips++;
487 pdi->seq_skips += (sip->end - sip->start + 1);
488 if (verbose)
489 fprintf(stderr,"(%d,%d): skipping %lu -> %lu\n",
490 MAJOR(pdi->dev), MINOR(pdi->dev),
491 sip->start, sip->end);
492 }
492da111
AB		 493 }
494}
495
824c2b39
JA		 496static void cpu_mark_online(struct per_dev_info *pdi, unsigned int cpu)
497{
498 if (cpu >= pdi->cpu_map_max || !pdi->cpu_map) {
499 int new_max = (cpu + CPUS_PER_LONG) & ~(CPUS_PER_LONG - 1);
500 unsigned long *map = malloc(new_max / sizeof(long));
501
502 memset(map, 0, new_max / sizeof(long));
503
504 if (pdi->cpu_map) {
505 memcpy(map, pdi->cpu_map, pdi->cpu_map_max / sizeof(long));
506 free(pdi->cpu_map);
507 }
508
509 pdi->cpu_map = map;
510 pdi->cpu_map_max = new_max;
511 }
512
513 pdi->cpu_map[CPU_IDX(cpu)] |= (1UL << CPU_BIT(cpu));
514}
515
516static inline void cpu_mark_offline(struct per_dev_info *pdi, int cpu)
517{
518 pdi->cpu_map[CPU_IDX(cpu)] &= ~(1UL << CPU_BIT(cpu));
519}
520
521static inline int cpu_is_online(struct per_dev_info *pdi, int cpu)
522{
523 return (pdi->cpu_map[CPU_IDX(cpu)] & (1UL << CPU_BIT(cpu))) != 0;
524}
525
bfc70ad5
JA		 526static inline int ppm_hash_pid(pid_t pid)
527{
528 return jhash_1word(pid, JHASH_RANDOM) & PPM_HASH_MASK;
529}
530
531static struct process_pid_map *find_ppm(pid_t pid)
532{
533 const int hash_idx = ppm_hash_pid(pid);
534 struct process_pid_map *ppm;
535
536 ppm = ppm_hash_table[hash_idx];
537 while (ppm) {
538 if (ppm->pid == pid)
539 return ppm;
540
541 ppm = ppm->hash_next;
542 }
543
544 return NULL;
545}
546
547static void add_ppm_hash(pid_t pid, const char *name)
548{
549 const int hash_idx = ppm_hash_pid(pid);
550 struct process_pid_map *ppm;
551
552 ppm = find_ppm(pid);
248eac8f
JA		 553 if (!ppm) {
554 ppm = malloc(sizeof(*ppm));
555 memset(ppm, 0, sizeof(*ppm));
556 ppm->pid = pid;
557 strcpy(ppm->comm, name);
558 ppm->hash_next = ppm_hash_table[hash_idx];
559 ppm_hash_table[hash_idx] = ppm;
bfc70ad5 560 }
bfc70ad5
JA		 561}
562
7bd4fd0a
OK		 563static void handle_notify(struct blk_io_trace *bit)
564{
565 void *payload = (caddr_t) bit + sizeof(*bit);
566 __u32 two32[2];
567
568 switch (bit->action) {
569 case BLK_TN_PROCESS:
570 add_ppm_hash(bit->pid, payload);
571 break;
572
573 case BLK_TN_TIMESTAMP:
574 if (bit->pdu_len != sizeof(two32))
575 return;
576 memcpy(two32, payload, sizeof(two32));
577 if (!data_is_native) {
578 two32[0] = be32_to_cpu(two32[0]);
579 two32[1] = be32_to_cpu(two32[1]);
580 }
581 start_timestamp = bit->time;
582 abs_start_time.tv_sec = two32[0];
583 abs_start_time.tv_nsec = two32[1];
584 if (abs_start_time.tv_nsec < 0) {
585 abs_start_time.tv_sec--;
586 abs_start_time.tv_nsec += 1000000000;
587 }
588
589 break;
590
591 default:
592 /* Ignore unknown notify events */
593 ;
594 }
595}
596
bfc70ad5
JA		 597char *find_process_name(pid_t pid)
598{
599 struct process_pid_map *ppm = find_ppm(pid);
600
601 if (ppm)
602 return ppm->comm;
603
604 return NULL;
605}
606
9e4cd1b8 607static inline int ppi_hash_pid(pid_t pid)
bf0720af
JA		 608{
609 return jhash_1word(pid, JHASH_RANDOM) & PPI_HASH_MASK;
610}
611
612static inline int ppi_hash_name(const char *name)
152f6476 613{
bf0720af
JA		 614 return jhash(name, 16, JHASH_RANDOM) & PPI_HASH_MASK;
615}
616
617static inline int ppi_hash(struct per_process_info *ppi)
618{
2990e589
JA		 619 struct process_pid_map *ppm = ppi->ppm;
620
bf0720af 621 if (ppi_hash_by_pid)
2990e589 622 return ppi_hash_pid(ppm->pid);
bf0720af 623
2990e589 624 return ppi_hash_name(ppm->comm);
152f6476
JA		 625}
626
bfc70ad5 627static inline void add_ppi_to_hash(struct per_process_info *ppi)
152f6476 628{
bf0720af 629 const int hash_idx = ppi_hash(ppi);
152f6476 630
bf0720af
JA		 631 ppi->hash_next = ppi_hash_table[hash_idx];
632 ppi_hash_table[hash_idx] = ppi;
152f6476
JA		 633}
634
bfc70ad5 635static inline void add_ppi_to_list(struct per_process_info *ppi)
152f6476
JA		 636{
637 ppi->list_next = ppi_list;
638 ppi_list = ppi;
886ecf0e 639 ppi_list_entries++;
152f6476
JA		 640}
641
bfc70ad5 642static struct per_process_info *find_ppi_by_name(char *name)
bf0720af
JA		 643{
644 const int hash_idx = ppi_hash_name(name);
645 struct per_process_info *ppi;
646
647 ppi = ppi_hash_table[hash_idx];
648 while (ppi) {
2990e589
JA		 649 struct process_pid_map *ppm = ppi->ppm;
650
651 if (!strcmp(ppm->comm, name))
bf0720af
JA		 652 return ppi;
653
654 ppi = ppi->hash_next;
655 }
656
657 return NULL;
658}
659
9e4cd1b8 660static struct per_process_info *find_ppi_by_pid(pid_t pid)
152f6476 661{
bf0720af 662 const int hash_idx = ppi_hash_pid(pid);
152f6476
JA		 663 struct per_process_info *ppi;
664
bf0720af 665 ppi = ppi_hash_table[hash_idx];
152f6476 666 while (ppi) {
2990e589
JA		 667 struct process_pid_map *ppm = ppi->ppm;
668
669 if (ppm->pid == pid)
152f6476
JA		 670 return ppi;
671
672 ppi = ppi->hash_next;
673 }
674
675 return NULL;
676}
677
9e4cd1b8 678static struct per_process_info *find_ppi(pid_t pid)
bf0720af 679{
715d8021 680 struct per_process_info *ppi;
bfc70ad5 681 char *name;
715d8021 682
bf0720af 683 if (ppi_hash_by_pid)
bfc70ad5
JA		 684 return find_ppi_by_pid(pid);
685
686 name = find_process_name(pid);
687 if (!name)
688 return NULL;
bf0720af 689
bfc70ad5 690 ppi = find_ppi_by_name(name);
2990e589 691 if (ppi && ppi->ppm->pid != pid)
715d8021
JA		 692 ppi->more_than_one = 1;
693
694 return ppi;
bf0720af
JA		 695}
696
210824c3
JA		 697/*
698 * struct trace and blktrace allocation cache, we do potentially
699 * millions of mallocs for these structures while only using at most
700 * a few thousand at the time
701 */
702static inline void t_free(struct trace *t)
703{
704 if (t_alloc_cache < 1024) {
705 t->next = t_alloc_list;
706 t_alloc_list = t;
707 t_alloc_cache++;
708 } else
709 free(t);
710}
711
712static inline struct trace *t_alloc(void)
713{
714 struct trace *t = t_alloc_list;
715
716 if (t) {
717 t_alloc_list = t->next;
718 t_alloc_cache--;
719 return t;
720 }
721
722 return malloc(sizeof(*t));
723}
724
725static inline void bit_free(struct blk_io_trace *bit)
726{
727 if (bit_alloc_cache < 1024 && !bit->pdu_len) {
728 /*
729 * abuse a 64-bit field for a next pointer for the free item
730 */
731 bit->time = (__u64) (unsigned long) bit_alloc_list;
732 bit_alloc_list = (struct blk_io_trace *) bit;
733 bit_alloc_cache++;
734 } else
735 free(bit);
736}
737
738static inline struct blk_io_trace *bit_alloc(void)
739{
740 struct blk_io_trace *bit = bit_alloc_list;
741
742 if (bit) {
743 bit_alloc_list = (struct blk_io_trace *) (unsigned long) \
744 bit->time;
745 bit_alloc_cache--;
746 return bit;
747 }
748
749 return malloc(sizeof(*bit));
750}
751
752static inline void __put_trace_last(struct per_dev_info *pdi, struct trace *t)
753{
754 struct per_cpu_info *pci = get_cpu_info(pdi, t->bit->cpu);
755
756 rb_erase(&t->rb_node, &pci->rb_last);
757 pci->rb_last_entries--;
758
759 bit_free(t->bit);
760 t_free(t);
761}
762
763static void put_trace(struct per_dev_info *pdi, struct trace *t)
764{
765 rb_erase(&t->rb_node, &rb_sort_root);
766 rb_sort_entries--;
767
768 trace_rb_insert_last(pdi, t);
769}
770
89482da6 771static inline int trace_rb_insert(struct trace *t, struct rb_root *root)
7997c5b0 772{
2a1b3424 773 struct rb_node **p = &root->rb_node;
7997c5b0
JA		 774 struct rb_node *parent = NULL;
775 struct trace *__t;
776
777 while (*p) {
778 parent = *p;
2a1b3424 779
7997c5b0
JA		 780 __t = rb_entry(parent, struct trace, rb_node);
781
89482da6
JA		 782 if (t->bit->time < __t->bit->time)
783 p = &(*p)->rb_left;
784 else if (t->bit->time > __t->bit->time)
785 p = &(*p)->rb_right;
786 else if (t->bit->device < __t->bit->device)
e7c9f3ff
NS		 787 p = &(*p)->rb_left;
788 else if (t->bit->device > __t->bit->device)
789 p = &(*p)->rb_right;
dcf0f7ed
JA		 790 else if (t->bit->sequence < __t->bit->sequence)
791 p = &(*p)->rb_left;
0b07f23e 792 else /* >= sequence */
dcf0f7ed 793 p = &(*p)->rb_right;
7997c5b0
JA		 794 }
795
796 rb_link_node(&t->rb_node, parent, p);
2a1b3424 797 rb_insert_color(&t->rb_node, root);
7997c5b0
JA		 798 return 0;
799}
800
2a1b3424 801static inline int trace_rb_insert_sort(struct trace *t)
e3556946 802{
89482da6 803 if (!trace_rb_insert(t, &rb_sort_root)) {
2a1b3424
JA		 804 rb_sort_entries++;
805 return 0;
806 }
807
808 return 1;
809}
810
210824c3 811static int trace_rb_insert_last(struct per_dev_info *pdi, struct trace *t)
2a1b3424 812{
210824c3
JA		 813 struct per_cpu_info *pci = get_cpu_info(pdi, t->bit->cpu);
814
815 if (trace_rb_insert(t, &pci->rb_last))
816 return 1;
817
818 pci->rb_last_entries++;
819
820 if (pci->rb_last_entries > rb_batch * pdi->nfiles) {
821 struct rb_node *n = rb_first(&pci->rb_last);
822
823 t = rb_entry(n, struct trace, rb_node);
824 __put_trace_last(pdi, t);
2a1b3424
JA		 825 }
826
210824c3 827 return 0;
2a1b3424
JA		 828}
829
830static struct trace *trace_rb_find(dev_t device, unsigned long sequence,
831 struct rb_root *root, int order)
832{
833 struct rb_node *n = root->rb_node;
834 struct rb_node *prev = NULL;
e3556946
JA		 835 struct trace *__t;
836
2a1b3424
JA		 837 while (n) {
838 __t = rb_entry(n, struct trace, rb_node);
839 prev = n;
e3556946 840
0583b6a2 841 if (device < __t->bit->device)
2a1b3424 842 n = n->rb_left;
0583b6a2 843 else if (device > __t->bit->device)
2a1b3424 844 n = n->rb_right;
0583b6a2 845 else if (sequence < __t->bit->sequence)
2a1b3424 846 n = n->rb_left;
e3556946 847 else if (sequence > __t->bit->sequence)
2a1b3424 848 n = n->rb_right;
e3556946
JA		 849 else
850 return __t;
851 }
852
2a1b3424
JA		 853 /*
854 * hack - the list may not be sequence ordered because some
855 * events don't have sequence and time matched. so we end up
856 * being a little off in the rb lookup here, because we don't
857 * know the time we are looking for. compensate by browsing
858 * a little ahead from the last entry to find the match
859 */
860 if (order && prev) {
861 int max = 5;
862
863 while (((n = rb_next(prev)) != NULL) && max--) {
864 __t = rb_entry(n, struct trace, rb_node);
492da111 865
2a1b3424
JA		 866 if (__t->bit->device == device &&
867 __t->bit->sequence == sequence)
868 return __t;
869
870 prev = n;
871 }
872 }
492da111 873
e3556946
JA		 874 return NULL;
875}
876
2a1b3424 877static inline struct trace *trace_rb_find_last(struct per_dev_info *pdi,
210824c3 878 struct per_cpu_info *pci,
2a1b3424
JA		 879 unsigned long seq)
880{
210824c3 881 return trace_rb_find(pdi->dev, seq, &pci->rb_last, 0);
2a1b3424
JA		 882}
883
f7bd1a9b 884static inline int track_rb_insert(struct per_dev_info *pdi,struct io_track *iot)
7997c5b0 885{
f7bd1a9b 886 struct rb_node **p = &pdi->rb_track.rb_node;
7997c5b0
JA		 887 struct rb_node *parent = NULL;
888 struct io_track *__iot;
889
890 while (*p) {
891 parent = *p;
7997c5b0
JA		 892 __iot = rb_entry(parent, struct io_track, rb_node);
893
f7bd1a9b 894 if (iot->sector < __iot->sector)
7997c5b0
JA		 895 p = &(*p)->rb_left;
896 else if (iot->sector > __iot->sector)
897 p = &(*p)->rb_right;
898 else {
e7c9f3ff 899 fprintf(stderr,
ab197ca7
AB		 900 "sector alias (%Lu) on device %d,%d!\n",
901 (unsigned long long) iot->sector,
f7bd1a9b 902 MAJOR(pdi->dev), MINOR(pdi->dev));
7997c5b0
JA		 903 return 1;
904 }
905 }
906
907 rb_link_node(&iot->rb_node, parent, p);
f7bd1a9b 908 rb_insert_color(&iot->rb_node, &pdi->rb_track);
7997c5b0
JA		 909 return 0;
910}
911
f7bd1a9b 912static struct io_track *__find_track(struct per_dev_info *pdi, __u64 sector)
7997c5b0 913{
f7bd1a9b 914 struct rb_node *n = pdi->rb_track.rb_node;
7997c5b0
JA		 915 struct io_track *__iot;
916
2a1b3424
JA		 917 while (n) {
918 __iot = rb_entry(n, struct io_track, rb_node);
7997c5b0 919
f7bd1a9b 920 if (sector < __iot->sector)
2a1b3424 921 n = n->rb_left;
7997c5b0 922 else if (sector > __iot->sector)
2a1b3424 923 n = n->rb_right;
7997c5b0
JA		 924 else
925 return __iot;
926 }
927
928 return NULL;
929}
930
9e4cd1b8 931static struct io_track *find_track(struct per_dev_info *pdi, pid_t pid,
bfc70ad5 932 __u64 sector)
7997c5b0 933{
916b5501 934 struct io_track *iot;
7997c5b0 935
f7bd1a9b 936 iot = __find_track(pdi, sector);
7997c5b0
JA		 937 if (!iot) {
938 iot = malloc(sizeof(*iot));
2990e589 939 iot->ppm = find_ppm(pid);
7997c5b0 940 iot->sector = sector;
f7bd1a9b 941 track_rb_insert(pdi, iot);
7997c5b0
JA		 942 }
943
944 return iot;
945}
946
f7bd1a9b
JA		 947static void log_track_frontmerge(struct per_dev_info *pdi,
948 struct blk_io_trace *t)
2e3e8ded
JA		 949{
950 struct io_track *iot;
951
952 if (!track_ios)
953 return;
2e3e8ded 954
ae957cbc 955 iot = __find_track(pdi, t->sector + t_sec(t));
cb2a1a62 956 if (!iot) {
57ea8602
JA		 957 if (verbose)
958 fprintf(stderr, "merge not found for (%d,%d): %llu\n",
959 MAJOR(pdi->dev), MINOR(pdi->dev),
960 (unsigned long long) t->sector + t_sec(t));
cb2a1a62 961 return;
2e3e8ded 962 }
cb2a1a62 963
f7bd1a9b 964 rb_erase(&iot->rb_node, &pdi->rb_track);
ae957cbc 965 iot->sector -= t_sec(t);
f7bd1a9b 966 track_rb_insert(pdi, iot);
2e3e8ded
JA		 967}
968
f7bd1a9b 969static void log_track_getrq(struct per_dev_info *pdi, struct blk_io_trace *t)
2e3e8ded
JA		 970{
971 struct io_track *iot;
972
973 if (!track_ios)
974 return;
975
bfc70ad5 976 iot = find_track(pdi, t->pid, t->sector);
95c15013
JA		 977 iot->allocation_time = t->time;
978}
979
753f9091
JA		 980static inline int is_remapper(struct per_dev_info *pdi)
981{
982 int major = MAJOR(pdi->dev);
983
984 return (major == 253 || major == 9);
985}
986
987/*
988 * for md/dm setups, the interesting cycle is Q -> C. So track queueing
989 * time here, as dispatch time
990 */
991static void log_track_queue(struct per_dev_info *pdi, struct blk_io_trace *t)
992{
993 struct io_track *iot;
994
995 if (!track_ios)
996 return;
997 if (!is_remapper(pdi))
998 return;
999
bfc70ad5 1000 iot = find_track(pdi, t->pid, t->sector);
753f9091
JA		 1001 iot->dispatch_time = t->time;
1002}
1003
95c15013 1004/*
b6076a9b 1005 * return time between rq allocation and insertion
95c15013 1006 */
f7bd1a9b
JA		 1007static unsigned long long log_track_insert(struct per_dev_info *pdi,
1008 struct blk_io_trace *t)
95c15013 1009{
50adc0ba 1010 unsigned long long elapsed;
95c15013
JA		 1011 struct io_track *iot;
1012
1013 if (!track_ios)
1014 return -1;
1015
bfc70ad5 1016 iot = find_track(pdi, t->pid, t->sector);
2e3e8ded 1017 iot->queue_time = t->time;
acd70d21
JA		 1018
1019 if (!iot->allocation_time)
1020 return -1;
1021
50adc0ba
JA		 1022 elapsed = iot->queue_time - iot->allocation_time;
1023
1024 if (per_process_stats) {
2990e589 1025 struct per_process_info *ppi = find_ppi(iot->ppm->pid);
b9d40d6f 1026 int w = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
50adc0ba 1027
b9d40d6f
JA		 1028 if (ppi && elapsed > ppi->longest_allocation_wait[w])
1029 ppi->longest_allocation_wait[w] = elapsed;
50adc0ba
JA		 1030 }
1031
1032 return elapsed;
2e3e8ded
JA		 1033}
1034
1035/*
1036 * return time between queue and issue
1037 */
f7bd1a9b
JA		 1038static unsigned long long log_track_issue(struct per_dev_info *pdi,
1039 struct blk_io_trace *t)
2e3e8ded 1040{
50adc0ba 1041 unsigned long long elapsed;
2e3e8ded
JA		 1042 struct io_track *iot;
1043
1044 if (!track_ios)
1045 return -1;
1046 if ((t->action & BLK_TC_ACT(BLK_TC_FS)) == 0)
1047 return -1;
1048
f7bd1a9b 1049 iot = __find_track(pdi, t->sector);
cb2a1a62 1050 if (!iot) {
57ea8602
JA		 1051 if (verbose)
1052 fprintf(stderr, "issue not found for (%d,%d): %llu\n",
1053 MAJOR(pdi->dev), MINOR(pdi->dev),
1054 (unsigned long long) t->sector);
2e3e8ded 1055 return -1;
cb2a1a62 1056 }
2e3e8ded
JA		 1057
1058 iot->dispatch_time = t->time;
50adc0ba
JA		 1059 elapsed = iot->dispatch_time - iot->queue_time;
1060
1061 if (per_process_stats) {
2990e589 1062 struct per_process_info *ppi = find_ppi(iot->ppm->pid);
b9d40d6f 1063 int w = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
50adc0ba 1064
b9d40d6f
JA		 1065 if (ppi && elapsed > ppi->longest_dispatch_wait[w])
1066 ppi->longest_dispatch_wait[w] = elapsed;
50adc0ba
JA		 1067 }
1068
1069 return elapsed;
2e3e8ded
JA		 1070}
1071
1072/*
1073 * return time between dispatch and complete
1074 */
f7bd1a9b
JA		 1075static unsigned long long log_track_complete(struct per_dev_info *pdi,
1076 struct blk_io_trace *t)
2e3e8ded
JA		 1077{
1078 unsigned long long elapsed;
1079 struct io_track *iot;
1080
1081 if (!track_ios)
1082 return -1;
2e3e8ded 1083
f7bd1a9b 1084 iot = __find_track(pdi, t->sector);
cb2a1a62 1085 if (!iot) {
57ea8602
JA		 1086 if (verbose)
1087 fprintf(stderr,"complete not found for (%d,%d): %llu\n",
1088 MAJOR(pdi->dev), MINOR(pdi->dev),
1089 (unsigned long long) t->sector);
2e3e8ded 1090 return -1;
cb2a1a62 1091 }
2e3e8ded
JA		 1092
1093 iot->completion_time = t->time;
1094 elapsed = iot->completion_time - iot->dispatch_time;
1095
50adc0ba 1096 if (per_process_stats) {
2990e589 1097 struct per_process_info *ppi = find_ppi(iot->ppm->pid);
b9d40d6f 1098 int w = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
50adc0ba 1099
b9d40d6f
JA		 1100 if (ppi && elapsed > ppi->longest_completion_wait[w])
1101 ppi->longest_completion_wait[w] = elapsed;
50adc0ba
JA		 1102 }
1103
2e3e8ded
JA		 1104 /*
1105 * kill the trace, we don't need it after completion
1106 */
f7bd1a9b 1107 rb_erase(&iot->rb_node, &pdi->rb_track);
2e3e8ded
JA		 1108 free(iot);
1109
1110 return elapsed;
1111}
1112
1113
9e4cd1b8 1114static struct io_stats *find_process_io_stats(pid_t pid)
152f6476 1115{
bfc70ad5 1116 struct per_process_info *ppi = find_ppi(pid);
152f6476
JA		 1117
1118 if (!ppi) {
1119 ppi = malloc(sizeof(*ppi));
1120 memset(ppi, 0, sizeof(*ppi));
2990e589 1121 ppi->ppm = find_ppm(pid);
bfc70ad5
JA		 1122 add_ppi_to_hash(ppi);
1123 add_ppi_to_list(ppi);
152f6476
JA		 1124 }
1125
1126 return &ppi->io_stats;
1127}
1128
e7c9f3ff
NS		 1129static char *get_dev_name(struct per_dev_info *pdi, char *buffer, int size)
1130{
1131 if (pdi->name)
1132 snprintf(buffer, size, "%s", pdi->name);
1133 else
f7bd1a9b 1134 snprintf(buffer, size, "%d,%d",MAJOR(pdi->dev),MINOR(pdi->dev));
e7c9f3ff
NS		 1135 return buffer;
1136}
1137
e7c9f3ff 1138static void check_time(struct per_dev_info *pdi, struct blk_io_trace *bit)
cfab07eb
AB		 1139{
1140 unsigned long long this = bit->time;
e7c9f3ff 1141 unsigned long long last = pdi->last_reported_time;
cfab07eb 1142
e7c9f3ff
NS		 1143 pdi->backwards = (this < last) ? 'B' : ' ';
1144 pdi->last_reported_time = this;
cfab07eb
AB		 1145}
1146
152f6476
JA		 1147static inline void __account_m(struct io_stats *ios, struct blk_io_trace *t,
1148 int rw)
d0ca268b
JA		 1149{
1150 if (rw) {
152f6476 1151 ios->mwrites++;
ae957cbc 1152 ios->qwrite_kb += t_kb(t);
d0ca268b 1153 } else {
152f6476 1154 ios->mreads++;
ae957cbc 1155 ios->qread_kb += t_kb(t);
152f6476
JA		 1156 }
1157}
1158
1159static inline void account_m(struct blk_io_trace *t, struct per_cpu_info *pci,
1160 int rw)
1161{
1162 __account_m(&pci->io_stats, t, rw);
1163
1164 if (per_process_stats) {
bfc70ad5 1165 struct io_stats *ios = find_process_io_stats(t->pid);
152f6476
JA		 1166
1167 __account_m(ios, t, rw);
d0ca268b
JA		 1168 }
1169}
1170
b6076a9b
JA		 1171static inline void __account_queue(struct io_stats *ios, struct blk_io_trace *t,
1172 int rw)
d0ca268b
JA		 1173{
1174 if (rw) {
152f6476 1175 ios->qwrites++;
ae957cbc 1176 ios->qwrite_kb += t_kb(t);
d0ca268b 1177 } else {
152f6476 1178 ios->qreads++;
ae957cbc 1179 ios->qread_kb += t_kb(t);
152f6476
JA		 1180 }
1181}
1182
b6076a9b
JA		 1183static inline void account_queue(struct blk_io_trace *t,
1184 struct per_cpu_info *pci, int rw)
152f6476 1185{
b6076a9b 1186 __account_queue(&pci->io_stats, t, rw);
152f6476
JA		 1187
1188 if (per_process_stats) {
bfc70ad5 1189 struct io_stats *ios = find_process_io_stats(t->pid);
152f6476 1190
b6076a9b 1191 __account_queue(ios, t, rw);
d0ca268b
JA		 1192 }
1193}
1194
e21dc4dd 1195static inline void __account_c(struct io_stats *ios, int rw, int bytes)
d0ca268b
JA		 1196{
1197 if (rw) {
152f6476
JA		 1198 ios->cwrites++;
1199 ios->cwrite_kb += bytes >> 10;
d0ca268b 1200 } else {
152f6476
JA		 1201 ios->creads++;
1202 ios->cread_kb += bytes >> 10;
1203 }
1204}
1205
1206static inline void account_c(struct blk_io_trace *t, struct per_cpu_info *pci,
1207 int rw, int bytes)
1208{
1209 __account_c(&pci->io_stats, rw, bytes);
1210
1211 if (per_process_stats) {
bfc70ad5 1212 struct io_stats *ios = find_process_io_stats(t->pid);
152f6476
JA		 1213
1214 __account_c(ios, rw, bytes);
d0ca268b
JA		 1215 }
1216}
1217
b6076a9b
JA		 1218static inline void __account_issue(struct io_stats *ios, int rw,
1219 unsigned int bytes)
afd2d7ad 1220{
1221 if (rw) {
152f6476
JA		 1222 ios->iwrites++;
1223 ios->iwrite_kb += bytes >> 10;
afd2d7ad 1224 } else {
152f6476
JA		 1225 ios->ireads++;
1226 ios->iread_kb += bytes >> 10;
afd2d7ad 1227 }
1228}
1229
b6076a9b
JA		 1230static inline void account_issue(struct blk_io_trace *t,
1231 struct per_cpu_info *pci, int rw)
d0ca268b 1232{
b6076a9b 1233 __account_issue(&pci->io_stats, rw, t->bytes);
152f6476
JA		 1234
1235 if (per_process_stats) {
bfc70ad5 1236 struct io_stats *ios = find_process_io_stats(t->pid);
d5396421 1237
b6076a9b 1238 __account_issue(ios, rw, t->bytes);
152f6476
JA		 1239 }
1240}
1241
06639b27
JA		 1242static inline void __account_unplug(struct io_stats *ios, int timer)
1243{
1244 if (timer)
1245 ios->timer_unplugs++;
1246 else
1247 ios->io_unplugs++;
1248}
1249
1250static inline void account_unplug(struct blk_io_trace *t,
1251 struct per_cpu_info *pci, int timer)
1252{
1253 __account_unplug(&pci->io_stats, timer);
1254
1255 if (per_process_stats) {
bfc70ad5 1256 struct io_stats *ios = find_process_io_stats(t->pid);
06639b27
JA		 1257
1258 __account_unplug(ios, timer);
1259 }
1260}
1261
4054070a
JA		 1262static inline void __account_requeue(struct io_stats *ios,
1263 struct blk_io_trace *t, int rw)
1264{
1265 if (rw) {
1266 ios->wrqueue++;
1267 ios->iwrite_kb -= t_kb(t);
1268 } else {
1269 ios->rrqueue++;
1270 ios->iread_kb -= t_kb(t);
1271 }
1272}
1273
1274static inline void account_requeue(struct blk_io_trace *t,
1275 struct per_cpu_info *pci, int rw)
1276{
1277 __account_requeue(&pci->io_stats, t, rw);
1278
1279 if (per_process_stats) {
bfc70ad5 1280 struct io_stats *ios = find_process_io_stats(t->pid);
4054070a
JA		 1281
1282 __account_requeue(ios, t, rw);
1283 }
1284}
1285
f7bd1a9b
JA		 1286static void log_complete(struct per_dev_info *pdi, struct per_cpu_info *pci,
1287 struct blk_io_trace *t, char *act)
ab197ca7 1288{
f7bd1a9b 1289 process_fmt(act, pci, t, log_track_complete(pdi, t), 0, NULL);
ab197ca7
AB		 1290}
1291
f7bd1a9b
JA		 1292static void log_insert(struct per_dev_info *pdi, struct per_cpu_info *pci,
1293 struct blk_io_trace *t, char *act)
b6076a9b 1294{
f7bd1a9b 1295 process_fmt(act, pci, t, log_track_insert(pdi, t), 0, NULL);
b6076a9b
JA		 1296}
1297
ab197ca7
AB		 1298static void log_queue(struct per_cpu_info *pci, struct blk_io_trace *t,
1299 char *act)
1300{
b6076a9b 1301 process_fmt(act, pci, t, -1, 0, NULL);
ab197ca7 1302}
2e3e8ded 1303
f7bd1a9b
JA		 1304static void log_issue(struct per_dev_info *pdi, struct per_cpu_info *pci,
1305 struct blk_io_trace *t, char *act)
ab197ca7 1306{
f7bd1a9b 1307 process_fmt(act, pci, t, log_track_issue(pdi, t), 0, NULL);
d0ca268b
JA		 1308}
1309
f7bd1a9b
JA		 1310static void log_merge(struct per_dev_info *pdi, struct per_cpu_info *pci,
1311 struct blk_io_trace *t, char *act)
d0ca268b 1312{
a01516de 1313 if (act[0] == 'F')
f7bd1a9b 1314 log_track_frontmerge(pdi, t);
2e3e8ded 1315
ab197ca7 1316 process_fmt(act, pci, t, -1ULL, 0, NULL);
d0ca268b
JA		 1317}
1318
dfe34da1 1319static void log_action(struct per_cpu_info *pci, struct blk_io_trace *t,
3639a11e 1320 char *act)
dfe34da1 1321{
ab197ca7 1322 process_fmt(act, pci, t, -1ULL, 0, NULL);
dfe34da1
JA		 1323}
1324
d5396421 1325static void log_generic(struct per_cpu_info *pci, struct blk_io_trace *t,
3639a11e 1326 char *act)
d0ca268b 1327{
ab197ca7 1328 process_fmt(act, pci, t, -1ULL, 0, NULL);
d0ca268b
JA		 1329}
1330
ab197ca7 1331static void log_unplug(struct per_cpu_info *pci, struct blk_io_trace *t,
3639a11e 1332 char *act)
67e14fdc 1333{
ab197ca7 1334 process_fmt(act, pci, t, -1ULL, 0, NULL);
67e14fdc
JA		 1335}
1336
93f1c611
JA		 1337static void log_split(struct per_cpu_info *pci, struct blk_io_trace *t,
1338 char *act)
1339{
1340 process_fmt(act, pci, t, -1ULL, 0, NULL);
1341}
1342
ab197ca7 1343static void log_pc(struct per_cpu_info *pci, struct blk_io_trace *t, char *act)
d0ca268b 1344{
ab197ca7 1345 unsigned char *buf = (unsigned char *) t + sizeof(*t);
d0ca268b 1346
ab197ca7 1347 process_fmt(act, pci, t, -1ULL, t->pdu_len, buf);
d0ca268b
JA		 1348}
1349
ff3a732c 1350static void dump_trace_pc(struct blk_io_trace *t, struct per_cpu_info *pci)
d0ca268b 1351{
56f2af81
JA		 1352 int act = t->action & 0xffff;
1353
1354 switch (act) {
d0ca268b 1355 case __BLK_TA_QUEUE:
3639a11e 1356 log_generic(pci, t, "Q");
d0ca268b
JA		 1357 break;
1358 case __BLK_TA_GETRQ:
3639a11e 1359 log_generic(pci, t, "G");
d0ca268b
JA		 1360 break;
1361 case __BLK_TA_SLEEPRQ:
3639a11e 1362 log_generic(pci, t, "S");
d0ca268b
JA		 1363 break;
1364 case __BLK_TA_REQUEUE:
3639a11e 1365 log_generic(pci, t, "R");
d0ca268b
JA		 1366 break;
1367 case __BLK_TA_ISSUE:
ab197ca7 1368 log_pc(pci, t, "D");
d0ca268b
JA		 1369 break;
1370 case __BLK_TA_COMPLETE:
3639a11e 1371 log_pc(pci, t, "C");
d0ca268b 1372 break;
56f2af81
JA		 1373 case __BLK_TA_INSERT:
1374 log_pc(pci, t, "I");
1375 break;
d0ca268b 1376 default:
56f2af81 1377 fprintf(stderr, "Bad pc action %x\n", act);
87b72777 1378 break;
d0ca268b 1379 }
d0ca268b
JA		 1380}
1381
f7bd1a9b
JA		 1382static void dump_trace_fs(struct blk_io_trace *t, struct per_dev_info *pdi,
1383 struct per_cpu_info *pci)
d0ca268b 1384{
649c7b66 1385 int w = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
7997c5b0 1386 int act = t->action & 0xffff;
d0ca268b 1387
7997c5b0 1388 switch (act) {
d0ca268b 1389 case __BLK_TA_QUEUE:
753f9091 1390 log_track_queue(pdi, t);
b6076a9b 1391 account_queue(t, pci, w);
3639a11e 1392 log_queue(pci, t, "Q");
d0ca268b 1393 break;
b6076a9b 1394 case __BLK_TA_INSERT:
f7bd1a9b 1395 log_insert(pdi, pci, t, "I");
b6076a9b 1396 break;
d0ca268b 1397 case __BLK_TA_BACKMERGE:
152f6476 1398 account_m(t, pci, w);
f7bd1a9b 1399 log_merge(pdi, pci, t, "M");
d0ca268b
JA		 1400 break;
1401 case __BLK_TA_FRONTMERGE:
152f6476 1402 account_m(t, pci, w);
f7bd1a9b 1403 log_merge(pdi, pci, t, "F");
d0ca268b
JA		 1404 break;
1405 case __BLK_TA_GETRQ:
f7bd1a9b 1406 log_track_getrq(pdi, t);
3639a11e 1407 log_generic(pci, t, "G");
d0ca268b
JA		 1408 break;
1409 case __BLK_TA_SLEEPRQ:
3639a11e 1410 log_generic(pci, t, "S");
d0ca268b
JA		 1411 break;
1412 case __BLK_TA_REQUEUE:
65f2deb5
JA		 1413 /*
1414 * can happen if we miss traces, don't let it go
1415 * below zero
1416 */
1417 if (pdi->cur_depth[w])
1418 pdi->cur_depth[w]--;
4054070a 1419 account_requeue(t, pci, w);
3639a11e 1420 log_queue(pci, t, "R");
d0ca268b
JA		 1421 break;
1422 case __BLK_TA_ISSUE:
b6076a9b 1423 account_issue(t, pci, w);
649c7b66
JA		 1424 pdi->cur_depth[w]++;
1425 if (pdi->cur_depth[w] > pdi->max_depth[w])
1426 pdi->max_depth[w] = pdi->cur_depth[w];
f7bd1a9b 1427 log_issue(pdi, pci, t, "D");
d0ca268b
JA		 1428 break;
1429 case __BLK_TA_COMPLETE:
65f2deb5
JA		 1430 if (pdi->cur_depth[w])
1431 pdi->cur_depth[w]--;
152f6476 1432 account_c(t, pci, w, t->bytes);
f7bd1a9b 1433 log_complete(pdi, pci, t, "C");
d0ca268b 1434 break;
88b1a526 1435 case __BLK_TA_PLUG:
3639a11e 1436 log_action(pci, t, "P");
88b1a526 1437 break;
3639a11e 1438 case __BLK_TA_UNPLUG_IO:
06639b27 1439 account_unplug(t, pci, 0);
3639a11e
JA		 1440 log_unplug(pci, t, "U");
1441 break;
1442 case __BLK_TA_UNPLUG_TIMER:
06639b27 1443 account_unplug(t, pci, 1);
3639a11e 1444 log_unplug(pci, t, "UT");
88b1a526 1445 break;
93f1c611
JA		 1446 case __BLK_TA_SPLIT:
1447 log_split(pci, t, "X");
1448 break;
1449 case __BLK_TA_BOUNCE:
1450 log_generic(pci, t, "B");
1451 break;
a8f30e64
JA		 1452 case __BLK_TA_REMAP:
1453 log_generic(pci, t, "A");
1454 break;
d0ca268b
JA		 1455 default:
1456 fprintf(stderr, "Bad fs action %x\n", t->action);
1f79c4a0 1457 break;
d0ca268b 1458 }
d0ca268b
JA		 1459}
1460
ff3a732c
JA		 1461static void dump_trace(struct blk_io_trace *t, struct per_cpu_info *pci,
1462 struct per_dev_info *pdi)
d0ca268b 1463{
234db09d
AB		 1464 if (text_output) {
1465 if (t->action & BLK_TC_ACT(BLK_TC_PC))
1466 dump_trace_pc(t, pci);
1467 else
1468 dump_trace_fs(t, pdi, pci);
1469 }
87b72777 1470
20ed6177
JA		 1471 if (!pdi->events)
1472 pdi->first_reported_time = t->time;
1473
e7c9f3ff 1474 pdi->events++;
a2594911
AB		 1475
1476 output_binary(t, sizeof(*t) + t->pdu_len);
d0ca268b
JA		 1477}
1478
4c523165
JA		 1479/*
1480 * print in a proper way, not too small and not too big. if more than
1481 * 1000,000K, turn into M and so on
1482 */
1483static char *size_cnv(char *dst, unsigned long long num, int in_kb)
1484{
da19e768 1485 char suff[] = { '\0', 'K', 'M', 'G', 'P' };
0dc3602c 1486 unsigned int i = 0;
4c523165
JA		 1487
1488 if (in_kb)
1489 i++;
1490
0dc3602c 1491 while (num > 1000 * 1000ULL && (i < sizeof(suff) - 1)) {
4c523165
JA		 1492 i++;
1493 num /= 1000;
1494 }
1495
1496 sprintf(dst, "%'8Lu%c", num, suff[i]);
1497 return dst;
1498}
1499
649c7b66
JA		 1500static void dump_io_stats(struct per_dev_info *pdi, struct io_stats *ios,
1501 char *msg)
5c017e4b 1502{
4c523165
JA		 1503 static char x[256], y[256];
1504
152f6476
JA		 1505 fprintf(ofp, "%s\n", msg);
1506
4c523165
JA		 1507 fprintf(ofp, " Reads Queued: %s, %siB\t", size_cnv(x, ios->qreads, 0), size_cnv(y, ios->qread_kb, 1));
1508 fprintf(ofp, " Writes Queued: %s, %siB\n", size_cnv(x, ios->qwrites, 0), size_cnv(y, ios->qwrite_kb, 1));
0a6b8fc4 1509
4c523165
JA		 1510 fprintf(ofp, " Read Dispatches: %s, %siB\t", size_cnv(x, ios->ireads, 0), size_cnv(y, ios->iread_kb, 1));
1511 fprintf(ofp, " Write Dispatches: %s, %siB\n", size_cnv(x, ios->iwrites, 0), size_cnv(y, ios->iwrite_kb, 1));
4054070a
JA		 1512 fprintf(ofp, " Reads Requeued: %s\t\t", size_cnv(x, ios->rrqueue, 0));
1513 fprintf(ofp, " Writes Requeued: %s\n", size_cnv(x, ios->wrqueue, 0));
4c523165
JA		 1514 fprintf(ofp, " Reads Completed: %s, %siB\t", size_cnv(x, ios->creads, 0), size_cnv(y, ios->cread_kb, 1));
1515 fprintf(ofp, " Writes Completed: %s, %siB\n", size_cnv(x, ios->cwrites, 0), size_cnv(y, ios->cwrite_kb, 1));
152f6476 1516 fprintf(ofp, " Read Merges: %'8lu%8c\t", ios->mreads, ' ');
152f6476 1517 fprintf(ofp, " Write Merges: %'8lu\n", ios->mwrites);
649c7b66
JA		 1518 if (pdi) {
1519 fprintf(ofp, " Read depth: %'8u%8c\t", pdi->max_depth[0], ' ');
1520 fprintf(ofp, " Write depth: %'8u\n", pdi->max_depth[1]);
1521 }
06639b27
JA		 1522 fprintf(ofp, " IO unplugs: %'8lu%8c\t", ios->io_unplugs, ' ');
1523 fprintf(ofp, " Timer unplugs: %'8lu\n", ios->timer_unplugs);
5c017e4b
JA		 1524}
1525
50adc0ba
JA		 1526static void dump_wait_stats(struct per_process_info *ppi)
1527{
b9d40d6f
JA		 1528 unsigned long rawait = ppi->longest_allocation_wait[0] / 1000;
1529 unsigned long rdwait = ppi->longest_dispatch_wait[0] / 1000;
1530 unsigned long rcwait = ppi->longest_completion_wait[0] / 1000;
1531 unsigned long wawait = ppi->longest_allocation_wait[1] / 1000;
1532 unsigned long wdwait = ppi->longest_dispatch_wait[1] / 1000;
1533 unsigned long wcwait = ppi->longest_completion_wait[1] / 1000;
1534
1535 fprintf(ofp, " Allocation wait: %'8lu%8c\t", rawait, ' ');
1536 fprintf(ofp, " Allocation wait: %'8lu\n", wawait);
1537 fprintf(ofp, " Dispatch wait: %'8lu%8c\t", rdwait, ' ');
1538 fprintf(ofp, " Dispatch wait: %'8lu\n", wdwait);
1539 fprintf(ofp, " Completion wait: %'8lu%8c\t", rcwait, ' ');
1540 fprintf(ofp, " Completion wait: %'8lu\n", wcwait);
50adc0ba
JA		 1541}
1542
886ecf0e
JA		 1543static int ppi_name_compare(const void *p1, const void *p2)
1544{
1545 struct per_process_info *ppi1 = *((struct per_process_info **) p1);
1546 struct per_process_info *ppi2 = *((struct per_process_info **) p2);
1547 int res;
1548
2990e589 1549 res = strverscmp(ppi1->ppm->comm, ppi2->ppm->comm);
886ecf0e 1550 if (!res)
2990e589 1551 res = ppi1->ppm->pid > ppi2->ppm->pid;
886ecf0e
JA		 1552
1553 return res;
1554}
1555
1556static void sort_process_list(void)
1557{
1558 struct per_process_info **ppis;
1559 struct per_process_info *ppi;
1560 int i = 0;
1561
1562 ppis = malloc(ppi_list_entries * sizeof(struct per_process_info *));
1563
1564 ppi = ppi_list;
1565 while (ppi) {
06e6f286 1566 ppis[i++] = ppi;
886ecf0e
JA		 1567 ppi = ppi->list_next;
1568 }
1569
06e6f286 1570 qsort(ppis, ppi_list_entries, sizeof(ppi), ppi_name_compare);
886ecf0e
JA		 1571
1572 i = ppi_list_entries - 1;
1573 ppi_list = NULL;
1574 while (i >= 0) {
1575 ppi = ppis[i];
1576
1577 ppi->list_next = ppi_list;
1578 ppi_list = ppi;
1579 i--;
1580 }
50c38702
JA		 1581
1582 free(ppis);
886ecf0e
JA		 1583}
1584
152f6476
JA		 1585static void show_process_stats(void)
1586{
1587 struct per_process_info *ppi;
1588
886ecf0e
JA		 1589 sort_process_list();
1590
152f6476
JA		 1591 ppi = ppi_list;
1592 while (ppi) {
2990e589 1593 struct process_pid_map *ppm = ppi->ppm;
ce8b6b4f
JA		 1594 char name[64];
1595
715d8021 1596 if (ppi->more_than_one)
2990e589 1597 sprintf(name, "%s (%u, ...)", ppm->comm, ppm->pid);
715d8021 1598 else
2990e589 1599 sprintf(name, "%s (%u)", ppm->comm, ppm->pid);
bf0720af 1600
649c7b66 1601 dump_io_stats(NULL, &ppi->io_stats, name);
50adc0ba 1602 dump_wait_stats(ppi);
152f6476
JA		 1603 ppi = ppi->list_next;
1604 }
1605
1606 fprintf(ofp, "\n");
1607}
1608
e7c9f3ff 1609static void show_device_and_cpu_stats(void)
d0ca268b 1610{
e7c9f3ff
NS		 1611 struct per_dev_info *pdi;
1612 struct per_cpu_info *pci;
1613 struct io_stats total, *ios;
20ed6177 1614 unsigned long long rrate, wrate, msec;
e7c9f3ff
NS		 1615 int i, j, pci_events;
1616 char line[3 + 8/*cpu*/ + 2 + 32/*dev*/ + 3];
1617 char name[32];
8a82e321 1618 double ratio;
e7c9f3ff
NS		 1619
1620 for (pdi = devices, i = 0; i < ndevices; i++, pdi++) {
1621
1622 memset(&total, 0, sizeof(total));
1623 pci_events = 0;
1624
1625 if (i > 0)
1626 fprintf(ofp, "\n");
1627
1628 for (pci = pdi->cpus, j = 0; j < pdi->ncpus; j++, pci++) {
1629 if (!pci->nelems)
1630 continue;
1631
1632 ios = &pci->io_stats;
1633 total.qreads += ios->qreads;
1634 total.qwrites += ios->qwrites;
1635 total.creads += ios->creads;
1636 total.cwrites += ios->cwrites;
1637 total.mreads += ios->mreads;
1638 total.mwrites += ios->mwrites;
1639 total.ireads += ios->ireads;
1640 total.iwrites += ios->iwrites;
4054070a
JA		 1641 total.rrqueue += ios->rrqueue;
1642 total.wrqueue += ios->wrqueue;
e7c9f3ff
NS		 1643 total.qread_kb += ios->qread_kb;
1644 total.qwrite_kb += ios->qwrite_kb;
1645 total.cread_kb += ios->cread_kb;
1646 total.cwrite_kb += ios->cwrite_kb;
1647 total.iread_kb += ios->iread_kb;
1648 total.iwrite_kb += ios->iwrite_kb;
06639b27
JA		 1649 total.timer_unplugs += ios->timer_unplugs;
1650 total.io_unplugs += ios->io_unplugs;
e7c9f3ff
NS		 1651
1652 snprintf(line, sizeof(line) - 1, "CPU%d (%s):",
1653 j, get_dev_name(pdi, name, sizeof(name)));
649c7b66 1654 dump_io_stats(pdi, ios, line);
e7c9f3ff
NS		 1655 pci_events++;
1656 }
5c017e4b 1657
e7c9f3ff
NS		 1658 if (pci_events > 1) {
1659 fprintf(ofp, "\n");
1660 snprintf(line, sizeof(line) - 1, "Total (%s):",
1661 get_dev_name(pdi, name, sizeof(name)));
649c7b66 1662 dump_io_stats(NULL, &total, line);
e7c9f3ff 1663 }
d0ca268b 1664
20ed6177 1665 wrate = rrate = 0;
20ed6177
JA		 1666 msec = (pdi->last_reported_time - pdi->first_reported_time) / 1000000;
1667 if (msec) {
1668 rrate = 1000 * total.cread_kb / msec;
1669 wrate = 1000 * total.cwrite_kb / msec;
1670 }
1671
dce0f678
AB		 1672 fprintf(ofp, "\nThroughput (R/W): %'LuKiB/s / %'LuKiB/s\n",
1673 rrate, wrate);
1674 fprintf(ofp, "Events (%s): %'Lu entries\n",
1675 get_dev_name(pdi, line, sizeof(line)), pdi->events);
492da111
AB		 1676
1677 collect_pdi_skips(pdi);
8a82e321
MZ		 1678 if (!pdi->skips && !pdi->events)
1679 ratio = 0.0;
1680 else
1681 ratio = 100.0 * ((double)pdi->seq_skips /
1682 (double)(pdi->events + pdi->seq_skips));
492da111 1683 fprintf(ofp, "Skips: %'lu forward (%'llu - %5.1lf%%)\n",
8a82e321 1684 pdi->skips, pdi->seq_skips, ratio);
e7c9f3ff 1685 }
d0ca268b
JA		 1686}
1687
4f0ae44f
JA		 1688static void find_genesis(void)
1689{
1690 struct trace *t = trace_list;
1691
1692 genesis_time = -1ULL;
1693 while (t != NULL) {
1694 if (t->bit->time < genesis_time)
1695 genesis_time = t->bit->time;
1696
1697 t = t->next;
1698 }
7bd4fd0a
OK		 1699
1700 /* The time stamp record will usually be the first
1701 * record in the trace, but not always.
1702 */
1703 if (start_timestamp
1704 && start_timestamp != genesis_time) {
1705 long delta = genesis_time - start_timestamp;
1706
1707 abs_start_time.tv_sec += SECONDS(delta);
1708 abs_start_time.tv_nsec += NANO_SECONDS(delta);
1709 if (abs_start_time.tv_nsec < 0) {
1710 abs_start_time.tv_nsec += 1000000000;
1711 abs_start_time.tv_sec -= 1;
1712 } else
1713 if (abs_start_time.tv_nsec > 1000000000) {
1714 abs_start_time.tv_nsec -= 1000000000;
1715 abs_start_time.tv_sec += 1;
1716 }
1717 }
4f0ae44f
JA		 1718}
1719
7f4d89e6 1720static inline int check_stopwatch(struct blk_io_trace *bit)
4f0ae44f 1721{
7f4d89e6
JA		 1722 if (bit->time < stopwatch_end &&
1723 bit->time >= stopwatch_start)
4f0ae44f
JA		 1724 return 0;
1725
1726 return 1;
1727}
1728
53c68c88
JA		 1729/*
1730 * return youngest entry read
1731 */
1732static int sort_entries(unsigned long long *youngest)
4f0ae44f 1733{
210824c3
JA		 1734 struct per_dev_info *pdi = NULL;
1735 struct per_cpu_info *pci = NULL;
4f0ae44f 1736 struct trace *t;
4f0ae44f
JA		 1737
1738 if (!genesis_time)
1739 find_genesis();
1740
d6222db8 1741 *youngest = 0;
4f0ae44f
JA		 1742 while ((t = trace_list) != NULL) {
1743 struct blk_io_trace *bit = t->bit;
1744
1745 trace_list = t->next;
1746
7f4d89e6 1747 bit->time -= genesis_time;
4f0ae44f 1748
d6222db8
JA		 1749 if (bit->time < *youngest || !*youngest)
1750 *youngest = bit->time;
1751
210824c3
JA		 1752 if (!pdi || pdi->dev != bit->device) {
1753 pdi = get_dev_info(bit->device);
1754 pci = NULL;
1755 }
1756
1757 if (!pci || pci->cpu != bit->cpu)
1758 pci = get_cpu_info(pdi, bit->cpu);
1759
1760 if (bit->sequence < pci->smallest_seq_read)
1761 pci->smallest_seq_read = bit->sequence;
774a1a10 1762
7f4d89e6 1763 if (check_stopwatch(bit)) {
4f0ae44f
JA		 1764 bit_free(bit);
1765 t_free(t);
1766 continue;
1767 }
1768
2a1b3424 1769 if (trace_rb_insert_sort(t))
53c68c88 1770 return -1;
4f0ae44f
JA		 1771 }
1772
53c68c88 1773 return 0;
4f0ae44f
JA		 1774}
1775
824c2b39
JA		 1776/*
1777 * to continue, we must have traces from all online cpus in the tree
1778 */
1779static int check_cpu_map(struct per_dev_info *pdi)
1780{
1781 unsigned long *cpu_map;
1782 struct rb_node *n;
1783 struct trace *__t;
1784 unsigned int i;
1785 int ret, cpu;
1786
1787 /*
1788 * create a map of the cpus we have traces for
1789 */
1790 cpu_map = malloc(pdi->cpu_map_max / sizeof(long));
1791 n = rb_first(&rb_sort_root);
1792 while (n) {
1793 __t = rb_entry(n, struct trace, rb_node);
1794 cpu = __t->bit->cpu;
1795
1796 cpu_map[CPU_IDX(cpu)] |= (1UL << CPU_BIT(cpu));
1797 n = rb_next(n);
1798 }
1799
1800 /*
b1c8e614
JA		 1801 * we can't continue if pdi->cpu_map has entries set that we don't
1802 * have in the sort rbtree. the opposite is not a problem, though
824c2b39
JA		 1803 */
1804 ret = 0;
1805 for (i = 0; i < pdi->cpu_map_max / CPUS_PER_LONG; i++) {
1806 if (pdi->cpu_map[i] & ~(cpu_map[i])) {
1807 ret = 1;
1808 break;
1809 }
1810 }
1811
1812 free(cpu_map);
1813 return ret;
1814}
1815
a141a7cd 1816static int check_sequence(struct per_dev_info *pdi, struct trace *t, int force)
2a1b3424 1817{
1ca323a5 1818 struct blk_io_trace *bit = t->bit;
210824c3
JA		 1819 unsigned long expected_sequence;
1820 struct per_cpu_info *pci;
1ca323a5 1821 struct trace *__t;
492da111 1822
210824c3
JA		 1823 pci = get_cpu_info(pdi, bit->cpu);
1824 expected_sequence = pci->last_sequence + 1;
1825
774a1a10 1826 if (!expected_sequence) {
774a1a10
JA		 1827 /*
1828 * 1 should be the first entry, just allow it
1829 */
1830 if (bit->sequence == 1)
1831 return 0;
210824c3 1832 if (bit->sequence == pci->smallest_seq_read)
79ee9704 1833 return 0;
774a1a10 1834
824c2b39 1835 return check_cpu_map(pdi);
774a1a10 1836 }
2a1b3424
JA		 1837
1838 if (bit->sequence == expected_sequence)
1839 return 0;
1840
2a1b3424 1841 /*
1c7c54aa
JA		 1842 * we may not have seen that sequence yet. if we are not doing
1843 * the final run, break and wait for more entries.
1c24add6 1844 */
210824c3
JA		 1845 if (expected_sequence < pci->smallest_seq_read) {
1846 __t = trace_rb_find_last(pdi, pci, expected_sequence);
1ca323a5 1847 if (!__t)
1c7c54aa 1848 goto skip;
2a1b3424 1849
1ca323a5 1850 __put_trace_last(pdi, __t);
2a1b3424 1851 return 0;
a141a7cd
JA		 1852 } else if (!force) {
1853 return 1;
0b07f23e 1854 } else {
1c7c54aa 1855skip:
66930177 1856 if (check_current_skips(pci, bit->sequence))
492da111
AB		 1857 return 0;
1858
965eca2d 1859 if (expected_sequence < bit->sequence)
66930177 1860 insert_skip(pci, expected_sequence, bit->sequence - 1);
1c7c54aa
JA		 1861 return 0;
1862 }
2a1b3424
JA		 1863}
1864
a649216c 1865static void show_entries_rb(int force)
8fc0abbc 1866{
1f7afa72
JA		 1867 struct per_dev_info *pdi = NULL;
1868 struct per_cpu_info *pci = NULL;
8fc0abbc 1869 struct blk_io_trace *bit;
3aabcd89 1870 struct rb_node *n;
8fc0abbc 1871 struct trace *t;
1f7afa72 1872
7d747d22 1873 while ((n = rb_first(&rb_sort_root)) != NULL) {
dd90748f 1874 if (is_done() && !force && !pipeline)
1f7afa72 1875 break;
8fc0abbc
JA		 1876
1877 t = rb_entry(n, struct trace, rb_node);
1878 bit = t->bit;
1879
a43c1c17
JA		 1880 if (read_sequence - t->read_sequence < 1 && !force)
1881 break;
1882
210824c3 1883 if (!pdi || pdi->dev != bit->device) {
287fa3d6 1884 pdi = get_dev_info(bit->device);
210824c3
JA		 1885 pci = NULL;
1886 }
1f7afa72 1887
e7c9f3ff
NS		 1888 if (!pdi) {
1889 fprintf(stderr, "Unknown device ID? (%d,%d)\n",
1890 MAJOR(bit->device), MINOR(bit->device));
1891 break;
1892 }
1f7afa72 1893
a141a7cd
JA		 1894 if (check_sequence(pdi, t, force))
1895 break;
cb2a1a62 1896
a141a7cd
JA		 1897 if (!force && bit->time > last_allowed_time)
1898 break;
8fc0abbc 1899
4f0ae44f 1900 check_time(pdi, bit);
8fc0abbc 1901
4f0ae44f
JA		 1902 if (!pci || pci->cpu != bit->cpu)
1903 pci = get_cpu_info(pdi, bit->cpu);
287fa3d6 1904
210824c3
JA		 1905 pci->last_sequence = bit->sequence;
1906
cbc927b6
JA		 1907 pci->nelems++;
1908
66930177 1909 if (bit->action & (act_mask << BLK_TC_SHIFT))
98f8386b 1910 dump_trace(bit, pci, pdi);
87b72777 1911
2a1b3424 1912 put_trace(pdi, t);
cb2a1a62 1913 }
8fc0abbc
JA		 1914}
1915
c0e0dbc2 1916static int read_data(int fd, void *buffer, int bytes, int block, int *fdblock)
1f79c4a0
JA		 1917{
1918 int ret, bytes_left, fl;
1919 void *p;
1920
c0e0dbc2
JA		 1921 if (block != *fdblock) {
1922 fl = fcntl(fd, F_GETFL);
1f79c4a0 1923
c0e0dbc2
JA		 1924 if (!block) {
1925 *fdblock = 0;
1926 fcntl(fd, F_SETFL, fl | O_NONBLOCK);
1927 } else {
1928 *fdblock = 1;
1929 fcntl(fd, F_SETFL, fl & ~O_NONBLOCK);
1930 }
1931 }
1f79c4a0
JA		 1932
1933 bytes_left = bytes;
1934 p = buffer;
1935 while (bytes_left > 0) {
1936 ret = read(fd, p, bytes_left);
1937 if (!ret)
1938 return 1;
1939 else if (ret < 0) {
db7e0552 1940 if (errno != EAGAIN) {
1f79c4a0 1941 perror("read");
db7e0552
JA		 1942 return -1;
1943 }
a649216c 1944
5c0f40f7
JA		 1945 /*
1946 * never do partial reads. we can return if we
1947 * didn't read anything and we should not block,
1948 * otherwise wait for data
1949 */
1950 if ((bytes_left == bytes) && !block)
1951 return 1;
1952
1953 usleep(10);
1954 continue;
1f79c4a0
JA		 1955 } else {
1956 p += ret;
1957 bytes_left -= ret;
1958 }
1959 }
1960
1961 return 0;
1962}
1963
017d1660
JA		 1964static inline __u16 get_pdulen(struct blk_io_trace *bit)
1965{
1966 if (data_is_native)
1967 return bit->pdu_len;
1968
1969 return __bswap_16(bit->pdu_len);
1970}
1971
1972static inline __u32 get_magic(struct blk_io_trace *bit)
1973{
1974 if (data_is_native)
1975 return bit->magic;
1976
1977 return __bswap_32(bit->magic);
1978}
1979
c0e0dbc2 1980static int read_events(int fd, int always_block, int *fdblock)
cb2a1a62 1981{
287fa3d6 1982 struct per_dev_info *pdi = NULL;
e820abd7 1983 unsigned int events = 0;
7d747d22
JA		 1984
1985 while (!is_done() && events < rb_batch) {
1986 struct blk_io_trace *bit;
1987 struct trace *t;
db7e0552 1988 int pdu_len, should_block, ret;
7d747d22
JA		 1989 __u32 magic;
1990
d36421e4 1991 bit = bit_alloc();
cb2a1a62 1992
c0e0dbc2
JA		 1993 should_block = !events || always_block;
1994
db7e0552
JA		 1995 ret = read_data(fd, bit, sizeof(*bit), should_block, fdblock);
1996 if (ret) {
eb9bd4e9 1997 bit_free(bit);
db7e0552
JA		 1998 if (!events && ret < 0)
1999 events = ret;
cb2a1a62 2000 break;
eb9bd4e9 2001 }
cb2a1a62 2002
017d1660
JA		 2003 /*
2004 * look at first trace to check whether we need to convert
2005 * data in the future
2006 */
9e4cd1b8 2007 if (data_is_native == -1 && check_data_endianness(bit->magic))
017d1660
JA		 2008 break;
2009
2010 magic = get_magic(bit);
7d747d22
JA		 2011 if ((magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) {
2012 fprintf(stderr, "Bad magic %x\n", magic);
2013 break;
2014 }
2015
017d1660 2016 pdu_len = get_pdulen(bit);
7d747d22
JA		 2017 if (pdu_len) {
2018 void *ptr = realloc(bit, sizeof(*bit) + pdu_len);
2019
c0e0dbc2 2020 if (read_data(fd, ptr + sizeof(*bit), pdu_len, 1, fdblock)) {
eb9bd4e9 2021 bit_free(ptr);
7d747d22 2022 break;
eb9bd4e9 2023 }
7d747d22
JA		 2024
2025 bit = ptr;
2026 }
2027
d6222db8
JA		 2028 trace_to_cpu(bit);
2029
2030 if (verify_trace(bit)) {
2031 bit_free(bit);
2032 continue;
2033 }
2034
bfc70ad5
JA		 2035 /*
2036 * not a real trace, so grab and handle it here
2037 */
2038 if (bit->action & BLK_TC_ACT(BLK_TC_NOTIFY)) {
7bd4fd0a 2039 handle_notify(bit);
a2594911 2040 output_binary(bit, sizeof(*bit) + bit->pdu_len);
bfc70ad5
JA		 2041 continue;
2042 }
2043
d36421e4 2044 t = t_alloc();
cb2a1a62
JA		 2045 memset(t, 0, sizeof(*t));
2046 t->bit = bit;
a43c1c17 2047 t->read_sequence = read_sequence;
cb2a1a62 2048
7d747d22
JA		 2049 t->next = trace_list;
2050 trace_list = t;
1f7afa72 2051
f7bd1a9b 2052 if (!pdi || pdi->dev != bit->device)
287fa3d6
JA		 2053 pdi = get_dev_info(bit->device);
2054
2055 if (bit->time > pdi->last_read_time)
2056 pdi->last_read_time = bit->time;
2057
7d747d22 2058 events++;
cb2a1a62
JA		 2059 }
2060
7d747d22 2061 return events;
cb2a1a62
JA		 2062}
2063
70317a16
AB		 2064/*
2065 * Managing input streams
2066 */
2067
2068struct ms_stream {
2069 struct ms_stream *next;
2070 struct trace *first, *last;
73877e12 2071 struct per_dev_info *pdi;
70317a16
AB		 2072 unsigned int cpu;
2073};
d0ca268b 2074
70317a16 2075#define MS_HASH(d, c) ((MAJOR(d) & 0xff) ^ (MINOR(d) & 0xff) ^ (cpu & 0xff))
73877e12 2076
70317a16
AB		 2077struct ms_stream *ms_head;
2078struct ms_stream *ms_hash[256];
87b72777 2079
70317a16
AB		 2080static void ms_sort(struct ms_stream *msp);
2081static int ms_prime(struct ms_stream *msp);
2082
2083static inline struct trace *ms_peek(struct ms_stream *msp)
2084{
2085 return (msp == NULL) ? NULL : msp->first;
2086}
d0ca268b 2087
70317a16
AB		 2088static inline __u64 ms_peek_time(struct ms_stream *msp)
2089{
2090 return ms_peek(msp)->bit->time;
2091}
d1d7f15f 2092
70317a16
AB		 2093static inline void ms_resort(struct ms_stream *msp)
2094{
2095 if (msp->next && ms_peek_time(msp) > ms_peek_time(msp->next)) {
2096 ms_head = msp->next;
2097 msp->next = NULL;
2098 ms_sort(msp);
2099 }
2100}
e7c9f3ff 2101
70317a16
AB		 2102static inline void ms_deq(struct ms_stream *msp)
2103{
2104 msp->first = msp->first->next;
2105 if (!msp->first) {
2106 msp->last = NULL;
2107 if (!ms_prime(msp)) {
2108 ms_head = msp->next;
2109 msp->next = NULL;
2110 return;
d0ca268b 2111 }
d5396421
JA		 2112 }
2113
70317a16
AB		 2114 ms_resort(msp);
2115}
53c68c88 2116
70317a16
AB		 2117static void ms_sort(struct ms_stream *msp)
2118{
2119 __u64 msp_t = ms_peek_time(msp);
2120 struct ms_stream *this_msp = ms_head;
d5396421 2121
70317a16
AB		 2122 if (this_msp == NULL)
2123 ms_head = msp;
2124 else if (msp_t < ms_peek_time(this_msp)) {
2125 msp->next = this_msp;
2126 ms_head = msp;
2127 }
2128 else {
2129 while (this_msp->next && ms_peek_time(this_msp->next) < msp_t)
2130 this_msp = this_msp->next;
73877e12 2131
70317a16
AB		 2132 msp->next = this_msp->next;
2133 this_msp->next = msp;
2134 }
2135}
d5396421 2136
70317a16
AB		 2137static int ms_prime(struct ms_stream *msp)
2138{
2139 __u32 magic;
2140 unsigned int i;
2141 struct trace *t;
2142 struct per_dev_info *pdi = msp->pdi;
2143 struct per_cpu_info *pci = get_cpu_info(pdi, msp->cpu);
2144 struct blk_io_trace *bit = NULL;
2145 int ret, pdu_len, ndone = 0;
d5396421 2146
70317a16
AB		 2147 for (i = 0; !is_done() && pci->fd >= 0 && i < rb_batch; i++) {
2148 bit = bit_alloc();
2149 ret = read_data(pci->fd, bit, sizeof(*bit), 1, &pci->fdblock);
2150 if (ret)
2151 goto err;
51128a28 2152
70317a16
AB		 2153 if (data_is_native == -1 && check_data_endianness(bit->magic))
2154 goto err;
210824c3 2155
70317a16
AB		 2156 magic = get_magic(bit);
2157 if ((magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) {
2158 fprintf(stderr, "Bad magic %x\n", magic);
2159 goto err;
d5396421 2160
70317a16 2161 }
d5396421 2162
70317a16
AB		 2163 pdu_len = get_pdulen(bit);
2164 if (pdu_len) {
2165 void *ptr = realloc(bit, sizeof(*bit) + pdu_len);
2166 ret = read_data(pci->fd, ptr + sizeof(*bit), pdu_len,
2167 1, &pci->fdblock);
2168 if (ret) {
2169 free(ptr);
2170 goto err;
7d747d22 2171 }
70317a16
AB		 2172
2173 bit = ptr;
2ff323b0 2174 }
d5396421 2175
70317a16
AB		 2176 trace_to_cpu(bit);
2177 if (verify_trace(bit))
2178 goto err;
53c68c88 2179
70317a16 2180 if (bit->action & BLK_TC_ACT(BLK_TC_NOTIFY)) {
7bd4fd0a 2181 handle_notify(bit);
70317a16
AB		 2182 output_binary(bit, sizeof(*bit) + bit->pdu_len);
2183 bit_free(bit);
287fa3d6 2184
70317a16
AB		 2185 i -= 1;
2186 continue;
2187 }
cb2a1a62 2188
70317a16
AB		 2189 if (bit->time > pdi->last_read_time)
2190 pdi->last_read_time = bit->time;
d5396421 2191
70317a16
AB		 2192 t = t_alloc();
2193 memset(t, 0, sizeof(*t));
2194 t->bit = bit;
2195
2196 if (msp->first == NULL)
2197 msp->first = msp->last = t;
2198 else {
2199 msp->last->next = t;
2200 msp->last = t;
2201 }
2202
2203 ndone++;
2204 }
2205
2206 return ndone;
2207
2208err:
2209 if (bit) bit_free(bit);
2210
2211 cpu_mark_offline(pdi, pci->cpu);
2212 close(pci->fd);
2213 pci->fd = -1;
2214
2215 return ndone;
2216}
2217
2218static struct ms_stream *ms_alloc(struct per_dev_info *pdi, int cpu)
2219{
2220 struct ms_stream *msp = malloc(sizeof(*msp));
2221
2222 msp->next = NULL;
2223 msp->first = msp->last = NULL;
2224 msp->pdi = pdi;
2225 msp->cpu = cpu;
2226
2227 if (ms_prime(msp))
2228 ms_sort(msp);
2229
2230 return msp;
2231}
2232
2233static int setup_file(struct per_dev_info *pdi, int cpu)
2234{
2235 int len = 0;
2236 struct stat st;
2237 char *p, *dname;
2238 struct per_cpu_info *pci = get_cpu_info(pdi, cpu);
2239
2240 pci->cpu = cpu;
2241 pci->fdblock = -1;
2242
2243 p = strdup(pdi->name);
2244 dname = dirname(p);
2245 if (strcmp(dname, ".")) {
2246 input_dir = dname;
2247 p = strdup(pdi->name);
2248 strcpy(pdi->name, basename(p));
2249 }
2250 free(p);
2251
2252 if (input_dir)
2253 len = sprintf(pci->fname, "%s/", input_dir);
2254
2255 snprintf(pci->fname + len, sizeof(pci->fname)-1-len,
2256 "%s.blktrace.%d", pdi->name, pci->cpu);
8afe3d7d 2257 if (stat(pci->fname, &st) < 0)
70317a16 2258 return 0;
8afe3d7d
AB		 2259 if (!st.st_size)
2260 return 1;
70317a16
AB		 2261
2262 pci->fd = open(pci->fname, O_RDONLY);
2263 if (pci->fd < 0) {
2264 perror(pci->fname);
2265 return 0;
2266 }
2267
2268 printf("Input file %s added\n", pci->fname);
2269 cpu_mark_online(pdi, pci->cpu);
2270
2271 pdi->nfiles++;
2272 ms_alloc(pdi, pci->cpu);
2273
2274 return 1;
2275}
2276
2277static int handle(struct ms_stream *msp)
2278{
2279 struct trace *t;
2280 struct per_dev_info *pdi;
2281 struct per_cpu_info *pci;
2282 struct blk_io_trace *bit;
2283
2284 t = ms_peek(msp);
2285 if (t->bit->time > stopwatch_end)
2286 return 0;
2287
2288 bit = t->bit;
2289 pdi = msp->pdi;
2290 pci = get_cpu_info(pdi, msp->cpu);
2291 pci->nelems++;
2292
8091de93
AB		 2293 bit->time -= genesis_time;
2294 pdi->last_reported_time = bit->time;
70317a16
AB		 2295 if (bit->action & (act_mask << BLK_TC_SHIFT))
2296 dump_trace(bit, pci, pdi);
2297
2298 ms_deq(msp);
2299
2300 if (text_output)
2301 trace_rb_insert_last(pdi, t);
2302 else {
2303 bit_free(t->bit);
2304 t_free(t);
2305 }
2306
2307 return 1;
2308}
2309
2310static int do_file(void)
2311{
2312 int i, cpu;
2313 struct per_dev_info *pdi;
2314
2315 /*
2316 * first prepare all files for reading
2317 */
2318 for (i = 0; i < ndevices; i++) {
2319 pdi = &devices[i];
2320 for (cpu = 0; setup_file(pdi, cpu); cpu++)
2321 ;
2322 }
2323
8091de93
AB		 2324 /*
2325 * Get the initial time stamp
2326 */
2327 if (ms_head)
2328 genesis_time = ms_peek_time(ms_head);
2329
70317a16
AB		 2330 /*
2331 * Keep processing traces while any are left
2332 */
2333 while (!is_done() && ms_head && handle(ms_head))
2334 ;
a649216c 2335
7d747d22 2336 return 0;
412819ce 2337}
d5396421 2338
67076cbc 2339static void do_pipe(int fd)
412819ce 2340{
53c68c88 2341 unsigned long long youngest;
67076cbc 2342 int events, fdblock;
d5396421 2343
be925321 2344 last_allowed_time = -1ULL;
c0e0dbc2 2345 fdblock = -1;
db7e0552 2346 while ((events = read_events(fd, 0, &fdblock)) > 0) {
4ab42801 2347 read_sequence++;
412819ce 2348
210824c3 2349#if 0
0b07f23e 2350 smallest_seq_read = -1U;
210824c3 2351#endif
0b07f23e 2352
53c68c88
JA		 2353 if (sort_entries(&youngest))
2354 break;
2355
2356 if (youngest > stopwatch_end)
2ff323b0
JA		 2357 break;
2358
763d936e 2359 show_entries_rb(0);
0b07f23e 2360 }
d5396421 2361
a649216c
JA		 2362 if (rb_sort_entries)
2363 show_entries_rb(1);
67076cbc
JA		 2364}
2365
2366static int do_fifo(void)
2367{
2368 int fd;
2369
2370 if (!strcmp(pipename, "-"))
2371 fd = dup(STDIN_FILENO);
2372 else
2373 fd = open(pipename, O_RDONLY);
2374
2375 if (fd == -1) {
2376 perror("dup stdin");
2377 return -1;
2378 }
a649216c 2379
67076cbc 2380 do_pipe(fd);
d5396421 2381 close(fd);
d5396421
JA		 2382 return 0;
2383}
d0ca268b 2384
cbc927b6 2385static void show_stats(void)
412819ce 2386{
cbc927b6
JA		 2387 if (!ofp)
2388 return;
2389 if (stats_printed)
2390 return;
2391
2392 stats_printed = 1;
2393
2394 if (per_process_stats)
2395 show_process_stats();
2396
2397 if (per_device_and_cpu_stats)
2398 show_device_and_cpu_stats();
2399
152f6476 2400 fflush(ofp);
412819ce
JA		 2401}
2402
e820abd7 2403static void handle_sigint(__attribute__((__unused__)) int sig)
412819ce
JA		 2404{
2405 done = 1;
412819ce
JA		 2406}
2407
46e6968b
NS		 2408/*
2409 * Extract start and duration times from a string, allowing
2410 * us to specify a time interval of interest within a trace.
2411 * Format: "duration" (start is zero) or "start:duration".
2412 */
2413static int find_stopwatch_interval(char *string)
2414{
2415 double value;
2416 char *sp;
2417
2418 value = strtod(string, &sp);
2419 if (sp == string) {
2420 fprintf(stderr,"Invalid stopwatch timer: %s\n", string);
2421 return 1;
2422 }
2423 if (*sp == ':') {
2424 stopwatch_start = DOUBLE_TO_NANO_ULL(value);
2425 string = sp + 1;
2426 value = strtod(string, &sp);
2427 if (sp == string || *sp != '\0') {
2428 fprintf(stderr,"Invalid stopwatch duration time: %s\n",
2429 string);
2430 return 1;
2431 }
2432 } else if (*sp != '\0') {
2433 fprintf(stderr,"Invalid stopwatch start timer: %s\n", string);
2434 return 1;
2435 }
1b928247
JA		 2436 stopwatch_end = DOUBLE_TO_NANO_ULL(value);
2437 if (stopwatch_end <= stopwatch_start) {
2438 fprintf(stderr, "Invalid stopwatch interval: %Lu -> %Lu\n",
2439 stopwatch_start, stopwatch_end);
2440 return 1;
2441 }
2442
46e6968b
NS		 2443 return 0;
2444}
2445
67076cbc
JA		 2446static int is_pipe(const char *str)
2447{
2448 struct stat st;
2449
2450 if (!strcmp(str, "-"))
2451 return 1;
2452 if (!stat(str, &st) && S_ISFIFO(st.st_mode))
2453 return 1;
2454
2455 return 0;
2456}
2457
234db09d
AB		 2458#define S_OPTS "a:A:b:D:d:f:F:hi:o:Oqstw:vV"
2459static char usage_str[] = "\n\n" \
2460 "-i <file> | --input=<file>\n" \
2461 "[ -a <action field> | --act-mask=<action field> ]\n" \
2462 "[ -A <action mask> | --set-mask=<action mask> ]\n" \
2463 "[ -b <traces> | --batch=<traces> ]\n" \
2464 "[ -d <file> | --dump-binary=<file> ]\n" \
2465 "[ -D <dir> | --input-directory=<dir> ]\n" \
2466 "[ -f <format> | --format=<format> ]\n" \
2467 "[ -F <spec> | --format-spec=<spec> ]\n" \
2468 "[ -h | --hash-by-name ]\n" \
2469 "[ -o <file> | --output=<file> ]\n" \
2470 "[ -O | --no-text-output ]\n" \
2471 "[ -q | --quiet ]\n" \
2472 "[ -s | --per-program-stats ]\n" \
2473 "[ -t | --track-ios ]\n" \
2474 "[ -w <time> | --stopwatch=<time> ]\n" \
2475 "[ -v | --verbose ]\n" \
2476 "[ -V | --version ]\n\n" \
2477 "\t-b stdin read batching\n" \
2478 "\t-d Output file. If specified, binary data is written to file\n" \
d1d7f15f 2479 "\t-D Directory to prepend to input file names\n" \
234db09d
AB		 2480 "\t-f Output format. Customize the output format. The format field\n" \
2481 "\t identifies can be found in the documentation\n" \
2482 "\t-F Format specification. Can be found in the documentation\n" \
2483 "\t-h Hash processes by name, not pid\n" \
2484 "\t-i Input file containing trace data, or '-' for stdin\n" \
52724a0e 2485 "\t-o Output file. If not given, output is stdout\n" \
234db09d
AB		 2486 "\t-O Do NOT output text data\n" \
2487 "\t-q Quiet. Don't display any stats at the end of the trace\n" \
52724a0e
JA		 2488 "\t-s Show per-program io statistics\n" \
2489 "\t-t Track individual ios. Will tell you the time a request took\n" \
2490 "\t to get queued, to get dispatched, and to get completed\n" \
52724a0e
JA		 2491 "\t-w Only parse data between the given time interval in seconds.\n" \
2492 "\t If 'start' isn't given, blkparse defaults the start time to 0\n" \
57ea8602
JA		 2493 "\t-v More verbose for marginal errors\n" \
2494 "\t-V Print program version info\n\n";
52724a0e 2495
1f79c4a0
JA		 2496static void usage(char *prog)
2497{
52724a0e 2498 fprintf(stderr, "Usage: %s %s %s", prog, blkparse_version, usage_str);
1f79c4a0
JA		 2499}
2500
d5396421
JA		 2501int main(int argc, char *argv[])
2502{
98f8386b 2503 int i, c, ret, mode;
98f8386b 2504 int act_mask_tmp = 0;
234db09d 2505 char *ofp_buffer = NULL;
346d8a74 2506 char *bin_ofp_buffer = NULL;
d5396421
JA		 2507
2508 while ((c = getopt_long(argc, argv, S_OPTS, l_opts, NULL)) != -1) {
2509 switch (c) {
98f8386b
AB		 2510 case 'a':
2511 i = find_mask_map(optarg);
2512 if (i < 0) {
2513 fprintf(stderr,"Invalid action mask %s\n",
2514 optarg);
2515 return 1;
2516 }
2517 act_mask_tmp |= i;
2518 break;
2519
2520 case 'A':
2521 if ((sscanf(optarg, "%x", &i) != 1) ||
2522 !valid_act_opt(i)) {
2523 fprintf(stderr,
2524 "Invalid set action mask %s/0x%x\n",
2525 optarg, i);
2526 return 1;
2527 }
2528 act_mask_tmp = i;
2529 break;
d5396421 2530 case 'i':
67076cbc 2531 if (is_pipe(optarg) && !pipeline) {
e7c9f3ff 2532 pipeline = 1;
67076cbc
JA		 2533 pipename = strdup(optarg);
2534 } else if (resize_devices(optarg) != 0)
e7c9f3ff 2535 return 1;
d5396421 2536 break;
d1d7f15f
JA		 2537 case 'D':
2538 input_dir = optarg;
2539 break;
d5396421 2540 case 'o':
66efebf8 2541 output_name = optarg;
d5396421 2542 break;
234db09d
AB		 2543 case 'O':
2544 text_output = 0;
2545 break;
79f19470
JA		 2546 case 'b':
2547 rb_batch = atoi(optarg);
2548 if (rb_batch <= 0)
2549 rb_batch = RB_BATCH_DEFAULT;
2550 break;
152f6476
JA		 2551 case 's':
2552 per_process_stats = 1;
2553 break;
7997c5b0
JA		 2554 case 't':
2555 track_ios = 1;
2556 break;
1e1c60f1
NS		 2557 case 'q':
2558 per_device_and_cpu_stats = 0;
2559 break;
46e6968b
NS		 2560 case 'w':
2561 if (find_stopwatch_interval(optarg) != 0)
2562 return 1;
2563 break;
ab197ca7
AB		 2564 case 'f':
2565 set_all_format_specs(optarg);
2566 break;
2567 case 'F':
2568 if (add_format_spec(optarg) != 0)
2569 return 1;
2570 break;
d915dee6 2571 case 'h':
715d8021 2572 ppi_hash_by_pid = 0;
bf0720af 2573 break;
52724a0e 2574 case 'v':
57ea8602
JA		 2575 verbose++;
2576 break;
2577 case 'V':
52724a0e
JA		 2578 printf("%s version %s\n", argv[0], blkparse_version);
2579 return 0;
a2594911
AB		 2580 case 'd':
2581 dump_binary = optarg;
2582 break;
d5396421 2583 default:
1f79c4a0 2584 usage(argv[0]);
d5396421
JA		 2585 return 1;
2586 }
d0ca268b
JA		 2587 }
2588
e7c9f3ff 2589 while (optind < argc) {
67076cbc 2590 if (is_pipe(argv[optind]) && !pipeline) {
e7c9f3ff 2591 pipeline = 1;
67076cbc
JA		 2592 pipename = strdup(optarg);
2593 } else if (resize_devices(argv[optind]) != 0)
e7c9f3ff
NS		 2594 return 1;
2595 optind++;
2596 }
2597
2598 if (!pipeline && !ndevices) {
1f79c4a0 2599 usage(argv[0]);
d5396421
JA		 2600 return 1;
2601 }
2602
98f8386b
AB		 2603 if (act_mask_tmp != 0)
2604 act_mask = act_mask_tmp;
2605
7997c5b0 2606 memset(&rb_sort_root, 0, sizeof(rb_sort_root));
412819ce
JA		 2607
2608 signal(SIGINT, handle_sigint);
2609 signal(SIGHUP, handle_sigint);
2610 signal(SIGTERM, handle_sigint);
d5396421 2611
d69db225
JA		 2612 setlocale(LC_NUMERIC, "en_US");
2613
234db09d
AB		 2614 if (text_output) {
2615 if (!output_name) {
2616 ofp = fdopen(STDOUT_FILENO, "w");
2617 mode = _IOLBF;
2618 } else {
2619 char ofname[128];
152f6476 2620
234db09d
AB		 2621 snprintf(ofname, sizeof(ofname) - 1, "%s", output_name);
2622 ofp = fopen(ofname, "w");
2623 mode = _IOFBF;
2624 }
152f6476 2625
234db09d
AB		 2626 if (!ofp) {
2627 perror("fopen");
2628 return 1;
2629 }
152f6476 2630
234db09d
AB		 2631 ofp_buffer = malloc(4096);
2632 if (setvbuf(ofp, ofp_buffer, mode, 4096)) {
2633 perror("setvbuf");
2634 return 1;
2635 }
152f6476
JA		 2636 }
2637
a2594911 2638 if (dump_binary) {
346d8a74
AB		 2639 dump_fp = fopen(dump_binary, "w");
2640 if (!dump_fp) {
a2594911
AB		 2641 perror(dump_binary);
2642 dump_binary = NULL;
2643 return 1;
2644 }
346d8a74
AB		 2645 bin_ofp_buffer = malloc(128 * 1024);
2646 if (setvbuf(dump_fp, bin_ofp_buffer, _IOFBF, 128 * 1024)) {
2647 perror("setvbuf binary");
2648 return 1;
2649 }
a2594911
AB		 2650 }
2651
e7c9f3ff 2652 if (pipeline)
67076cbc 2653 ret = do_fifo();
d5396421
JA		 2654 else
2655 ret = do_file();
2656
cbc927b6 2657 show_stats();
8091de93
AB		 2658 if (ofp_buffer) {
2659 fflush(ofp);
234db09d 2660 free(ofp_buffer);
8091de93
AB		 2661 }
2662 if (bin_ofp_buffer) {
2663 fflush(dump_fp);
346d8a74 2664 free(bin_ofp_buffer);
8091de93 2665 }
d5396421 2666 return ret;
d0ca268b 2667}
Block queue io tracer