2 * blktrace output analysis: generate a timeline & gather statistics
4 * Copyright (C) 2006 Alan D. Brunelle <Alan.Brunelle@hp.com>
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.
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.
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
22 static inline int remapper_dev(__u32 dev)
25 return mjr == 9 || mjr == 253 || mjr == 254;
28 static inline void region_init(struct region_info *reg)
30 INIT_LIST_HEAD(®->qranges);
31 INIT_LIST_HEAD(®->cranges);
34 static inline void __region_exit(struct list_head *range_head)
36 struct list_head *p, *q;
37 struct range_info *rip;
39 list_for_each_safe(p, q, range_head) {
40 rip = list_entry(p, struct range_info, head);
45 static inline void region_exit(struct region_info *reg)
47 __region_exit(®->qranges);
48 __region_exit(®->cranges);
51 static inline void update_range(struct list_head *head_p, __u64 time)
53 struct range_info *rip;
55 if (!list_empty(head_p)) {
56 rip = list_entry(head_p->prev, struct range_info, head);
61 if (BIT_TIME(time - rip->end) < range_delta) {
67 rip = malloc(sizeof(*rip));
68 rip->start = rip->end = time;
69 list_add_tail(&rip->head, head_p);
72 static inline void update_qregion(struct region_info *reg, __u64 time)
74 update_range(®->qranges, time);
77 static inline void update_cregion(struct region_info *reg, __u64 time)
79 update_range(®->cranges, time);
82 static inline void avg_update(struct avg_info *ap, __u64 t)
85 ap->min = ap->total = ap->max = t;
95 static inline void avg_update_n(struct avg_info *ap, __u64 t, int n)
98 ap->min = ap->max = t;
104 else if (t > ap->max)
106 ap->total += (n * t);
112 static inline void avg_unupdate(struct avg_info *ap, __u64 t)
118 static inline void update_lq(__u64 *last_q, struct avg_info *avg, __u64 time)
120 if (*last_q != ((__u64)-1))
121 avg_update(avg, (time > *last_q) ? time - *last_q : 1);
125 static inline void dip_update_q(struct d_info *dip, struct io *iop)
127 if (remapper_dev(dip->device))
128 update_lq(&dip->last_q, &dip->avgs.q2q_dm, iop->t.time);
130 update_lq(&dip->last_q, &dip->avgs.q2q, iop->t.time);
131 update_qregion(&dip->regions, iop->t.time);
134 static inline struct io *io_alloc(void)
136 struct io *iop = malloc(sizeof(*iop));
138 memset(iop, 0, sizeof(struct io));
139 list_add_tail(&iop->a_head, &all_ios);
144 static inline void io_free(struct io *iop)
146 list_del(&iop->a_head);
150 static inline void io_free_all(void)
153 struct list_head *p, *q;
155 list_for_each_safe(p, q, &all_ios) {
156 iop = list_entry(p, struct io, a_head);
161 static inline int io_setup(struct io *iop, enum iop_type type)
164 iop->dip = dip_add(iop->t.device, iop);
166 iop->pip = find_process(iop->t.pid, NULL);
167 iop->bytes_left = iop->t.bytes;
173 static inline void io_release(struct io *iop)
183 #define UPDATE_AVGS(_avg, _iop, _pip, _time) do { \
184 avg_update(&all_avgs. _avg , _time); \
185 avg_update(&_iop->dip->avgs. _avg , _time); \
186 if (_pip) avg_update(&_pip->avgs. _avg , _time); \
189 #define UPDATE_AVGS_N(_avg, _iop, _pip, _time, _n) do { \
190 avg_update_n(&all_avgs. _avg , _time, _n); \
191 avg_update_n(&_iop->dip->avgs. _avg , _time, _n); \
192 if (_pip) avg_update_n(&_pip->avgs. _avg , _time,_n); \
195 #define UNUPDATE_AVGS(_avg, _iop, _pip, _time) do { \
196 avg_unupdate(&all_avgs. _avg , _time); \
197 avg_unupdate(&_iop->dip->avgs. _avg , _time); \
198 if (_pip) avg_unupdate(&_pip->avgs. _avg , _time); \
201 static inline void update_q2c(struct io *iop, __u64 c_time)
203 if (remapper_dev(iop->dip->device))
204 UPDATE_AVGS(q2c_dm, iop, iop->pip, c_time);
206 UPDATE_AVGS(q2c, iop, iop->pip, c_time);
209 static inline void update_q2a(struct io *iop, __u64 a_time)
211 if (remapper_dev(iop->dip->device))
212 UPDATE_AVGS(q2a_dm, iop, iop->pip, a_time);
214 UPDATE_AVGS(q2a, iop, iop->pip, a_time);
217 static inline void update_q2g(struct io *iop, __u64 g_time)
219 UPDATE_AVGS(q2g, iop, iop->pip, g_time);
222 static inline void update_s2g(struct io *iop, __u64 g_time)
224 UPDATE_AVGS(s2g, iop, iop->pip, g_time);
227 static inline void unupdate_q2g(struct io *iop, __u64 g_time)
229 UNUPDATE_AVGS(q2g, iop, iop->pip, g_time);
232 static inline void update_g2i(struct io *iop, __u64 i_time)
234 UPDATE_AVGS(g2i, iop, iop->pip, i_time);
237 static inline void unupdate_g2i(struct io *iop, __u64 i_time)
239 UNUPDATE_AVGS(g2i, iop, iop->pip, i_time);
242 static inline void update_q2m(struct io *iop, __u64 m_time)
244 UPDATE_AVGS(q2m, iop, iop->pip, m_time);
247 static inline void unupdate_q2m(struct io *iop, __u64 m_time)
249 UNUPDATE_AVGS(q2m, iop, iop->pip, m_time);
252 static inline void update_i2d(struct io *iop, __u64 d_time)
254 UPDATE_AVGS(i2d, iop, iop->pip, d_time);
257 static inline void unupdate_i2d(struct io *iop, __u64 d_time)
259 UNUPDATE_AVGS(i2d, iop, iop->pip, d_time);
262 static inline void update_m2d(struct io *iop, __u64 d_time)
264 UPDATE_AVGS(m2d, iop, iop->pip, d_time);
267 static inline void unupdate_m2d(struct io *iop, __u64 d_time)
269 UNUPDATE_AVGS(m2d, iop, iop->pip, d_time);
272 static inline void update_d2c(struct io *iop, __u64 c_time)
274 UPDATE_AVGS(d2c, iop, iop->pip, c_time);
277 static inline void update_blks(struct io *iop)
279 __u64 nblks = iop->t.bytes >> 9;
280 avg_update(&all_avgs.blks, nblks);
281 avg_update(&iop->dip->avgs.blks, nblks);
283 avg_update(&iop->pip->avgs.blks, nblks);
286 static inline struct rb_root *__get_root(struct d_info *dip, enum iop_type type)
288 struct rb_root *roots = dip->heads;
292 static inline int dip_rb_ins(struct d_info *dip, struct io *iop)
294 return rb_insert(__get_root(dip, iop->type), iop);
297 static inline void dip_rb_rem(struct io *iop)
299 rb_erase(&iop->rb_node, __get_root(iop->dip, iop->type));
302 static inline void dip_rb_fe(struct d_info *dip, enum iop_type type,
304 void (*fnc)(struct io *iop, struct io *this),
305 struct list_head *head)
307 rb_foreach(__get_root(dip, type)->rb_node, iop, fnc, head);
310 static inline struct io *dip_rb_find_sec(struct d_info *dip,
311 enum iop_type type, __u64 sec)
313 return rb_find_sec(__get_root(dip, type), sec);
316 static inline __u64 tdelta(__u64 from, __u64 to)
318 return (from < to) ? (to - from) : 1;
321 static inline int type2c(enum iop_type type)
326 case IOP_Q: c = 'Q'; break;
327 case IOP_X: c = 'X'; break;
328 case IOP_A: c = 'A'; break;
329 case IOP_I: c = 'I'; break;
330 case IOP_M: c = 'M'; break;
331 case IOP_D: c = 'D'; break;
332 case IOP_C: c = 'C'; break;
333 case IOP_R: c = 'R'; break;
334 case IOP_G: c = 'G'; break;
335 default : c = '?'; break;
341 static inline int histo_idx(__u64 nbytes)
343 int idx = (nbytes >> 9) - 1;
344 return min(idx, N_HIST_BKTS-1);
347 static inline void update_q_histo(__u64 nbytes)
349 q_histo[histo_idx(nbytes)]++;
352 static inline void update_d_histo(__u64 nbytes)
354 d_histo[histo_idx(nbytes)]++;
357 static inline struct io *io_first_list(struct list_head *head)
359 if (list_empty(head))
362 return list_entry(head->next, struct io, f_head);
365 static inline void __dump_iop(FILE *ofp, struct io *iop, int extra_nl)
367 fprintf(ofp, "%5d.%09lu %3d,%-3d %c %10llu+%-4u\n",
368 (int)SECONDS(iop->t.time),
369 (unsigned long)NANO_SECONDS(iop->t.time),
370 MAJOR(iop->t.device), MINOR(iop->t.device), type2c(iop->type),
371 (unsigned long long)iop->t.sector, t_sec(&iop->t));
372 if (extra_nl) fprintf(ofp, "\n");
375 static inline void __dump_iop2(FILE *ofp, struct io *a_iop, struct io *l_iop)
377 fprintf(ofp, "%5d.%09lu %3d,%-3d %c %10llu+%-4u <- (%3d,%-3d) %10llu\n",
378 (int)SECONDS(a_iop->t.time),
379 (unsigned long)NANO_SECONDS(a_iop->t.time),
380 MAJOR(a_iop->t.device), MINOR(a_iop->t.device),
381 type2c(a_iop->type), (unsigned long long)a_iop->t.sector,
382 t_sec(&a_iop->t), MAJOR(l_iop->t.device),
383 MINOR(l_iop->t.device), (unsigned long long)l_iop->t.sector);