Commit | Line | Data |
---|---|---|
d47a3fec AB |
1 | /* |
2 | * Blktrace record utility - Convert binary trace data into bunches of IOs | |
3 | * | |
4 | * Copyright (C) 2007 Alan D. Brunelle <Alan.Brunelle@hp.com> | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, write to the Free Software | |
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 | */ | |
20 | ||
21 | static char build_date[] = __DATE__ " at "__TIME__; | |
22 | ||
23 | #include <assert.h> | |
24 | #include <fcntl.h> | |
25 | #include <stdio.h> | |
26 | #include <stdlib.h> | |
27 | #include <string.h> | |
28 | #include <unistd.h> | |
29 | #include <sys/param.h> | |
30 | #include <sys/stat.h> | |
31 | #include <sys/types.h> | |
32 | #include <dirent.h> | |
65a7043b | 33 | #include <stdarg.h> |
d47a3fec AB |
34 | |
35 | #if !defined(_GNU_SOURCE) | |
36 | # define _GNU_SOURCE | |
37 | #endif | |
38 | #include <getopt.h> | |
39 | ||
40 | #include "list.h" | |
41 | #include "btrecord.h" | |
42 | #include "blktrace.h" | |
43 | ||
44 | /* | |
45 | * Per input file information | |
46 | * | |
47 | * @head: Used to link up on input_files | |
48 | * @devnm: Device name portion of this input file | |
49 | * @file_name: Fully qualified name for this input file | |
50 | * @cpu: CPU that this file was collected on | |
51 | * @ifd: Input file descriptor (when opened) | |
52 | * @tpkts: Total number of packets processed. | |
53 | */ | |
54 | struct ifile_info { | |
55 | struct list_head head; | |
56 | char *devnm, *file_name; | |
57 | int cpu, ifd; | |
58 | __u64 tpkts, genesis; | |
59 | }; | |
60 | ||
61 | /* | |
62 | * Per IO trace information | |
63 | * | |
64 | * @time: Time stamp when trace was emitted | |
65 | * @sector: IO sector identifier | |
66 | * @bytes: Number of bytes transferred | |
67 | * @rw: Read (1) or write (0) | |
68 | */ | |
69 | struct io_spec { | |
70 | __u64 time; | |
71 | __u64 sector; | |
72 | __u32 bytes; | |
73 | int rw; | |
74 | }; | |
75 | ||
76 | /* | |
77 | * Per output file information | |
78 | * | |
79 | * @ofp: Output file | |
80 | * @vfp: Verbose output file | |
81 | * @file_name: Fully qualified name for this file | |
82 | * @vfn: Fully qualified name for this file | |
83 | * @cur: Current IO bunch being collected | |
84 | * @iip: Input file this is associated with | |
85 | * @start_time: Start time of th ecurrent bunch | |
86 | * @last_time: Time of last packet put in | |
87 | * @bunches: Number of bunches processed | |
88 | * @pkts: Number of packets stored in bunches | |
89 | */ | |
90 | struct io_stream { | |
91 | FILE *ofp, *vfp; | |
92 | char *file_name, *vfn; | |
93 | struct io_bunch *cur; | |
94 | struct ifile_info *iip; | |
95 | __u64 start_time, last_time, bunches, pkts; | |
96 | }; | |
97 | ||
98 | int data_is_native; // Indicates whether to swap | |
99 | static LIST_HEAD(input_files); // List of all input files | |
100 | static char *idir = "."; // Input directory base | |
101 | static char *odir = "."; // Output directory base | |
102 | static char *obase = "replay"; // Output file base | |
103 | static __u64 max_bunch_tm = (10 * 1000 * 1000); // 10 milliseconds | |
104 | static __u64 max_pkts_per_bunch = 8; // Default # of pkts per bunch | |
105 | static int verbose = 0; // Boolean: output stats | |
106 | static int find_traces = 0; // Boolean: Find traces in dir | |
107 | ||
108 | static char usage_str[] = \ | |
109 | "\n" \ | |
110 | "\t[ -d <dir> : --input-directory=<dir> ] Default: .\n" \ | |
111 | "\t[ -D <dir> : --output-directory=<dir>] Default: .\n" \ | |
112 | "\t[ -F : --find-traces ] Default: Off\n" \ | |
113 | "\t[ -h : --help ] Default: Off\n" \ | |
114 | "\t[ -m <nsec> : --max-bunch-time=<nsec> ] Default: 10 msec\n" \ | |
115 | "\t[ -M <pkts> : --max-pkts=<pkts> ] Default: 8\n" \ | |
116 | "\t[ -o <base> : --output-base=<base> ] Default: replay\n" \ | |
117 | "\t[ -v : --verbose ] Default: Off\n" \ | |
118 | "\t[ -V : --version ] Default: Off\n" \ | |
119 | "\t<dev>... Default: None\n" \ | |
120 | "\n"; | |
121 | ||
122 | #define S_OPTS "d:D:Fhm:M:o:vV" | |
123 | static struct option l_opts[] = { | |
124 | { | |
125 | .name = "input-directory", | |
126 | .has_arg = required_argument, | |
127 | .flag = NULL, | |
128 | .val = 'd' | |
129 | }, | |
130 | { | |
131 | .name = "output-directory", | |
132 | .has_arg = required_argument, | |
133 | .flag = NULL, | |
134 | .val = 'D' | |
135 | }, | |
136 | { | |
137 | .name = "find-traces", | |
138 | .has_arg = no_argument, | |
139 | .flag = NULL, | |
140 | .val = 'F' | |
141 | }, | |
142 | { | |
143 | .name = "help", | |
144 | .has_arg = no_argument, | |
145 | .flag = NULL, | |
146 | .val = 'h' | |
147 | }, | |
148 | { | |
149 | .name = "max-bunch-time", | |
150 | .has_arg = required_argument, | |
151 | .flag = NULL, | |
152 | .val = 'm' | |
153 | }, | |
154 | { | |
155 | .name = "max_pkts", | |
156 | .has_arg = required_argument, | |
157 | .flag = NULL, | |
158 | .val = 'M' | |
159 | }, | |
160 | { | |
161 | .name = "output-base", | |
162 | .has_arg = required_argument, | |
163 | .flag = NULL, | |
164 | .val = 'o' | |
165 | }, | |
166 | { | |
167 | .name = "verbose", | |
168 | .has_arg = no_argument, | |
169 | .flag = NULL, | |
170 | .val = 'v' | |
171 | }, | |
172 | { | |
173 | .name = "version", | |
174 | .has_arg = no_argument, | |
175 | .flag = NULL, | |
176 | .val = 'V' | |
177 | }, | |
178 | { | |
179 | .name = NULL | |
180 | } | |
181 | }; | |
182 | ||
183 | #define ERR_ARGS 1 | |
184 | #define ERR_SYSCALL 2 | |
65a7043b AB |
185 | static inline void fatal(const char *errstring, const int exitval, |
186 | const char *fmt, ...) | |
187 | { | |
188 | va_list ap; | |
189 | ||
190 | if (errstring) | |
191 | perror(errstring); | |
192 | ||
193 | va_start(ap, fmt); | |
194 | vfprintf(stderr, fmt, ap); | |
195 | va_end(ap); | |
196 | ||
197 | exit(exitval); | |
198 | /*NOTREACHED*/ | |
199 | } | |
d47a3fec AB |
200 | |
201 | /** | |
202 | * match - Return true if this trace is a proper QUEUE transaction | |
203 | * @action: Action field from trace | |
204 | */ | |
205 | static inline int match(__u32 action) | |
206 | { | |
207 | return ((action & 0xffff) == __BLK_TA_QUEUE) && | |
208 | (action & BLK_TC_ACT(BLK_TC_QUEUE)); | |
209 | } | |
210 | ||
211 | /** | |
212 | * usage - Display usage string and version | |
213 | */ | |
214 | static void usage(void) | |
215 | { | |
216 | fprintf(stderr, "Usage: btrecord -- version %s\n%s", | |
217 | my_btversion, usage_str); | |
218 | } | |
219 | ||
220 | /** | |
221 | * write_file_hdr - Seek to and write btrecord file header | |
222 | * @stream: Output file information | |
223 | * @hdr: Header to write | |
224 | */ | |
225 | static void write_file_hdr(struct io_stream *stream, struct io_file_hdr *hdr) | |
226 | { | |
227 | hdr->version = mk_btversion(btver_mjr, btver_mnr, btver_sub); | |
228 | ||
229 | if (verbose) { | |
230 | fprintf(stderr, "\t%s: %llx %llx %llx %llx\n", | |
231 | stream->file_name, | |
232 | (long long unsigned)hdr->version, | |
233 | (long long unsigned)hdr->genesis, | |
234 | (long long unsigned)hdr->nbunches, | |
235 | (long long unsigned)hdr->total_pkts); | |
236 | } | |
237 | ||
238 | fseek(stream->ofp, 0, SEEK_SET); | |
239 | if (fwrite(hdr, sizeof(*hdr), 1, stream->ofp) != 1) { | |
240 | fatal(stream->file_name, ERR_SYSCALL, "Hdr write failed\n"); | |
241 | /*NOTREACHED*/ | |
242 | } | |
243 | } | |
244 | ||
245 | /** | |
246 | * io_bunch_create - Allocate & initialize an io_bunch | |
247 | * @io_stream: IO stream being added to | |
248 | * @pre_stall: Amount of time that this bunch should be delayed by | |
249 | * @start_time: Records current start | |
250 | */ | |
251 | static inline void io_bunch_create(struct io_stream *stream, __u64 start_time) | |
252 | { | |
253 | struct io_bunch *cur = malloc(sizeof(*cur)); | |
254 | ||
255 | memset(cur, 0, sizeof(*cur)); | |
256 | ||
257 | cur->hdr.npkts = 0; | |
258 | cur->hdr.time_stamp = stream->start_time = start_time; | |
259 | ||
260 | stream->cur = cur; | |
261 | } | |
262 | ||
263 | /** | |
264 | * io_bunch_add - Add an IO to the current bunch of IOs | |
265 | * @stream: Per-output file stream information | |
266 | * @spec: IO trace specification | |
267 | * | |
268 | * Returns update bunch information | |
269 | */ | |
270 | static void io_bunch_add(struct io_stream *stream, struct io_spec *spec) | |
271 | { | |
272 | struct io_bunch *cur = stream->cur; | |
273 | struct io_pkt iop = { | |
274 | .sector = spec->sector, | |
275 | .nbytes = spec->bytes, | |
276 | .rw = spec->rw | |
277 | }; | |
278 | ||
279 | assert(cur != NULL); | |
280 | assert(cur->hdr.npkts < BT_MAX_PKTS); | |
281 | assert(stream->last_time == 0 || stream->last_time <= spec->time); | |
282 | ||
283 | cur->pkts[cur->hdr.npkts++] = iop; // Struct copy | |
284 | stream->last_time = spec->time; | |
285 | } | |
286 | ||
287 | /** | |
288 | * rem_input_file - Release resources associated with an input file | |
289 | * @iip: Per-input file information | |
290 | */ | |
291 | static void rem_input_file(struct ifile_info *iip) | |
292 | { | |
293 | list_del(&iip->head); | |
294 | ||
295 | close(iip->ifd); | |
296 | free(iip->file_name); | |
297 | free(iip->devnm); | |
298 | free(iip); | |
299 | } | |
300 | ||
301 | /** | |
302 | * __add_input_file - Allocate and initialize per-input file structure | |
303 | * @cpu: CPU for this file | |
304 | * @devnm: Device name for this file | |
305 | * @file_name: Fully qualifed input file name | |
306 | */ | |
307 | static void __add_input_file(int cpu, char *devnm, char *file_name) | |
308 | { | |
309 | struct ifile_info *iip = malloc(sizeof(*iip)); | |
310 | ||
311 | iip->cpu = cpu; | |
312 | iip->tpkts = 0; | |
313 | iip->genesis = 0; | |
314 | iip->devnm = strdup(devnm); | |
315 | iip->file_name = strdup(file_name); | |
316 | iip->ifd = open(file_name, O_RDONLY); | |
317 | if (iip->ifd < 0) { | |
318 | fatal(file_name, ERR_ARGS, "Unable to open\n"); | |
319 | /*NOTREACHED*/ | |
320 | } | |
321 | ||
322 | list_add_tail(&iip->head, &input_files); | |
323 | } | |
324 | ||
325 | /** | |
326 | * add_input_file - Set up the input file name | |
327 | * @devnm: Device name to use | |
328 | */ | |
329 | static void add_input_file(char *devnm) | |
330 | { | |
331 | struct list_head *p; | |
332 | int cpu, found = 0; | |
333 | ||
334 | __list_for_each(p, &input_files) { | |
335 | struct ifile_info *iip = list_entry(p, struct ifile_info, head); | |
336 | if (strcmp(iip->devnm, devnm) == 0) | |
337 | return; | |
338 | } | |
339 | ||
340 | for (cpu = 0; ; cpu++) { | |
341 | char full_name[MAXPATHLEN]; | |
342 | ||
343 | sprintf(full_name, "%s/%s.blktrace.%d", idir, devnm, cpu); | |
344 | if (access(full_name, R_OK) != 0) | |
345 | break; | |
346 | ||
347 | __add_input_file(cpu, devnm, full_name); | |
348 | found++; | |
349 | } | |
350 | ||
351 | if (!found) { | |
352 | fatal(NULL, ERR_ARGS, "No traces found for %s\n", devnm); | |
353 | /*NOTREACHED*/ | |
354 | } | |
355 | } | |
356 | ||
357 | static void find_input_files(char *idir) | |
358 | { | |
359 | struct dirent *ent; | |
360 | DIR *dir = opendir(idir); | |
361 | ||
362 | if (dir == NULL) { | |
363 | fatal(idir, ERR_ARGS, "Unable to open %s\n", idir); | |
364 | /*NOTREACHED*/ | |
365 | } | |
366 | ||
367 | while ((ent = readdir(dir)) != NULL) { | |
368 | char *p, *dsf = malloc(256); | |
369 | ||
370 | if (strstr(ent->d_name, ".blktrace.") == NULL) | |
371 | continue; | |
372 | ||
373 | dsf = strdup(ent->d_name); | |
374 | p = index(dsf, '.'); | |
375 | assert(p != NULL); | |
376 | *p = '\0'; | |
377 | add_input_file(dsf); | |
378 | free(dsf); | |
379 | } | |
380 | ||
381 | closedir(dir); | |
382 | } | |
383 | ||
384 | /** | |
385 | * handle_args - Parse passed in argument list | |
386 | * @argc: Number of arguments in argv | |
387 | * @argv: Arguments passed in | |
388 | * | |
389 | * Does rudimentary parameter verification as well. | |
390 | */ | |
391 | void handle_args(int argc, char *argv[]) | |
392 | { | |
393 | int c; | |
394 | ||
395 | while ((c = getopt_long(argc, argv, S_OPTS, l_opts, NULL)) != -1) { | |
396 | switch (c) { | |
397 | case 'd': | |
398 | idir = optarg; | |
399 | if (access(idir, R_OK | X_OK) != 0) { | |
400 | fatal(idir, ERR_ARGS, | |
401 | "Invalid input directory specified\n"); | |
402 | /*NOTREACHED*/ | |
403 | } | |
404 | break; | |
405 | ||
406 | case 'D': | |
407 | odir = optarg; | |
408 | if (access(odir, R_OK | X_OK) != 0) { | |
409 | fatal(odir, ERR_ARGS, | |
410 | "Invalid output directory specified\n"); | |
411 | /*NOTREACHED*/ | |
412 | } | |
413 | break; | |
414 | ||
415 | case 'F': | |
416 | find_traces = 1; | |
417 | break; | |
418 | ||
419 | case 'h': | |
420 | usage(); | |
421 | exit(0); | |
422 | /*NOTREACHED*/ | |
423 | ||
424 | case 'm': | |
425 | max_bunch_tm = (__u64)atoll(optarg); | |
426 | if (max_bunch_tm < 1) { | |
427 | fprintf(stderr, "Invalid bunch time %llu\n", | |
428 | (unsigned long long)max_bunch_tm); | |
429 | exit(ERR_ARGS); | |
430 | /*NOTREACHED*/ | |
431 | } | |
432 | break; | |
433 | ||
434 | case 'M': | |
435 | max_pkts_per_bunch = (__u64)atoll(optarg); | |
436 | if (!((1 <= max_pkts_per_bunch) && | |
437 | (max_pkts_per_bunch < 513))) { | |
438 | fprintf(stderr, "Invalid max pkts %llu\n", | |
439 | (unsigned long long)max_pkts_per_bunch); | |
440 | exit(ERR_ARGS); | |
441 | /*NOTREACHED*/ | |
442 | } | |
443 | break; | |
444 | ||
445 | case 'o': | |
446 | obase = optarg; | |
447 | break; | |
448 | ||
449 | case 'V': | |
450 | fprintf(stderr, "btrecord -- version %s\n", | |
451 | my_btversion); | |
452 | fprintf(stderr, " Built on %s\n", build_date); | |
453 | exit(0); | |
454 | /*NOTREACHED*/ | |
455 | ||
456 | case 'v': | |
457 | verbose++; | |
458 | break; | |
459 | ||
460 | default: | |
461 | usage(); | |
462 | fatal(NULL, ERR_ARGS, "Invalid command line\n"); | |
463 | /*NOTREACHED*/ | |
464 | } | |
465 | } | |
466 | ||
467 | while (optind < argc) | |
468 | add_input_file(argv[optind++]); | |
469 | ||
470 | if (find_traces) | |
471 | find_input_files(idir); | |
472 | ||
473 | if (list_len(&input_files) == 0) { | |
474 | fatal(NULL, ERR_ARGS, "Missing required input file name(s)\n"); | |
475 | /*NOTREACHED*/ | |
476 | } | |
477 | } | |
478 | ||
479 | /** | |
480 | * next_io - Retrieve next Q trace from input stream | |
481 | * @iip: Per-input file information | |
482 | * @spec: IO specifier for trace | |
483 | * | |
484 | * Returns 0 on end of file, 1 if valid data returned. | |
485 | */ | |
486 | static int next_io(struct ifile_info *iip, struct io_spec *spec) | |
487 | { | |
488 | ssize_t ret; | |
489 | __u32 action; | |
490 | __u16 pdu_len; | |
491 | struct blk_io_trace t; | |
492 | ||
493 | again: | |
494 | ret = read(iip->ifd, &t, sizeof(t)); | |
495 | if (ret < 0) { | |
496 | fatal(iip->file_name, ERR_SYSCALL, "Read failed\n"); | |
497 | /*NOTREACHED*/ | |
498 | } | |
499 | else if (ret == 0) | |
500 | return 0; | |
501 | else if (ret < (ssize_t)sizeof(t)) { | |
502 | fprintf(stderr, "WARNING: Short read on %s (%d)\n", | |
503 | iip->file_name, (int)ret); | |
504 | return 0; | |
505 | } | |
506 | ||
507 | if (data_is_native == -1) | |
508 | check_data_endianness(t.magic); | |
509 | ||
510 | assert(data_is_native >= 0); | |
511 | if (data_is_native) { | |
512 | spec->time = t.time; | |
513 | spec->sector = t.sector; | |
514 | spec->bytes = t.bytes; | |
515 | action = t.action; | |
516 | pdu_len = t.pdu_len; | |
517 | } | |
518 | else { | |
519 | spec->time = be64_to_cpu(t.time); | |
520 | spec->sector = be64_to_cpu(t.sector); | |
521 | spec->bytes = be32_to_cpu(t.bytes); | |
522 | action = be32_to_cpu(t.action); | |
523 | pdu_len = be16_to_cpu(t.pdu_len); | |
524 | } | |
525 | ||
526 | ||
527 | if (pdu_len) { | |
528 | char buf[pdu_len]; | |
529 | ||
530 | ret = read(iip->ifd, buf, pdu_len); | |
531 | if (ret < 0) { | |
532 | fatal(iip->file_name, ERR_SYSCALL, "Read PDU failed\n"); | |
533 | /*NOTREACHED*/ | |
534 | } | |
535 | else if (ret < (ssize_t)pdu_len) { | |
536 | fprintf(stderr, "WARNING: Short PDU read on %s (%d)\n", | |
537 | iip->file_name, (int)ret); | |
538 | return 0; | |
539 | } | |
540 | } | |
541 | ||
542 | iip->tpkts++; | |
543 | if (!match(action)) | |
544 | goto again; | |
545 | ||
546 | spec->rw = (action & BLK_TC_ACT(BLK_TC_READ)) ? 1 : 0; | |
547 | if (verbose > 1) | |
548 | fprintf(stderr, "%2d: %10llu+%10llu (%d) @ %10llx\n", | |
549 | iip->cpu, (long long unsigned)spec->sector, | |
550 | (long long unsigned)spec->bytes / 512LLU, | |
551 | spec->rw, (long long unsigned)spec->time); | |
552 | ||
553 | if (iip->genesis == 0) { | |
554 | iip->genesis = spec->time; | |
555 | if (verbose > 1) | |
556 | fprintf(stderr, "\tSetting new genesis: %llx(%d)\n", | |
557 | (long long unsigned)iip->genesis, iip->cpu); | |
558 | } | |
559 | else if (iip->genesis > spec->time) | |
560 | fatal(NULL, ERR_SYSCALL, | |
561 | "Time inversion? %llu ... %llu\n", | |
562 | (long long unsigned )iip->genesis, | |
563 | (long long unsigned )spec->time); | |
564 | ||
565 | return 1; | |
566 | } | |
567 | ||
568 | /** | |
569 | * bunch_output_hdr - Output bunch header | |
570 | */ | |
571 | static inline void bunch_output_hdr(struct io_stream *stream) | |
572 | { | |
573 | struct io_bunch_hdr *hdrp = &stream->cur->hdr; | |
574 | ||
575 | assert(0 < hdrp->npkts && hdrp->npkts <= BT_MAX_PKTS); | |
576 | if (fwrite(hdrp, sizeof(struct io_bunch_hdr), 1, stream->ofp) != 1) { | |
577 | fatal(stream->file_name, ERR_SYSCALL, "fwrite(hdr) failed\n"); | |
578 | /*NOTREACHED*/ | |
579 | } | |
580 | ||
581 | if (verbose) { | |
582 | __u64 off = hdrp->time_stamp - stream->iip->genesis; | |
583 | ||
584 | assert(stream->vfp); | |
585 | fprintf(stream->vfp, "------------------\n"); | |
586 | fprintf(stream->vfp, "%4llu.%09llu %3llu\n", | |
587 | (unsigned long long)off / (1000 * 1000 * 1000), | |
588 | (unsigned long long)off % (1000 * 1000 * 1000), | |
589 | (unsigned long long)hdrp->npkts); | |
590 | fprintf(stream->vfp, "------------------\n"); | |
591 | } | |
592 | } | |
593 | ||
594 | /** | |
595 | * bunch_output_pkt - Output IO packets | |
596 | */ | |
597 | static inline void bunch_output_pkts(struct io_stream *stream) | |
598 | { | |
599 | struct io_pkt *p = stream->cur->pkts; | |
600 | size_t npkts = stream->cur->hdr.npkts; | |
601 | ||
602 | assert(0 < npkts && npkts <= BT_MAX_PKTS); | |
603 | if (fwrite(p, sizeof(struct io_pkt), npkts, stream->ofp) != npkts) { | |
604 | fatal(stream->file_name, ERR_SYSCALL, "fwrite(pkts) failed\n"); | |
605 | /*NOTREACHED*/ | |
606 | } | |
607 | ||
608 | if (verbose) { | |
609 | size_t i; | |
610 | ||
611 | assert(stream->vfp); | |
612 | for (i = 0; i < npkts; i++, p++) | |
613 | fprintf(stream->vfp, "\t%1d %10llu\t%10llu\n", | |
614 | p->rw, | |
615 | (unsigned long long)p->sector, | |
616 | (unsigned long long)p->nbytes / 512); | |
617 | } | |
618 | } | |
619 | ||
620 | /** | |
621 | * stream_flush - Flush current bunch of IOs out to the output stream | |
622 | * @stream: Per-output file stream information | |
623 | */ | |
624 | static void stream_flush(struct io_stream *stream) | |
625 | { | |
626 | struct io_bunch *cur = stream->cur; | |
627 | ||
628 | if (cur) { | |
629 | if (cur->hdr.npkts) { | |
630 | assert(cur->hdr.npkts <= BT_MAX_PKTS); | |
631 | bunch_output_hdr(stream); | |
632 | bunch_output_pkts(stream); | |
633 | ||
634 | stream->bunches++; | |
635 | stream->pkts += cur->hdr.npkts; | |
636 | } | |
637 | free(cur); | |
638 | } | |
639 | } | |
640 | ||
641 | /** | |
642 | * bunch_done - Returns true if current bunch is either full, or next IO is late | |
643 | * @stream: Output stream information | |
644 | * @spec: IO trace specification | |
645 | */ | |
646 | static inline int bunch_done(struct io_stream *stream, struct io_spec *spec) | |
647 | { | |
648 | if (stream->cur->hdr.npkts >= max_pkts_per_bunch) | |
649 | return 1; | |
650 | ||
651 | if ((spec->time - stream->start_time) > max_bunch_tm) | |
652 | return 1; | |
653 | ||
654 | return 0; | |
655 | } | |
656 | ||
657 | /** | |
658 | * stream_add_io - Add an IO trace to the current stream | |
659 | * @stream: Output stream information | |
660 | * @spec: IO trace specification | |
661 | */ | |
662 | static void stream_add_io(struct io_stream *stream, struct io_spec *spec) | |
663 | { | |
664 | ||
665 | if (stream->cur == NULL) | |
666 | io_bunch_create(stream, spec->time); | |
667 | else if (bunch_done(stream, spec)) { | |
668 | stream_flush(stream); | |
669 | io_bunch_create(stream, spec->time); | |
670 | } | |
671 | ||
672 | io_bunch_add(stream, spec); | |
673 | } | |
674 | ||
675 | /** | |
676 | * stream_open - Open output stream for specified input stream | |
677 | * @iip: Per-input file information | |
678 | */ | |
679 | static struct io_stream *stream_open(struct ifile_info *iip) | |
680 | { | |
681 | char ofile_name[MAXPATHLEN]; | |
682 | struct io_stream *stream = malloc(sizeof(*stream)); | |
683 | struct io_file_hdr io_file_hdr = { | |
684 | .genesis = 0, | |
685 | .nbunches = 0, | |
686 | .total_pkts = 0 | |
687 | }; | |
688 | ||
689 | memset(stream, 0, sizeof(*stream)); | |
690 | ||
691 | sprintf(ofile_name, "%s/%s.%s.%d", odir, iip->devnm, obase, iip->cpu); | |
692 | stream->ofp = fopen(ofile_name, "w"); | |
693 | if (!stream->ofp) { | |
694 | fatal(ofile_name, ERR_SYSCALL, "Open failed\n"); | |
695 | /*NOTREACHED*/ | |
696 | } | |
697 | ||
698 | stream->iip = iip; | |
699 | stream->cur = NULL; | |
700 | stream->bunches = stream->pkts = 0; | |
701 | stream->last_time = 0; | |
702 | stream->file_name = strdup(ofile_name); | |
703 | ||
704 | write_file_hdr(stream, &io_file_hdr); | |
705 | ||
706 | if (verbose) { | |
707 | char vfile_name[MAXPATHLEN]; | |
708 | ||
709 | sprintf(vfile_name, "%s/%s.%s.%d.rec", odir, iip->devnm, | |
710 | obase, iip->cpu); | |
711 | stream->vfp = fopen(vfile_name, "w"); | |
712 | if (!stream->vfp) { | |
713 | fatal(vfile_name, ERR_SYSCALL, "Open failed\n"); | |
714 | /*NOTREACHED*/ | |
715 | } | |
716 | ||
717 | stream->vfn = strdup(vfile_name); | |
718 | } | |
719 | ||
720 | data_is_native = -1; | |
721 | return stream; | |
722 | } | |
723 | ||
724 | /** | |
725 | * stream_close - Release resources associated with an output stream | |
726 | * @stream: Stream to release | |
727 | */ | |
728 | static void stream_close(struct io_stream *stream) | |
729 | { | |
730 | struct io_file_hdr io_file_hdr = { | |
731 | .genesis = stream->iip->genesis, | |
732 | .nbunches = stream->bunches, | |
733 | .total_pkts = stream->pkts | |
734 | }; | |
735 | ||
736 | stream_flush(stream); | |
737 | write_file_hdr(stream, &io_file_hdr); | |
738 | fclose(stream->ofp); | |
739 | ||
740 | if (verbose && stream->bunches) { | |
741 | fprintf(stderr, | |
742 | "%s:%d: %llu pkts (tot), %llu pkts (replay), " | |
743 | "%llu bunches, %.1lf pkts/bunch\n", | |
744 | stream->iip->devnm, stream->iip->cpu, | |
745 | (unsigned long long)stream->iip->tpkts, | |
746 | (unsigned long long)stream->pkts, | |
747 | (unsigned long long)stream->bunches, | |
748 | (double)(stream->pkts) / (double)(stream->bunches)); | |
749 | ||
750 | fclose(stream->vfp); | |
751 | free(stream->vfn); | |
752 | } | |
753 | ||
754 | free(stream->file_name); | |
755 | free(stream); | |
756 | } | |
757 | ||
758 | /** | |
759 | * process - Process one input file to an output file | |
760 | * @iip: Per-input file information | |
761 | */ | |
762 | static void process(struct ifile_info *iip) | |
763 | { | |
764 | struct io_spec spec; | |
765 | struct io_stream *stream; | |
766 | ||
767 | stream = stream_open(iip); | |
768 | while (next_io(iip, &spec)) | |
769 | stream_add_io(stream, &spec); | |
770 | stream_close(stream); | |
771 | ||
772 | rem_input_file(iip); | |
773 | } | |
774 | ||
775 | /** | |
776 | * main - | |
777 | * @argc: Number of arguments | |
778 | * @argv: Array of arguments | |
779 | */ | |
780 | int main(int argc, char *argv[]) | |
781 | { | |
782 | struct list_head *p, *q; | |
783 | ||
784 | handle_args(argc, argv); | |
785 | list_for_each_safe(p, q, &input_files) | |
786 | process(list_entry(p, struct ifile_info, head)); | |
787 | ||
788 | return 0; | |
789 | } |