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