projects / fio.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
gcompat: provide backwards compatible functions for older gtk versions
[fio.git] / gfio.c
... / ...
CommitLineData
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 "gfio.h"
34#include "ghelpers.h"
35#include "goptions.h"
36#include "gerror.h"
37#include "gclient.h"
38#include "graph.h"
39
40static int gfio_server_running;
41static unsigned int gfio_graph_limit = 100;
42
43GdkColor gfio_color_white;
44const char *gfio_graph_font = GRAPH_DEFAULT_FONT;
45
46typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
47
48static void connect_clicked(GtkWidget *widget, gpointer data);
49static void start_job_clicked(GtkWidget *widget, gpointer data);
50static void send_clicked(GtkWidget *widget, gpointer data);
51
52static struct button_spec {
53 const char *buttontext;
54 clickfunction f;
55 const char *tooltiptext[2];
56 const int start_sensitive;
57} buttonspeclist[] = {
58 {
59 .buttontext = "Connect",
60 .f = connect_clicked,
61 .tooltiptext = { "Disconnect from host", "Connect to host" },
62 .start_sensitive = 1,
63 },
64 {
65 .buttontext = "Send",
66 .f = send_clicked,
67 .tooltiptext = { "Send job description to host", NULL },
68 .start_sensitive = 0,
69 },
70 {
71 .buttontext = "Start Job",
72 .f = start_job_clicked,
73 .tooltiptext = { "Start the current job on the server", NULL },
74 .start_sensitive = 0,
75 },
76};
77
78static void setup_iops_graph(struct gfio_graphs *gg)
79{
80 struct graph *g;
81
82 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
83 graph_title(g, "IOPS (IOs/sec)");
84 graph_x_title(g, "Time (secs)");
85 gg->read_iops = graph_add_label(g, "Read IOPS");
86 gg->write_iops = graph_add_label(g, "Write IOPS");
87 graph_set_color(g, gg->read_iops, 0.13, 0.54, 0.13);
88 graph_set_color(g, gg->write_iops, 1.0, 0.0, 0.0);
89 line_graph_set_data_count_limit(g, gfio_graph_limit);
90 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
91 graph_set_graph_all_zeroes(g, 0);
92 gg->iops_graph = g;
93}
94
95static void setup_bandwidth_graph(struct gfio_graphs *gg)
96{
97 struct graph *g;
98
99 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
100 graph_title(g, "Bandwidth (bytes/sec)");
101 graph_x_title(g, "Time (secs)");
102 gg->read_bw = graph_add_label(g, "Read Bandwidth");
103 gg->write_bw = graph_add_label(g, "Write Bandwidth");
104 graph_set_color(g, gg->read_bw, 0.13, 0.54, 0.13);
105 graph_set_color(g, gg->write_bw, 1.0, 0.0, 0.0);
106 graph_set_base_offset(g, 1);
107 line_graph_set_data_count_limit(g, 100);
108 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
109 graph_set_graph_all_zeroes(g, 0);
110 gg->bandwidth_graph = g;
111}
112
113static void setup_graphs(struct gfio_graphs *g)
114{
115 setup_iops_graph(g);
116 setup_bandwidth_graph(g);
117}
118
119void clear_ge_ui_info(struct gui_entry *ge)
120{
121 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), "");
122 gtk_label_set_text(GTK_LABEL(ge->probe.os), "");
123 gtk_label_set_text(GTK_LABEL(ge->probe.arch), "");
124 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), "");
125#if 0
126 /* should we empty it... */
127 gtk_entry_set_text(GTK_ENTRY(ge->eta.name), "");
128#endif
129 multitext_update_entry(&ge->eta.iotype, 0, "");
130 multitext_update_entry(&ge->eta.bs, 0, "");
131 multitext_update_entry(&ge->eta.ioengine, 0, "");
132 multitext_update_entry(&ge->eta.iodepth, 0, "");
133 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), "");
134 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), "");
135 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), "");
136 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), "");
137 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), "");
138 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), "");
139}
140
141static void set_menu_entry_text(struct gui *ui, const char *path,
142 const char *text)
143{
144 GtkWidget *w;
145
146 w = gtk_ui_manager_get_widget(ui->uimanager, path);
147 if (w)
148 gtk_menu_item_set_label(GTK_MENU_ITEM(w), text);
149 else
150 fprintf(stderr, "gfio: can't find path %s\n", path);
151}
152
153
154static void set_menu_entry_visible(struct gui *ui, const char *path, int show)
155{
156 GtkWidget *w;
157
158 w = gtk_ui_manager_get_widget(ui->uimanager, path);
159 if (w)
160 gtk_widget_set_sensitive(w, show);
161 else
162 fprintf(stderr, "gfio: can't find path %s\n", path);
163}
164
165static void set_job_menu_visible(struct gui *ui, int visible)
166{
167 set_menu_entry_visible(ui, "/MainMenu/JobMenu", visible);
168}
169
170static void set_view_results_visible(struct gui *ui, int visible)
171{
172 set_menu_entry_visible(ui, "/MainMenu/ViewMenu/Results", visible);
173}
174
175static const char *get_button_tooltip(struct button_spec *s, int sensitive)
176{
177 if (s->tooltiptext[sensitive])
178 return s->tooltiptext[sensitive];
179
180 return s->tooltiptext[0];
181}
182
183static GtkWidget *add_button(GtkWidget *buttonbox,
184 struct button_spec *buttonspec, gpointer data)
185{
186 GtkWidget *button = gtk_button_new_with_label(buttonspec->buttontext);
187 gboolean sens = buttonspec->start_sensitive;
188
189 g_signal_connect(button, "clicked", G_CALLBACK(buttonspec->f), data);
190 gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 3);
191
192 sens = buttonspec->start_sensitive;
193 gtk_widget_set_tooltip_text(button, get_button_tooltip(buttonspec, sens));
194 gtk_widget_set_sensitive(button, sens);
195
196 return button;
197}
198
199static void add_buttons(struct gui_entry *ge, struct button_spec *buttonlist,
200 int nbuttons)
201{
202 int i;
203
204 for (i = 0; i < nbuttons; i++)
205 ge->button[i] = add_button(ge->buttonbox, &buttonlist[i], ge);
206}
207
208/*
209 * Update sensitivity of job buttons and job menu items, based on the
210 * state of the client.
211 */
212static void update_button_states(struct gui *ui, struct gui_entry *ge)
213{
214 unsigned int connect_state, send_state, start_state, edit_state;
215 const char *connect_str = NULL;
216
217 switch (ge->state) {
218 default:
219 gfio_report_error(ge, "Bad client state: %u\n", ge->state);
220 /* fall through to new state */
221 case GE_STATE_NEW:
222 connect_state = 1;
223 edit_state = 1;
224 connect_str = "Connect";
225 send_state = 0;
226 start_state = 0;
227 break;
228 case GE_STATE_CONNECTED:
229 connect_state = 1;
230 edit_state = 1;
231 connect_str = "Disconnect";
232 send_state = 1;
233 start_state = 0;
234 break;
235 case GE_STATE_JOB_SENT:
236 connect_state = 1;
237 edit_state = 1;
238 connect_str = "Disconnect";
239 send_state = 0;
240 start_state = 1;
241 break;
242 case GE_STATE_JOB_STARTED:
243 connect_state = 1;
244 edit_state = 1;
245 connect_str = "Disconnect";
246 send_state = 0;
247 start_state = 1;
248 break;
249 case GE_STATE_JOB_RUNNING:
250 connect_state = 1;
251 edit_state = 0;
252 connect_str = "Disconnect";
253 send_state = 0;
254 start_state = 0;
255 break;
256 case GE_STATE_JOB_DONE:
257 connect_state = 1;
258 edit_state = 0;
259 connect_str = "Connect";
260 send_state = 0;
261 start_state = 0;
262 break;
263 }
264
265 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_CONNECT], connect_state);
266 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_SEND], send_state);
267 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_START], start_state);
268 gtk_button_set_label(GTK_BUTTON(ge->button[GFIO_BUTTON_CONNECT]), connect_str);
269 gtk_widget_set_tooltip_text(ge->button[GFIO_BUTTON_CONNECT], get_button_tooltip(&buttonspeclist[GFIO_BUTTON_CONNECT], connect_state));
270
271 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Connect", connect_state);
272 set_menu_entry_text(ui, "/MainMenu/JobMenu/Connect", connect_str);
273
274 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Edit job", edit_state);
275 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Send job", send_state);
276 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Start job", start_state);
277
278 if (ge->client && ge->client->nr_results)
279 set_view_results_visible(ui, 1);
280 else
281 set_view_results_visible(ui, 0);
282}
283
284void gfio_set_state(struct gui_entry *ge, unsigned int state)
285{
286 ge->state = state;
287 update_button_states(ge->ui, ge);
288}
289
290static void gfio_ui_setup_log(struct gui *ui)
291{
292 GtkTreeSelection *selection;
293 GtkListStore *model;
294 GtkWidget *tree_view;
295
296 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
297
298 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
299 gtk_widget_set_can_focus(tree_view, FALSE);
300
301 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
302 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
303 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
304 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
305
306 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE);
307 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE);
308 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE);
309 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE);
310
311 ui->log_model = model;
312 ui->log_tree = tree_view;
313}
314
315static gint on_config_drawing_area(GtkWidget *w, GdkEventConfigure *event,
316 gpointer data)
317{
318 struct gfio_graphs *g = data;
319
320 graph_set_size(g->iops_graph, w->allocation.width / 2.0, w->allocation.height);
321 graph_set_position(g->iops_graph, w->allocation.width / 2.0, 0.0);
322 graph_set_size(g->bandwidth_graph, w->allocation.width / 2.0, w->allocation.height);
323 graph_set_position(g->bandwidth_graph, 0, 0);
324 return TRUE;
325}
326
327static void draw_graph(struct graph *g, cairo_t *cr)
328{
329 line_graph_draw(g, cr);
330 cairo_stroke(cr);
331}
332
333static gboolean graph_tooltip(GtkWidget *w, gint x, gint y,
334 gboolean keyboard_mode, GtkTooltip *tooltip,
335 gpointer data)
336{
337 struct gfio_graphs *g = data;
338 const char *text = NULL;
339
340 if (graph_contains_xy(g->iops_graph, x, y))
341 text = graph_find_tooltip(g->iops_graph, x, y);
342 else if (graph_contains_xy(g->bandwidth_graph, x, y))
343 text = graph_find_tooltip(g->bandwidth_graph, x, y);
344
345 if (text) {
346 gtk_tooltip_set_text(tooltip, text);
347 return TRUE;
348 }
349
350 return FALSE;
351}
352
353static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
354{
355 struct gfio_graphs *g = p;
356 cairo_t *cr;
357
358 cr = gdk_cairo_create(w->window);
359
360 if (graph_has_tooltips(g->iops_graph) ||
361 graph_has_tooltips(g->bandwidth_graph)) {
362 g_object_set(w, "has-tooltip", TRUE, NULL);
363 g_signal_connect(w, "query-tooltip", G_CALLBACK(graph_tooltip), g);
364 }
365
366 cairo_set_source_rgb(cr, 0, 0, 0);
367 draw_graph(g->iops_graph, cr);
368 draw_graph(g->bandwidth_graph, cr);
369 cairo_destroy(cr);
370
371 return FALSE;
372}
373
374/*
375 * FIXME: need more handling here
376 */
377static void ge_destroy(struct gui_entry *ge)
378{
379 struct gfio_client *gc = ge->client;
380
381 if (gc) {
382 if (gc->client) {
383 if (ge->state >= GE_STATE_CONNECTED)
384 fio_client_terminate(gc->client);
385
386 fio_put_client(gc->client);
387 }
388 free(gc);
389 }
390
391 g_hash_table_remove(ge->ui->ge_hash, &ge->page_num);
392
393 free(ge->job_file);
394 free(ge->host);
395 free(ge);
396}
397
398static void ge_widget_destroy(GtkWidget *w, gpointer data)
399{
400 struct gui_entry *ge = (struct gui_entry *) data;
401
402 ge_destroy(ge);
403}
404
405static void gfio_quit(struct gui *ui)
406{
407 gtk_main_quit();
408}
409
410static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
411 __attribute__((unused)) gpointer data)
412{
413 struct gui *ui = (struct gui *) data;
414
415 gfio_quit(ui);
416}
417
418static void *job_thread(void *arg)
419{
420 struct gui *ui = arg;
421
422 ui->handler_running = 1;
423 fio_handle_clients(&gfio_client_ops);
424 ui->handler_running = 0;
425 return NULL;
426}
427
428static int send_job_file(struct gui_entry *ge)
429{
430 struct gfio_client *gc = ge->client;
431 int ret = 0;
432
433 /*
434 * Prune old options, we are expecting the return options
435 * when the job file is parsed remotely and returned to us.
436 */
437 while (!flist_empty(&gc->o_list)) {
438 struct gfio_client_options *gco;
439
440 gco = flist_entry(gc->o_list.next, struct gfio_client_options, list);
441 flist_del(&gco->list);
442 free(gco);
443 }
444
445 ret = fio_client_send_ini(gc->client, ge->job_file);
446 if (!ret)
447 return 0;
448
449 gfio_report_error(ge, "Failed to send file %s: %s\n", ge->job_file, strerror(-ret));
450 return 1;
451}
452
453static void *server_thread(void *arg)
454{
455 is_backend = 1;
456 gfio_server_running = 1;
457 fio_start_server(NULL);
458 gfio_server_running = 0;
459 return NULL;
460}
461
462static void gfio_start_server(struct gui *ui)
463{
464 if (!gfio_server_running) {
465 gfio_server_running = 1;
466 pthread_create(&ui->server_t, NULL, server_thread, NULL);
467 pthread_detach(ui->server_t);
468 }
469}
470
471static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
472 gpointer data)
473{
474 struct gui_entry *ge = data;
475 struct gfio_client *gc = ge->client;
476
477 if (gc)
478 fio_start_client(gc->client);
479}
480
481static void file_open(GtkWidget *w, gpointer data);
482
483struct connection_widgets
484{
485 GtkWidget *hentry;
486 GtkWidget *combo;
487 GtkWidget *button;
488};
489
490static void hostname_cb(GtkEntry *entry, gpointer data)
491{
492 struct connection_widgets *cw = data;
493 int uses_net = 0, is_localhost = 0;
494 const gchar *text;
495 gchar *ctext;
496
497 /*
498 * Check whether to display the 'auto start backend' box
499 * or not. Show it if we are a localhost and using network,
500 * or using a socket.
501 */
502 ctext = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(cw->combo));
503 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4))
504 uses_net = 1;
505 g_free(ctext);
506
507 if (uses_net) {
508 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry));
509 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") ||
510 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") ||
511 !strcmp(text, "ip6-loopback"))
512 is_localhost = 1;
513 }
514
515 if (!uses_net || is_localhost) {
516 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1);
517 gtk_widget_set_sensitive(cw->button, 1);
518 } else {
519 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0);
520 gtk_widget_set_sensitive(cw->button, 0);
521 }
522}
523
524static int get_connection_details(struct gui_entry *ge)
525{
526 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry;
527 struct connection_widgets cw;
528 struct gui *ui = ge->ui;
529 char *typeentry;
530
531 if (ge->host)
532 return 0;
533
534 dialog = gtk_dialog_new_with_buttons("Connection details",
535 GTK_WINDOW(ui->window),
536 GTK_DIALOG_DESTROY_WITH_PARENT,
537 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
538 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
539
540 frame = gtk_frame_new("Hostname / socket name");
541 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
542 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
543
544 box = gtk_vbox_new(FALSE, 6);
545 gtk_container_add(GTK_CONTAINER(frame), box);
546
547 hbox = gtk_hbox_new(TRUE, 10);
548 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
549 cw.hentry = gtk_entry_new();
550 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost");
551 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0);
552
553 frame = gtk_frame_new("Port");
554 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
555 box = gtk_vbox_new(FALSE, 10);
556 gtk_container_add(GTK_CONTAINER(frame), box);
557
558 hbox = gtk_hbox_new(TRUE, 4);
559 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
560 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
561
562 frame = gtk_frame_new("Type");
563 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
564 box = gtk_vbox_new(FALSE, 10);
565 gtk_container_add(GTK_CONTAINER(frame), box);
566
567 hbox = gtk_hbox_new(TRUE, 4);
568 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
569
570 cw.combo = gtk_combo_box_text_new();
571 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(cw.combo), "IPv4");
572 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(cw.combo), "IPv6");
573 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(cw.combo), "local socket");
574 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0);
575
576 gtk_container_add(GTK_CONTAINER(hbox), cw.combo);
577
578 frame = gtk_frame_new("Options");
579 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
580 box = gtk_vbox_new(FALSE, 10);
581 gtk_container_add(GTK_CONTAINER(frame), box);
582
583 hbox = gtk_hbox_new(TRUE, 4);
584 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
585
586 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend");
587 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1);
588 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.");
589 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6);
590
591 /*
592 * Connect edit signal, so we can show/not-show the auto start button
593 */
594 g_signal_connect(G_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw);
595 g_signal_connect(G_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw);
596
597 gtk_widget_show_all(dialog);
598
599 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
600 gtk_widget_destroy(dialog);
601 return 1;
602 }
603
604 ge->host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry)));
605 ge->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
606
607 typeentry = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(cw.combo));
608 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
609 ge->type = Fio_client_ipv4;
610 else if (!strncmp(typeentry, "IPv6", 4))
611 ge->type = Fio_client_ipv6;
612 else
613 ge->type = Fio_client_socket;
614 g_free(typeentry);
615
616 ge->server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button));
617
618 gtk_widget_destroy(dialog);
619 return 0;
620}
621
622static void gfio_set_client(struct gfio_client *gc, struct fio_client *client)
623{
624 gc->client = fio_get_client(client);
625 client->client_data = gc;
626}
627
628static void gfio_client_added(struct gui_entry *ge, struct fio_client *client)
629{
630 struct gfio_client_options *gco;
631 struct gfio_client *gc;
632
633 gc = calloc(1, sizeof(*gc));
634 INIT_FLIST_HEAD(&gc->o_list);
635 gc->ge = ge;
636 ge->client = gc;
637 gfio_set_client(gc, client);
638
639 /*
640 * Just add a default set of options, need to consider how best
641 * to handle this
642 */
643 gco = calloc(1, sizeof(*gco));
644 INIT_FLIST_HEAD(&gco->list);
645 options_default_fill(&gco->o);
646 flist_add_tail(&gco->list, &gc->o_list);
647 gc->o_list_nr++;
648}
649
650static void connect_clicked(GtkWidget *widget, gpointer data)
651{
652 struct gui_entry *ge = data;
653 struct gfio_client *gc = ge->client;
654
655 if (ge->state == GE_STATE_NEW) {
656 int ret;
657
658 if (!ge->job_file)
659 file_open(widget, ge->ui);
660 if (!ge->job_file)
661 return;
662
663 gc = ge->client;
664
665 if (!gc->client) {
666 struct fio_client *client;
667
668 if (get_connection_details(ge)) {
669 gfio_report_error(ge, "Failed to get connection details\n");
670 return;
671 }
672
673 client = fio_client_add_explicit(&gfio_client_ops, ge->host, ge->type, ge->port);
674 if (!client) {
675 gfio_report_error(ge, "Failed to add client %s\n", ge->host);
676 free(ge->host);
677 ge->host = NULL;
678 return;
679 }
680 gfio_set_client(gc, client);
681 }
682
683 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No jobs running");
684 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
685 ret = fio_client_connect(gc->client);
686 if (!ret) {
687 if (!ge->ui->handler_running)
688 pthread_create(&ge->ui->t, NULL, job_thread, ge->ui);
689 gfio_set_state(ge, GE_STATE_CONNECTED);
690 } else {
691 gfio_report_error(ge, "Failed to connect to %s: %s\n", ge->client->client->hostname, strerror(-ret));
692 }
693 } else {
694 fio_client_terminate(gc->client);
695 gfio_set_state(ge, GE_STATE_NEW);
696 clear_ge_ui_info(ge);
697 }
698}
699
700static void send_clicked(GtkWidget *widget, gpointer data)
701{
702 struct gui_entry *ge = data;
703
704 if (send_job_file(ge))
705 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_START], 1);
706}
707
708static GtkWidget *new_client_page(struct gui_entry *ge);
709
710static struct gui_entry *alloc_new_gui_entry(struct gui *ui)
711{
712 struct gui_entry *ge;
713
714 ge = malloc(sizeof(*ge));
715 memset(ge, 0, sizeof(*ge));
716 ge->state = GE_STATE_NEW;
717 ge->ui = ui;
718 return ge;
719}
720
721static struct gui_entry *get_new_ge_with_tab(struct gui *ui, const char *name)
722{
723 struct gui_entry *ge;
724
725 ge = alloc_new_gui_entry(ui);
726
727 ge->vbox = new_client_page(ge);
728 g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_widget_destroy), ge);
729
730 ge->page_label = gtk_label_new(name);
731 ge->page_num = gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), ge->vbox, ge->page_label);
732
733 g_hash_table_insert(ui->ge_hash, &ge->page_num, ge);
734
735 gtk_widget_show_all(ui->window);
736 return ge;
737}
738
739static void file_new(GtkWidget *w, gpointer data)
740{
741 struct gui *ui = (struct gui *) data;
742 struct gui_entry *ge;
743
744 ge = get_new_ge_with_tab(ui, "Untitled");
745 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
746}
747
748/*
749 * Return the 'ge' corresponding to the tab. If the active tab is the
750 * main tab, open a new tab.
751 */
752static struct gui_entry *get_ge_from_page(struct gui *ui, gint cur_page,
753 int *created)
754{
755 if (!cur_page) {
756 if (created)
757 *created = 1;
758 return get_new_ge_with_tab(ui, "Untitled");
759 }
760
761 if (created)
762 *created = 0;
763
764 return g_hash_table_lookup(ui->ge_hash, &cur_page);
765}
766
767static struct gui_entry *get_ge_from_cur_tab(struct gui *ui)
768{
769 gint cur_page;
770
771 /*
772 * Main tab is tab 0, so any current page other than 0 holds
773 * a ge entry.
774 */
775 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
776 if (cur_page)
777 return get_ge_from_page(ui, cur_page, NULL);
778
779 return NULL;
780}
781
782static void file_close(GtkWidget *w, gpointer data)
783{
784 struct gui *ui = (struct gui *) data;
785 struct gui_entry *ge;
786
787 /*
788 * Can't close the main tab
789 */
790 ge = get_ge_from_cur_tab(ui);
791 if (ge) {
792 gtk_widget_destroy(ge->vbox);
793 return;
794 }
795
796 if (g_hash_table_size(ui->ge_hash)) {
797 gfio_report_info(ui, "Error", "The main page view cannot be closed\n");
798 return;
799 }
800
801 gfio_quit(ui);
802}
803
804static void file_add_recent(struct gui *ui, const gchar *uri)
805{
806 GtkRecentData grd;
807
808 memset(&grd, 0, sizeof(grd));
809 grd.display_name = strdup("gfio");
810 grd.description = strdup("Fio job file");
811 grd.mime_type = strdup(GFIO_MIME);
812 grd.app_name = strdup(g_get_application_name());
813 grd.app_exec = strdup("gfio %f/%u");
814
815 gtk_recent_manager_add_full(ui->recentmanager, uri, &grd);
816}
817
818static gchar *get_filename_from_uri(const gchar *uri)
819{
820 if (strncmp(uri, "file://", 7))
821 return strdup(uri);
822
823 return strdup(uri + 7);
824}
825
826static int do_file_open(struct gui_entry *ge, const gchar *uri)
827{
828 struct fio_client *client;
829
830 assert(!ge->job_file);
831
832 ge->job_file = get_filename_from_uri(uri);
833
834 client = fio_client_add_explicit(&gfio_client_ops, ge->host, ge->type, ge->port);
835 if (client) {
836 char *label = strdup(uri);
837
838 basename(label);
839 gtk_label_set_text(GTK_LABEL(ge->page_label), basename(label));
840 free(label);
841
842 gfio_client_added(ge, client);
843 file_add_recent(ge->ui, uri);
844 return 0;
845 }
846
847 gfio_report_error(ge, "Failed to add client %s\n", ge->host);
848 free(ge->host);
849 ge->host = NULL;
850 free(ge->job_file);
851 ge->job_file = NULL;
852 return 1;
853}
854
855static int do_file_open_with_tab(struct gui *ui, const gchar *uri)
856{
857 struct gui_entry *ge;
858 gint cur_page;
859 int ret, ge_is_new = 0;
860
861 /*
862 * Creates new tab if current tab is the main window, or the
863 * current tab already has a client.
864 */
865 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
866 ge = get_ge_from_page(ui, cur_page, &ge_is_new);
867 if (ge->client) {
868 ge = get_new_ge_with_tab(ui, "Untitled");
869 ge_is_new = 1;
870 }
871
872 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
873
874 if (get_connection_details(ge)) {
875 if (ge_is_new)
876 gtk_widget_destroy(ge->vbox);
877
878 return 1;
879 }
880
881 ret = do_file_open(ge, uri);
882
883 if (!ret) {
884 if (ge->server_start)
885 gfio_start_server(ui);
886 } else {
887 if (ge_is_new)
888 gtk_widget_destroy(ge->vbox);
889 }
890
891 return ret;
892}
893
894static void recent_open(GtkAction *action, gpointer data)
895{
896 struct gui *ui = (struct gui *) data;
897 GtkRecentInfo *info;
898 const gchar *uri;
899
900 info = g_object_get_data(G_OBJECT(action), "gtk-recent-info");
901 uri = gtk_recent_info_get_uri(info);
902
903 do_file_open_with_tab(ui, uri);
904}
905
906static void file_open(GtkWidget *w, gpointer data)
907{
908 struct gui *ui = data;
909 GtkWidget *dialog;
910 GtkFileFilter *filter;
911 gchar *filename;
912
913 dialog = gtk_file_chooser_dialog_new("Open File",
914 GTK_WINDOW(ui->window),
915 GTK_FILE_CHOOSER_ACTION_OPEN,
916 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
917 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
918 NULL);
919 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), FALSE);
920
921 filter = gtk_file_filter_new();
922 gtk_file_filter_add_pattern(filter, "*.fio");
923 gtk_file_filter_add_pattern(filter, "*.job");
924 gtk_file_filter_add_pattern(filter, "*.ini");
925 gtk_file_filter_add_mime_type(filter, GFIO_MIME);
926 gtk_file_filter_set_name(filter, "Fio job file");
927 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
928
929 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
930 gtk_widget_destroy(dialog);
931 return;
932 }
933
934 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
935
936 gtk_widget_destroy(dialog);
937
938 do_file_open_with_tab(ui, filename);
939 g_free(filename);
940}
941
942static void file_save(GtkWidget *w, gpointer data)
943{
944 struct gui *ui = data;
945 GtkWidget *dialog;
946
947 dialog = gtk_file_chooser_dialog_new("Save File",
948 GTK_WINDOW(ui->window),
949 GTK_FILE_CHOOSER_ACTION_SAVE,
950 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
951 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
952 NULL);
953
954 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
955 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
956
957 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
958 char *filename;
959
960 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
961 // save_job_file(filename);
962 g_free(filename);
963 }
964 gtk_widget_destroy(dialog);
965}
966
967static void view_log_destroy(GtkWidget *w, gpointer data)
968{
969 struct gui *ui = (struct gui *) data;
970
971 g_object_ref(G_OBJECT(ui->log_tree));
972 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree);
973 gtk_widget_destroy(w);
974 ui->log_view = NULL;
975}
976
977void gfio_view_log(struct gui *ui)
978{
979 GtkWidget *win, *scroll, *vbox, *box;
980
981 if (ui->log_view)
982 return;
983
984 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
985 gtk_window_set_title(GTK_WINDOW(win), "Log");
986 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500);
987
988 scroll = gtk_scrolled_window_new(NULL, NULL);
989
990 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
991
992 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
993
994 box = gtk_hbox_new(TRUE, 0);
995 gtk_box_pack_start(GTK_BOX(box), ui->log_tree, TRUE, TRUE, 0);
996 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui);
997 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box);
998
999 vbox = gtk_vbox_new(TRUE, 5);
1000 gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0);
1001
1002 gtk_container_add(GTK_CONTAINER(win), vbox);
1003 gtk_widget_show_all(win);
1004}
1005
1006static void view_log(GtkWidget *w, gpointer data)
1007{
1008 struct gui *ui = (struct gui *) data;
1009
1010 gfio_view_log(ui);
1011}
1012
1013static void connect_job_entry(GtkWidget *w, gpointer data)
1014{
1015 struct gui *ui = (struct gui *) data;
1016 struct gui_entry *ge;
1017
1018 ge = get_ge_from_cur_tab(ui);
1019 if (ge)
1020 connect_clicked(w, ge);
1021}
1022
1023static void send_job_entry(GtkWidget *w, gpointer data)
1024{
1025 struct gui *ui = (struct gui *) data;
1026 struct gui_entry *ge;
1027
1028 ge = get_ge_from_cur_tab(ui);
1029 if (ge)
1030 send_clicked(w, ge);
1031}
1032
1033static void edit_job_entry(GtkWidget *w, gpointer data)
1034{
1035 struct gui *ui = (struct gui *) data;
1036 struct gui_entry *ge;
1037
1038 ge = get_ge_from_cur_tab(ui);
1039 if (ge && ge->client)
1040 gopt_get_options_window(ui->window, ge->client);
1041}
1042
1043static void start_job_entry(GtkWidget *w, gpointer data)
1044{
1045 struct gui *ui = (struct gui *) data;
1046 struct gui_entry *ge;
1047
1048 ge = get_ge_from_cur_tab(ui);
1049 if (ge)
1050 start_job_clicked(w, ge);
1051}
1052
1053static void view_results(GtkWidget *w, gpointer data)
1054{
1055 struct gui *ui = (struct gui *) data;
1056 struct gfio_client *gc;
1057 struct gui_entry *ge;
1058
1059 ge = get_ge_from_cur_tab(ui);
1060 if (!ge)
1061 return;
1062
1063 if (ge->results_window)
1064 return;
1065
1066 gc = ge->client;
1067 if (gc && gc->nr_results)
1068 gfio_display_end_results(gc);
1069}
1070
1071static void __update_graph_settings(struct gfio_graphs *g)
1072{
1073 line_graph_set_data_count_limit(g->iops_graph, gfio_graph_limit);
1074 graph_set_font(g->iops_graph, gfio_graph_font);
1075 line_graph_set_data_count_limit(g->bandwidth_graph, gfio_graph_limit);
1076 graph_set_font(g->bandwidth_graph, gfio_graph_font);
1077}
1078
1079static void ge_update_settings_fn(gpointer key, gpointer value, gpointer data)
1080{
1081 struct gui_entry *ge = (struct gui_entry *) value;
1082 GdkEvent *ev;
1083
1084 __update_graph_settings(&ge->graphs);
1085
1086 ev = gdk_event_new(GDK_EXPOSE);
1087 g_signal_emit_by_name(G_OBJECT(ge->graphs.drawing_area), "expose_event", GTK_WIDGET(ge->graphs.drawing_area), ev, &ge->graphs);
1088 gdk_event_free(ev);
1089}
1090
1091static void update_graph_limits(void)
1092{
1093 struct gui *ui = &main_ui;
1094 GdkEvent *ev;
1095
1096 __update_graph_settings(&ui->graphs);
1097
1098 ev = gdk_event_new(GDK_EXPOSE);
1099 g_signal_emit_by_name(G_OBJECT(ui->graphs.drawing_area), "expose_event", GTK_WIDGET(ui->graphs.drawing_area), ev, &ui->graphs);
1100 gdk_event_free(ev);
1101
1102 g_hash_table_foreach(ui->ge_hash, ge_update_settings_fn, NULL);
1103}
1104
1105static void preferences(GtkWidget *w, gpointer data)
1106{
1107 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font;
1108 GtkWidget *hbox, *spin, *entry, *spin_int;
1109 struct gui *ui = (struct gui *) data;
1110 int i;
1111
1112 dialog = gtk_dialog_new_with_buttons("Preferences",
1113 GTK_WINDOW(ui->window),
1114 GTK_DIALOG_DESTROY_WITH_PARENT,
1115 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1116 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1117 NULL);
1118
1119 frame = gtk_frame_new("Graphing");
1120 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1121 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1122 vbox = gtk_vbox_new(FALSE, 6);
1123 gtk_container_add(GTK_CONTAINER(frame), vbox);
1124
1125 hbox = gtk_hbox_new(FALSE, 5);
1126 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
1127 entry = gtk_label_new("Font face to use for graph labels");
1128 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5);
1129
1130 font = gtk_font_button_new_with_font(gfio_graph_font);
1131 gtk_box_pack_start(GTK_BOX(hbox), font, FALSE, FALSE, 5);
1132
1133 box = gtk_vbox_new(FALSE, 6);
1134 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
1135
1136 hbox = gtk_hbox_new(FALSE, 5);
1137 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
1138 entry = gtk_label_new("Maximum number of data points in graph (seconds)");
1139 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
1140
1141 spin = create_spinbutton(hbox, 10, 1000000, gfio_graph_limit);
1142
1143 box = gtk_vbox_new(FALSE, 6);
1144 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
1145
1146 hbox = gtk_hbox_new(FALSE, 5);
1147 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
1148 entry = gtk_label_new("Client ETA request interval (msec)");
1149 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
1150
1151 spin_int = create_spinbutton(hbox, 100, 100000, gfio_client_ops.eta_msec);
1152 frame = gtk_frame_new("Debug logging");
1153 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1154 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1155 vbox = gtk_vbox_new(FALSE, 6);
1156 gtk_container_add(GTK_CONTAINER(frame), vbox);
1157
1158 box = gtk_hbox_new(FALSE, 6);
1159 gtk_container_add(GTK_CONTAINER(vbox), box);
1160
1161 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
1162
1163 for (i = 0; i < FD_DEBUG_MAX; i++) {
1164 if (i == 7) {
1165 box = gtk_hbox_new(FALSE, 6);
1166 gtk_container_add(GTK_CONTAINER(vbox), box);
1167 }
1168
1169
1170 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
1171 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
1172 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
1173 }
1174
1175 gtk_widget_show_all(dialog);
1176
1177 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1178 gtk_widget_destroy(dialog);
1179 return;
1180 }
1181
1182 for (i = 0; i < FD_DEBUG_MAX; i++) {
1183 int set;
1184
1185 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
1186 if (set)
1187 fio_debug |= (1UL << i);
1188 }
1189
1190 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
1191 gfio_graph_limit = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
1192 update_graph_limits();
1193 gfio_client_ops.eta_msec = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin_int));
1194
1195 gtk_widget_destroy(dialog);
1196}
1197
1198static void about_dialog(GtkWidget *w, gpointer data)
1199{
1200 const char *authors[] = {
1201 "Jens Axboe <axboe@kernel.dk>",
1202 "Stephen Carmeron <stephenmcameron@gmail.com>",
1203 NULL
1204 };
1205 const char *license[] = {
1206 "Fio is free software; you can redistribute it and/or modify "
1207 "it under the terms of the GNU General Public License as published by "
1208 "the Free Software Foundation; either version 2 of the License, or "
1209 "(at your option) any later version.\n",
1210 "Fio is distributed in the hope that it will be useful, "
1211 "but WITHOUT ANY WARRANTY; without even the implied warranty of "
1212 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
1213 "GNU General Public License for more details.\n",
1214 "You should have received a copy of the GNU General Public License "
1215 "along with Fio; if not, write to the Free Software Foundation, Inc., "
1216 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
1217 };
1218 char *license_trans;
1219
1220 license_trans = g_strconcat(license[0], "\n", license[1], "\n",
1221 license[2], "\n", NULL);
1222
1223 gtk_show_about_dialog(NULL,
1224 "program-name", "gfio",
1225 "comments", "Gtk2 UI for fio",
1226 "license", license_trans,
1227 "website", "http://git.kernel.dk/?p=fio.git;a=summary",
1228 "authors", authors,
1229 "version", fio_version_string,
1230 "copyright", "© 2012 Jens Axboe <axboe@kernel.dk>",
1231 "logo-icon-name", "fio",
1232 /* Must be last: */
1233 "wrap-license", TRUE,
1234 NULL);
1235
1236 g_free(license_trans);
1237}
1238
1239static GtkActionEntry menu_items[] = {
1240 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
1241 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
1242 { "JobMenuAction", GTK_STOCK_FILE, "Job", NULL, NULL, NULL},
1243 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
1244 { "NewFile", GTK_STOCK_NEW, "New", "<Control>N", NULL, G_CALLBACK(file_new) },
1245 { "CloseFile", GTK_STOCK_CLOSE, "Close", "<Control>W", NULL, G_CALLBACK(file_close) },
1246 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
1247 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
1248 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
1249 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) },
1250 { "ViewResults", NULL, "Results", "<Control>R", NULL, G_CALLBACK(view_results) },
1251 { "ConnectJob", NULL, "Connect", "<Control>D", NULL, G_CALLBACK(connect_job_entry) },
1252 { "EditJob", NULL, "Edit job", "<Control>E", NULL, G_CALLBACK(edit_job_entry) },
1253 { "SendJob", NULL, "Send job", "<Control>X", NULL, G_CALLBACK(send_job_entry) },
1254 { "StartJob", NULL, "Start job", "<Control>L", NULL, G_CALLBACK(start_job_entry) },
1255 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
1256 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
1257};
1258static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
1259
1260static const gchar *ui_string = " \
1261 <ui> \
1262 <menubar name=\"MainMenu\"> \
1263 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
1264 <menuitem name=\"New\" action=\"NewFile\" /> \
1265 <menuitem name=\"Open\" action=\"OpenFile\" /> \
1266 <menuitem name=\"Close\" action=\"CloseFile\" /> \
1267 <separator name=\"Separator1\"/> \
1268 <menuitem name=\"Save\" action=\"SaveFile\" /> \
1269 <separator name=\"Separator2\"/> \
1270 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
1271 <separator name=\"Separator3\"/> \
1272 <placeholder name=\"FileRecentFiles\"/> \
1273 <separator name=\"Separator4\"/> \
1274 <menuitem name=\"Quit\" action=\"Quit\" /> \
1275 </menu> \
1276 <menu name=\"JobMenu\" action=\"JobMenuAction\"> \
1277 <menuitem name=\"Connect\" action=\"ConnectJob\" /> \
1278 <separator name=\"Separator5\"/> \
1279 <menuitem name=\"Edit job\" action=\"EditJob\" /> \
1280 <menuitem name=\"Send job\" action=\"SendJob\" /> \
1281 <separator name=\"Separator6\"/> \
1282 <menuitem name=\"Start job\" action=\"StartJob\" /> \
1283 </menu>\
1284 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
1285 <menuitem name=\"Results\" action=\"ViewResults\" /> \
1286 <separator name=\"Separator7\"/> \
1287 <menuitem name=\"Log\" action=\"ViewLog\" /> \
1288 </menu>\
1289 <menu name=\"Help\" action=\"HelpMenuAction\"> \
1290 <menuitem name=\"About\" action=\"About\" /> \
1291 </menu> \
1292 </menubar> \
1293 </ui> \
1294";
1295
1296static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager,
1297 struct gui *ui)
1298{
1299 GtkActionGroup *action_group;
1300 GError *error = 0;
1301
1302 action_group = gtk_action_group_new("Menu");
1303 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui);
1304
1305 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
1306 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
1307
1308 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
1309
1310 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
1311}
1312
1313void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
1314 GtkWidget *vbox, GtkUIManager *ui_manager)
1315{
1316 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
1317}
1318
1319static void combo_entry_changed(GtkComboBox *box, gpointer data)
1320{
1321 struct gui_entry *ge = (struct gui_entry *) data;
1322 gint index;
1323
1324 index = gtk_combo_box_get_active(box);
1325
1326 multitext_set_entry(&ge->eta.iotype, index);
1327 multitext_set_entry(&ge->eta.bs, index);
1328 multitext_set_entry(&ge->eta.ioengine, index);
1329 multitext_set_entry(&ge->eta.iodepth, index);
1330}
1331
1332static void combo_entry_destroy(GtkWidget *widget, gpointer data)
1333{
1334 struct gui_entry *ge = (struct gui_entry *) data;
1335
1336 multitext_free(&ge->eta.iotype);
1337 multitext_free(&ge->eta.bs);
1338 multitext_free(&ge->eta.ioengine);
1339 multitext_free(&ge->eta.iodepth);
1340}
1341
1342static GtkWidget *new_client_page(struct gui_entry *ge)
1343{
1344 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
1345 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
1346
1347 main_vbox = gtk_vbox_new(FALSE, 3);
1348
1349 top_align = gtk_alignment_new(0, 0, 1, 0);
1350 top_vbox = gtk_vbox_new(FALSE, 3);
1351 gtk_container_add(GTK_CONTAINER(top_align), top_vbox);
1352 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0);
1353
1354 probe = gtk_frame_new("Job");
1355 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
1356 probe_frame = gtk_vbox_new(FALSE, 3);
1357 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1358
1359 probe_box = gtk_hbox_new(FALSE, 3);
1360 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
1361 ge->probe.hostname = new_info_label_in_frame(probe_box, "Host");
1362 ge->probe.os = new_info_label_in_frame(probe_box, "OS");
1363 ge->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
1364 ge->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
1365
1366 probe_box = gtk_hbox_new(FALSE, 3);
1367 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
1368
1369 ge->eta.names = new_combo_entry_in_frame(probe_box, "Jobs");
1370 g_signal_connect(ge->eta.names, "changed", G_CALLBACK(combo_entry_changed), ge);
1371 g_signal_connect(ge->eta.names, "destroy", G_CALLBACK(combo_entry_destroy), ge);
1372 ge->eta.iotype.entry = new_info_entry_in_frame(probe_box, "IO");
1373 ge->eta.bs.entry = new_info_entry_in_frame(probe_box, "Blocksize (Read/Write)");
1374 ge->eta.ioengine.entry = new_info_entry_in_frame(probe_box, "IO Engine");
1375 ge->eta.iodepth.entry = new_info_entry_in_frame(probe_box, "IO Depth");
1376 ge->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
1377 ge->eta.files = new_info_entry_in_frame(probe_box, "Open files");
1378
1379 probe_box = gtk_hbox_new(FALSE, 3);
1380 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
1381 ge->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
1382 ge->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
1383 ge->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
1384 ge->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
1385
1386 /*
1387 * Only add this if we have a commit rate
1388 */
1389#if 0
1390 probe_box = gtk_hbox_new(FALSE, 3);
1391 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1392
1393 ge->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1394 ge->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1395
1396 ge->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1397 ge->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1398#endif
1399
1400 /*
1401 * Set up a drawing area and IOPS and bandwidth graphs
1402 */
1403 ge->graphs.drawing_area = gtk_drawing_area_new();
1404 gtk_widget_set_size_request(GTK_WIDGET(ge->graphs.drawing_area),
1405 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
1406 gtk_widget_modify_bg(ge->graphs.drawing_area, GTK_STATE_NORMAL, &gfio_color_white);
1407 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "expose_event",
1408 G_CALLBACK(on_expose_drawing_area), &ge->graphs);
1409 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "configure_event",
1410 G_CALLBACK(on_config_drawing_area), &ge->graphs);
1411 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1412 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
1413 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1414 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1415 ge->graphs.drawing_area);
1416 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window, TRUE, TRUE, 0);
1417
1418 setup_graphs(&ge->graphs);
1419
1420 /*
1421 * Set up alignments for widgets at the bottom of ui,
1422 * align bottom left, expand horizontally but not vertically
1423 */
1424 bottom_align = gtk_alignment_new(0, 1, 1, 0);
1425 ge->buttonbox = gtk_hbox_new(FALSE, 0);
1426 gtk_container_add(GTK_CONTAINER(bottom_align), ge->buttonbox);
1427 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0);
1428
1429 add_buttons(ge, buttonspeclist, ARRAY_SIZE(buttonspeclist));
1430
1431 /*
1432 * Set up thread status progress bar
1433 */
1434 ge->thread_status_pb = gtk_progress_bar_new();
1435 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
1436 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No connections");
1437 gtk_container_add(GTK_CONTAINER(ge->buttonbox), ge->thread_status_pb);
1438
1439
1440 return main_vbox;
1441}
1442
1443static GtkWidget *new_main_page(struct gui *ui)
1444{
1445 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
1446 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
1447
1448 main_vbox = gtk_vbox_new(FALSE, 3);
1449
1450 /*
1451 * Set up alignments for widgets at the top of ui,
1452 * align top left, expand horizontally but not vertically
1453 */
1454 top_align = gtk_alignment_new(0, 0, 1, 0);
1455 top_vbox = gtk_vbox_new(FALSE, 0);
1456 gtk_container_add(GTK_CONTAINER(top_align), top_vbox);
1457 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0);
1458
1459 probe = gtk_frame_new("Run statistics");
1460 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
1461 probe_frame = gtk_vbox_new(FALSE, 3);
1462 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1463
1464 probe_box = gtk_hbox_new(FALSE, 3);
1465 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
1466 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Running");
1467 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
1468 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
1469 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
1470 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
1471
1472 /*
1473 * Only add this if we have a commit rate
1474 */
1475#if 0
1476 probe_box = gtk_hbox_new(FALSE, 3);
1477 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1478
1479 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1480 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1481
1482 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1483 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1484#endif
1485
1486 /*
1487 * Set up a drawing area and IOPS and bandwidth graphs
1488 */
1489 ui->graphs.drawing_area = gtk_drawing_area_new();
1490 gtk_widget_set_size_request(GTK_WIDGET(ui->graphs.drawing_area),
1491 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
1492 gtk_widget_modify_bg(ui->graphs.drawing_area, GTK_STATE_NORMAL, &gfio_color_white);
1493 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "expose_event",
1494 G_CALLBACK(on_expose_drawing_area), &ui->graphs);
1495 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "configure_event",
1496 G_CALLBACK(on_config_drawing_area), &ui->graphs);
1497 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1498 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
1499 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1500 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1501 ui->graphs.drawing_area);
1502 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window,
1503 TRUE, TRUE, 0);
1504
1505 setup_graphs(&ui->graphs);
1506
1507 /*
1508 * Set up alignments for widgets at the bottom of ui,
1509 * align bottom left, expand horizontally but not vertically
1510 */
1511 bottom_align = gtk_alignment_new(0, 1, 1, 0);
1512 ui->buttonbox = gtk_hbox_new(FALSE, 0);
1513 gtk_container_add(GTK_CONTAINER(bottom_align), ui->buttonbox);
1514 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0);
1515
1516 /*
1517 * Set up thread status progress bar
1518 */
1519 ui->thread_status_pb = gtk_progress_bar_new();
1520 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
1521 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
1522 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
1523
1524 return main_vbox;
1525}
1526
1527static gboolean notebook_switch_page(GtkNotebook *notebook, GtkWidget *widget,
1528 guint page, gpointer data)
1529
1530{
1531 struct gui *ui = (struct gui *) data;
1532 struct gui_entry *ge;
1533
1534 if (!page) {
1535 set_job_menu_visible(ui, 0);
1536 set_view_results_visible(ui, 0);
1537 return TRUE;
1538 }
1539
1540 set_job_menu_visible(ui, 1);
1541 ge = get_ge_from_page(ui, page, NULL);
1542 if (ge)
1543 update_button_states(ui, ge);
1544
1545 return TRUE;
1546}
1547
1548static gint compare_recent_items(GtkRecentInfo *a, GtkRecentInfo *b)
1549{
1550 time_t time_a = gtk_recent_info_get_visited(a);
1551 time_t time_b = gtk_recent_info_get_visited(b);
1552
1553 return time_b - time_a;
1554}
1555
1556static void add_recent_file_items(struct gui *ui)
1557{
1558 const gchar *gfio = g_get_application_name();
1559 GList *items, *item;
1560 int i = 0;
1561
1562 if (ui->recent_ui_id) {
1563 gtk_ui_manager_remove_ui(ui->uimanager, ui->recent_ui_id);
1564 gtk_ui_manager_ensure_update(ui->uimanager);
1565 }
1566 ui->recent_ui_id = gtk_ui_manager_new_merge_id(ui->uimanager);
1567
1568 if (ui->actiongroup) {
1569 gtk_ui_manager_remove_action_group(ui->uimanager, ui->actiongroup);
1570 g_object_unref(ui->actiongroup);
1571 }
1572 ui->actiongroup = gtk_action_group_new("RecentFileActions");
1573
1574 gtk_ui_manager_insert_action_group(ui->uimanager, ui->actiongroup, -1);
1575
1576 items = gtk_recent_manager_get_items(ui->recentmanager);
1577 items = g_list_sort(items, (GCompareFunc) compare_recent_items);
1578
1579 for (item = items; item && item->data; item = g_list_next(item)) {
1580 GtkRecentInfo *info = (GtkRecentInfo *) item->data;
1581 gchar *action_name;
1582 const gchar *label;
1583 GtkAction *action;
1584
1585 if (!gtk_recent_info_has_application(info, gfio))
1586 continue;
1587
1588 /*
1589 * We only support local files for now
1590 */
1591 if (!gtk_recent_info_is_local(info) || !gtk_recent_info_exists(info))
1592 continue;
1593
1594 action_name = g_strdup_printf("RecentFile%u", i++);
1595 label = gtk_recent_info_get_display_name(info);
1596
1597 action = g_object_new(GTK_TYPE_ACTION,
1598 "name", action_name,
1599 "label", label, NULL);
1600
1601 g_object_set_data_full(G_OBJECT(action), "gtk-recent-info",
1602 gtk_recent_info_ref(info),
1603 (GDestroyNotify) gtk_recent_info_unref);
1604
1605
1606 g_signal_connect(action, "activate", G_CALLBACK(recent_open), ui);
1607
1608 gtk_action_group_add_action(ui->actiongroup, action);
1609 g_object_unref(action);
1610
1611 gtk_ui_manager_add_ui(ui->uimanager, ui->recent_ui_id,
1612 "/MainMenu/FileMenu/FileRecentFiles",
1613 label, action_name,
1614 GTK_UI_MANAGER_MENUITEM, FALSE);
1615
1616 g_free(action_name);
1617
1618 if (i == 8)
1619 break;
1620 }
1621
1622 g_list_foreach(items, (GFunc) gtk_recent_info_unref, NULL);
1623 g_list_free(items);
1624}
1625
1626static void drag_and_drop_received(GtkWidget *widget, GdkDragContext *ctx,
1627 gint x, gint y, GtkSelectionData *seldata,
1628 guint info, guint time, gpointer *data)
1629{
1630 struct gui *ui = (struct gui *) data;
1631 gchar **uris;
1632 GtkWidget *source;
1633
1634 source = gtk_drag_get_source_widget(ctx);
1635 if (source && widget == gtk_widget_get_toplevel(source)) {
1636 gtk_drag_finish(ctx, FALSE, FALSE, time);
1637 return;
1638 }
1639
1640 uris = gtk_selection_data_get_uris(seldata);
1641 if (!uris) {
1642 gtk_drag_finish(ctx, FALSE, FALSE, time);
1643 return;
1644 }
1645
1646 if (uris[0])
1647 do_file_open_with_tab(ui, uris[0]);
1648
1649 gtk_drag_finish(ctx, TRUE, FALSE, time);
1650 g_strfreev(uris);
1651}
1652
1653static void init_ui(int *argc, char **argv[], struct gui *ui)
1654{
1655 GtkSettings *settings;
1656 GtkWidget *vbox;
1657
1658 /* Magical g*thread incantation, you just need this thread stuff.
1659 * Without it, the update that happens in gfio_update_thread_status
1660 * doesn't really happen in a timely fashion, you need expose events
1661 */
1662 if (!g_thread_supported())
1663 g_thread_init(NULL);
1664 gdk_threads_init();
1665
1666 gtk_init(argc, argv);
1667 settings = gtk_settings_get_default();
1668 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
1669 g_type_init();
1670 gdk_color_parse("white", &gfio_color_white);
1671
1672 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1673 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
1674 gtk_window_set_default_size(GTK_WINDOW(ui->window), 1024, 768);
1675
1676 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), ui);
1677 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), ui);
1678
1679 ui->vbox = gtk_vbox_new(FALSE, 0);
1680 gtk_container_add(GTK_CONTAINER(ui->window), ui->vbox);
1681
1682 ui->uimanager = gtk_ui_manager_new();
1683 ui->menu = get_menubar_menu(ui->window, ui->uimanager, ui);
1684 gfio_ui_setup(settings, ui->menu, ui->vbox, ui->uimanager);
1685
1686 ui->recentmanager = gtk_recent_manager_get_default();
1687 add_recent_file_items(ui);
1688
1689 ui->notebook = gtk_notebook_new();
1690 g_signal_connect(ui->notebook, "switch-page", G_CALLBACK(notebook_switch_page), ui);
1691 gtk_notebook_set_scrollable(GTK_NOTEBOOK(ui->notebook), 1);
1692 gtk_notebook_popup_enable(GTK_NOTEBOOK(ui->notebook));
1693 gtk_container_add(GTK_CONTAINER(ui->vbox), ui->notebook);
1694
1695 vbox = new_main_page(ui);
1696 gtk_drag_dest_set(GTK_WIDGET(ui->window), GTK_DEST_DEFAULT_ALL, NULL, 1, GDK_ACTION_COPY);
1697 gtk_drag_dest_add_uri_targets(GTK_WIDGET(ui->window));
1698 g_signal_connect(ui->window, "drag-data-received", G_CALLBACK(drag_and_drop_received), ui);
1699
1700 gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), vbox, gtk_label_new("Main"));
1701
1702 gfio_ui_setup_log(ui);
1703
1704 gtk_widget_show_all(ui->window);
1705}
1706
1707int main(int argc, char *argv[], char *envp[])
1708{
1709 if (initialize_fio(envp))
1710 return 1;
1711 if (fio_init_options())
1712 return 1;
1713
1714 gopt_init();
1715
1716 memset(&main_ui, 0, sizeof(main_ui));
1717 main_ui.ge_hash = g_hash_table_new(g_int_hash, g_int_equal);
1718
1719 init_ui(&argc, &argv, &main_ui);
1720
1721 gdk_threads_enter();
1722 gtk_main();
1723 gdk_threads_leave();
1724
1725 g_hash_table_destroy(main_ui.ge_hash);
1726
1727 gopt_exit();
1728 return 0;
1729}
fio - Flexible IO Tester