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