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;
103 else if (t > ap->max)
105 ap->total += (n * t);
111 static inline void avg_unupdate(struct avg_info *ap, __u64 t)
117 static inline void update_lq(__u64 *last_q, struct avg_info *avg, __u64 time)
119 if (*last_q != ((__u64)-1))
120 avg_update(avg, (time > *last_q) ? time - *last_q : 1);
124 static inline void dip_update_q(struct d_info *dip, struct io *iop)
126 if (remapper_dev(dip->device))
127 update_lq(&dip->last_q, &dip->avgs.q2q_dm, iop->t.time);
129 update_lq(&dip->last_q, &dip->avgs.q2q, iop->t.time);
130 update_qregion(&dip->regions, iop->t.time);
133 static inline struct io *io_alloc(void)
135 struct io *iop = malloc(sizeof(*iop));
137 memset(iop, 0, sizeof(struct io));
138 list_add_tail(&iop->a_head, &all_ios);
143 static inline void io_free(struct io *iop)
145 list_del(&iop->a_head);
149 static inline void io_free_all(void)
152 struct list_head *p, *q;
154 list_for_each_safe(p, q, &all_ios) {
155 iop = list_entry(p, struct io, a_head);
160 static inline int io_setup(struct io *iop, enum iop_type type)
163 iop->dip = dip_alloc(iop->t.device, iop);
165 iop->pip = find_process(iop->t.pid, NULL);
166 iop->bytes_left = iop->t.bytes;
172 static inline void io_release(struct io *iop)
182 #define UPDATE_AVGS(_avg, _iop, _pip, _time) do { \
183 avg_update(&all_avgs. _avg , _time); \
184 avg_update(&_iop->dip->avgs. _avg , _time); \
185 if (_pip) avg_update(&_pip->avgs. _avg , _time); \
188 #define UPDATE_AVGS_N(_avg, _iop, _pip, _time, _n) do { \
189 avg_update_n(&all_avgs. _avg , _time, _n); \
190 avg_update_n(&_iop->dip->avgs. _avg , _time, _n); \
191 if (_pip) avg_update_n(&_pip->avgs. _avg , _time,_n); \
194 #define UNUPDATE_AVGS(_avg, _iop, _pip, _time) do { \
195 avg_unupdate(&all_avgs. _avg , _time); \
196 avg_unupdate(&_iop->dip->avgs. _avg , _time); \
197 if (_pip) avg_unupdate(&_pip->avgs. _avg , _time); \
200 static inline void update_q2c(struct io *iop, __u64 c_time)
202 if (remapper_dev(iop->dip->device))
203 UPDATE_AVGS(q2c_dm, iop, iop->pip, c_time);
205 UPDATE_AVGS(q2c, iop, iop->pip, c_time);
208 static inline void update_q2a(struct io *iop, __u64 a_time)
210 if (remapper_dev(iop->dip->device))
211 UPDATE_AVGS(q2a_dm, iop, iop->pip, a_time);
213 UPDATE_AVGS(q2a, iop, iop->pip, a_time);
216 static inline void update_q2g(struct io *iop, __u64 g_time)
218 UPDATE_AVGS(q2g, iop, iop->pip, g_time);
221 static inline void update_s2g(struct io *iop, __u64 g_time)
223 UPDATE_AVGS(s2g, iop, iop->pip, g_time);
226 static inline void unupdate_q2g(struct io *iop, __u64 g_time)
228 UNUPDATE_AVGS(q2g, iop, iop->pip, g_time);
231 static inline void update_g2i(struct io *iop, __u64 i_time)
233 UPDATE_AVGS(g2i, iop, iop->pip, i_time);
236 static inline void unupdate_g2i(struct io *iop, __u64 i_time)
238 UNUPDATE_AVGS(g2i, iop, iop->pip, i_time);
241 static inline void update_q2m(struct io *iop, __u64 m_time)
243 UPDATE_AVGS(q2m, iop, iop->pip, m_time);
246 static inline void unupdate_q2m(struct io *iop, __u64 m_time)
248 UNUPDATE_AVGS(q2m, iop, iop->pip, m_time);
251 static inline void update_i2d(struct io *iop, __u64 d_time)
253 UPDATE_AVGS(i2d, iop, iop->pip, d_time);
256 static inline void unupdate_i2d(struct io *iop, __u64 d_time)
258 UNUPDATE_AVGS(i2d, iop, iop->pip, d_time);
261 static inline void update_m2d(struct io *iop, __u64 d_time)
263 UPDATE_AVGS(m2d, iop, iop->pip, d_time);
266 static inline void unupdate_m2d(struct io *iop, __u64 d_time)
268 UNUPDATE_AVGS(m2d, iop, iop->pip, d_time);
271 static inline void update_d2c(struct io *iop, __u64 c_time)
273 UPDATE_AVGS(d2c, iop, iop->pip, c_time);
276 static inline void update_blks(struct io *iop)
278 __u64 nblks = iop->t.bytes >> 9;
279 avg_update(&all_avgs.blks, nblks);
280 avg_update(&iop->dip->avgs.blks, nblks);
282 avg_update(&iop->pip->avgs.blks, nblks);
285 static inline struct rb_root *__get_root(struct d_info *dip, enum iop_type type)
287 struct rb_root *roots = dip->heads;
291 static inline int dip_rb_ins(struct d_info *dip, struct io *iop)
293 return rb_insert(__get_root(dip, iop->type), iop);
296 static inline void dip_rb_rem(struct io *iop)
298 rb_erase(&iop->rb_node, __get_root(iop->dip, iop->type));
301 static inline void dip_rb_fe(struct d_info *dip, enum iop_type type,
303 void (*fnc)(struct io *iop, struct io *this),
304 struct list_head *head)
306 rb_foreach(__get_root(dip, type)->rb_node, iop, fnc, head);
309 static inline struct io *dip_rb_find_sec(struct d_info *dip,
310 enum iop_type type, __u64 sec)
312 return rb_find_sec(__get_root(dip, type), sec);
315 static inline __u64 tdelta(__u64 from, __u64 to)
317 return (from < to) ? (to - from) : 1;
320 static inline int type2c(enum iop_type type)
325 case IOP_Q: c = 'Q'; break;
326 case IOP_X: c = 'X'; break;
327 case IOP_A: c = 'A'; break;
328 case IOP_I: c = 'I'; break;
329 case IOP_M: c = 'M'; break;
330 case IOP_D: c = 'D'; break;
331 case IOP_C: c = 'C'; break;
332 case IOP_R: c = 'R'; break;
333 case IOP_G: c = 'G'; break;
334 default : c = '?'; break;
340 static inline int histo_idx(__u64 nbytes)
342 int idx = (nbytes >> 9) - 1;
343 return min(idx, N_HIST_BKTS-1);
346 static inline void update_q_histo(__u64 nbytes)
348 q_histo[histo_idx(nbytes)]++;
351 static inline void update_d_histo(__u64 nbytes)
353 d_histo[histo_idx(nbytes)]++;
356 static inline struct io *io_first_list(struct list_head *head)
358 if (list_empty(head))
361 return list_entry(head->next, struct io, f_head);
364 static inline void __dump_iop(FILE *ofp, struct io *iop, int extra_nl)
366 fprintf(ofp, "%5d.%09lu %3d,%-3d %c %10llu+%-4u\n",
367 (int)SECONDS(iop->t.time),
368 (unsigned long)NANO_SECONDS(iop->t.time),
369 MAJOR(iop->t.device), MINOR(iop->t.device), type2c(iop->type),
370 (unsigned long long)iop->t.sector, t_sec(&iop->t));
371 if (extra_nl) fprintf(ofp, "\n");
374 static inline void __dump_iop2(FILE *ofp, struct io *a_iop, struct io *l_iop)
376 fprintf(ofp, "%5d.%09lu %3d,%-3d %c %10llu+%-4u <- (%3d,%-3d) %10llu\n",
377 (int)SECONDS(a_iop->t.time),
378 (unsigned long)NANO_SECONDS(a_iop->t.time),
379 MAJOR(a_iop->t.device), MINOR(a_iop->t.device),
380 type2c(a_iop->type), (unsigned long long)a_iop->t.sector,
381 t_sec(&a_iop->t), MAJOR(l_iop->t.device),
382 MINOR(l_iop->t.device), (unsigned long long)l_iop->t.sector);