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