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