2 * gfio - gui front end for fio - the flexible io tester
4 * Copyright (C) 2012 Stephen M. Cameron <stephenmcameron@gmail.com>
5 * Copyright (C) 2012 Jens Axboe <axboe@kernel.dk>
7 * The license below covers all files distributed with fio unless otherwise
8 * noted in the file itself.
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.
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.
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
41 static int gfio_server_running;
42 static unsigned int gfio_graph_limit = 100;
44 GdkColor gfio_color_white;
45 GdkColor gfio_color_lightyellow;
46 const char *gfio_graph_font = GRAPH_DEFAULT_FONT;
48 typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
50 static void connect_clicked(GtkWidget *widget, gpointer data);
51 static void start_job_clicked(GtkWidget *widget, gpointer data);
52 static void send_clicked(GtkWidget *widget, gpointer data);
54 static struct button_spec {
55 const char *buttontext;
57 const char *tooltiptext[2];
58 const int start_sensitive;
59 } buttonspeclist[] = {
61 .buttontext = "Connect",
63 .tooltiptext = { "Disconnect from host", "Connect to host" },
69 .tooltiptext = { "Send job description to host", NULL },
73 .buttontext = "Start Job",
74 .f = start_job_clicked,
75 .tooltiptext = { "Start the current job on the server", NULL },
80 static void setup_iops_graph(struct gfio_graphs *gg)
84 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
85 graph_title(g, "IOPS (IOs/sec)");
86 graph_x_title(g, "Time (secs)");
87 gg->read_iops = graph_add_label(g, "Read IOPS");
88 gg->write_iops = graph_add_label(g, "Write IOPS");
89 gg->trim_iops = graph_add_label(g, "Trim IOPS");
90 graph_set_color(g, gg->read_iops, GFIO_READ_R, GFIO_READ_G, GFIO_READ_B);
91 graph_set_color(g, gg->write_iops, GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B);
92 graph_set_color(g, gg->trim_iops, GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B);
93 line_graph_set_data_count_limit(g, gfio_graph_limit);
94 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
95 graph_set_graph_all_zeroes(g, 0);
99 static void setup_bandwidth_graph(struct gfio_graphs *gg)
103 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
104 graph_title(g, "Bandwidth (bytes/sec)");
105 graph_x_title(g, "Time (secs)");
106 gg->read_bw = graph_add_label(g, "Read Bandwidth");
107 gg->write_bw = graph_add_label(g, "Write Bandwidth");
108 gg->trim_bw = graph_add_label(g, "Trim Bandwidth");
109 graph_set_color(g, gg->read_bw, GFIO_READ_R, GFIO_READ_G, GFIO_READ_B);
110 graph_set_color(g, gg->write_bw, GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B);
111 graph_set_color(g, gg->trim_bw, GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B);
112 graph_set_base_offset(g, 1);
113 line_graph_set_data_count_limit(g, 100);
114 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
115 graph_set_graph_all_zeroes(g, 0);
116 gg->bandwidth_graph = g;
119 static void setup_graphs(struct gfio_graphs *g)
122 setup_bandwidth_graph(g);
125 void clear_ge_ui_info(struct gui_entry *ge)
127 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), "");
128 gtk_label_set_text(GTK_LABEL(ge->probe.os), "");
129 gtk_label_set_text(GTK_LABEL(ge->probe.arch), "");
130 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), "");
132 /* should we empty it... */
133 gtk_entry_set_text(GTK_ENTRY(ge->eta.name), "");
135 multitext_update_entry(&ge->eta.iotype, 0, "");
136 multitext_update_entry(&ge->eta.bs, 0, "");
137 multitext_update_entry(&ge->eta.ioengine, 0, "");
138 multitext_update_entry(&ge->eta.iodepth, 0, "");
139 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), "");
140 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), "");
141 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), "");
142 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), "");
143 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), "");
144 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), "");
147 static void set_menu_entry_text(struct gui *ui, const char *path,
152 w = gtk_ui_manager_get_widget(ui->uimanager, path);
154 gtk_menu_item_set_label(GTK_MENU_ITEM(w), text);
156 fprintf(stderr, "gfio: can't find path %s\n", path);
160 static void set_menu_entry_visible(struct gui *ui, const char *path, int show)
164 w = gtk_ui_manager_get_widget(ui->uimanager, path);
166 gtk_widget_set_sensitive(w, show);
168 fprintf(stderr, "gfio: can't find path %s\n", path);
171 static void set_job_menu_visible(struct gui *ui, int visible)
173 set_menu_entry_visible(ui, "/MainMenu/JobMenu", visible);
176 static void set_view_results_visible(struct gui *ui, int visible)
178 set_menu_entry_visible(ui, "/MainMenu/ViewMenu/Results", visible);
181 static const char *get_button_tooltip(struct button_spec *s, int sensitive)
183 if (s->tooltiptext[sensitive])
184 return s->tooltiptext[sensitive];
186 return s->tooltiptext[0];
189 static GtkWidget *add_button(GtkWidget *buttonbox,
190 struct button_spec *buttonspec, gpointer data)
192 GtkWidget *button = gtk_button_new_with_label(buttonspec->buttontext);
193 gboolean sens = buttonspec->start_sensitive;
195 g_signal_connect(button, "clicked", G_CALLBACK(buttonspec->f), data);
196 gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 3);
198 sens = buttonspec->start_sensitive;
199 gtk_widget_set_tooltip_text(button, get_button_tooltip(buttonspec, sens));
200 gtk_widget_set_sensitive(button, sens);
205 static void add_buttons(struct gui_entry *ge, struct button_spec *buttonlist,
210 for (i = 0; i < nbuttons; i++)
211 ge->button[i] = add_button(ge->buttonbox, &buttonlist[i], ge);
215 * Update sensitivity of job buttons and job menu items, based on the
216 * state of the client.
218 static void update_button_states(struct gui *ui, struct gui_entry *ge)
220 unsigned int connect_state, send_state, start_state, edit_state;
221 const char *connect_str = NULL;
225 gfio_report_error(ge, "Bad client state: %u\n", ge->state);
226 /* fall through to new state */
230 connect_str = "Connect";
234 case GE_STATE_CONNECTED:
237 connect_str = "Disconnect";
241 case GE_STATE_JOB_SENT:
244 connect_str = "Disconnect";
248 case GE_STATE_JOB_STARTED:
251 connect_str = "Disconnect";
255 case GE_STATE_JOB_RUNNING:
258 connect_str = "Disconnect";
262 case GE_STATE_JOB_DONE:
265 connect_str = "Connect";
271 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_CONNECT], connect_state);
272 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_SEND], send_state);
273 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_START], start_state);
274 gtk_button_set_label(GTK_BUTTON(ge->button[GFIO_BUTTON_CONNECT]), connect_str);
275 gtk_widget_set_tooltip_text(ge->button[GFIO_BUTTON_CONNECT], get_button_tooltip(&buttonspeclist[GFIO_BUTTON_CONNECT], connect_state));
277 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Connect", connect_state);
278 set_menu_entry_text(ui, "/MainMenu/JobMenu/Connect", connect_str);
280 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Edit job", edit_state);
281 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Send job", send_state);
282 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Start job", start_state);
284 if (ge->client && ge->client->nr_results)
285 set_view_results_visible(ui, 1);
287 set_view_results_visible(ui, 0);
290 void gfio_set_state(struct gui_entry *ge, unsigned int state)
293 update_button_states(ge->ui, ge);
296 static void gfio_ui_setup_log(struct gui *ui)
298 GtkTreeSelection *selection;
300 GtkWidget *tree_view;
302 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
304 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
305 gtk_widget_set_can_focus(tree_view, FALSE);
307 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
308 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
309 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
310 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
312 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE);
313 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE);
314 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE);
315 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE);
317 ui->log_model = model;
318 ui->log_tree = tree_view;
321 static gint on_config_drawing_area(GtkWidget *w, GdkEventConfigure *event,
324 guint width = gtk_widget_get_allocated_width(w);
325 guint height = gtk_widget_get_allocated_height(w);
326 struct gfio_graphs *g = data;
328 graph_set_size(g->iops_graph, width / 2.0, height);
329 graph_set_position(g->iops_graph, width / 2.0, 0.0);
330 graph_set_size(g->bandwidth_graph, width / 2.0, height);
331 graph_set_position(g->bandwidth_graph, 0, 0);
335 static void draw_graph(struct graph *g, cairo_t *cr)
337 line_graph_draw(g, cr);
341 static gboolean graph_tooltip(GtkWidget *w, gint x, gint y,
342 gboolean keyboard_mode, GtkTooltip *tooltip,
345 struct gfio_graphs *g = data;
346 const char *text = NULL;
348 if (graph_contains_xy(g->iops_graph, x, y))
349 text = graph_find_tooltip(g->iops_graph, x, y);
350 else if (graph_contains_xy(g->bandwidth_graph, x, y))
351 text = graph_find_tooltip(g->bandwidth_graph, x, y);
354 gtk_tooltip_set_text(tooltip, text);
361 static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
363 struct gfio_graphs *g = p;
366 cr = gdk_cairo_create(gtk_widget_get_window(w));
368 if (graph_has_tooltips(g->iops_graph) ||
369 graph_has_tooltips(g->bandwidth_graph)) {
370 g_object_set(w, "has-tooltip", TRUE, NULL);
371 g_signal_connect(w, "query-tooltip", G_CALLBACK(graph_tooltip), g);
374 cairo_set_source_rgb(cr, 0, 0, 0);
375 draw_graph(g->iops_graph, cr);
376 draw_graph(g->bandwidth_graph, cr);
383 * FIXME: need more handling here
385 static void ge_destroy(struct gui_entry *ge)
387 struct gfio_client *gc = ge->client;
391 if (ge->state >= GE_STATE_CONNECTED)
392 fio_client_terminate(gc->client);
394 fio_put_client(gc->client);
399 g_hash_table_remove(ge->ui->ge_hash, &ge->page_num);
406 static void ge_widget_destroy(GtkWidget *w, gpointer data)
408 struct gui_entry *ge = (struct gui_entry *) data;
413 static void gfio_quit(struct gui *ui)
418 static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
421 struct gui *ui = (struct gui *) data;
426 static void *job_thread(void *arg)
428 struct gui *ui = arg;
430 ui->handler_running = 1;
431 fio_handle_clients(&gfio_client_ops);
432 ui->handler_running = 0;
436 static int send_job_file(struct gui_entry *ge)
438 struct gfio_client *gc = ge->client;
442 * Prune old options, we are expecting the return options
443 * when the job file is parsed remotely and returned to us.
445 while (!flist_empty(&gc->o_list)) {
446 struct gfio_client_options *gco;
448 gco = flist_first_entry(&gc->o_list, struct gfio_client_options, list);
449 flist_del(&gco->list);
453 ret = fio_client_send_ini(gc->client, ge->job_file, false);
457 gfio_report_error(ge, "Failed to send file %s: %s\n", ge->job_file, strerror(-ret));
461 static void *server_thread(void *arg)
463 fio_server_create_sk_key();
465 gfio_server_running = 1;
466 fio_start_server(NULL);
467 gfio_server_running = 0;
468 fio_server_destroy_sk_key();
472 static void gfio_start_server(struct gui *ui)
474 if (!gfio_server_running) {
475 gfio_server_running = 1;
476 pthread_create(&ui->server_t, NULL, server_thread, NULL);
477 pthread_detach(ui->server_t);
481 static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
484 struct gui_entry *ge = data;
485 struct gfio_client *gc = ge->client;
488 fio_start_client(gc->client);
491 static void file_open(GtkWidget *w, gpointer data);
493 struct connection_widgets
500 static void hostname_cb(GtkEntry *entry, gpointer data)
502 struct connection_widgets *cw = data;
503 int uses_net = 0, is_localhost = 0;
508 * Check whether to display the 'auto start backend' box
509 * or not. Show it if we are a localhost and using network,
512 ctext = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(cw->combo));
513 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4))
518 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry));
519 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") ||
520 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") ||
521 !strcmp(text, "ip6-loopback"))
525 if (!uses_net || is_localhost) {
526 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1);
527 gtk_widget_set_sensitive(cw->button, 1);
529 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0);
530 gtk_widget_set_sensitive(cw->button, 0);
534 static int get_connection_details(struct gui_entry *ge)
536 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry;
537 struct connection_widgets cw;
538 struct gui *ui = ge->ui;
544 dialog = gtk_dialog_new_with_buttons("Connection details",
545 GTK_WINDOW(ui->window),
546 GTK_DIALOG_DESTROY_WITH_PARENT,
547 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
548 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
550 frame = gtk_frame_new("Hostname / socket name");
551 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
552 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
554 box = gtk_vbox_new(FALSE, 6);
555 gtk_container_add(GTK_CONTAINER(frame), box);
557 hbox = gtk_hbox_new(TRUE, 10);
558 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
559 cw.hentry = gtk_entry_new();
560 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost");
561 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0);
563 frame = gtk_frame_new("Port");
564 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
565 box = gtk_vbox_new(FALSE, 10);
566 gtk_container_add(GTK_CONTAINER(frame), box);
568 hbox = gtk_hbox_new(TRUE, 4);
569 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
570 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
572 frame = gtk_frame_new("Type");
573 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
574 box = gtk_vbox_new(FALSE, 10);
575 gtk_container_add(GTK_CONTAINER(frame), box);
577 hbox = gtk_hbox_new(TRUE, 4);
578 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
580 cw.combo = gtk_combo_box_text_new();
581 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(cw.combo), "IPv4");
582 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(cw.combo), "IPv6");
583 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(cw.combo), "local socket");
584 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0);
586 gtk_container_add(GTK_CONTAINER(hbox), cw.combo);
588 frame = gtk_frame_new("Options");
589 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
590 box = gtk_vbox_new(FALSE, 10);
591 gtk_container_add(GTK_CONTAINER(frame), box);
593 hbox = gtk_hbox_new(TRUE, 4);
594 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
596 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend");
597 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1);
598 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.");
599 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6);
602 * Connect edit signal, so we can show/not-show the auto start button
604 g_signal_connect(G_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw);
605 g_signal_connect(G_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw);
607 gtk_widget_show_all(dialog);
609 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
610 gtk_widget_destroy(dialog);
614 ge->host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry)));
615 ge->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
617 typeentry = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(cw.combo));
618 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
619 ge->type = Fio_client_ipv4;
620 else if (!strncmp(typeentry, "IPv6", 4))
621 ge->type = Fio_client_ipv6;
623 ge->type = Fio_client_socket;
626 ge->server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button));
628 gtk_widget_destroy(dialog);
632 static void gfio_set_client(struct gfio_client *gc, struct fio_client *client)
634 gc->client = fio_get_client(client);
635 client->client_data = gc;
638 static void gfio_client_added(struct gui_entry *ge, struct fio_client *client)
640 struct gfio_client_options *gco;
641 struct gfio_client *gc;
643 gc = calloc(1, sizeof(*gc));
644 INIT_FLIST_HEAD(&gc->o_list);
647 gfio_set_client(gc, client);
650 * Just add a default set of options, need to consider how best
653 gco = calloc(1, sizeof(*gco));
654 INIT_FLIST_HEAD(&gco->list);
655 options_default_fill(&gco->o);
656 flist_add_tail(&gco->list, &gc->o_list);
660 static void gfio_clear_graph_data(struct gfio_graphs *g)
662 graph_clear_values(g->iops_graph);
663 graph_clear_values(g->bandwidth_graph);
666 static void connect_clicked(GtkWidget *widget, gpointer data)
668 struct gui_entry *ge = data;
669 struct gfio_client *gc = ge->client;
671 if (ge->state == GE_STATE_NEW) {
675 file_open(widget, ge->ui);
682 struct fio_client *client;
684 if (get_connection_details(ge)) {
685 gfio_report_error(ge, "Failed to get connection details\n");
689 client = fio_client_add_explicit(&gfio_client_ops, ge->host, ge->type, ge->port);
691 gfio_report_error(ge, "Failed to add client %s\n", ge->host);
696 gfio_set_client(gc, client);
699 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No jobs running");
700 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
701 ret = fio_client_connect(gc->client);
703 if (!ge->ui->handler_running)
704 pthread_create(&ge->ui->t, NULL, job_thread, ge->ui);
705 gfio_set_state(ge, GE_STATE_CONNECTED);
706 gfio_clear_graph_data(&ge->graphs);
708 gfio_report_error(ge, "Failed to connect to %s: %s\n", ge->client->client->hostname, strerror(-ret));
711 fio_client_terminate(gc->client);
712 gfio_set_state(ge, GE_STATE_NEW);
713 clear_ge_ui_info(ge);
717 static void send_clicked(GtkWidget *widget, gpointer data)
719 struct gui_entry *ge = data;
721 if (send_job_file(ge))
722 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_START], 1);
725 static GtkWidget *new_client_page(struct gui_entry *ge);
727 static struct gui_entry *alloc_new_gui_entry(struct gui *ui)
729 struct gui_entry *ge;
731 ge = malloc(sizeof(*ge));
732 memset(ge, 0, sizeof(*ge));
733 ge->state = GE_STATE_NEW;
738 static struct gui_entry *get_new_ge_with_tab(struct gui *ui, const char *name)
740 struct gui_entry *ge;
742 ge = alloc_new_gui_entry(ui);
744 ge->vbox = new_client_page(ge);
745 g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_widget_destroy), ge);
747 ge->page_label = gtk_label_new(name);
748 ge->page_num = gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), ge->vbox, ge->page_label);
750 g_hash_table_insert(ui->ge_hash, &ge->page_num, ge);
752 gtk_widget_show_all(ui->window);
756 static void file_new(GtkWidget *w, gpointer data)
758 struct gui *ui = (struct gui *) data;
759 struct gui_entry *ge;
761 ge = get_new_ge_with_tab(ui, "Untitled");
762 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
766 * Return the 'ge' corresponding to the tab. If the active tab is the
767 * main tab, open a new tab.
769 static struct gui_entry *get_ge_from_page(struct gui *ui, gint cur_page,
775 return get_new_ge_with_tab(ui, "Untitled");
781 return g_hash_table_lookup(ui->ge_hash, &cur_page);
784 static struct gui_entry *get_ge_from_cur_tab(struct gui *ui)
789 * Main tab is tab 0, so any current page other than 0 holds
792 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
794 return get_ge_from_page(ui, cur_page, NULL);
799 static void file_close(GtkWidget *w, gpointer data)
801 struct gui *ui = (struct gui *) data;
802 struct gui_entry *ge;
805 * Can't close the main tab
807 ge = get_ge_from_cur_tab(ui);
809 gtk_widget_destroy(ge->vbox);
813 if (g_hash_table_size(ui->ge_hash)) {
814 gfio_report_info(ui, "Error", "The main page view cannot be closed\n");
821 static void file_add_recent(struct gui *ui, const gchar *uri)
825 memset(&grd, 0, sizeof(grd));
826 grd.display_name = strdup("gfio");
827 grd.description = strdup("Fio job file");
828 grd.mime_type = strdup(GFIO_MIME);
829 grd.app_name = strdup(g_get_application_name());
830 grd.app_exec = strdup("gfio %f/%u");
832 gtk_recent_manager_add_full(ui->recentmanager, uri, &grd);
835 static gchar *get_filename_from_uri(const gchar *uri)
837 if (strncmp(uri, "file://", 7))
840 return strdup(uri + 7);
843 static int do_file_open(struct gui_entry *ge, const gchar *uri)
845 struct fio_client *client;
847 assert(!ge->job_file);
849 ge->job_file = get_filename_from_uri(uri);
851 client = fio_client_add_explicit(&gfio_client_ops, ge->host, ge->type, ge->port);
853 char *label = strdup(uri);
856 gtk_label_set_text(GTK_LABEL(ge->page_label), basename(label));
859 gfio_client_added(ge, client);
860 file_add_recent(ge->ui, uri);
864 gfio_report_error(ge, "Failed to add client %s\n", ge->host);
872 static int do_file_open_with_tab(struct gui *ui, const gchar *uri)
874 struct gui_entry *ge;
876 int ret, ge_is_new = 0;
879 * Creates new tab if current tab is the main window, or the
880 * current tab already has a client.
882 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
883 ge = get_ge_from_page(ui, cur_page, &ge_is_new);
885 ge = get_new_ge_with_tab(ui, "Untitled");
889 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
891 if (get_connection_details(ge)) {
893 gtk_widget_destroy(ge->vbox);
898 ret = do_file_open(ge, uri);
901 if (ge->server_start)
902 gfio_start_server(ui);
905 gtk_widget_destroy(ge->vbox);
911 static void recent_open(GtkAction *action, gpointer data)
913 struct gui *ui = (struct gui *) data;
917 info = g_object_get_data(G_OBJECT(action), "gtk-recent-info");
918 uri = gtk_recent_info_get_uri(info);
920 do_file_open_with_tab(ui, uri);
923 static void file_open(GtkWidget *w, gpointer data)
925 struct gui *ui = data;
927 GtkFileFilter *filter;
930 dialog = gtk_file_chooser_dialog_new("Open File",
931 GTK_WINDOW(ui->window),
932 GTK_FILE_CHOOSER_ACTION_OPEN,
933 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
934 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
936 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), FALSE);
938 filter = gtk_file_filter_new();
939 gtk_file_filter_add_pattern(filter, "*.fio");
940 gtk_file_filter_add_pattern(filter, "*.job");
941 gtk_file_filter_add_pattern(filter, "*.ini");
942 gtk_file_filter_add_mime_type(filter, GFIO_MIME);
943 gtk_file_filter_set_name(filter, "Fio job file");
944 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
946 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
947 gtk_widget_destroy(dialog);
951 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
953 gtk_widget_destroy(dialog);
955 do_file_open_with_tab(ui, filename);
959 static void file_save(GtkWidget *w, gpointer data)
961 struct gui *ui = data;
964 dialog = gtk_file_chooser_dialog_new("Save File",
965 GTK_WINDOW(ui->window),
966 GTK_FILE_CHOOSER_ACTION_SAVE,
967 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
968 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
971 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
972 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
974 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
977 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
978 // save_job_file(filename);
981 gtk_widget_destroy(dialog);
984 static void view_log_destroy(GtkWidget *w, gpointer data)
986 struct gui *ui = (struct gui *) data;
988 g_object_ref(G_OBJECT(ui->log_tree));
989 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree);
990 gtk_widget_destroy(w);
994 void gfio_view_log(struct gui *ui)
996 GtkWidget *win, *scroll, *vbox, *box;
1001 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1002 gtk_window_set_title(GTK_WINDOW(win), "Log");
1003 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500);
1005 scroll = gtk_scrolled_window_new(NULL, NULL);
1007 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
1009 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1011 box = gtk_hbox_new(TRUE, 0);
1012 gtk_box_pack_start(GTK_BOX(box), ui->log_tree, TRUE, TRUE, 0);
1013 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui);
1014 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box);
1016 vbox = gtk_vbox_new(TRUE, 5);
1017 gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0);
1019 gtk_container_add(GTK_CONTAINER(win), vbox);
1020 gtk_widget_show_all(win);
1023 static void view_log(GtkWidget *w, gpointer data)
1025 struct gui *ui = (struct gui *) data;
1030 static void connect_job_entry(GtkWidget *w, gpointer data)
1032 struct gui *ui = (struct gui *) data;
1033 struct gui_entry *ge;
1035 ge = get_ge_from_cur_tab(ui);
1037 connect_clicked(w, ge);
1040 static void send_job_entry(GtkWidget *w, gpointer data)
1042 struct gui *ui = (struct gui *) data;
1043 struct gui_entry *ge;
1045 ge = get_ge_from_cur_tab(ui);
1047 send_clicked(w, ge);
1050 static void edit_job_entry(GtkWidget *w, gpointer data)
1052 struct gui *ui = (struct gui *) data;
1053 struct gui_entry *ge;
1055 ge = get_ge_from_cur_tab(ui);
1056 if (ge && ge->client)
1057 gopt_get_options_window(ui->window, ge->client);
1060 static void start_job_entry(GtkWidget *w, gpointer data)
1062 struct gui *ui = (struct gui *) data;
1063 struct gui_entry *ge;
1065 ge = get_ge_from_cur_tab(ui);
1067 start_job_clicked(w, ge);
1070 static void view_results(GtkWidget *w, gpointer data)
1072 struct gui *ui = (struct gui *) data;
1073 struct gfio_client *gc;
1074 struct gui_entry *ge;
1076 ge = get_ge_from_cur_tab(ui);
1080 if (ge->results_window)
1084 if (gc && gc->nr_results)
1085 gfio_display_end_results(gc);
1088 static void __update_graph_settings(struct gfio_graphs *g)
1090 line_graph_set_data_count_limit(g->iops_graph, gfio_graph_limit);
1091 graph_set_font(g->iops_graph, gfio_graph_font);
1092 line_graph_set_data_count_limit(g->bandwidth_graph, gfio_graph_limit);
1093 graph_set_font(g->bandwidth_graph, gfio_graph_font);
1096 static void ge_update_settings_fn(gpointer key, gpointer value, gpointer data)
1098 struct gui_entry *ge = (struct gui_entry *) value;
1101 __update_graph_settings(&ge->graphs);
1103 ev = gdk_event_new(GDK_EXPOSE);
1104 g_signal_emit_by_name(G_OBJECT(ge->graphs.drawing_area), GFIO_DRAW_EVENT, GTK_WIDGET(ge->graphs.drawing_area), ev, &ge->graphs);
1108 static void update_graph_limits(void)
1110 struct gui *ui = &main_ui;
1113 __update_graph_settings(&ui->graphs);
1115 ev = gdk_event_new(GDK_EXPOSE);
1116 g_signal_emit_by_name(G_OBJECT(ui->graphs.drawing_area), GFIO_DRAW_EVENT, GTK_WIDGET(ui->graphs.drawing_area), ev, &ui->graphs);
1119 g_hash_table_foreach(ui->ge_hash, ge_update_settings_fn, NULL);
1122 static void preferences(GtkWidget *w, gpointer data)
1124 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font;
1125 GtkWidget *hbox, *spin, *entry, *spin_int;
1126 struct gui *ui = (struct gui *) data;
1129 dialog = gtk_dialog_new_with_buttons("Preferences",
1130 GTK_WINDOW(ui->window),
1131 GTK_DIALOG_DESTROY_WITH_PARENT,
1132 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1133 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1136 frame = gtk_frame_new("Graphing");
1137 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1138 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1139 vbox = gtk_vbox_new(FALSE, 6);
1140 gtk_container_add(GTK_CONTAINER(frame), vbox);
1142 hbox = gtk_hbox_new(FALSE, 5);
1143 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
1144 entry = gtk_label_new("Font face to use for graph labels");
1145 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5);
1147 font = gtk_font_button_new_with_font(gfio_graph_font);
1148 gtk_box_pack_start(GTK_BOX(hbox), font, FALSE, FALSE, 5);
1150 box = gtk_vbox_new(FALSE, 6);
1151 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
1153 hbox = gtk_hbox_new(FALSE, 5);
1154 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
1155 entry = gtk_label_new("Maximum number of data points in graph (seconds)");
1156 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
1158 spin = create_spinbutton(hbox, 10, 1000000, gfio_graph_limit);
1160 box = gtk_vbox_new(FALSE, 6);
1161 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
1163 hbox = gtk_hbox_new(FALSE, 5);
1164 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
1165 entry = gtk_label_new("Client ETA request interval (msec)");
1166 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
1168 spin_int = create_spinbutton(hbox, 100, 100000, gfio_client_ops.eta_msec);
1169 frame = gtk_frame_new("Debug logging");
1170 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1171 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1172 vbox = gtk_vbox_new(FALSE, 6);
1173 gtk_container_add(GTK_CONTAINER(frame), vbox);
1175 box = gtk_hbox_new(FALSE, 6);
1176 gtk_container_add(GTK_CONTAINER(vbox), box);
1178 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
1180 for (i = 0; i < FD_DEBUG_MAX; i++) {
1182 box = gtk_hbox_new(FALSE, 6);
1183 gtk_container_add(GTK_CONTAINER(vbox), box);
1187 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
1188 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
1189 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
1192 gtk_widget_show_all(dialog);
1194 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1195 gtk_widget_destroy(dialog);
1199 for (i = 0; i < FD_DEBUG_MAX; i++) {
1202 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
1204 fio_debug |= (1UL << i);
1207 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
1208 gfio_graph_limit = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
1209 update_graph_limits();
1210 gfio_client_ops.eta_msec = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin_int));
1212 gtk_widget_destroy(dialog);
1215 static void about_dialog(GtkWidget *w, gpointer data)
1217 const char *authors[] = {
1218 "Jens Axboe <axboe@kernel.dk>",
1219 "Stephen Cameron <stephenmcameron@gmail.com>",
1222 const char *license[] = {
1223 "Fio is free software; you can redistribute it and/or modify "
1224 "it under the terms of the GNU General Public License as published by "
1225 "the Free Software Foundation; either version 2 of the License, or "
1226 "(at your option) any later version.\n",
1227 "Fio is distributed in the hope that it will be useful, "
1228 "but WITHOUT ANY WARRANTY; without even the implied warranty of "
1229 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
1230 "GNU General Public License for more details.\n",
1231 "You should have received a copy of the GNU General Public License "
1232 "along with Fio; if not, write to the Free Software Foundation, Inc., "
1233 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
1235 char *license_trans;
1237 license_trans = g_strconcat(license[0], "\n", license[1], "\n",
1238 license[2], "\n", NULL);
1240 gtk_show_about_dialog(NULL,
1241 "program-name", "gfio",
1242 "comments", "Gtk2 UI for fio",
1243 "license", license_trans,
1244 "website", "http://git.kernel.dk/cgit/fio/",
1246 "version", fio_version_string,
1247 "copyright", "© 2012-2017 Jens Axboe <axboe@kernel.dk>",
1248 "logo-icon-name", "fio",
1250 "wrap-license", TRUE,
1253 g_free(license_trans);
1256 static GtkActionEntry menu_items[] = {
1257 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
1258 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
1259 { "JobMenuAction", GTK_STOCK_FILE, "Job", NULL, NULL, NULL},
1260 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
1261 { "NewFile", GTK_STOCK_NEW, "New", "<Control>N", NULL, G_CALLBACK(file_new) },
1262 { "CloseFile", GTK_STOCK_CLOSE, "Close", "<Control>W", NULL, G_CALLBACK(file_close) },
1263 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
1264 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
1265 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
1266 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) },
1267 { "ViewResults", NULL, "Results", "<Control>R", NULL, G_CALLBACK(view_results) },
1268 { "ConnectJob", NULL, "Connect", "<Control>D", NULL, G_CALLBACK(connect_job_entry) },
1269 { "EditJob", NULL, "Edit job", "<Control>E", NULL, G_CALLBACK(edit_job_entry) },
1270 { "SendJob", NULL, "Send job", "<Control>X", NULL, G_CALLBACK(send_job_entry) },
1271 { "StartJob", NULL, "Start job", "<Control>L", NULL, G_CALLBACK(start_job_entry) },
1272 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
1273 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
1275 static gint nmenu_items = ARRAY_SIZE(menu_items);
1277 static const gchar *ui_string = " \
1279 <menubar name=\"MainMenu\"> \
1280 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
1281 <menuitem name=\"New\" action=\"NewFile\" /> \
1282 <menuitem name=\"Open\" action=\"OpenFile\" /> \
1283 <menuitem name=\"Close\" action=\"CloseFile\" /> \
1284 <separator name=\"Separator1\"/> \
1285 <menuitem name=\"Save\" action=\"SaveFile\" /> \
1286 <separator name=\"Separator2\"/> \
1287 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
1288 <separator name=\"Separator3\"/> \
1289 <placeholder name=\"FileRecentFiles\"/> \
1290 <separator name=\"Separator4\"/> \
1291 <menuitem name=\"Quit\" action=\"Quit\" /> \
1293 <menu name=\"JobMenu\" action=\"JobMenuAction\"> \
1294 <menuitem name=\"Connect\" action=\"ConnectJob\" /> \
1295 <separator name=\"Separator5\"/> \
1296 <menuitem name=\"Edit job\" action=\"EditJob\" /> \
1297 <menuitem name=\"Send job\" action=\"SendJob\" /> \
1298 <separator name=\"Separator6\"/> \
1299 <menuitem name=\"Start job\" action=\"StartJob\" /> \
1301 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
1302 <menuitem name=\"Results\" action=\"ViewResults\" /> \
1303 <separator name=\"Separator7\"/> \
1304 <menuitem name=\"Log\" action=\"ViewLog\" /> \
1306 <menu name=\"Help\" action=\"HelpMenuAction\"> \
1307 <menuitem name=\"About\" action=\"About\" /> \
1313 static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager,
1316 GtkActionGroup *action_group;
1319 action_group = gtk_action_group_new("Menu");
1320 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui);
1322 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
1323 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
1325 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
1327 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
1330 void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
1331 GtkWidget *vbox, GtkUIManager *ui_manager)
1333 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
1336 static void combo_entry_changed(GtkComboBox *box, gpointer data)
1338 struct gui_entry *ge = (struct gui_entry *) data;
1341 index = gtk_combo_box_get_active(box);
1343 multitext_set_entry(&ge->eta.iotype, index);
1344 multitext_set_entry(&ge->eta.bs, index);
1345 multitext_set_entry(&ge->eta.ioengine, index);
1346 multitext_set_entry(&ge->eta.iodepth, index);
1349 static void combo_entry_destroy(GtkWidget *widget, gpointer data)
1351 struct gui_entry *ge = (struct gui_entry *) data;
1353 multitext_free(&ge->eta.iotype);
1354 multitext_free(&ge->eta.bs);
1355 multitext_free(&ge->eta.ioengine);
1356 multitext_free(&ge->eta.iodepth);
1359 static GtkWidget *new_client_page(struct gui_entry *ge)
1361 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
1362 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
1364 main_vbox = gtk_vbox_new(FALSE, 3);
1366 top_align = gtk_alignment_new(0, 0, 1, 0);
1367 top_vbox = gtk_vbox_new(FALSE, 3);
1368 gtk_container_add(GTK_CONTAINER(top_align), top_vbox);
1369 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0);
1371 probe = gtk_frame_new("Job");
1372 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
1373 probe_frame = gtk_vbox_new(FALSE, 3);
1374 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1376 probe_box = gtk_hbox_new(FALSE, 3);
1377 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
1378 ge->probe.hostname = new_info_label_in_frame(probe_box, "Host");
1379 ge->probe.os = new_info_label_in_frame(probe_box, "OS");
1380 ge->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
1381 ge->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
1383 probe_box = gtk_hbox_new(FALSE, 3);
1384 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
1386 ge->eta.names = new_combo_entry_in_frame(probe_box, "Jobs");
1387 g_signal_connect(ge->eta.names, "changed", G_CALLBACK(combo_entry_changed), ge);
1388 g_signal_connect(ge->eta.names, "destroy", G_CALLBACK(combo_entry_destroy), ge);
1389 ge->eta.iotype.entry = new_info_entry_in_frame(probe_box, "IO");
1390 ge->eta.bs.entry = new_info_entry_in_frame(probe_box, "Blocksize (Read/Write/Trim)");
1391 ge->eta.ioengine.entry = new_info_entry_in_frame(probe_box, "IO Engine");
1392 ge->eta.iodepth.entry = new_info_entry_in_frame(probe_box, "IO Depth");
1393 ge->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
1394 ge->eta.files = new_info_entry_in_frame(probe_box, "Open files");
1396 probe_box = gtk_hbox_new(FALSE, 3);
1397 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
1398 ge->eta.read_bw = new_info_entry_in_frame_rgb(probe_box, "Read BW", GFIO_READ_R, GFIO_READ_G, GFIO_READ_B);
1399 ge->eta.read_iops = new_info_entry_in_frame_rgb(probe_box, "Read IOPS", GFIO_READ_R, GFIO_READ_G, GFIO_READ_B);
1400 ge->eta.write_bw = new_info_entry_in_frame_rgb(probe_box, "Write BW", GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B);
1401 ge->eta.write_iops = new_info_entry_in_frame_rgb(probe_box, "Write IOPS", GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B);
1402 ge->eta.trim_bw = new_info_entry_in_frame_rgb(probe_box, "Trim BW", GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B);
1403 ge->eta.trim_iops = new_info_entry_in_frame_rgb(probe_box, "Trim IOPS", GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B);
1406 * Only add this if we have a commit rate
1409 probe_box = gtk_hbox_new(FALSE, 3);
1410 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1412 ge->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1413 ge->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1415 ge->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1416 ge->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1420 * Set up a drawing area and IOPS and bandwidth graphs
1422 ge->graphs.drawing_area = gtk_drawing_area_new();
1423 gtk_widget_set_size_request(GTK_WIDGET(ge->graphs.drawing_area),
1424 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
1425 gtk_widget_modify_bg(ge->graphs.drawing_area, GTK_STATE_NORMAL, &gfio_color_lightyellow);
1426 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), GFIO_DRAW_EVENT,
1427 G_CALLBACK(on_expose_drawing_area), &ge->graphs);
1428 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "configure_event",
1429 G_CALLBACK(on_config_drawing_area), &ge->graphs);
1430 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1431 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
1432 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1433 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1434 ge->graphs.drawing_area);
1435 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window, TRUE, TRUE, 0);
1437 setup_graphs(&ge->graphs);
1440 * Set up alignments for widgets at the bottom of ui,
1441 * align bottom left, expand horizontally but not vertically
1443 bottom_align = gtk_alignment_new(0, 1, 1, 0);
1444 ge->buttonbox = gtk_hbox_new(FALSE, 0);
1445 gtk_container_add(GTK_CONTAINER(bottom_align), ge->buttonbox);
1446 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0);
1448 add_buttons(ge, buttonspeclist, ARRAY_SIZE(buttonspeclist));
1451 * Set up thread status progress bar
1453 ge->thread_status_pb = gtk_progress_bar_new();
1454 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
1455 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No connections");
1456 gtk_container_add(GTK_CONTAINER(ge->buttonbox), ge->thread_status_pb);
1462 static GtkWidget *new_main_page(struct gui *ui)
1464 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
1465 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
1467 main_vbox = gtk_vbox_new(FALSE, 3);
1470 * Set up alignments for widgets at the top of ui,
1471 * align top left, expand horizontally but not vertically
1473 top_align = gtk_alignment_new(0, 0, 1, 0);
1474 top_vbox = gtk_vbox_new(FALSE, 0);
1475 gtk_container_add(GTK_CONTAINER(top_align), top_vbox);
1476 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0);
1478 probe = gtk_frame_new("Run statistics");
1479 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
1480 probe_frame = gtk_vbox_new(FALSE, 3);
1481 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1483 probe_box = gtk_hbox_new(FALSE, 3);
1484 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
1485 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Running");
1486 ui->eta.read_bw = new_info_entry_in_frame_rgb(probe_box, "Read BW", GFIO_READ_R, GFIO_READ_G, GFIO_READ_B);
1487 ui->eta.read_iops = new_info_entry_in_frame_rgb(probe_box, "IOPS", GFIO_READ_R, GFIO_READ_G, GFIO_READ_B);
1488 ui->eta.write_bw = new_info_entry_in_frame_rgb(probe_box, "Write BW", GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B);
1489 ui->eta.write_iops = new_info_entry_in_frame_rgb(probe_box, "IOPS", GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B);
1490 ui->eta.trim_bw = new_info_entry_in_frame_rgb(probe_box, "Trim BW", GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B);
1491 ui->eta.trim_iops = new_info_entry_in_frame_rgb(probe_box, "IOPS", GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B);
1494 * Only add this if we have a commit rate
1497 probe_box = gtk_hbox_new(FALSE, 3);
1498 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1500 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1501 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1503 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1504 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1508 * Set up a drawing area and IOPS and bandwidth graphs
1510 ui->graphs.drawing_area = gtk_drawing_area_new();
1511 gtk_widget_set_size_request(GTK_WIDGET(ui->graphs.drawing_area),
1512 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
1513 gtk_widget_modify_bg(ui->graphs.drawing_area, GTK_STATE_NORMAL, &gfio_color_lightyellow);
1514 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), GFIO_DRAW_EVENT,
1515 G_CALLBACK(on_expose_drawing_area), &ui->graphs);
1516 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "configure_event",
1517 G_CALLBACK(on_config_drawing_area), &ui->graphs);
1518 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1519 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
1520 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1521 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1522 ui->graphs.drawing_area);
1523 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window,
1526 setup_graphs(&ui->graphs);
1529 * Set up alignments for widgets at the bottom of ui,
1530 * align bottom left, expand horizontally but not vertically
1532 bottom_align = gtk_alignment_new(0, 1, 1, 0);
1533 ui->buttonbox = gtk_hbox_new(FALSE, 0);
1534 gtk_container_add(GTK_CONTAINER(bottom_align), ui->buttonbox);
1535 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0);
1538 * Set up thread status progress bar
1540 ui->thread_status_pb = gtk_progress_bar_new();
1541 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
1542 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
1543 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
1548 static gboolean notebook_switch_page(GtkNotebook *notebook, GtkWidget *widget,
1549 guint page, gpointer data)
1552 struct gui *ui = (struct gui *) data;
1553 struct gui_entry *ge;
1556 set_job_menu_visible(ui, 0);
1557 set_view_results_visible(ui, 0);
1561 set_job_menu_visible(ui, 1);
1562 ge = get_ge_from_page(ui, page, NULL);
1564 update_button_states(ui, ge);
1569 static gint compare_recent_items(GtkRecentInfo *a, GtkRecentInfo *b)
1571 time_t time_a = gtk_recent_info_get_visited(a);
1572 time_t time_b = gtk_recent_info_get_visited(b);
1574 return time_b - time_a;
1577 static void add_recent_file_items(struct gui *ui)
1579 const gchar *gfio = g_get_application_name();
1580 GList *items, *item;
1583 if (ui->recent_ui_id) {
1584 gtk_ui_manager_remove_ui(ui->uimanager, ui->recent_ui_id);
1585 gtk_ui_manager_ensure_update(ui->uimanager);
1587 ui->recent_ui_id = gtk_ui_manager_new_merge_id(ui->uimanager);
1589 if (ui->actiongroup) {
1590 gtk_ui_manager_remove_action_group(ui->uimanager, ui->actiongroup);
1591 g_object_unref(ui->actiongroup);
1593 ui->actiongroup = gtk_action_group_new("RecentFileActions");
1595 gtk_ui_manager_insert_action_group(ui->uimanager, ui->actiongroup, -1);
1597 items = gtk_recent_manager_get_items(ui->recentmanager);
1598 items = g_list_sort(items, (GCompareFunc) compare_recent_items);
1600 for (item = items; item && item->data; item = g_list_next(item)) {
1601 GtkRecentInfo *info = (GtkRecentInfo *) item->data;
1606 if (!gtk_recent_info_has_application(info, gfio))
1610 * We only support local files for now
1612 if (!gtk_recent_info_is_local(info) || !gtk_recent_info_exists(info))
1615 action_name = g_strdup_printf("RecentFile%u", i++);
1616 label = gtk_recent_info_get_display_name(info);
1618 action = g_object_new(GTK_TYPE_ACTION,
1619 "name", action_name,
1620 "label", label, NULL);
1622 g_object_set_data_full(G_OBJECT(action), "gtk-recent-info",
1623 gtk_recent_info_ref(info),
1624 (GDestroyNotify) gtk_recent_info_unref);
1627 g_signal_connect(action, "activate", G_CALLBACK(recent_open), ui);
1629 gtk_action_group_add_action(ui->actiongroup, action);
1630 g_object_unref(action);
1632 gtk_ui_manager_add_ui(ui->uimanager, ui->recent_ui_id,
1633 "/MainMenu/FileMenu/FileRecentFiles",
1635 GTK_UI_MANAGER_MENUITEM, FALSE);
1637 g_free(action_name);
1643 g_list_foreach(items, (GFunc) gtk_recent_info_unref, NULL);
1647 static void drag_and_drop_received(GtkWidget *widget, GdkDragContext *ctx,
1648 gint x, gint y, GtkSelectionData *seldata,
1649 guint info, guint time, gpointer *data)
1651 struct gui *ui = (struct gui *) data;
1655 source = gtk_drag_get_source_widget(ctx);
1656 if (source && widget == gtk_widget_get_toplevel(source)) {
1657 gtk_drag_finish(ctx, FALSE, FALSE, time);
1661 uris = gtk_selection_data_get_uris(seldata);
1663 gtk_drag_finish(ctx, FALSE, FALSE, time);
1668 do_file_open_with_tab(ui, uris[0]);
1670 gtk_drag_finish(ctx, TRUE, FALSE, time);
1674 static void init_ui(int *argc, char **argv[], struct gui *ui)
1676 GtkSettings *settings;
1679 /* Magical g*thread incantation, you just need this thread stuff.
1680 * Without it, the update that happens in gfio_update_thread_status
1681 * doesn't really happen in a timely fashion, you need expose events
1683 #if !GLIB_CHECK_VERSION(2, 31, 0)
1684 if (!g_thread_supported())
1685 g_thread_init(NULL);
1690 gtk_init(argc, argv);
1691 settings = gtk_settings_get_default();
1692 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
1693 #if !GLIB_CHECK_VERSION(2, 36, 0)
1696 gdk_color_parse("#fffff4", &gfio_color_lightyellow);
1697 gdk_color_parse("white", &gfio_color_white);
1699 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1700 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
1701 gtk_window_set_default_size(GTK_WINDOW(ui->window), 1024, 768);
1703 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), ui);
1704 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), ui);
1706 ui->vbox = gtk_vbox_new(FALSE, 0);
1707 gtk_container_add(GTK_CONTAINER(ui->window), ui->vbox);
1709 ui->uimanager = gtk_ui_manager_new();
1710 ui->menu = get_menubar_menu(ui->window, ui->uimanager, ui);
1711 gfio_ui_setup(settings, ui->menu, ui->vbox, ui->uimanager);
1713 ui->recentmanager = gtk_recent_manager_get_default();
1714 add_recent_file_items(ui);
1716 ui->notebook = gtk_notebook_new();
1717 g_signal_connect(ui->notebook, "switch-page", G_CALLBACK(notebook_switch_page), ui);
1718 gtk_notebook_set_scrollable(GTK_NOTEBOOK(ui->notebook), 1);
1719 gtk_notebook_popup_enable(GTK_NOTEBOOK(ui->notebook));
1720 gtk_container_add(GTK_CONTAINER(ui->vbox), ui->notebook);
1722 vbox = new_main_page(ui);
1723 gtk_drag_dest_set(GTK_WIDGET(ui->window), GTK_DEST_DEFAULT_ALL, NULL, 1, GDK_ACTION_COPY);
1724 gtk_drag_dest_add_uri_targets(GTK_WIDGET(ui->window));
1725 g_signal_connect(ui->window, "drag-data-received", G_CALLBACK(drag_and_drop_received), ui);
1727 gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), vbox, gtk_label_new("Main"));
1729 gfio_ui_setup_log(ui);
1731 gtk_widget_show_all(ui->window);
1734 int main(int argc, char *argv[], char *envp[])
1736 if (initialize_fio(envp))
1738 if (fio_init_options())
1743 memset(&main_ui, 0, sizeof(main_ui));
1744 main_ui.ge_hash = g_hash_table_new(g_int_hash, g_int_equal);
1746 init_ui(&argc, &argv, &main_ui);
1748 gdk_threads_enter();
1750 gdk_threads_leave();
1752 g_hash_table_destroy(main_ui.ge_hash);