gfio.c revision 1b42725f06f8906b9b99381da3490484f59df28a
1/* 2 * gfio - gui front end for fio - the flexible io tester 3 * 4 * Copyright (C) 2012 Stephen M. Cameron <stephenmcameron@gmail.com> 5 * Copyright (C) 2012 Jens Axboe <axboe@kernel.dk> 6 * 7 * The license below covers all files distributed with fio unless otherwise 8 * noted in the file itself. 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * 23 */ 24#include <locale.h> 25#include <malloc.h> 26#include <string.h> 27 28#include <glib.h> 29#include <cairo.h> 30#include <gtk/gtk.h> 31 32#include "fio.h" 33#include "graph.h" 34 35#define GFIO_MIME "text/fio" 36 37static int gfio_server_running; 38static const char *gfio_graph_font; 39static unsigned int gfio_graph_limit = 100; 40 41static void view_log(GtkWidget *w, gpointer data); 42 43#define ARRAYSIZE(x) (sizeof((x)) / (sizeof((x)[0]))) 44 45typedef void (*clickfunction)(GtkWidget *widget, gpointer data); 46 47static void connect_clicked(GtkWidget *widget, gpointer data); 48static void start_job_clicked(GtkWidget *widget, gpointer data); 49static void send_clicked(GtkWidget *widget, gpointer data); 50 51static struct button_spec { 52 const char *buttontext; 53 clickfunction f; 54 const char *tooltiptext; 55 const int start_insensitive; 56} buttonspeclist[] = { 57#define CONNECT_BUTTON 0 58#define SEND_BUTTON 1 59#define START_JOB_BUTTON 2 60 { "Connect", connect_clicked, "Connect to host", 0 }, 61 { "Send", send_clicked, "Send job description to host", 1 }, 62 { "Start Job", start_job_clicked, 63 "Start the current job on the server", 1 }, 64}; 65 66struct probe_widget { 67 GtkWidget *hostname; 68 GtkWidget *os; 69 GtkWidget *arch; 70 GtkWidget *fio_ver; 71}; 72 73struct multitext_widget { 74 GtkWidget *entry; 75 char **text; 76 unsigned int cur_text; 77 unsigned int max_text; 78}; 79 80struct eta_widget { 81 GtkWidget *names; 82 struct multitext_widget iotype; 83 struct multitext_widget ioengine; 84 struct multitext_widget iodepth; 85 GtkWidget *jobs; 86 GtkWidget *files; 87 GtkWidget *read_bw; 88 GtkWidget *read_iops; 89 GtkWidget *cr_bw; 90 GtkWidget *cr_iops; 91 GtkWidget *write_bw; 92 GtkWidget *write_iops; 93 GtkWidget *cw_bw; 94 GtkWidget *cw_iops; 95}; 96 97struct gfio_graphs { 98#define DRAWING_AREA_XDIM 1000 99#define DRAWING_AREA_YDIM 400 100 GtkWidget *drawing_area; 101 struct graph *iops_graph; 102 struct graph *bandwidth_graph; 103}; 104 105/* 106 * Main window widgets and data 107 */ 108struct gui { 109 GtkUIManager *uimanager; 110 GtkRecentManager *recentmanager; 111 GtkActionGroup *actiongroup; 112 guint recent_ui_id; 113 GtkWidget *menu; 114 GtkWidget *window; 115 GtkWidget *vbox; 116 GtkWidget *thread_status_pb; 117 GtkWidget *buttonbox; 118 GtkWidget *notebook; 119 GtkWidget *error_info_bar; 120 GtkWidget *error_label; 121 GtkListStore *log_model; 122 GtkWidget *log_tree; 123 GtkWidget *log_view; 124 struct gfio_graphs graphs; 125 struct probe_widget probe; 126 struct eta_widget eta; 127 pthread_t server_t; 128 129 pthread_t t; 130 int handler_running; 131 132 struct flist_head list; 133} main_ui; 134 135enum { 136 GE_STATE_NEW = 1, 137 GE_STATE_CONNECTED, 138 GE_STATE_JOB_SENT, 139 GE_STATE_JOB_STARTED, 140 GE_STATE_JOB_RUNNING, 141 GE_STATE_JOB_DONE, 142}; 143 144/* 145 * Notebook entry 146 */ 147struct gui_entry { 148 struct flist_head list; 149 struct gui *ui; 150 151 GtkWidget *vbox; 152 GtkWidget *job_notebook; 153 GtkWidget *thread_status_pb; 154 GtkWidget *buttonbox; 155 GtkWidget *button[ARRAYSIZE(buttonspeclist)]; 156 GtkWidget *notebook; 157 GtkWidget *error_info_bar; 158 GtkWidget *error_label; 159 GtkWidget *results_notebook; 160 GtkWidget *results_window; 161 GtkListStore *log_model; 162 GtkWidget *log_tree; 163 GtkWidget *log_view; 164 struct gfio_graphs graphs; 165 struct probe_widget probe; 166 struct eta_widget eta; 167 GtkWidget *page_label; 168 gint page_num; 169 unsigned int state; 170 171 struct gfio_client *client; 172 int nr_job_files; 173 char **job_files; 174}; 175 176struct gfio_client { 177 struct gui_entry *ge; 178 struct fio_client *client; 179 GtkWidget *results_widget; 180 GtkWidget *disk_util_frame; 181 GtkWidget *err_entry; 182 unsigned int job_added; 183 struct thread_options o; 184}; 185 186static void gfio_update_thread_status(struct gui_entry *ge, char *status_message, double perc); 187static void gfio_update_thread_status_all(char *status_message, double perc); 188void report_error(GError *error); 189 190static struct graph *setup_iops_graph(void) 191{ 192 struct graph *g; 193 194 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font); 195 graph_title(g, "IOPS (IOs/sec)"); 196 graph_x_title(g, "Time (secs)"); 197 graph_add_label(g, "Read IOPS"); 198 graph_add_label(g, "Write IOPS"); 199 graph_set_color(g, "Read IOPS", 0.13, 0.54, 0.13); 200 graph_set_color(g, "Write IOPS", 1.0, 0.0, 0.0); 201 line_graph_set_data_count_limit(g, gfio_graph_limit); 202 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0); 203 return g; 204} 205 206static struct graph *setup_bandwidth_graph(void) 207{ 208 struct graph *g; 209 210 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font); 211 graph_title(g, "Bandwidth (bytes/sec)"); 212 graph_x_title(g, "Time (secs)"); 213 graph_add_label(g, "Read Bandwidth"); 214 graph_add_label(g, "Write Bandwidth"); 215 graph_set_color(g, "Read Bandwidth", 0.13, 0.54, 0.13); 216 graph_set_color(g, "Write Bandwidth", 1.0, 0.0, 0.0); 217 graph_set_base_offset(g, 1); 218 line_graph_set_data_count_limit(g, 100); 219 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0); 220 return g; 221} 222 223static void setup_graphs(struct gfio_graphs *g) 224{ 225 g->iops_graph = setup_iops_graph(); 226 g->bandwidth_graph = setup_bandwidth_graph(); 227} 228 229static void multitext_add_entry(struct multitext_widget *mt, const char *text) 230{ 231 mt->text = realloc(mt->text, (mt->max_text + 1) * sizeof(char *)); 232 mt->text[mt->max_text] = strdup(text); 233 mt->max_text++; 234} 235 236static void multitext_set_entry(struct multitext_widget *mt, unsigned int index) 237{ 238 if (index >= mt->max_text) 239 return; 240 if (!mt->text || !mt->text[index]) 241 return; 242 243 mt->cur_text = index; 244 gtk_entry_set_text(GTK_ENTRY(mt->entry), mt->text[index]); 245} 246 247static void multitext_update_entry(struct multitext_widget *mt, 248 unsigned int index, const char *text) 249{ 250 if (!mt->text) 251 return; 252 253 if (mt->text[index]) 254 free(mt->text[index]); 255 256 mt->text[index] = strdup(text); 257 if (mt->cur_text == index) 258 gtk_entry_set_text(GTK_ENTRY(mt->entry), mt->text[index]); 259} 260 261static void multitext_free(struct multitext_widget *mt) 262{ 263 int i; 264 265 gtk_entry_set_text(GTK_ENTRY(mt->entry), ""); 266 267 for (i = 0; i < mt->max_text; i++) { 268 if (mt->text[i]) 269 free(mt->text[i]); 270 } 271 272 free(mt->text); 273 mt->cur_text = -1; 274 mt->max_text = 0; 275} 276 277static void clear_ge_ui_info(struct gui_entry *ge) 278{ 279 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), ""); 280 gtk_label_set_text(GTK_LABEL(ge->probe.os), ""); 281 gtk_label_set_text(GTK_LABEL(ge->probe.arch), ""); 282 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), ""); 283#if 0 284 /* should we empty it... */ 285 gtk_entry_set_text(GTK_ENTRY(ge->eta.name), ""); 286#endif 287 multitext_update_entry(&ge->eta.iotype, 0, ""); 288 multitext_update_entry(&ge->eta.ioengine, 0, ""); 289 multitext_update_entry(&ge->eta.iodepth, 0, ""); 290 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), ""); 291 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), ""); 292 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), ""); 293 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), ""); 294 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), ""); 295 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), ""); 296} 297 298static GtkWidget *new_combo_entry_in_frame(GtkWidget *box, const char *label) 299{ 300 GtkWidget *entry, *frame; 301 302 frame = gtk_frame_new(label); 303 entry = gtk_combo_box_new_text(); 304 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3); 305 gtk_container_add(GTK_CONTAINER(frame), entry); 306 307 return entry; 308} 309 310static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label) 311{ 312 GtkWidget *entry, *frame; 313 314 frame = gtk_frame_new(label); 315 entry = gtk_entry_new(); 316 gtk_entry_set_editable(GTK_ENTRY(entry), 0); 317 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3); 318 gtk_container_add(GTK_CONTAINER(frame), entry); 319 320 return entry; 321} 322 323static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label) 324{ 325 GtkWidget *label_widget; 326 GtkWidget *frame; 327 328 frame = gtk_frame_new(label); 329 label_widget = gtk_label_new(NULL); 330 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3); 331 gtk_container_add(GTK_CONTAINER(frame), label_widget); 332 333 return label_widget; 334} 335 336static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval) 337{ 338 GtkWidget *button, *box; 339 340 box = gtk_hbox_new(FALSE, 3); 341 gtk_container_add(GTK_CONTAINER(hbox), box); 342 343 button = gtk_spin_button_new_with_range(min, max, 1.0); 344 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0); 345 346 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID); 347 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval); 348 349 return button; 350} 351 352static void label_set_int_value(GtkWidget *entry, unsigned int val) 353{ 354 char tmp[80]; 355 356 sprintf(tmp, "%u", val); 357 gtk_label_set_text(GTK_LABEL(entry), tmp); 358} 359 360static void entry_set_int_value(GtkWidget *entry, unsigned int val) 361{ 362 char tmp[80]; 363 364 sprintf(tmp, "%u", val); 365 gtk_entry_set_text(GTK_ENTRY(entry), tmp); 366} 367 368static void show_info_dialog(struct gui *ui, const char *title, 369 const char *message) 370{ 371 GtkWidget *dialog, *content, *label; 372 373 dialog = gtk_dialog_new_with_buttons(title, GTK_WINDOW(ui->window), 374 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, 375 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); 376 377 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); 378 label = gtk_label_new(message); 379 gtk_container_add(GTK_CONTAINER(content), label); 380 gtk_widget_show_all(dialog); 381 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT); 382 gtk_dialog_run(GTK_DIALOG(dialog)); 383 gtk_widget_destroy(dialog); 384} 385 386/* 387 * Update sensitivity of job buttons and job menu items, based on the 388 * state of the client. 389 */ 390static void update_button_states(struct gui *ui, struct gui_entry *ge) 391{ 392 unsigned int connect_state, send_state, start_state, edit_state; 393 const char *connect_str = NULL; 394 GtkWidget *w; 395 396 switch (ge->state) { 397 default: { 398 char tmp[80]; 399 400 sprintf(tmp, "Bad client state: %u\n", ge->state); 401 show_info_dialog(ui, "Error", tmp); 402 /* fall through to new state */ 403 } 404 405 case GE_STATE_NEW: 406 connect_state = 1; 407 edit_state = 0; 408 connect_str = "Connect"; 409 send_state = 0; 410 start_state = 0; 411 break; 412 case GE_STATE_CONNECTED: 413 connect_state = 1; 414 edit_state = 0; 415 connect_str = "Disconnect"; 416 send_state = 1; 417 start_state = 0; 418 break; 419 case GE_STATE_JOB_SENT: 420 connect_state = 1; 421 edit_state = 0; 422 connect_str = "Disconnect"; 423 send_state = 0; 424 start_state = 1; 425 break; 426 case GE_STATE_JOB_STARTED: 427 connect_state = 1; 428 edit_state = 1; 429 connect_str = "Disconnect"; 430 send_state = 0; 431 start_state = 1; 432 break; 433 case GE_STATE_JOB_RUNNING: 434 connect_state = 1; 435 edit_state = 0; 436 connect_str = "Disconnect"; 437 send_state = 0; 438 start_state = 0; 439 break; 440 case GE_STATE_JOB_DONE: 441 connect_state = 1; 442 edit_state = 0; 443 connect_str = "Connect"; 444 send_state = 0; 445 start_state = 0; 446 break; 447 } 448 449 gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], connect_state); 450 gtk_widget_set_sensitive(ge->button[SEND_BUTTON], send_state); 451 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], start_state); 452 gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), connect_str); 453 454 /* 455 * So the below doesn't work at all, how to set those menu items 456 * invisibible... 457 */ 458 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Connect"); 459 gtk_widget_set_sensitive(w, connect_state); 460 gtk_menu_item_set_label(GTK_MENU_ITEM(w), connect_str); 461 462 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Edit job"); 463 gtk_widget_set_sensitive(w, edit_state); 464 465 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Send job"); 466 gtk_widget_set_sensitive(w, send_state); 467 468 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Start job"); 469 gtk_widget_set_sensitive(w, start_state); 470} 471 472static void gfio_set_state(struct gui_entry *ge, unsigned int state) 473{ 474 ge->state = state; 475 update_button_states(ge->ui, ge); 476} 477 478#define ALIGN_LEFT 1 479#define ALIGN_RIGHT 2 480#define INVISIBLE 4 481#define UNSORTABLE 8 482 483GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags) 484{ 485 GtkCellRenderer *renderer; 486 GtkTreeViewColumn *col; 487 double xalign = 0.0; /* left as default */ 488 PangoAlignment align; 489 gboolean visible; 490 491 align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT : 492 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT : 493 PANGO_ALIGN_CENTER; 494 visible = !(flags & INVISIBLE); 495 496 renderer = gtk_cell_renderer_text_new(); 497 col = gtk_tree_view_column_new(); 498 499 gtk_tree_view_column_set_title(col, title); 500 if (!(flags & UNSORTABLE)) 501 gtk_tree_view_column_set_sort_column_id(col, index); 502 gtk_tree_view_column_set_resizable(col, TRUE); 503 gtk_tree_view_column_pack_start(col, renderer, TRUE); 504 gtk_tree_view_column_add_attribute(col, renderer, "text", index); 505 gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL); 506 switch (align) { 507 case PANGO_ALIGN_LEFT: 508 xalign = 0.0; 509 break; 510 case PANGO_ALIGN_CENTER: 511 xalign = 0.5; 512 break; 513 case PANGO_ALIGN_RIGHT: 514 xalign = 1.0; 515 break; 516 } 517 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5); 518 gtk_tree_view_column_set_visible(col, visible); 519 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col); 520 return col; 521} 522 523static void gfio_ui_setup_log(struct gui *ui) 524{ 525 GtkTreeSelection *selection; 526 GtkListStore *model; 527 GtkWidget *tree_view; 528 529 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING); 530 531 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); 532 gtk_widget_set_can_focus(tree_view, FALSE); 533 534 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); 535 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE); 536 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE, 537 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL); 538 539 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE); 540 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE); 541 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE); 542 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE); 543 544 ui->log_model = model; 545 ui->log_tree = tree_view; 546} 547 548static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals, 549 fio_fp64_t *plist, 550 unsigned int len, 551 const char *base, 552 unsigned int scale) 553{ 554 GType types[FIO_IO_U_LIST_MAX_LEN]; 555 GtkWidget *tree_view; 556 GtkTreeSelection *selection; 557 GtkListStore *model; 558 GtkTreeIter iter; 559 int i; 560 561 for (i = 0; i < len; i++) 562 types[i] = G_TYPE_INT; 563 564 model = gtk_list_store_newv(len, types); 565 566 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); 567 gtk_widget_set_can_focus(tree_view, FALSE); 568 569 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE, 570 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL); 571 572 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); 573 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE); 574 575 for (i = 0; i < len; i++) { 576 char fbuf[8]; 577 578 sprintf(fbuf, "%2.2f%%", plist[i].u.f); 579 tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE); 580 } 581 582 gtk_list_store_append(model, &iter); 583 584 for (i = 0; i < len; i++) { 585 if (scale) 586 ovals[i] = (ovals[i] + 999) / 1000; 587 gtk_list_store_set(model, &iter, i, ovals[i], -1); 588 } 589 590 return tree_view; 591} 592 593static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts, 594 int ddir) 595{ 596 unsigned int *io_u_plat = ts->io_u_plat[ddir]; 597 unsigned long nr = ts->clat_stat[ddir].samples; 598 fio_fp64_t *plist = ts->percentile_list; 599 unsigned int *ovals, len, minv, maxv, scale_down; 600 const char *base; 601 GtkWidget *tree_view, *frame, *hbox; 602 char tmp[64]; 603 604 len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv); 605 if (!len) 606 goto out; 607 608 /* 609 * We default to usecs, but if the value range is such that we 610 * should scale down to msecs, do that. 611 */ 612 if (minv > 2000 && maxv > 99999) { 613 scale_down = 1; 614 base = "msec"; 615 } else { 616 scale_down = 0; 617 base = "usec"; 618 } 619 620 tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down); 621 622 sprintf(tmp, "Completion percentiles (%s)", base); 623 frame = gtk_frame_new(tmp); 624 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 625 626 hbox = gtk_hbox_new(FALSE, 3); 627 gtk_container_add(GTK_CONTAINER(frame), hbox); 628 629 gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3); 630out: 631 if (ovals) 632 free(ovals); 633} 634 635static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min, 636 unsigned long max, double mean, double dev) 637{ 638 const char *base = "(usec)"; 639 GtkWidget *hbox, *label, *frame; 640 char *minp, *maxp; 641 char tmp[64]; 642 643 if (!usec_to_msec(&min, &max, &mean, &dev)) 644 base = "(msec)"; 645 646 minp = num2str(min, 6, 1, 0); 647 maxp = num2str(max, 6, 1, 0); 648 649 sprintf(tmp, "%s %s", name, base); 650 frame = gtk_frame_new(tmp); 651 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 652 653 hbox = gtk_hbox_new(FALSE, 3); 654 gtk_container_add(GTK_CONTAINER(frame), hbox); 655 656 label = new_info_label_in_frame(hbox, "Minimum"); 657 gtk_label_set_text(GTK_LABEL(label), minp); 658 label = new_info_label_in_frame(hbox, "Maximum"); 659 gtk_label_set_text(GTK_LABEL(label), maxp); 660 label = new_info_label_in_frame(hbox, "Average"); 661 sprintf(tmp, "%5.02f", mean); 662 gtk_label_set_text(GTK_LABEL(label), tmp); 663 label = new_info_label_in_frame(hbox, "Standard deviation"); 664 sprintf(tmp, "%5.02f", dev); 665 gtk_label_set_text(GTK_LABEL(label), tmp); 666 667 free(minp); 668 free(maxp); 669 670} 671 672#define GFIO_CLAT 1 673#define GFIO_SLAT 2 674#define GFIO_LAT 4 675 676static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs, 677 struct thread_stat *ts, int ddir) 678{ 679 const char *ddir_label[2] = { "Read", "Write" }; 680 GtkWidget *frame, *label, *box, *vbox, *main_vbox; 681 unsigned long min[3], max[3], runt; 682 unsigned long long bw, iops; 683 unsigned int flags = 0; 684 double mean[3], dev[3]; 685 char *io_p, *bw_p, *iops_p; 686 int i2p; 687 688 if (!ts->runtime[ddir]) 689 return; 690 691 i2p = is_power_of_2(rs->kb_base); 692 runt = ts->runtime[ddir]; 693 694 bw = (1000 * ts->io_bytes[ddir]) / runt; 695 io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p); 696 bw_p = num2str(bw, 6, 1, i2p); 697 698 iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt; 699 iops_p = num2str(iops, 6, 1, 0); 700 701 box = gtk_hbox_new(FALSE, 3); 702 gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3); 703 704 frame = gtk_frame_new(ddir_label[ddir]); 705 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5); 706 707 main_vbox = gtk_vbox_new(FALSE, 3); 708 gtk_container_add(GTK_CONTAINER(frame), main_vbox); 709 710 box = gtk_hbox_new(FALSE, 3); 711 gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3); 712 713 label = new_info_label_in_frame(box, "IO"); 714 gtk_label_set_text(GTK_LABEL(label), io_p); 715 label = new_info_label_in_frame(box, "Bandwidth"); 716 gtk_label_set_text(GTK_LABEL(label), bw_p); 717 label = new_info_label_in_frame(box, "IOPS"); 718 gtk_label_set_text(GTK_LABEL(label), iops_p); 719 label = new_info_label_in_frame(box, "Runtime (msec)"); 720 label_set_int_value(label, ts->runtime[ddir]); 721 722 if (calc_lat(&ts->bw_stat[ddir], &min[0], &max[0], &mean[0], &dev[0])) { 723 double p_of_agg = 100.0; 724 const char *bw_str = "KB"; 725 char tmp[32]; 726 727 if (rs->agg[ddir]) { 728 p_of_agg = mean[0] * 100 / (double) rs->agg[ddir]; 729 if (p_of_agg > 100.0) 730 p_of_agg = 100.0; 731 } 732 733 if (mean[0] > 999999.9) { 734 min[0] /= 1000.0; 735 max[0] /= 1000.0; 736 mean[0] /= 1000.0; 737 dev[0] /= 1000.0; 738 bw_str = "MB"; 739 } 740 741 sprintf(tmp, "Bandwidth (%s)", bw_str); 742 frame = gtk_frame_new(tmp); 743 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5); 744 745 box = gtk_hbox_new(FALSE, 3); 746 gtk_container_add(GTK_CONTAINER(frame), box); 747 748 label = new_info_label_in_frame(box, "Minimum"); 749 label_set_int_value(label, min[0]); 750 label = new_info_label_in_frame(box, "Maximum"); 751 label_set_int_value(label, max[0]); 752 label = new_info_label_in_frame(box, "Percentage of jobs"); 753 sprintf(tmp, "%3.2f%%", p_of_agg); 754 gtk_label_set_text(GTK_LABEL(label), tmp); 755 label = new_info_label_in_frame(box, "Average"); 756 sprintf(tmp, "%5.02f", mean[0]); 757 gtk_label_set_text(GTK_LABEL(label), tmp); 758 label = new_info_label_in_frame(box, "Standard deviation"); 759 sprintf(tmp, "%5.02f", dev[0]); 760 gtk_label_set_text(GTK_LABEL(label), tmp); 761 } 762 763 if (calc_lat(&ts->slat_stat[ddir], &min[0], &max[0], &mean[0], &dev[0])) 764 flags |= GFIO_SLAT; 765 if (calc_lat(&ts->clat_stat[ddir], &min[1], &max[1], &mean[1], &dev[1])) 766 flags |= GFIO_CLAT; 767 if (calc_lat(&ts->lat_stat[ddir], &min[2], &max[2], &mean[2], &dev[2])) 768 flags |= GFIO_LAT; 769 770 if (flags) { 771 frame = gtk_frame_new("Latency"); 772 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5); 773 774 vbox = gtk_vbox_new(FALSE, 3); 775 gtk_container_add(GTK_CONTAINER(frame), vbox); 776 777 if (flags & GFIO_SLAT) 778 gfio_show_lat(vbox, "Submission latency", min[0], max[0], mean[0], dev[0]); 779 if (flags & GFIO_CLAT) 780 gfio_show_lat(vbox, "Completion latency", min[1], max[1], mean[1], dev[1]); 781 if (flags & GFIO_LAT) 782 gfio_show_lat(vbox, "Total latency", min[2], max[2], mean[2], dev[2]); 783 } 784 785 if (ts->clat_percentiles) 786 gfio_show_clat_percentiles(main_vbox, ts, ddir); 787 788 789 free(io_p); 790 free(bw_p); 791 free(iops_p); 792} 793 794static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num, 795 const char **labels) 796{ 797 GtkWidget *tree_view; 798 GtkTreeSelection *selection; 799 GtkListStore *model; 800 GtkTreeIter iter; 801 GType *types; 802 int i, skipped; 803 804 /* 805 * Check if all are empty, in which case don't bother 806 */ 807 for (i = 0, skipped = 0; i < num; i++) 808 if (lat[i] <= 0.0) 809 skipped++; 810 811 if (skipped == num) 812 return NULL; 813 814 types = malloc(num * sizeof(GType)); 815 816 for (i = 0; i < num; i++) 817 types[i] = G_TYPE_STRING; 818 819 model = gtk_list_store_newv(num, types); 820 free(types); 821 types = NULL; 822 823 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); 824 gtk_widget_set_can_focus(tree_view, FALSE); 825 826 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE, 827 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL); 828 829 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); 830 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE); 831 832 for (i = 0; i < num; i++) 833 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE); 834 835 gtk_list_store_append(model, &iter); 836 837 for (i = 0; i < num; i++) { 838 char fbuf[32]; 839 840 if (lat[i] <= 0.0) 841 sprintf(fbuf, "0.00"); 842 else 843 sprintf(fbuf, "%3.2f%%", lat[i]); 844 845 gtk_list_store_set(model, &iter, i, fbuf, -1); 846 } 847 848 return tree_view; 849} 850 851static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts) 852{ 853 GtkWidget *box, *frame, *tree_view; 854 double io_u_lat_u[FIO_IO_U_LAT_U_NR]; 855 double io_u_lat_m[FIO_IO_U_LAT_M_NR]; 856 const char *uranges[] = { "2", "4", "10", "20", "50", "100", 857 "250", "500", "750", "1000", }; 858 const char *mranges[] = { "2", "4", "10", "20", "50", "100", 859 "250", "500", "750", "1000", "2000", 860 ">= 2000", }; 861 862 stat_calc_lat_u(ts, io_u_lat_u); 863 stat_calc_lat_m(ts, io_u_lat_m); 864 865 tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges); 866 if (tree_view) { 867 frame = gtk_frame_new("Latency buckets (usec)"); 868 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 869 870 box = gtk_hbox_new(FALSE, 3); 871 gtk_container_add(GTK_CONTAINER(frame), box); 872 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3); 873 } 874 875 tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges); 876 if (tree_view) { 877 frame = gtk_frame_new("Latency buckets (msec)"); 878 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 879 880 box = gtk_hbox_new(FALSE, 3); 881 gtk_container_add(GTK_CONTAINER(frame), box); 882 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3); 883 } 884} 885 886static void gfio_show_cpu_usage(GtkWidget *vbox, struct thread_stat *ts) 887{ 888 GtkWidget *box, *frame, *entry; 889 double usr_cpu, sys_cpu; 890 unsigned long runtime; 891 char tmp[32]; 892 893 runtime = ts->total_run_time; 894 if (runtime) { 895 double runt = (double) runtime; 896 897 usr_cpu = (double) ts->usr_time * 100 / runt; 898 sys_cpu = (double) ts->sys_time * 100 / runt; 899 } else { 900 usr_cpu = 0; 901 sys_cpu = 0; 902 } 903 904 frame = gtk_frame_new("OS resources"); 905 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 906 907 box = gtk_hbox_new(FALSE, 3); 908 gtk_container_add(GTK_CONTAINER(frame), box); 909 910 entry = new_info_entry_in_frame(box, "User CPU"); 911 sprintf(tmp, "%3.2f%%", usr_cpu); 912 gtk_entry_set_text(GTK_ENTRY(entry), tmp); 913 entry = new_info_entry_in_frame(box, "System CPU"); 914 sprintf(tmp, "%3.2f%%", sys_cpu); 915 gtk_entry_set_text(GTK_ENTRY(entry), tmp); 916 entry = new_info_entry_in_frame(box, "Context switches"); 917 entry_set_int_value(entry, ts->ctx); 918 entry = new_info_entry_in_frame(box, "Major faults"); 919 entry_set_int_value(entry, ts->majf); 920 entry = new_info_entry_in_frame(box, "Minor faults"); 921 entry_set_int_value(entry, ts->minf); 922} 923static void gfio_add_sc_depths_tree(GtkListStore *model, 924 struct thread_stat *ts, unsigned int len, 925 int submit) 926{ 927 double io_u_dist[FIO_IO_U_MAP_NR]; 928 GtkTreeIter iter; 929 /* Bits 0, and 3-8 */ 930 const int add_mask = 0x1f9; 931 int i, j; 932 933 if (submit) 934 stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist); 935 else 936 stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist); 937 938 gtk_list_store_append(model, &iter); 939 940 gtk_list_store_set(model, &iter, 0, submit ? "Submit" : "Complete", -1); 941 942 for (i = 1, j = 0; i < len; i++) { 943 char fbuf[32]; 944 945 if (!(add_mask & (1UL << (i - 1)))) 946 sprintf(fbuf, "0.0%%"); 947 else { 948 sprintf(fbuf, "%3.1f%%", io_u_dist[j]); 949 j++; 950 } 951 952 gtk_list_store_set(model, &iter, i, fbuf, -1); 953 } 954 955} 956 957static void gfio_add_total_depths_tree(GtkListStore *model, 958 struct thread_stat *ts, unsigned int len) 959{ 960 double io_u_dist[FIO_IO_U_MAP_NR]; 961 GtkTreeIter iter; 962 /* Bits 1-6, and 8 */ 963 const int add_mask = 0x17e; 964 int i, j; 965 966 stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist); 967 968 gtk_list_store_append(model, &iter); 969 970 gtk_list_store_set(model, &iter, 0, "Total", -1); 971 972 for (i = 1, j = 0; i < len; i++) { 973 char fbuf[32]; 974 975 if (!(add_mask & (1UL << (i - 1)))) 976 sprintf(fbuf, "0.0%%"); 977 else { 978 sprintf(fbuf, "%3.1f%%", io_u_dist[j]); 979 j++; 980 } 981 982 gtk_list_store_set(model, &iter, i, fbuf, -1); 983 } 984 985} 986 987static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts) 988{ 989 GtkWidget *frame, *box, *tree_view; 990 GtkTreeSelection *selection; 991 GtkListStore *model; 992 GType types[FIO_IO_U_MAP_NR + 1]; 993 int i; 994#define NR_LABELS 10 995 const char *labels[NR_LABELS] = { "Depth", "0", "1", "2", "4", "8", "16", "32", "64", ">= 64" }; 996 997 frame = gtk_frame_new("IO depths"); 998 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 999 1000 box = gtk_hbox_new(FALSE, 3); 1001 gtk_container_add(GTK_CONTAINER(frame), box); 1002 1003 for (i = 0; i < NR_LABELS; i++) 1004 types[i] = G_TYPE_STRING; 1005 1006 model = gtk_list_store_newv(NR_LABELS, types); 1007 1008 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); 1009 gtk_widget_set_can_focus(tree_view, FALSE); 1010 1011 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE, 1012 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL); 1013 1014 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); 1015 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE); 1016 1017 for (i = 0; i < NR_LABELS; i++) 1018 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE); 1019 1020 gfio_add_total_depths_tree(model, ts, NR_LABELS); 1021 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 1); 1022 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 0); 1023 1024 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3); 1025} 1026 1027static gboolean results_window_delete(GtkWidget *w, gpointer data) 1028{ 1029 struct gui_entry *ge = (struct gui_entry *) data; 1030 1031 gtk_widget_destroy(w); 1032 ge->results_window = NULL; 1033 ge->results_notebook = NULL; 1034 return TRUE; 1035} 1036 1037static GtkWidget *get_results_window(struct gui_entry *ge) 1038{ 1039 GtkWidget *win, *notebook; 1040 1041 if (ge->results_window) 1042 return ge->results_notebook; 1043 1044 win = gtk_window_new(GTK_WINDOW_TOPLEVEL); 1045 gtk_window_set_title(GTK_WINDOW(win), "Results"); 1046 gtk_window_set_default_size(GTK_WINDOW(win), 1024, 768); 1047 g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ge); 1048 g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ge); 1049 1050 notebook = gtk_notebook_new(); 1051 gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), 1); 1052 gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook)); 1053 gtk_container_add(GTK_CONTAINER(win), notebook); 1054 1055 ge->results_window = win; 1056 ge->results_notebook = notebook; 1057 return ge->results_notebook; 1058} 1059 1060static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts, 1061 struct group_run_stats *rs) 1062{ 1063 GtkWidget *res_win, *box, *vbox, *entry, *scroll; 1064 struct gfio_client *gc = client->client_data; 1065 1066 gdk_threads_enter(); 1067 1068 res_win = get_results_window(gc->ge); 1069 1070 scroll = gtk_scrolled_window_new(NULL, NULL); 1071 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5); 1072 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 1073 1074 vbox = gtk_vbox_new(FALSE, 3); 1075 1076 box = gtk_hbox_new(FALSE, 0); 1077 gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 5); 1078 1079 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), vbox); 1080 1081 gtk_notebook_append_page(GTK_NOTEBOOK(res_win), scroll, gtk_label_new(ts->name)); 1082 1083 gc->results_widget = vbox; 1084 1085 entry = new_info_entry_in_frame(box, "Name"); 1086 gtk_entry_set_text(GTK_ENTRY(entry), ts->name); 1087 if (strlen(ts->description)) { 1088 entry = new_info_entry_in_frame(box, "Description"); 1089 gtk_entry_set_text(GTK_ENTRY(entry), ts->description); 1090 } 1091 entry = new_info_entry_in_frame(box, "Group ID"); 1092 entry_set_int_value(entry, ts->groupid); 1093 entry = new_info_entry_in_frame(box, "Jobs"); 1094 entry_set_int_value(entry, ts->members); 1095 gc->err_entry = entry = new_info_entry_in_frame(box, "Error"); 1096 entry_set_int_value(entry, ts->error); 1097 entry = new_info_entry_in_frame(box, "PID"); 1098 entry_set_int_value(entry, ts->pid); 1099 1100 if (ts->io_bytes[DDIR_READ]) 1101 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ); 1102 if (ts->io_bytes[DDIR_WRITE]) 1103 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE); 1104 1105 gfio_show_latency_buckets(vbox, ts); 1106 gfio_show_cpu_usage(vbox, ts); 1107 gfio_show_io_depths(vbox, ts); 1108 1109 gtk_widget_show_all(gc->ge->results_window); 1110 gdk_threads_leave(); 1111} 1112 1113static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd) 1114{ 1115 struct cmd_text_pdu *p = (struct cmd_text_pdu *) cmd->payload; 1116 struct gui *ui = &main_ui; 1117 GtkTreeIter iter; 1118 struct tm *tm; 1119 time_t sec; 1120 char tmp[64], timebuf[80]; 1121 1122 sec = p->log_sec; 1123 tm = localtime(&sec); 1124 strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S", tm); 1125 sprintf(timebuf, "%s.%03ld", tmp, p->log_usec / 1000); 1126 1127 gdk_threads_enter(); 1128 1129 gtk_list_store_append(ui->log_model, &iter); 1130 gtk_list_store_set(ui->log_model, &iter, 0, timebuf, -1); 1131 gtk_list_store_set(ui->log_model, &iter, 1, client->hostname, -1); 1132 gtk_list_store_set(ui->log_model, &iter, 2, p->level, -1); 1133 gtk_list_store_set(ui->log_model, &iter, 3, p->buf, -1); 1134 1135 if (p->level == FIO_LOG_ERR) 1136 view_log(NULL, (gpointer) ui); 1137 1138 gdk_threads_leave(); 1139} 1140 1141static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd) 1142{ 1143 struct cmd_du_pdu *p = (struct cmd_du_pdu *) cmd->payload; 1144 struct gfio_client *gc = client->client_data; 1145 GtkWidget *box, *frame, *entry, *vbox; 1146 double util; 1147 char tmp[16]; 1148 1149 gdk_threads_enter(); 1150 1151 if (!gc->results_widget) 1152 goto out; 1153 1154 if (!gc->disk_util_frame) { 1155 gc->disk_util_frame = gtk_frame_new("Disk utilization"); 1156 gtk_box_pack_start(GTK_BOX(gc->results_widget), gc->disk_util_frame, FALSE, FALSE, 5); 1157 } 1158 1159 vbox = gtk_vbox_new(FALSE, 3); 1160 gtk_container_add(GTK_CONTAINER(gc->disk_util_frame), vbox); 1161 1162 frame = gtk_frame_new((char *) p->dus.name); 1163 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 2); 1164 1165 box = gtk_vbox_new(FALSE, 3); 1166 gtk_container_add(GTK_CONTAINER(frame), box); 1167 1168 frame = gtk_frame_new("Read"); 1169 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2); 1170 vbox = gtk_hbox_new(TRUE, 3); 1171 gtk_container_add(GTK_CONTAINER(frame), vbox); 1172 entry = new_info_entry_in_frame(vbox, "IOs"); 1173 entry_set_int_value(entry, p->dus.ios[0]); 1174 entry = new_info_entry_in_frame(vbox, "Merges"); 1175 entry_set_int_value(entry, p->dus.merges[0]); 1176 entry = new_info_entry_in_frame(vbox, "Sectors"); 1177 entry_set_int_value(entry, p->dus.sectors[0]); 1178 entry = new_info_entry_in_frame(vbox, "Ticks"); 1179 entry_set_int_value(entry, p->dus.ticks[0]); 1180 1181 frame = gtk_frame_new("Write"); 1182 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2); 1183 vbox = gtk_hbox_new(TRUE, 3); 1184 gtk_container_add(GTK_CONTAINER(frame), vbox); 1185 entry = new_info_entry_in_frame(vbox, "IOs"); 1186 entry_set_int_value(entry, p->dus.ios[1]); 1187 entry = new_info_entry_in_frame(vbox, "Merges"); 1188 entry_set_int_value(entry, p->dus.merges[1]); 1189 entry = new_info_entry_in_frame(vbox, "Sectors"); 1190 entry_set_int_value(entry, p->dus.sectors[1]); 1191 entry = new_info_entry_in_frame(vbox, "Ticks"); 1192 entry_set_int_value(entry, p->dus.ticks[1]); 1193 1194 frame = gtk_frame_new("Shared"); 1195 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2); 1196 vbox = gtk_hbox_new(TRUE, 3); 1197 gtk_container_add(GTK_CONTAINER(frame), vbox); 1198 entry = new_info_entry_in_frame(vbox, "IO ticks"); 1199 entry_set_int_value(entry, p->dus.io_ticks); 1200 entry = new_info_entry_in_frame(vbox, "Time in queue"); 1201 entry_set_int_value(entry, p->dus.time_in_queue); 1202 1203 util = 0.0; 1204 if (p->dus.msec) 1205 util = (double) 100 * p->dus.io_ticks / (double) p->dus.msec; 1206 if (util > 100.0) 1207 util = 100.0; 1208 1209 sprintf(tmp, "%3.2f%%", util); 1210 entry = new_info_entry_in_frame(vbox, "Disk utilization"); 1211 gtk_entry_set_text(GTK_ENTRY(entry), tmp); 1212 1213 gtk_widget_show_all(gc->results_widget); 1214out: 1215 gdk_threads_leave(); 1216} 1217 1218extern int sum_stat_clients; 1219extern struct thread_stat client_ts; 1220extern struct group_run_stats client_gs; 1221 1222static int sum_stat_nr; 1223 1224static void gfio_thread_status_op(struct fio_client *client, 1225 struct fio_net_cmd *cmd) 1226{ 1227 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload; 1228 1229 gfio_display_ts(client, &p->ts, &p->rs); 1230 1231 if (sum_stat_clients == 1) 1232 return; 1233 1234 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr); 1235 sum_group_stats(&client_gs, &p->rs); 1236 1237 client_ts.members++; 1238 client_ts.groupid = p->ts.groupid; 1239 1240 if (++sum_stat_nr == sum_stat_clients) { 1241 strcpy(client_ts.name, "All clients"); 1242 gfio_display_ts(client, &client_ts, &client_gs); 1243 } 1244} 1245 1246static void gfio_group_stats_op(struct fio_client *client, 1247 struct fio_net_cmd *cmd) 1248{ 1249 /* We're ignoring group stats for now */ 1250} 1251 1252static gint on_config_drawing_area(GtkWidget *w, GdkEventConfigure *event, 1253 gpointer data) 1254{ 1255 struct gfio_graphs *g = data; 1256 1257 graph_set_size(g->iops_graph, w->allocation.width / 2.0, w->allocation.height); 1258 graph_set_position(g->iops_graph, w->allocation.width / 2.0, 0.0); 1259 graph_set_size(g->bandwidth_graph, w->allocation.width / 2.0, w->allocation.height); 1260 graph_set_position(g->bandwidth_graph, 0, 0); 1261 return TRUE; 1262} 1263 1264static void draw_graph(struct graph *g, cairo_t *cr) 1265{ 1266 line_graph_draw(g, cr); 1267 cairo_stroke(cr); 1268} 1269 1270static gboolean graph_tooltip(GtkWidget *w, gint x, gint y, 1271 gboolean keyboard_mode, GtkTooltip *tooltip, 1272 gpointer data) 1273{ 1274 struct gfio_graphs *g = data; 1275 const char *text = NULL; 1276 1277 if (graph_contains_xy(g->iops_graph, x, y)) 1278 text = graph_find_tooltip(g->iops_graph, x, y); 1279 else if (graph_contains_xy(g->bandwidth_graph, x, y)) 1280 text = graph_find_tooltip(g->bandwidth_graph, x, y); 1281 1282 if (text) { 1283 gtk_tooltip_set_text(tooltip, text); 1284 return TRUE; 1285 } 1286 1287 return FALSE; 1288} 1289 1290static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p) 1291{ 1292 struct gfio_graphs *g = p; 1293 cairo_t *cr; 1294 1295 cr = gdk_cairo_create(w->window); 1296 1297 if (graph_has_tooltips(g->iops_graph) || 1298 graph_has_tooltips(g->bandwidth_graph)) { 1299 g_object_set(w, "has-tooltip", TRUE, NULL); 1300 g_signal_connect(w, "query-tooltip", G_CALLBACK(graph_tooltip), g); 1301 } 1302 1303 cairo_set_source_rgb(cr, 0, 0, 0); 1304 draw_graph(g->iops_graph, cr); 1305 draw_graph(g->bandwidth_graph, cr); 1306 cairo_destroy(cr); 1307 1308 return FALSE; 1309} 1310 1311/* 1312 * Client specific ETA 1313 */ 1314static void gfio_update_client_eta(struct fio_client *client, struct jobs_eta *je) 1315{ 1316 struct gfio_client *gc = client->client_data; 1317 struct gui_entry *ge = gc->ge; 1318 static int eta_good; 1319 char eta_str[128]; 1320 char output[256]; 1321 char tmp[32]; 1322 double perc = 0.0; 1323 int i2p = 0; 1324 1325 gdk_threads_enter(); 1326 1327 eta_str[0] = '\0'; 1328 output[0] = '\0'; 1329 1330 if (je->eta_sec != INT_MAX && je->elapsed_sec) { 1331 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec); 1332 eta_to_str(eta_str, je->eta_sec); 1333 } 1334 1335 sprintf(tmp, "%u", je->nr_running); 1336 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), tmp); 1337 sprintf(tmp, "%u", je->files_open); 1338 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), tmp); 1339 1340#if 0 1341 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) { 1342 if (je->m_rate || je->t_rate) { 1343 char *tr, *mr; 1344 1345 mr = num2str(je->m_rate, 4, 0, i2p); 1346 tr = num2str(je->t_rate, 4, 0, i2p); 1347 gtk_entry_set_text(GTK_ENTRY(ge->eta); 1348 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr); 1349 free(tr); 1350 free(mr); 1351 } else if (je->m_iops || je->t_iops) 1352 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops); 1353 1354 gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_bw), "---"); 1355 gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_iops), "---"); 1356 gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_bw), "---"); 1357 gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_iops), "---"); 1358#endif 1359 1360 if (je->eta_sec != INT_MAX && je->nr_running) { 1361 char *iops_str[2]; 1362 char *rate_str[2]; 1363 1364 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running) 1365 strcpy(output, "-.-% done"); 1366 else { 1367 eta_good = 1; 1368 perc *= 100.0; 1369 sprintf(output, "%3.1f%% done", perc); 1370 } 1371 1372 rate_str[0] = num2str(je->rate[0], 5, 10, i2p); 1373 rate_str[1] = num2str(je->rate[1], 5, 10, i2p); 1374 1375 iops_str[0] = num2str(je->iops[0], 4, 1, 0); 1376 iops_str[1] = num2str(je->iops[1], 4, 1, 0); 1377 1378 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), rate_str[0]); 1379 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), iops_str[0]); 1380 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), rate_str[1]); 1381 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), iops_str[1]); 1382 1383 graph_add_xy_data(ge->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0], iops_str[0]); 1384 graph_add_xy_data(ge->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1], iops_str[1]); 1385 graph_add_xy_data(ge->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0], rate_str[0]); 1386 graph_add_xy_data(ge->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1], rate_str[1]); 1387 1388 free(rate_str[0]); 1389 free(rate_str[1]); 1390 free(iops_str[0]); 1391 free(iops_str[1]); 1392 } 1393 1394 if (eta_str[0]) { 1395 char *dst = output + strlen(output); 1396 1397 sprintf(dst, " - %s", eta_str); 1398 } 1399 1400 gfio_update_thread_status(ge, output, perc); 1401 gdk_threads_leave(); 1402} 1403 1404/* 1405 * Update ETA in main window for all clients 1406 */ 1407static void gfio_update_all_eta(struct jobs_eta *je) 1408{ 1409 struct gui *ui = &main_ui; 1410 static int eta_good; 1411 char eta_str[128]; 1412 char output[256]; 1413 double perc = 0.0; 1414 int i2p = 0; 1415 1416 gdk_threads_enter(); 1417 1418 eta_str[0] = '\0'; 1419 output[0] = '\0'; 1420 1421 if (je->eta_sec != INT_MAX && je->elapsed_sec) { 1422 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec); 1423 eta_to_str(eta_str, je->eta_sec); 1424 } 1425 1426#if 0 1427 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) { 1428 if (je->m_rate || je->t_rate) { 1429 char *tr, *mr; 1430 1431 mr = num2str(je->m_rate, 4, 0, i2p); 1432 tr = num2str(je->t_rate, 4, 0, i2p); 1433 gtk_entry_set_text(GTK_ENTRY(ui->eta); 1434 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr); 1435 free(tr); 1436 free(mr); 1437 } else if (je->m_iops || je->t_iops) 1438 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops); 1439 1440 gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_bw), "---"); 1441 gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_iops), "---"); 1442 gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_bw), "---"); 1443 gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_iops), "---"); 1444#endif 1445 1446 entry_set_int_value(ui->eta.jobs, je->nr_running); 1447 1448 if (je->eta_sec != INT_MAX && je->nr_running) { 1449 char *iops_str[2]; 1450 char *rate_str[2]; 1451 1452 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running) 1453 strcpy(output, "-.-% done"); 1454 else { 1455 eta_good = 1; 1456 perc *= 100.0; 1457 sprintf(output, "%3.1f%% done", perc); 1458 } 1459 1460 rate_str[0] = num2str(je->rate[0], 5, 10, i2p); 1461 rate_str[1] = num2str(je->rate[1], 5, 10, i2p); 1462 1463 iops_str[0] = num2str(je->iops[0], 4, 1, 0); 1464 iops_str[1] = num2str(je->iops[1], 4, 1, 0); 1465 1466 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), rate_str[0]); 1467 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), iops_str[0]); 1468 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), rate_str[1]); 1469 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), iops_str[1]); 1470 1471 graph_add_xy_data(ui->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0], iops_str[0]); 1472 graph_add_xy_data(ui->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1], iops_str[1]); 1473 graph_add_xy_data(ui->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0], rate_str[0]); 1474 graph_add_xy_data(ui->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1], rate_str[1]); 1475 1476 free(rate_str[0]); 1477 free(rate_str[1]); 1478 free(iops_str[0]); 1479 free(iops_str[1]); 1480 } 1481 1482 if (eta_str[0]) { 1483 char *dst = output + strlen(output); 1484 1485 sprintf(dst, " - %s", eta_str); 1486 } 1487 1488 gfio_update_thread_status_all(output, perc); 1489 gdk_threads_leave(); 1490} 1491 1492static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd) 1493{ 1494 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload; 1495 struct gfio_client *gc = client->client_data; 1496 struct gui_entry *ge = gc->ge; 1497 const char *os, *arch; 1498 char buf[64]; 1499 1500 os = fio_get_os_string(probe->os); 1501 if (!os) 1502 os = "unknown"; 1503 1504 arch = fio_get_arch_string(probe->arch); 1505 if (!arch) 1506 os = "unknown"; 1507 1508 if (!client->name) 1509 client->name = strdup((char *) probe->hostname); 1510 1511 gdk_threads_enter(); 1512 1513 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), (char *) probe->hostname); 1514 gtk_label_set_text(GTK_LABEL(ge->probe.os), os); 1515 gtk_label_set_text(GTK_LABEL(ge->probe.arch), arch); 1516 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch); 1517 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), buf); 1518 1519 gfio_set_state(ge, GE_STATE_CONNECTED); 1520 1521 gdk_threads_leave(); 1522} 1523 1524static void gfio_update_thread_status(struct gui_entry *ge, 1525 char *status_message, double perc) 1526{ 1527 static char message[100]; 1528 const char *m = message; 1529 1530 strncpy(message, status_message, sizeof(message) - 1); 1531 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), m); 1532 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), perc / 100.0); 1533 gtk_widget_queue_draw(main_ui.window); 1534} 1535 1536static void gfio_update_thread_status_all(char *status_message, double perc) 1537{ 1538 struct gui *ui = &main_ui; 1539 static char message[100]; 1540 const char *m = message; 1541 1542 strncpy(message, status_message, sizeof(message) - 1); 1543 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), m); 1544 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), perc / 100.0); 1545 gtk_widget_queue_draw(ui->window); 1546} 1547 1548static void gfio_quit_op(struct fio_client *client, struct fio_net_cmd *cmd) 1549{ 1550 struct gfio_client *gc = client->client_data; 1551 1552 gdk_threads_enter(); 1553 gfio_set_state(gc->ge, GE_STATE_NEW); 1554 gdk_threads_leave(); 1555} 1556 1557static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd) 1558{ 1559 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload; 1560 struct gfio_client *gc = client->client_data; 1561 struct thread_options *o = &gc->o; 1562 struct gui_entry *ge = gc->ge; 1563 char tmp[8]; 1564 1565 convert_thread_options_to_cpu(o, &p->top); 1566 1567 gdk_threads_enter(); 1568 1569 gtk_label_set_text(GTK_LABEL(ge->page_label), (gchar *) o->name); 1570 1571 gtk_combo_box_append_text(GTK_COMBO_BOX(ge->eta.names), (gchar *) o->name); 1572 gtk_combo_box_set_active(GTK_COMBO_BOX(ge->eta.names), 0); 1573 1574 multitext_add_entry(&ge->eta.iotype, ddir_str(o->td_ddir)); 1575 multitext_add_entry(&ge->eta.ioengine, (const char *) o->ioengine); 1576 1577 sprintf(tmp, "%u", o->iodepth); 1578 multitext_add_entry(&ge->eta.iodepth, tmp); 1579 1580 multitext_set_entry(&ge->eta.iotype, 0); 1581 multitext_set_entry(&ge->eta.ioengine, 0); 1582 multitext_set_entry(&ge->eta.iodepth, 0); 1583 1584 gc->job_added++; 1585 1586 gfio_set_state(ge, GE_STATE_JOB_SENT); 1587 1588 gdk_threads_leave(); 1589} 1590 1591static void gfio_client_timed_out(struct fio_client *client) 1592{ 1593 struct gfio_client *gc = client->client_data; 1594 char buf[256]; 1595 1596 gdk_threads_enter(); 1597 1598 gfio_set_state(gc->ge, GE_STATE_NEW); 1599 clear_ge_ui_info(gc->ge); 1600 1601 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname); 1602 show_info_dialog(gc->ge->ui, "Network timeout", buf); 1603 1604 gdk_threads_leave(); 1605} 1606 1607static void gfio_client_stop(struct fio_client *client, struct fio_net_cmd *cmd) 1608{ 1609 struct gfio_client *gc = client->client_data; 1610 1611 gdk_threads_enter(); 1612 1613 gfio_set_state(gc->ge, GE_STATE_JOB_DONE); 1614 1615 if (gc->err_entry) 1616 entry_set_int_value(gc->err_entry, client->error); 1617 1618 gdk_threads_leave(); 1619} 1620 1621static void gfio_client_start(struct fio_client *client, struct fio_net_cmd *cmd) 1622{ 1623 struct gfio_client *gc = client->client_data; 1624 1625 gdk_threads_enter(); 1626 gfio_set_state(gc->ge, GE_STATE_JOB_STARTED); 1627 gdk_threads_leave(); 1628} 1629 1630static void gfio_client_job_start(struct fio_client *client, struct fio_net_cmd *cmd) 1631{ 1632 struct gfio_client *gc = client->client_data; 1633 1634 gdk_threads_enter(); 1635 gfio_set_state(gc->ge, GE_STATE_JOB_RUNNING); 1636 gdk_threads_leave(); 1637} 1638 1639static void gfio_client_iolog(struct fio_client *client, struct cmd_iolog_pdu *pdu) 1640{ 1641 free(pdu); 1642} 1643 1644struct client_ops gfio_client_ops = { 1645 .text = gfio_text_op, 1646 .disk_util = gfio_disk_util_op, 1647 .thread_status = gfio_thread_status_op, 1648 .group_stats = gfio_group_stats_op, 1649 .jobs_eta = gfio_update_client_eta, 1650 .eta = gfio_update_all_eta, 1651 .probe = gfio_probe_op, 1652 .quit = gfio_quit_op, 1653 .add_job = gfio_add_job_op, 1654 .timed_out = gfio_client_timed_out, 1655 .stop = gfio_client_stop, 1656 .start = gfio_client_start, 1657 .job_start = gfio_client_job_start, 1658 .iolog = gfio_client_iolog, 1659 .eta_msec = FIO_CLIENT_DEF_ETA_MSEC, 1660 .stay_connected = 1, 1661 .client_type = FIO_CLIENT_TYPE_GUI, 1662}; 1663 1664/* 1665 * FIXME: need more handling here 1666 */ 1667static void ge_destroy(struct gui_entry *ge) 1668{ 1669 struct gfio_client *gc = ge->client; 1670 1671 if (gc && gc->client) { 1672 if (ge->state >= GE_STATE_CONNECTED) 1673 fio_client_terminate(gc->client); 1674 1675 fio_put_client(gc->client); 1676 } 1677 1678 flist_del(&ge->list); 1679 free(ge); 1680} 1681 1682static void ge_widget_destroy(GtkWidget *w, gpointer data) 1683{ 1684 struct gui_entry *ge = data; 1685 1686 ge_destroy(ge); 1687} 1688 1689static void gfio_quit(struct gui *ui) 1690{ 1691 struct gui_entry *ge; 1692 1693 while (!flist_empty(&ui->list)) { 1694 ge = flist_entry(ui->list.next, struct gui_entry, list); 1695 ge_destroy(ge); 1696 } 1697 1698 gtk_main_quit(); 1699} 1700 1701static void quit_clicked(__attribute__((unused)) GtkWidget *widget, 1702 __attribute__((unused)) gpointer data) 1703{ 1704 gfio_quit(data); 1705} 1706 1707static void *job_thread(void *arg) 1708{ 1709 struct gui *ui = arg; 1710 1711 ui->handler_running = 1; 1712 fio_handle_clients(&gfio_client_ops); 1713 ui->handler_running = 0; 1714 return NULL; 1715} 1716 1717static int send_job_files(struct gui_entry *ge) 1718{ 1719 struct gfio_client *gc = ge->client; 1720 int i, ret = 0; 1721 1722 for (i = 0; i < ge->nr_job_files; i++) { 1723 ret = fio_client_send_ini(gc->client, ge->job_files[i]); 1724 if (ret < 0) { 1725 GError *error; 1726 1727 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to send file %s: %s\n", ge->job_files[i], strerror(-ret)); 1728 report_error(error); 1729 g_error_free(error); 1730 break; 1731 } else if (ret) 1732 break; 1733 1734 free(ge->job_files[i]); 1735 ge->job_files[i] = NULL; 1736 } 1737 while (i < ge->nr_job_files) { 1738 free(ge->job_files[i]); 1739 ge->job_files[i] = NULL; 1740 i++; 1741 } 1742 1743 free(ge->job_files); 1744 ge->job_files = NULL; 1745 ge->nr_job_files = 0; 1746 return ret; 1747} 1748 1749static void *server_thread(void *arg) 1750{ 1751 is_backend = 1; 1752 gfio_server_running = 1; 1753 fio_start_server(NULL); 1754 gfio_server_running = 0; 1755 return NULL; 1756} 1757 1758static void gfio_start_server(void) 1759{ 1760 struct gui *ui = &main_ui; 1761 1762 if (!gfio_server_running) { 1763 gfio_server_running = 1; 1764 pthread_create(&ui->server_t, NULL, server_thread, NULL); 1765 pthread_detach(ui->server_t); 1766 } 1767} 1768 1769static void start_job_clicked(__attribute__((unused)) GtkWidget *widget, 1770 gpointer data) 1771{ 1772 struct gui_entry *ge = data; 1773 struct gfio_client *gc = ge->client; 1774 1775 if (gc) 1776 fio_start_client(gc->client); 1777} 1778 1779static void file_open(GtkWidget *w, gpointer data); 1780 1781static void connect_clicked(GtkWidget *widget, gpointer data) 1782{ 1783 struct gui_entry *ge = data; 1784 struct gfio_client *gc = ge->client; 1785 1786 if (ge->state == GE_STATE_NEW) { 1787 int ret; 1788 1789 if (!ge->nr_job_files) 1790 file_open(widget, ge->ui); 1791 if (!ge->nr_job_files) 1792 return; 1793 1794 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No jobs running"); 1795 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0); 1796 ret = fio_client_connect(gc->client); 1797 if (!ret) { 1798 if (!ge->ui->handler_running) 1799 pthread_create(&ge->ui->t, NULL, job_thread, ge->ui); 1800 gfio_set_state(ge, GE_STATE_CONNECTED); 1801 } else { 1802 GError *error; 1803 1804 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to connect to %s: %s\n", ge->client->client->hostname, strerror(-ret)); 1805 report_error(error); 1806 g_error_free(error); 1807 } 1808 } else { 1809 fio_client_terminate(gc->client); 1810 gfio_set_state(ge, GE_STATE_NEW); 1811 clear_ge_ui_info(ge); 1812 } 1813} 1814 1815static void send_clicked(GtkWidget *widget, gpointer data) 1816{ 1817 struct gui_entry *ge = data; 1818 1819 if (send_job_files(ge)) { 1820 GError *error; 1821 1822 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to send one or more job files for client %s", ge->client->client->hostname); 1823 report_error(error); 1824 g_error_free(error); 1825 1826 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 1); 1827 } 1828} 1829 1830static GtkWidget *add_button(GtkWidget *buttonbox, 1831 struct button_spec *buttonspec, gpointer data) 1832{ 1833 GtkWidget *button = gtk_button_new_with_label(buttonspec->buttontext); 1834 1835 g_signal_connect(button, "clicked", G_CALLBACK(buttonspec->f), data); 1836 gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 3); 1837 gtk_widget_set_tooltip_text(button, buttonspec->tooltiptext); 1838 gtk_widget_set_sensitive(button, !buttonspec->start_insensitive); 1839 1840 return button; 1841} 1842 1843static void add_buttons(struct gui_entry *ge, struct button_spec *buttonlist, 1844 int nbuttons) 1845{ 1846 int i; 1847 1848 for (i = 0; i < nbuttons; i++) 1849 ge->button[i] = add_button(ge->buttonbox, &buttonlist[i], ge); 1850} 1851 1852static void on_info_bar_response(GtkWidget *widget, gint response, 1853 gpointer data) 1854{ 1855 struct gui *ui = &main_ui; 1856 1857 if (response == GTK_RESPONSE_OK) { 1858 gtk_widget_destroy(widget); 1859 ui->error_info_bar = NULL; 1860 } 1861} 1862 1863void report_error(GError *error) 1864{ 1865 struct gui *ui = &main_ui; 1866 1867 if (ui->error_info_bar == NULL) { 1868 ui->error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK, 1869 GTK_RESPONSE_OK, 1870 NULL); 1871 g_signal_connect(ui->error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL); 1872 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui->error_info_bar), 1873 GTK_MESSAGE_ERROR); 1874 1875 ui->error_label = gtk_label_new(error->message); 1876 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui->error_info_bar)); 1877 gtk_container_add(GTK_CONTAINER(container), ui->error_label); 1878 1879 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->error_info_bar, FALSE, FALSE, 0); 1880 gtk_widget_show_all(ui->vbox); 1881 } else { 1882 char buffer[256]; 1883 snprintf(buffer, sizeof(buffer), "Failed to open file."); 1884 gtk_label_set(GTK_LABEL(ui->error_label), buffer); 1885 } 1886} 1887 1888struct connection_widgets 1889{ 1890 GtkWidget *hentry; 1891 GtkWidget *combo; 1892 GtkWidget *button; 1893}; 1894 1895static void hostname_cb(GtkEntry *entry, gpointer data) 1896{ 1897 struct connection_widgets *cw = data; 1898 int uses_net = 0, is_localhost = 0; 1899 const gchar *text; 1900 gchar *ctext; 1901 1902 /* 1903 * Check whether to display the 'auto start backend' box 1904 * or not. Show it if we are a localhost and using network, 1905 * or using a socket. 1906 */ 1907 ctext = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw->combo)); 1908 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4)) 1909 uses_net = 1; 1910 g_free(ctext); 1911 1912 if (uses_net) { 1913 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry)); 1914 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") || 1915 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") || 1916 !strcmp(text, "ip6-loopback")) 1917 is_localhost = 1; 1918 } 1919 1920 if (!uses_net || is_localhost) { 1921 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1); 1922 gtk_widget_set_sensitive(cw->button, 1); 1923 } else { 1924 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0); 1925 gtk_widget_set_sensitive(cw->button, 0); 1926 } 1927} 1928 1929static int get_connection_details(char **host, int *port, int *type, 1930 int *server_start) 1931{ 1932 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry; 1933 struct connection_widgets cw; 1934 char *typeentry; 1935 1936 dialog = gtk_dialog_new_with_buttons("Connection details", 1937 GTK_WINDOW(main_ui.window), 1938 GTK_DIALOG_DESTROY_WITH_PARENT, 1939 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, 1940 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); 1941 1942 frame = gtk_frame_new("Hostname / socket name"); 1943 /* gtk_dialog_get_content_area() is 2.14 and newer */ 1944 vbox = GTK_DIALOG(dialog)->vbox; 1945 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 1946 1947 box = gtk_vbox_new(FALSE, 6); 1948 gtk_container_add(GTK_CONTAINER(frame), box); 1949 1950 hbox = gtk_hbox_new(TRUE, 10); 1951 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0); 1952 cw.hentry = gtk_entry_new(); 1953 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost"); 1954 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0); 1955 1956 frame = gtk_frame_new("Port"); 1957 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 1958 box = gtk_vbox_new(FALSE, 10); 1959 gtk_container_add(GTK_CONTAINER(frame), box); 1960 1961 hbox = gtk_hbox_new(TRUE, 4); 1962 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0); 1963 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT); 1964 1965 frame = gtk_frame_new("Type"); 1966 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 1967 box = gtk_vbox_new(FALSE, 10); 1968 gtk_container_add(GTK_CONTAINER(frame), box); 1969 1970 hbox = gtk_hbox_new(TRUE, 4); 1971 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0); 1972 1973 cw.combo = gtk_combo_box_new_text(); 1974 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv4"); 1975 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv6"); 1976 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "local socket"); 1977 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0); 1978 1979 gtk_container_add(GTK_CONTAINER(hbox), cw.combo); 1980 1981 frame = gtk_frame_new("Options"); 1982 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 1983 box = gtk_vbox_new(FALSE, 10); 1984 gtk_container_add(GTK_CONTAINER(frame), box); 1985 1986 hbox = gtk_hbox_new(TRUE, 4); 1987 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0); 1988 1989 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend"); 1990 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1); 1991 gtk_widget_set_tooltip_text(cw.button, "When running fio locally, it is necessary to have the backend running on the same system. If this is checked, gfio will start the backend automatically for you if it isn't already running."); 1992 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6); 1993 1994 /* 1995 * Connect edit signal, so we can show/not-show the auto start button 1996 */ 1997 g_signal_connect(GTK_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw); 1998 g_signal_connect(GTK_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw); 1999 2000 gtk_widget_show_all(dialog); 2001 2002 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) { 2003 gtk_widget_destroy(dialog); 2004 return 1; 2005 } 2006 2007 *host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry))); 2008 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry)); 2009 2010 typeentry = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw.combo)); 2011 if (!typeentry || !strncmp(typeentry, "IPv4", 4)) 2012 *type = Fio_client_ipv4; 2013 else if (!strncmp(typeentry, "IPv6", 4)) 2014 *type = Fio_client_ipv6; 2015 else 2016 *type = Fio_client_socket; 2017 g_free(typeentry); 2018 2019 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button)); 2020 2021 gtk_widget_destroy(dialog); 2022 return 0; 2023} 2024 2025static void gfio_client_added(struct gui_entry *ge, struct fio_client *client) 2026{ 2027 struct gfio_client *gc; 2028 2029 gc = malloc(sizeof(*gc)); 2030 memset(gc, 0, sizeof(*gc)); 2031 gc->ge = ge; 2032 gc->client = fio_get_client(client); 2033 2034 ge->client = gc; 2035 2036 client->client_data = gc; 2037} 2038 2039static GtkWidget *new_client_page(struct gui_entry *ge); 2040 2041static struct gui_entry *alloc_new_gui_entry(struct gui *ui) 2042{ 2043 struct gui_entry *ge; 2044 2045 ge = malloc(sizeof(*ge)); 2046 memset(ge, 0, sizeof(*ge)); 2047 ge->state = GE_STATE_NEW; 2048 INIT_FLIST_HEAD(&ge->list); 2049 flist_add_tail(&ge->list, &ui->list); 2050 ge->ui = ui; 2051 return ge; 2052} 2053 2054static struct gui_entry *get_new_ge_with_tab(const char *name) 2055{ 2056 struct gui_entry *ge; 2057 2058 ge = alloc_new_gui_entry(&main_ui); 2059 2060 ge->vbox = new_client_page(ge); 2061 g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_widget_destroy), ge); 2062 2063 ge->page_label = gtk_label_new(name); 2064 ge->page_num = gtk_notebook_append_page(GTK_NOTEBOOK(main_ui.notebook), ge->vbox, ge->page_label); 2065 2066 gtk_widget_show_all(main_ui.window); 2067 return ge; 2068} 2069 2070static void file_new(GtkWidget *w, gpointer data) 2071{ 2072 struct gui *ui = (struct gui *) data; 2073 struct gui_entry *ge; 2074 2075 ge = get_new_ge_with_tab("Untitled"); 2076 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num); 2077} 2078 2079/* 2080 * Return the 'ge' corresponding to the tab. If the active tab is the 2081 * main tab, open a new tab. 2082 */ 2083static struct gui_entry *get_ge_from_page(gint cur_page, int *created) 2084{ 2085 struct flist_head *entry; 2086 struct gui_entry *ge; 2087 2088 if (!cur_page) { 2089 if (created) 2090 *created = 1; 2091 return get_new_ge_with_tab("Untitled"); 2092 } 2093 2094 if (created) 2095 *created = 0; 2096 2097 flist_for_each(entry, &main_ui.list) { 2098 ge = flist_entry(entry, struct gui_entry, list); 2099 if (ge->page_num == cur_page) 2100 return ge; 2101 } 2102 2103 return NULL; 2104} 2105 2106static struct gui_entry *get_ge_from_cur_tab(struct gui *ui) 2107{ 2108 gint cur_page; 2109 2110 /* 2111 * Main tab is tab 0, so any current page other than 0 holds 2112 * a ge entry. 2113 */ 2114 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook)); 2115 if (cur_page) 2116 return get_ge_from_page(cur_page, NULL); 2117 2118 return NULL; 2119} 2120 2121static void file_close(GtkWidget *w, gpointer data) 2122{ 2123 struct gui *ui = (struct gui *) data; 2124 struct gui_entry *ge; 2125 2126 /* 2127 * Can't close the main tab 2128 */ 2129 ge = get_ge_from_cur_tab(ui); 2130 if (ge) { 2131 gtk_widget_destroy(ge->vbox); 2132 return; 2133 } 2134 2135 if (!flist_empty(&ui->list)) { 2136 show_info_dialog(ui, "Error", "The main page view cannot be closed\n"); 2137 return; 2138 } 2139 2140 gfio_quit(ui); 2141} 2142 2143static void file_add_recent(struct gui *ui, const gchar *uri) 2144{ 2145 GtkRecentData grd; 2146 2147 memset(&grd, 0, sizeof(grd)); 2148 grd.display_name = strdup("gfio"); 2149 grd.description = strdup("Fio job file"); 2150 grd.mime_type = strdup(GFIO_MIME); 2151 grd.app_name = strdup(g_get_application_name()); 2152 grd.app_exec = strdup("gfio %f/%u"); 2153 2154 gtk_recent_manager_add_full(ui->recentmanager, uri, &grd); 2155} 2156 2157static gchar *get_filename_from_uri(const gchar *uri) 2158{ 2159 if (strncmp(uri, "file://", 7)) 2160 return strdup(uri); 2161 2162 return strdup(uri + 7); 2163} 2164 2165static int do_file_open(struct gui_entry *ge, const gchar *uri, char *host, 2166 int type, int port) 2167{ 2168 struct fio_client *client; 2169 gchar *filename; 2170 2171 filename = get_filename_from_uri(uri); 2172 2173 ge->job_files = realloc(ge->job_files, (ge->nr_job_files + 1) * sizeof(char *)); 2174 ge->job_files[ge->nr_job_files] = strdup(filename); 2175 ge->nr_job_files++; 2176 2177 client = fio_client_add_explicit(&gfio_client_ops, host, type, port); 2178 if (!client) { 2179 GError *error; 2180 2181 error = g_error_new(g_quark_from_string("fio"), 1, 2182 "Failed to add client %s", host); 2183 report_error(error); 2184 g_error_free(error); 2185 return 1; 2186 } 2187 2188 gfio_client_added(ge, client); 2189 file_add_recent(ge->ui, uri); 2190 return 0; 2191} 2192 2193static int do_file_open_with_tab(struct gui *ui, const gchar *uri) 2194{ 2195 int port, type, server_start; 2196 struct gui_entry *ge; 2197 gint cur_page; 2198 char *host; 2199 int ret, ge_is_new = 0; 2200 2201 /* 2202 * Creates new tab if current tab is the main window, or the 2203 * current tab already has a client. 2204 */ 2205 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook)); 2206 ge = get_ge_from_page(cur_page, &ge_is_new); 2207 if (ge->client) { 2208 ge = get_new_ge_with_tab("Untitled"); 2209 ge_is_new = 1; 2210 } 2211 2212 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num); 2213 2214 if (get_connection_details(&host, &port, &type, &server_start)) { 2215 if (ge_is_new) 2216 gtk_widget_destroy(ge->vbox); 2217 2218 return 1; 2219 } 2220 2221 ret = do_file_open(ge, uri, host, type, port); 2222 2223 free(host); 2224 2225 if (!ret) { 2226 if (server_start) 2227 gfio_start_server(); 2228 } else { 2229 if (ge_is_new) 2230 gtk_widget_destroy(ge->vbox); 2231 } 2232 2233 return ret; 2234} 2235 2236static void recent_open(GtkAction *action, gpointer data) 2237{ 2238 struct gui *ui = (struct gui *) data; 2239 GtkRecentInfo *info; 2240 const gchar *uri; 2241 2242 info = g_object_get_data(G_OBJECT(action), "gtk-recent-info"); 2243 uri = gtk_recent_info_get_uri(info); 2244 2245 do_file_open_with_tab(ui, uri); 2246} 2247 2248static void file_open(GtkWidget *w, gpointer data) 2249{ 2250 struct gui *ui = data; 2251 GtkWidget *dialog; 2252 GSList *filenames, *fn_glist; 2253 GtkFileFilter *filter; 2254 2255 dialog = gtk_file_chooser_dialog_new("Open File", 2256 GTK_WINDOW(ui->window), 2257 GTK_FILE_CHOOSER_ACTION_OPEN, 2258 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 2259 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, 2260 NULL); 2261 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE); 2262 2263 filter = gtk_file_filter_new(); 2264 gtk_file_filter_add_pattern(filter, "*.fio"); 2265 gtk_file_filter_add_pattern(filter, "*.job"); 2266 gtk_file_filter_add_pattern(filter, "*.ini"); 2267 gtk_file_filter_add_mime_type(filter, GFIO_MIME); 2268 gtk_file_filter_set_name(filter, "Fio job file"); 2269 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); 2270 2271 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) { 2272 gtk_widget_destroy(dialog); 2273 return; 2274 } 2275 2276 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog)); 2277 2278 gtk_widget_destroy(dialog); 2279 2280 filenames = fn_glist; 2281 while (filenames != NULL) { 2282 if (do_file_open_with_tab(ui, filenames->data)) 2283 break; 2284 filenames = g_slist_next(filenames); 2285 } 2286 2287 g_slist_free(fn_glist); 2288} 2289 2290static void file_save(GtkWidget *w, gpointer data) 2291{ 2292 struct gui *ui = data; 2293 GtkWidget *dialog; 2294 2295 dialog = gtk_file_chooser_dialog_new("Save File", 2296 GTK_WINDOW(ui->window), 2297 GTK_FILE_CHOOSER_ACTION_SAVE, 2298 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 2299 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, 2300 NULL); 2301 2302 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE); 2303 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document"); 2304 2305 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { 2306 char *filename; 2307 2308 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); 2309 // save_job_file(filename); 2310 g_free(filename); 2311 } 2312 gtk_widget_destroy(dialog); 2313} 2314 2315static void view_log_destroy(GtkWidget *w, gpointer data) 2316{ 2317 struct gui *ui = (struct gui *) data; 2318 2319 gtk_widget_ref(ui->log_tree); 2320 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree); 2321 gtk_widget_destroy(w); 2322 ui->log_view = NULL; 2323} 2324 2325static void view_log(GtkWidget *w, gpointer data) 2326{ 2327 GtkWidget *win, *scroll, *vbox, *box; 2328 struct gui *ui = (struct gui *) data; 2329 2330 if (ui->log_view) 2331 return; 2332 2333 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL); 2334 gtk_window_set_title(GTK_WINDOW(win), "Log"); 2335 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500); 2336 2337 scroll = gtk_scrolled_window_new(NULL, NULL); 2338 2339 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5); 2340 2341 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 2342 2343 box = gtk_hbox_new(TRUE, 0); 2344 gtk_box_pack_start_defaults(GTK_BOX(box), ui->log_tree); 2345 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui); 2346 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box); 2347 2348 vbox = gtk_vbox_new(TRUE, 5); 2349 gtk_box_pack_start_defaults(GTK_BOX(vbox), scroll); 2350 2351 gtk_container_add(GTK_CONTAINER(win), vbox); 2352 gtk_widget_show_all(win); 2353} 2354 2355static void connect_job_entry(GtkWidget *w, gpointer data) 2356{ 2357 struct gui *ui = (struct gui *) data; 2358 struct gui_entry *ge; 2359 2360 ge = get_ge_from_cur_tab(ui); 2361 if (ge) 2362 connect_clicked(w, ge); 2363} 2364 2365static void send_job_entry(GtkWidget *w, gpointer data) 2366{ 2367 struct gui *ui = (struct gui *) data; 2368 struct gui_entry *ge; 2369 2370 ge = get_ge_from_cur_tab(ui); 2371 if (ge) 2372 send_clicked(w, ge); 2373 2374} 2375 2376static void edit_job_entry(GtkWidget *w, gpointer data) 2377{ 2378} 2379 2380static void start_job_entry(GtkWidget *w, gpointer data) 2381{ 2382 struct gui *ui = (struct gui *) data; 2383 struct gui_entry *ge; 2384 2385 ge = get_ge_from_cur_tab(ui); 2386 if (ge) 2387 start_job_clicked(w, ge); 2388} 2389 2390static void __update_graph_limits(struct gfio_graphs *g) 2391{ 2392 line_graph_set_data_count_limit(g->iops_graph, gfio_graph_limit); 2393 line_graph_set_data_count_limit(g->bandwidth_graph, gfio_graph_limit); 2394} 2395 2396static void update_graph_limits(void) 2397{ 2398 struct flist_head *entry; 2399 struct gui_entry *ge; 2400 2401 __update_graph_limits(&main_ui.graphs); 2402 2403 flist_for_each(entry, &main_ui.list) { 2404 ge = flist_entry(entry, struct gui_entry, list); 2405 __update_graph_limits(&ge->graphs); 2406 } 2407} 2408 2409static void preferences(GtkWidget *w, gpointer data) 2410{ 2411 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font; 2412 GtkWidget *hbox, *spin, *entry, *spin_int; 2413 int i; 2414 2415 dialog = gtk_dialog_new_with_buttons("Preferences", 2416 GTK_WINDOW(main_ui.window), 2417 GTK_DIALOG_DESTROY_WITH_PARENT, 2418 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, 2419 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, 2420 NULL); 2421 2422 frame = gtk_frame_new("Graphing"); 2423 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5); 2424 vbox = gtk_vbox_new(FALSE, 6); 2425 gtk_container_add(GTK_CONTAINER(frame), vbox); 2426 2427 hbox = gtk_hbox_new(FALSE, 5); 2428 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); 2429 entry = gtk_label_new("Font face to use for graph labels"); 2430 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5); 2431 2432 font = gtk_font_button_new(); 2433 gtk_box_pack_start(GTK_BOX(hbox), font, FALSE, FALSE, 5); 2434 2435 box = gtk_vbox_new(FALSE, 6); 2436 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5); 2437 2438 hbox = gtk_hbox_new(FALSE, 5); 2439 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5); 2440 entry = gtk_label_new("Maximum number of data points in graph (seconds)"); 2441 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5); 2442 2443 spin = create_spinbutton(hbox, 10, 1000000, gfio_graph_limit); 2444 2445 box = gtk_vbox_new(FALSE, 6); 2446 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5); 2447 2448 hbox = gtk_hbox_new(FALSE, 5); 2449 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5); 2450 entry = gtk_label_new("Client ETA request interval (msec)"); 2451 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5); 2452 2453 spin_int = create_spinbutton(hbox, 100, 100000, gfio_client_ops.eta_msec); 2454 frame = gtk_frame_new("Debug logging"); 2455 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5); 2456 vbox = gtk_vbox_new(FALSE, 6); 2457 gtk_container_add(GTK_CONTAINER(frame), vbox); 2458 2459 box = gtk_hbox_new(FALSE, 6); 2460 gtk_container_add(GTK_CONTAINER(vbox), box); 2461 2462 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX); 2463 2464 for (i = 0; i < FD_DEBUG_MAX; i++) { 2465 if (i == 7) { 2466 box = gtk_hbox_new(FALSE, 6); 2467 gtk_container_add(GTK_CONTAINER(vbox), box); 2468 } 2469 2470 2471 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name); 2472 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help); 2473 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6); 2474 } 2475 2476 gtk_widget_show_all(dialog); 2477 2478 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) { 2479 gtk_widget_destroy(dialog); 2480 return; 2481 } 2482 2483 for (i = 0; i < FD_DEBUG_MAX; i++) { 2484 int set; 2485 2486 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i])); 2487 if (set) 2488 fio_debug |= (1UL << i); 2489 } 2490 2491 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font))); 2492 gfio_graph_limit = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin)); 2493 update_graph_limits(); 2494 gfio_client_ops.eta_msec = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin_int)); 2495 2496 gtk_widget_destroy(dialog); 2497} 2498 2499static void about_dialog(GtkWidget *w, gpointer data) 2500{ 2501 const char *authors[] = { 2502 "Jens Axboe <axboe@kernel.dk>", 2503 "Stephen Carmeron <stephenmcameron@gmail.com>", 2504 NULL 2505 }; 2506 const char *license[] = { 2507 "Fio is free software; you can redistribute it and/or modify " 2508 "it under the terms of the GNU General Public License as published by " 2509 "the Free Software Foundation; either version 2 of the License, or " 2510 "(at your option) any later version.\n", 2511 "Fio is distributed in the hope that it will be useful, " 2512 "but WITHOUT ANY WARRANTY; without even the implied warranty of " 2513 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the " 2514 "GNU General Public License for more details.\n", 2515 "You should have received a copy of the GNU General Public License " 2516 "along with Fio; if not, write to the Free Software Foundation, Inc., " 2517 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n" 2518 }; 2519 char *license_trans; 2520 2521 license_trans = g_strconcat(license[0], "\n", license[1], "\n", 2522 license[2], "\n", NULL); 2523 2524 gtk_show_about_dialog(NULL, 2525 "program-name", "gfio", 2526 "comments", "Gtk2 UI for fio", 2527 "license", license_trans, 2528 "website", "http://git.kernel.dk/?p=fio.git;a=summary", 2529 "authors", authors, 2530 "version", fio_version_string, 2531 "copyright", "© 2012 Jens Axboe <axboe@kernel.dk>", 2532 "logo-icon-name", "fio", 2533 /* Must be last: */ 2534 "wrap-license", TRUE, 2535 NULL); 2536 2537 g_free(license_trans); 2538} 2539 2540static GtkActionEntry menu_items[] = { 2541 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL}, 2542 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL}, 2543 { "JobMenuAction", GTK_STOCK_FILE, "Job", NULL, NULL, NULL}, 2544 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL}, 2545 { "NewFile", GTK_STOCK_NEW, "New", "<Control>N", NULL, G_CALLBACK(file_new) }, 2546 { "CloseFile", GTK_STOCK_CLOSE, "Close", "<Control>W", NULL, G_CALLBACK(file_close) }, 2547 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) }, 2548 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) }, 2549 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) }, 2550 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) }, 2551 { "ConnectJob", NULL, "Connect", "<Control>E", NULL, G_CALLBACK(connect_job_entry) }, 2552 { "EditJob", NULL, "Edit job", "<Control>E", NULL, G_CALLBACK(edit_job_entry) }, 2553 { "SendJob", NULL, "Send job", "<Control>X", NULL, G_CALLBACK(send_job_entry) }, 2554 { "StartJob", NULL, "Start job", "<Control>L", NULL, G_CALLBACK(start_job_entry) }, 2555 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) }, 2556 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) }, 2557}; 2558static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]); 2559 2560static const gchar *ui_string = " \ 2561 <ui> \ 2562 <menubar name=\"MainMenu\"> \ 2563 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \ 2564 <menuitem name=\"New\" action=\"NewFile\" /> \ 2565 <menuitem name=\"Close\" action=\"CloseFile\" /> \ 2566 <separator name=\"Separator1\"/> \ 2567 <menuitem name=\"Open\" action=\"OpenFile\" /> \ 2568 <menuitem name=\"Save\" action=\"SaveFile\" /> \ 2569 <separator name=\"Separator2\"/> \ 2570 <menuitem name=\"Preferences\" action=\"Preferences\" /> \ 2571 <separator name=\"Separator3\"/> \ 2572 <placeholder name=\"FileRecentFiles\"/> \ 2573 <separator name=\"Separator4\"/> \ 2574 <menuitem name=\"Quit\" action=\"Quit\" /> \ 2575 </menu> \ 2576 <menu name=\"JobMenu\" action=\"JobMenuAction\"> \ 2577 <menuitem name=\"Connect\" action=\"ConnectJob\" /> \ 2578 <separator name=\"Separator5\"/> \ 2579 <menuitem name=\"Edit job\" action=\"EditJob\" /> \ 2580 <menuitem name=\"Send job\" action=\"SendJob\" /> \ 2581 <separator name=\"Separator6\"/> \ 2582 <menuitem name=\"Start job\" action=\"StartJob\" /> \ 2583 </menu>\ 2584 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \ 2585 <menuitem name=\"Log\" action=\"ViewLog\" /> \ 2586 </menu>\ 2587 <menu name=\"Help\" action=\"HelpMenuAction\"> \ 2588 <menuitem name=\"About\" action=\"About\" /> \ 2589 </menu> \ 2590 </menubar> \ 2591 </ui> \ 2592"; 2593 2594static void set_job_menu_visible(struct gui *ui, int visible) 2595{ 2596 GtkWidget *job; 2597 2598 job = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu"); 2599 gtk_widget_set_sensitive(job, visible); 2600} 2601 2602static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager, 2603 struct gui *ui) 2604{ 2605 GtkActionGroup *action_group = gtk_action_group_new("Menu"); 2606 GError *error = 0; 2607 2608 action_group = gtk_action_group_new("Menu"); 2609 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui); 2610 2611 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); 2612 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error); 2613 2614 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager)); 2615 2616 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu"); 2617} 2618 2619void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar, 2620 GtkWidget *vbox, GtkUIManager *ui_manager) 2621{ 2622 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0); 2623} 2624 2625static void combo_entry_changed(GtkComboBox *box, gpointer data) 2626{ 2627 struct gui_entry *ge = (struct gui_entry *) data; 2628 gint index; 2629 2630 index = gtk_combo_box_get_active(box); 2631 2632 multitext_set_entry(&ge->eta.iotype, index); 2633 multitext_set_entry(&ge->eta.ioengine, index); 2634 multitext_set_entry(&ge->eta.iodepth, index); 2635} 2636 2637static void combo_entry_destroy(GtkWidget *widget, gpointer data) 2638{ 2639 struct gui_entry *ge = (struct gui_entry *) data; 2640 2641 multitext_free(&ge->eta.iotype); 2642 multitext_free(&ge->eta.ioengine); 2643 multitext_free(&ge->eta.iodepth); 2644} 2645 2646static GtkWidget *new_client_page(struct gui_entry *ge) 2647{ 2648 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box; 2649 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox; 2650 GdkColor white; 2651 2652 main_vbox = gtk_vbox_new(FALSE, 3); 2653 2654 top_align = gtk_alignment_new(0, 0, 1, 0); 2655 top_vbox = gtk_vbox_new(FALSE, 3); 2656 gtk_container_add(GTK_CONTAINER(top_align), top_vbox); 2657 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0); 2658 2659 probe = gtk_frame_new("Job"); 2660 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3); 2661 probe_frame = gtk_vbox_new(FALSE, 3); 2662 gtk_container_add(GTK_CONTAINER(probe), probe_frame); 2663 2664 probe_box = gtk_hbox_new(FALSE, 3); 2665 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3); 2666 ge->probe.hostname = new_info_label_in_frame(probe_box, "Host"); 2667 ge->probe.os = new_info_label_in_frame(probe_box, "OS"); 2668 ge->probe.arch = new_info_label_in_frame(probe_box, "Architecture"); 2669 ge->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version"); 2670 2671 probe_box = gtk_hbox_new(FALSE, 3); 2672 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3); 2673 2674 ge->eta.names = new_combo_entry_in_frame(probe_box, "Jobs"); 2675 g_signal_connect(ge->eta.names, "changed", G_CALLBACK(combo_entry_changed), ge); 2676 g_signal_connect(ge->eta.names, "destroy", G_CALLBACK(combo_entry_destroy), ge); 2677 ge->eta.iotype.entry = new_info_entry_in_frame(probe_box, "IO"); 2678 ge->eta.ioengine.entry = new_info_entry_in_frame(probe_box, "IO Engine"); 2679 ge->eta.iodepth.entry = new_info_entry_in_frame(probe_box, "IO Depth"); 2680 ge->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs"); 2681 ge->eta.files = new_info_entry_in_frame(probe_box, "Open files"); 2682 2683 probe_box = gtk_hbox_new(FALSE, 3); 2684 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3); 2685 ge->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW"); 2686 ge->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS"); 2687 ge->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW"); 2688 ge->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS"); 2689 2690 /* 2691 * Only add this if we have a commit rate 2692 */ 2693#if 0 2694 probe_box = gtk_hbox_new(FALSE, 3); 2695 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3); 2696 2697 ge->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW"); 2698 ge->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS"); 2699 2700 ge->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW"); 2701 ge->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS"); 2702#endif 2703 2704 /* 2705 * Set up a drawing area and IOPS and bandwidth graphs 2706 */ 2707 gdk_color_parse("white", &white); 2708 ge->graphs.drawing_area = gtk_drawing_area_new(); 2709 gtk_widget_set_size_request(GTK_WIDGET(ge->graphs.drawing_area), 2710 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM); 2711 gtk_widget_modify_bg(ge->graphs.drawing_area, GTK_STATE_NORMAL, &white); 2712 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "expose_event", 2713 G_CALLBACK(on_expose_drawing_area), &ge->graphs); 2714 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "configure_event", 2715 G_CALLBACK(on_config_drawing_area), &ge->graphs); 2716 scrolled_window = gtk_scrolled_window_new(NULL, NULL); 2717 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), 2718 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 2719 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), 2720 ge->graphs.drawing_area); 2721 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window, TRUE, TRUE, 0); 2722 2723 setup_graphs(&ge->graphs); 2724 2725 /* 2726 * Set up alignments for widgets at the bottom of ui, 2727 * align bottom left, expand horizontally but not vertically 2728 */ 2729 bottom_align = gtk_alignment_new(0, 1, 1, 0); 2730 ge->buttonbox = gtk_hbox_new(FALSE, 0); 2731 gtk_container_add(GTK_CONTAINER(bottom_align), ge->buttonbox); 2732 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0); 2733 2734 add_buttons(ge, buttonspeclist, ARRAYSIZE(buttonspeclist)); 2735 2736 /* 2737 * Set up thread status progress bar 2738 */ 2739 ge->thread_status_pb = gtk_progress_bar_new(); 2740 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0); 2741 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No connections"); 2742 gtk_container_add(GTK_CONTAINER(ge->buttonbox), ge->thread_status_pb); 2743 2744 2745 return main_vbox; 2746} 2747 2748static GtkWidget *new_main_page(struct gui *ui) 2749{ 2750 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box; 2751 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox; 2752 GdkColor white; 2753 2754 main_vbox = gtk_vbox_new(FALSE, 3); 2755 2756 /* 2757 * Set up alignments for widgets at the top of ui, 2758 * align top left, expand horizontally but not vertically 2759 */ 2760 top_align = gtk_alignment_new(0, 0, 1, 0); 2761 top_vbox = gtk_vbox_new(FALSE, 0); 2762 gtk_container_add(GTK_CONTAINER(top_align), top_vbox); 2763 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0); 2764 2765 probe = gtk_frame_new("Run statistics"); 2766 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3); 2767 probe_frame = gtk_vbox_new(FALSE, 3); 2768 gtk_container_add(GTK_CONTAINER(probe), probe_frame); 2769 2770 probe_box = gtk_hbox_new(FALSE, 3); 2771 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3); 2772 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Running"); 2773 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW"); 2774 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS"); 2775 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW"); 2776 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS"); 2777 2778 /* 2779 * Only add this if we have a commit rate 2780 */ 2781#if 0 2782 probe_box = gtk_hbox_new(FALSE, 3); 2783 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3); 2784 2785 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW"); 2786 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS"); 2787 2788 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW"); 2789 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS"); 2790#endif 2791 2792 /* 2793 * Set up a drawing area and IOPS and bandwidth graphs 2794 */ 2795 gdk_color_parse("white", &white); 2796 ui->graphs.drawing_area = gtk_drawing_area_new(); 2797 gtk_widget_set_size_request(GTK_WIDGET(ui->graphs.drawing_area), 2798 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM); 2799 gtk_widget_modify_bg(ui->graphs.drawing_area, GTK_STATE_NORMAL, &white); 2800 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "expose_event", 2801 G_CALLBACK(on_expose_drawing_area), &ui->graphs); 2802 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "configure_event", 2803 G_CALLBACK(on_config_drawing_area), &ui->graphs); 2804 scrolled_window = gtk_scrolled_window_new(NULL, NULL); 2805 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), 2806 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 2807 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), 2808 ui->graphs.drawing_area); 2809 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window, 2810 TRUE, TRUE, 0); 2811 2812 setup_graphs(&ui->graphs); 2813 2814 /* 2815 * Set up alignments for widgets at the bottom of ui, 2816 * align bottom left, expand horizontally but not vertically 2817 */ 2818 bottom_align = gtk_alignment_new(0, 1, 1, 0); 2819 ui->buttonbox = gtk_hbox_new(FALSE, 0); 2820 gtk_container_add(GTK_CONTAINER(bottom_align), ui->buttonbox); 2821 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0); 2822 2823 /* 2824 * Set up thread status progress bar 2825 */ 2826 ui->thread_status_pb = gtk_progress_bar_new(); 2827 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0); 2828 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections"); 2829 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb); 2830 2831 return main_vbox; 2832} 2833 2834static gboolean notebook_switch_page(GtkNotebook *notebook, GtkWidget *widget, 2835 guint page, gpointer data) 2836 2837{ 2838 struct gui *ui = (struct gui *) data; 2839 struct gui_entry *ge; 2840 2841 if (!page) { 2842 set_job_menu_visible(ui, 0); 2843 return TRUE; 2844 } 2845 2846 set_job_menu_visible(ui, 1); 2847 ge = get_ge_from_page(page, NULL); 2848 if (ge) 2849 update_button_states(ui, ge); 2850 2851 return TRUE; 2852} 2853 2854static gint compare_recent_items(GtkRecentInfo *a, GtkRecentInfo *b) 2855{ 2856 time_t time_a = gtk_recent_info_get_visited(a); 2857 time_t time_b = gtk_recent_info_get_visited(b); 2858 2859 return time_b - time_a; 2860} 2861 2862static void add_recent_file_items(struct gui *ui) 2863{ 2864 const gchar *gfio = g_get_application_name(); 2865 GList *items, *item; 2866 int i = 0; 2867 2868 if (ui->recent_ui_id) { 2869 gtk_ui_manager_remove_ui(ui->uimanager, ui->recent_ui_id); 2870 gtk_ui_manager_ensure_update(ui->uimanager); 2871 } 2872 ui->recent_ui_id = gtk_ui_manager_new_merge_id(ui->uimanager); 2873 2874 if (ui->actiongroup) { 2875 gtk_ui_manager_remove_action_group(ui->uimanager, ui->actiongroup); 2876 g_object_unref(ui->actiongroup); 2877 } 2878 ui->actiongroup = gtk_action_group_new("RecentFileActions"); 2879 2880 gtk_ui_manager_insert_action_group(ui->uimanager, ui->actiongroup, -1); 2881 2882 items = gtk_recent_manager_get_items(ui->recentmanager); 2883 items = g_list_sort(items, (GCompareFunc) compare_recent_items); 2884 2885 for (item = items; item && item->data; item = g_list_next(item)) { 2886 GtkRecentInfo *info = (GtkRecentInfo *) item->data; 2887 gchar *action_name; 2888 const gchar *label; 2889 GtkAction *action; 2890 2891 if (!gtk_recent_info_has_application(info, gfio)) 2892 continue; 2893 2894 /* 2895 * We only support local files for now 2896 */ 2897 if (!gtk_recent_info_is_local(info) || !gtk_recent_info_exists(info)) 2898 continue; 2899 2900 action_name = g_strdup_printf("RecentFile%u", i++); 2901 label = gtk_recent_info_get_display_name(info); 2902 2903 action = g_object_new(GTK_TYPE_ACTION, 2904 "name", action_name, 2905 "label", label, NULL); 2906 2907 g_object_set_data_full(G_OBJECT(action), "gtk-recent-info", 2908 gtk_recent_info_ref(info), 2909 (GDestroyNotify) gtk_recent_info_unref); 2910 2911 2912 g_signal_connect(action, "activate", G_CALLBACK(recent_open), ui); 2913 2914 gtk_action_group_add_action(ui->actiongroup, action); 2915 g_object_unref(action); 2916 2917 gtk_ui_manager_add_ui(ui->uimanager, ui->recent_ui_id, 2918 "/MainMenu/FileMenu/FileRecentFiles", 2919 label, action_name, 2920 GTK_UI_MANAGER_MENUITEM, FALSE); 2921 2922 g_free(action_name); 2923 2924 if (i == 8) 2925 break; 2926 } 2927 2928 g_list_foreach(items, (GFunc) gtk_recent_info_unref, NULL); 2929 g_list_free(items); 2930} 2931 2932static void drag_and_drop_received(GtkWidget *widget, GdkDragContext *ctx, 2933 gint x, gint y, GtkSelectionData *data, 2934 guint info, guint time) 2935{ 2936 struct gui *ui = &main_ui; 2937 gchar **uris; 2938 GtkWidget *source; 2939 int i; 2940 2941 source = gtk_drag_get_source_widget(ctx); 2942 if (source && widget == gtk_widget_get_toplevel(source)) { 2943 gtk_drag_finish(ctx, FALSE, FALSE, time); 2944 return; 2945 } 2946 2947 uris = gtk_selection_data_get_uris(data); 2948 if (!uris) { 2949 gtk_drag_finish(ctx, FALSE, FALSE, time); 2950 return; 2951 } 2952 2953 i = 0; 2954 while (uris[i]) { 2955 if (do_file_open_with_tab(ui, uris[i])) 2956 break; 2957 i++; 2958 } 2959 2960 gtk_drag_finish(ctx, TRUE, FALSE, time); 2961 g_strfreev(uris); 2962} 2963 2964static void init_ui(int *argc, char **argv[], struct gui *ui) 2965{ 2966 GtkSettings *settings; 2967 GtkWidget *vbox; 2968 2969 /* Magical g*thread incantation, you just need this thread stuff. 2970 * Without it, the update that happens in gfio_update_thread_status 2971 * doesn't really happen in a timely fashion, you need expose events 2972 */ 2973 if (!g_thread_supported()) 2974 g_thread_init(NULL); 2975 gdk_threads_init(); 2976 2977 gtk_init(argc, argv); 2978 settings = gtk_settings_get_default(); 2979 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting"); 2980 g_type_init(); 2981 2982 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 2983 gtk_window_set_title(GTK_WINDOW(ui->window), "fio"); 2984 gtk_window_set_default_size(GTK_WINDOW(ui->window), 1024, 768); 2985 2986 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL); 2987 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL); 2988 2989 ui->vbox = gtk_vbox_new(FALSE, 0); 2990 gtk_container_add(GTK_CONTAINER(ui->window), ui->vbox); 2991 2992 ui->uimanager = gtk_ui_manager_new(); 2993 ui->menu = get_menubar_menu(ui->window, ui->uimanager, ui); 2994 gfio_ui_setup(settings, ui->menu, ui->vbox, ui->uimanager); 2995 2996 ui->recentmanager = gtk_recent_manager_get_default(); 2997 add_recent_file_items(ui); 2998 2999 ui->notebook = gtk_notebook_new(); 3000 g_signal_connect(ui->notebook, "switch-page", G_CALLBACK(notebook_switch_page), ui); 3001 gtk_notebook_set_scrollable(GTK_NOTEBOOK(ui->notebook), 1); 3002 gtk_notebook_popup_enable(GTK_NOTEBOOK(ui->notebook)); 3003 gtk_container_add(GTK_CONTAINER(ui->vbox), ui->notebook); 3004 3005 vbox = new_main_page(ui); 3006 gtk_drag_dest_set(GTK_WIDGET(ui->window), GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY); 3007 gtk_drag_dest_add_uri_targets(GTK_WIDGET(ui->window)); 3008 g_signal_connect(ui->window, "drag-data-received", G_CALLBACK(drag_and_drop_received), ui); 3009 3010 gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), vbox, gtk_label_new("Main")); 3011 3012 gfio_ui_setup_log(ui); 3013 3014 gtk_widget_show_all(ui->window); 3015} 3016 3017int main(int argc, char *argv[], char *envp[]) 3018{ 3019 if (initialize_fio(envp)) 3020 return 1; 3021 if (fio_init_options()) 3022 return 1; 3023 3024 memset(&main_ui, 0, sizeof(main_ui)); 3025 INIT_FLIST_HEAD(&main_ui.list); 3026 3027 init_ui(&argc, &argv, &main_ui); 3028 3029 gdk_threads_enter(); 3030 gtk_main(); 3031 gdk_threads_leave(); 3032 return 0; 3033} 3034