#include <string.h>
#include "ui.h"
GList *all_cpus = NULL;
GList *all_irqs = NULL;
char *IRQ_CLASS_TO_STR[] = {
"Other",
"Legacy",
"SCSI",
"Video",
"Ethernet",
"Gigabit Ethernet",
"10-Gigabit Ethernet,"
"Virt Event"};
void show_frame()
{
int i;
attrset(COLOR_PAIR(4));
char top[COLS];
top[0] = '\0';
while(strlen(top) != (size_t)COLS - 1) {
snprintf(top + strlen(top), COLS - strlen(top), " ");
}
mvprintw(0, 0, top);
for(i = 0; i < LINES; i++) {
mvprintw(i, 0, " ");
mvprintw(i, COLS - 1, " ");
}
}
void show_footer()
{
char footer[COLS];
snprintf(footer, COLS - 1,
" q (QUIT) F3 (TREE) F4 (SETTINGS) F5 (SETUP IRQS)");
while(strlen(footer) != (size_t)COLS - 1) {
snprintf(footer + strlen(footer), COLS - strlen(footer), " ");
}
attrset(COLOR_PAIR(4));
mvprintw(LINES - 1, 0, footer);
}
char * check_control_in_sleep_input(int max_len, int column_offest, int line_offset)
{
char *input_to = malloc(max_len * sizeof(char));
int iteration = 0;
while(iteration < max_len) {
int new = getch();
switch(new) {
case ERR:
/* No input is ready for nonblocking getch() call */
break;
case '\r':
case '\n':
input_to[iteration] = '\0';
return input_to;
case 'q':
close_window(0);
break;
case KEY_BACKSPACE:
if(iteration > 0) {
attrset(COLOR_PAIR(5));
iteration--;
mvaddch(line_offset, column_offest + iteration, ' ');
}
move(line_offset, column_offest + iteration);
attrset(COLOR_PAIR(6));
break;
case 27:
free(input_to);
return NULL;
default:
input_to[iteration] = new;
iteration++;
break;
}
}
return input_to;
}
int get_valid_sleep_input(int column_offest)
{
uint64_t new_sleep = setup.sleep;
while(1) {
attrset(COLOR_PAIR(5));
mvprintw(2, column_offest, " ");
attrset(COLOR_PAIR(6));
refresh();
move(2, column_offest);
curs_set(1);
char *input = check_control_in_sleep_input(20, column_offest, 3);
if(input == NULL) {
curs_set(0);
attrset(COLOR_PAIR(1));
mvprintw(2, column_offest, "%lu ", new_sleep);
move(LINES, COLS);
break;
}
attrset(COLOR_PAIR(1));
mvprintw(LINES - 2, 1, " ");
curs_set(0);
refresh();
char *error;
new_sleep = strtol(input, &error, 10);
if((*error == '\0') && (new_sleep >= 1)) {
break;
} else {
new_sleep = setup.sleep;
attrset(COLOR_PAIR(4));
mvprintw(LINES - 2, 1,
"Invalid input: %s ",
input);
refresh();
}
free(input);
}
attrset(COLOR_PAIR(1));
mvprintw(2, column_offest, "%lu ", new_sleep);
return new_sleep;
}
void get_banned_cpu(int *cpu, void *data __attribute__((unused)))
{
cpu_ban_t *new = malloc(sizeof(cpu_ban_t));
new->number = *cpu;
new->is_banned = 1;
all_cpus = g_list_append(all_cpus, new);
}
void print_cpu_line(cpu_ban_t *cpu, void *data)
{
int *line_offset = data;
if(cpu->is_banned) {
attrset(COLOR_PAIR(10));
} else {
attrset(COLOR_PAIR(9));
}
mvprintw(*line_offset, 3, "CPU %d", cpu->number);
mvprintw(*line_offset, 19, "%s", cpu->is_banned ?
"YES " :
"NO ");
(*line_offset)++;
}
void print_all_cpus()
{
if(all_cpus == NULL) {
for_each_node(tree, get_cpu, NULL);
for_each_int(setup.banned_cpus, get_banned_cpu, NULL);
all_cpus = g_list_sort(all_cpus, sort_all_cpus);
}
int *line = malloc(sizeof(int));
*line = 6;
attrset(COLOR_PAIR(2));
mvprintw(4, 3, "NUMBER IS BANNED");
for_each_cpu(all_cpus, print_cpu_line, line);
}
void add_banned_cpu(int *banned_cpu, void *data)
{
snprintf(data + strlen(data), 1024 - strlen(data), "%d, ", *banned_cpu);
}
void display_banned_cpus()
{
char banned_cpus[1024] = "Banned CPU numbers: \0";
if(g_list_length(setup.banned_cpus) > 0) {
for_each_int(setup.banned_cpus, add_banned_cpu, banned_cpus);
snprintf(banned_cpus + strlen(banned_cpus) - 2,
1024 - strlen(banned_cpus), "\n");
} else {
snprintf(banned_cpus + strlen(banned_cpus),
1024 - strlen(banned_cpus), "None\n");
}
attrset(COLOR_PAIR(0));
mvprintw(2, 5, "%s\n", banned_cpus);
}
int toggle_cpu(GList *cpu_list, int cpu_number)
{
GList *entry = g_list_first(cpu_list);
cpu_ban_t *entry_data = (cpu_ban_t *)(entry->data);
while(entry_data->number != cpu_number) {
entry = g_list_next(entry);
entry_data = (cpu_ban_t *)(entry->data);
}
if(((cpu_ban_t *)(entry->data))->is_banned) {
((cpu_ban_t *)(entry->data))->is_banned = 0;
} else {
((cpu_ban_t *)(entry->data))->is_banned = 1;
}
return ((cpu_ban_t *)(entry->data))->is_banned;
}
void get_new_cpu_ban_values(cpu_ban_t *cpu, void *data)
{
char *mask_data = (char *)data;
if(cpu->is_banned) {
snprintf(mask_data + strlen(mask_data), 1024 - strlen(mask_data),
"%d,", cpu->number);
}
}
void get_cpu(cpu_node_t *node, void *data __attribute__((unused)))
{
if(node->type == OBJ_TYPE_CPU) {
cpu_ban_t *new = malloc(sizeof(cpu_ban_t));
new->number = node->number;
new->is_banned = 0;
all_cpus = g_list_append(all_cpus, new);
}
if(g_list_length(node->children) > 0) {
for_each_node(node->children, get_cpu, NULL);
}
}
void handle_cpu_banning()
{
GList *tmp = g_list_copy_deep(all_cpus, copy_cpu_ban, NULL);
attrset(COLOR_PAIR(5));
mvprintw(LINES - 3, 1, "Move up and down the list, toggle ban with Enter.");
mvprintw(LINES - 2, 1,
"Press ESC for discarding and <S> for saving the values.");
move(6, 19);
curs_set(1);
refresh();
size_t position = 5;
char processing = 1;
while(processing) {
int direction = getch();
switch(direction) {
case KEY_UP:
if(position > 6) {
position--;
move(position, 19);
}
break;
case KEY_DOWN:
if(position <= g_list_length(all_cpus) + 4) {
position++;
move(position, 19);
}
break;
case '\n':
case '\r': {
attrset(COLOR_PAIR(3));
int banned = toggle_cpu(tmp, position - 6);
if(banned) {
mvprintw(position, 19, "YES");
} else {
mvprintw(position, 19, "NO ");
}
move(position, 19);
refresh();
break;
}
case 27:
processing = 0;
curs_set(0);
/* Forget the changes */
tmp = g_list_copy_deep(all_cpus, copy_cpu_ban, NULL);
print_all_cpus();
attrset(COLOR_PAIR(0));
mvprintw(LINES - 3, 1, " \
");
attrset(COLOR_PAIR(5));
mvprintw(LINES - 2, 1,
"Press <S> for changing sleep setup, <C> for CPU ban setup. ");
move(LINES - 1, COLS - 1);
refresh();
break;
case 's':
processing = 0;
all_cpus = tmp;
curs_set(0);
print_all_cpus();
attrset(COLOR_PAIR(0));
mvprintw(LINES - 3, 1, " \
");
attrset(COLOR_PAIR(5));
mvprintw(LINES - 2, 1,
"Press <S> for changing sleep setup, <C> for CPU ban setup. ");
attrset(COLOR_PAIR(3));
move(LINES - 1, COLS - 1);
refresh();
char settings_string[1024] = "settings cpus \0";
for_each_cpu(all_cpus, get_new_cpu_ban_values, settings_string);
if(!strcmp("settings cpus \0", settings_string)) {
strncpy(settings_string + strlen(settings_string),
"NULL", 1024 - strlen(settings_string));
}
send_settings(settings_string);
break;
case 'q':
processing = 0;
close_window(0);
break;
case KEY_F(3):
is_tree = 1;
processing = 0;
display_tree();
break;
case KEY_F(5):
is_tree = 0;
processing = 0;
setup_irqs();
break;
default:
break;
}
}
}
void copy_assigned_obj(int *number, void *data)
{
snprintf(data + strlen(data), 128 - strlen(data), "%d, ", *number);
}
void print_assigned_objects_string(irq_t *irq, int *line_offset)
{
if(irq->is_banned) {
return;
}
char assigned_to[128] = "\0";
for_each_int(irq->assigned_to, copy_assigned_obj, assigned_to);
assigned_to[strlen(assigned_to) - 2] = '\0';
mvprintw(*line_offset, 36, assigned_to);
}
void print_irq_line(irq_t *irq, void *data)
{
int *line_offset = data;
switch(irq->class) {
case(IRQ_OTHER):
attrset(COLOR_PAIR(1));
break;
case(IRQ_LEGACY):
attrset(COLOR_PAIR(2));
break;
case(IRQ_SCSI):
attrset(COLOR_PAIR(3));
break;
case(IRQ_VIDEO):
attrset(COLOR_PAIR(8));
break;
case(IRQ_ETH):
case(IRQ_GBETH):
case(IRQ_10GBETH):
attrset(COLOR_PAIR(9));
break;
case(IRQ_VIRT_EVENT):
attrset(COLOR_PAIR(10));
break;
default:
attrset(COLOR_PAIR(0));
break;
}
mvprintw(*line_offset, 3, "IRQ %d", irq->vector);
mvprintw(*line_offset, 19, "%s", irq->is_banned ? "YES" : "NO ");
print_assigned_objects_string(irq, line_offset);
mvprintw(*line_offset, 84, "%s",
irq->class < 0 ? "Unknown" : IRQ_CLASS_TO_STR[irq->class]);
(*line_offset)++;
}
void print_all_irqs()
{
int *line = malloc(sizeof(int));
*line = 4;
attrset(COLOR_PAIR(0));
mvprintw(2, 3,
"NUMBER IS BANNED ASSIGNED TO CPUS \
CLASS");
for_each_irq(all_irqs, print_irq_line, line);
}
int toggle_irq(GList *irq_list, int position)
{
GList *entry = g_list_first(irq_list);
int irq_node = 0;
while(irq_node != position) {
entry = g_list_next(entry);
irq_node++;
}
if(((irq_t *)(entry->data))->is_banned) {
((irq_t *)(entry->data))->is_banned = 0;
} else {
((irq_t *)(entry->data))->is_banned = 1;
}
return ((irq_t *)(entry->data))->is_banned;
}
void get_new_irq_ban_values(irq_t *irq, void *data)
{
char *ban_list = (char *)data;
if(irq->is_banned) {
snprintf(ban_list + strlen(ban_list), 1024 - strlen(ban_list),
" %d", irq->vector);
}
}
void copy_irqs_from_nodes(cpu_node_t *node, void *data __attribute__((unused)))
{
if(g_list_length(node->irqs) > 0) {
GList *new = g_list_copy_deep(node->irqs, copy_irq, NULL);
all_irqs = g_list_concat(all_irqs, new);
}
if(g_list_length(node->children) > 0) {
for_each_node(node->children, copy_irqs_from_nodes, all_irqs);
}
}
void get_all_irqs()
{
all_irqs = g_list_copy_deep(setup.banned_irqs, copy_irq, NULL);
for_each_node(tree, copy_irqs_from_nodes, NULL);
}
void handle_irq_banning()
{
GList *tmp = g_list_copy_deep(all_irqs, copy_irq, NULL);
attrset(COLOR_PAIR(5));
mvprintw(LINES - 3, 1, "Move up and down the list, toggle ban with Enter.");
mvprintw(LINES - 2, 1, "Press ESC for discarding and <S> for saving the values.");
move(4, 19);
curs_set(1);
refresh();
size_t position = 3;
char processing = 1;
while(processing) {
int direction = getch();
switch(direction) {
case KEY_UP:
if(position > 4) {
position--;
move(position, 19);
}
break;
case KEY_DOWN:
if(position < g_list_length(all_irqs) + 3) {
position++;
move(position, 19);
}
break;
case '\n':
case '\r': {
attrset(COLOR_PAIR(3));
int banned = toggle_irq(tmp, position - 4);
if(banned) {
mvprintw(position, 19, "YES");
} else {
mvprintw(position, 19, "NO ");
}
move(position, 19);
refresh();
break;
}
case 27:
processing = 0;
curs_set(0);
/* Forget the changes */
tmp = g_list_copy_deep(all_irqs, copy_irq, NULL);
print_all_irqs();
attrset(COLOR_PAIR(0));
mvprintw(LINES - 3, 1, " \
");
attrset(COLOR_PAIR(5));
mvprintw(LINES - 2, 1, "Press <I> for setting up IRQ banning.\
");
move(LINES - 1, COLS - 1);
refresh();
break;
case 's':
processing = 0;
all_irqs = tmp;
curs_set(0);
print_all_irqs();
attrset(COLOR_PAIR(0));
mvprintw(LINES - 3, 1, " \
");
attrset(COLOR_PAIR(5));
mvprintw(LINES - 2, 1, "Press <I> for setting up IRQ banning.\
");
attrset(COLOR_PAIR(3));
move(LINES - 1, COLS - 1);
refresh();
char settings_string[1024] = BAN_IRQS;
for_each_irq(all_irqs, get_new_irq_ban_values, settings_string);
if(!strcmp(BAN_IRQS, settings_string)) {
strncpy(settings_string + strlen(settings_string),
" NONE", 1024 - strlen(settings_string));
}
send_settings(settings_string);
break;
case 'q':
processing = 0;
close_window(0);
break;
case KEY_F(3):
is_tree = 1;
processing = 0;
display_tree();
break;
case KEY_F(4):
is_tree = 0;
processing = 0;
settings();
break;
default:
break;
}
}
}
void init()
{
signal(SIGINT, close_window);
initscr();
keypad(stdscr, TRUE);
curs_set(0);
nonl();
cbreak();
nodelay(stdscr, TRUE);
echo();
if(has_colors()) {
start_color();
init_pair(1, COLOR_RED, COLOR_BLACK);
init_pair(2, COLOR_YELLOW, COLOR_BLACK);
init_pair(3, COLOR_GREEN, COLOR_BLACK);
init_pair(4, COLOR_WHITE, COLOR_BLUE);
init_pair(5, COLOR_WHITE, COLOR_RED);
init_pair(6, COLOR_RED, COLOR_WHITE);
init_pair(7, COLOR_BLACK, COLOR_CYAN);
init_pair(8, COLOR_BLUE, COLOR_BLACK);
init_pair(9, COLOR_CYAN, COLOR_BLACK);
init_pair(10, COLOR_MAGENTA, COLOR_BLACK);
}
display_tree();
}
void close_window(int sig __attribute__((unused)))
{
g_list_free(setup.banned_irqs);
g_list_free(setup.banned_cpus);
g_list_free_full(tree, free);
endwin();
exit(EXIT_SUCCESS);
}
void settings()
{
clear();
char *setup_data = get_data(SETUP);
parse_setup(setup_data);
char info[128] = "Current sleep interval between rebalancing: \0";
uint8_t sleep_input_offset = strlen(info) + 3;
snprintf(info + strlen(info), 128 - strlen(info), "%lu\n", setup.sleep);
attrset(COLOR_PAIR(1));
mvprintw(2, 3, info);
print_all_cpus();
int user_input = 1;
while(user_input) {
attrset(COLOR_PAIR(5));
mvprintw(LINES - 2, 1,
"Press <S> for changing sleep setup, <C> for CPU ban setup. ");
show_frame();
show_footer();
refresh();
int c = getch();
switch(c) {
case 's': {
mvprintw(LINES - 1, 1, "Press ESC for discarding your input.\
");
attrset(COLOR_PAIR(0));
mvprintw(LINES - 2, 1, " \
");
uint64_t new_sleep = get_valid_sleep_input(sleep_input_offset);
if(new_sleep != setup.sleep) {
setup.sleep = new_sleep;
char settings_data[128];
snprintf(settings_data, 128, "%s %lu", SET_SLEEP, new_sleep);
send_settings(settings_data);
}
break;
}
case 'c':
handle_cpu_banning();
break;
/* We need to include window changing options as well because the
* related char was eaten up by getch() already */
case 'q':
user_input = 0;
close_window(0);
break;
case KEY_F(3):
is_tree = 1;
user_input = 0;
display_tree();
break;
case KEY_F(5):
is_tree = 0;
user_input = 0;
setup_irqs();
break;
default:
break;
}
}
free(setup_data);
}
void setup_irqs()
{
clear();
get_all_irqs();
all_irqs = g_list_sort(all_irqs, sort_all_irqs);
print_all_irqs();
attrset(COLOR_PAIR(5));
mvprintw(LINES - 2, 1, "Press <I> for setting up IRQ banning.");
show_frame();
show_footer();
refresh();
int user_input = 1;
while(user_input) {
int c = getch();
switch(c) {
case 'i':
handle_irq_banning();
break;
case 'q':
user_input = 0;
close_window(0);
break;
case KEY_F(3):
is_tree = 1;
user_input = 0;
display_tree();
break;
case KEY_F(4):
is_tree = 0;
user_input = 0;
settings();
break;
default:
break;
}
}
}
void display_tree_node_irqs(irq_t *irq, void *data)
{
char indent[32] = " \0";
snprintf(indent + strlen(indent), 32 - strlen(indent), "%s", (char *)data);
attrset(COLOR_PAIR(3));
printw("%sIRQ %lu, IRQs since last rebalance %lu\n",
indent, irq->vector, irq->diff);
}
void display_tree_node(cpu_node_t *node, void *data)
{
int i;
const char *node_type_to_str[] = {
"CPU\0",
"CACHE DOMAIN\0",
"CPU PACKAGE\0",
"NUMA NODE\0"};
char *spaces = " \0";
char indent[32] = "\0";
char *asciitree = " `--\0";
for(i = node->type; i <= OBJ_TYPE_NODE; i++) {
snprintf(indent + strlen(indent), 32 - strlen(indent), "%s", spaces);
if(i != OBJ_TYPE_NODE) {
snprintf(indent + strlen(indent), 32 - strlen(indent), " ");
}
}
snprintf(indent + strlen(indent), 32 - strlen(indent), "%s", asciitree);
char copy_to[1024];
char *numa_available = "\0";
if((node->type == OBJ_TYPE_NODE) && (node->number == -1)) {
numa_available = " (This machine is not NUMA-capable)";
}
snprintf(copy_to, 1024, "%s%s, number %d%s, CPU mask %s\n",
indent, node_type_to_str[node->type], node->number, numa_available,
node->cpu_mask);
switch(node->type) {
case(OBJ_TYPE_CPU):
attrset(COLOR_PAIR(1));
break;
case(OBJ_TYPE_CACHE):
attrset(COLOR_PAIR(2));
break;
case(OBJ_TYPE_PACKAGE):
attrset(COLOR_PAIR(8));
break;
case(OBJ_TYPE_NODE):
attrset(COLOR_PAIR(9));
break;
default:
break;
}
printw(copy_to);
if(g_list_length(node->irqs) > 0) {
for_each_irq(node->irqs, display_tree_node_irqs, indent);
}
if(g_list_length(node->children)) {
for_each_node(node->children, display_tree_node, data);
}
}
void display_tree()
{
clear();
char *setup_data = get_data(SETUP);
parse_setup(setup_data);
char *irqbalance_data = get_data(STATS);
parse_into_tree(irqbalance_data);
display_banned_cpus();
for_each_node(tree, display_tree_node, NULL);
show_frame();
show_footer();
refresh();
free(setup_data);
free(irqbalance_data);
}