git.lttng.org Git - lttv.git/blob

   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
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19
  20 #include <math.h>
  21
  22 #include <glib.h>
  23 #include <gtk/gtk.h>
  24 #include <gdk/gdk.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <ltt/ltt.h>
  29 #include <ltt/event.h>
  30 #include <ltt/type.h>
  31 #include <ltt/trace.h>
  32 #include <ltt/facility.h>
  33 #include <lttv/module.h>
  34 #include <lttv/hook.h>
  35 #include <lttv/tracecontext.h>
  36 #include <lttv/state.h>
  37 #include <lttv/filter.h>
  38 #include <lttvwindow/lttvwindow.h>
  39 #include <lttvwindow/lttv_plugin_tab.h>
  40 #include <ltt/time.h>
  41
  42 #include "hDiskPerformanceInsert.xpm"
  43
  44
  45 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
  46 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
  47 // fixed #define TRACE_NUMBER 0
  48 #define NO_ITEMS 0
  49
  50 enum{
  51   DISKNAME_COLUMN,
  52   BYTES_RD_COLUMN,
  53   BYTES_RD_SEC_COLUMN,
  54   NUM_RD_COLUMN,
  55   BYTES_WR_COLUMN,
  56   BYTES_WR_SEC_COLUMN,
  57   NUM_WR_COLUMN,
  58   N_COLUMNS
  59 };
  60
  61 enum operation_t {
  62      LTTV_READ_OPERATION = 1,
  63      LTTV_WRITE_OPERATION
  64 };
  65
  66 typedef struct _DiskPerformanceData {
  67
  68   Tab        * tab;
  69
  70   LttvPluginTab *ptab;
  71
  72   LttvHooks  * hooks_trace_after;
  73
  74   LttvHooks  * hooks_trace_before;
  75   /* time window */
  76   TimeWindow   time_window;
  77
  78   GtkWidget * scroll_win;
  79
  80   /* Model containing list data */
  81   GtkListStore *store_m;
  82
  83   GtkWidget *hbox_v;
  84
  85   /* Widget to display the data in a columned list */
  86   GtkWidget *tree_v;
  87
  88   /* Selection handler */
  89   GtkTreeSelection *select_c;
  90
  91   GArray *disk_array;
  92
  93   LttvHooksById * event_by_id_hooks;
  94
  95 } DiskPerformanceData;
  96
  97
  98 typedef struct _lttv_block {
  99         guint major_number;
 100         guint minor_number;
 101         guint size;
 102 } lttv_block;
 103
 104 typedef struct _lttv_total_block {
 105         char diskname[10];
 106         guint64 total_bytes_read;
 107         guint num_read_operations;
 108         guint64 total_bytes_written;
 109         guint num_write_operations;
 110
 111 } lttv_total_block;
 112
 113 GSList *g_disk_data_list = NULL ;
 114
 115
 116
 117 /* facility */
 118 GQuark LTT_FACILITY_BLOCK;
 119
 120 /* events */
 121 GQuark LTT_EVENT_BLOCK_READ;
 122 GQuark LTT_EVENT_BLOCK_WRITE;
 123
 124 static DiskPerformanceData *disk_performance_data(LttvPluginTab *ptab);
 125 static void disk_destroy_walk(gpointer data, gpointer user_data);
 126 static gboolean disk_show(void *hook_data, void *call_data);
 127 static gboolean trace_header(void *hook_data, void *call_data);
 128 static gboolean disk_update_time_window(void * hook_data, void * call_data);
 129 static void request_event(  DiskPerformanceData *disk_performance);
 130 void gui_disperformance_free(DiskPerformanceData *event_viewer_data);
 131 static void get_event_detail(LttEvent *e, lttv_block* disk_data);
 132 static char * major_minor_to_diskname( lttv_block* disk_data);
 133 static void sum_data(char* diskname, guint size, enum operation_t opt, GArray *disk_array);
 134 static GtkWidget *disk_performance(LttvPlugin *plugin);
 135
 136 static gboolean block_read_callback(void *hook_data, void *call_data);
 137
 138 static gboolean block_write_callback(void *hook_data, void *call_data);
 139
 140
 141 static gboolean disk_show(void *hook_data, void *call_data){
 142
 143   guint i;
 144   lttv_total_block element;
 145   GtkTreeIter    iter;
 146   LttTime time_interval;
 147   guint64 time_interval_64;
 148   guint64 temp_variable;
 149   guint64 bytes_read_per_sec, bytes_written_per_sec;
 150   g_info(" diskperformance: disk_show() \n");
 151   DiskPerformanceData *disk_performance = (DiskPerformanceData *)hook_data;
 152   GArray *disk_array = disk_performance->disk_array;
 153   time_interval =  ltt_time_sub(disk_performance->time_window.end_time, disk_performance->time_window.start_time);
 154
 155   time_interval_64  = time_interval.tv_sec;
 156   time_interval_64 *= NANOSECONDS_PER_SECOND;
 157   time_interval_64 += time_interval.tv_nsec;
 158   gtk_list_store_clear(disk_performance->store_m);
 159   for(i = 0; i < disk_array->len; i++){
 160
 161     element = g_array_index(disk_array,lttv_total_block,i);
 162     temp_variable =  element.total_bytes_read * NANOSECONDS_PER_SECOND;
 163     bytes_read_per_sec = (guint64) temp_variable / time_interval_64;
 164
 165     temp_variable =  element.total_bytes_written * NANOSECONDS_PER_SECOND;
 166     bytes_written_per_sec  = (guint64) temp_variable / time_interval_64;
 167
 168     gtk_list_store_append (disk_performance->store_m, &iter);
 169     gtk_list_store_set (disk_performance->store_m, &iter,
 170       DISKNAME_COLUMN, element.diskname,
 171       BYTES_RD_COLUMN, element.total_bytes_read,
 172       BYTES_RD_SEC_COLUMN,bytes_read_per_sec,
 173       NUM_RD_COLUMN, element.num_read_operations,
 174       BYTES_WR_COLUMN, element.total_bytes_written,
 175       BYTES_WR_SEC_COLUMN, bytes_written_per_sec,
 176       NUM_WR_COLUMN, element.num_write_operations,
 177       -1);
 178
 179   }
 180   if(disk_performance->disk_array->len)
 181     g_array_remove_range (disk_performance->disk_array,0,disk_performance->disk_array->len);
 182   return FALSE;
 183 }
 184
 185 static gboolean trace_header(void *hook_data, void *call_data){
 186   return FALSE;
 187 }
 188
 189
 190 static gboolean disk_update_time_window(void * hook_data, void * call_data){
 191
 192   DiskPerformanceData *disk_performance = (DiskPerformanceData *) hook_data;
 193   const TimeWindowNotifyData *time_window_nofify_data =  ((const TimeWindowNotifyData *)call_data);
 194   disk_performance->time_window = *time_window_nofify_data->new_time_window;
 195   Tab *tab = disk_performance->tab;
 196   lttvwindow_events_request_remove_all(tab, disk_performance);
 197   request_event( disk_performance);
 198
 199
 200     return FALSE;
 201 }
 202
 203 void gui_disperformance_free(DiskPerformanceData  *eventdata){
 204   Tab *tab = eventdata->tab;
 205   g_info("disperformance.c : gui_disperformance_free, %p", eventdata);
 206   g_info("%p, %p", eventdata, tab);
 207   if(tab != NULL)
 208   {
 209      g_array_free (eventdata->disk_array, TRUE);
 210
 211      lttvwindow_unregister_time_window_notify(tab,
 212         disk_update_time_window,
 213         eventdata);
 214
 215      lttvwindow_events_request_remove_all(eventdata->tab,
 216                                           eventdata);
 217      g_disk_data_list = g_slist_remove(g_disk_data_list, eventdata);
 218   }
 219   g_free(eventdata);
 220   g_info("disperformance.c : gui_disperformance_free end, %p", eventdata);
 221 }
 222
 223
 224
 225
 226
 227
 228 void disk_destructor_full(DiskPerformanceData *disk_data)
 229 {
 230
 231   if(GTK_IS_WIDGET(disk_data->hbox_v))
 232     gtk_widget_destroy(disk_data->hbox_v);
 233
 234 }
 235
 236 static void disk_destroy_walk(gpointer data, gpointer user_data)
 237 {
 238   g_info("Walk destroy GUI disk performance Viewer");
 239   disk_destructor_full((DiskPerformanceData*)data);
 240 }
 241 /**
 242  *  init function
 243  *
 244  *
 245  * This is the entry point of the viewer.
 246  *
 247  */
 248 static void init()
 249 {
 250
 251   g_info("Init diskPerformance.c");
 252
 253   LTT_FACILITY_BLOCK    = g_quark_from_string("block");
 254   LTT_EVENT_BLOCK_READ  =  g_quark_from_string("read");
 255   LTT_EVENT_BLOCK_WRITE = g_quark_from_string("write");
 256
 257   lttvwindow_register_constructor("diskperformance",
 258                                   "/",
 259                                   "Insert Disk Performance",
 260                                   hDiskPerformanceInsert_xpm,
 261                                   "Insert Disk Performance",
 262                                   disk_performance);
 263 }
 264
 265 /**
 266  *  Constructor hook
 267  *
 268  */
 269 GtkWidget *disk_performance(LttvPlugin *plugin)
 270 {
 271   LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
 272   DiskPerformanceData* disk_data = disk_performance_data(ptab);
 273   if(disk_data)
 274     return disk_data->hbox_v;
 275   else
 276     return NULL;
 277 }
 278
 279 /**
 280  * This function initializes the Event Viewer functionnality through the
 281  * GTK  API.
 282  */
 283 DiskPerformanceData *disk_performance_data(LttvPluginTab *ptab)
 284 {
 285   LttTime end;
 286   GtkTreeViewColumn *column;
 287   GtkCellRenderer *renderer;
 288   DiskPerformanceData* disk_data = g_new(DiskPerformanceData,1) ;
 289
 290   g_info("enter disk_performance_data \n");
 291   Tab *tab = ptab->tab;
 292   disk_data->tab = tab;
 293   disk_data->ptab = ptab;
 294   disk_data->time_window  =  lttvwindow_get_time_window(tab);
 295
 296   disk_data->disk_array = g_array_new(FALSE, FALSE, sizeof(lttv_total_block ));
 297
 298   lttvwindow_register_time_window_notify(tab,
 299                                          disk_update_time_window,
 300                                          disk_data);
 301
 302   disk_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
 303   gtk_widget_show (disk_data->scroll_win);
 304   gtk_scrolled_window_set_policy(
 305       GTK_SCROLLED_WINDOW(disk_data->scroll_win),
 306       GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 307
 308   /* Create a model for storing the data list */
 309   disk_data->store_m = gtk_list_store_new (
 310     N_COLUMNS,      /* Total number of columns     */
 311     G_TYPE_STRING,     /* Diskname                 */
 312     G_TYPE_INT64,     /* Bytes read                */
 313     G_TYPE_INT64,     /* Bytes read/sec            */
 314     G_TYPE_INT,
 315     G_TYPE_INT64,    /*  bytes written             */
 316     G_TYPE_INT64,    /*  bytes written/sec         */
 317     G_TYPE_INT
 318     );
 319
 320   disk_data->tree_v = gtk_tree_view_new_with_model (GTK_TREE_MODEL (disk_data->store_m));
 321
 322   g_object_unref (G_OBJECT (disk_data->store_m));
 323
 324   renderer = gtk_cell_renderer_text_new ();
 325
 326   column = gtk_tree_view_column_new_with_attributes ("DiskName",
 327                  renderer,
 328                  "text", DISKNAME_COLUMN,
 329                  NULL);
 330   gtk_tree_view_column_set_alignment (column, 0.0);
 331   gtk_tree_view_column_set_fixed_width (column, 45);
 332   gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
 333
 334   renderer = gtk_cell_renderer_text_new ();
 335   column = gtk_tree_view_column_new_with_attributes ("BytesRead",
 336                  renderer,
 337                  "text", BYTES_RD_COLUMN,
 338                  NULL);
 339   gtk_tree_view_column_set_alignment (column, 0.0);
 340   gtk_tree_view_column_set_fixed_width (column,  220);
 341   gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
 342
 343   renderer = gtk_cell_renderer_text_new ();
 344   column = gtk_tree_view_column_new_with_attributes ("BytesRead/sec",
 345                  renderer,
 346                  "text", BYTES_RD_SEC_COLUMN,
 347                  NULL);
 348   gtk_tree_view_column_set_alignment (column, 1.0);
 349   gtk_tree_view_column_set_fixed_width (column, 220);
 350   gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
 351
 352   renderer = gtk_cell_renderer_text_new ();
 353   column = gtk_tree_view_column_new_with_attributes ("NumReadOperations",
 354                  renderer,
 355                  "text",NUM_RD_COLUMN,
 356                  NULL);
 357   gtk_tree_view_column_set_alignment (column, 1.0);
 358   gtk_tree_view_column_set_fixed_width (column, 220);
 359   gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
 360
 361   renderer = gtk_cell_renderer_text_new ();
 362   column = gtk_tree_view_column_new_with_attributes ("BytesWritten",
 363                  renderer,
 364                  "text", BYTES_WR_COLUMN,
 365                  NULL);
 366   gtk_tree_view_column_set_alignment (column, 0.0);
 367   gtk_tree_view_column_set_fixed_width (column, 145);
 368   gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
 369
 370   renderer = gtk_cell_renderer_text_new ();
 371   column = gtk_tree_view_column_new_with_attributes ("BytesWritten/sec",
 372                  renderer,
 373                  "text", BYTES_WR_SEC_COLUMN,
 374                  NULL);
 375   gtk_tree_view_column_set_alignment (column, 1.0);
 376   gtk_tree_view_column_set_fixed_width (column, 220);
 377   gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
 378
 379   renderer = gtk_cell_renderer_text_new ();
 380   column = gtk_tree_view_column_new_with_attributes ("NumWriteOperations",
 381                  renderer,
 382                  "text",NUM_WR_COLUMN,
 383                  NULL);
 384   gtk_tree_view_column_set_alignment (column, 0.0);
 385   gtk_tree_view_column_set_fixed_width (column, 145);
 386   gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
 387
 388   disk_data->select_c = gtk_tree_view_get_selection (GTK_TREE_VIEW (disk_data->tree_v));
 389   gtk_tree_selection_set_mode (disk_data->select_c, GTK_SELECTION_SINGLE);
 390
 391   gtk_container_add (GTK_CONTAINER (disk_data->scroll_win), disk_data->tree_v);
 392
 393   disk_data->hbox_v = gtk_hbox_new(0, 0);
 394   gtk_box_pack_start(GTK_BOX(disk_data->hbox_v), disk_data->scroll_win, TRUE, TRUE, 0);
 395
 396   gtk_widget_show(disk_data->hbox_v);
 397   gtk_widget_show(disk_data->tree_v);
 398
 399
 400   g_disk_data_list = g_slist_append(g_disk_data_list, disk_data);
 401   g_object_set_data_full(G_OBJECT(disk_data->hbox_v),
 402       "disk_data",
 403        disk_data,
 404       (GDestroyNotify)gui_disperformance_free);
 405
 406   request_event(disk_data);
 407   return disk_data;
 408 }
 409
 410 /**
 411  *
 412  * For each trace in the traceset, this function:
 413  *  - calls lttv_trace_find_hook() & registers a hook function to event_by_id_hooks
 414  *  - registers a callback function to each hook
 415  *  - calls lttvwindow_events_request() to request data in a specific
 416  *    time interval to the main window
 417  *
 418  */
 419 static void request_event(DiskPerformanceData *disk_performance)
 420 {
 421   guint i, k, l, nb_trace;
 422
 423   GArray *hooks;
 424
 425   guint ret;
 426
 427   LttvTraceHook *hook;
 428
 429   LttvTraceState *ts;
 430
 431   LttvTraceHookByFacility *thf;
 432
 433   LttvTracesetContext *tsc = lttvwindow_get_traceset_context(disk_performance->tab);
 434   /* Get the traceset */
 435   LttvTraceset *traceset = tsc->ts;
 436
 437   nb_trace = lttv_traceset_number(traceset);
 438
 439   //for(i = 0; i<MIN(TRACE_NUMBER+1, nb_trace);i++) {
 440   for(i = 0 ; i < nb_trace ; i++) {
 441         EventsRequest *events_request = g_new(EventsRequest, 1);
 442
 443         hooks = g_array_new(FALSE, FALSE, sizeof(LttvTraceHook));
 444
 445         hooks = g_array_set_size(hooks, 2);
 446
 447         /* Get a trace state */
 448         ts = (LttvTraceState *)tsc->traces[i];
 449
 450         disk_performance->event_by_id_hooks = lttv_hooks_by_id_new();
 451         /* Register event_by_id_hooks with a callback function */
 452         ret = lttv_trace_find_hook(ts->parent.t,
 453                 LTT_FACILITY_BLOCK, LTT_EVENT_BLOCK_READ,
 454                 0, 0, 0,
 455                 block_read_callback,
 456                 disk_performance,
 457                 &g_array_index(hooks, LttvTraceHook, 0));
 458
 459         ret = lttv_trace_find_hook(ts->parent.t,
 460                 LTT_FACILITY_BLOCK, LTT_EVENT_BLOCK_WRITE,
 461                 0, 0, 0,
 462                 block_write_callback,
 463                 disk_performance,
 464                 &g_array_index(hooks, LttvTraceHook, 1));
 465
 466         g_assert(!ret);
 467
 468         /*iterate through the facility list*/
 469         for(k = 0 ; k < hooks->len; k++)
 470         {
 471                 hook = &g_array_index(hooks, LttvTraceHook, k);
 472                 for(l=0; l<hook->fac_list->len; l++)
 473                 {
 474                         thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
 475                         lttv_hooks_add(lttv_hooks_by_id_find(disk_performance->event_by_id_hooks, thf->id),
 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;
 507         events_request->event_by_id             = disk_performance->event_by_id_hooks;
 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);
 515   }
 516
 517 }
 518
 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);
 538
 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;
 544 }
 545
 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);
 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
 569  return FALSE;
 570 }
 571
 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++)
 586   {
 587         element = ltt_eventtype_field(event_type,i);
 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
 602   }
 603
 604 }
 605
 606
 607
 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 {
 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
 664
 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
 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";
1095
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 }
1269 LTTV_MODULE("diskperformance", "disk info view", \
1270             "Produce disk I/O performance", \
1271             init, destroy, "lttvwindow")
1272