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