Commit | Line | Data |
---|---|---|
a4f37ccd | 1 | /* This file is part of the Linux Trace Toolkit viewer |
2 | * Copyright (C) 2005 Peter Ho | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License Version 2 as | |
6 | * published by the Free Software Foundation; | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | * GNU General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License | |
14 | * along with this program; if not, write to the Free Software | |
b9ce0bad YB |
15 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
16 | * MA 02110-1301, USA. | |
a4f37ccd | 17 | */ |
18 | ||
19 | ||
20 | #include <math.h> | |
21 | ||
22 | #include <glib.h> | |
23 | #include <gtk/gtk.h> | |
24 | #include <gdk/gdk.h> | |
a4f37ccd | 25 | #include <stdio.h> |
26 | #include <stdlib.h> | |
27 | #include <string.h> | |
a4f37ccd | 28 | #include <ltt/ltt.h> |
29 | #include <ltt/event.h> | |
a4f37ccd | 30 | #include <ltt/trace.h> |
a4f37ccd | 31 | #include <lttv/module.h> |
32 | #include <lttv/hook.h> | |
33 | #include <lttv/tracecontext.h> | |
34 | #include <lttv/state.h> | |
35 | #include <lttv/filter.h> | |
36 | #include <lttvwindow/lttvwindow.h> | |
e433e6d6 | 37 | #include <lttvwindow/lttv_plugin_tab.h> |
a4f37ccd | 38 | #include <ltt/time.h> |
39 | ||
40 | #include "hDiskPerformanceInsert.xpm" | |
41 | ||
42 | ||
43 | #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format) | |
44 | #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format) | |
8402f27d | 45 | // fixed #define TRACE_NUMBER 0 |
a4f37ccd | 46 | #define NO_ITEMS 0 |
47 | ||
48 | enum{ | |
49 | DISKNAME_COLUMN, | |
50 | BYTES_RD_COLUMN, | |
51 | BYTES_RD_SEC_COLUMN, | |
52 | NUM_RD_COLUMN, | |
53 | BYTES_WR_COLUMN, | |
54 | BYTES_WR_SEC_COLUMN, | |
55 | NUM_WR_COLUMN, | |
56 | N_COLUMNS | |
57 | }; | |
4ea3dbbf | 58 | |
a4f37ccd | 59 | enum operation_t { |
60 | LTTV_READ_OPERATION = 1, | |
61 | LTTV_WRITE_OPERATION | |
62 | }; | |
63 | ||
64 | typedef struct _DiskPerformanceData { | |
65 | ||
66 | Tab * tab; | |
e433e6d6 | 67 | |
68 | LttvPluginTab *ptab; | |
4ea3dbbf | 69 | |
a4f37ccd | 70 | LttvHooks * hooks_trace_after; |
4ea3dbbf | 71 | |
a4f37ccd | 72 | LttvHooks * hooks_trace_before; |
4ea3dbbf | 73 | /* time window */ |
74 | TimeWindow time_window; | |
a4f37ccd | 75 | |
76 | GtkWidget * scroll_win; | |
4ea3dbbf | 77 | |
a4f37ccd | 78 | /* Model containing list data */ |
79 | GtkListStore *store_m; | |
4ea3dbbf | 80 | |
a4f37ccd | 81 | GtkWidget *hbox_v; |
4ea3dbbf | 82 | |
a4f37ccd | 83 | /* Widget to display the data in a columned list */ |
84 | GtkWidget *tree_v; | |
4ea3dbbf | 85 | |
a4f37ccd | 86 | /* Selection handler */ |
87 | GtkTreeSelection *select_c; | |
88 | ||
89 | GArray *disk_array; | |
90 | ||
750eb11a | 91 | LttvHooksByIdChannelArray * event_by_id_hooks; |
4ea3dbbf | 92 | |
a4f37ccd | 93 | } DiskPerformanceData; |
94 | ||
95 | ||
96 | typedef struct _lttv_block { | |
97 | guint major_number; | |
98 | guint minor_number; | |
99 | guint size; | |
100 | } lttv_block; | |
101 | ||
102 | typedef struct _lttv_total_block { | |
103 | char diskname[10]; | |
104 | guint64 total_bytes_read; | |
105 | guint num_read_operations; | |
106 | guint64 total_bytes_written; | |
107 | guint num_write_operations; | |
108 | ||
109 | } lttv_total_block; | |
110 | ||
111 | GSList *g_disk_data_list = NULL ; | |
112 | ||
4ea3dbbf | 113 | |
114 | ||
115 | /* facility */ | |
116 | GQuark LTT_FACILITY_BLOCK; | |
117 | ||
118 | /* events */ | |
119 | GQuark LTT_EVENT_BLOCK_READ; | |
120 | GQuark LTT_EVENT_BLOCK_WRITE; | |
121 | ||
e433e6d6 | 122 | static DiskPerformanceData *disk_performance_data(LttvPluginTab *ptab); |
a4f37ccd | 123 | static void disk_destroy_walk(gpointer data, gpointer user_data); |
a4f37ccd | 124 | static gboolean disk_show(void *hook_data, void *call_data); |
125 | static gboolean trace_header(void *hook_data, void *call_data); | |
126 | static gboolean disk_update_time_window(void * hook_data, void * call_data); | |
a4f37ccd | 127 | static void request_event( DiskPerformanceData *disk_performance); |
128 | void gui_disperformance_free(DiskPerformanceData *event_viewer_data); | |
4ea3dbbf | 129 | static void get_event_detail(LttEvent *e, lttv_block* disk_data); |
a4f37ccd | 130 | static char * major_minor_to_diskname( lttv_block* disk_data); |
131 | static void sum_data(char* diskname, guint size, enum operation_t opt, GArray *disk_array); | |
e433e6d6 | 132 | static GtkWidget *disk_performance(LttvPlugin *plugin); |
4ea3dbbf | 133 | |
134 | static gboolean block_read_callback(void *hook_data, void *call_data); | |
135 | ||
136 | static gboolean block_write_callback(void *hook_data, void *call_data); | |
137 | ||
138 | ||
139 | static gboolean disk_show(void *hook_data, void *call_data){ | |
140 | ||
141 | guint i; | |
142 | lttv_total_block element; | |
143 | GtkTreeIter iter; | |
144 | LttTime time_interval; | |
145 | guint64 time_interval_64; | |
146 | guint64 temp_variable; | |
147 | guint64 bytes_read_per_sec, bytes_written_per_sec; | |
148 | g_info(" diskperformance: disk_show() \n"); | |
149 | DiskPerformanceData *disk_performance = (DiskPerformanceData *)hook_data; | |
150 | GArray *disk_array = disk_performance->disk_array; | |
151 | time_interval = ltt_time_sub(disk_performance->time_window.end_time, disk_performance->time_window.start_time); | |
152 | ||
153 | time_interval_64 = time_interval.tv_sec; | |
154 | time_interval_64 *= NANOSECONDS_PER_SECOND; | |
155 | time_interval_64 += time_interval.tv_nsec; | |
156 | gtk_list_store_clear(disk_performance->store_m); | |
157 | for(i = 0; i < disk_array->len; i++){ | |
158 | ||
159 | element = g_array_index(disk_array,lttv_total_block,i); | |
160 | temp_variable = element.total_bytes_read * NANOSECONDS_PER_SECOND; | |
161 | bytes_read_per_sec = (guint64) temp_variable / time_interval_64; | |
162 | ||
163 | temp_variable = element.total_bytes_written * NANOSECONDS_PER_SECOND; | |
164 | bytes_written_per_sec = (guint64) temp_variable / time_interval_64; | |
165 | ||
166 | gtk_list_store_append (disk_performance->store_m, &iter); | |
167 | gtk_list_store_set (disk_performance->store_m, &iter, | |
168 | DISKNAME_COLUMN, element.diskname, | |
169 | BYTES_RD_COLUMN, element.total_bytes_read, | |
170 | BYTES_RD_SEC_COLUMN,bytes_read_per_sec, | |
171 | NUM_RD_COLUMN, element.num_read_operations, | |
172 | BYTES_WR_COLUMN, element.total_bytes_written, | |
173 | BYTES_WR_SEC_COLUMN, bytes_written_per_sec, | |
174 | NUM_WR_COLUMN, element.num_write_operations, | |
175 | -1); | |
176 | ||
177 | } | |
178 | if(disk_performance->disk_array->len) | |
179 | g_array_remove_range (disk_performance->disk_array,0,disk_performance->disk_array->len); | |
180 | return FALSE; | |
181 | } | |
182 | ||
183 | static gboolean trace_header(void *hook_data, void *call_data){ | |
184 | return FALSE; | |
185 | } | |
186 | ||
187 | ||
188 | static gboolean disk_update_time_window(void * hook_data, void * call_data){ | |
189 | ||
190 | DiskPerformanceData *disk_performance = (DiskPerformanceData *) hook_data; | |
191 | const TimeWindowNotifyData *time_window_nofify_data = ((const TimeWindowNotifyData *)call_data); | |
192 | disk_performance->time_window = *time_window_nofify_data->new_time_window; | |
193 | Tab *tab = disk_performance->tab; | |
194 | lttvwindow_events_request_remove_all(tab, disk_performance); | |
195 | request_event( disk_performance); | |
196 | ||
197 | ||
198 | return FALSE; | |
199 | } | |
200 | ||
201 | void gui_disperformance_free(DiskPerformanceData *eventdata){ | |
202 | Tab *tab = eventdata->tab; | |
203 | g_info("disperformance.c : gui_disperformance_free, %p", eventdata); | |
204 | g_info("%p, %p", eventdata, tab); | |
205 | if(tab != NULL) | |
206 | { | |
207 | g_array_free (eventdata->disk_array, TRUE); | |
208 | ||
209 | lttvwindow_unregister_time_window_notify(tab, | |
210 | disk_update_time_window, | |
211 | eventdata); | |
212 | ||
213 | lttvwindow_events_request_remove_all(eventdata->tab, | |
214 | eventdata); | |
215 | g_disk_data_list = g_slist_remove(g_disk_data_list, eventdata); | |
216 | } | |
217 | g_free(eventdata); | |
218 | g_info("disperformance.c : gui_disperformance_free end, %p", eventdata); | |
219 | } | |
220 | ||
221 | ||
222 | ||
223 | ||
224 | ||
225 | ||
226 | void disk_destructor_full(DiskPerformanceData *disk_data) | |
227 | { | |
228 | ||
229 | if(GTK_IS_WIDGET(disk_data->hbox_v)) | |
230 | gtk_widget_destroy(disk_data->hbox_v); | |
231 | ||
232 | } | |
233 | ||
234 | static void disk_destroy_walk(gpointer data, gpointer user_data) | |
235 | { | |
236 | g_info("Walk destroy GUI disk performance Viewer"); | |
237 | disk_destructor_full((DiskPerformanceData*)data); | |
238 | } | |
239 | /** | |
240 | * init function | |
241 | * | |
242 | * | |
243 | * This is the entry point of the viewer. | |
244 | * | |
245 | */ | |
246 | static void init() | |
247 | { | |
248 | ||
249 | g_info("Init diskPerformance.c"); | |
250 | ||
251 | LTT_FACILITY_BLOCK = g_quark_from_string("block"); | |
252 | LTT_EVENT_BLOCK_READ = g_quark_from_string("read"); | |
253 | LTT_EVENT_BLOCK_WRITE = g_quark_from_string("write"); | |
254 | ||
255 | lttvwindow_register_constructor("diskperformance", | |
256 | "/", | |
257 | "Insert Disk Performance", | |
258 | hDiskPerformanceInsert_xpm, | |
259 | "Insert Disk Performance", | |
260 | disk_performance); | |
261 | } | |
a4f37ccd | 262 | |
4ea3dbbf | 263 | /** |
264 | * Constructor hook | |
265 | * | |
266 | */ | |
e433e6d6 | 267 | GtkWidget *disk_performance(LttvPlugin *plugin) |
4ea3dbbf | 268 | { |
e433e6d6 | 269 | LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin); |
270 | DiskPerformanceData* disk_data = disk_performance_data(ptab); | |
271 | if(disk_data) | |
a4f37ccd | 272 | return disk_data->hbox_v; |
e433e6d6 | 273 | else |
a4f37ccd | 274 | return NULL; |
a4f37ccd | 275 | } |
276 | ||
4ea3dbbf | 277 | /** |
278 | * This function initializes the Event Viewer functionnality through the | |
279 | * GTK API. | |
280 | */ | |
e433e6d6 | 281 | DiskPerformanceData *disk_performance_data(LttvPluginTab *ptab) |
4ea3dbbf | 282 | { |
a4f37ccd | 283 | LttTime end; |
284 | GtkTreeViewColumn *column; | |
285 | GtkCellRenderer *renderer; | |
286 | DiskPerformanceData* disk_data = g_new(DiskPerformanceData,1) ; | |
287 | ||
288 | g_info("enter disk_performance_data \n"); | |
e433e6d6 | 289 | Tab *tab = ptab->tab; |
a4f37ccd | 290 | disk_data->tab = tab; |
e433e6d6 | 291 | disk_data->ptab = ptab; |
a4f37ccd | 292 | disk_data->time_window = lttvwindow_get_time_window(tab); |
293 | ||
294 | disk_data->disk_array = g_array_new(FALSE, FALSE, sizeof(lttv_total_block )); | |
295 | ||
296 | lttvwindow_register_time_window_notify(tab, | |
297 | disk_update_time_window, | |
298 | disk_data); | |
299 | ||
300 | disk_data->scroll_win = gtk_scrolled_window_new (NULL, NULL); | |
301 | gtk_widget_show (disk_data->scroll_win); | |
302 | gtk_scrolled_window_set_policy( | |
303 | GTK_SCROLLED_WINDOW(disk_data->scroll_win), | |
4ea3dbbf | 304 | GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); |
305 | ||
a4f37ccd | 306 | /* Create a model for storing the data list */ |
307 | disk_data->store_m = gtk_list_store_new ( | |
308 | N_COLUMNS, /* Total number of columns */ | |
4ea3dbbf | 309 | G_TYPE_STRING, /* Diskname */ |
a4f37ccd | 310 | G_TYPE_INT64, /* Bytes read */ |
4ea3dbbf | 311 | G_TYPE_INT64, /* Bytes read/sec */ |
a4f37ccd | 312 | G_TYPE_INT, |
4ea3dbbf | 313 | G_TYPE_INT64, /* bytes written */ |
314 | G_TYPE_INT64, /* bytes written/sec */ | |
a4f37ccd | 315 | G_TYPE_INT |
316 | ); | |
317 | ||
318 | disk_data->tree_v = gtk_tree_view_new_with_model (GTK_TREE_MODEL (disk_data->store_m)); | |
4ea3dbbf | 319 | |
a4f37ccd | 320 | g_object_unref (G_OBJECT (disk_data->store_m)); |
321 | ||
322 | renderer = gtk_cell_renderer_text_new (); | |
4ea3dbbf | 323 | |
a4f37ccd | 324 | column = gtk_tree_view_column_new_with_attributes ("DiskName", |
325 | renderer, | |
326 | "text", DISKNAME_COLUMN, | |
327 | NULL); | |
328 | gtk_tree_view_column_set_alignment (column, 0.0); | |
329 | gtk_tree_view_column_set_fixed_width (column, 45); | |
330 | gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column); | |
331 | ||
332 | renderer = gtk_cell_renderer_text_new (); | |
333 | column = gtk_tree_view_column_new_with_attributes ("BytesRead", | |
334 | renderer, | |
335 | "text", BYTES_RD_COLUMN, | |
336 | NULL); | |
337 | gtk_tree_view_column_set_alignment (column, 0.0); | |
338 | gtk_tree_view_column_set_fixed_width (column, 220); | |
339 | gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column); | |
340 | ||
341 | renderer = gtk_cell_renderer_text_new (); | |
342 | column = gtk_tree_view_column_new_with_attributes ("BytesRead/sec", | |
343 | renderer, | |
344 | "text", BYTES_RD_SEC_COLUMN, | |
345 | NULL); | |
346 | gtk_tree_view_column_set_alignment (column, 1.0); | |
347 | gtk_tree_view_column_set_fixed_width (column, 220); | |
348 | gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column); | |
349 | ||
350 | renderer = gtk_cell_renderer_text_new (); | |
351 | column = gtk_tree_view_column_new_with_attributes ("NumReadOperations", | |
352 | renderer, | |
353 | "text",NUM_RD_COLUMN, | |
354 | NULL); | |
355 | gtk_tree_view_column_set_alignment (column, 1.0); | |
356 | gtk_tree_view_column_set_fixed_width (column, 220); | |
357 | gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column); | |
358 | ||
359 | renderer = gtk_cell_renderer_text_new (); | |
360 | column = gtk_tree_view_column_new_with_attributes ("BytesWritten", | |
361 | renderer, | |
362 | "text", BYTES_WR_COLUMN, | |
363 | NULL); | |
364 | gtk_tree_view_column_set_alignment (column, 0.0); | |
365 | gtk_tree_view_column_set_fixed_width (column, 145); | |
366 | gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column); | |
367 | ||
368 | renderer = gtk_cell_renderer_text_new (); | |
369 | column = gtk_tree_view_column_new_with_attributes ("BytesWritten/sec", | |
370 | renderer, | |
371 | "text", BYTES_WR_SEC_COLUMN, | |
372 | NULL); | |
373 | gtk_tree_view_column_set_alignment (column, 1.0); | |
374 | gtk_tree_view_column_set_fixed_width (column, 220); | |
375 | gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column); | |
376 | ||
377 | renderer = gtk_cell_renderer_text_new (); | |
378 | column = gtk_tree_view_column_new_with_attributes ("NumWriteOperations", | |
379 | renderer, | |
380 | "text",NUM_WR_COLUMN, | |
381 | NULL); | |
382 | gtk_tree_view_column_set_alignment (column, 0.0); | |
383 | gtk_tree_view_column_set_fixed_width (column, 145); | |
384 | gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column); | |
385 | ||
386 | disk_data->select_c = gtk_tree_view_get_selection (GTK_TREE_VIEW (disk_data->tree_v)); | |
387 | gtk_tree_selection_set_mode (disk_data->select_c, GTK_SELECTION_SINGLE); | |
4ea3dbbf | 388 | |
a4f37ccd | 389 | gtk_container_add (GTK_CONTAINER (disk_data->scroll_win), disk_data->tree_v); |
390 | ||
391 | disk_data->hbox_v = gtk_hbox_new(0, 0); | |
392 | gtk_box_pack_start(GTK_BOX(disk_data->hbox_v), disk_data->scroll_win, TRUE, TRUE, 0); | |
393 | ||
394 | gtk_widget_show(disk_data->hbox_v); | |
395 | gtk_widget_show(disk_data->tree_v); | |
396 | ||
397 | ||
398 | g_disk_data_list = g_slist_append(g_disk_data_list, disk_data); | |
399 | g_object_set_data_full(G_OBJECT(disk_data->hbox_v), | |
400 | "disk_data", | |
401 | disk_data, | |
402 | (GDestroyNotify)gui_disperformance_free); | |
403 | ||
404 | request_event(disk_data); | |
405 | return disk_data; | |
406 | } | |
a4f37ccd | 407 | |
4ea3dbbf | 408 | /** |
409 | * | |
410 | * For each trace in the traceset, this function: | |
411 | * - calls lttv_trace_find_hook() & registers a hook function to event_by_id_hooks | |
412 | * - registers a callback function to each hook | |
413 | * - calls lttvwindow_events_request() to request data in a specific | |
414 | * time interval to the main window | |
415 | * | |
416 | */ | |
417 | static void request_event(DiskPerformanceData *disk_performance) | |
418 | { | |
419 | guint i, k, l, nb_trace; | |
a4f37ccd | 420 | |
4ea3dbbf | 421 | GArray *hooks; |
a4f37ccd | 422 | |
4ea3dbbf | 423 | guint ret; |
424 | ||
425 | LttvTraceHook *hook; | |
426 | ||
427 | LttvTraceState *ts; | |
a4f37ccd | 428 | |
4ea3dbbf | 429 | LttvTraceHookByFacility *thf; |
430 | ||
431 | LttvTracesetContext *tsc = lttvwindow_get_traceset_context(disk_performance->tab); | |
432 | /* Get the traceset */ | |
433 | LttvTraceset *traceset = tsc->ts; | |
434 | ||
435 | nb_trace = lttv_traceset_number(traceset); | |
a4f37ccd | 436 | |
8402f27d | 437 | //for(i = 0; i<MIN(TRACE_NUMBER+1, nb_trace);i++) { |
438 | for(i = 0 ; i < nb_trace ; i++) { | |
4ea3dbbf | 439 | EventsRequest *events_request = g_new(EventsRequest, 1); |
440 | ||
441 | hooks = g_array_new(FALSE, FALSE, sizeof(LttvTraceHook)); | |
442 | ||
443 | hooks = g_array_set_size(hooks, 2); | |
444 | ||
445 | /* Get a trace state */ | |
446 | ts = (LttvTraceState *)tsc->traces[i]; | |
447 | ||
750eb11a | 448 | disk_performance->event_by_id_hooks = lttv_hooks_by_id_channel_new(); |
4ea3dbbf | 449 | /* Register event_by_id_hooks with a callback function */ |
450 | ret = lttv_trace_find_hook(ts->parent.t, | |
750eb11a | 451 | LTT_CHANNEL_BLOCK, LTT_EVENT_BLOCK_READ, |
4ea3dbbf | 452 | 0, 0, 0, |
453 | block_read_callback, | |
454 | disk_performance, | |
455 | &g_array_index(hooks, LttvTraceHook, 0)); | |
456 | ||
457 | ret = lttv_trace_find_hook(ts->parent.t, | |
750eb11a | 458 | LTT_CHANNEL_BLOCK, LTT_EVENT_BLOCK_WRITE, |
4ea3dbbf | 459 | 0, 0, 0, |
460 | block_write_callback, | |
461 | disk_performance, | |
462 | &g_array_index(hooks, LttvTraceHook, 1)); | |
463 | ||
464 | g_assert(!ret); | |
465 | ||
466 | /*iterate through the facility list*/ | |
467 | for(k = 0 ; k < hooks->len; k++) | |
468 | { | |
469 | hook = &g_array_index(hooks, LttvTraceHook, k); | |
470 | for(l=0; l<hook->fac_list->len; l++) | |
471 | { | |
472 | thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l); | |
750eb11a | 473 | lttv_hooks_add(lttv_hooks_by_id_channel_find( |
474 | disk_performance->event_by_id_hooks, | |
475 | thf->channel, thf->id), | |
4ea3dbbf | 476 | thf->h, |
477 | disk_performance, | |
478 | LTTV_PRIO_DEFAULT); | |
479 | ||
480 | } | |
481 | } | |
482 | ||
483 | disk_performance->hooks_trace_after = lttv_hooks_new(); | |
484 | /* Registers a hook function */ | |
485 | lttv_hooks_add(disk_performance->hooks_trace_after, disk_show, disk_performance, LTTV_PRIO_DEFAULT); | |
486 | ||
487 | disk_performance->hooks_trace_before = lttv_hooks_new(); | |
488 | /* Registers a hook function */ | |
489 | lttv_hooks_add(disk_performance->hooks_trace_before, trace_header, disk_performance, LTTV_PRIO_DEFAULT); | |
490 | ||
491 | /* Initalize the EventsRequest structure */ | |
492 | events_request->owner = disk_performance; | |
493 | events_request->viewer_data = disk_performance; | |
494 | events_request->servicing = FALSE; | |
495 | events_request->start_time = disk_performance->time_window.start_time; | |
496 | events_request->start_position = NULL; | |
497 | events_request->stop_flag = FALSE; | |
498 | events_request->end_time = disk_performance->time_window.end_time; | |
499 | events_request->num_events = G_MAXUINT; | |
500 | events_request->end_position = NULL; | |
501 | events_request->trace = i; | |
502 | events_request->hooks = hooks; | |
503 | events_request->before_chunk_traceset = NULL; | |
504 | events_request->before_chunk_trace = disk_performance->hooks_trace_before; | |
505 | events_request->before_chunk_tracefile= NULL; | |
506 | events_request->event = NULL; | |
750eb11a | 507 | events_request->event_by_id_channel = disk_performance->event_by_id_hooks; |
4ea3dbbf | 508 | events_request->after_chunk_tracefile = NULL; |
509 | events_request->after_chunk_trace = NULL; | |
510 | events_request->after_chunk_traceset = NULL; | |
511 | events_request->before_request = NULL; | |
512 | events_request->after_request = disk_performance->hooks_trace_after; | |
513 | ||
514 | lttvwindow_events_request(disk_performance->tab, events_request); | |
a4f37ccd | 515 | } |
a4f37ccd | 516 | |
a4f37ccd | 517 | } |
518 | ||
4ea3dbbf | 519 | /** |
520 | * This function is called whenever a read event occurs. | |
521 | * | |
522 | */ | |
523 | static gboolean block_read_callback(void *hook_data, void *call_data) | |
524 | { | |
525 | LttEvent *e; | |
526 | LttTime event_time; | |
527 | unsigned cpu_id; | |
528 | lttv_block block_read; | |
529 | char *diskname; | |
530 | ||
531 | LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; | |
532 | LttvTracefileState *tfs = (LttvTracefileState *)call_data; | |
533 | DiskPerformanceData *disk_performance = (DiskPerformanceData *)hook_data; | |
534 | GArray *disk_array = disk_performance->disk_array; | |
535 | e = ltt_tracefile_get_event(tfc->tf); | |
536 | event_time = ltt_event_time(e); | |
537 | cpu_id = ltt_event_cpu_id(e); | |
4ea3dbbf | 538 | |
e62ca91e | 539 | get_event_detail(e, &block_read); |
540 | diskname = major_minor_to_diskname(&block_read); | |
541 | sum_data(diskname, block_read.size,LTTV_READ_OPERATION, disk_array); | |
542 | ||
543 | return FALSE; | |
a4f37ccd | 544 | } |
545 | ||
4ea3dbbf | 546 | /** |
547 | * This function is called whenever a write event occurs. | |
548 | * | |
549 | */ | |
550 | static gboolean block_write_callback(void *hook_data, void *call_data) | |
551 | { | |
552 | LttEvent *e; | |
553 | LttTime event_time; | |
554 | unsigned cpu_id; | |
555 | lttv_block block_write; | |
556 | char *diskname; | |
557 | LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; | |
558 | LttvTracefileState *tfs = (LttvTracefileState *)call_data; | |
559 | DiskPerformanceData *disk_performance = (DiskPerformanceData *)hook_data; | |
560 | GArray *disk_array = disk_performance->disk_array; | |
561 | e = ltt_tracefile_get_event(tfc->tf); | |
562 | event_time = ltt_event_time(e); | |
563 | cpu_id = ltt_event_cpu_id(e); | |
e62ca91e | 564 | |
565 | get_event_detail(e, &block_write); | |
566 | diskname = major_minor_to_diskname(&block_write); | |
567 | sum_data(diskname, block_write.size,LTTV_WRITE_OPERATION, disk_array); | |
568 | ||
4ea3dbbf | 569 | return FALSE; |
a4f37ccd | 570 | } |
a4f37ccd | 571 | |
4ea3dbbf | 572 | /** |
573 | * This function extracts the major, minor and size | |
574 | * | |
575 | */ | |
576 | static void get_event_detail(LttEvent *e, lttv_block* disk_data) | |
577 | { | |
578 | guint i, num_fields; | |
579 | LttEventType *event_type; | |
580 | LttField *element; | |
581 | LttField *field; | |
582 | event_type = ltt_event_eventtype(e); | |
583 | num_fields = ltt_eventtype_num_fields(event_type); | |
584 | ||
585 | for(i = 0 ; i < num_fields ; i++) | |
a4f37ccd | 586 | { |
4ea3dbbf | 587 | element = ltt_eventtype_field(event_type,i); |
e62ca91e | 588 | switch(i) |
589 | { | |
590 | case 0: | |
591 | disk_data->major_number = ltt_event_get_long_unsigned(e, element); | |
592 | break; | |
593 | ||
594 | case 1: | |
595 | disk_data->minor_number = ltt_event_get_long_unsigned(e, element); | |
596 | break; | |
597 | case 2: | |
598 | disk_data->size = ltt_event_get_long_unsigned(e, element); | |
599 | break; | |
600 | } | |
601 | ||
a4f37ccd | 602 | } |
4ea3dbbf | 603 | |
a4f37ccd | 604 | } |
a4f37ccd | 605 | |
e62ca91e | 606 | |
a4f37ccd | 607 | |
4ea3dbbf | 608 | /** |
609 | * This function calculates: the number of operations, the total bytes read or written, | |
610 | * the average number of bytes read or written by sec. | |
611 | */ | |
612 | static void sum_data(char* diskname, guint size, enum operation_t operation, GArray *disk_array) | |
613 | { | |
a4f37ccd | 614 | |
615 | lttv_total_block data; | |
616 | lttv_total_block *element; | |
617 | guint i; | |
618 | gboolean notFound = FALSE; | |
619 | ||
620 | memset ((void*)&data, 0,sizeof(lttv_total_block)); | |
621 | ||
622 | if(disk_array->len == NO_ITEMS){ | |
623 | strcpy(data.diskname, diskname); | |
624 | if(operation == LTTV_READ_OPERATION){ | |
625 | data.total_bytes_read = size; | |
626 | data.num_read_operations++; | |
627 | } | |
628 | else{ | |
629 | data.total_bytes_written = size; | |
630 | data.num_write_operations ++; | |
631 | } | |
632 | g_array_append_val (disk_array, data); | |
633 | } | |
634 | else{ | |
635 | for(i = 0; i < disk_array->len; i++){ | |
636 | element = &g_array_index(disk_array,lttv_total_block,i); | |
637 | if(strcmp(element->diskname,diskname) == 0){ | |
638 | if(operation == LTTV_READ_OPERATION){ | |
639 | element->num_read_operations++; | |
640 | element->total_bytes_read += size; | |
641 | } | |
642 | else{ | |
643 | element->num_write_operations ++; | |
644 | element->total_bytes_written += size; | |
645 | } | |
646 | notFound = TRUE; | |
647 | } | |
648 | } | |
649 | if(!notFound){ | |
650 | strcpy(data.diskname, diskname); | |
651 | if(operation == LTTV_READ_OPERATION){ | |
652 | data.total_bytes_read = size; | |
653 | data.num_read_operations ++; | |
654 | } | |
655 | else{ | |
656 | data.total_bytes_written = size; | |
657 | data.num_write_operations ++; | |
658 | } | |
659 | g_array_append_val (disk_array, data); | |
660 | } | |
661 | } | |
662 | } | |
663 | ||
a4f37ccd | 664 | |
a4f37ccd | 665 | static void destroy() |
666 | { | |
667 | g_info("Destroy diskPerformance"); | |
668 | g_slist_foreach(g_disk_data_list, disk_destroy_walk, NULL ); | |
669 | g_slist_free(g_disk_data_list); | |
670 | ||
671 | lttvwindow_unregister_constructor(disk_performance); | |
672 | ||
673 | } | |
674 | ||
e62ca91e | 675 | /** |
676 | * This function convert the major and minor number to the corresponding disk. | |
677 | * Data taken from Documentation/devices.txt of the kernel tree. | |
678 | */ | |
679 | static char * major_minor_to_diskname( lttv_block* disk_data) | |
680 | { | |
681 | switch(disk_data->major_number) | |
682 | { | |
683 | /* IDE Disks */ | |
684 | case 3: /* First MFM, RLL and IDE hard disk/CD-ROM interface */ | |
685 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
686 | return "/dev/hda"; | |
687 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
688 | return "/dev/hdb"; | |
689 | break; | |
690 | ||
691 | case 22: /*Second IDE hard disk/CD-ROM interface */ | |
692 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
693 | return "/dev/hdc"; | |
694 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
695 | return "/dev/hdd"; | |
696 | break; | |
697 | ||
698 | case 33: /* Third IDE hard disk/CD-ROM interface */ | |
699 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
700 | return "/dev/hde"; | |
701 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
702 | return "/dev/hdf"; | |
703 | break; | |
704 | ||
705 | case 34: /* Fourth IDE hard disk/CD-ROM interface */ | |
706 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
707 | return "/dev/hdg"; | |
708 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
709 | return "/dev/hdh"; | |
710 | break; | |
711 | ||
712 | case 56: /* Fifth IDE hard disk/CD-ROM interface */ | |
713 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
714 | return "/dev/hdi"; | |
715 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
716 | return "/dev/hdj"; | |
717 | break; | |
718 | ||
719 | case 57: /* Sixth IDE hard disk/CD-ROM interface */ | |
720 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
721 | return "/dev/hdk"; | |
722 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
723 | return "/dev/hdl"; | |
724 | break; | |
725 | ||
726 | case 88: /* Seventh IDE hard disk/CD-ROM interface */ | |
727 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
728 | return "/dev/hdm"; | |
729 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
730 | return "/dev/hdn"; | |
731 | break; | |
732 | ||
733 | case 89: /* Eighth IDE hard disk/CD-ROM interface */ | |
734 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
735 | return "/dev/hdo"; | |
736 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
737 | return "/dev/hdp"; | |
738 | break; | |
739 | ||
740 | case 90: /* Ninth IDE hard disk/CD-ROM interface */ | |
741 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
742 | return "/dev/hdq"; | |
743 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
744 | return "/dev/hdr"; | |
745 | break; | |
746 | ||
747 | case 91: /* Tenth IDE hard disk/CD-ROM interface */ | |
748 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 64)) | |
749 | return "/dev/hds"; | |
750 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 128)) | |
751 | return "/dev/hdt"; | |
752 | break; | |
753 | ||
754 | /* SCSI Disks */ | |
755 | case 8: /* SCSI disk devices */ | |
756 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
757 | return "/dev/sda"; // First SCSI disk whole disk | |
758 | ||
759 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
760 | return "/dev/sdb";// Second SCSI disk whole disk | |
761 | ||
762 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
763 | return "/dev/sdc";// Third SCSI disk whole disk | |
764 | ||
765 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
766 | return "/dev/sdd";// Fourth SCSI disk whole disk | |
767 | ||
768 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
769 | return "/dev/sde";// Fifth SCSI disk whole disk | |
770 | ||
771 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
772 | return "/dev/sdf";// Sixth SCSI disk whole disk | |
773 | ||
774 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
775 | return "/dev/sdg";// seventh SCSI disk whole disk | |
776 | ||
777 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
778 | return "/dev/sdh";// eighth SCSI disk whole disk | |
779 | ||
780 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
781 | return "/dev/sdi";// 9th SCSI disk whole disk | |
782 | ||
783 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
784 | return "/dev/sdj";// 10th SCSI disk whole disk | |
785 | ||
786 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
787 | return "/dev/sdk";// 11th SCSI disk whole disk | |
788 | ||
789 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
790 | return "/dev/sdl";// 12th SCSI disk whole disk | |
791 | ||
792 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
793 | return "/dev/sdm";// 13th SCSI disk whole disk | |
794 | ||
795 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) | |
796 | return "/dev/sdn";// 14th SCSI disk whole disk | |
797 | ||
798 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
799 | return "/dev/sdo";// 15th SCSI disk whole disk | |
800 | ||
801 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
802 | return "/dev/sdp";// 16th SCSI disk whole disk | |
803 | break; | |
804 | ||
805 | case 65: /* SCSI disk devices */ | |
806 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
807 | return "/dev/sdq"; | |
808 | ||
809 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
810 | return "/dev/sdr"; | |
811 | ||
812 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
813 | return "/dev/sds"; | |
814 | ||
815 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
816 | return "/dev/sdt"; | |
817 | ||
818 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
819 | return "/dev/sdu"; | |
820 | ||
821 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
822 | return "/dev/sdv"; | |
823 | ||
824 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
825 | return "/dev/sdw"; | |
826 | ||
827 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
828 | return "/dev/sdy"; | |
829 | ||
830 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
831 | return "/dev/sdx"; | |
832 | ||
833 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
834 | return "/dev/sdz"; | |
835 | ||
836 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
837 | return "/dev/sdaa"; | |
838 | ||
839 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
840 | return "/dev/sdab"; | |
841 | ||
842 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
843 | return "/dev/sdac"; | |
844 | ||
845 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) | |
846 | return "/dev/sdad"; | |
847 | ||
848 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
849 | return "/dev/sdae"; | |
850 | ||
851 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
852 | return "/dev/sdaf"; | |
853 | break; | |
854 | ||
855 | case 66: /* SCSI disk devices */ | |
856 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
857 | return "/dev/sdag"; | |
858 | ||
859 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
860 | return "/dev/sdah"; | |
861 | ||
862 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
863 | return "/dev/sdai"; | |
864 | ||
865 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
866 | return "/dev/sdaj"; | |
867 | ||
868 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
869 | return "/dev/sdak"; | |
870 | ||
871 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
872 | return "/dev/sdal"; | |
873 | ||
874 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
875 | return "/dev/sdam"; | |
876 | ||
877 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
878 | return "/dev/sdan"; | |
879 | ||
880 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
881 | return "/dev/sdao"; | |
882 | ||
883 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
884 | return "/dev/sdap"; | |
885 | ||
886 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
887 | return "/dev/sdaq"; | |
888 | ||
889 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
890 | return "/dev/sdar"; | |
891 | ||
892 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
893 | return "/dev/sdas"; | |
894 | ||
895 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) | |
896 | return "/dev/sdat"; | |
897 | ||
898 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
899 | return "/dev/sdau"; | |
900 | ||
901 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
902 | return "/dev/sdav"; | |
903 | break; | |
904 | ||
905 | ||
906 | case 67: /* SCSI disk devices */ | |
907 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
908 | return "/dev/sdaw"; | |
909 | ||
910 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
911 | return "/dev/sdax"; | |
912 | ||
913 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
914 | return "/dev/sday"; | |
915 | ||
916 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
917 | return "/dev/sdaz"; | |
918 | ||
919 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
920 | return "/dev/sdba"; | |
921 | ||
922 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
923 | return "/dev/sdbb"; | |
924 | ||
925 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
926 | return "/dev/sdbc"; | |
927 | ||
928 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
929 | return "/dev/sdbd"; | |
930 | ||
931 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
932 | return "/dev/sdbe"; | |
933 | ||
934 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
935 | return "/dev/sdbf"; | |
936 | ||
937 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
938 | return "/dev/sdbg"; | |
939 | ||
940 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
941 | return "/dev/sdbh"; | |
942 | ||
943 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
944 | return "/dev/sdbi"; | |
945 | ||
946 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) | |
947 | return "/dev/sdbj"; | |
948 | ||
949 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
950 | return "/dev/sdbk"; | |
951 | ||
952 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
953 | return "/dev/sdbl"; | |
954 | break; | |
955 | ||
956 | case 68 : /* SCSI disk devices */ | |
957 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
958 | return "/dev/sdbm"; | |
959 | ||
960 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
961 | return "/dev/sdbm"; | |
962 | ||
963 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
964 | return "/dev/sdbo"; | |
965 | ||
966 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
967 | return "/dev/sdbp"; | |
968 | ||
969 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
970 | return "/dev/sdbq"; | |
971 | ||
972 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
973 | return "/dev/sdbr"; | |
974 | ||
975 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
976 | return "/dev/sdbs"; | |
977 | ||
978 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
979 | return "/dev/sdbt"; | |
980 | ||
981 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
982 | return "/dev/sdbu"; | |
983 | ||
984 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
985 | return "/dev/sdbv"; | |
986 | ||
987 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
988 | return "/dev/sdbw"; | |
989 | ||
990 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
991 | return "/dev/sdbx"; | |
992 | ||
993 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
994 | return "/dev/sdby"; | |
995 | ||
996 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) | |
997 | return "/dev/sdbz"; | |
998 | ||
999 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
1000 | return "/dev/sdca"; | |
1001 | ||
1002 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
1003 | return "/dev/sdcb"; | |
1004 | break; | |
1005 | case 69 : /* SCSI disk devices */ | |
1006 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
1007 | return "/dev/sdcc"; | |
1008 | ||
1009 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
1010 | return "/dev/sdcd"; | |
1011 | ||
1012 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
1013 | return "/dev/sdce"; | |
1014 | ||
1015 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
1016 | return "/dev/sdcf"; | |
1017 | ||
1018 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
1019 | return "/dev/sdcg"; | |
1020 | ||
1021 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
1022 | return "/dev/sdch"; | |
1023 | ||
1024 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
1025 | return "/dev/sdci"; | |
1026 | ||
1027 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
1028 | return "/dev/sdcj"; | |
1029 | ||
1030 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
1031 | return "/dev/sdck"; | |
1032 | ||
1033 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
1034 | return "/dev/sdcl"; | |
1035 | ||
1036 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
1037 | return "/dev/sdcm"; | |
1038 | ||
1039 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
1040 | return "/dev/sdcn"; | |
1041 | ||
1042 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
1043 | return "/dev/sdco"; | |
1044 | ||
1045 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) | |
1046 | return "/dev/sdcp"; | |
1047 | ||
1048 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
1049 | return "/dev/sdcq"; | |
1050 | ||
1051 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
1052 | return "/dev/sdcr"; | |
1053 | break; | |
1054 | ||
1055 | ||
1056 | case 70 : /* SCSI disk devices */ | |
1057 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
1058 | return "/dev/sdcs"; | |
1059 | ||
1060 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
1061 | return "/dev/sdct"; | |
1062 | ||
1063 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
1064 | return "/dev/sdcu"; | |
1065 | ||
1066 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
1067 | return "/dev/sdcv"; | |
1068 | ||
1069 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
1070 | return "/dev/sdcw"; | |
1071 | ||
1072 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
1073 | return "/dev/sdcx"; | |
1074 | ||
1075 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
1076 | return "/dev/sdcy"; | |
1077 | ||
1078 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
1079 | return "/dev/sdcz"; | |
1080 | ||
1081 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
1082 | return "/dev/sdda"; | |
1083 | ||
1084 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
1085 | return "/dev/sddb"; | |
1086 | ||
1087 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
1088 | return "/dev/sddc"; | |
1089 | ||
1090 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
1091 | return "/dev/sddd"; | |
1092 | ||
1093 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
1094 | return "/dev/sdde"; | |
a4f37ccd | 1095 | |
e62ca91e | 1096 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) |
1097 | return "/dev/sddf"; | |
1098 | ||
1099 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
1100 | return "/dev/sddg"; | |
1101 | ||
1102 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
1103 | return "/dev/sddh"; | |
1104 | break; | |
1105 | ||
1106 | case 71: /* SCSI disk devices */ | |
1107 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
1108 | return "/dev/sddi"; | |
1109 | ||
1110 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
1111 | return "/dev/sddj"; | |
1112 | ||
1113 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
1114 | return "/dev/sddk"; | |
1115 | ||
1116 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
1117 | return "/dev/sddl"; | |
1118 | ||
1119 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
1120 | return "/dev/sddm"; | |
1121 | ||
1122 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
1123 | return "/dev/sddn"; | |
1124 | ||
1125 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
1126 | return "/dev/sddo"; | |
1127 | ||
1128 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
1129 | return "/dev/sddp"; | |
1130 | ||
1131 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
1132 | return "/dev/sddq"; | |
1133 | ||
1134 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
1135 | return "/dev/sddr"; | |
1136 | ||
1137 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
1138 | return "/dev/sdds"; | |
1139 | ||
1140 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
1141 | return "/dev/sddt"; | |
1142 | ||
1143 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
1144 | return "/dev/sddu"; | |
1145 | ||
1146 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) | |
1147 | return "/dev/sddv"; | |
1148 | ||
1149 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
1150 | return "/dev/sddw"; | |
1151 | ||
1152 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
1153 | return "/dev/sddx"; | |
1154 | break; | |
1155 | ||
1156 | case 128: /* SCSI disk devices */ | |
1157 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
1158 | return "/dev/sddy"; | |
1159 | ||
1160 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
1161 | return "/dev/sddz"; | |
1162 | ||
1163 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
1164 | return "/dev/sdea"; | |
1165 | ||
1166 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
1167 | return "/dev/sdeb"; | |
1168 | ||
1169 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
1170 | return "/dev/sdec"; | |
1171 | ||
1172 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
1173 | return "/dev/sded"; | |
1174 | ||
1175 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
1176 | return "/dev/sdee"; | |
1177 | ||
1178 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
1179 | return "/dev/sdef"; | |
1180 | ||
1181 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
1182 | return "/dev/sdeg"; | |
1183 | ||
1184 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
1185 | return "/dev/sdeh"; | |
1186 | ||
1187 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
1188 | return "/dev/sdei"; | |
1189 | ||
1190 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
1191 | return "/dev/sdej"; | |
1192 | ||
1193 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
1194 | return "/dev/sdek"; | |
1195 | ||
1196 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) | |
1197 | return "/dev/sdel"; | |
1198 | ||
1199 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
1200 | return "/dev/sdem"; | |
1201 | ||
1202 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
1203 | return "/dev/sden"; | |
1204 | break; | |
1205 | ||
1206 | case 129: /* SCSI disk devices */ | |
1207 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 16)) | |
1208 | return "/dev/sdeo"; | |
1209 | ||
1210 | if((disk_data->minor_number >= 16) && (disk_data->minor_number < 32)) | |
1211 | return "/dev/sdep"; | |
1212 | ||
1213 | if((disk_data->minor_number >= 32) && (disk_data->minor_number < 48)) | |
1214 | return "/dev/sdeq"; | |
1215 | ||
1216 | if((disk_data->minor_number >= 48) && (disk_data->minor_number < 64)) | |
1217 | return "/dev/sder"; | |
1218 | ||
1219 | if((disk_data->minor_number >= 64) && (disk_data->minor_number < 80)) | |
1220 | return "/dev/sdes"; | |
1221 | ||
1222 | if((disk_data->minor_number >= 80) && (disk_data->minor_number < 96)) | |
1223 | return "/dev/sdet"; | |
1224 | ||
1225 | if((disk_data->minor_number >= 96) && (disk_data->minor_number < 112)) | |
1226 | return "/dev/sdeu"; | |
1227 | ||
1228 | if((disk_data->minor_number >= 112) && (disk_data->minor_number < 128)) | |
1229 | return "/dev/sdev"; | |
1230 | ||
1231 | if((disk_data->minor_number >= 128) && (disk_data->minor_number < 144)) | |
1232 | return "/dev/sdew"; | |
1233 | ||
1234 | if((disk_data->minor_number >= 144) && (disk_data->minor_number < 160)) | |
1235 | return "/dev/sdez"; | |
1236 | ||
1237 | if((disk_data->minor_number >= 160) && (disk_data->minor_number < 176)) | |
1238 | return "/dev/sdey"; | |
1239 | ||
1240 | if((disk_data->minor_number >= 176) && (disk_data->minor_number < 192)) | |
1241 | return "/dev/sdez"; | |
1242 | ||
1243 | if((disk_data->minor_number >= 192) && (disk_data->minor_number < 208)) | |
1244 | return "/dev/sdfa"; | |
1245 | ||
1246 | if((disk_data->minor_number >= 208) && (disk_data->minor_number < 224)) | |
1247 | return "/dev/sdfb"; | |
1248 | ||
1249 | if((disk_data->minor_number >= 224) && (disk_data->minor_number < 240)) | |
1250 | return "/dev/sdfc"; | |
1251 | ||
1252 | if((disk_data->minor_number >= 240) && (disk_data->minor_number < 256)) | |
1253 | return "/dev/sdfd"; | |
1254 | break; | |
1255 | /*USB block devices*/ | |
1256 | case 180: | |
1257 | if( (disk_data->minor_number >= 0) && (disk_data->minor_number < 8)) | |
1258 | return "/dev/uba"; | |
1259 | if( (disk_data->minor_number >= 8) && (disk_data->minor_number < 16)) | |
1260 | return "/dev/ubb"; | |
1261 | if( (disk_data->minor_number >= 16) && (disk_data->minor_number < 24)) | |
1262 | return "/dev/ubc"; | |
1263 | break; | |
1264 | ||
1265 | } | |
1266 | ||
1267 | ||
1268 | } | |
a4f37ccd | 1269 | LTTV_MODULE("diskperformance", "disk info view", \ |
1270 | "Produce disk I/O performance", \ | |
1271 | init, destroy, "lttvwindow") | |
1272 |