diff options
Diffstat (limited to 'modules')
47 files changed, 6172 insertions, 2429 deletions
diff --git a/modules/benchmark.c b/modules/benchmark.c index 94997df8..50fddf4d 100644 --- a/modules/benchmark.c +++ b/modules/benchmark.c @@ -36,6 +36,7 @@ void scan_bfsh(gboolean reload); void scan_cryptohash(gboolean reload); void scan_fib(gboolean reload); void scan_nqueens(gboolean reload); +void scan_zlib(gboolean reload); void scan_gui(gboolean reload); gchar *callback_fft(); @@ -44,6 +45,7 @@ gchar *callback_bfsh(); gchar *callback_fib(); gchar *callback_cryptohash(); gchar *callback_nqueens(); +gchar *callback_zlib(); gchar *callback_gui(); static ModuleEntry entries[] = { @@ -51,9 +53,12 @@ static ModuleEntry entries[] = { {N_("CPU CryptoHash"), "cryptohash.png", callback_cryptohash, scan_cryptohash, MODULE_FLAG_NONE}, {N_("CPU Fibonacci"), "nautilus.png", callback_fib, scan_fib, MODULE_FLAG_NONE}, {N_("CPU N-Queens"), "nqueens.png", callback_nqueens, scan_nqueens, MODULE_FLAG_NONE}, + {N_("CPU Zlib"), "file-roller.png", callback_zlib, scan_zlib, MODULE_FLAG_NONE}, {N_("FPU FFT"), "fft.png", callback_fft, scan_fft, MODULE_FLAG_NONE}, {N_("FPU Raytracing"), "raytrace.png", callback_raytr, scan_raytr, MODULE_FLAG_NONE}, +#if !GTK_CHECK_VERSION(3,0,0) {N_("GPU Drawing"), "module.png", callback_gui, scan_gui, MODULE_FLAG_NO_REMOTE}, +#endif {NULL} }; @@ -187,30 +192,30 @@ static gchar *__benchmark_include_results(gdouble result, { GKeyFile *conf; gchar **machines; - gchar *path, *results = g_strdup(""), *return_value, *processor_frequency; + gchar *path, *results = g_strdup(""), *return_value, *processor_frequency, *processor_name; int i; conf = g_key_file_new(); path = g_build_filename(g_get_home_dir(), ".hardinfo", "benchmark.conf", NULL); if (!g_file_test(path, G_FILE_TEST_EXISTS)) { - DEBUG("local benchmark.conf not found, trying system-wide"); - g_free(path); - path = g_build_filename(params.path_data, "benchmark.conf", NULL); + DEBUG("local benchmark.conf not found, trying system-wide"); + g_free(path); + path = g_build_filename(params.path_data, "benchmark.conf", NULL); } g_key_file_load_from_file(conf, path, 0, NULL); machines = g_key_file_get_keys(conf, benchmark, NULL, NULL); for (i = 0; machines && machines[i]; i++) { - gchar *value, *cleaned_machine; + gchar *value, *cleaned_machine; - value = g_key_file_get_value(conf, benchmark, machines[i], NULL); - cleaned_machine = clean_cpuname(machines[i]); - results = h_strconcat(results, cleaned_machine, "=", value, "\n", NULL); + value = g_key_file_get_value(conf, benchmark, machines[i], NULL); + cleaned_machine = clean_cpuname(machines[i]); + results = h_strconcat(results, cleaned_machine, "=", value, "\n", NULL); - g_free(value); - g_free(cleaned_machine); + g_free(value); + g_free(cleaned_machine); } g_strfreev(machines); @@ -218,30 +223,37 @@ static gchar *__benchmark_include_results(gdouble result, g_key_file_free(conf); if (result > 0.0f) { - processor_frequency = module_call_method("devices::getProcessorFrequency"); - return_value = g_strdup_printf(_("[$ShellParam$]\n" - "Zebra=1\n" - "OrderType=%d\n" - "ViewType=3\n" - "ColumnTitle$Extra1=CPU Clock\n" - "ColumnTitle$Progress=Results\n" - "ColumnTitle$TextValue=CPU\n" - "ShowColumnHeaders=true\n" - "[%s]\n" - "<big><b>This Machine</b></big>=%.3f|%s MHz\n" - "%s"), order_type, benchmark, result, processor_frequency, results); + processor_name = module_call_method("devices::getProcessorName"); + processor_frequency = module_call_method("devices::getProcessorFrequencyDesc"); + return_value = g_strdup_printf("[$ShellParam$]\n" + "Zebra=1\n" + "OrderType=%d\n" + "ViewType=3\n" + "ColumnTitle$Extra1=%s\n" /* CPU Clock */ + "ColumnTitle$Progress=%s\n" /* Results */ + "ColumnTitle$TextValue=%s\n" /* CPU */ + "ShowColumnHeaders=true\n" + "[%s]\n" + "<big><b>%s</b></big>=%.3f|%s\n" + "%s", order_type, + _("CPU Config"), _("Results"), _("CPU"), + benchmark, + processor_name, result, processor_frequency, results); g_free(processor_frequency); + g_free(processor_name); } else { - return_value = g_strdup_printf(_("[$ShellParam$]\n" - "Zebra=1\n" - "OrderType=%d\n" - "ViewType=3\n" - "ColumnTitle$Extra1=CPU Clock\n" - "ColumnTitle$Progress=Results\n" - "ColumnTitle$TextValue=CPU\n" - "ShowColumnHeaders=true\n" - "[%s]\n" - "%s"), order_type, benchmark, results); + return_value = g_strdup_printf("[$ShellParam$]\n" + "Zebra=1\n" + "OrderType=%d\n" + "ViewType=3\n" + "ColumnTitle$Extra1=%s\n" /* CPU Clock */ + "ColumnTitle$Progress=%s\n" /* Results */ + "ColumnTitle$TextValue=%s\n" /* CPU */ + "ShowColumnHeaders=true\n" + "[%s]\n%s", + order_type, + _("CPU Config"), _("Results"), _("CPU"), + benchmark, results); } return return_value; } @@ -306,6 +318,12 @@ gchar *callback_fib() "CPU Fibonacci"); } +gchar *callback_zlib() +{ + return benchmark_include_results(bench_results[BENCHMARK_ZLIB], + "CPU Zlib"); +} + typedef struct _BenchmarkDialog BenchmarkDialog; struct _BenchmarkDialog { GtkWidget *dialog; @@ -348,7 +366,7 @@ static gboolean do_benchmark_handler(GIOChannel *source, static void do_benchmark(void (*benchmark_function)(void), int entry) { int old_priority = 0; - + if (params.gui_running && !sending_benchmark_results) { gchar *argv[] = { params.argv0, "-b", entries[entry].name, "-m", "benchmark.so", "-a", NULL }; @@ -364,7 +382,7 @@ static void do_benchmark(void (*benchmark_function)(void), int entry) shell_view_set_enabled(FALSE); shell_status_update(bench_status); - + g_free(bench_status); bench_image = icon_cache_get_image("benchmark.png"); @@ -388,7 +406,7 @@ static void do_benchmark(void (*benchmark_function)(void), int entry) benchmark_dialog = g_new0(BenchmarkDialog, 1); benchmark_dialog->dialog = bench_dialog; benchmark_dialog->result = -1.0f; - + if (!g_path_is_absolute(params.argv0)) { spawn_flags |= G_SPAWN_SEARCH_PATH; } @@ -432,7 +450,7 @@ static void do_benchmark(void (*benchmark_function)(void), int entry) return; } - + gtk_widget_destroy(bench_dialog); g_free(benchmark_dialog); shell_status_set_enabled(TRUE); @@ -504,12 +522,20 @@ void scan_fib(gboolean reload) SCAN_END(); } +void scan_zlib(gboolean reload) +{ + SCAN_START(); + do_benchmark(benchmark_zlib, BENCHMARK_ZLIB); + SCAN_END(); +} + const gchar *hi_note_func(gint entry) { switch (entry) { case BENCHMARK_CRYPTOHASH: return _("Results in MiB/second. Higher is better."); + case BENCHMARK_ZLIB: case BENCHMARK_GUI: return _("Results in HIMarks. Higher is better."); @@ -595,7 +621,7 @@ static gchar *get_benchmark_results() g_free(machineram); sending_benchmark_results = FALSE; - + return result; } diff --git a/modules/benchmark/zlib.c b/modules/benchmark/zlib.c new file mode 100644 index 00000000..eeec9d0e --- /dev/null +++ b/modules/benchmark/zlib.c @@ -0,0 +1,71 @@ +/* + * HardInfo - Displays System Information + * Copyright (C) 2017 Leandro A. F. Pereira <leandro@hardinfo.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <glib.h> +#include <stdlib.h> +#include <zlib.h> + +#include "benchmark.h" + +static gpointer zlib_for(unsigned int start, unsigned int end, void *data, gint thread_number) +{ + char *compressed; + uLong bound = compressBound(bound); + unsigned int i; + + compressed = malloc(bound); + if (!compressed) + return NULL; + + for (i = start; i <= end; i++) { + char uncompressed[65536]; + uLong compressedBound = bound; + uLong destBound = sizeof(uncompressed); + + compress(compressed, &compressedBound, data, 65536); + uncompress(uncompressed, &destBound, compressed, compressedBound); + } + + free(compressed); + + return NULL; +} + +void +benchmark_zlib(void) +{ + gdouble elapsed = 0; + gchar *tmpsrc, *bdata_path; + + bdata_path = g_build_filename(params.path_data, "benchmark.data", NULL); + if (!g_file_get_contents(bdata_path, &tmpsrc, NULL, NULL)) { + g_free(bdata_path); + return; + } + + shell_view_set_enabled(FALSE); + shell_status_update("Running Zlib benchmark..."); + + elapsed = benchmark_parallel_for(0, 50000, zlib_for, tmpsrc); + + g_free(bdata_path); + g_free(tmpsrc); + + gdouble marks = (50000. * 65536.) / (elapsed * 840205128.); + bench_results[BENCHMARK_ZLIB] = marks; +} diff --git a/modules/computer.c b/modules/computer.c index eda405e8..513d94f5 100644 --- a/modules/computer.c +++ b/modules/computer.c @@ -16,13 +16,14 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#include <config.h> +#include <gtk/gtk.h> +#include <stdarg.h> #include <stdlib.h> #include <string.h> -#include <gtk/gtk.h> -#include <config.h> -#include <time.h> #include <string.h> #include <sys/stat.h> +#include <time.h> #include <hardinfo.h> #include <iconcache.h> @@ -31,21 +32,22 @@ #include <vendor.h> #include "computer.h" +#include "info.h" /* Callbacks */ -gchar *callback_summary(); -gchar *callback_os(); -gchar *callback_modules(); -gchar *callback_boots(); -gchar *callback_locales(); -gchar *callback_fs(); -gchar *callback_display(); -gchar *callback_network(); -gchar *callback_users(); -gchar *callback_groups(); -gchar *callback_env_var(); +gchar *callback_summary(void); +gchar *callback_os(void); +gchar *callback_modules(void); +gchar *callback_boots(void); +gchar *callback_locales(void); +gchar *callback_fs(void); +gchar *callback_display(void); +gchar *callback_network(void); +gchar *callback_users(void); +gchar *callback_groups(void); +gchar *callback_env_var(void); #if GLIB_CHECK_VERSION(2,14,0) -gchar *callback_dev(); +gchar *callback_dev(void); #endif /* GLIB_CHECK_VERSION(2,14,0) */ /* Scan callbacks */ @@ -81,6 +83,7 @@ static ModuleEntry entries[] = { {NULL}, }; + gchar *module_list = NULL; Computer *computer = NULL; @@ -89,7 +92,7 @@ gchar *hi_more_info(gchar * entry) gchar *info = moreinfo_lookup_with_prefix("COMP", entry); if (info) - return g_strdup(info); + return g_strdup(info); return g_strdup_printf("[%s]", entry); } @@ -99,22 +102,22 @@ gchar *hi_get_field(gchar * field) gchar *tmp; if (g_str_equal(field, _("Memory"))) { - MemoryInfo *mi = computer_get_memory(); - tmp = g_strdup_printf(_("%dMB (%dMB used)"), mi->total, mi->used); - g_free(mi); + MemoryInfo *mi = computer_get_memory(); + tmp = g_strdup_printf(_("%dMB (%dMB used)"), mi->total, mi->used); + g_free(mi); } else if (g_str_equal(field, _("Uptime"))) { - tmp = computer_get_formatted_uptime(); + tmp = computer_get_formatted_uptime(); } else if (g_str_equal(field, _("Date/Time"))) { - time_t t = time(NULL); + time_t t = time(NULL); - tmp = g_new0(gchar, 64); - strftime(tmp, 64, "%c", localtime(&t)); + tmp = g_new0(gchar, 64); + strftime(tmp, 64, "%c", localtime(&t)); } else if (g_str_equal(field, _("Load Average"))) { - tmp = computer_get_formatted_loadavg(); + tmp = computer_get_formatted_loadavg(); } else if (g_str_equal(field, _("Available entropy in /dev/random"))) { - tmp = computer_get_entropy_avail(); + tmp = computer_get_entropy_avail(); } else { - tmp = g_strdup_printf("Unknown field: %s", field); + tmp = g_strdup_printf("Unknown field: %s", field); } return tmp; } @@ -189,7 +192,7 @@ static gchar *dev_list = NULL; void scan_dev(gboolean reload) { SCAN_START(); - + int i; struct { gchar *compiler_name; @@ -198,8 +201,13 @@ void scan_dev(gboolean reload) gboolean stdout; } detect_lang[] = { { N_("Scripting Languages"), NULL, FALSE }, - { N_("CPython"), "python -V", "\\d+\\.\\d+\\.\\d+", TRUE }, + { N_("Gambas3 (gbr3)"), "gbr3 --version", "\\d+\\.\\d+\\.\\d+", TRUE }, + { N_("Python"), "python -V", "\\d+\\.\\d+\\.\\d+", FALSE }, + { N_("Python2"), "python2 -V", "\\d+\\.\\d+\\.\\d+", FALSE }, + { N_("Python3"), "python3 -V", "\\d+\\.\\d+\\.\\d+", TRUE }, { N_("Perl"), "perl -v", "\\d+\\.\\d+\\.\\d+", TRUE }, + { N_("Perl6 (VM)"), "perl6 -v", "(?<=This is ).*", TRUE }, + { N_("Perl6"), "perl6 -v", "(?<=implementing Perl )\\w*\\.\\w*", TRUE }, { N_("PHP"), "php --version", "\\d+\\.\\d+\\.\\S+", TRUE}, { N_("Ruby"), "ruby --version", "\\d+\\.\\d+\\.\\d+", TRUE }, { N_("Bash"), "bash --version", "\\d+\\.\\d+\\.\\S+", TRUE}, @@ -207,6 +215,7 @@ void scan_dev(gboolean reload) { N_("C (GCC)"), "gcc -v", "\\d+\\.\\d+\\.\\d+", FALSE }, { N_("C (Clang)"), "clang -v", "\\d+\\.\\d+", FALSE }, { N_("D (dmd)"), "dmd --help", "\\d+\\.\\d+", TRUE }, + { N_("Gambas3 (gbc3)"), "gbc3 --version", "\\d+\\.\\d+\\.\\d+", FALSE }, { N_("Java"), "javac -version", "\\d+\\.\\d+\\.\\d+", FALSE }, { N_("CSharp (Mono, old)"), "mcs --version", "\\d+\\.\\d+\\.\\d+\\.\\d+", TRUE }, { N_("CSharp (Mono)"), "gmcs --version", "\\d+\\.\\d+\\.\\d+\\.\\d+", TRUE }, @@ -216,36 +225,38 @@ void scan_dev(gboolean reload) { N_("Go"), "go version", "\\d+\\.\\d+\\.?\\d* ", TRUE }, { N_("Tools"), NULL, FALSE }, { N_("make"), "make --version", "\\d+\\.\\d+", TRUE }, - { N_("GDB"), "gdb --version", "\\d+\\.\\S+", TRUE }, + { N_("GDB"), "gdb --version", "(?<=^GNU gdb ).*", TRUE }, { N_("strace"), "strace -V", "\\d+\\.\\d+\\.?\\d*", TRUE }, { N_("valgrind"), "valgrind --version", "\\d+\\.\\d+\\.\\S+", TRUE }, { N_("QMake"), "qmake --version", "\\d+\\.\\S+", TRUE}, { N_("CMake"), "cmake --version", "\\d+\\.\\d+\\.?\\d*", TRUE}, + { N_("Gambas3 IDE"), "gambas3 --version", "\\d+\\.\\d+\\.\\d+", FALSE }, }; - + g_free(dev_list); - + dev_list = g_strdup(""); - + for (i = 0; i < G_N_ELEMENTS(detect_lang); i++) { gchar *version = NULL; - gchar *output; + gchar *output, *ignored; gchar *temp; GRegex *regex; GMatchInfo *match_info; gboolean found; - + if (!detect_lang[i].regex) { - dev_list = h_strdup_cprintf("[%s]\n", dev_list, detect_lang[i].compiler_name); + dev_list = h_strdup_cprintf("[%s]\n", dev_list, _(detect_lang[i].compiler_name)); continue; } - + if (detect_lang[i].stdout) { - found = g_spawn_command_line_sync(detect_lang[i].version_command, &output, NULL, NULL, NULL); + found = g_spawn_command_line_sync(detect_lang[i].version_command, &output, &ignored, NULL, NULL); } else { - found = g_spawn_command_line_sync(detect_lang[i].version_command, NULL, &output, NULL, NULL); + found = g_spawn_command_line_sync(detect_lang[i].version_command, &ignored, &output, NULL, NULL); } - + g_free(ignored); + if (found) { regex = g_regex_new(detect_lang[i].regex, 0, 0, NULL); @@ -253,41 +264,131 @@ void scan_dev(gboolean reload) if (g_match_info_matches(match_info)) { version = g_match_info_fetch(match_info, 0); } - + g_match_info_free(match_info); g_regex_unref(regex); g_free(output); } - - if (version) { - dev_list = h_strdup_cprintf("%s=%s\n", dev_list, detect_lang[i].compiler_name, version); - g_free(version); - } else { - dev_list = h_strdup_cprintf(_("%s=Not found\n"), dev_list, detect_lang[i].compiler_name); - } - + + if (version == NULL) + version = strdup(_("Not found")); + + dev_list = h_strdup_cprintf("%s=%s\n", dev_list, detect_lang[i].compiler_name, version); + g_free(version); + temp = g_strdup_printf(_("Detecting version: %s"), detect_lang[i].compiler_name); shell_status_update(temp); g_free(temp); } - + SCAN_END(); } -gchar *callback_dev() +gchar *callback_dev(void) { - return g_strdup_printf(_("[$ShellParam$]\n" - "ColumnTitle$TextValue=Program\n" - "ColumnTitle$Value=Version\n" - "ShowColumnHeaders=true\n" - "%s"), dev_list); + return g_strdup_printf( + "[$ShellParam$]\n" + "ColumnTitle$TextValue=%s\n" /* Program */ + "ColumnTitle$Value=%s\n" /* Version */ + "ShowColumnHeaders=true\n" + "%s", + _("Program"), _("Version"), + dev_list); } #endif /* GLIB_CHECK_VERSION(2,14,0) */ +static gchar *detect_machine_type(void) +{ + GDir *dir; + gchar *chassis; + + if (g_file_get_contents("/sys/devices/virtual/dmi/id/chassis_type", &chassis, NULL, NULL)) { + static const char *types[] = { + N_("Invalid chassis type (0)"), + N_("Unknown chassis type"), /* 1 is "Other", but not helpful in HardInfo */ + N_("Unknown chassis type"), + N_("Desktop"), + N_("Low-profile Desktop"), + N_("Pizza Box"), + N_("Mini Tower"), + N_("Tower"), + N_("Portable"), + N_("Laptop"), + N_("Notebook"), + N_("Handheld"), + N_("Docking Station"), + N_("All-in-one"), + N_("Subnotebook"), + N_("Space-saving"), + N_("Lunch Box"), + N_("Main Server Chassis"), + N_("Expansion Chassis"), + N_("Sub Chassis"), + N_("Bus Expansion Chassis"), + N_("Peripheral Chassis"), + N_("RAID Chassis"), + N_("Rack Mount Chassis"), + N_("Sealed-case PC"), + }; + int chassis_type = atoi(idle_free(chassis)); + + if (chassis_type >= 0 && chassis_type < G_N_ELEMENTS(types)) + return g_strdup(_(types[chassis_type])); + } + + if (g_file_test("/proc/pmu/info", G_FILE_TEST_EXISTS)) + return g_strdup(_("Laptop")); + + dir = g_dir_open("/proc/acpi/battery", 0, NULL); + if (dir) { + const gchar *name = g_dir_read_name(dir); + + g_dir_close(dir); + + if (name) + return g_strdup(_("Laptop")); + } + + dir = g_dir_open("/sys/class/power_supply", 0, NULL); + if (dir) { + const gchar *name; + + while ((name = g_dir_read_name(dir))) { + gchar *contents; + gchar type[PATH_MAX]; + int r; + + r = snprintf(type, sizeof(type), "%s/%s/type", + "/sys/class/power_supply", name); + if (r < 0 || r > PATH_MAX) + continue; + + if (g_file_get_contents(type, &contents, NULL, NULL)) { + if (g_str_has_prefix(contents, "Battery")) { + g_free(contents); + g_dir_close(dir); + + return g_strdup(_("Laptop")); + } + + g_free(contents); + } + } + + g_dir_close(dir); + } + + /* FIXME: check if batteries are found using /proc/apm */ + + /* FIXME: use dmidecode if available to get chassis type */ + + return g_strdup(_("Unknown physical machine type")); +} + /* Table based off imvirt by Thomas Liske <liske@ibh.de> Copyright (c) 2008 IBH IT-Service GmbH under GPLv2. */ -gchar *computer_get_virtualization() +gchar *computer_get_virtualization(void) { gboolean found = FALSE; gint i, j; @@ -324,18 +425,18 @@ gchar *computer_get_virtualization() { " hypervisor", "Virtual (hypervisor present)"} , { NULL } }; - + DEBUG("Detecting virtual machine"); if (g_file_test("/proc/xen", G_FILE_TEST_EXISTS)) { DEBUG("/proc/xen found; assuming Xen"); return g_strdup("Xen"); } - + for (i = 0; files[i+1]; i++) { gchar buffer[512]; FILE *file; - + if ((file = fopen(files[i], "r"))) { while (!found && fgets(buffer, 512, file)) { for (j = 0; vm_types[j+1].str; j++) { @@ -345,200 +446,191 @@ gchar *computer_get_virtualization() } } } - + fclose(file); - + if (found) { DEBUG("%s found (by reading file %s)", vm_types[j].vmtype, files[i]); return g_strdup(vm_types[j].vmtype); } } - + } - + DEBUG("no virtual machine detected; assuming physical machine"); - - return g_strdup(_("Physical machine")); -} - -gchar *callback_summary() -{ - gchar *processor_name, *alsa_cards; - gchar *input_devices, *printers; - gchar *storage_devices, *summary; - gchar *virt; - - processor_name = module_call_method("devices::getProcessorName"); - alsa_cards = computer_get_alsacards(computer); - input_devices = module_call_method("devices::getInputDevices"); - printers = module_call_method("devices::getPrinters"); - storage_devices = module_call_method("devices::getStorageDevices"); - virt = computer_get_virtualization(); - - summary = g_strdup_printf(_("[$ShellParam$]\n" - "UpdateInterval$Memory=1000\n" - "UpdateInterval$Date/Time=1000\n" - "#ReloadInterval=5000\n" - "[Computer]\n" - "Processor=%s\n" - "Memory=...\n" - "Machine Type=%s\n" - "Operating System=%s\n" - "User Name=%s\n" - "Date/Time=...\n" - "[Display]\n" - "Resolution=%dx%d pixels\n" - "OpenGL Renderer=%s\n" - "X11 Vendor=%s\n" - "\n%s\n" - "[Input Devices]\n%s\n" - "\n%s\n" - "\n%s\n"), - processor_name, - virt, - computer->os->distro, - computer->os->username, - computer->display->width, - computer->display->height, - computer->display->ogl_renderer, - computer->display->vendor, - alsa_cards, - input_devices, printers, storage_devices); - - g_free(processor_name); - g_free(alsa_cards); - g_free(input_devices); - g_free(printers); - g_free(storage_devices); - g_free(virt); - - return summary; -} - -gchar *callback_os() -{ - return g_strdup_printf(_("[$ShellParam$]\n" - "UpdateInterval$Uptime=10000\n" - "UpdateInterval$Load Average=1000\n" - "UpdateInterval$Available entropy in /dev/random=1000\n" - "[Version]\n" - "Kernel=%s\n" - "Version=%s\n" - "C Library=%s\n" - "Distribution=%s\n" - "[Current Session]\n" - "Computer Name=%s\n" - "User Name=%s\n" - "#Language=%s\n" - "Home Directory=%s\n" - "Desktop Environment=%s\n" - "[Misc]\n" - "Uptime=...\n" - "Load Average=...\n" - "Available entropy in /dev/random=..."), - computer->os->kernel, - computer->os->kernel_version, - computer->os->libc, - computer->os->distro, - computer->os->hostname, - computer->os->username, - computer->os->language, - computer->os->homedir, - computer->os->desktop); -} - -gchar *callback_modules() -{ - return g_strdup_printf(_("[Loaded Modules]\n" - "%s" - "[$ShellParam$]\n" - "ViewType=1\n" - "ColumnTitle$TextValue=Name\n" - "ColumnTitle$Value=Description\n" - "ShowColumnHeaders=true\n"), module_list); -} - -gchar *callback_boots() -{ - return g_strdup_printf(_("[$ShellParam$]\n" - "ColumnTitle$TextValue=Date & Time\n" - "ColumnTitle$Value=Kernel Version\n" - "ShowColumnHeaders=true\n" - "\n" - "%s"), computer->os->boots); -} - -gchar *callback_locales() -{ - return g_strdup_printf(_("[$ShellParam$]\n" - "ViewType=1\n" - "ColumnTitle$TextValue=Language Code\n" - "ColumnTitle$Value=Name\n" - "ShowColumnHeaders=true\n" - "[Available Languages]\n" - "%s"), computer->os->languages); -} - -gchar *callback_fs() -{ - return g_strdup_printf(_("[$ShellParam$]\n" - "ViewType=4\n" - "ReloadInterval=5000\n" - "Zebra=1\n" - "NormalizePercentage=false\n" - "ColumnTitle$Extra1=Mount Point\n" - "ColumnTitle$Progress=Usage\n" - "ColumnTitle$TextValue=Device\n" - "ShowColumnHeaders=true\n" - "[Mounted File Systems]\n%s\n"), fs_list); -} - -gchar *callback_display() -{ - return g_strdup_printf(_("[Display]\n" - "Resolution=%dx%d pixels\n" - "Vendor=%s\n" - "Version=%s\n" - "[Monitors]\n" - "%s" - "[Extensions]\n" - "%s" - "[OpenGL]\n" - "Vendor=%s\n" - "Renderer=%s\n" - "Version=%s\n" - "Direct Rendering=%s\n"), - computer->display->width, - computer->display->height, - computer->display->vendor, - computer->display->version, - computer->display->monitors, - computer->display->extensions, - computer->display->ogl_vendor, - computer->display->ogl_renderer, - computer->display->ogl_version, - computer->display->dri ? _("Y_es") : _("No")); -} - -gchar *callback_users() -{ - return g_strdup_printf("[$ShellParam$]\n" - "ReloadInterval=10000\n" - "ViewType=1\n" - "[Users]\n" - "%s\n", users); -} - -gchar *callback_groups() -{ - return g_strdup_printf(_("[$ShellParam$]\n" - "ReloadInterval=10000\n" - "ColumnTitle$TextValue=Name\n" - "ColumnTitle$Value=Group ID\n" - "ShowColumnHeaders=true\n" - "[Groups]\n" - "%s\n"), groups); + + return detect_machine_type(); +} + +gchar *callback_summary(void) +{ + struct Info *info = info_new(); + + info_add_group(info, _("Computer"), + info_field_printf(_("Processor"), "%s", + module_call_method("devices::getProcessorName")), + info_field_update(_("Memory"), 1000), + info_field_printf(_("Machine Type"), "%s", + computer_get_virtualization()), + info_field(_("Operating System"), computer->os->distro), + info_field(_("User Name"), computer->os->username), + info_field_update(_("Date/Time"), 1000), + info_field_last()); + + info_add_group(info, _("Display"), + info_field_printf(_("Resolution"), _(/* label for resolution */ "%dx%d pixels"), + computer->display->width, computer->display->height), + info_field(_("OpenGL Renderer"), computer->display->ogl_renderer), + info_field(_("X11 Vendor"), computer->display->vendor), + info_field_last()); + + info_add_computed_group(info, _("Audio Devices"), + idle_free(computer_get_alsacards(computer))); + info_add_computed_group(info, _("Input Devices"), + idle_free(module_call_method("devices::getInputDevices"))); + info_add_computed_group(info, _("Printers"), + idle_free(module_call_method("devices::getPrinters"))); + info_add_computed_group(info, _("Storage"), + idle_free(module_call_method("devices::getStorageDevices"))); + + return info_flatten(info); +} + +gchar *callback_os(void) +{ + struct Info *info = info_new(); + + info_add_group(info, _("Version"), + info_field(_("Kernel"), computer->os->kernel), + info_field(_("Version"), computer->os->kernel_version), + info_field(_("C Library"), computer->os->libc), + info_field(_("Distribution"), computer->os->distro), + info_field_last()); + + info_add_group(info, _("Current Session"), + info_field(_("Computer Name"), computer->os->hostname), + info_field(_("User Name"), computer->os->username), + info_field(_("Language"), computer->os->language), + info_field(_("Home Directory"), computer->os->homedir), + info_field_last()); + + info_add_group(info, _("Misc"), + info_field_update(_("Uptime"), 1000), + info_field_update(_("Load Average"), 10000), + info_field_update(_("Available entropy in /dev/random"), 1000), + info_field_last()); + + return info_flatten(info); +} + +gchar *callback_modules(void) +{ + struct Info *info = info_new(); + + info_add_computed_group(info, _("Loaded Modules"), module_list); + + info_set_column_title(info, "TextValue", _("Name")); + info_set_column_title(info, "Value", _("Description")); + info_set_column_headers_visible(info, TRUE); + info_set_view_type(info, SHELL_VIEW_DUAL); + + return info_flatten(info); +} + +gchar *callback_boots(void) +{ + struct Info *info = info_new(); + + info_add_computed_group(info, _("Boots"), computer->os->boots); + + info_set_column_title(info, "TextValue", _("Date & Time")); + info_set_column_title(info, "Value", _("Kernel Version")); + info_set_column_headers_visible(info, TRUE); + + return info_flatten(info); +} + +gchar *callback_locales(void) +{ + struct Info *info = info_new(); + + info_add_computed_group(info, _("Available Languages"), computer->os->languages); + + info_set_column_title(info, "TextValue", _("Language Code")); + info_set_column_title(info, "Value", _("Name")); + info_set_view_type(info, SHELL_VIEW_DUAL); + info_set_column_headers_visible(info, TRUE); + + return info_flatten(info); +} + +gchar *callback_fs(void) +{ + struct Info *info = info_new(); + + info_add_computed_group(info, _("Mounted File Systems"), fs_list); + + info_set_column_title(info, "Extra1", _("Mount Point")); + info_set_column_title(info, "Progress", _("Usage")); + info_set_column_title(info, "TextValue", _("Device")); + info_set_column_headers_visible(info, TRUE); + info_set_view_type(info, SHELL_VIEW_PROGRESS_DUAL); + info_set_zebra_visible(info, TRUE); + info_set_normalize_percentage(info, FALSE); + + return info_flatten(info); +} + +gchar *callback_display(void) +{ + struct Info *info = info_new(); + + info_add_group(info, _("Display"), + info_field_printf(_("Resolution"), _(/* resolution WxH unit */ "%dx%d pixels"), + computer->display->width, computer->display->height), + info_field(_("Vendor"), computer->display->vendor), + info_field(_("Version"), computer->display->version), + info_field_last()); + + info_add_computed_group(info, _("Monitors"), computer->display->monitors); + + info_add_group(info, _("OpenGL"), + info_field(_("Vendor"), computer->display->ogl_vendor), + info_field(_("Renderer"), computer->display->ogl_renderer), + info_field(_("Version"), computer->display->ogl_version), + info_field(_("Direct Rendering"), + computer->display->dri ? _("Yes") : _("No")), + info_field_last()); + + info_add_computed_group(info, _("Extensions"), computer->display->extensions); + + return info_flatten(info); +} + +gchar *callback_users(void) +{ + struct Info *info = info_new(); + + info_add_computed_group(info, _("Users"), users); + info_set_view_type(info, SHELL_VIEW_DUAL); + info_set_reload_interval(info, 10000); + + return info_flatten(info); +} + +gchar *callback_groups(void) +{ + struct Info *info = info_new(); + + info_add_computed_group(info, _("Group"), groups); + + info_set_column_title(info, "TextValue", _("Name")); + info_set_column_title(info, "Value", _("Group ID")); + info_set_column_headers_visible(info, TRUE); + info_set_reload_interval(info, 10000); + + return info_flatten(info); } gchar *get_os_kernel(void) @@ -569,16 +661,16 @@ gchar *get_display_summary(void) gchar *get_kernel_module_description(gchar *module) { gchar *description; - + if (!_module_hash_table) { scan_modules(FALSE); } - + description = g_hash_table_lookup(_module_hash_table, module); if (!description) { return NULL; } - + return g_strdup(description); } @@ -587,19 +679,19 @@ gchar *get_audio_cards(void) if (!computer->alsa) { computer->alsa = computer_get_alsainfo(); } - + return computer_get_alsacards(computer); } ShellModuleMethod *hi_exported_methods(void) { static ShellModuleMethod m[] = { - {"getOSKernel", get_os_kernel}, - {"getOS", get_os}, - {"getDisplaySummary", get_display_summary}, - {"getAudioCards", get_audio_cards}, - {"getKernelModuleDescription", get_kernel_module_description}, - {NULL} + {"getOSKernel", get_os_kernel}, + {"getOS", get_os}, + {"getDisplaySummary", get_display_summary}, + {"getAudioCards", get_audio_cards}, + {"getKernelModuleDescription", get_kernel_module_description}, + {NULL} }; return m; @@ -629,30 +721,34 @@ gchar **hi_module_get_dependencies(void) gchar *hi_module_get_summary(void) { - return g_strdup("[Operating System]\n" + return g_strdup_printf("[%s]\n" "Icon=os.png\n" "Method=computer::getOS\n" - "[CPU]\n" + "[%s]\n" "Icon=processor.png\n" - "Method=devices::getProcessorName\n" - "[RAM]\n" + "Method=devices::getProcessorNameAndDesc\n" + "[%s]\n" "Icon=memory.png\n" "Method=devices::getMemoryTotal\n" - "[Motherboard]\n" + "[%s]\n" "Icon=module.png\n" "Method=devices::getMotherboard\n" - "[Graphics]\n" + "[%s]\n" "Icon=monitor.png\n" "Method=computer::getDisplaySummary\n" - "[Storage]\n" + "[%s]\n" "Icon=hdd.png\n" "Method=devices::getStorageDevices\n" - "[Printers]\n" + "[%s]\n" "Icon=printer.png\n" "Method=devices::getPrinters\n" - "[Audio]\n" + "[%s]\n" "Icon=audio.png\n" - "Method=computer::getAudioCards\n"); + "Method=computer::getAudioCards\n", + _("Operating System"), + _("CPU"), _("RAM"), _("Motherboard"), _("Graphics"), + _("Storage"), _("Printers"), _("Audio") + ); } void hi_module_deinit(void) @@ -672,7 +768,7 @@ void hi_module_deinit(void) g_free(computer->os->boots); g_free(computer->os); } - + if (computer->display) { g_free(computer->display->ogl_vendor); g_free(computer->display->ogl_renderer); @@ -684,15 +780,15 @@ void hi_module_deinit(void) g_free(computer->display->monitors); g_free(computer->display); } - + if (computer->alsa) { g_slist_free(computer->alsa->cards); g_free(computer->alsa); } - + g_free(computer->date_time); g_free(computer); - + moreinfo_del_with_prefix("COMP"); } @@ -704,11 +800,11 @@ void hi_module_init(void) ModuleAbout *hi_module_get_about(void) { static ModuleAbout ma[] = { - { - .author = "Leandro A. F. Pereira", - .description = N_("Gathers high-level computer information"), - .version = VERSION, - .license = "GNU GPL version 2"} + { + .author = "Leandro A. F. Pereira", + .description = N_("Gathers high-level computer information"), + .version = VERSION, + .license = "GNU GPL version 2"} }; return ma; diff --git a/modules/computer/alsa.c b/modules/computer/alsa.c index e1e7b946..00c1fceb 100644 --- a/modules/computer/alsa.c +++ b/modules/computer/alsa.c @@ -23,16 +23,16 @@ gchar * computer_get_alsacards(Computer * computer) { GSList *p; - gchar *tmp = g_strdup(_("[Audio Devices]\n")); + gchar *tmp = g_strdup_printf("[%s]\n", _("Audio Devices")); gint n = 0; if (computer->alsa) { - for (p = computer->alsa->cards; p; p = p->next) { - AlsaCard *ac = (AlsaCard *) p->data; + for (p = computer->alsa->cards; p; p = p->next) { + AlsaCard *ac = (AlsaCard *) p->data; - tmp = h_strdup_cprintf(_("Audio Adapter#%d=%s\n"), - tmp, ++n, ac->friendly_name); - } + tmp = h_strdup_cprintf("%s#%d=%s\n", tmp, + _("Audio Adapter"), ++n, ac->friendly_name); + } } return tmp; @@ -48,22 +48,22 @@ computer_get_alsainfo(void) cards = fopen("/proc/asound/cards", "r"); if (!cards) - return NULL; + return NULL; ai = g_new0(AlsaInfo, 1); while (fgets(buffer, 128, cards)) { - gchar **tmp; + gchar **tmp; - ac = g_new0(AlsaCard, 1); + ac = g_new0(AlsaCard, 1); - tmp = g_strsplit(buffer, ":", 0); + tmp = g_strsplit(buffer, ":", 0); - ac->friendly_name = g_strdup(tmp[1]); - ai->cards = g_slist_append(ai->cards, ac); + ac->friendly_name = g_strdup(tmp[1]); + ai->cards = g_slist_append(ai->cards, ac); - g_strfreev(tmp); - (void)fgets(buffer, 128, cards); /* skip next line */ + g_strfreev(tmp); + (void)fgets(buffer, 128, cards); /* skip next line */ } fclose(cards); diff --git a/modules/computer/boots.c b/modules/computer/boots.c index 478e89ac..d8a6d32a 100644 --- a/modules/computer/boots.c +++ b/modules/computer/boots.c @@ -30,22 +30,22 @@ scan_boots_real(void) scan_os(FALSE); if (!computer->os->boots) - computer->os->boots = g_strdup(_("[Boots]\n")); + computer->os->boots = g_strdup_printf("[%s]\n", _("Boots")); else return; - + last = popen("last", "r"); if (last) { while (fgets(buffer, 256, last)) { if (strstr(buffer, "system boot")) { gchar **tmp, *buf = buffer; - + strend(buffer, '\n'); - + while (*buf) { if (*buf == ' ' && *(buf + 1) == ' ') { memmove(buf, buf + 1, strlen(buf) + 1); - + buf--; } else { buf++; @@ -53,13 +53,14 @@ scan_boots_real(void) } tmp = g_strsplit(buffer, " ", 0); - computer->os->boots = h_strdup_cprintf("\n%s %s %s %s=%s|%s", - computer->os->boots, - tmp[4], tmp[5], tmp[6], tmp[7], tmp[3], tmp[8]); + computer->os->boots = + h_strdup_cprintf("\n%s %s %s %s=%s|%s", + computer->os->boots, + tmp[4], tmp[5], tmp[6], tmp[7], tmp[3], tmp[8]); g_strfreev(tmp); } } - + pclose(last); } } diff --git a/modules/computer/environment.c b/modules/computer/environment.c index 2a8d235c..dc0fb6f3 100644 --- a/modules/computer/environment.c +++ b/modules/computer/environment.c @@ -23,19 +23,19 @@ static gchar *_env = NULL; void scan_env_var(gboolean reload) { SCAN_START(); - + gchar **envlist; gint i; - + g_free(_env); - - _env = g_strdup(_("[Environment Variables]\n")); + + _env = g_strdup_printf("[%s]\n", _("Environment Variables") ); for (i = 0, envlist = g_listenv(); envlist[i]; i++) { _env = h_strdup_cprintf("%s=%s\n", _env, envlist[i], g_getenv(envlist[i])); } g_strfreev(envlist); - + SCAN_END(); } diff --git a/modules/computer/filesystem.c b/modules/computer/filesystem.c index a7162777..397dc636 100644 --- a/modules/computer/filesystem.c +++ b/modules/computer/filesystem.c @@ -16,8 +16,8 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Some code from xfce4-mount-plugin, version 0.4.3 - * Copyright (C) 2005 Jean-Baptiste jb_dul@yahoo.com - * Distributed under the terms of GNU GPL 2. + * Copyright (C) 2005 Jean-Baptiste jb_dul@yahoo.com + * Distributed under the terms of GNU GPL 2. */ #include <string.h> @@ -41,62 +41,64 @@ scan_filesystems(void) mtab = fopen("/etc/mtab", "r"); if (!mtab) - return; + return; while (fgets(buf, 1024, mtab)) { - gfloat size, used, avail; - gchar **tmp; - - tmp = g_strsplit(buf, " ", 0); - if (!statfs(tmp[1], &sfs)) { - gfloat use_ratio; - - size = (float) sfs.f_bsize * (float) sfs.f_blocks; - avail = (float) sfs.f_bsize * (float) sfs.f_bavail; - used = size - avail; - - if (size == 0.0f) { - continue; - } - - if (avail == 0.0f) { - use_ratio = 100.0f; - } else { - use_ratio = 100.0f * (used / size); - } - - gchar *strsize = size_human_readable(size), - *stravail = size_human_readable(avail), - *strused = size_human_readable(used); - - gchar *strhash; - - strreplacechr(tmp[0], "#", '_'); - strhash = g_strdup_printf("[%s]\n" - "Filesystem=%s\n" - "Mounted As=%s\n" - "Mount Point=%s\n" - "Size=%s\n" - "Used=%s\n" - "Available=%s\n", - tmp[0], - tmp[2], - strstr(tmp[3], "rw") ? "Read-Write" : - "Read-Only", tmp[1], strsize, strused, - stravail); - gchar *key = g_strdup_printf("FS%d", ++count); - moreinfo_add_with_prefix("COMP", key, strhash); - g_free(key); - - fs_list = h_strdup_cprintf("$FS%d$%s=%.2f %% (%s of %s)|%s\n", - fs_list, - count, tmp[0], use_ratio, stravail, strsize, tmp[1]); - - g_free(strsize); - g_free(stravail); - g_free(strused); - } - g_strfreev(tmp); + gfloat size, used, avail; + gchar **tmp; + + tmp = g_strsplit(buf, " ", 0); + if (!statfs(tmp[1], &sfs)) { + gfloat use_ratio; + + size = (float) sfs.f_bsize * (float) sfs.f_blocks; + avail = (float) sfs.f_bsize * (float) sfs.f_bavail; + used = size - avail; + + if (size == 0.0f) { + continue; + } + + if (avail == 0.0f) { + use_ratio = 100.0f; + } else { + use_ratio = 100.0f * (used / size); + } + + gchar *strsize = size_human_readable(size), + *stravail = size_human_readable(avail), + *strused = size_human_readable(used); + + gchar *strhash; + + strreplacechr(tmp[0], "#", '_'); + strhash = g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n", + tmp[0], /* path */ + _("Filesystem"), tmp[2], + _("Mounted As"), ( strstr(tmp[3], "rw") != NULL) ? _("Read-Write") : _("Read-Only"), + _("Mount Point"), tmp[1], + _("Size"), strsize, + _("Used"), strused, + _("Available"), stravail); + gchar *key = g_strdup_printf("FS%d", ++count); + moreinfo_add_with_prefix("COMP", key, strhash); + g_free(key); + + fs_list = h_strdup_cprintf("$FS%d$%s=%.2f %% (%s of %s)|%s\n", + fs_list, + count, tmp[0], use_ratio, stravail, strsize, tmp[1]); + + g_free(strsize); + g_free(stravail); + g_free(strused); + } + g_strfreev(tmp); } fclose(mtab); diff --git a/modules/computer/languages.c b/modules/computer/languages.c index 5877c41c..d4681839 100644 --- a/modules/computer/languages.c +++ b/modules/computer/languages.c @@ -20,6 +20,7 @@ #include "hardinfo.h" #include "computer.h" +#include "cpu_util.h" /* for UNKIFNULL() */ void scan_languages(OperatingSystem * os) @@ -67,43 +68,64 @@ scan_languages(OperatingSystem * os) g_strfreev(tmp); } else { - gchar *currlocale; - - retval = h_strdup_cprintf("$%s$%s=%s\n", retval, name, name, title); - -#define FIELD(f) f ? f : "(Unknown)" - currlocale = g_strdup_printf("[Locale Information]\n" - "Name=%s (%s)\n" - "Source=%s\n" - "Address=%s\n" - "Email=%s\n" - "Language=%s\n" - "Territory=%s\n" - "Revision=%s\n" - "Date=%s\n" - "Codeset=%s\n", - name, FIELD(title), - FIELD(source), FIELD(address), - FIELD(email), FIELD(language), - FIELD(territory), FIELD(revision), - FIELD(date), FIELD(codeset)); -#undef FIELD - - moreinfo_add_with_prefix("COMP", name, currlocale); - - g_free(title); - g_free(source); - g_free(address); - g_free(email); - g_free(language); - g_free(territory); - g_free(revision); - g_free(date); - g_free(codeset); - - title = source = address = email = language = territory = \ - revision = date = codeset = NULL; - } + gchar *currlocale; + + retval = h_strdup_cprintf("$%s$%s=%s\n", retval, name, name, title); + + UNKIFNULL(title); + UNKIFNULL(source); + UNKIFNULL(address); + UNKIFNULL(email); + UNKIFNULL(language); + UNKIFNULL(territory); + UNKIFNULL(revision); + UNKIFNULL(date); + UNKIFNULL(codeset); + + /* values may have & */ + title = hardinfo_clean_value(title, 1); + source = hardinfo_clean_value(source, 1); + address = hardinfo_clean_value(address, 1); + email = hardinfo_clean_value(email, 1); + language = hardinfo_clean_value(language, 1); + territory = hardinfo_clean_value(territory, 1); + + currlocale = g_strdup_printf("[%s]\n" + /* Name */ "%s=%s (%s)\n" + /* Source */ "%s=%s\n" + /* Address */ "%s=%s\n" + /* Email */ "%s=%s\n" + /* Language */ "%s=%s\n" + /* Territory */"%s=%s\n" + /* Revision */ "%s=%s\n" + /* Date */ "%s=%s\n" + /* Codeset */ "%s=%s\n", + _("Locale Information"), + _("Name"), name, title, + _("Source"), source, + _("Address"), address, + _("E-mail"), email, + _("Language"), language, + _("Territory"), territory, + _("Revision"), revision, + _("Date"), date, + _("Codeset"), codeset ); + + moreinfo_add_with_prefix("COMP", name, currlocale); + + g_free(title); + g_free(source); + g_free(address); + g_free(email); + g_free(language); + g_free(territory); + g_free(revision); + g_free(date); + g_free(codeset); + + title = source = address = email = language = territory = \ + revision = date = codeset = NULL; + } } fclose(locale); diff --git a/modules/computer/memory.c b/modules/computer/memory.c index 3d320e8a..dc8599c2 100644 --- a/modules/computer/memory.c +++ b/modules/computer/memory.c @@ -28,23 +28,26 @@ computer_get_memory(void) procmem = fopen("/proc/meminfo", "r"); if (!procmem) - return NULL; + return NULL; mi = g_new0(MemoryInfo, 1); while (fgets(buffer, 128, procmem)) { - gchar **tmp = g_strsplit(buffer, ":", 2); - - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); - - get_int("MemTotal", mi->total); - get_int("MemFree", mi->free); - get_int("Cached", mi->cached); - - g_strfreev(tmp); + gchar **tmp = g_strsplit(buffer, ":", 2); + if (tmp[1] == NULL) { + g_strfreev(tmp); + continue; + } + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); + + get_int("MemTotal", mi->total); + get_int("MemFree", mi->free); + get_int("Cached", mi->cached); + + g_strfreev(tmp); } fclose(procmem); - + mi->used = mi->total - mi->free; mi->total /= 1000; diff --git a/modules/computer/modules.c b/modules/computer/modules.c index bbc05f42..df876e3a 100644 --- a/modules/computer/modules.c +++ b/modules/computer/modules.c @@ -20,6 +20,7 @@ #include "hardinfo.h" #include "computer.h" +#include "cpu_util.h" /* for STRIFNULL() */ #define GET_STR(field_name,ptr) \ if (!ptr && strstr(tmp[0], field_name)) { \ @@ -42,7 +43,7 @@ scan_modules_do(void) } g_free(module_list); - + module_list = NULL; moreinfo_del_with_prefix("COMP:MOD"); @@ -51,7 +52,7 @@ scan_modules_do(void) return; lsmod = popen(lsmod_path, "r"); if (!lsmod) { - g_free(lsmod_path); + g_free(lsmod_path); return; } @@ -99,7 +100,7 @@ scan_modules_do(void) remove_quotes(license); */ /* old modutils displays <none> when there's no value for a - given field; this is not desirable in the module name + given field; this is not desirable in the module name display, so change it to an empty string */ if (description && g_str_equal(description, "<none>")) { g_free(description); @@ -121,38 +122,45 @@ scan_modules_do(void) modname, description ? description : ""); -#define NONE_IF_NULL(var) (var) ? (var) : "N/A" - - /* create the module information string */ - strmodule = g_strdup_printf("[Module Information]\n" - "Path=%s\n" - "Used Memory=%.2fKiB\n" - "[Description]\n" - "Name=%s\n" - "Description=%s\n" - "Version Magic=%s\n" - "[Copyright]\n" - "Author=%s\n" - "License=%s\n", - NONE_IF_NULL(filename), - memory / 1024.0, - modname, - NONE_IF_NULL(description), - NONE_IF_NULL(vermagic), - NONE_IF_NULL(author), - NONE_IF_NULL(license)); - - /* if there are dependencies, append them to that string */ - if (deps && strlen(deps)) { - gchar **tmp = g_strsplit(deps, ",", 0); - - strmodule = h_strconcat(strmodule, - "\n[Dependencies]\n", - g_strjoinv("=\n", tmp), - "=\n", NULL); - g_strfreev(tmp); - g_free(deps); - } + STRIFNULL(filename, _("(Not available)") ); + STRIFNULL(description, _("(Not available)") ); + STRIFNULL(vermagic, _("(Not available)") ); + STRIFNULL(author, _("(Not available)") ); + STRIFNULL(license, _("(Not available)") ); + + /* create the module information string */ + strmodule = g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%.2f %s\n" + "[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "[%s]\n" + "%s=%s\n" + "%s=%s\n", + _("Module Information"), + _("Path"), filename, + _("Used Memory"), memory / 1024.0, _("KiB"), + _("Description"), + _("Name"), modname, + _("Description"), description, + _("Version Magic"), vermagic, + _("Copyright"), + _("Author"), author, + _("License"), license ); + + /* if there are dependencies, append them to that string */ + if (deps && strlen(deps)) { + gchar **tmp = g_strsplit(deps, ",", 0); + + strmodule = h_strconcat(strmodule, + "\n[", _("Dependencies"), "]\n", + g_strjoinv("=\n", tmp), + "=\n", NULL); + g_strfreev(tmp); + g_free(deps); + } moreinfo_add_with_prefix("COMP", hashkey, strmodule); g_free(hashkey); @@ -164,6 +172,6 @@ scan_modules_do(void) g_free(filename); } pclose(lsmod); - + g_free(lsmod_path); } diff --git a/modules/computer/os.c b/modules/computer/os.c index 3caf6c26..a8886f64 100644 --- a/modules/computer/os.c +++ b/modules/computer/os.c @@ -16,6 +16,7 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#include <gdk/gdkx.h> #include <string.h> #include <sys/utsname.h> #include "hardinfo.h" @@ -24,219 +25,350 @@ static gchar * get_libc_version(void) { - FILE *libc; - gchar buf[256], *tmp, *p; - char *libc_paths[] = { - "/lib/ld-uClibc.so.0", "/lib64/ld-uClibc.so.0", - "/lib/libc.so.6", "/lib64/libc.so.6" - }; - int i; - - for (i=0; i < 4; i++) { - if (g_file_test(libc_paths[i], G_FILE_TEST_EXISTS)) break; - } - switch (i) { - case 0: case 1: return g_strdup("uClibc Library"); - case 2: case 3: break; // gnu libc, continue processing - default: goto err; - } - - libc = popen(libc_paths[i], "r"); - if (!libc) goto err; - - (void)fgets(buf, 256, libc); - if (pclose(libc)) goto err; - - tmp = strstr(buf, "version "); - if (!tmp) goto err; - - p = strchr(tmp, ','); - if (p) *p = '\0'; - else goto err; - - return g_strdup_printf(_("GNU C Library version %s (%sstable)"), - strchr(tmp, ' ') + 1, - strstr(buf, " stable ") ? "" : _("un")); - err: + static const struct { + const char *test_cmd; + const char *match_str; + const char *lib_name; + gboolean try_ver_str; + gboolean use_stderr; + } libs[] = { + { "ldd --version", "GLIBC", N_("GNU C Library"), TRUE, FALSE}, + { "ldd --version", "GNU libc", N_("GNU C Library"), TRUE, FALSE}, + { "ldconfig -V", "GLIBC", N_("GNU C Library"), TRUE, FALSE}, + { "ldconfig -V", "GNU libc", N_("GNU C Library"), TRUE, FALSE}, + { "ldconfig -v", "uClibc", N_("uClibc or uClibc-ng"), FALSE, FALSE}, + { "diet", "diet version", N_("diet libc"), TRUE, TRUE}, + { NULL } + }; + int i; + + for (i = 0; libs[i].test_cmd; i++) { + gboolean spawned; + gchar *out, *err, *p; + + spawned = g_spawn_command_line_sync(libs[i].test_cmd, + &out, &err, NULL, NULL); + if (!spawned) + continue; + + if (libs[i].use_stderr) { + p = strend(idle_free(err), '\n'); + g_free(out); + } else { + p = strend(idle_free(out), '\n'); + g_free(err); + } + + if (!p || !strstr(p, libs[i].match_str)) + continue; + + if (libs[i].try_ver_str) { + /* skip the first word, likely "ldconfig" or name of utility */ + const gchar *ver_str = strchr(p, ' '); + + if (ver_str) { + return g_strdup_printf("%s / %s", _(libs[i].lib_name), + ver_str + 1); + } + } + + return g_strdup(_(libs[i].lib_name)); + } + return g_strdup(_("Unknown")); } -#include <gdk/gdkx.h> +static gchar *detect_kde_version(void) +{ + const gchar *cmd; + const gchar *tmp = g_getenv("KDE_SESSION_VERSION"); + gchar *out; + gboolean spawned; + + if (tmp && tmp[0] == '4') { + cmd = "kwin --version"; + } else { + cmd = "kcontrol --version"; + } + + spawned = g_spawn_command_line_sync(cmd, &out, NULL, NULL, NULL); + if (!spawned) + return NULL; + + tmp = strstr(idle_free(out), "KDE: "); + return tmp ? g_strdup(tmp + strlen("KDE: ")) : NULL; +} + +static gchar * +detect_gnome_version(void) +{ + gchar *tmp; + gchar *out; + gboolean spawned; + + spawned = g_spawn_command_line_sync( + "gnome-shell --version", &out, NULL, NULL, NULL); + if (spawned) { + tmp = strstr(idle_free(out), _("GNOME Shell ")); + + if (tmp) { + tmp += strlen(_("GNOME Shell ")); + return g_strdup_printf("GNOME %s", strend(tmp, '\n')); + } + } + + spawned = g_spawn_command_line_sync( + "gnome-about --gnome-version", &out, NULL, NULL, NULL); + if (spawned) { + tmp = strstr(idle_free(out), _("Version: ")); + + if (tmp) { + tmp += strlen(_("Version: ")); + return g_strdup_printf("GNOME %s", strend(tmp, '\n')); + } + } + + return NULL; +} -void -detect_desktop_environment(OperatingSystem * os) +static gchar * +detect_window_manager(void) { - const gchar *tmp = g_getenv("GNOME_DESKTOP_SESSION_ID"); - FILE *version; - char vers[16]; + GdkScreen *screen = gdk_screen_get_default(); + const gchar *windowman; + const gchar *curdesktop; + + if (!screen || !GDK_IS_SCREEN(screen)) + return NULL; + + windowman = gdk_x11_screen_get_window_manager_name(screen); + if (g_str_equal(windowman, "Xfwm4")) + return g_strdup("XFCE 4"); + + curdesktop = g_getenv("XDG_CURRENT_DESKTOP"); + if (curdesktop) { + const gchar *desksession = g_getenv("DESKTOP_SESSION"); + + if (desksession && !g_str_equal(curdesktop, desksession)) + return g_strdup(desksession); + } + + return g_strdup_printf(_("Unknown (Window Manager: %s)"), windowman); +} + +static gchar * +desktop_with_session_type(const gchar *desktop_env) +{ + const char *tmp; + + tmp = g_getenv("XDG_SESSION_TYPE"); if (tmp) { - /* FIXME: this might not be true, as the gnome-panel in path - may not be the one that's running. - see where the user's running panel is and run *that* to - obtain the version. */ - version = popen("gnome-about --gnome-version", "r"); - if (version) { - (void)fscanf(version, _("Version: %s"), vers); - if (pclose(version)) - goto unknown; - } else { - goto unknown; - } - - os->desktop = g_strdup_printf("GNOME %s", vers); - } else if (g_getenv("KDE_FULL_SESSION")) { - - if (g_getenv("KDE_SESSION_VERSION") && strstr(g_getenv("KDE_SESSION_VERSION"),(gchar *)"4")) { - version = popen("kwin --version", "r"); - } else { - version = popen("kcontrol --version", "r"); - } - - if (version) { - char buf[32]; - - (void)fgets(buf, 32, version); - - (void)fscanf(version, "KDE: %s", vers); - if (pclose(version)) - goto unknown; - } else { - goto unknown; - } - - os->desktop = g_strdup_printf("KDE %s", vers); - } else { - unknown: - os->desktop = NULL; - - if (!g_getenv("DISPLAY")) { - os->desktop = g_strdup(_("Terminal")); - } else { - GdkScreen *screen = gdk_screen_get_default(); - - if (screen && GDK_IS_SCREEN(screen)) { - const gchar *windowman; - - windowman = gdk_x11_screen_get_window_manager_name(screen); - if (g_str_equal(windowman, "Xfwm4")) { - /* FIXME: check if xprop -root | grep XFCE_DESKTOP_WINDOW is defined */ - os->desktop = g_strdup("XFCE 4"); - } else if ((tmp = g_getenv("XDG_CURRENT_DESKTOP"))) { - os->desktop = g_strdup(tmp); - if ((tmp = g_getenv("DESKTOP_SESSION")) && !g_str_equal(os->desktop, tmp)) { - g_free(os->desktop); - os->desktop = g_strdup(tmp); - } - } - - if (!os->desktop) { - os->desktop = g_strdup_printf(_("Unknown (Window Manager: %s)"), - windowman); - } - } else { - os->desktop = g_strdup(_("Unknown")); - } - } + if (!g_str_equal(tmp, "unspecified")) + return g_strdup_printf(_(/*/{desktop environment} on {session type}*/ "%s on %s"), desktop_env, tmp); + } + + return g_strdup(desktop_env); +} + +static gchar * +detect_xdg_environment(const gchar *env_var) +{ + const gchar *tmp; + + tmp = g_getenv(env_var); + if (!tmp) + return NULL; + + if (g_str_equal(tmp, "GNOME") || g_str_equal(tmp, "gnome")) { + gchar *maybe_gnome = detect_gnome_version(); + + if (maybe_gnome) + return maybe_gnome; } + if (g_str_equal(tmp, "KDE") || g_str_equal(tmp, "kde")) { + gchar *maybe_kde = detect_kde_version(); + + if (maybe_kde) + return maybe_kde; + } + + return g_strdup(tmp); +} + +static gchar * +detect_desktop_environment(void) +{ + const gchar *tmp; + gchar *windowman; + + windowman = detect_xdg_environment("XDG_CURRENT_DESKTOP"); + if (windowman) + return windowman; + windowman = detect_xdg_environment("XDG_SESSION_DESKTOP"); + if (windowman) + return windowman; + + tmp = g_getenv("KDE_FULL_SESSION"); + if (tmp) { + gchar *maybe_kde = detect_kde_version(); + + if (maybe_kde) + return maybe_kde; + } + tmp = g_getenv("GNOME_DESKTOP_SESSION_ID"); + if (tmp) { + gchar *maybe_gnome = detect_gnome_version(); + + if (maybe_gnome) + return maybe_gnome; + } + + windowman = detect_window_manager(); + if (windowman) + return windowman; + + if (!g_getenv("DISPLAY")) + return g_strdup(_("Terminal")); + + return g_strdup(_("Unknown")); } gchar * computer_get_entropy_avail(void) { + gchar tab_entropy_fstr[][32] = { + N_(/*/bits of entropy for rng (0)*/ "(None or not available)"), + N_(/*/bits of entropy for rng (low/poor value)*/ "%d bits (low)"), + N_(/*/bits of entropy for rng (medium value)*/ "%d bits (medium)"), + N_(/*/bits of entropy for rng (high/good value)*/ "%d bits (healthy)") + }; gint bits = h_sysfs_read_int("/proc/sys/kernel/random", "entropy_avail"); - if (bits < 200) - return g_strdup_printf("%d bits (low)", bits); - if (bits < 3000) - return g_strdup_printf("%d bits (medium)", bits); - return g_strdup_printf("%d bits (healthy)", bits); + if (bits > 3000) return g_strdup_printf(_(tab_entropy_fstr[3]), bits); + if (bits > 200) return g_strdup_printf(_(tab_entropy_fstr[2]), bits); + if (bits > 1) return g_strdup_printf(_(tab_entropy_fstr[1]), bits); + return g_strdup_printf(_(tab_entropy_fstr[0]), bits); } -OperatingSystem * -computer_get_os(void) +gchar * +computer_get_language(void) { - struct utsname utsbuf; - OperatingSystem *os; + gchar *tab_lang_env[] = + { "LANGUAGE", "LANG", "LC_ALL", "LC_MESSAGES", NULL }; + gchar *lc = NULL, *env = NULL, *ret = NULL; + gint i = 0; + + lc = setlocale(LC_ALL, NULL); + + while (tab_lang_env[i] != NULL) { + env = g_strdup( g_getenv(tab_lang_env[i]) ); + if (env != NULL) break; + i++; + } + + if (env != NULL) + if (lc != NULL) + ret = g_strdup_printf("%s (%s)", lc, env); + else + ret = g_strdup_printf("%s", env); + else + if (lc != NULL) + ret = g_strdup_printf("%s", lc); + + if (ret == NULL) + ret = g_strdup( _("(Unknown)") ); + + return ret; +} + +static gchar * +detect_distro(void) +{ + static const struct { + const gchar *file; + const gchar *codename; + const gchar *override; + } distro_db[] = { +#define DB_PREFIX "/etc/" + { DB_PREFIX "arch-release", "arch", "Arch Linux" }, + { DB_PREFIX "fatdog-version", "fatdog" }, + { DB_PREFIX "debian_version", "deb" }, + { DB_PREFIX "slackware-version", "slk" }, + { DB_PREFIX "mandrake-release", "mdk" }, + { DB_PREFIX "mandriva-release", "mdv" }, + { DB_PREFIX "fedora-release", "fdra" }, + { DB_PREFIX "coas", "coas" }, + { DB_PREFIX "environment.corel", "corel"}, + { DB_PREFIX "gentoo-release", "gnt" }, + { DB_PREFIX "conectiva-release", "cnc" }, + { DB_PREFIX "versão-conectiva", "cnc" }, + { DB_PREFIX "turbolinux-release", "tl" }, + { DB_PREFIX "yellowdog-release", "yd" }, + { DB_PREFIX "sabayon-release", "sbn" }, + { DB_PREFIX "arch-release", "arch" }, + { DB_PREFIX "enlisy-release", "enlsy" }, + { DB_PREFIX "SuSE-release", "suse" }, + { DB_PREFIX "sun-release", "sun" }, + { DB_PREFIX "zenwalk-version", "zen" }, + { DB_PREFIX "DISTRO_SPECS", "ppy", "Puppy Linux" }, + { DB_PREFIX "puppyversion", "ppy", "Puppy Linux" }, + { DB_PREFIX "distro-release", "fl" }, + { DB_PREFIX "vine-release", "vine" }, + { DB_PREFIX "PartedMagic-version", "pmag" }, + /* + * RedHat must be the *last* one to be checked, since + * some distros (like Mandrake) includes a redhat-relase + * file too. + */ + { DB_PREFIX "redhat-release", "rh" }, +#undef DB_PREFIX + { NULL, NULL } + }; + gchar *contents; int i; - os = g_new0(OperatingSystem, 1); + if (g_spawn_command_line_sync("lsb_release -d", &contents, NULL, NULL, NULL)) { + gchar *tmp = strstr(idle_free(contents), "Description:\t"); - /* Attempt to get the Distribution name; try using /etc/lsb-release first, - then doing the legacy method (checking for /etc/$DISTRO-release files) */ - if (g_file_test("/etc/lsb-release", G_FILE_TEST_EXISTS)) { - FILE *release; - gchar buffer[128]; + if (tmp) + return g_strdup(tmp + strlen("Description:\t")); + } - release = popen("lsb_release -d", "r"); - if (release) { - (void)fgets(buffer, 128, release); - pclose(release); + for (i = 0; distro_db[i].file; i++) { + if (!g_file_get_contents(distro_db[i].file, &contents, NULL, NULL)) + continue; - os->distro = buffer; - os->distro = g_strdup(os->distro + strlen("Description:\t")); + if (distro_db[i].override) { + g_free(contents); + return g_strdup(distro_db[i].override); } - } else if (g_file_test("/etc/arch-release", G_FILE_TEST_EXISTS)) { - os->distrocode = g_strdup("arch"); - os->distro = g_strdup("Arch Linux"); - } else { - for (i = 0;; i++) { - if (distro_db[i].file == NULL) { - os->distrocode = g_strdup("unk"); - os->distro = g_strdup(_("Unknown distribution")); - break; - } - if (g_file_test(distro_db[i].file, G_FILE_TEST_EXISTS)) { - FILE *distro_ver; - char buf[128]; - - distro_ver = fopen(distro_db[i].file, "r"); - if (distro_ver) { - (void)fgets(buf, 128, distro_ver); - fclose(distro_ver); - } else { - continue; - } - - buf[strlen(buf) - 1] = 0; - - if (!os->distro) { - /* - * HACK: Some Debian systems doesn't include - * the distribuition name in /etc/debian_release, - * so add them here. - */ - if (!strncmp(distro_db[i].codename, "deb", 3) && - ((buf[0] >= '0' && buf[0] <= '9') || buf[0] != 'D')) { - os->distro = g_strdup_printf - ("Debian GNU/Linux %s", buf); - } else { - os->distro = g_strdup(buf); - } - } - - if (g_str_equal(distro_db[i].codename, "ppy")) { - gchar *tmp; - tmp = g_strdup_printf("Puppy Linux"); - g_free(os->distro); - os->distro = tmp; - } - - if (g_str_equal(distro_db[i].codename, "fatdog")) { - gchar *tmp; - tmp = g_strdup_printf("Fatdog64 [%.10s]", os->distro); - g_free(os->distro); - os->distro = tmp; - } - - os->distrocode = g_strdup(distro_db[i].codename); - - break; - } + if (g_str_equal(distro_db[i].codename, "deb")) { + /* HACK: Some Debian systems doesn't include the distribuition + * name in /etc/debian_release, so add them here. */ + if (isdigit(contents[0]) || contents[0] != 'D') + return g_strdup_printf("Debian GNU/Linux %s", (char*)idle_free(contents)); } + + if (g_str_equal(distro_db[i].codename, "fatdog")) + return g_strdup_printf("Fatdog64 [%.10s]", (char*)idle_free(contents)); + + return contents; } - os->distro = g_strstrip(os->distro); + return g_strdup(_("Unknown")); +} + +OperatingSystem * +computer_get_os(void) +{ + struct utsname utsbuf; + OperatingSystem *os; + int i; + + os = g_new0(OperatingSystem, 1); + + os->distro = g_strstrip(detect_distro()); /* Kernel and hostname info */ uname(&utsbuf); @@ -244,13 +376,16 @@ computer_get_os(void) os->kernel = g_strdup_printf("%s %s (%s)", utsbuf.sysname, utsbuf.release, utsbuf.machine); os->hostname = g_strdup(utsbuf.nodename); - os->language = g_strdup(g_getenv("LC_MESSAGES")); + os->language = computer_get_language(); os->homedir = g_strdup(g_get_home_dir()); os->username = g_strdup_printf("%s (%s)", g_get_user_name(), g_get_real_name()); os->libc = get_libc_version(); scan_languages(os); - detect_desktop_environment(os); + + os->desktop = detect_desktop_environment(); + if (os->desktop) + os->desktop = desktop_with_session_type(idle_free(os->desktop)); os->entropy_avail = computer_get_entropy_avail(); diff --git a/modules/computer/uptime.c b/modules/computer/uptime.c index 8eb563fa..5f0f1942 100644 --- a/modules/computer/uptime.c +++ b/modules/computer/uptime.c @@ -26,11 +26,11 @@ computer_get_uptime(void) gulong minutes; if ((procuptime = fopen("/proc/uptime", "r")) != NULL) { - (void)fscanf(procuptime, "%lu", &minutes); - ui->minutes = minutes / 60; - fclose(procuptime); + (void)fscanf(procuptime, "%lu", &minutes); + ui->minutes = minutes / 60; + fclose(procuptime); } else { - return NULL; + return NULL; } ui->hours = ui->minutes / 60; @@ -45,32 +45,27 @@ gchar * computer_get_formatted_uptime() { UptimeInfo *ui; - gchar *tmp; + const gchar *days_fmt, *hours_fmt, *minutes_fmt; + gchar *full_fmt = NULL, *ret = NULL; ui = computer_get_uptime(); - /* FIXME: Use ngettext */ -#define plural(x) ((x > 1) ? "s" : "") + days_fmt = ngettext("%d day", "%d days", ui->days); + hours_fmt = ngettext("%d hour", "%d hours", ui->hours); + minutes_fmt = ngettext("%d minute", "%d minutes", ui->minutes); if (ui->days < 1) { - if (ui->hours < 1) { - tmp = - g_strdup_printf("%d minute%s", ui->minutes, - plural(ui->minutes)); - } else { - tmp = - g_strdup_printf("%d hour%s, %d minute%s", ui->hours, - plural(ui->hours), ui->minutes, - plural(ui->minutes)); - } + if (ui->hours < 1) { + ret = g_strdup_printf(minutes_fmt, ui->minutes); + } else { + full_fmt = g_strdup_printf("%s %s", hours_fmt, minutes_fmt); + ret = g_strdup_printf(full_fmt, ui->hours, ui->minutes); + } } else { - tmp = - g_strdup_printf("%d day%s, %d hour%s and %d minute%s", - ui->days, plural(ui->days), ui->hours, - plural(ui->hours), ui->minutes, - plural(ui->minutes)); + full_fmt = g_strdup_printf("%s %s %s", days_fmt, hours_fmt, minutes_fmt); + ret = g_strdup_printf(full_fmt, ui->days, ui->hours, ui->minutes); } - + g_free(full_fmt); g_free(ui); - return tmp; + return ret; } diff --git a/modules/computer/users.c b/modules/computer/users.c index e8f891ac..f47320bb 100644 --- a/modules/computer/users.c +++ b/modules/computer/users.c @@ -39,15 +39,16 @@ scan_users_do(void) while (passwd_) { gchar *key = g_strdup_printf("USER%s", passwd_->pw_name); - gchar *val = g_strdup_printf("[User Information]\n" - "User ID=%d\n" - "Group ID=%d\n" - "Home directory=%s\n" - "Default shell=%s\n", - (gint) passwd_->pw_uid, - (gint) passwd_->pw_gid, - passwd_->pw_dir, - passwd_->pw_shell); + gchar *val = g_strdup_printf("[%s]\n" + "%s=%d\n" + "%s=%d\n" + "%s=%s\n" + "%s=%s\n", + _("User Information"), + _("User ID"), (gint) passwd_->pw_uid, + _("Group ID"), (gint) passwd_->pw_gid, + _("Home Directory"), passwd_->pw_dir, + _("Default Shell"), passwd_->pw_shell); moreinfo_add_with_prefix("COMP", key, val); strend(passwd_->pw_gecos, ','); @@ -55,6 +56,6 @@ scan_users_do(void) passwd_ = getpwent(); g_free(key); } - + endpwent(); } diff --git a/modules/devices.c b/modules/devices.c index 87bb8a80..9c7a184d 100644 --- a/modules/devices.c +++ b/modules/devices.c @@ -37,6 +37,7 @@ #include <socket.h> #include "devices.h" +#include "dt_util.h" gchar *callback_processors(); gchar *callback_memory(); @@ -51,6 +52,7 @@ gchar *callback_usb(); gchar *callback_dmi(); gchar *callback_spd(); #endif +gchar *callback_dtree(); gchar *callback_device_resources(); void scan_processors(gboolean reload); @@ -66,6 +68,7 @@ void scan_usb(gboolean reload); void scan_dmi(gboolean reload); void scan_spd(gboolean reload); #endif +void scan_dtree(gboolean reload); void scan_device_resources(gboolean reload); gboolean root_required_for_resources(void); @@ -73,6 +76,7 @@ gboolean root_required_for_resources(void); gchar *hi_more_info(gchar *entry); enum { + ENTRY_DTREE, ENTRY_PROCESSOR, ENTRY_MEMORY, ENTRY_PCI, @@ -100,9 +104,14 @@ static ModuleEntry entries[] = { #if defined(ARCH_x86) || defined(ARCH_x86_64) [ENTRY_DMI] = {N_("DMI"), "computer.png", callback_dmi, scan_dmi, MODULE_FLAG_NONE}, [ENTRY_SPD] = {N_("Memory SPD"), "memory.png", callback_spd, scan_spd, MODULE_FLAG_NONE}, + [ENTRY_DTREE] = {"#"}, +#else + [ENTRY_DMI] = {"#"}, + [ENTRY_SPD] = {"#"}, + [ENTRY_DTREE] = {N_("Device Tree"), "devices.png", callback_dtree, scan_dtree, MODULE_FLAG_NONE}, #endif /* x86 or x86_64 */ [ENTRY_RESOURCES] = {N_("Resources"), "resources.png", callback_device_resources, scan_device_resources, MODULE_FLAG_NONE}, - {NULL} + { NULL } }; static GSList *processors = NULL; @@ -117,21 +126,127 @@ gchar *lginterval = NULL; #include <vendor.h> -gchar *get_processor_name(void) +static gint proc_cmp_model_name(Processor *a, Processor *b) { + return g_strcmp0(a->model_name, b->model_name); +} + +static gint proc_cmp_max_freq(Processor *a, Processor *b) { + if (a->cpu_mhz == b->cpu_mhz) + return 0; + if (a->cpu_mhz > b->cpu_mhz) + return -1; + return 1; +} + +gchar *processor_describe_default(GSList * processors) { - scan_processors(FALSE); + int packs, cores, threads; + const gchar *packs_fmt, *cores_fmt, *threads_fmt; + gchar *ret, *full_fmt; - Processor *p = (Processor *) processors->data; + cpu_procs_cores_threads(&packs, &cores, &threads); - if (g_slist_length(processors) > 1) { - return idle_free(g_strdup_printf("%dx %s", - g_slist_length(processors), - p->model_name)); + /* if topology info was available, else fallback to old method */ + if (cores > 0) { + packs_fmt = ngettext("%d physical processor", "%d physical processors", packs); + cores_fmt = ngettext("%d core", "%d cores", cores); + threads_fmt = ngettext("%d thread", "%d threads", threads); + full_fmt = g_strdup_printf(_(/*/NP procs; NC cores; NT threads*/ "%s; %s; %s"), packs_fmt, cores_fmt, threads_fmt); + ret = g_strdup_printf(full_fmt, packs, cores, threads); + g_free(full_fmt); + return ret; } else { - return p->model_name; + return processor_describe_by_counting_names(processors); + } +} + +gchar *processor_name_default(GSList * processors) +{ + gchar *ret = g_strdup(""); + GSList *tmp, *l; + Processor *p; + gchar *cur_str = NULL; + gint cur_count = 0; + + tmp = g_slist_copy(processors); + tmp = g_slist_sort(tmp, (GCompareFunc)proc_cmp_model_name); + + for (l = tmp; l; l = l->next) { + p = (Processor*)l->data; + if (cur_str == NULL) { + cur_str = p->model_name; + cur_count = 1; + } else { + if(g_strcmp0(cur_str, p->model_name)) { + ret = h_strdup_cprintf("%s%s", ret, strlen(ret) ? "; " : "", cur_str); + cur_str = p->model_name; + cur_count = 1; + } else { + cur_count++; + } + } + } + ret = h_strdup_cprintf("%s%s", ret, strlen(ret) ? "; " : "", cur_str); + g_slist_free(tmp); + return ret; +} + +/* TODO: prefix counts are threads when they should be cores. */ +gchar *processor_describe_by_counting_names(GSList * processors) +{ + gchar *ret = g_strdup(""); + GSList *tmp, *l; + Processor *p; + gchar *cur_str = NULL; + gint cur_count = 0; + + tmp = g_slist_copy(processors); + tmp = g_slist_sort(tmp, (GCompareFunc)proc_cmp_model_name); + + for (l = tmp; l; l = l->next) { + p = (Processor*)l->data; + if (cur_str == NULL) { + cur_str = p->model_name; + cur_count = 1; + } else { + if(g_strcmp0(cur_str, p->model_name)) { + ret = h_strdup_cprintf("%s%dx %s", ret, strlen(ret) ? " + " : "", cur_count, cur_str); + cur_str = p->model_name; + cur_count = 1; + } else { + cur_count++; + } + } } + ret = h_strdup_cprintf("%s%dx %s", ret, strlen(ret) ? " + " : "", cur_count, cur_str); + g_slist_free(tmp); + return ret; +} + +gchar *get_processor_name(void) +{ + scan_processors(FALSE); + return processor_name(processors); +} + +gchar *get_processor_desc(void) +{ + scan_processors(FALSE); + return processor_describe(processors); +} + +gchar *get_processor_name_and_desc(void) +{ + scan_processors(FALSE); + gchar* name = processor_name(processors); + gchar* desc = processor_describe(processors); + gchar* nd = g_strdup_printf("%s\n%s", name, desc); + g_free(name); + g_free(desc); + return nd; } + gchar *get_storage_devices(void) { scan_storage(FALSE); @@ -160,175 +275,127 @@ gchar *get_processor_count(void) return g_strdup_printf("%d", g_slist_length(processors)); } -gchar *get_processor_frequency(void) +/* TODO: maybe move into processor.c along with processor_name() etc. + * Could mention the big.LITTLE cluster arangement for ARM that kind of thing. + * TODO: prefix counts are threads when they should be cores. */ +gchar *processor_frequency_desc(GSList * processors) +{ + gchar *ret = g_strdup(""); + GSList *tmp, *l; + Processor *p; + float cur_val = -1; + gint cur_count = 0; + + tmp = g_slist_copy(processors); + tmp = g_slist_sort(tmp, (GCompareFunc)proc_cmp_max_freq); + + for (l = tmp; l; l = l->next) { + p = (Processor*)l->data; + if (cur_val == -1) { + cur_val = p->cpu_mhz; + cur_count = 1; + } else { + if(cur_val != p->cpu_mhz) { + ret = h_strdup_cprintf("%s%dx %.2f %s", ret, strlen(ret) ? " + " : "", cur_count, cur_val, _("MHz") ); + cur_val = p->cpu_mhz; + cur_count = 1; + } else { + cur_count++; + } + } + } + ret = h_strdup_cprintf("%s%dx %.2f %s", ret, strlen(ret) ? " + " : "", cur_count, cur_val, _("MHz")); + g_slist_free(tmp); + return ret; +} + +gchar *get_processor_frequency_desc(void) +{ + scan_processors(FALSE); + return processor_frequency_desc(processors); +} + +gchar *get_processor_max_frequency(void) { + GSList *l; Processor *p; + float max_freq = 0; scan_processors(FALSE); - p = (Processor *)processors->data; - if (p->cpu_mhz == 0.0f) { + for (l = processors; l; l = l->next) { + p = (Processor*)l->data; + if (p->cpu_mhz > max_freq) + max_freq = p->cpu_mhz; + } + + if (max_freq == 0.0f) { return g_strdup(N_("Unknown")); } else { - return g_strdup_printf("%.0f", p->cpu_mhz); + return g_strdup_printf("%.2f %s", max_freq, _("MHz") ); } } gchar *get_pci_device_description(gchar *pci_id) { gchar *description; - + if (!_pci_devices) { scan_pci(FALSE); } - + if ((description = g_hash_table_lookup(_pci_devices, pci_id))) { return g_strdup(description); } - + return NULL; } gchar *get_memory_total(void) { scan_memory(FALSE); - return moreinfo_lookup ("DEV:Total Memory"); //hi_more_info(N_("Total Memory")); -} - -/* information table from: http://elinux.org/RPi_HardwareHistory */ -static struct { - char *value, *intro, *model, *pcb, *mem, *mfg; -} rpi_boardinfo[] = { -/* Value Introduction Model Name PCB rev. Memory Manufacturer * - * Raspberry Pi %s */ - { "Beta", "Q1 2012", "B (Beta)", "?", "256MB", "(Beta board)" }, - { "0002", "Q1 2012", "B", "1.0", "256MB", "?" }, - { "0003", "Q3 2012", "B (ECN0001)", "1.0", "256MB", "(Fuses mod and D14 removed)" }, - { "0004", "Q3 2012", "B", "2.0", "256MB", "Sony" }, - { "0005", "Q4 2012", "B", "2.0", "256MB", "Qisda" }, - { "0006", "Q4 2012", "B", "2.0", "256MB", "Egoman" }, - { "0007", "Q1 2013", "A", "2.0", "256MB", "Egoman" }, - { "0008", "Q1 2013", "A", "2.0", "256MB", "Sony" }, - { "0009", "Q1 2013", "A", "2.0", "256MB", "Qisda" }, - { "000d", "Q4 2012", "B", "2.0", "512MB", "Egoman" }, - { "000e", "Q4 2012", "B", "2.0", "512MB", "Sony" }, - { "000f", "Q4 2012", "B", "2.0", "512MB", "Qisda" }, - { "0010", "Q3 2014", "B+", "1.0", "512MB", "Sony" }, - { "0011", "Q2 2014", "Compute Module 1", "1.0", "512MB", "Sony" }, - { "0012", "Q4 2014", "A+", "1.1", "256MB", "Sony" }, - { "0013", "Q1 2015", "B+", "1.2", "512MB", "?" }, - { "0014", "Q2 2014", "Compute Module 1", "1.0", "512MB", "Embest" }, - { "0015", "?", "A+", "1.1", "256MB/512MB", "Embest" }, - { "a01040", "Unknown", "2 Model B", "1.0", "1GB", "Sony" }, - { "a01041", "Q1 2015", "2 Model B", "1.1", "1GB", "Sony" }, - { "a21041", "Q1 2015", "2 Model B", "1.1", "1GB", "Embest" }, - { "a22042", "Q3 2016", "2 Model B", "1.2", "1GB", "Embest" }, /* (with BCM2837) */ - { "900021", "Q3 2016", "A+", "1.1", "512MB", "Sony" }, - { "900032", "Q2 2016?", "B+", "1.2", "512MB", "Sony" }, - { "900092", "Q4 2015", "Zero", "1.2", "512MB", "Sony" }, - { "900093", "Q2 2016", "Zero", "1.3", "512MB", "Sony" }, - { "920093", "Q4 2016?", "Zero", "1.3", "512MB", "Embest" }, - { "9000c1", "Q1 2017", "Zero W", "1.1", "512MB", "Sony" }, - { "a02082", "Q1 2016", "3 Model B", "1.2", "1GB", "Sony" }, - { "a020a0", "Q1 2017", "Compute Module 3 or CM3 Lite", "1.0", "1GB", "Sony" }, - { "a22082", "Q1 2016", "3 Model B", "1.2", "1GB", "Embest" }, - { "a32082", "Q4 2016", "3 Model B", "1.2", "1GB", "Sony Japan" }, - { NULL, NULL, NULL, NULL, NULL, NULL } -}; - -static gchar *rpi_get_boardname(void) { - int i = 0, c = 0; - gchar *ret = NULL; - gchar *soc = NULL; - gchar *revision = NULL; - int overvolt = 0; - FILE *cpuinfo; - gchar buffer[128]; - - cpuinfo = fopen("/proc/cpuinfo", "r"); - if (!cpuinfo) - return NULL; - while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); - get_str("Revision", revision); - get_str("Hardware", soc); - } - fclose(cpuinfo); - - if (revision == NULL || soc == NULL) { - g_free(soc); - g_free(revision); - return NULL; - } - - if (g_str_has_prefix(revision, "1000")) - overvolt = 1; - - while (rpi_boardinfo[i].value != NULL) { - if (overvolt) - /* +4 to ignore the 1000 prefix */ - c = g_strcmp0(revision+4, rpi_boardinfo[i].value); - else - c = g_strcmp0(revision, rpi_boardinfo[i].value); - - if (c == 0) { - ret = g_strdup_printf("Raspberry Pi %s (%s) pcb-rev:%s soc:%s mem:%s mfg-by:%s%s", - rpi_boardinfo[i].model, rpi_boardinfo[i].intro, - rpi_boardinfo[i].pcb, soc, - rpi_boardinfo[i].mem, rpi_boardinfo[i].mfg, - (overvolt) ? " (over-volted)" : "" ); - break; - } - i++; - } - g_free(soc); - g_free(revision); - return ret; + return moreinfo_lookup ("DEV:MemTotal"); } gchar *get_motherboard(void) { - char *board_name, *board_vendor; + char *board_name, *board_vendor, *product_version; + #if defined(ARCH_x86) || defined(ARCH_x86_64) scan_dmi(FALSE); board_name = moreinfo_lookup("DEV:DMI:Board:Name"); board_vendor = moreinfo_lookup("DEV:DMI:Board:Vendor"); - - if (board_name && board_vendor && *board_name && *board_vendor) - return g_strconcat(board_vendor, " ", board_name, NULL); - else if (board_name && *board_name) - return g_strconcat(board_name, _(" (vendor unknown)"), NULL); - else if (board_vendor && *board_vendor) - return g_strconcat(board_vendor, _(" (model unknown)"), NULL); -#else - /* use device tree "model" */ - if (g_file_get_contents("/proc/device-tree/model", &board_vendor, NULL, NULL)) { - - /* if a raspberry pi, try and get a more detailed name */ - if (g_str_has_prefix(board_vendor, "Raspberry Pi")) { - board_name = rpi_get_boardname(); - if (board_name != NULL) { - g_free(board_vendor); - return board_name; - } - } + product_version = moreinfo_lookup("DEV:DMI:Product:Version#1"); - return board_vendor; - } + if (!board_name || !*board_name) + board_name = _(" (model unknown)"); + if (!board_vendor || !*board_vendor) + board_vendor = _(" (vendor unknown)"); + + if (product_version && *product_version) + return g_strdup_printf("%s / %s (%s)", product_version, board_name, board_vendor); + + return g_strconcat(board_vendor, " ", board_name, NULL); #endif + /* use device tree "model" */ + board_vendor = dtr_get_string("/model", 0); + if (board_vendor != NULL) + return board_vendor; + return g_strdup(_("Unknown")); } ShellModuleMethod *hi_exported_methods(void) { static ShellModuleMethod m[] = { - {"getProcessorCount", get_processor_count}, + {"getProcessorCount", get_processor_count}, {"getProcessorName", get_processor_name}, - {"getProcessorFrequency", get_processor_frequency}, + {"getProcessorDesc", get_processor_desc}, + {"getProcessorNameAndDesc", get_processor_name_and_desc}, + {"getProcessorFrequency", get_processor_max_frequency}, + {"getProcessorFrequencyDesc", get_processor_frequency_desc}, {"getMemoryTotal", get_memory_total}, {"getStorageDevices", get_storage_devices}, {"getPrinters", get_printers}, @@ -344,7 +411,7 @@ ShellModuleMethod *hi_exported_methods(void) gchar *hi_more_info(gchar * entry) { gchar *info = moreinfo_lookup_with_prefix("DEV", entry); - + if (info) return g_strdup(info); @@ -377,6 +444,13 @@ void scan_spd(gboolean reload) } #endif +void scan_dtree(gboolean reload) +{ + SCAN_START(); + __scan_dtree(); + SCAN_END(); +} + void scan_processors(gboolean reload) { SCAN_START(); @@ -462,15 +536,28 @@ gchar *callback_spd() } #endif +gchar *callback_dtree() +{ + return g_strdup_printf("%s" + "[$ShellParam$]\n" + "ViewType=1\n", dtree_info); +} + gchar *callback_memory() { return g_strdup_printf("[Memory]\n" - "%s\n" - "[$ShellParam$]\n" - "ViewType=2\n" - "LoadGraphSuffix= kB\n" - "RescanInterval=2000\n" - "%s\n", meminfo, lginterval); + "%s\n" + "[$ShellParam$]\n" + "ViewType=2\n" + "LoadGraphSuffix= kB\n" + "RescanInterval=2000\n" + "ColumnTitle$TextValue=%s\n" + "ColumnTitle$Extra1=%s\n" + "ColumnTitle$Value=%s\n" + "ShowColumnHeaders=true\n" + "%s\n", meminfo, + _("Field"), _("Description"), _("Value"), /* column labels */ + lginterval); } gchar *callback_battery() @@ -489,8 +576,20 @@ gchar *callback_pci() gchar *callback_sensors() { - return g_strdup_printf("[$ShellParam$]\n" - "ReloadInterval=5000\n" "%s", sensors); + return g_strdup_printf("[Sensors]\n" + "%s\n" + "[$ShellParam$]\n" + "ViewType=2\n" + "LoadGraphSuffix=\n" + "ColumnTitle$TextValue=%s\n" + "ColumnTitle$Value=%s\n" + "ColumnTitle$Extra1=%s\n" + "ShowColumnHeaders=true\n" + "RescanInterval=5000\n" + "%s", + sensors, + _("Sensor"), _("Value"), _("Type"), /* column labels */ + lginterval); } gchar *callback_printers() @@ -564,7 +663,7 @@ void hi_module_init(void) .save_to = "cpuflags.conf", .get_data = NULL }; - + sync_manager_add_entry(&se); } #endif /* defined(ARCH_x86) */ @@ -606,7 +705,7 @@ const gchar *hi_note_func(gint entry) { if (entry == ENTRY_RESOURCES) { if (root_required_for_resources()) { - return g_strdup_printf(_("Resource information requires superuser privileges")); + return g_strdup(_("Resource information requires superuser privileges")); } } return NULL; diff --git a/modules/devices/alpha/processor.c b/modules/devices/alpha/processor.c index f55526f7..c7862232 100644 --- a/modules/devices/alpha/processor.c +++ b/modules/devices/alpha/processor.c @@ -18,6 +18,7 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" GSList * processor_scan(void) @@ -25,54 +26,69 @@ processor_scan(void) Processor *processor; FILE *cpuinfo; gchar buffer[128]; + long long hz = 0; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) - return NULL; + return NULL; processor = g_new0(Processor, 1); while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); + gchar **tmp = g_strsplit(buffer, ":", 2); - if (tmp[0] && tmp[1]) { - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); - get_str("cpu model", processor->model_name); - get_float("BogoMIPS", processor->bogomips); - get_str("platform string", processor->strmodel); + get_str("cpu model", processor->model_name); + get_float("BogoMIPS", processor->bogomips); + get_str("platform string", processor->strmodel); + get_str("cycle frequency [Hz]", processor->cycle_frequency_hz_str); - } - g_strfreev(tmp); + } + g_strfreev(tmp); } - + + fclose(cpuinfo); + gchar *tmp = g_strconcat("Alpha ", processor->model_name, NULL); g_free(processor->model_name); processor->model_name = tmp; - processor->cpu_mhz = 0.0f; - fclose(cpuinfo); + if (processor->cycle_frequency_hz_str) { + hz = atoll(processor->cycle_frequency_hz_str); + processor->cpu_mhz = hz; + processor->cpu_mhz /= 1000000; + } else + processor->cpu_mhz = 0.0f; return g_slist_append(NULL, processor); } +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); +} + gchar * processor_get_info(GSList *processors) { - Processor *processor = (Processor *)processors->data; + Processor *processor = (Processor *)processors->data; - return g_strdup_printf("[Processor]\n" - "Model=%s\n" - "Platform String=%s\n" - "BogoMIPS=%.2f" - "Byte Order=%s\n", - processor->model_name, - processor->strmodel, - processor->bogomips, -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian" -#else - "Big Endian" -#endif - ); + return g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%.2f %s\n" /* frequency */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n", /* byte order */ + _("Processor"), + _("Model"), processor->model_name, + _("Platform String"), processor->strmodel, + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str() + ); } diff --git a/modules/devices/arm/arm_data.c b/modules/devices/arm/arm_data.c index 2e2cbe60..60e8ea34 100644 --- a/modules/devices/arm/arm_data.c +++ b/modules/devices/arm/arm_data.c @@ -23,6 +23,13 @@ #include <string.h> #include "arm_data.h" +#ifndef C_ +#define C_(Ctx, String) String +#endif +#ifndef NC_ +#define NC_(Ctx, String) String +#endif + /* sources: * https://unix.stackexchange.com/a/43563 * git:linux/arch/arm/kernel/setup.c @@ -32,47 +39,46 @@ static struct { char *name, *meaning; } tab_flag_meaning[] = { /* arm/hw_cap */ - { "swp", "SWP instruction (atomic read-modify-write)" }, - { "half", "Half-word loads and stores" }, - { "thumb", "Thumb (16-bit instruction set)" }, - { "26bit", "26-Bit Model (Processor status register folded into program counter)" }, - { "fastmult", "32x32->64-bit multiplication" }, - { "fpa", "Floating point accelerator" }, - { "vfp", "VFP (early SIMD vector floating point instructions)" }, - { "edsp", "DSP extensions (the 'e' variant of the ARM9 CPUs, and all others above)" }, - { "java", "Jazelle (Java bytecode accelerator)" }, - { "iwmmxt", "SIMD instructions similar to Intel MMX" }, - { "crunch", "MaverickCrunch coprocessor (if kernel support enabled)" }, - { "thumbee", "ThumbEE" }, - { "neon", "Advanced SIMD/NEON on AArch32" }, - { "evtstrm", "kernel event stream using generic architected timer" }, - { "vfpv3", "VFP version 3" }, - { "vfpv3d16", "VFP version 3 with 16 D-registers" }, - { "vfpv4", "VFP version 4 with fast context switching" }, - { "vfpd32", "VFP with 32 D-registers" }, - { "tls", "TLS register" }, - { "idiva", "SDIV and UDIV hardware division in ARM mode" }, - { "idivt", "SDIV and UDIV hardware division in Thumb mode" }, - { "lpae", "40-bit Large Physical Address Extension" }, + { "swp", NC_("arm-flag", /*/flag:swp*/ "SWP instruction (atomic read-modify-write)") }, + { "half", NC_("arm-flag", /*/flag:half*/ "Half-word loads and stores") }, + { "thumb", NC_("arm-flag", /*/flag:thumb*/ "Thumb (16-bit instruction set)") }, + { "26bit", NC_("arm-flag", /*/flag:26bit*/ "26-Bit Model (Processor status register folded into program counter)") }, + { "fastmult", NC_("arm-flag", /*/flag:fastmult*/ "32x32->64-bit multiplication") }, + { "fpa", NC_("arm-flag", /*/flag:fpa*/ "Floating point accelerator") }, + { "vfp", NC_("arm-flag", /*/flag:vfp*/ "VFP (early SIMD vector floating point instructions)") }, + { "edsp", NC_("arm-flag", /*/flag:edsp*/ "DSP extensions (the 'e' variant of the ARM9 CPUs, and all others above)") }, + { "java", NC_("arm-flag", /*/flag:java*/ "Jazelle (Java bytecode accelerator)") }, + { "iwmmxt", NC_("arm-flag", /*/flag:iwmmxt*/ "SIMD instructions similar to Intel MMX") }, + { "crunch", NC_("arm-flag", /*/flag:crunch*/ "MaverickCrunch coprocessor (if kernel support enabled)") }, + { "thumbee", NC_("arm-flag", /*/flag:thumbee*/ "ThumbEE") }, + { "neon", NC_("arm-flag", /*/flag:neon*/ "Advanced SIMD/NEON on AArch32") }, + { "evtstrm", NC_("arm-flag", /*/flag:evtstrm*/ "Kernel event stream using generic architected timer") }, + { "vfpv3", NC_("arm-flag", /*/flag:vfpv3*/ "VFP version 3") }, + { "vfpv3d16", NC_("arm-flag", /*/flag:vfpv3d16*/ "VFP version 3 with 16 D-registers") }, + { "vfpv4", NC_("arm-flag", /*/flag:vfpv4*/ "VFP version 4 with fast context switching") }, + { "vfpd32", NC_("arm-flag", /*/flag:vfpd32*/ "VFP with 32 D-registers") }, + { "tls", NC_("arm-flag", /*/flag:tls*/ "TLS register") }, + { "idiva", NC_("arm-flag", /*/flag:idiva*/ "SDIV and UDIV hardware division in ARM mode") }, + { "idivt", NC_("arm-flag", /*/flag:idivt*/ "SDIV and UDIV hardware division in Thumb mode") }, + { "lpae", NC_("arm-flag", /*/flag:lpae*/ "40-bit Large Physical Address Extension") }, /* arm/hw_cap2 */ - { "pmull", "64x64->128-bit F2m multiplication (arch>8)" }, - { "aes", "Crypto:AES (arch>8)" }, - { "sha1", "Crypto:SHA1 (arch>8)" }, - { "sha2", "Crypto:SHA2 (arch>8)" }, - { "crc32", "CRC32 checksum instructions (arch>8)" }, + { "pmull", NC_("arm-flag", /*/flag:pmull*/ "64x64->128-bit F2m multiplication (arch>8)") }, + { "aes", NC_("arm-flag", /*/flag:aes*/ "Crypto:AES (arch>8)") }, + { "sha1", NC_("arm-flag", /*/flag:sha1*/ "Crypto:SHA1 (arch>8)") }, + { "sha2", NC_("arm-flag", /*/flag:sha2*/ "Crypto:SHA2 (arch>8)") }, + { "crc32", NC_("arm-flag", /*/flag:crc32*/ "CRC32 checksum instructions (arch>8)") }, /* arm64/hw_cap */ - { "fp", "" }, - { "asimd", "Advanced SIMD/NEON on AArch64 (arch>8)" }, - { "atomics", "" }, - { "fphp", "" }, - { "asimdhp", "" }, - { "cpuid", "" }, - { "asimdrdm", "" }, - { "jscvt", "" }, - { "fcma", "" }, - { "lrcpc", "" }, - - { NULL, NULL}, + { "fp", NULL }, + { "asimd", NC_("arm-flag", /*/flag:asimd*/ "Advanced SIMD/NEON on AArch64 (arch>8)") }, + { "atomics", NULL }, + { "fphp", NULL }, + { "asimdhp", NULL }, + { "cpuid", NULL }, + { "asimdrdm", NULL }, + { "jscvt", NULL }, + { "fcma", NULL }, + { "lrcpc", NULL }, + { NULL, NULL } }; static struct { @@ -108,9 +114,11 @@ static struct { /*d */ { 0xd01, "Cortex-A32" }, /*dt*/ { 0xd03, "Cortex-A53" }, /*d */ { 0xd04, "Cortex-A35" }, + /*d */ { 0xd05, "Cortex-A55" }, /*d */ { 0xd07, "Cortex-A57 MPCore" }, /*d */ { 0xd08, "Cortex-A72" }, /*d */ { 0xd09, "Cortex-A73" }, + /*d */ { 0xd0a, "Cortex-A75" }, { 0, NULL}, }; @@ -143,8 +151,11 @@ const char *arm_flag_meaning(const char *flag) { int i = 0; if (flag) while(tab_flag_meaning[i].name != NULL) { - if (strcmp(tab_flag_meaning[i].name, flag) == 0) - return tab_flag_meaning[i].meaning; + if (strcmp(tab_flag_meaning[i].name, flag) == 0) { + if (tab_flag_meaning[i].meaning != NULL) + return C_("arm-flag", tab_flag_meaning[i].meaning); + else return NULL; + } i++; } return NULL; @@ -220,7 +231,7 @@ char *arm_decoded_name(const char *imp, const char *part, const char *var, const p = strtol(rev, NULL, 0); imp_name = (char*) arm_implementer(imp); part_desc = (char*) arm_part(imp, part); - arch_name = (char *) arm_arch(arch); + arch_name = (char*) arm_arch(arch); if (imp_name || part_desc) { if (arch_name != arch) sprintf(dnbuff, "%s %s r%dp%d (%s)", diff --git a/modules/devices/arm/processor.c b/modules/devices/arm/processor.c index ad7adf7f..e9446229 100644 --- a/modules/devices/arm/processor.c +++ b/modules/devices/arm/processor.c @@ -18,6 +18,8 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" +#include "dt_util.h" #include "arm_data.h" #include "arm_data.c" @@ -34,34 +36,6 @@ static const gchar *arm_mode_str[] = { "A32 on A64", }; -static gint get_cpu_int(const gchar* file, gint cpuid) { - gchar *tmp0 = NULL; - gchar *tmp1 = NULL; - gint ret = 0; - - tmp0 = g_strdup_printf("/sys/devices/system/cpu/cpu%d/%s", cpuid, file); - g_file_get_contents(tmp0, &tmp1, NULL, NULL); - if (tmp1) - ret = atol(tmp1); - g_free(tmp0); - g_free(tmp1); - return ret; -} - -int processor_has_flag(gchar * strflags, gchar * strflag) -{ - gchar **flags; - gint ret = 0; - if (strflags == NULL || strflag == NULL) - return 0; - flags = g_strsplit(strflags, " ", 0); - ret = g_strv_contains((const gchar * const *)flags, strflag); - g_strfreev(flags); - return ret; -} - -#define PROC_CPUINFO "/proc/cpuinfo" - GSList * processor_scan(void) { @@ -70,7 +44,6 @@ processor_scan(void) FILE *cpuinfo; gchar buffer[128]; gchar *rep_pname = NULL; - gchar *tmpfreq_str = NULL; GSList *pi = NULL; cpuinfo = fopen(PROC_CPUINFO, "r"); @@ -101,7 +74,7 @@ processor_scan(void) processor->id = atol(tmp[1]); if (rep_pname) - processor->model_name = g_strdup(rep_pname); + processor->linux_name = g_strdup(rep_pname); g_strfreev(tmp); continue; @@ -117,11 +90,11 @@ processor_scan(void) processor->id = 0; if (rep_pname) - processor->model_name = g_strdup(rep_pname); + processor->linux_name = g_strdup(rep_pname); } if (processor) { - get_str("model name", processor->model_name); + get_str("model name", processor->linux_name); get_str("Features", processor->flags); get_float("BogoMIPS", processor->bogomips); @@ -166,29 +139,26 @@ processor_scan(void) processor = (Processor *) pi->data; /* strings can't be null or segfault later */ -#define STRIFNULL(f,cs) if (processor->f == NULL) processor->f = g_strdup(cs); -#define UNKIFNULL(f) STRIFNULL(f, "(Unknown)") -#define EMPIFNULL(f) STRIFNULL(f, "") - STRIFNULL(model_name, "ARM Processor"); - EMPIFNULL(flags); - UNKIFNULL(cpu_implementer); - UNKIFNULL(cpu_architecture); - UNKIFNULL(cpu_variant); - UNKIFNULL(cpu_part); - UNKIFNULL(cpu_revision); - - processor->decoded_name = arm_decoded_name( + STRIFNULL(processor->linux_name, _("ARM Processor") ); + EMPIFNULL(processor->flags); + UNKIFNULL(processor->cpu_implementer); + UNKIFNULL(processor->cpu_architecture); + UNKIFNULL(processor->cpu_variant); + UNKIFNULL(processor->cpu_part); + UNKIFNULL(processor->cpu_revision); + + processor->model_name = arm_decoded_name( processor->cpu_implementer, processor->cpu_part, processor->cpu_variant, processor->cpu_revision, - processor->cpu_architecture, processor->model_name); - UNKIFNULL(decoded_name); - - /* freq */ - processor->cpukhz_cur = get_cpu_int("cpufreq/scaling_cur_freq", processor->id); - processor->cpukhz_min = get_cpu_int("cpufreq/scaling_min_freq", processor->id); - processor->cpukhz_max = get_cpu_int("cpufreq/scaling_max_freq", processor->id); - if (processor->cpukhz_max) - processor->cpu_mhz = processor->cpukhz_max / 1000; + processor->cpu_architecture, processor->linux_name); + UNKIFNULL(processor->model_name); + + /* topo & freq */ + processor->cpufreq = cpufreq_new(processor->id); + processor->cputopo = cputopo_new(processor->id); + + if (processor->cpufreq->cpukhz_max) + processor->cpu_mhz = processor->cpufreq->cpukhz_max / 1000; else processor->cpu_mhz = 0.0f; @@ -236,78 +206,168 @@ gchar *processor_get_capabilities_from_flags(gchar * strflags) gchar * processor_get_detailed_info(Processor *processor) { - gchar *tmp_flags, *tmp_imp, *tmp_part, *tmp_arch, *ret; + gchar *tmp_flags, *tmp_imp, *tmp_part, *tmp_arch, *tmp_cpufreq, *tmp_topology, *ret; tmp_flags = processor_get_capabilities_from_flags(processor->flags); tmp_imp = (char*)arm_implementer(processor->cpu_implementer); tmp_part = (char*)arm_part(processor->cpu_implementer, processor->cpu_part); tmp_arch = (char*)arm_arch_more(processor->cpu_architecture); - ret = g_strdup_printf("[Processor]\n" - "Linux Name=%s\n" - "Decoded Name=%s\n" - "Mode=%s\n" - "BogoMips=%.2f\n" - "Endianesss=" -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian" -#else - "Big Endian" -#endif - "\n" - "[Frequency Scaling]\n" - "Minimum=%d kHz\n" - "Maximum=%d kHz\n" - "Current=%d kHz\n" - "[ARM]\n" - "Implementer=[%s] %s\n" - "Part=[%s] %s\n" - "Architecture=[%s] %s\n" - "Variant=%s\n" - "Revision=%s\n" - "[Capabilities]\n" + tmp_topology = cputopo_section_str(processor->cputopo); + tmp_cpufreq = cpufreq_section_str(processor->cpufreq); + + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" /* linux name */ + "%s=%s\n" /* decoded name */ + "%s=%s\n" /* mode */ + "%s=%.2f %s\n" /* frequency */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n" /* byte order */ + "%s" /* topology */ + "%s" /* frequency scaling */ + "[%s]\n" /* ARM */ + "%s=[%s] %s\n" /* implementer */ + "%s=[%s] %s\n" /* part */ + "%s=[%s] %s\n" /* architecture */ + "%s=%s\n" /* variant */ + "%s=%s\n" /* revision */ + "[%s]\n" /* flags */ "%s" - "%s", - processor->model_name, - processor->decoded_name, - arm_mode_str[processor->mode], - processor->bogomips, - processor->cpukhz_min, - processor->cpukhz_max, - processor->cpukhz_cur, - processor->cpu_implementer, (tmp_imp) ? tmp_imp : "", - processor->cpu_part, (tmp_part) ? tmp_part : "", - processor->cpu_architecture, (tmp_arch) ? tmp_arch : "", - processor->cpu_variant, - processor->cpu_revision, - tmp_flags, + "%s", /* empty */ + _("Processor"), + _("Linux Name"), processor->linux_name, + _("Decoded Name"), processor->model_name, + _("Mode"), arm_mode_str[processor->mode], + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str(), + tmp_topology, + tmp_cpufreq, + _("ARM"), + _("Implementer"), processor->cpu_implementer, (tmp_imp) ? tmp_imp : "", + _("Part"), processor->cpu_part, (tmp_part) ? tmp_part : "", + _("Architecture"), processor->cpu_architecture, (tmp_arch) ? tmp_arch : "", + _("Variant"), processor->cpu_variant, + _("Revision"), processor->cpu_revision, + _("Capabilities"), tmp_flags, ""); g_free(tmp_flags); + g_free(tmp_cpufreq); + g_free(tmp_topology); + return ret; +} +gchar *processor_name(GSList *processors) { + /* compatible contains a list of compatible hardware, so be careful + * with matching order. + * ex: "ti,omap3-beagleboard-xm", "ti,omap3450", "ti,omap3"; + * matches "omap3 family" first. + * ex: "brcm,bcm2837", "brcm,bcm2836"; + * would match 2836 when it is a 2837. + */ +#define UNKSOC "(Unknown)" + const struct { + char *search_str; + char *vendor; + char *soc; + } dt_compat_searches[] = { + { "brcm,bcm2837", "Broadcom", "BCM2837" }, + { "brcm,bcm2836", "Broadcom", "BCM2836" }, + { "brcm,bcm2835", "Broadcom", "BCM2835" }, + { "ti,omap5432", "Texas Instruments", "OMAP5432" }, + { "ti,omap5430", "Texas Instruments", "OMAP5430" }, + { "ti,omap4470", "Texas Instruments", "OMAP4470" }, + { "ti,omap4460", "Texas Instruments", "OMAP4460" }, + { "ti,omap4430", "Texas Instruments", "OMAP4430" }, + { "ti,omap3620", "Texas Instruments", "OMAP3620" }, + { "ti,omap3450", "Texas Instruments", "OMAP3450" }, + { "ti,omap5", "Texas Instruments", "OMAP5-family" }, + { "ti,omap4", "Texas Instruments", "OMAP4-family" }, + { "ti,omap3", "Texas Instruments", "OMAP3-family" }, + { "ti,omap2", "Texas Instruments", "OMAP2-family" }, + { "ti,omap1", "Texas Instruments", "OMAP1-family" }, + { "qcom,msm8939", "Qualcomm", "Snapdragon 615"}, + { "qcom,msm", "Qualcomm", "Snapdragon-family"}, + { "nvidia,tegra" "nVidia", "Tegra-family" }, + { "bcm,", "Broadcom", UNKSOC }, + { "nvidia," "nVidia", UNKSOC }, + { "rockchip," "Rockchip", UNKSOC }, + { "ti,", "Texas Instruments", UNKSOC }, + { "qcom,", "Qualcom", UNKSOC }, + { NULL, NULL } + }; + gchar *ret = NULL; + gchar *compat = NULL; + int i; + + compat = dtr_get_string("/compatible", 1); + + if (compat != NULL) { + i = 0; + while(dt_compat_searches[i].search_str != NULL) { + if (strstr(compat, dt_compat_searches[i].search_str) != NULL) { + ret = g_strdup_printf("%s %s", dt_compat_searches[i].vendor, dt_compat_searches[i].soc); + break; + } + i++; + } + } + g_free(compat); + UNKIFNULL(ret); + return ret; +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_by_counting_names(processors); +} + +gchar *processor_meta(GSList * processors) { + gchar *meta_soc = processor_name(processors); + gchar *meta_cpu_desc = processor_describe(processors); + gchar *meta_cpu_topo = processor_describe_default(processors); + gchar *meta_clocks = processor_frequency_desc(processors); + gchar *ret = NULL; + UNKIFNULL(meta_cpu_desc); + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n", + _("SOC/Package"), + _("Name"), meta_soc, + _("Description"), meta_cpu_desc, + _("Topology"), meta_cpu_topo, + _("Clocks"), meta_clocks ); + g_free(meta_soc); + g_free(meta_cpu_desc); + g_free(meta_cpu_topo); + g_free(meta_clocks); return ret; } gchar *processor_get_info(GSList * processors) { Processor *processor; - - if (g_slist_length(processors) > 1) { gchar *ret, *tmp, *hashkey; + gchar *meta; /* becomes owned by more_info? no need to free? */ GSList *l; - tmp = g_strdup(""); + tmp = g_strdup_printf("$CPU_META$%s=\n", _("SOC/Package Information") ); + + meta = processor_meta(processors); + moreinfo_add_with_prefix("DEV", "CPU_META", meta); for (l = processors; l; l = l->next) { processor = (Processor *) l->data; - tmp = g_strdup_printf(_("%s$CPU%d$%s=%.2fMHz\n"), + tmp = g_strdup_printf("%s$CPU%d$%s=%.2f %s\n", tmp, processor->id, processor->model_name, - processor->cpu_mhz); + processor->cpu_mhz, _("MHz")); hashkey = g_strdup_printf("CPU%d", processor->id); moreinfo_add_with_prefix("DEV", hashkey, processor_get_detailed_info(processor)); - g_free(hashkey); + g_free(hashkey); } ret = g_strdup_printf("[$ShellParam$]\n" @@ -317,8 +377,4 @@ gchar *processor_get_info(GSList * processors) g_free(tmp); return ret; - } - - processor = (Processor *) processors->data; - return processor_get_detailed_info(processor); } diff --git a/modules/devices/cpu_util.c b/modules/devices/cpu_util.c new file mode 100644 index 00000000..f5bddd5c --- /dev/null +++ b/modules/devices/cpu_util.c @@ -0,0 +1,225 @@ +/* + * HardInfo - Displays System Information + * Copyright (C) 2003-2006 Leandro A. F. Pereira <leandro@hardinfo.org> + * This file by Burt P. <pburt0@gmail.com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <string.h> +#include "hardinfo.h" +#include "cpu_util.h" + +#include "cpubits.c" + +#define CPU_TOPO_NULL -9877 + +const gchar *byte_order_str() { +#if G_BYTE_ORDER == G_LITTLE_ENDIAN + return _("Little Endian"); +#else + return _("Big Endian"); +#endif +} + +int processor_has_flag(gchar * strflags, gchar * strflag) +{ + gchar **flags; + gint ret = 0; + if (strflags == NULL || strflag == NULL) + return 0; + flags = g_strsplit(strflags, " ", 0); + ret = g_strv_contains((const gchar * const *)flags, strflag); + g_strfreev(flags); + return ret; +} + +gchar* get_cpu_str(const gchar* file, gint cpuid) { + gchar *tmp0 = NULL; + gchar *tmp1 = NULL; + tmp0 = g_strdup_printf("/sys/devices/system/cpu/cpu%d/%s", cpuid, file); + g_file_get_contents(tmp0, &tmp1, NULL, NULL); + g_free(tmp0); + return tmp1; +} + +gint get_cpu_int(const char* item, int cpuid, int null_val) { + gchar *fc = NULL; + int ret = null_val; + fc = get_cpu_str(item, cpuid); + if (fc) { + ret = atol(fc); + g_free(fc); + } + return ret; +} + +/* cpubits is 32768 bits long + * core_ids are not unique among physical_ids + * hack up cpubits into 128 packs of 256 cores + * to make cores unique in cpubits */ +#define MAX_CORES_PER_PACK 256 +#define MAX_PACKS 128 + +int cpu_procs_cores_threads(int *p, int *c, int *t) { + cpubits *threads, *cores, *packs; + char *tmp; + int i, m, pack_id, core_id; + g_file_get_contents("/sys/devices/system/cpu/present", &tmp, NULL, NULL); + if (tmp != NULL) { + threads = cpubits_from_str(tmp); + cores = cpubits_from_str(""); + packs = cpubits_from_str(""); + m = cpubits_max(threads); + for (i = 0; i <= m; i++) { + pack_id = get_cpu_int("topology/physical_package_id", i, CPU_TOPO_NULL); + core_id = get_cpu_int("topology/core_id", i, CPU_TOPO_NULL); + if (pack_id >= 0) { CPUBIT_SET(packs, pack_id); } + if (core_id >= 0) { CPUBIT_SET(cores, (pack_id * MAX_CORES_PER_PACK) + core_id ); } + } + *t = cpubits_count(threads); + *c = cpubits_count(cores); + *p = cpubits_count(packs); + if (!*c) *c = 1; + if (!*p) *p = 1; + free(threads); + free(cores); + free(packs); + free(tmp); + return 1; + } else { + *p = *c = *t = -1; + return 0; + } +} + +cpufreq_data *cpufreq_new(gint id) +{ + cpufreq_data *cpufd; + cpufd = malloc(sizeof(cpufreq_data)); + if (cpufd) { + memset(cpufd, 0, sizeof(cpufreq_data)); + cpufd->id = id; + cpufreq_update(cpufd, 0); + } + return cpufd; +} + +void cpufreq_update(cpufreq_data *cpufd, int cur_only) +{ + if (cpufd) { + cpufd->cpukhz_cur = get_cpu_int("cpufreq/scaling_cur_freq", cpufd->id, 0); + if (cur_only) return; + cpufd->scaling_driver = get_cpu_str("cpufreq/scaling_driver", cpufd->id); + cpufd->scaling_governor = get_cpu_str("cpufreq/scaling_governor", cpufd->id); + cpufd->transition_latency = get_cpu_int("cpufreq/cpuinfo_transition_latency", cpufd->id, 0); + cpufd->cpukhz_min = get_cpu_int("cpufreq/scaling_min_freq", cpufd->id, 0); + cpufd->cpukhz_max = get_cpu_int("cpufreq/scaling_max_freq", cpufd->id, 0); + if (cpufd->scaling_driver == NULL) cpufd->scaling_driver = g_strdup("(Unknown)"); + if (cpufd->scaling_governor == NULL) cpufd->scaling_governor = g_strdup("(Unknown)"); + } +} + +void cpufreq_free(cpufreq_data *cpufd) +{ + if (cpufd) { + g_free(cpufd->scaling_driver); + g_free(cpufd->scaling_governor); + } + g_free(cpufd); +} + +cpu_topology_data *cputopo_new(gint id) +{ + cpu_topology_data *cputd; + cputd = malloc(sizeof(cpu_topology_data)); + if (cputd) { + memset(cputd, 0, sizeof(cpu_topology_data)); + cputd->id = id; + cputd->socket_id = get_cpu_int("topology/physical_package_id", id, CPU_TOPO_NULL); + cputd->core_id = get_cpu_int("topology/core_id", id, CPU_TOPO_NULL); + cputd->book_id = get_cpu_int("topology/book_id", id, CPU_TOPO_NULL); + cputd->drawer_id = get_cpu_int("topology/drawer_id", id, CPU_TOPO_NULL); + } + return cputd; + +} + +void cputopo_free(cpu_topology_data *cputd) +{ + g_free(cputd); +} + +gchar *cpufreq_section_str(cpufreq_data *cpufd) +{ + if (cpufd == NULL) + return g_strdup(""); + + if (cpufd->cpukhz_min || cpufd->cpukhz_max || cpufd->cpukhz_cur) { + return g_strdup_printf( + "[%s]\n" + "%s=%d %s\n" + "%s=%d %s\n" + "%s=%d %s\n" + "%s=%d %s\n" + "%s=%s\n" + "%s=%s\n", + _("Frequency Scaling"), + _("Minimum"), cpufd->cpukhz_min, _("kHz"), + _("Maximum"), cpufd->cpukhz_max, _("kHz"), + _("Current"), cpufd->cpukhz_cur, _("kHz"), + _("Transition Latency"), cpufd->transition_latency, _("ns"), + _("Governor"), cpufd->scaling_governor, + _("Driver"), cpufd->scaling_driver); + } else { + return g_strdup_printf( + "[%s]\n" + "%s=%s\n", + _("Frequency Scaling"), + _("Driver"), cpufd->scaling_driver); + } +} + +gchar *cputopo_section_str(cpu_topology_data *cputd) +{ + static const char na[] = N_("(Not Available)"); + char sock_str[64] = "", core_str[64] = ""; + char book_str[64] = "", drawer_str[64] = ""; + + if (cputd == NULL) + return g_strdup(""); + + if (cputd->socket_id != CPU_TOPO_NULL && cputd->socket_id != -1) + sprintf(sock_str, "%s=%d\n", _("Socket"), cputd->socket_id); + else + sprintf(sock_str, "%s=%s\n", _("Socket"), na); + + if (cputd->core_id != CPU_TOPO_NULL) + sprintf(core_str, "%s=%d\n", _("Core"), cputd->core_id); + else + sprintf(core_str, "%s=%s\n", _("Core"), na); + + if (cputd->book_id != CPU_TOPO_NULL) + sprintf(core_str, "%s=%d\n", _("Book"), cputd->book_id); + if (cputd->book_id != CPU_TOPO_NULL) + sprintf(core_str, "%s=%d\n", _("Drawer"), cputd->drawer_id); + + return g_strdup_printf( + "[%s]\n" + "%s=%d\n" + "%s%s%s%s", + _("Topology"), + _("ID"), cputd->id, + sock_str, core_str, book_str, drawer_str ); +} diff --git a/modules/devices/cpubits.c b/modules/devices/cpubits.c new file mode 100644 index 00000000..ba9bffc7 --- /dev/null +++ b/modules/devices/cpubits.c @@ -0,0 +1,113 @@ +/* + * rpiz - https://github.com/bp0/rpiz + * Copyright (C) 2017 Burt P. <pburt0@gmail.com> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <stdint.h> + +typedef uint32_t cpubits; +uint32_t cpubits_count(cpubits *b); +cpubits *cpubits_from_str(char *str); +char *cpubits_to_str(cpubits *bits, char *str, int max_len); + +#define CPUBITS_SIZE 4096 /* bytes, multiple of sizeof(uint32_t) */ +#define CPUBIT_SET(BITS, BIT) (BITS[BIT/32] |= (1 << BIT%32)) +#define CPUBIT_GET(BITS, BIT) ((BITS[BIT/32] & (1 << BIT%32)) >> BIT%32) +#define CPUBITS_CLEAR(BITS) memset(BITS, 0, CPUBITS_SIZE) + +uint32_t cpubits_count(cpubits *b) { + static const uint32_t max = CPUBITS_SIZE * 8; + uint32_t count = 0, i = 0; + while (i < max) { + count += CPUBIT_GET(b, i); + i++; + } + return count; +} + +int cpubits_max(cpubits *b) { + int i = CPUBITS_SIZE * 8; + while (i >= 0) { + if (CPUBIT_GET(b, i)) + break; + i--; + } + return i; +} + +cpubits *cpubits_from_str(char *str) { + char *v, *nv, *hy; + int r0, r1; + cpubits *newbits = malloc(CPUBITS_SIZE); + if (newbits) { + memset(newbits, 0, CPUBITS_SIZE); + if (str != NULL) { + v = (char*)str; + while ( *v != 0 ) { + nv = strchr(v, ','); /* strchrnul() */ + if (nv == NULL) nv = strchr(v, 0); /* equivalent */ + hy = strchr(v, '-'); + if (hy && hy < nv) { + r0 = strtol(v, NULL, 0); + r1 = strtol(hy + 1, NULL, 0); + } else { + r0 = r1 = strtol(v, NULL, 0); + } + for (; r0 <= r1; r0++) { + CPUBIT_SET(newbits, r0); + } + v = (*nv == ',') ? nv + 1 : nv; + } + } + } + return newbits; +} + +char *cpubits_to_str(cpubits *bits, char *str, int max_len) { + static const uint32_t max = CPUBITS_SIZE * 8; + uint32_t i = 1, seq_start = 0, seq_last = 0, seq = 0, l = 0; + char buffer[65536] = ""; + if (CPUBIT_GET(bits, 0)) { + seq = 1; + strcpy(buffer, "0"); + } + while (i < max) { + if (CPUBIT_GET(bits, i) ) { + seq_last = i; + if (!seq) { + seq = 1; + seq_start = i; + l = strlen(buffer); + sprintf(buffer + l, "%s%d", l ? "," : "", i); + } + } else { + if (seq && seq_last != seq_start) { + l = strlen(buffer); + sprintf(buffer + l, "-%d", seq_last); + } + seq = 0; + } + i++; + } + if (str == NULL) + return strdup(buffer); + else { + strncpy(str, buffer, max_len); + return str; + } +} diff --git a/modules/devices/devicetree.c b/modules/devices/devicetree.c new file mode 100644 index 00000000..6fce066a --- /dev/null +++ b/modules/devices/devicetree.c @@ -0,0 +1,272 @@ +/* + * HardInfo - Displays System Information + * Copyright (C) 2003-2007 Leandro A. F. Pereira <leandro@hardinfo.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ +/* + * Device Tree support by Burt P. <pburt0@gmail.com> + * Sources: + * http://elinux.org/Device_Tree_Usage + * http://elinux.org/Device_Tree_Mysteries + */ +#include <unistd.h> +#include <sys/types.h> +#include <stdint.h> +#include "hardinfo.h" +#include "devices.h" +#include "cpu_util.h" +#include "dt_util.h" + +#include "devicetree/rpi_data.c" +#include "devicetree/pmac_data.c" + +dtr *dt; +gchar *dtree_info = NULL; + +gchar *get_node(char *np) { + gchar *nodes = NULL, *props = NULL, *ret = NULL; + gchar *tmp = NULL, *pstr = NULL, *lstr = NULL; + gchar *dir_path; + gchar *node_path; + const gchar *fn; + GDir *dir; + dtr_obj *node, *child; + + props = g_strdup_printf("[%s]\n", _("Properties") ); + nodes = g_strdup_printf("[%s]\n", _("Children") ); + node = dtr_obj_read(dt, np); + dir_path = dtr_obj_full_path(node); + + dir = g_dir_open(dir_path, 0 , NULL); + if (dir) { + while((fn = g_dir_read_name(dir)) != NULL) { + child = dtr_get_prop_obj(dt, node, fn); + pstr = hardinfo_clean_value(dtr_str(child), 1); + lstr = hardinfo_clean_label(fn, 0); + if (dtr_obj_type(child) == DT_NODE) { + tmp = g_strdup_printf("%s%s=%s\n", + nodes, lstr, pstr); + g_free(nodes); + nodes = tmp; + } else { + tmp = g_strdup_printf("%s%s=%s\n", + props, lstr, pstr); + g_free(props); + props = tmp; + } + dtr_obj_free(child); + g_free(pstr); + g_free(lstr); + } + } + g_dir_close(dir); + g_free(dir_path); + + lstr = dtr_obj_alias(node); + pstr = dtr_obj_symbol(node); + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s%s", + _("Node"), + _("Node Path"), dtr_obj_path(node), + _("Alias"), (lstr != NULL) ? lstr : _("(None)"), + _("Symbol"), (pstr != NULL) ? pstr : _("(None)"), + props, nodes); + + dtr_obj_free(node); + g_free(props); + g_free(nodes); + return ret; +} + +/* different from dtr_get_string() in that it re-uses the existing dt */ +char *get_dt_string(char *path, int decode) { + dtr_obj *obj; + char *ret = NULL; + if (decode) { + obj = dtr_get_prop_obj(dt, NULL, path); + ret = dtr_str(obj); + dtr_obj_free(obj); + } else + ret = dtr_get_prop_str(dt, NULL, path); + return ret; +} + +gchar *get_summary() { + char *model = NULL, *compat = NULL; + char *tmp[10]; + char *ret = NULL; + + model = get_dt_string("/model", 0); + compat = get_dt_string("/compatible", 1); + UNKIFNULL(model); + EMPIFNULL(compat); + + /* Expand on the DT information from known machines, like RPi. + * RPi stores a revision value in /proc/cpuinfo that can be used + * to look up details. This is just a nice place to pull it all + * together for DT machines, with a nice fallback. + * PPC Macs could be handled this way too. They store + * machine identifiers in /proc/cpuinfo. */ + if ( strstr(model, "Raspberry Pi") != NULL + || strstr(compat, "raspberrypi") != NULL ) { + tmp[0] = get_dt_string("/serial-number", 1); + tmp[1] = get_dt_string("/soc/gpu/compatible", 1); + tmp[9] = rpi_board_details(); + tmp[8] = g_strdup_printf( + "[%s]\n" "%s=%s\n" "%s=%s\n", + _("Platform"), + _("Compatible"), compat, + _("GPU-compatible"), tmp[1] ); + if (tmp[9] != NULL) { + ret = g_strdup_printf("%s%s", tmp[9], tmp[8]); + } else { + ret = g_strdup_printf( + "[%s]\n" "%s=%s\n" "%s=%s\n" "%s=%s\n" "%s", + _("Raspberry Pi or Compatible"), + _("Model"), model, + _("Serial Number"), tmp[0], + _("RCode"), _("No revision code available; unable to lookup model details."), + tmp[8]); + } + free(tmp[0]); free(tmp[1]); + free(tmp[9]); free(tmp[8]); + } + + /* Power Macintosh */ + if (strstr(compat, "PowerBook") != NULL + || strstr(compat, "MacRISC") != NULL + || strstr(compat, "Power Macintosh") != NULL) { + tmp[9] = ppc_mac_details(); + if (tmp[9] != NULL) { + tmp[0] = get_dt_string("/serial-number", 1); + ret = g_strdup_printf( + "%s[%s]\n" "%s=%s\n", tmp[9], + _("More"), + _("Serial Number"), tmp[0] ); + free(tmp[0]); + } + free(tmp[9]); + } + + /* fallback */ + if (ret == NULL) { + tmp[0] = get_dt_string("/serial-number", 1); + EMPIFNULL(tmp[0]); + ret = g_strdup_printf( + "[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n", + _("Board"), + _("Model"), model, + _("Serial Number"), tmp[0], + _("Compatible"), compat); + free(tmp[0]); + } + free(model); + return ret; +} + +void mi_add(const char *key, const char *value) { + gchar *ckey, *rkey; + + ckey = hardinfo_clean_label(key, 0); + rkey = g_strdup_printf("%s:%s", "DTREE", ckey); + + dtree_info = h_strdup_cprintf("$%s$%s=\n", dtree_info, rkey, ckey); + moreinfo_add_with_prefix("DEV", rkey, g_strdup(value)); + + g_free(ckey); + g_free(rkey); +} + +void add_keys(char *np) { + gchar *dir_path, *dt_path; + gchar *ftmp, *ntmp; + gchar *n_info; + const gchar *fn; + GDir *dir; + dtr_obj *obj; + + /* add self */ + obj = dtr_obj_read(dt, np); + dt_path = dtr_obj_path(obj); + n_info = get_node(dt_path); + mi_add(dt_path, n_info); + + dir_path = g_strdup_printf("%s/%s", dtr_base_path(dt), np); + dir = g_dir_open(dir_path, 0 , NULL); + if (dir) { + while((fn = g_dir_read_name(dir)) != NULL) { + ftmp = g_strdup_printf("%s/%s", dir_path, fn); + if ( g_file_test(ftmp, G_FILE_TEST_IS_DIR) ) { + if (strcmp(np, "/") == 0) + ntmp = g_strdup_printf("/%s", fn); + else + ntmp = g_strdup_printf("%s/%s", np, fn); + add_keys(ntmp); + g_free(ntmp); + } + g_free(ftmp); + } + } + g_dir_close(dir); +} + +char *msg_section(int dump) { + gchar *aslbl = NULL; + gchar *messages = dtr_messages(dt); + gchar *ret = g_strdup_printf("[%s]\n", _("Messages")); + gchar **lines = g_strsplit(messages, "\n", 0); + int i = 0; + while(lines[i] != NULL) { + aslbl = hardinfo_clean_label(lines[i], 0); + ret = appf(ret, "%s=\n", aslbl); + g_free(aslbl); + i++; + } + g_strfreev(lines); + if (dump) + printf("%s", messages); + g_free(messages); + return ret; +} + +void __scan_dtree() +{ + dt = dtr_new(NULL); + gchar *summary = get_summary(); + gchar *maps = dtr_maps_info(dt); + gchar *messages = NULL; + + dtree_info = g_strdup("[Device Tree]\n"); + mi_add("Summary", summary); + mi_add("Maps", maps); + + if(dtr_was_found(dt)) + add_keys("/"); + messages = msg_section(0); + mi_add("Messages", messages); + + //printf("%s\n", dtree_info); + + g_free(summary); + g_free(maps); + g_free(messages); + dtr_free(dt); +} diff --git a/modules/devices/devicetree/dt_util.c b/modules/devices/devicetree/dt_util.c new file mode 100644 index 00000000..9678042d --- /dev/null +++ b/modules/devices/devicetree/dt_util.c @@ -0,0 +1,1040 @@ +/* + * HardInfo - Displays System Information + * Copyright (C) 2003-2007 Leandro A. F. Pereira <leandro@hardinfo.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ +/* + * Device Tree support by Burt P. <pburt0@gmail.com> + * Sources: + * http://elinux.org/Device_Tree_Usage + * http://elinux.org/Device_Tree_Mysteries + */ +#include <unistd.h> +#include <sys/types.h> +#include <endian.h> +#include "hardinfo.h" +#include "dt_util.h" + +static struct { + char *name; int type; +} prop_types[] = { + { "name", DTP_STR }, + { "compatible", DTP_STR }, + { "model", DTP_STR }, + { "reg", DTP_REG }, + { "clocks", DTP_CLOCKS }, + { "gpios", DTP_GPIOS }, + { "cs-gpios", DTP_GPIOS }, + { "phandle", DTP_PH }, + { "interrupts", DTP_INTRUPT }, + { "interrupts-extended", DTP_INTRUPT_EX }, + { "interrupt-parent", DTP_PH_REF }, + { "interrupt-controller", DTP_EMPTY }, + { "regulator-min-microvolt", DTP_UINT }, + { "regulator-max-microvolt", DTP_UINT }, + { "clock-frequency", DTP_UINT }, + { "dmas", DTP_DMAS }, + { "dma-channels", DTP_UINT }, + { "dma-requests", DTP_UINT }, + { NULL, 0 }, +}; + +static struct { + char *name; uint32_t v; +} default_values[] = { + { "#address-cells", 2 }, + { "#size-cells", 1 }, + { "#dma-cells", 1 }, + { NULL, 0 }, +}; + +struct _dtr_map { + uint32_t v; /* phandle */ + char *label; /* alias */ + char *path; + struct _dtr_map *next; +}; +typedef struct _dtr_map dtr_map; + +struct _dtr { + dtr_map *aliases; + dtr_map *symbols; + dtr_map *phandles; + char *base_path; + char *log; +}; + +struct _dtr_obj { + char *path; + union { + void *data; + char *data_str; + dt_uint *data_int; + }; + char *name; + uint32_t length; + int type; + char *prefix; /* if the name has a manufacturer's prefix or null */ + char *np_name; /* the name without any prefix. points into .prefix or .name, do not free */ + const char *alias; /* null until first dtr_obj_alias(). do not free */ + const char *symbol; /* null until first dtr_obj_symbol(). do not free */ + dtr *dt; +}; + +dtr_map *dtr_map_add(dtr_map *map, uint32_t v, const char *label, const char *path) { + dtr_map *it; + dtr_map *nmap = malloc(sizeof(dtr_map)); + memset(nmap, 0, sizeof(dtr_map)); + nmap->v = v; + + if (label != NULL) nmap->label = strdup(label); + if (path != NULL) nmap->path = strdup(path); + if (map == NULL) + return nmap; + + it = map; + while(it->next != NULL) + it = it->next; + it->next = nmap; + + return nmap; +} + +void dtr_map_free(dtr_map *map) { + dtr_map *it; + while(map != NULL) { + it = map->next; + free(map->label); + free(map->path); + free(map); + map = it; + } +} + +/* simple sort for maps + * sv: 1 = sort by v, 0 = sort by label */ +void dtr_map_sort(dtr_map *map, int sv) +{ + int done = 0, cmp; + dtr_map *this, *next, *top, *next_top; + uint32_t tmp_v; + char *tmp_l, *tmp_p; + if (map == NULL) return; + do { + this = map; + next_top = NULL; + while(this != NULL) { + next = this->next; + if (this == top) + break; + if (next == NULL) + break; + if (sv) + cmp = (this->v > next->v) ? 1 : 0; + else + cmp = strcmp(this->label, next->label); + if (cmp > 0) { + tmp_v = this->v; this->v = next->v; next->v = tmp_v; + tmp_l = this->label; this->label = next->label; next->label = tmp_l; + tmp_p = this->path; this->path = next->path; next->path = tmp_p; + next_top = this; + } + this = next; + } + if (next_top == NULL) + done = 1; + else + top = next_top; + } while (!done); +} + +const char *dtr_phandle_lookup(dtr *s, uint32_t v) { + dtr_map *phi = s->phandles; + /* 0 and 0xffffffff are invalid phandle values */ + /* TODO: perhaps "INVALID" or something */ + if (v == 0 || v == 0xffffffff) + return NULL; + while(phi != NULL) { + if (phi->v == v) + return phi->path; + phi = phi->next; + } + return NULL; +} + +const char *dtr_alias_lookup(dtr *s, const char* label) { + dtr_map *ali = s->aliases; + while(ali != NULL) { + if (strcmp(ali->label, label) == 0) + return ali->path; + ali = ali->next; + } + return NULL; +} + +const char *dtr_alias_lookup_by_path(dtr *s, const char* path) { + dtr_map *ali = s->aliases; + while(ali != NULL) { + if (strcmp(ali->path, path) == 0) + return ali->label; + ali = ali->next; + } + return NULL; +} + +const char *dtr_symbol_lookup_by_path(dtr *s, const char* path) { + dtr_map *ali = s->symbols; + while(ali != NULL) { + if (strcmp(ali->path, path) == 0) + return ali->label; + ali = ali->next; + } + return NULL; +} + +void _dtr_read_aliases(dtr *); +void _dtr_read_symbols(dtr *); +void _dtr_map_phandles(dtr *, char *np); + +const char *dtr_find_device_tree_root() { + char *candidates[] = { + "/proc/device-tree", + "/sys/firmware/devicetree/base", + /* others? */ + NULL + }; + int i = 0; + while (candidates[i] != NULL) { + if(access(candidates[i], F_OK) != -1) + return candidates[i]; + i++; + } + return NULL; +} + +dtr *dtr_new_x(const char *base_path, int fast) { + dtr *dt = malloc(sizeof(dtr)); + if (dt != NULL) { + memset(dt, 0, sizeof(dtr)); + dt->log = strdup(""); + + if (base_path == NULL) + base_path = DTR_ROOT; + + if (base_path != NULL) + dt->base_path = strdup(base_path); + else { + dtr_msg(dt, "%s", "Device Tree not found."); + return dt; + } + + /* build alias and phandle lists */ + dt->aliases = NULL; + dt->symbols = NULL; + dt->phandles = NULL; + if (!fast) { + _dtr_read_aliases(dt); + _dtr_read_symbols(dt); + _dtr_map_phandles(dt, ""); + } + } + return dt; +} + +dtr *dtr_new(const char *base_path) { + return dtr_new_x(base_path, 0); +} + +void dtr_free(dtr *s) { + if (s != NULL) { + dtr_map_free(s->aliases); + dtr_map_free(s->symbols); + dtr_map_free(s->phandles); + free(s->base_path); + free(s->log); + free(s); + } +} + +int dtr_was_found(dtr *s) { + if (s != NULL) { + if (s->base_path != NULL) + return 1; + } + return 0; +} + +void dtr_msg(dtr *s, char *fmt, ...) { + gchar *buf, *tmp; + va_list args; + + va_start(args, fmt); + buf = g_strdup_vprintf(fmt, args); + va_end(args); + + tmp = g_strdup_printf("%s%s", s->log, buf); + g_free(s->log); + s->log = tmp; +} + +char *dtr_messages(dtr *s) { + if (s != NULL) + return strdup(s->log); + else + return NULL; +} + +const char *dtr_base_path(dtr *s) { + if (s) + return s->base_path; + return NULL; +} + +/*glib, but _dt_obj *prop uses malloc() and std types */ +dtr_obj *dtr_obj_read(dtr *s, const char *dtp) { + char *full_path; + char *slash, *coma; + dtr_obj *obj; + + if (dtp == NULL) + return NULL; + + obj = malloc(sizeof(dtr_obj)); + if (obj != NULL) { + memset(obj, 0, sizeof(dtr_obj)); + + obj->dt = s; + if (*dtp != '/') { + /* doesn't start with slash, use alias */ + obj->path = (char*)dtr_alias_lookup(s, dtp); + if (obj->path != NULL) + obj->path = strdup(obj->path); + else { + dtr_obj_free(obj); + return NULL; + } + } else + obj->path = strdup(dtp); + + /* find name after last slash, or start */ + slash = strrchr(obj->path, '/'); + if (slash != NULL) + obj->name = strdup(slash + 1); + else + obj->name = strdup(obj->path); + + /* find manufacturer prefix */ + obj->prefix = strdup(obj->name); + coma = strchr(obj->prefix, ','); + if (coma != NULL) { + /* coma -> null; .np_name starts after */ + *coma = 0; + obj->np_name = coma + 1; + } else { + obj->np_name = obj->name; + free(obj->prefix); + obj->prefix = NULL; + } + + /* read data */ + full_path = g_strdup_printf("%s%s", s->base_path, obj->path); + if ( g_file_test(full_path, G_FILE_TEST_IS_DIR) ) { + obj->type = DT_NODE; + } else { + if (!g_file_get_contents(full_path, (gchar**)&obj->data, (gsize*)&obj->length, NULL)) { + dtr_obj_free(obj); + g_free(full_path); + return NULL; + } + obj->type = dtr_guess_type(obj); + } + g_free(full_path); + + return obj; + } + return NULL; +} + +void dtr_obj_free(dtr_obj *s) { + if (s != NULL) { + free(s->path); + free(s->name); + free(s->prefix); + free(s->data); + free(s); + } +} + +int dtr_obj_type(dtr_obj *s) { + if (s) + return s->type; + return DT_TYPE_ERR; +} + +char *dtr_obj_alias(dtr_obj *s) { + if (s) { + if (s->alias == NULL) + s->alias = dtr_alias_lookup_by_path(s->dt, s->path); + return (char*)s->alias; + } + return NULL; +} + +char *dtr_obj_symbol(dtr_obj *s) { + if (s) { + if (s->symbol == NULL) + s->symbol = dtr_symbol_lookup_by_path(s->dt, s->path); + return (char*)s->symbol; + } + return NULL; +} + +char *dtr_obj_path(dtr_obj *s) { + if (s) + return s->path; + return NULL; +} + +char *dtr_obj_full_path(dtr_obj *s) { + if (s) { + if (strcmp(s->path, "/") == 0) + return g_strdup_printf("%s", s->dt->base_path); + else + return g_strdup_printf("%s%s", s->dt->base_path, s->path); + } + return NULL; +} + +dtr_obj *dtr_get_prop_obj(dtr *s, dtr_obj *node, const char *name) { + dtr_obj *prop; + char *ptmp; + ptmp = g_strdup_printf("%s/%s", (node == NULL) ? "" : node->path, name); + prop = dtr_obj_read(s, ptmp); + g_free(ptmp); + return prop; +} + +char *dtr_get_prop_str(dtr *s, dtr_obj *node, const char *name) { + dtr_obj *prop; + char *ptmp; + char *ret = NULL; + + ptmp = g_strdup_printf("%s/%s", (node == NULL) ? "" : node->path, name); + prop = dtr_obj_read(s, ptmp); + if (prop != NULL && prop->data != NULL) { + ret = strdup(prop->data_str); + dtr_obj_free(prop); + } + g_free(ptmp); + return ret; +} + +char *dtr_get_string(const char *p, int decode) { + dtr *dt = dtr_new_x(NULL, 1); + dtr_obj *obj; + char *ret = NULL; + if (decode) { + obj = dtr_get_prop_obj(dt, NULL, p); + ret = dtr_str(obj); + dtr_obj_free(obj); + } else + ret = dtr_get_prop_str(dt, NULL, p); + dtr_free(dt); + return ret; +} + +uint32_t dtr_get_prop_u32(dtr *s, dtr_obj *node, const char *name) { + dtr_obj *prop; + char *ptmp; + uint32_t ret = 0; + + ptmp = g_strdup_printf("%s/%s", (node == NULL) ? "" : node->path, name); + prop = dtr_obj_read(s, ptmp); + if (prop != NULL && prop->data != NULL) { + ret = be32toh(*prop->data_int); + dtr_obj_free(prop); + } + g_free(ptmp); + return ret; +} + +int dtr_guess_type(dtr_obj *obj) { + char *tmp, *dash; + int i = 0, anc = 0, might_be_str = 1; + + if (obj->length == 0) + return DTP_EMPTY; + + /* special #(.*)-cells names are UINT */ + if (*obj->name == '#') { + dash = strrchr(obj->name, '-'); + if (dash != NULL) { + if (strcmp(dash, "-cells") == 0) + return DTP_UINT; + } + } + + /* /aliases/* and /__symbols__/* are always strings */ + if (strncmp(obj->path, "/aliases/", strlen("/aliases/") ) == 0) + return DTP_STR; + if (strncmp(obj->path, "/__symbols__/", strlen("/__symbols__/") ) == 0) + return DTP_STR; + + /* /__overrides__/* */ + if (strncmp(obj->path, "/__overrides__/", strlen("/__overrides__/") ) == 0) + if (strcmp(obj->name, "name") != 0) + return DTP_OVR; + + /* lookup known type */ + while (prop_types[i].name != NULL) { + if (strcmp(obj->name, prop_types[i].name) == 0) + return prop_types[i].type; + i++; + } + + /* maybe a string? */ + for (i = 0; i < obj->length; i++) { + tmp = obj->data_str + i; + if ( isalnum(*tmp) ) anc++; /* count the alpha-nums */ + if ( isprint(*tmp) || *tmp == 0 ) + continue; + might_be_str = 0; + break; + } + if (might_be_str && + ( anc >= obj->length - 2 /* all alpha-nums but ^/ and \0$ */ + || anc >= 5 ) /*arbitrary*/) + return DTP_STR; + + /* multiple of 4 bytes, try list of hex values */ + if (!(obj->length % 4)) + return DTP_HEX; + + return DTP_UNK; +} + +char *dtr_elem_phref(dtr *s, dt_uint e, int show_path) { + const char *ph_path, *al_label; + char *ret = NULL; + ph_path = dtr_phandle_lookup(s, be32toh(e)); + if (ph_path != NULL) { + /* TODO: alias or symbol? */ + al_label = dtr_symbol_lookup_by_path(s, ph_path); + if (al_label != NULL) { + if (show_path) + ret = g_strdup_printf("&%s (%s)", al_label, ph_path); + else + ret = g_strdup_printf("&%s", al_label); + } else { + if (show_path) + ret = g_strdup_printf("0x%x (%s)", be32toh(e), ph_path); + } + } + if (ret == NULL) + ret = dtr_elem_hex(e); + return ret; +} + +char *dtr_elem_hex(dt_uint e) { + return g_strdup_printf("0x%x", be32toh(e) ); +} + +char *dtr_elem_byte(uint8_t e) { + return g_strdup_printf("%x", e); +} + +char *dtr_elem_uint(dt_uint e) { + return g_strdup_printf("%u", be32toh(e) ); +} + +char *dtr_list_byte(uint8_t *bytes, unsigned long count) { + char *ret, *dest; + char buff[4] = ""; /* max element: " 00\0" */ + uint32_t v; + unsigned long i, l; + l = count * 4 + 1; + ret = malloc(l); + memset(ret, 0, l); + strcpy(ret, "["); + dest = ret + 1; + for (i = 0; i < count; i++) { + v = bytes[i]; + sprintf(buff, "%s%02x", (i) ? " " : "", v); + l = strlen(buff); + strncpy(dest, buff, l); + dest += l; + } + strcpy(dest, "]"); + return ret; +} + +char *dtr_list_hex(dt_uint *list, unsigned long count) { + char *ret, *dest; + char buff[12] = ""; /* max element: " 0x00000000\0" */ + unsigned long i, l; + l = count * 12 + 1; + dest = ret = malloc(l); + memset(ret, 0, l); + for (i = 0; i < count; i++) { + sprintf(buff, "%s0x%x", (i) ? " " : "", be32toh(list[i])); + l = strlen(buff); + strncpy(dest, buff, l); + dest += l; + } + return ret; +} + +/*cstd, except for g_strescape()*/ +char *dtr_list_str0(const char *data, uint32_t length) { + char *tmp, *esc, *next_str; + char ret[1024] = ""; + uint32_t l, tl; + + /* treat as null-separated string list */ + tl = 0; + strcpy(ret, ""); + tmp = ret; + next_str = (char*)data; + while(next_str != NULL) { + l = strlen(next_str); + esc = g_strescape(next_str, NULL); + sprintf(tmp, "%s\"%s\"", + strlen(ret) ? ", " : "", esc); + free(esc); + tmp += strlen(tmp); + tl += l + 1; next_str += l + 1; + if (tl >= length) break; + } + + return strdup(ret); +} + +char *dtr_list_override(dtr_obj *obj) { + /* <phref, string "property:value"> ... */ + char *ret = NULL; + char *ph, *str; + char *src; + int l, consumed = 0; + src = obj->data_str; + while (consumed + 5 <= obj->length) { + ph = dtr_elem_phref(obj->dt, *(dt_uint*)src, 1); + src += 4; consumed += 4; + l = strlen(src) + 1; /* consume the null */ + str = dtr_list_str0(src, l); + ret = appf(ret, "<%s -> %s>", ph, str); + src += l; consumed += l; + free(ph); + free(str); + } + if (consumed < obj->length) { + str = dtr_list_byte(src, obj->length - consumed); + ret = appf(ret, "%s", str); + free(str); + } + return ret; +} + +uint32_t dtr_get_phref_prop(dtr *s, uint32_t phandle, char *prop) { + const char *ph_path; + char *tmp; + uint32_t ret; + ph_path = dtr_phandle_lookup(s, phandle); + tmp = g_strdup_printf("%s/%s", ph_path, prop); + ret = dtr_get_prop_u32(s, NULL, tmp); + free(tmp); + return ret; +} + +char *dtr_list_phref(dtr_obj *obj, char *ext_cell_prop) { + /* <phref, #XXX-cells> */ + int count = obj->length / 4; + int i = 0, ext_cells = 0; + char *ph_path; + char *ph, *ext, *ret = NULL; + while (i < count) { + if (ext_cell_prop == NULL) + ext_cells = 0; + else + ext_cells = dtr_get_phref_prop(obj->dt, be32toh(obj->data_int[i]), ext_cell_prop); + ph = dtr_elem_phref(obj->dt, obj->data_int[i], 0); i++; + if (ext_cells > count - i) ext_cells = count - i; + ext = dtr_list_hex((obj->data_int + i), ext_cells); i+=ext_cells; + ret = appf(ret, "<%s%s%s>", + ph, (ext_cells) ? " " : "", ext); + g_free(ph); + g_free(ext); + } + return ret; +} + +char *dtr_list_interrupts(dtr_obj *obj) { + char *ext, *ret = NULL; + uint32_t iparent, icells; + int count, i = 0; + + iparent = dtr_inh_find(obj, "interrupt-parent", 0); + if (!iparent) { + dtr_msg(obj->dt, "Did not find an interrupt-parent for %s", obj->path); + goto intr_err; + } + icells = dtr_get_phref_prop(obj->dt, iparent, "#interrupt-cells"); + if (!icells) { + dtr_msg(obj->dt, "Invalid #interrupt-cells value %d for %s", icells, obj->path); + goto intr_err; + } + + count = obj->length / 4; + while (i < count) { + icells = MIN(icells, count - i); + ext = dtr_list_hex((obj->data_int + i), icells); i+=icells; + ret = appf(ret, "<%s>", ext); + } + return ret; + +intr_err: + return dtr_list_hex(obj->data_int, obj->length); + +} + +char *dtr_list_reg(dtr_obj *obj) { + char *tup_str, *ret = NULL; + uint32_t acells, scells, tup_len; + uint32_t tups, extra, consumed; /* extra and consumed are bytes */ + uint32_t *next; + + acells = dtr_inh_find(obj, "#address-cells", 2); + scells = dtr_inh_find(obj, "#size-cells", 2); + tup_len = acells + scells; + tups = obj->length / (tup_len * 4); + extra = obj->length % (tup_len * 4); + consumed = 0; /* bytes */ + + //printf("list reg: %s\n ... acells: %u, scells: %u, extra: %u\n", obj->path, acells, scells, extra); + + if (extra) { + /* error: length is not a multiple of tuples */ + dtr_msg(obj->dt, "Data length (%u) is not a multiple of (#address-cells:%u + #size-cells:%u) for %s\n", + obj->length, acells, scells, obj->path); + return dtr_list_hex(obj->data, obj->length / 4); + } + + next = obj->data_int; + consumed = 0; + while (consumed + (tup_len * 4) <= obj->length) { + tup_str = dtr_list_hex(next, tup_len); + ret = appf(ret, "<%s>", tup_str); + free(tup_str); + consumed += (tup_len * 4); + next += tup_len; + } + + //printf(" ... %s\n", ret); + return ret; +} + +char* dtr_str(dtr_obj *obj) { + char *ret; + int type; + + if (obj == NULL) return NULL; + type = obj->type; + + if (type == DTP_PH_REF) { + if (!DTEX_PHREFS || obj->length != 4) + type = DTP_HEX; + } + + switch(type) { + case DT_NODE: + ret = strdup("{node}"); + break; + case DTP_EMPTY: + ret = strdup("{empty}"); + break; + case DTP_STR: + ret = dtr_list_str0(obj->data_str, obj->length); + break; + case DTP_OVR: + ret = dtr_list_override(obj); + break; + case DTP_REG: + /* <#address-cells #size-cells> */ + ret = dtr_list_reg(obj); + break; + case DTP_INTRUPT: + ret = dtr_list_interrupts(obj); + break; + case DTP_INTRUPT_EX: + /* <phref, #interrupt-cells"> */ + ret = dtr_list_phref(obj, "#interrupt-cells"); + break; + case DTP_CLOCKS: + /* <phref, #clock-cells"> */ + ret = dtr_list_phref(obj, "#clock-cells"); + break; + case DTP_GPIOS: + /* <phref, #gpio-cells"> */ + ret = dtr_list_phref(obj, "#gpio-cells"); + break; + case DTP_DMAS: + /* <phref, #dma-cells"> */ + ret = dtr_list_phref(obj, "#dma-cells"); + break; + case DTP_PH: + case DTP_HEX: + if (obj->length % 4) + ret = dtr_list_byte((uint8_t*)obj->data, obj->length); + else + ret = dtr_list_hex(obj->data, obj->length / 4); + break; + case DTP_PH_REF: + ret = dtr_elem_phref(obj->dt, *obj->data_int, 1); + break; + case DTP_UINT: + ret = dtr_elem_uint(*obj->data_int); + break; + case DTP_UNK: + default: + if (obj->length > 64) /* maybe should use #define at the top */ + ret = g_strdup_printf(ret, "{data} (%lu bytes)", obj->length); + else + ret = dtr_list_byte((uint8_t*)obj->data, obj->length); + break; + } + + return ret; +} + +dtr_obj *dtr_get_parent_obj(dtr_obj *obj) { + char *slash, *parent; + dtr_obj *ret = NULL; + + if (obj == NULL) + return NULL; + + parent = strdup(obj->path); + slash = strrchr(parent, '/'); + if (slash != NULL) { + *slash = 0; + if (strlen(parent) > 0) + ret = dtr_obj_read(obj->dt, parent); + else + ret = dtr_obj_read(obj->dt, "/"); + } + free(parent); + return ret; +} + +/* find the value of a path-inherited property by climbing the path */ +int dtr_inh_find(dtr_obj *obj, char *qprop, int limit) { + dtr_obj *tobj, *pobj, *qobj; + uint32_t ret = 0; + int i, found = 0; + + if (!limit) limit = 1000; + + tobj = obj; + while (tobj != NULL) { + pobj = dtr_get_parent_obj(tobj); + if (tobj != obj) + dtr_obj_free(tobj); + if (!limit || pobj == NULL) break; + qobj = dtr_get_prop_obj(obj->dt, pobj, qprop); + if (qobj != NULL) { + ret = be32toh(*qobj->data_int); + found = 1; + dtr_obj_free(qobj); + break; + } + tobj = pobj; + limit--; + } + dtr_obj_free(pobj); + + if (!found) { + i = 0; + while(default_values[i].name != NULL) { + if (strcmp(default_values[i].name, qprop) == 0) { + ret = default_values[i].v; + dtr_msg(obj->dt, "Using default value %d for %s in %s\n", ret, qprop, obj->path); + break; + } + i++; + } + } + + return ret; +} + +void _dtr_read_aliases(dtr *s) { + gchar *dir_path; + GDir *dir; + const gchar *fn; + dtr_obj *anode, *prop; + dtr_map *al; + anode = dtr_obj_read(s, "/aliases"); + + dir_path = g_strdup_printf("%s/aliases", s->base_path); + dir = g_dir_open(dir_path, 0 , NULL); + if (dir) { + while((fn = g_dir_read_name(dir)) != NULL) { + prop = dtr_get_prop_obj(s, anode, fn); + if (prop->type == DTP_STR) { + if (*prop->data_str == '/') { + al = dtr_map_add(s->aliases, 0, prop->name, prop->data_str); + if (s->aliases == NULL) + s->aliases = al; + } + } + dtr_obj_free(prop); + } + } + g_dir_close(dir); + g_free(dir_path); + dtr_obj_free(anode); + dtr_map_sort(s->aliases, 0); +} + +void _dtr_read_symbols(dtr *s) { + gchar *dir_path; + GDir *dir; + const gchar *fn; + dtr_obj *anode, *prop; + dtr_map *al; + anode = dtr_obj_read(s, "/__symbols__"); + + dir_path = g_strdup_printf("%s/__symbols__", s->base_path); + dir = g_dir_open(dir_path, 0 , NULL); + if (dir) { + while((fn = g_dir_read_name(dir)) != NULL) { + prop = dtr_get_prop_obj(s, anode, fn); + if (prop->type == DTP_STR) { + if (*prop->data_str == '/') { + al = dtr_map_add(s->symbols, 0, prop->name, prop->data_str); + if (s->symbols == NULL) + s->symbols = al; + } + } + dtr_obj_free(prop); + } + } + g_dir_close(dir); + g_free(dir_path); + dtr_obj_free(anode); + dtr_map_sort(s->symbols, 0); +} + +/* TODO: rewrite */ +void _dtr_map_phandles(dtr *s, char *np) { + gchar *dir_path; + gchar *ftmp, *ntmp, *ptmp; + const gchar *fn; + GDir *dir; + dtr_obj *prop, *ph_prop; + dtr_map *ph; + uint32_t phandle; + + if (np == NULL) np = ""; + dir_path = g_strdup_printf("%s/%s", s->base_path, np); + + prop = dtr_obj_read(s, np); + dir = g_dir_open(dir_path, 0 , NULL); + if (dir) { + while((fn = g_dir_read_name(dir)) != NULL) { + ftmp = g_strdup_printf("%s/%s", dir_path, fn); + if ( g_file_test(ftmp, G_FILE_TEST_IS_DIR) ) { + ntmp = g_strdup_printf("%s/%s", np, fn); + ptmp = g_strdup_printf("%s/phandle", ntmp); + ph_prop = dtr_obj_read(s, ptmp); + if (ph_prop != NULL) { + ph = dtr_map_add(s->phandles, be32toh(*ph_prop->data_int), NULL, ntmp); + if (s->phandles == NULL) + s->phandles = ph; + } + _dtr_map_phandles(s, ntmp); + g_free(ptmp); + g_free(ntmp); + dtr_obj_free(ph_prop); + } + g_free(ftmp); + } + } + g_dir_close(dir); + dtr_obj_free(prop); + dtr_map_sort(s->phandles, 1); +} + +/* + * Maybe these should move to devicetree.c, but would have to expose + * struct internals. + */ + +/* kvl: 0 = key is label, 1 = key is v */ +char *dtr_map_info_section(dtr *s, dtr_map *map, char *title, int kvl) { + gchar *tmp, *ret; + const gchar *sym; + ret = g_strdup_printf("[%s]\n", _(title)); + dtr_map *it = map; + while(it != NULL) { + if (kvl) { + sym = dtr_symbol_lookup_by_path(s, it->path); + if (sym != NULL) + tmp = g_strdup_printf("%s0x%x (%s)=%s\n", ret, + it->v, sym, it->path); + else + tmp = g_strdup_printf("%s0x%x=%s\n", ret, + it->v, it->path); + } else + tmp = g_strdup_printf("%s%s=%s\n", ret, + it->label, it->path); + g_free(ret); + ret = tmp; + it = it->next; + } + + return ret; +} + +char *dtr_maps_info(dtr *s) { + gchar *ph_map, *al_map, *sy_map, *ret; + + ph_map = dtr_map_info_section(s, s->phandles, _("phandle Map"), 1); + al_map = dtr_map_info_section(s, s->aliases, _("Alias Map"), 0); + sy_map = dtr_map_info_section(s, s->symbols, _("Symbol Map"), 0); + ret = g_strdup_printf("%s%s%s", ph_map, sy_map, al_map); + g_free(ph_map); + g_free(al_map); + g_free(sy_map); + return ret; +} + +char *appf(char *src, char *fmt, ...) { + gchar *buf, *ret; + va_list args; + + va_start(args, fmt); + buf = g_strdup_vprintf(fmt, args); + va_end(args); + + if (src != NULL) { + ret = g_strdup_printf("%s%s%s", src, sp_sep(src), buf); + g_free(buf); + g_free(src); + } else + ret = buf; + + return ret; +} + diff --git a/modules/devices/devicetree/pmac_data.c b/modules/devices/devicetree/pmac_data.c new file mode 100644 index 00000000..b236aef1 --- /dev/null +++ b/modules/devices/devicetree/pmac_data.c @@ -0,0 +1,98 @@ +/* + * HardInfo - Displays System Information + * Copyright (C) 2003-2007 Leandro A. F. Pereira <leandro@hardinfo.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "cpu_util.h" /* for PROC_CPUINFO */ + +static gchar *ppc_mac_details(void) { + int i = 0; + gchar *ret = NULL; + gchar *platform = NULL; + gchar *model = NULL; + gchar *machine = NULL; + gchar *motherboard = NULL; + gchar *detected_as = NULL; + gchar *pmac_flags = NULL; + gchar *l2_cache = NULL; + gchar *pmac_gen = NULL; + + FILE *cpuinfo; + gchar buffer[128]; + + cpuinfo = fopen(PROC_CPUINFO, "r"); + if (!cpuinfo) + return NULL; + while (fgets(buffer, 128, cpuinfo)) { + gchar **tmp = g_strsplit(buffer, ":", 2); + if (tmp[1] == NULL) { + g_strfreev(tmp); + continue; + } + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); + get_str("platform", platform); + get_str("model", model); + get_str("machine", machine); + get_str("motherboard", motherboard); + get_str("detected as", detected_as); + get_str("pmac flags", pmac_flags); + get_str("L2 cache", l2_cache); + get_str("pmac-generation", pmac_gen); + } + fclose(cpuinfo); + + if (machine == NULL) + goto pmd_exit; + + UNKIFNULL(platform); + UNKIFNULL(model); + UNKIFNULL(motherboard); + UNKIFNULL(detected_as); + UNKIFNULL(pmac_flags); + UNKIFNULL(l2_cache); + UNKIFNULL(pmac_gen); + + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n", + _("Apple Power Macintosh"), + _("Platform"), platform, + _("Model"), model, + _("Machine"), machine, + _("Motherboard"), motherboard, + _("Detected as"), detected_as, + _("PMAC Flags"), pmac_flags, + _("L2 Cache"), l2_cache, + _("PMAC Generation"), pmac_gen ); + +pmd_exit: + g_free(platform); + g_free(model); + g_free(machine); + g_free(motherboard); + g_free(detected_as); + g_free(pmac_flags); + g_free(l2_cache); + g_free(pmac_gen); + return ret; +} diff --git a/modules/devices/devicetree/rpi_data.c b/modules/devices/devicetree/rpi_data.c new file mode 100644 index 00000000..d0132e3a --- /dev/null +++ b/modules/devices/devicetree/rpi_data.c @@ -0,0 +1,166 @@ +/* + * HardInfo - Displays System Information + * Copyright (C) 2003-2007 Leandro A. F. Pereira <leandro@hardinfo.org> + * This file from: rpiz - https://github.com/bp0/rpiz + * Copyright (C) 2017 Burt P. <pburt0@gmail.com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +static char unk[] = "(Unknown)"; + +/* information table from: http://elinux.org/RPi_HardwareHistory */ +static struct { + char *value, *intro, *model, *pcb, *mem, *mfg, *soc; +} rpi_boardinfo[] = { +/* Value Introduction Model Name PCB rev. Memory(spec) Manufacturer SOC(spec) * + * Raspberry Pi %s */ + { unk, unk, unk, unk, unk, unk, NULL }, + { "Beta", "Q1 2012", "B (Beta)", unk, "256MB", "(Beta board)", NULL }, + { "0002", "Q1 2012", "B", "1.0", "256MB", unk, "BCM2835" }, + { "0003", "Q3 2012", "B (ECN0001)", "1.0", "256MB", "(Fuses mod and D14 removed)", NULL }, + { "0004", "Q3 2012", "B", "2.0", "256MB", "Sony", NULL }, + { "0005", "Q4 2012", "B", "2.0", "256MB", "Qisda", NULL }, + { "0006", "Q4 2012", "B", "2.0", "256MB", "Egoman", NULL }, + { "0007", "Q1 2013", "A", "2.0", "256MB", "Egoman", NULL }, + { "0008", "Q1 2013", "A", "2.0", "256MB", "Sony", NULL }, + { "0009", "Q1 2013", "A", "2.0", "256MB", "Qisda", NULL }, + { "000d", "Q4 2012", "B", "2.0", "512MB", "Egoman", NULL }, + { "000e", "Q4 2012", "B", "2.0", "512MB", "Sony", NULL }, + { "000f", "Q4 2012", "B", "2.0", "512MB", "Qisda", NULL }, + { "0010", "Q3 2014", "B+", "1.0", "512MB", "Sony", NULL }, + { "0011", "Q2 2014", "Compute Module 1", "1.0", "512MB", "Sony", NULL }, + { "0012", "Q4 2014", "A+", "1.1", "256MB", "Sony", NULL }, + { "0013", "Q1 2015", "B+", "1.2", "512MB", unk, NULL }, + { "0014", "Q2 2014", "Compute Module 1", "1.0", "512MB", "Embest", NULL }, + { "0015", unk, "A+", "1.1", "256MB/512MB", "Embest", NULL }, + { "a01040", unk, "2 Model B", "1.0", "1GB", "Sony", "BCM2836" }, + { "a01041", "Q1 2015", "2 Model B", "1.1", "1GB", "Sony", "BCM2836" }, + { "a21041", "Q1 2015", "2 Model B", "1.1", "1GB", "Embest", "BCM2836" }, + { "a22042", "Q3 2016", "2 Model B", "1.2", "1GB", "Embest", "BCM2837" }, /* (with BCM2837) */ + { "900021", "Q3 2016", "A+", "1.1", "512MB", "Sony", NULL }, + { "900032", "Q2 2016?", "B+", "1.2", "512MB", "Sony", NULL }, + { "900092", "Q4 2015", "Zero", "1.2", "512MB", "Sony", NULL }, + { "900093", "Q2 2016", "Zero", "1.3", "512MB", "Sony", NULL }, + { "920093", "Q4 2016?", "Zero", "1.3", "512MB", "Embest", NULL }, + { "9000c1", "Q1 2017", "Zero W", "1.1", "512MB", "Sony", NULL }, + { "a02082", "Q1 2016", "3 Model B", "1.2", "1GB", "Sony", "BCM2837" }, + { "a020a0", "Q1 2017", "Compute Module 3 or CM3 Lite", "1.0", "1GB", "Sony", NULL }, + { "a22082", "Q1 2016", "3 Model B", "1.2", "1GB", "Embest", "BCM2837" }, + { "a32082", "Q4 2016", "3 Model B", "1.2", "1GB", "Sony Japan", NULL }, + { NULL, NULL, NULL, NULL, NULL, NULL, NULL } +}; + + +/* return number of chars to skip */ +static int rpi_ov_check(const char *r_code) { + /* sources differ. prefix is either 1000... or just 1... */ + //if (strncmp(r, "1000", 4) == 0) + // return 4; + if (strncmp(r_code, "1", 1) == 0) + return 1; + return 0; +} + +static int rpi_code_match(const char* code0, const char* code1) { + int c0, c1; + if (code0 == NULL || code1 == NULL) return 0; + c0 = strtol(code0, NULL, 16); + c1 = strtol(code1, NULL, 16); + if (c0 && c1) + return (c0 == c1) ? 1 : 0; + else + return (strcmp(code0, code1) == 0) ? 1 : 0; +} + +static int rpi_find_board(const char *r_code) { + int i = 0; + char *r = (char*)r_code; + if (r_code == NULL) + return 0; + /* ignore the overvolt prefix */ + r += rpi_ov_check(r_code); + while (rpi_boardinfo[i].value != NULL) { + if (rpi_code_match(r, rpi_boardinfo[i].value)) + return i; + + i++; + } + return 0; +} + +/* ------------------------- */ + +#include "cpu_util.h" /* for PROC_CPUINFO */ + +static gchar *rpi_board_details(void) { + int i = 0; + gchar *ret = NULL; + gchar *soc = NULL; + gchar *serial = NULL; + gchar *revision = NULL; + int ov = 0; + FILE *cpuinfo; + gchar buffer[128]; + + cpuinfo = fopen(PROC_CPUINFO, "r"); + if (!cpuinfo) + return NULL; + while (fgets(buffer, 128, cpuinfo)) { + gchar **tmp = g_strsplit(buffer, ":", 2); + if (tmp[1] == NULL) { + g_strfreev(tmp); + continue; + } + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); + get_str("Revision", revision); + get_str("Hardware", soc); + get_str("Serial", serial); + } + fclose(cpuinfo); + + if (revision == NULL || soc == NULL) { + g_free(soc); + g_free(revision); + return NULL; + } + + ov = rpi_ov_check(revision); + i = rpi_find_board(revision); + ret = g_strdup_printf("[%s]\n" + "%s=%s %s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n", + _("Raspberry Pi"), + _("Board Name"), _("Raspberry Pi"), rpi_boardinfo[i].model, + _("PCB Revision"), rpi_boardinfo[i].pcb, + _("Introduction"), rpi_boardinfo[i].intro, + _("Manufacturer"), rpi_boardinfo[i].mfg, + _("RCode"), rpi_boardinfo[i].value, + _("SOC (spec)"), rpi_boardinfo[i].soc, + _("Memory (spec)"), rpi_boardinfo[i].mem, + _("Serial Number"), serial, + _("Permanent overvolt bit"), (ov) ? C_("rpi-ov-bit", "Set") : C_("rpi-ov-bit", "Not set") ); + + g_free(soc); + g_free(revision); + return ret; +} diff --git a/modules/devices/devmemory.c b/modules/devices/devmemory.c index 7131536c..080e2bbe 100644 --- a/modules/devices/devmemory.c +++ b/modules/devices/devmemory.c @@ -23,10 +23,10 @@ GHashTable *memlabels = NULL; void scan_memory_do(void) { - gchar **keys, *tmp; + gchar **keys, *tmp, *tmp_label; static gint offset = -1; gint i; - + if (offset == -1) { /* gah. linux 2.4 adds three lines of data we don't need in /proc/meminfo */ @@ -38,38 +38,42 @@ void scan_memory_do(void) offset = 0; } } - + g_file_get_contents("/proc/meminfo", &meminfo, NULL, NULL); - + keys = g_strsplit(meminfo, "\n", 0); g_free(meminfo); g_free(lginterval); - + meminfo = g_strdup(""); lginterval = g_strdup(""); - + for (i = offset; keys[i]; i++) { gchar **newkeys = g_strsplit(keys[i], ":", 0); - + if (!newkeys[0]) { g_strfreev(newkeys); break; } - + + g_strstrip(newkeys[0]); g_strstrip(newkeys[1]); - - if ((tmp = g_hash_table_lookup(memlabels, newkeys[0]))) { - g_free(newkeys[0]); - newkeys[0] = g_strdup(tmp); - } - + + /* try to find a localizable label */ + tmp = g_hash_table_lookup(memlabels, newkeys[0]); + if (tmp) + tmp_label = _(tmp); + else + tmp_label = ""; /* or newkeys[0] */ + /* although it doesn't matter... */ + moreinfo_add_with_prefix("DEV", newkeys[0], g_strdup(newkeys[1])); - tmp = g_strconcat(meminfo, newkeys[0], "=", newkeys[1], "\n", NULL); + tmp = g_strconcat(meminfo, newkeys[0], "=", newkeys[1], "|", tmp_label, "\n", NULL); g_free(meminfo); meminfo = tmp; - + tmp = g_strconcat(lginterval, "UpdateInterval$", newkeys[0], "=1000\n", NULL); g_free(lginterval); @@ -86,21 +90,21 @@ void init_memory_labels(void) char *proc_label; char *real_label; } proc2real[] = { - { "MemTotal", N_("Total Memory") }, - { "MemFree", N_("Free Memory") }, - { "SwapCached", N_("Cached Swap") }, - { "HighTotal", N_("High Memory") }, - { "HighFree", N_("Free High Memory") }, - { "LowTotal", N_("Low Memory") }, - { "LowFree", N_("Free Low Memory") }, - { "SwapTotal", N_("Virtual Memory") }, - { "SwapFree", N_("Free Virtual Memory") }, + { "MemTotal", N_("Total Memory") }, + { "MemFree", N_("Free Memory") }, + { "SwapCached", N_("Cached Swap") }, + { "HighTotal", N_("High Memory") }, + { "HighFree", N_("Free High Memory") }, + { "LowTotal", N_("Low Memory") }, + { "LowFree", N_("Free Low Memory") }, + { "SwapTotal", N_("Virtual Memory") }, + { "SwapFree", N_("Free Virtual Memory") }, { NULL }, }; gint i; memlabels = g_hash_table_new(g_str_hash, g_str_equal); - + for (i = 0; proc2real[i].proc_label; i++) { g_hash_table_insert(memlabels, proc2real[i].proc_label, _(proc2real[i].real_label)); diff --git a/modules/devices/dmi.c b/modules/devices/dmi.c index 61cea65d..5f87df13 100644 --- a/modules/devices/dmi.c +++ b/modules/devices/dmi.c @@ -22,7 +22,7 @@ #include <sys/types.h> #include "devices.h" - + typedef struct _DMIInfo DMIInfo; struct _DMIInfo { @@ -35,10 +35,14 @@ DMIInfo dmi_info_table[] = { { "$BIOS", NULL, NULL }, { "Date", "/sys/class/dmi/id/bios_date", "bios-release-date" }, { "Vendor", "/sys/class/dmi/id/bios_vendor", "bios-vendor" }, - { "Version", "/sys/class/dmi/id/bios_version", "bios-version" }, + { "Version#0", "/sys/class/dmi/id/bios_version", "bios-version" }, { "$Board", NULL, NULL }, { "Name", "/sys/class/dmi/id/board_name", "baseboard-product-name" }, { "Vendor", "/sys/class/dmi/id/board_vendor", "baseboard-manufacturer" }, + { "$Product", NULL, NULL }, + { "Name", "/sys/class/dmi/id/product_name", "system-product-name" }, + { "Family", "/sys/class/dmi/id/product_family", "system-product-family" }, + { "Version#1", "/sys/class/dmi/id/product_version", "system-product-version" }, }; gchar *dmi_info = NULL; @@ -62,16 +66,16 @@ gboolean dmi_get_info_dmidecode() g_free(dmi_info); dmi_info = NULL; } - + for (i = 0; i < G_N_ELEMENTS(dmi_info_table); i++) { info = &dmi_info_table[i]; - + if (*(info->name) == '$') { group = info->name + 1; dmi_info = h_strdup_cprintf("[%s]\n", dmi_info, group); } else { gchar *temp; - + if (!info->param) continue; @@ -84,7 +88,7 @@ gboolean dmi_get_info_dmidecode() dmi_failed = TRUE; break; } - + add_to_moreinfo(group, info->name, buffer); const gchar *url = vendor_get_url(buffer); @@ -115,14 +119,14 @@ gboolean dmi_get_info_dmidecode() dmi_failed = TRUE; break; } - } + } } - + if (dmi_failed) { g_free(dmi_info); dmi_info = NULL; } - + return !dmi_failed; } @@ -132,17 +136,17 @@ gboolean dmi_get_info_sys() gchar buffer[256]; const gchar *group = NULL; DMIInfo *info; - gboolean dmi_failed = FALSE; + gboolean dmi_succeeded = FALSE; gint i; - + if (dmi_info) { g_free(dmi_info); dmi_info = NULL; } - + for (i = 0; i < G_N_ELEMENTS(dmi_info_table); i++) { info = &dmi_info_table[i]; - + if (*(info->name) == '$') { group = info->name + 1; dmi_info = h_strdup_cprintf("[%s]\n", dmi_info, group); @@ -152,7 +156,7 @@ gboolean dmi_get_info_sys() fclose(dmi_file); add_to_moreinfo(group, info->name, buffer); - + const gchar *url = vendor_get_url(buffer); if (url) { const gchar *vendor = vendor_get_name(buffer); @@ -176,31 +180,34 @@ gboolean dmi_get_info_sys() info->name, g_strstrip(buffer)); } + dmi_succeeded = TRUE; } else { - dmi_failed = TRUE; - break; + dmi_info = h_strdup_cprintf("%s=%s\n", + dmi_info, + info->name, + _("(Not available; Perhaps try running HardInfo as root.)") ); } - } + } } - - if (dmi_failed) { + + if (!dmi_succeeded) { g_free(dmi_info); dmi_info = NULL; } - - return !dmi_failed; + + return dmi_succeeded; } void __scan_dmi() { gboolean dmi_ok; - + dmi_ok = dmi_get_info_sys(); - + if (!dmi_ok) { dmi_ok = dmi_get_info_dmidecode(); } - + if (!dmi_ok) { dmi_info = g_strdup("[No DMI information]\n" "There was an error retrieving the information.=\n" diff --git a/modules/devices/ia64/processor.c b/modules/devices/ia64/processor.c index 55e5e3a8..c4d06a71 100644 --- a/modules/devices/ia64/processor.c +++ b/modules/devices/ia64/processor.c @@ -18,61 +18,198 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" GSList * processor_scan(void) { - Processor *processor; + GSList *procs = NULL; + Processor *processor = NULL; FILE *cpuinfo; gchar buffer[128]; + gchar *rep_pname = NULL; + GSList *pi = NULL; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) - return NULL; + return NULL; - processor = g_new0(Processor, 1); +#define CHECK_FOR(k) (g_str_has_prefix(tmp[0], k)) while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); + gchar **tmp = g_strsplit(buffer, ":", 2); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); + } else { + g_strfreev(tmp); + continue; + } + + get_str("Processor", rep_pname); + + if ( CHECK_FOR("processor") ) { + /* finish previous */ + if (processor) { + procs = g_slist_append(procs, processor); + } + + /* start next */ + processor = g_new0(Processor, 1); + processor->id = atol(tmp[1]); + + if (rep_pname) + processor->model_name = g_strdup(rep_pname); - if (tmp[0] && tmp[1]) { - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); + g_strfreev(tmp); + continue; + } - get_str("vendor", processor->model_name); - get_str("arch", processor->vendor_id); - get_str("family", processor->strmodel); - get_float("BogoMIPS", processor->bogomips); + if (!processor && + ( CHECK_FOR("vendor") + || CHECK_FOR("arch") + || CHECK_FOR("family") ) ) { - } - g_strfreev(tmp); + /* single proc/core may not have "processor : n" */ + processor = g_new0(Processor, 1); + processor->id = 0; + + if (rep_pname) + processor->model_name = g_strdup(rep_pname); + } + + if (processor) { + get_str("vendor", processor->vendor_id); + get_str("archrev", processor->archrev); + get_str("arch", processor->arch); + get_str("family", processor->family); + get_str("features", processor->features); + get_int("model", processor->model); + get_int("revision", processor->revision); + get_float("BogoMIPS", processor->bogomips); + get_float("cpu MHz", processor->cpu_mhz); + get_int("cpu regs", processor->cpu_regs); + } + g_strfreev(tmp); } - processor->cpu_mhz = 0.0f; - + if (processor) + procs = g_slist_append(procs, processor); + + g_free(rep_pname); fclose(cpuinfo); - return g_slist_append(NULL, processor); + /* TODO: redup */ + + /* data not from /proc/cpuinfo */ + for (pi = procs; pi; pi = pi->next) { + processor = (Processor *) pi->data; + + /* strings can't be null or segfault later */ + STRIFNULL(processor->model_name, _("IA64 Processor") ); + UNKIFNULL(processor->vendor_id); + STRIFNULL(processor->arch, "IA-64"); + STRIFNULL(processor->archrev, "0"); + UNKIFNULL(processor->family); + UNKIFNULL(processor->features); + + /* topo & freq */ + processor->cpufreq = cpufreq_new(processor->id); + processor->cputopo = cputopo_new(processor->id); + + if (processor->cpufreq->cpukhz_max) + processor->cpu_mhz = processor->cpufreq->cpukhz_max / 1000; + + } + + return procs; +} + +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); } gchar * -processor_get_info(GSList *processors) +processor_get_detailed_info(Processor *processor) { - Processor *processor = (Processor *)processors->data; - - return g_strdup_printf("[Processor]\n" - "Model=%s\n" - "Architecture=%s\n" - "Family=%sMHz\n" - "BogoMIPS=%s\n" - "Byte Order=%s\n", - processor->model_name, - processor->vendor_id, - processor->strmodel, - processor->bogomips, -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian" -#else - "Big Endian" -#endif - ); + gchar *tmp_cpufreq, *tmp_topology, *ret; + + tmp_topology = cputopo_section_str(processor->cputopo); + tmp_cpufreq = cpufreq_section_str(processor->cpufreq); + + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" /* name */ + "%s=%s\n" /* vendor */ + "%s=%s\n" /* arch */ + "%s=%s\n" /* archrev */ + "%s=%s\n" /* family */ + "%s=%d\n" /* model no. */ + "%s=%d\n" /* revision */ + "%s=%.2f %s\n" /* frequency */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n" /* byte order */ + "%s=%d\n" /* regs */ + "%s=%s\n" /* features */ + "%s" /* topology */ + "%s" /* frequency scaling */ + "%s",/* empty */ + _("Processor"), + _("Name"), processor->model_name, + _("Vendor"), processor->vendor_id, + _("Architecture"), processor->arch, + _("Architecture Revision"), processor->archrev, + _("Family"), processor->family, + _("Model"), processor->model, + _("Revision"), processor->revision, + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str(), + _("CPU regs"), processor->cpu_regs, + _("Features"), processor->features, + tmp_topology, + tmp_cpufreq, + ""); + g_free(tmp_cpufreq); + g_free(tmp_topology); + return ret; +} + +gchar *processor_get_info(GSList * processors) +{ + Processor *processor; + + if (g_slist_length(processors) > 1) { + gchar *ret, *tmp, *hashkey; + GSList *l; + + tmp = g_strdup(""); + + for (l = processors; l; l = l->next) { + processor = (Processor *) l->data; + + tmp = g_strdup_printf("%s$CPU%d$%s=%.2f %s\n", + tmp, processor->id, + processor->model_name, + processor->cpu_mhz, _("MHz")); + + hashkey = g_strdup_printf("CPU%d", processor->id); + moreinfo_add_with_prefix("DEV", hashkey, + processor_get_detailed_info(processor)); + g_free(hashkey); + } + + ret = g_strdup_printf("[$ShellParam$]\n" + "ViewType=1\n" + "[Processors]\n" + "%s", tmp); + g_free(tmp); + + return ret; + } + + processor = (Processor *) processors->data; + return processor_get_detailed_info(processor); } diff --git a/modules/devices/inputdevices.c b/modules/devices/inputdevices.c index d3f8847f..cf1728a9 100644 --- a/modules/devices/inputdevices.c +++ b/modules/devices/inputdevices.c @@ -85,55 +85,55 @@ __scan_input_devices(void) if (name && strstr(name, "PC Speaker")) { d = 3; // INPUT_PCSPKR } - - tmp = g_strdup_printf("INP%d", ++n); - input_list = h_strdup_cprintf("$%s$%s=\n", - input_list, - tmp, name); - input_icons = h_strdup_cprintf("Icon$%s$%s=%s\n", - input_icons, - tmp, name, - input_devices[d].icon); - gchar *strhash = g_strdup_printf("[Device Information]\n" - "Name=%s\n" - "Type=%s\n" - "Bus=0x%x\n", - name, - input_devices[d].name, - bus); - - const gchar *url = vendor_get_url(name); - if (url) { - strhash = h_strdup_cprintf("Vendor=%s (%s)\n", - strhash, - vendor_get_name(name), - url); - } else { - strhash = h_strdup_cprintf("Vendor=%x\n", - strhash, - vendor); - } - strhash = h_strdup_cprintf("Product=0x%x\n" - "Version=0x%x\n", - strhash, product, version); - - if (phys && phys[1] != 0) { - strhash = h_strdup_cprintf("Connected to=%s\n", - strhash, phys); - } - - if (phys && strstr(phys, "ir")) { - strhash = h_strdup_cprintf("InfraRed port=yes\n", - strhash); - } - - moreinfo_add_with_prefix("DEV", tmp, strhash); - g_free(tmp); + tmp = g_strdup_printf("INP%d", ++n); + input_list = h_strdup_cprintf("$%s$%s=\n", + input_list, + tmp, name); + input_icons = h_strdup_cprintf("Icon$%s$%s=%s\n", + input_icons, + tmp, name, + input_devices[d].icon); + + const gchar *v_url = (gchar*)vendor_get_url(name); + const gchar *v_name = (gchar*)vendor_get_name(name); + gchar *v_str = NULL; + if (v_url != NULL) + v_str = g_strdup_printf("[0x%x] %s (%s)", vendor, v_name, v_url); + else + v_str = g_strdup_printf("0x%x", vendor); + v_str = hardinfo_clean_value(v_str, 1); + name = hardinfo_clean_value(name, 1); + + gchar *strhash = g_strdup_printf("[%s]\n" + /* Name */ "%s=%s\n" + /* Type */ "%s=%s\n" + /* Bus */ "%s=0x%x\n" + /* Vendor */ "%s=%s\n" + /* Product */"%s=0x%x\n" + /* Version */"%s=0x%x\n", + _("Device Information"), + _("Name"), name, + _("Type"), input_devices[d].name, + _("Bus"), bus, + _("Vendor"), v_str, + _("Product"), product, + _("Version"), version ); - g_free(phys); - g_free(name); - } + if (phys && phys[1] != 0) { + strhash = h_strdup_cprintf("%s=%s\n", strhash, _("Connected to"), phys); + } + + if (phys && strstr(phys, "ir")) { + strhash = h_strdup_cprintf("%s=%s\n", strhash, _("InfraRed port"), _("Yes") ); + } + + moreinfo_add_with_prefix("DEV", tmp, strhash); + g_free(tmp); + g_free(v_str); + g_free(phys); + g_free(name); + } } fclose(dev); diff --git a/modules/devices/m68k/processor.c b/modules/devices/m68k/processor.c index d9902428..e030732a 100644 --- a/modules/devices/m68k/processor.c +++ b/modules/devices/m68k/processor.c @@ -18,6 +18,7 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" GSList * processor_scan(void) @@ -26,54 +27,66 @@ processor_scan(void) FILE *cpuinfo; gchar buffer[128]; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) - return NULL; + return NULL; processor = g_new0(Processor, 1); while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); + gchar **tmp = g_strsplit(buffer, ":", 2); - if (tmp[0] && tmp[1]) { - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); - get_str("CPU", processor->model_name); - get_float("Clocking", processor->cpu_mhz); - get_float("bogomips", processor->bogomips); - - get_str("FPU", processor->has_fpu); - } - g_strfreev(tmp); + get_str("CPU", processor->model_name); + get_str("MMU", processor->mmu_name); + get_str("FPU", processor->fpu_name); + get_float("Clocking", processor->cpu_mhz); + get_float("BogoMips", processor->bogomips); + get_str("Calibration", processor->calibration); + } + g_strfreev(tmp); } - + gchar *tmp; tmp = g_strconcat("Motorola ", processor->model_name, NULL); g_free(processor->model_name); processor->model_name = tmp; - + fclose(cpuinfo); return g_slist_append(NULL, processor); } +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); +} + gchar * processor_get_info(GSList *processors) { - Processor *processor = (Processor *)processors->data; - - return g_strdup_printf("[Processor]\n" - "Name=%s\n" - "Frequency=%.2fMHz\n" - "BogoMips=%.2f\n" - "Byte Order=%s\n", - processor->model_name, - processor->cpu_mhz, - processor->bogomips, -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian" -#else - "Big Endian" -#endif - ); + Processor *processor = (Processor *)processors->data; + + return g_strdup_printf("[%s]\n" + "%s=%s\n" /* cpu */ + "%s=%s\n" /* mmu */ + "%s=%s\n" /* fpu */ + "%s=%.2f %s\n" /* frequency */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n" /* byte order */ + "%s=%s\n", /* calibration */ + _("Processor"), + _("Model"), processor->model_name, + _("MMU"), processor->mmu_name, + _("FPU"), processor->fpu_name, + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str(), + _("Calibration"), processor->calibration + ); } diff --git a/modules/devices/mips/processor.c b/modules/devices/mips/processor.c index 86c9b958..b31af7dd 100644 --- a/modules/devices/mips/processor.c +++ b/modules/devices/mips/processor.c @@ -18,6 +18,7 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" GSList * processor_scan(void) @@ -26,24 +27,24 @@ processor_scan(void) FILE *cpuinfo; gchar buffer[128]; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) - return NULL; + return NULL; processor = g_new0(Processor, 1); while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); + gchar **tmp = g_strsplit(buffer, ":", 2); - if (tmp[0] && tmp[1]) { - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); - get_str("system type", processor->model_name); - get_str("cpu model", processor->vendor_id); - get_float("cpu MHz", processor->cpu_mhz); - get_float("BogoMIPS", processor->bogomips); - } - g_strfreev(tmp); + get_str("system type", processor->vendor_id); + get_str("cpu model", processor->model_name); + get_float("cpu MHz", processor->cpu_mhz); + get_float("BogoMIPS", processor->bogomips); + } + g_strfreev(tmp); } fclose(cpuinfo); @@ -51,25 +52,30 @@ processor_scan(void) return g_slist_append(NULL, processor); } +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); +} + gchar * processor_get_info(GSList *processors) { - Processor *processor = (Processor *)processors->data; - - return g_strdup_printf("[Processor]\n" - "System Type=%s\n" - "CPU Model=%s\n" - "Frequency=%.2fMHz\n" - "BogoMIPS=%.2f\n" - "Byte Order=%s\n", - processor->model_name, - processor->vendor_id, - processor->cpu_mhz, - processor->bogomips, -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian" -#else - "Big Endian" -#endif - ); + Processor *processor = (Processor *)processors->data; + + return g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%.2f %s\n" /* frequency */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n", /* byte order */ + _("Processor"), + _("Model"), processor->model_name, + _("System Type"), processor->vendor_id, + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str() + ); } diff --git a/modules/devices/parisc/processor.c b/modules/devices/parisc/processor.c index 83672126..9ca38d12 100644 --- a/modules/devices/parisc/processor.c +++ b/modules/devices/parisc/processor.c @@ -18,70 +18,193 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" GSList * -processors_scan(void) +processor_scan(void) { - Processor *processor; + GSList *procs = NULL; + Processor *processor = NULL; FILE *cpuinfo; gchar buffer[128]; + gchar *rep_pname = NULL; + GSList *pi = NULL; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) - return NULL; + return NULL; - processor = g_new0(Processor, 1); +#define CHECK_FOR(k) (g_str_has_prefix(tmp[0], k)) while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); - - if (tmp[0] && tmp[1]) { - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); - - get_str("cpu family", processor->model_name); - get_str("cpu", processor->vendor_id); - get_float("cpu MHz", processor->cpu_mhz); - get_float("bogomips", processor->bogomips); - - get_str("model name", processor->strmodel); - - get_int("I-cache", processor->has_fpu); - get_int("D-cache", processor->flags); - - } - g_strfreev(tmp); + gchar **tmp = g_strsplit(buffer, ":", 2); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); + } else { + g_strfreev(tmp); + continue; + } + + get_str("Processor", rep_pname); + + if ( CHECK_FOR("processor") ) { + /* finish previous */ + if (processor) { + procs = g_slist_append(procs, processor); + } + + /* start next */ + processor = g_new0(Processor, 1); + processor->id = atol(tmp[1]); + + if (rep_pname) + processor->model_name = g_strdup(rep_pname); + + g_strfreev(tmp); + continue; + } + + if (!processor && + ( CHECK_FOR("cpu family") + || CHECK_FOR("cpu MHz") + || CHECK_FOR("cpu") ) ) { + + /* single proc/core may not have "processor : n" */ + processor = g_new0(Processor, 1); + processor->id = 0; + + if (rep_pname) + processor->model_name = g_strdup(rep_pname); + } + + if (processor) { + get_str("cpu family", processor->cpu_family); + get_float("cpu MHz", processor->cpu_mhz); + get_str("cpu", processor->model_name); + get_float("bogomips", processor->bogomips); + get_str("model name", processor->strmodel); + get_str("I-cache", processor->icache_str); + get_str("D-cache", processor->dcache_str); + get_str("hversion", processor->hversion); + get_str("sversion", processor->sversion); + } + g_strfreev(tmp); } + if (processor) + procs = g_slist_append(procs, processor); + + g_free(rep_pname); fclose(cpuinfo); - return g_slist_append(NULL, processor); + /* TODO: redup */ + + /* data not from /proc/cpuinfo */ + for (pi = procs; pi; pi = pi->next) { + processor = (Processor *) pi->data; + + /* strings can't be null or segfault later */ + STRIFNULL(processor->model_name, _("PA-RISC Processor") ); + STRIFNULL(processor->cpu_family, "PA-RISC"); + UNKIFNULL(processor->strmodel); + + /* topo & freq */ + processor->cpufreq = cpufreq_new(processor->id); + processor->cputopo = cputopo_new(processor->id); + + if (processor->cpufreq->cpukhz_max) + processor->cpu_mhz = processor->cpufreq->cpukhz_max / 1000; + + } + + return procs; +} + +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); } gchar * -processor_get_info(GSList *processors) +processor_get_detailed_info(Processor *processor) +{ + gchar *tmp_cpufreq, *tmp_topology, *ret; + + tmp_topology = cputopo_section_str(processor->cputopo); + tmp_cpufreq = cpufreq_section_str(processor->cpufreq); + + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n" /* model name */ + "%s=%.2f %s\n" /* frequency */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n" /* byte order */ + "%s=%s\n" /* hversion */ + "%s=%s\n" /* sversion */ + "[%s]\n" + "I-Cache=%s\n" + "D-Cache=%s\n" + "%s" /* topology */ + "%s" /* frequency scaling */ + "%s",/* empty */ + _("Processor"), + _("Model"), processor->model_name, + _("Architecture"), processor->cpu_family, + _("System"), processor->strmodel, + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str(), + _("HVersion"), processor->hversion, + _("SVersion"), processor->sversion, + _("Cache"), + processor->icache_str, + processor->dcache_str, + tmp_topology, + tmp_cpufreq, + ""); + + g_free(tmp_cpufreq); + g_free(tmp_topology); + return ret; +} + +gchar *processor_get_info(GSList * processors) { - Processor *processor = (Processor *)processors->data; - - return g_strdup_printf("[Processor]\n" - "CPU Family=%s\n" - "CPU=%s\n" - "Frequency=%.2fMHz\n" - "Bogomips=%.2f\n" - "Model Name=%s\n" - "Byte Order=%s\n" - "[Cache]\n" - "I-Cache=%s\n" - "D-Cache=%s\n", - processor->model_name, - processor->vendor_id, - processor->cpu_mhz, - processor->bogomips, - processor->strmodel, -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian", -#else - "Big Endian", -#endif - processor->has_fpu, - processor->flags); + Processor *processor; + + if (g_slist_length(processors) > 1) { + gchar *ret, *tmp, *hashkey; + GSList *l; + + tmp = g_strdup(""); + + for (l = processors; l; l = l->next) { + processor = (Processor *) l->data; + + tmp = g_strdup_printf("%s$CPU%d$%s=%.2f %s\n", + tmp, processor->id, + processor->model_name, + processor->cpu_mhz, _("MHz")); + + hashkey = g_strdup_printf("CPU%d", processor->id); + moreinfo_add_with_prefix("DEV", hashkey, + processor_get_detailed_info(processor)); + g_free(hashkey); + } + + ret = g_strdup_printf("[$ShellParam$]\n" + "ViewType=1\n" + "[Processors]\n" + "%s", tmp); + g_free(tmp); + + return ret; + } + + processor = (Processor *) processors->data; + return processor_get_detailed_info(processor); } diff --git a/modules/devices/pci.c b/modules/devices/pci.c index 91ff914d..c1965a63 100644 --- a/modules/devices/pci.c +++ b/modules/devices/pci.c @@ -40,13 +40,13 @@ scan_pci_do(void) gchar buffer[256], *buf, *strhash = NULL, *strdevice = NULL; gchar *category = NULL, *name = NULL, *icon, *lspci_path, *command_line = NULL; gint n = 0, x = 0; - + if ((lspci_path = find_program("lspci")) == NULL) { goto pci_error; } else { command_line = g_strdup_printf("%s -v", lspci_path); } - + if (!_pci_devices) { _pci_devices = g_hash_table_new(g_str_hash, g_str_equal); } @@ -60,11 +60,11 @@ scan_pci_do(void) } } else { gchar *tmp; - + tmp = g_strdup_printf("%s -i '%s'", command_line, buf); g_free(buf); buf = tmp; - + DEBUG("using updated PCI IDs (from %s)", buf); if (!(lspci = popen(tmp, "r"))) { g_free(buf); @@ -103,30 +103,31 @@ scan_pci_do(void) g_strfreev(list); if (irq) - strdevice = h_strdup_cprintf("IRQ=%d\n", strdevice, irq); + strdevice = h_strdup_cprintf("%s=%d\n", strdevice, _("IRQ"), irq); if (freq) - strdevice = h_strdup_cprintf("Frequency=%dMHz\n", strdevice, freq); + strdevice = h_strdup_cprintf("%s=%d %s\n", strdevice, _("Frequency"), freq, _("MHz") ); if (latency) - strdevice = h_strdup_cprintf("Latency=%d\n", strdevice, latency); + strdevice = h_strdup_cprintf("%s=%d\n", strdevice, _("Latency"), latency); - strdevice = h_strdup_cprintf("Bus Master=%s\n", strdevice, bus_master ? "Yes" : "No"); + strdevice = h_strdup_cprintf("%s=%s\n", strdevice, _("Bus Master"), bus_master ? _("Yes") : _("No") ); } else if (!strncmp(buf, "Kernel modules", 14)) { WALK_UNTIL(' '); WALK_UNTIL(':'); buf++; - - strdevice = h_strdup_cprintf("Kernel modules=%s\n", strdevice, buf); + + strdevice = h_strdup_cprintf("%s=%s\n", strdevice, _("Kernel modules"), buf); } else if (!strncmp(buf, "Subsystem", 9)) { WALK_UNTIL(' '); buf++; const gchar *oem_vendor_url = vendor_get_url(buf); - if (oem_vendor_url) - strdevice = h_strdup_cprintf("OEM Vendor=%s (%s)\n", + if (oem_vendor_url) + strdevice = h_strdup_cprintf(_("%s=%s (%s)\n"), strdevice, + _("OEM Vendor"), vendor_get_name(buf), oem_vendor_url); } else if (!strncmp(buf, "Capabilities", 12) - && !strstr(buf, "only to root") && + && !strstr(buf, "only to root") && !strstr(buf, "access denied")) { WALK_UNTIL(' '); WALK_UNTIL(']'); @@ -144,13 +145,13 @@ scan_pci_do(void) WALK_UNTIL('['); sscanf(buf, "[size=%d%c", &mem, &unit); - strdevice = h_strdup_cprintf("Memory#%d=%d%cB (%s%s)\n", - strdevice, ++x, + strdevice = h_strdup_cprintf("%s#%d=%d%cB (%s%s)\n", + strdevice, _("Memory"), ++x, mem, (unit == ']') ? ' ' : unit, _32bit ? "32-bit, " : "", - prefetch ? "prefetchable" : - "non-prefetchable"); + prefetch ? _("prefetchable") : + _("non-prefetchable") ); } else if (!strncmp(buf, "I/O ports at", 12)) { guint io_addr, io_size; @@ -158,8 +159,8 @@ scan_pci_do(void) sscanf(buf, "I/O ports at %x [size=%d]", &io_addr, &io_size); strdevice = - h_strdup_cprintf("I/O ports at#%d=0x%x - 0x%x\n", - strdevice, ++x, io_addr, + h_strdup_cprintf("%s#%d=0x%x - 0x%x\n", + strdevice, _("I/O ports at"), ++x, io_addr, io_addr + io_size - 1); } else if ((buf[0] >= '0' && buf[0] <= '9') && (buf[4] == ':' || buf[2] == ':')) { gint bus, device, function, domain; @@ -197,51 +198,57 @@ scan_pci_do(void) else if (strstr(category, "Multimedia")) icon = "media"; else if (strstr(category, "USB")) icon = "usb"; else icon = "pci"; - + name = g_strdup(buf); g_hash_table_insert(_pci_devices, g_strdup_printf("0000:%02x:%02x.%x", bus, device, function), name); - strhash = g_strdup_printf("PCI%d", n); - strdevice = g_strdup_printf("[Device Information]\n" - "Name=%s\n" - "Class=%s\n" - "Domain=%d\n" - "Bus, device, function=%d, %d, %d\n", - name, category, domain, bus, - device, function); - + strhash = g_strdup_printf("PCI%d", n); + strdevice = g_strdup_printf("[%s]\n" + /* Name */ "%s=%s\n" + /* Class */ "%s=%s\n" + /* Domain */ "%s=%d\n" + /* Bus, device, function */ + "%s=%d, %d, %d\n", + _("Device Information"), + _("Name"), name, + _("Class"), category, + _("Domain"), domain, + _("Bus, device, function"), + bus, device, function); + const gchar *url = vendor_get_url(name); if (url) { - strdevice = h_strdup_cprintf("Vendor=%s (%s)\n", + strdevice = h_strdup_cprintf("%s=%s (%s)\n", strdevice, + _("Vendor"), vendor_get_name(name), url); } - + g_hash_table_insert(_pci_devices, g_strdup_printf("0000:%02x:%02x.%x", bus, device, function), g_strdup(name)); - + pci_list = h_strdup_cprintf("$PCI%d$%s=%s\n", pci_list, n, category, name); n++; } } - + if (pclose(lspci)) { pci_error: /* error (no pci, perhaps?) */ - pci_list = g_strconcat(pci_list, "No PCI devices found=\n", NULL); + pci_list = g_strconcat(pci_list, _("No PCI devices found"), "=\n", NULL); } else if (strhash) { - /* insert the last device */ + /* insert the last device */ moreinfo_add_with_prefix("DEV", strhash, strdevice); g_free(strhash); g_free(category); g_free(name); } - + g_free(lspci_path); g_free(command_line); } diff --git a/modules/devices/ppc/processor.c b/modules/devices/ppc/processor.c index a7988f97..3360a136 100644 --- a/modules/devices/ppc/processor.c +++ b/modules/devices/ppc/processor.c @@ -18,68 +18,189 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" GSList * processor_scan(void) { - Processor *processor; + GSList *procs = NULL; + Processor *processor = NULL; FILE *cpuinfo; gchar buffer[128]; + gchar *rep_pname = NULL; + GSList *pi = NULL; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) - return NULL; + return NULL; - processor = g_new0(Processor, 1); +#define CHECK_FOR(k) (g_str_has_prefix(tmp[0], k)) while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); + gchar **tmp = g_strsplit(buffer, ":", 2); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); + } else { + g_strfreev(tmp); + continue; + } + + get_str("Processor", rep_pname); + + if ( CHECK_FOR("processor") ) { + /* finish previous */ + if (processor) { + procs = g_slist_append(procs, processor); + } + + /* start next */ + processor = g_new0(Processor, 1); + processor->id = atol(tmp[1]); + + if (rep_pname) + processor->model_name = g_strdup(rep_pname); - if (tmp[0] && tmp[1]) { - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); + g_strfreev(tmp); + continue; + } - get_str("cpu", processor->model_name); - get_str("machine", processor->vendor_id); - get_int("L2 cache", processor->cache_size); - get_float("clock", processor->cpu_mhz); - get_float("bogomips", processor->bogomips); + if (!processor && + ( CHECK_FOR("cpu") + || CHECK_FOR("clock") + || CHECK_FOR("revision") ) ) { - } - g_strfreev(tmp); + /* single proc/core may not have "processor : n" */ + processor = g_new0(Processor, 1); + processor->id = 0; + + if (rep_pname) + processor->model_name = g_strdup(rep_pname); + } + + if (processor) { + get_str("cpu", processor->model_name); + get_str("revision", processor->revision); + get_float("clock", processor->cpu_mhz); + get_float("BogoMIPS", processor->bogomips); + } + g_strfreev(tmp); } - - gchar *tmp = g_strdup_printf("PowerPC %s (%.2fMHz)", - processor->model_name, - processor->cpu_mhz); - g_free(processor->model_name); - processor->model_name = tmp; + if (processor) + procs = g_slist_append(procs, processor); + + g_free(rep_pname); fclose(cpuinfo); - return g_slist_append(NULL, processor); + /* re-duplicate missing data for /proc/cpuinfo variant that de-duplicated it */ +#define REDUP(f) if (dproc->f && !processor->f) processor->f = g_strdup(dproc->f); + Processor *dproc; + GSList *l; + l = procs = g_slist_reverse(procs); + while (l) { + processor = l->data; + if (processor->model_name) { + dproc = processor; + } else if (dproc) { + REDUP(model_name); + REDUP(revision); + } + l = g_slist_next(l); + } + procs = g_slist_reverse(procs); + + /* data not from /proc/cpuinfo */ + for (pi = procs; pi; pi = pi->next) { + processor = (Processor *) pi->data; + + /* strings can't be null or segfault later */ + STRIFNULL(processor->model_name, _("POWER Processor") ); + UNKIFNULL(processor->revision); + + /* topo & freq */ + processor->cpufreq = cpufreq_new(processor->id); + processor->cputopo = cputopo_new(processor->id); + + if (processor->cpufreq->cpukhz_max) + processor->cpu_mhz = processor->cpufreq->cpukhz_max / 1000; + + } + + return procs; +} + +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); } gchar * -processor_get_info(GSList *processors) +processor_get_detailed_info(Processor *processor) { - Processor *processor = (Processor *)processors->data; - - return g_strdup_printf("[Processor]\n" - "Machine=%s\n" - "CPU=%s\n" - "L2 Cache=%dkB\n" - "Frequency=%.2fMHz\n" - "BogoMips=%.2f\n" - "Byte Order=%s\n", - processor->vendor_id, - processor->model_name, - processor->cache_size, - processor->cpu_mhz, - processor->bogomips, -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian" -#else - "Big Endian" -#endif - ); + gchar *tmp_cpufreq, *tmp_topology, *ret; + + tmp_topology = cputopo_section_str(processor->cputopo); + tmp_cpufreq = cpufreq_section_str(processor->cpufreq); + + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" /* model */ + "%s=%s\n" /* revision */ + "%s=%.2f %s\n" /* frequency */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n" /* byte order */ + "%s" /* topology */ + "%s" /* frequency scaling */ + "%s",/* empty */ + _("Processor"), + _("Model"), processor->model_name, + _("Revision"), processor->revision, + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str(), + tmp_topology, + tmp_cpufreq, + ""); + g_free(tmp_cpufreq); + g_free(tmp_topology); + return ret; +} + +gchar *processor_get_info(GSList * processors) +{ + Processor *processor; + + if (g_slist_length(processors) > 1) { + gchar *ret, *tmp, *hashkey; + GSList *l; + + tmp = g_strdup(""); + + for (l = processors; l; l = l->next) { + processor = (Processor *) l->data; + + tmp = g_strdup_printf("%s$CPU%d$%s=%.2f %s\n", + tmp, processor->id, + processor->model_name, + processor->cpu_mhz, _("MHz")); + + hashkey = g_strdup_printf("CPU%d", processor->id); + moreinfo_add_with_prefix("DEV", hashkey, + processor_get_detailed_info(processor)); + g_free(hashkey); + } + + ret = g_strdup_printf("[$ShellParam$]\n" + "ViewType=1\n" + "[Processors]\n" + "%s", tmp); + g_free(tmp); + + return ret; + } + + processor = (Processor *) processors->data; + return processor_get_detailed_info(processor); } diff --git a/modules/devices/riscv/processor.c b/modules/devices/riscv/processor.c new file mode 100644 index 00000000..afddf89d --- /dev/null +++ b/modules/devices/riscv/processor.c @@ -0,0 +1,233 @@ +/* + * HardInfo - Displays System Information + * Copyright (C) 2003-2006 Leandro A. F. Pereira <leandro@hardinfo.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/* source: https://github.com/riscv/riscv-linux/blob/riscv-next/arch/riscv/kernel/cpu.c */ + +#include "hardinfo.h" +#include "devices.h" +#include "cpu_util.h" + +#include "riscv_data.h" +#include "riscv_data.c" + +GSList * +processor_scan(void) +{ + GSList *procs = NULL; + Processor *processor = NULL; + FILE *cpuinfo; + gchar buffer[128]; + gchar *rep_pname = NULL; + gchar *tmpfreq_str = NULL; + GSList *pi = NULL; + + cpuinfo = fopen(PROC_CPUINFO, "r"); + if (!cpuinfo) + return NULL; + +#define CHECK_FOR(k) (g_str_has_prefix(tmp[0], k)) + while (fgets(buffer, 128, cpuinfo)) { + gchar **tmp = g_strsplit(buffer, ":", 2); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); + } else { + g_strfreev(tmp); + continue; + } + + //get_str("Processor", rep_pname); + + if ( CHECK_FOR("hart") ) { + /* finish previous */ + if (processor) { + procs = g_slist_append(procs, processor); + } + + /* start next */ + processor = g_new0(Processor, 1); + processor->id = atol(tmp[1]); + + if (rep_pname) + processor->model_name = g_strdup(rep_pname); + + g_strfreev(tmp); + continue; + } + + if (!processor && + ( CHECK_FOR("mmu") + || CHECK_FOR("isa") + || CHECK_FOR("uarch") ) ) { + + /* single proc/core may not have "hart : n" */ + processor = g_new0(Processor, 1); + processor->id = 0; + + if (rep_pname) + processor->model_name = g_strdup(rep_pname); + } + + if (processor) { + get_str("mmu", processor->mmu); + get_str("isa", processor->isa); + get_str("uarch", processor->uarch); + } + g_strfreev(tmp); + } + + if (processor) + procs = g_slist_append(procs, processor); + + g_free(rep_pname); + fclose(cpuinfo); + + /* TODO: redup */ + + /* data not from /proc/cpuinfo */ + for (pi = procs; pi; pi = pi->next) { + processor = (Processor *) pi->data; + + /* strings can't be null or segfault later */ + STRIFNULL(processor->model_name, _("RISC-V Processor") ); + UNKIFNULL(processor->mmu); + UNKIFNULL(processor->isa); + UNKIFNULL(processor->uarch); + + processor->flags = riscv_isa_to_flags(processor->isa); + + /* topo & freq */ + processor->cpufreq = cpufreq_new(processor->id); + processor->cputopo = cputopo_new(processor->id); + + if (processor->cpufreq->cpukhz_max) + processor->cpu_mhz = processor->cpufreq->cpukhz_max / 1000; + else + processor->cpu_mhz = 0.0f; + } + + return procs; +} + +gchar *processor_get_capabilities_from_flags(gchar * strflags) +{ + gchar **flags, **old; + gchar *tmp = NULL; + gint j = 0; + + flags = g_strsplit(strflags, " ", 0); + old = flags; + + while (flags[j]) { + const gchar *meaning = riscv_ext_meaning( flags[j] ); + + if (meaning) { + tmp = h_strdup_cprintf("%s=%s\n", tmp, flags[j], meaning); + } else { + tmp = h_strdup_cprintf("%s=\n", tmp, flags[j]); + } + j++; + } + if (tmp == NULL || g_strcmp0(tmp, "") == 0) + tmp = g_strdup_printf("%s=%s\n", "empty", _("Empty List")); + + g_strfreev(old); + return tmp; +} + +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); +} + +gchar * +processor_get_detailed_info(Processor *processor) +{ + gchar *tmp_flags, *tmp_cpufreq, *tmp_topology, *ret; + tmp_flags = processor_get_capabilities_from_flags(processor->flags); + tmp_topology = cputopo_section_str(processor->cputopo); + tmp_cpufreq = cpufreq_section_str(processor->cpufreq); + + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" /* model */ + "%s=%s\n" /* isa */ + "%s=%s\n" /* uarch */ + "%s=%s\n" /* mmu */ + "%s=%.2f %s\n" /* frequency */ + "%s=%s\n" /* byte order */ + "%s" /* topology */ + "%s" /* frequency scaling */ + "[%s]\n" /* extensions */ + "%s" + "%s",/* empty */ + _("Processor"), + _("Model"), processor->model_name, + _("Architecture"), processor->isa, + _("uarch"), processor->uarch, + _("MMU"), processor->mmu, + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("Byte Order"), byte_order_str(), + tmp_topology, + tmp_cpufreq, + _("Capabilities"), tmp_flags, + ""); + g_free(tmp_flags); + g_free(tmp_cpufreq); + g_free(tmp_topology); + return ret; +} + +gchar *processor_get_info(GSList * processors) +{ + Processor *processor; + + if (g_slist_length(processors) > 1) { + gchar *ret, *tmp, *hashkey; + GSList *l; + + tmp = g_strdup(""); + + for (l = processors; l; l = l->next) { + processor = (Processor *) l->data; + + tmp = g_strdup_printf("%s$CPU%d$%s=%.2f %s\n", + tmp, processor->id, + processor->model_name, + processor->cpu_mhz, _("MHz")); + + hashkey = g_strdup_printf("CPU%d", processor->id); + moreinfo_add_with_prefix("DEV", hashkey, + processor_get_detailed_info(processor)); + g_free(hashkey); + } + + ret = g_strdup_printf("[$ShellParam$]\n" + "ViewType=1\n" + "[Processors]\n" + "%s", tmp); + g_free(tmp); + + return ret; + } + + processor = (Processor *) processors->data; + return processor_get_detailed_info(processor); +} diff --git a/modules/devices/riscv/riscv_data.c b/modules/devices/riscv/riscv_data.c new file mode 100644 index 00000000..4ae68ef4 --- /dev/null +++ b/modules/devices/riscv/riscv_data.c @@ -0,0 +1,212 @@ +/* + * rpiz - https://github.com/bp0/rpiz + * Copyright (C) 2017 Burt P. <pburt0@gmail.com> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <ctype.h> +#include "riscv_data.h" + +#ifndef C_ +#define C_(Ctx, String) String +#endif +#ifndef NC_ +#define NC_(Ctx, String) String +#endif + +static struct { + char *name, *meaning; +} tab_ext_meaning[] = { + { "RV32", NC_("rv-ext", /*/ext:RV32*/ "RISC-V 32-bit") }, + { "RV64", NC_("rv-ext", /*/ext:RV64*/ "RISC-V 64-bit") }, + { "RV128", NC_("rv-ext", /*/ext:RV128*/ "RISC-V 128-bit") }, + { "E", NC_("rv-ext", /*/ext:E*/ "Base embedded integer instructions (15 registers)") }, + { "I", NC_("rv-ext", /*/ext:I*/ "Base integer instructions (31 registers)") }, + { "M", NC_("rv-ext", /*/ext:M*/ "Hardware integer multiply and divide") }, + { "A", NC_("rv-ext", /*/ext:A*/ "Atomic memory operations") }, + { "C", NC_("rv-ext", /*/ext:C*/ "Compressed 16-bit instructions") }, + { "F", NC_("rv-ext", /*/ext:F*/ "Floating-point instructions, single-precision") }, + { "D", NC_("rv-ext", /*/ext:D*/ "Floating-point instructions, double-precision") }, + { "Q", NC_("rv-ext", /*/ext:Q*/ "Floating-point instructions, quad-precision") }, + { "B", NC_("rv-ext", /*/ext:B*/ "Bit manipulation instructions") }, + { "V", NC_("rv-ext", /*/ext:V*/ "Vector operations") }, + { "T", NC_("rv-ext", /*/ext:T*/ "Transactional memory") }, + { "P", NC_("rv-ext", /*/ext:P*/ "Packed SIMD instructions") }, + { "L", NC_("rv-ext", /*/ext:L*/ "Decimal floating-point instructions") }, + { "J", NC_("rv-ext", /*/ext:J*/ "Dynamically translated languages") }, + { "N", NC_("rv-ext", /*/ext:N*/ "User-level interrupts") }, + { NULL, NULL } +}; + +static char all_extensions[1024] = ""; + +#define APPEND_EXT(f) strcat(all_extensions, f); strcat(all_extensions, " "); +const char *riscv_ext_list() { + int i = 0, built = 0; + built = strlen(all_extensions); + if (!built) { + while(tab_ext_meaning[i].name != NULL) { + APPEND_EXT(tab_ext_meaning[i].name); + i++; + } + } + return all_extensions; +} + +const char *riscv_ext_meaning(const char *ext) { + int i = 0, l = 0; + char *c = NULL; + if (ext) { + c = strchr(ext, ':'); /* allow extension:version, ignore version */ + if (c != NULL) + l = c - ext; + else + l = strlen(ext); + while(tab_ext_meaning[i].name != NULL) { + if (strncasecmp(tab_ext_meaning[i].name, ext, l) == 0) { + if (tab_ext_meaning[i].meaning != NULL) + return C_("rv-ext", tab_ext_meaning[i].meaning); + else return NULL; + } + i++; + } + } + return NULL; +} + +/* see RISC-V spec 2.2: Chapter 22: ISA Subset Naming Conventions */ + +/* Spec says case-insensitve, but I prefer single-letter extensions + * capped and version string (like "2p1") with a lowercase p. */ +#define RV_FIX_CASE(fstr,vo) \ + p = fstr; while (*p != 0 && *p != ':') { if (!vo) *p = toupper(*p); p++; } \ + if (*p == ':') while (*p != 0) { if (*p == 'P') *p = 'p'; p++; } + +static int riscv_isa_next(const char *isap, char *flag) { + char *p = NULL, *start = NULL; + char *next_sep = NULL, *next_digit = NULL; + int skip_len = 0, tag_len = 0, ver_len = 0; + char ext_str[32], ver_str[32]; + + if (isap == NULL) + return 0; + + /* find start by skipping any '_' */ + start = (char*)isap; + while (*start != 0 && *start == '_') { start++; skip_len++; }; + if (*start == 0) + return 0; + + /* find next '_' or \0 */ + p = start; while (*p != 0 && *p != '_') { p++; }; next_sep = p; + + /* find next digit that may be a version, find length of version */ + p = start; while (*p != 0 && !isdigit(*p)) { p++; }; + if (isdigit(*p)) next_digit = p; + if (next_digit) { + while (*p != 0 && (isdigit(*p) || *p == 'p' || *p == 'P') ) { + if ((*p == 'p' || *p == 'P') && !isdigit(*(p+1)) ) + break; + ver_len++; + p++; + } + } + + /* is next version nearer than next separator */ + p = start; + if (next_digit && next_digit < next_sep) + tag_len = next_digit - p; + else { + tag_len = next_sep - p; + ver_len = 0; + } + + switch(*p) { + case 'S': case 's': /* supervisor extension */ + case 'X': case 'x': /* custom extension */ + /* custom supervisor extension (SX..) handled by S */ + break; + default: /* single character (standard) extension */ + tag_len = 1; + if (next_digit != p+1) ver_len = 0; + break; + } + + memset(ext_str, 0, 32); + memset(ver_str, 0, 32); + if (ver_len) { + strncpy(ext_str, p, tag_len); + strncpy(ver_str, next_digit, ver_len); + sprintf(flag, "%s:%s", ext_str, ver_str); + if (tag_len == 1) { + RV_FIX_CASE(flag, 0); + } else { + RV_FIX_CASE(flag, 1); + } + return skip_len + tag_len + ver_len; + } else { + strncpy(ext_str, p, tag_len); + sprintf(flag, "%s", ext_str); + if (tag_len == 1) { RV_FIX_CASE(flag, 0); } + return skip_len + tag_len; + } +} + +#define FSTR_SIZE 1024 +#define RV_CHECK_FOR(e) ( strncasecmp(ps, e, 2) == 0 ) +#define ADD_EXT_FLAG(ext) el = strlen(ext); strncpy(pd, ext, el); strncpy(pd + el, " ", 1); pd += el + 1; +char *riscv_isa_to_flags(const char *isa) { + char *flags = NULL, *ps = (char*)isa, *pd = NULL; + char flag_buf[64] = ""; + int isa_len = 0, tl = 0, el = 0; /* el used in macro */ + + if (isa) { + isa_len = strlen(isa); + flags = malloc(FSTR_SIZE); + if (flags) { + memset(flags, 0, FSTR_SIZE); + ps = (char*)isa; + pd = flags; + if ( RV_CHECK_FOR("RV") ) + { ps += 2; } + if ( RV_CHECK_FOR("32") ) + { ADD_EXT_FLAG("RV32"); ps += 2; } + else if ( RV_CHECK_FOR("64") ) + { ADD_EXT_FLAG("RV64"); ps += 2; } + else if ( RV_CHECK_FOR("128") ) + { ADD_EXT_FLAG("RV128"); ps += 3; } + + while( (tl = riscv_isa_next(ps, flag_buf)) ) { + if (flag_buf[0] == 'G') { /* G = IMAFD */ + flag_buf[0] = 'I'; ADD_EXT_FLAG(flag_buf); + flag_buf[0] = 'M'; ADD_EXT_FLAG(flag_buf); + flag_buf[0] = 'A'; ADD_EXT_FLAG(flag_buf); + flag_buf[0] = 'F'; ADD_EXT_FLAG(flag_buf); + flag_buf[0] = 'D'; ADD_EXT_FLAG(flag_buf); + } else { + ADD_EXT_FLAG(flag_buf); + } + ps += tl; + if (ps - isa >= isa_len) break; /* just in case */ + } + } + } + return flags; +} diff --git a/modules/devices/riscv/riscv_data.h b/modules/devices/riscv/riscv_data.h new file mode 100644 index 00000000..1d3a0a48 --- /dev/null +++ b/modules/devices/riscv/riscv_data.h @@ -0,0 +1,33 @@ +/* + * rpiz - https://github.com/bp0/rpiz + * Copyright (C) 2017 Burt P. <pburt0@gmail.com> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef _RISCVDATA_H_ +#define _RISCVDATA_H_ + +/* convert RISC-V ISA string to flags list */ +char *riscv_isa_to_flags(const char *isa); + +/* all known extensions as flags list */ +const char *riscv_ext_list(void); + +/* get meaning of flag */ +const char *riscv_ext_meaning(const char *ext); + +#endif diff --git a/modules/devices/s390/processor.c b/modules/devices/s390/processor.c index 99f1c8bd..cf45c33c 100644 --- a/modules/devices/s390/processor.c +++ b/modules/devices/s390/processor.c @@ -18,61 +18,163 @@ #include "hardinfo.h" #include "devices.h" +#include "string.h" +#include "cpu_util.h" GSList * processor_scan(void) { - Processor *processor; + GSList *procs = NULL; + Processor *processor = NULL; FILE *cpuinfo; gchar buffer[128]; + gchar *vendor_id = NULL; + gint num_procs = 0; + gfloat bogomips = 0.0f; + GSList *pi = NULL; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) - return NULL; + return NULL; - processor = g_new0(Processor, 1); +#define CHECK_FOR(k) (g_str_has_prefix(tmp[0], k)) while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); + gchar **tmp = g_strsplit(buffer, ":", 2); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); + } else { + g_strfreev(tmp); + continue; + } + + get_str("vendor_id", vendor_id); + get_int("# processors", num_procs); + get_int("bogomips per cpu", bogomips); + + if ( CHECK_FOR("processor") ) { + /* finish previous */ + if (processor) { + procs = g_slist_append(procs, processor); + } + + /* start next */ + processor = g_new0(Processor, 1); + if (strlen(tmp[0]) >= 10) + processor->id = atol(tmp[0] + 10); /* processor n: ... */ + else + processor->id = 0; /* idk */ + processor->proc_str = g_strdup(tmp[1]); - if (tmp[0] && tmp[1]) { - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); + if (vendor_id) + processor->model_name = g_strdup(vendor_id); + if (bogomips) + processor->bogomips = bogomips; - get_str("vendor_id", processor->vendor_id); - get_float("# processors", processor->cache_size); - get_int("bogomips per cpu", processor->bogomips); + g_strfreev(tmp); + continue; + } - } - g_strfreev(tmp); + g_strfreev(tmp); } - processor->cpu_mhz = 0.0f; - - processor->model_name = g_strconcat("S390 ", processor->vendor_id, NULL); - g_free(processor->vendor_id); + if (processor) + procs = g_slist_append(procs, processor); + g_free(vendor_id); fclose(cpuinfo); - return g_slist_append(NULL, processor); + /* data not from /proc/cpuinfo */ + for (pi = procs; pi; pi = pi->next) { + processor = (Processor *) pi->data; + + /* strings can't be null or segfault later */ + STRIFNULL(processor->model_name, _("S390 Processor") ); + UNKIFNULL(processor->proc_str); + + /* topo & freq */ + processor->cpufreq = cpufreq_new(processor->id); + processor->cputopo = cputopo_new(processor->id); + + if (processor->cpufreq->cpukhz_max) + processor->cpu_mhz = processor->cpufreq->cpukhz_max / 1000; + else + processor->cpu_mhz = 0.0f; + + } + + return procs; +} + +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); } gchar * -processor_get_info(GSList *processors) +processor_get_detailed_info(Processor *processor) +{ + gchar *tmp_cpufreq, *tmp_topology, *ret; + tmp_topology = cputopo_section_str(processor->cputopo); + tmp_cpufreq = cpufreq_section_str(processor->cpufreq); + + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" /* model */ + "%s=%s\n" /* proc string */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n" /* byte order */ + "%s" /* topology */ + "%s", /* frequency scaling */ + _("Processor"), + _("Model"), processor->model_name, + _("ID String"), processor->proc_str, + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str(), + tmp_topology, + tmp_cpufreq + ); + g_free(tmp_cpufreq); + g_free(tmp_topology); + return ret; +} + +gchar *processor_get_info(GSList * processors) { - Processor *processor = (Processor *)processors->data; - - return g_strdup_printf("[Processor]\n" - "Model=%s\n" - "Processors=%d\n" - "BogoMips per CPU=%.2f" - "Byte Order=%s\n", - processor->model_name, - processor->cache_size, - processor->bogomips, -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian" -#else - "Big Endian" -#endif - ); + Processor *processor; + + if (g_slist_length(processors) > 1) { + gchar *ret, *tmp, *hashkey; + GSList *l; + + tmp = g_strdup(""); + + for (l = processors; l; l = l->next) { + processor = (Processor *) l->data; + + tmp = g_strdup_printf("%s$CPU%d$%s=%.2f %s\n", + tmp, processor->id, + processor->model_name, + processor->cpu_mhz, _("MHz")); + + hashkey = g_strdup_printf("CPU%d", processor->id); + moreinfo_add_with_prefix("DEV", hashkey, + processor_get_detailed_info(processor)); + g_free(hashkey); + } + + ret = g_strdup_printf("[$ShellParam$]\n" + "ViewType=1\n" + "[Processors]\n" + "%s", tmp); + g_free(tmp); + + return ret; + } + + processor = (Processor *) processors->data; + return processor_get_detailed_info(processor); } + diff --git a/modules/devices/sensors.c b/modules/devices/sensors.c index 84e89361..c9d78ff7 100644 --- a/modules/devices/sensors.c +++ b/modules/devices/sensors.c @@ -27,8 +27,7 @@ gchar *sensors = NULL; GHashTable *sensor_compute = NULL; GHashTable *sensor_labels = NULL; -static void read_sensor_labels(gchar * driver) -{ +static void read_sensor_labels(gchar *driver) { FILE *conf; gchar buf[256], *line, *p; gboolean lock = FALSE; @@ -38,7 +37,8 @@ static void read_sensor_labels(gchar * driver) conf = fopen("/etc/sensors3.conf", "r"); /* If it fails, try to open sensors.conf */ - if (!conf) conf = fopen("/etc/sensors.conf", "r"); + if (!conf) + conf = fopen("/etc/sensors.conf", "r"); if (!conf) { /* Cannot open config file. */ @@ -46,117 +46,129 @@ static void read_sensor_labels(gchar * driver) } while (fgets(buf, 256, conf)) { - line = buf; - - remove_linefeed(line); - strend(line, '#'); - - if (*line == '\0') { - continue; - } else if (lock && strstr(line, "label")) { /* label lines */ - gchar **names = g_strsplit(strstr(line, "label") + 5, " ", 0); - gchar *name = NULL, *value = NULL; - - for (i = 0; names[i]; i++) { - if (names[i][0] == '\0') - continue; - - if (!name) - name = g_strdup(names[i]); - else if (!value) - value = g_strdup(names[i]); - else - value = g_strconcat(value, " ", names[i], NULL); - } - - remove_quotes(value); - g_hash_table_insert(sensor_labels, name, value); - - g_strfreev(names); - } else if (lock && strstr(line, "ignore")) { /* ignore lines */ - p = strstr(line, "ignore") + 6; - if (!strchr(p, ' ')) - continue; - - while (*p == ' ') - p++; - g_hash_table_insert(sensor_labels, g_strdup(p), "ignore"); - } else if (lock && strstr(line, "compute")) { /* compute lines */ - gchar **formulas = - g_strsplit(strstr(line, "compute") + 7, " ", 0); - gchar *name = NULL, *formula = NULL; - - for (i = 0; formulas[i]; i++) { - if (formulas[i][0] == '\0') - continue; - if (formulas[i][0] == ',') - break; - - if (!name) - name = g_strdup(formulas[i]); - else if (!formula) - formula = g_strdup(formulas[i]); - else - formula = g_strconcat(formula, formulas[i], NULL); - } - - g_strfreev(formulas); - g_hash_table_insert(sensor_compute, name, - math_string_to_postfix(formula)); - } else if (g_str_has_prefix(line, "chip")) { /* chip lines (delimiter) */ - if (lock == FALSE) { - gchar **chips = g_strsplit(line, " ", 0); - - for (i = 1; chips[i]; i++) { - strend(chips[i], '*'); - - if (g_str_has_prefix(chips[i] + 1, driver)) { - lock = TRUE; - break; - } - } - - g_strfreev(chips); - } else { - break; - } - } + line = buf; + + remove_linefeed(line); + strend(line, '#'); + + if (*line == '\0') { + continue; + } else if (lock && strstr(line, "label")) { /* label lines */ + gchar **names = g_strsplit(strstr(line, "label") + 5, " ", 0); + gchar *name = NULL, *value = NULL; + + for (i = 0; names[i]; i++) { + if (names[i][0] == '\0') + continue; + + if (!name) + name = g_strdup(names[i]); + else if (!value) + value = g_strdup(names[i]); + else + value = g_strconcat(value, " ", names[i], NULL); + } + + remove_quotes(value); + g_hash_table_insert(sensor_labels, name, value); + + g_strfreev(names); + } else if (lock && strstr(line, "ignore")) { /* ignore lines */ + p = strstr(line, "ignore") + 6; + if (!strchr(p, ' ')) + continue; + + while (*p == ' ') + p++; + g_hash_table_insert(sensor_labels, g_strdup(p), "ignore"); + } else if (lock && strstr(line, "compute")) { /* compute lines */ + gchar **formulas = g_strsplit(strstr(line, "compute") + 7, " ", 0); + gchar *name = NULL, *formula = NULL; + + for (i = 0; formulas[i]; i++) { + if (formulas[i][0] == '\0') + continue; + if (formulas[i][0] == ',') + break; + + if (!name) + name = g_strdup(formulas[i]); + else if (!formula) + formula = g_strdup(formulas[i]); + else + formula = g_strconcat(formula, formulas[i], NULL); + } + + g_strfreev(formulas); + g_hash_table_insert(sensor_compute, name, + math_string_to_postfix(formula)); + } else if (g_str_has_prefix(line, + "chip")) { /* chip lines (delimiter) */ + if (lock == FALSE) { + gchar **chips = g_strsplit(line, " ", 0); + + for (i = 1; chips[i]; i++) { + strend(chips[i], '*'); + + if (g_str_has_prefix(chips[i] + 1, driver)) { + lock = TRUE; + break; + } + } + + g_strfreev(chips); + } else { + break; + } + } } fclose(conf); } -static gchar *get_sensor_label(gchar * sensor) -{ +static void add_sensor(const char *type, + const char *sensor, + const char *driver, + double value, + const char *unit) { + char key[64]; + + sensors = h_strdup_cprintf("%s/%s=%.2f%s|%s\n", sensors, + driver, sensor, value, unit, type); + + snprintf(key, sizeof(key), "%s/%s", driver, sensor); + moreinfo_add_with_prefix("DEV", key, g_strdup_printf("%.2f%s", value, unit)); + + lginterval = h_strdup_cprintf("UpdateInterval$%s=1000\n", lginterval, key); +} + +static gchar *get_sensor_label(gchar *sensor) { gchar *ret; ret = g_hash_table_lookup(sensor_labels, sensor); if (!ret) - ret = g_strdup(sensor); + ret = g_strdup(sensor); else - ret = g_strdup(ret); + ret = g_strdup(ret); return ret; } -static float adjust_sensor(gchar * name, float value) -{ +static float adjust_sensor(gchar *name, float value) { GSList *postfix; postfix = g_hash_table_lookup(sensor_compute, name); if (!postfix) - return value; + return value; return math_postfix_eval(postfix, value); } -static char *get_sensor_path(int number, const char *prefix) -{ +static char *get_sensor_path(int number, const char *prefix) { return g_strdup_printf("/sys/class/hwmon/hwmon%d/%s", number, prefix); } -static char *determine_driver_for_hwmon_path(char *path) -{ +static char *determine_driver_for_hwmon_path(char *path) { char *tmp, *driver; tmp = g_strdup_printf("%s/device/driver", path); @@ -190,165 +202,171 @@ struct HwmonSensor { const char *friendly_name; const char *path_format; const char *key_format; - const char *value_format; + const char *unit; const float adjust_ratio; const int begin_at; }; static const struct HwmonSensor hwmon_sensors[] = { - { "Cooling Fans", "%s/fan%d_input", "fan%d", "%s (%s)=%.0fRPM\n", 1.0, 1 }, - { "Temperature", "%s/temp%d_input", "temp%d", "%s (%s)=%.2f\302\260C\n", 1000.0, 1 }, - { "Voltage Values", "%s/in%d_input", "in%d", "%s (%s)=%.3fV\n", 1000.0, 0 }, - { NULL, NULL, NULL, NULL, 0.0, 0 }, + { + "Fan", + "%s/fan%d_input", + "fan%d", + "RPM", + 1.0, + 1 + }, + { + "Temperature", + "%s/temp%d_input", + "temp%d", + "\302\260C", + 1000.0, + 1 + }, + { + "Voltage", + "%s/in%d_input", + "in%d", + "V", + 1000.0, + 0 + }, + { } }; -static const char *hwmon_prefix[] = { "device", "", NULL }; +static const char *hwmon_prefix[] = {"device", "", NULL}; -static void read_sensors_hwmon(void) -{ +static void read_sensors_hwmon(void) { int hwmon, count; gchar *path_hwmon, *path_sensor, *tmp, *driver, *name, *mon; const char **prefix; - + for (prefix = hwmon_prefix; *prefix; prefix++) { - hwmon = 0; - path_hwmon = get_sensor_path(hwmon, *prefix); - while (path_hwmon && g_file_test(path_hwmon, G_FILE_TEST_EXISTS)) { - const struct HwmonSensor *sensor; - - driver = determine_driver_for_hwmon_path(path_hwmon); - DEBUG("hwmon%d has driver=%s", hwmon, driver); - - if (!sensor_labels) { - read_sensor_labels(driver); - } - - for (sensor = hwmon_sensors; sensor->friendly_name; sensor++) { - char *output = NULL; - DEBUG("current sensor type=%s", sensor->friendly_name); - - for (count = sensor->begin_at;; count++) { - path_sensor = g_strdup_printf(sensor->path_format, path_hwmon, count); - DEBUG("should be reading from %s", path_sensor); - if (!g_file_get_contents(path_sensor, &tmp, NULL, NULL)) { - g_free(path_sensor); - if (count<256) - continue; // brute-force find all - else - break; - } - - mon = g_strdup_printf(sensor->key_format, count); - name = get_sensor_label(mon); - if (!g_str_equal(name, "ignore")) { - output = h_strdup_cprintf(sensor->value_format, - output, name, driver, - adjust_sensor(mon, - atof(tmp) / sensor->adjust_ratio)); - } - - g_free(tmp); - g_free(mon); - g_free(name); - g_free(path_sensor); - } - - if (output) { - sensors = g_strconcat(sensors, "[", sensor->friendly_name, "]\n", output, "\n", NULL); - g_free(output); - } - } - - g_free(path_hwmon); - g_free(driver); - - path_hwmon = get_sensor_path(++hwmon, *prefix); - } - - g_free(path_hwmon); - } + hwmon = 0; + path_hwmon = get_sensor_path(hwmon, *prefix); + while (path_hwmon && g_file_test(path_hwmon, G_FILE_TEST_EXISTS)) { + const struct HwmonSensor *sensor; + + driver = determine_driver_for_hwmon_path(path_hwmon); + DEBUG("hwmon%d has driver=%s", hwmon, driver); + + if (!sensor_labels) { + read_sensor_labels(driver); + } + + for (sensor = hwmon_sensors; sensor->friendly_name; sensor++) { + DEBUG("current sensor type=%s", sensor->friendly_name); + + for (count = sensor->begin_at;; count++) { + path_sensor = + g_strdup_printf(sensor->path_format, path_hwmon, count); + DEBUG("should be reading from %s", path_sensor); + if (!g_file_get_contents(path_sensor, &tmp, NULL, NULL)) { + g_free(path_sensor); + if (count < 256) + continue; // brute-force find all + else + break; + } + + mon = g_strdup_printf(sensor->key_format, count); + name = get_sensor_label(mon); + if (!g_str_equal(name, "ignore")) { + float adjusted = adjust_sensor(mon, + atof(tmp) / sensor->adjust_ratio); + + add_sensor(sensor->friendly_name, + name, + driver, + adjusted, + sensor->unit); + } + + g_free(tmp); + g_free(mon); + g_free(name); + g_free(path_sensor); + } + } + + g_free(path_hwmon); + g_free(driver); + + path_hwmon = get_sensor_path(++hwmon, *prefix); + } + + g_free(path_hwmon); + } } -static void read_sensors_acpi(void) -{ +static void read_sensors_acpi(void) { const gchar *path_tz = "/proc/acpi/thermal_zone"; if (g_file_test(path_tz, G_FILE_TEST_EXISTS)) { - GDir *tz; - - if ((tz = g_dir_open(path_tz, 0, NULL))) { - const gchar *entry; - gchar *temp = g_strdup(""); - - while ((entry = g_dir_read_name(tz))) { - gchar *path = - g_strdup_printf("%s/%s/temperature", path_tz, entry); - gchar *contents; + GDir *tz; - if (g_file_get_contents(path, &contents, NULL, NULL)) { - int temperature; + if ((tz = g_dir_open(path_tz, 0, NULL))) { + const gchar *entry; - sscanf(contents, "temperature: %d C", &temperature); + while ((entry = g_dir_read_name(tz))) { + gchar *path = + g_strdup_printf("%s/%s/temperature", path_tz, entry); + gchar *contents; - temp = h_strdup_cprintf("\n%s=%d\302\260C\n", - temp, entry, temperature); + if (g_file_get_contents(path, &contents, NULL, NULL)) { + int temperature; - g_free(contents); - } - } + sscanf(contents, "temperature: %d C", &temperature); - if (*temp != '\0') - sensors = - h_strdup_cprintf("\n[ACPI Thermal Zone]\n%s", - sensors, temp); + add_sensor("Temperature", + entry, + "ACPI Thermal Zone", + temperature, + "\302\260C"); + } + } - g_dir_close(tz); - } + g_dir_close(tz); + } } - } -static void read_sensors_sys_thermal(void) -{ +static void read_sensors_sys_thermal(void) { const gchar *path_tz = "/sys/class/thermal"; if (g_file_test(path_tz, G_FILE_TEST_EXISTS)) { - GDir *tz; - - if ((tz = g_dir_open(path_tz, 0, NULL))) { - const gchar *entry; - gchar *temp = g_strdup(""); + GDir *tz; - while ((entry = g_dir_read_name(tz))) { - gchar *path = - g_strdup_printf("%s/%s/temp", path_tz, entry); - gchar *contents; + if ((tz = g_dir_open(path_tz, 0, NULL))) { + const gchar *entry; + gchar *temp = g_strdup(""); - if (g_file_get_contents(path, &contents, NULL, NULL)) { - int temperature; + while ((entry = g_dir_read_name(tz))) { + gchar *path = g_strdup_printf("%s/%s/temp", path_tz, entry); + gchar *contents; - sscanf(contents, "%d", &temperature); + if (g_file_get_contents(path, &contents, NULL, NULL)) { + int temperature; - temp = h_strdup_cprintf("\n%s=%.2f\302\260C\n", - temp, entry, (1.0*temperature/1000)); + sscanf(contents, "%d", &temperature); - g_free(contents); - } - } + add_sensor("Temperature", + entry, + "thermal", + temperature / 1000.0, + "\302\260C"); - if (*temp != '\0') - sensors = - h_strdup_cprintf("\n[ACPI Thermal Zone (sysfs)]\n%s", - sensors, temp); + g_free(contents); + } + } - g_dir_close(tz); - } + g_dir_close(tz); + } } - } -static void read_sensors_omnibook(void) -{ +static void read_sensors_omnibook(void) { const gchar *path_ob = "/proc/omnibook/temperature"; gchar *contents; @@ -357,88 +375,79 @@ static void read_sensors_omnibook(void) sscanf(contents, "CPU temperature: %d C", &temperature); - sensors = h_strdup_cprintf("\n[Omnibook]\n" - "CPU temperature=%d\302\260C\n", - sensors, temperature); + add_sensor("Temperature", + "CPU", + "omnibook", + temperature, + "\302\260C\n"); g_free(contents); } } -static void read_sensors_hddtemp(void) -{ +static void read_sensors_hddtemp(void) { Socket *s; - static gchar *old = NULL; gchar buffer[1024]; gint len = 0; - if ((s = sock_connect("127.0.0.1", 7634))) { - while (!len) - len = sock_read(s, buffer, sizeof(buffer)); - sock_close(s); - - if (len > 2 && buffer[0] == '|' && buffer[1] == '/') { - gchar **disks; - int i; - - g_free(old); - - old = g_strdup("[Hard Disk Temperature]\n"); - - disks = g_strsplit(buffer, "\n", 0); - for (i = 0; disks[i]; i++) { - gchar **fields = g_strsplit(disks[i] + 1, "|", 5); - - /* - * 0 -> /dev/hda - * 1 -> FUJITSU MHV2080AH - * 2 -> 41 - * 3 -> C - */ - old = h_strdup_cprintf("\n%s (%s)=%s\302\260%s\n", - old, - fields[1], fields[0], - fields[2], fields[3]); - - g_strfreev(fields); - } + if (!(s = sock_connect("127.0.0.1", 7634))) + return; - g_strfreev(disks); - } - } else { - g_free(old); - old = NULL; - } + while (!len) + len = sock_read(s, buffer, sizeof(buffer)); + sock_close(s); + + if (len > 2 && buffer[0] == '|' && buffer[1] == '/') { + gchar **disks; + int i; + + disks = g_strsplit(buffer, "\n", 0); + for (i = 0; disks[i]; i++) { + gchar **fields = g_strsplit(disks[i] + 1, "|", 5); + + /* + * 0 -> /dev/hda + * 1 -> FUJITSU MHV2080AH + * 2 -> 41 + * 3 -> C + */ + const gchar *unit = strcmp(fields[3], "C") + ? "\302\260C" : "\302\260F"; + add_sensor("Hard Drive", + fields[1], + "hddtemp", + atoi(fields[2]), + unit); + + g_strfreev(fields); + } - if (old) { - sensors = g_strconcat(sensors, "\n", old, NULL); + g_strfreev(disks); } } -void scan_sensors_do(void) -{ +void scan_sensors_do(void) { g_free(sensors); - sensors = g_strdup(""); + g_free(lginterval); + lginterval = g_strdup(""); + read_sensors_hwmon(); read_sensors_acpi(); read_sensors_sys_thermal(); read_sensors_omnibook(); read_sensors_hddtemp(); - /* FIXME: Add support for ibm acpi and more sensors */ } -void sensors_init(void) -{ - sensor_labels = g_hash_table_new_full(g_str_hash, g_str_equal, - g_free, g_free); +void sensors_init(void) { + sensor_labels = + g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); sensor_compute = g_hash_table_new(g_str_hash, g_str_equal); } -void sensors_shutdown(void) -{ +void sensors_shutdown(void) { g_hash_table_destroy(sensor_labels); g_hash_table_destroy(sensor_compute); } diff --git a/modules/devices/sh/processor.c b/modules/devices/sh/processor.c index cbd9a60a..9da2f9b0 100644 --- a/modules/devices/sh/processor.c +++ b/modules/devices/sh/processor.c @@ -18,6 +18,7 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" GSList * processor_scan(void) @@ -26,50 +27,67 @@ processor_scan(void) FILE *cpuinfo; gchar buffer[128]; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) - return NULL; + return NULL; processor = g_new0(Processor, 1); while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); + gchar **tmp = g_strsplit(buffer, ":", 2); - if (tmp[0] && tmp[1]) { - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); - get_str("machine", processor->model_name); - get_str("cpu type", processor->vendor_id); - get_float("bogomips", processor->bogomips); - processor->cpu_mhz = processor->bogomips; - } - g_strfreev(tmp); + get_str("machine", processor->vendor_id); + get_str("cpu type", processor->model_name); + get_str("cpu family", processor->family); + get_float("cpu clock", processor->cpu_mhz); + get_float("bus clock", processor->bus_mhz); + get_float("module clock", processor->mod_mhz); + get_float("bogomips", processor->bogomips); + } + g_strfreev(tmp); } fclose(cpuinfo); + STRIFNULL(processor->model_name, _("SuperH Processor")); + UNKIFNULL(processor->vendor_id); + return g_slist_append(NULL, processor); } +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); +} + gchar * processor_get_info(GSList *processors) { - Processor *processor = (Processor *)processors->data; - - return g_strdup_printf("[Processor]\n" - "System Type=%s\n" - "CPU Model=%s\n" - "Frequency=%.2fMHz\n" - "BogoMIPS=%.2f\n" - "Byte Order=%s\n", - processor->model_name, - processor->vendor_id, - processor->cpu_mhz, - processor->bogomips, -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian" -#else - "Big Endian" -#endif - ); + Processor *processor = (Processor *)processors->data; + + return g_strdup_printf("[%s]\n" + "%s=%s\n" /* cpu type */ + "%s=%s\n" /* machine */ + "%s=%s\n" /* family */ + "%s=%.2f %s\n" /* frequency */ + "%s=%.2f %s\n" /* bus frequency */ + "%s=%.2f %s\n" /* module frequency */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n", /* byte order */ + _("Processor"), + _("Name"), processor->model_name, + _("Machine"), processor->vendor_id, + _("Family"), processor->family, + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("Bus Frequency"), processor->bus_mhz, _("MHz"), + _("Module Frequency"), processor->mod_mhz, _("MHz"), + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str() + ); } diff --git a/modules/devices/sparc/processor.c b/modules/devices/sparc/processor.c index 594117a7..32c7aa94 100644 --- a/modules/devices/sparc/processor.c +++ b/modules/devices/sparc/processor.c @@ -18,6 +18,7 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" GSList * processor_scan(void) @@ -26,22 +27,23 @@ processor_scan(void) FILE *cpuinfo; gchar buffer[128]; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) - return NULL; + return NULL; processor = g_new0(Processor, 1); while (fgets(buffer, 128, cpuinfo)) { - gchar **tmp = g_strsplit(buffer, ":", 2); + gchar **tmp = g_strsplit(buffer, ":", 2); - if (tmp[0] && tmp[1]) { - tmp[0] = g_strstrip(tmp[0]); - tmp[1] = g_strstrip(tmp[1]); + if (tmp[0] && tmp[1]) { + tmp[0] = g_strstrip(tmp[0]); + tmp[1] = g_strstrip(tmp[1]); - get_str("cpu", processor->model_name); - get_str("fpu", processor->has_fpu); - } - g_strfreev(tmp); + get_str("cpucaps", processor->cpucaps); + get_str("cpu", processor->model_name); + get_str("fpu", processor->has_fpu); + } + g_strfreev(tmp); } fclose(cpuinfo); @@ -51,14 +53,28 @@ processor_scan(void) return g_slist_append(NULL, processor); } +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} + +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); +} + gchar * processor_get_info(GSList *processors) { - Processor *processor = (Processor *)processors->data; - - return g_strdup_printf("[Processor]\n" - "CPU=%s\n" - "FPU=%s\n", - processor->model_name, - processor->has_fpu); + Processor *processor = (Processor *)processors->data; + + return g_strdup_printf("[%s]\n" + "%s=%s\n" /* cpu */ + "%s=%s\n" /* fpu */ + "%s=%s\n" /* byte order */ + "%s=%s\n", /* caps */ + _("Processor"), + _("CPU"), processor->model_name, + _("FPU"), processor->has_fpu, + _("Byte Order"), byte_order_str(), + _("Capabilities"), processor->cpucaps + ); } diff --git a/modules/devices/spd-decode.c b/modules/devices/spd-decode.c index ac1dd52b..2db4895b 100644 --- a/modules/devices/spd-decode.c +++ b/modules/devices/spd-decode.c @@ -11,12 +11,12 @@ * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. @@ -1497,13 +1497,16 @@ void scan_spd_do(void) g_slist_free(dimm_list); g_free(spd_info); - spd_info = g_strdup_printf("[SPD]\n" - "%s\n" - "[$ShellParam$]\n" - "ViewType=1\n" - "ColumnTitle$TextValue=Bank\n" - "ColumnTitle$Extra1=Size\n" - "ColumnTitle$Extra2=Manufacturer\n" - "ColumnTitle$Value=Model\n" "ShowColumnHeaders=true\n", list); + spd_info = g_strdup_printf("[%s]\n" + "%s\n" + "[$ShellParam$]\n" + "ViewType=1\n" + "ColumnTitle$TextValue=%s\n" /* Bank */ + "ColumnTitle$Extra1=%s\n" /* Size */ + "ColumnTitle$Extra2=%s\n" /* Manufacturer */ + "ColumnTitle$Value=%s\n" /* Model */ + "ShowColumnHeaders=true\n", + _("SPD"), list, + _("Bank"), _("Size"), _("Manufacturer"), _("Model") ); g_free(list); } diff --git a/modules/devices/usb.c b/modules/devices/usb.c index 3a93a3b6..e5088bd2 100644 --- a/modules/devices/usb.c +++ b/modules/devices/usb.c @@ -41,51 +41,59 @@ void __scan_usb_sysfs_add_device(gchar * endpoint, int n) version = h_sysfs_read_float(endpoint, "version"); if (!(mxpwr = h_sysfs_read_string(endpoint, "bMaxPower"))) { - mxpwr = g_strdup("0 mA"); + mxpwr = g_strdup_printf("%d %s", 0 , _("mA") ); } if (!(manufacturer = h_sysfs_read_string(endpoint, "manufacturer"))) { - manufacturer = g_strdup("Unknown"); + manufacturer = g_strdup(_("(Unknown)")); } if (!(product = h_sysfs_read_string(endpoint, "product"))) { - if (classid == 9) { - product = g_strdup_printf("USB %.2f Hub", version); - } else { - product = g_strdup_printf("Unknown USB %.2f Device (class %d)", version, classid); - } + if (classid == 9) { + product = g_strdup_printf(_(/*/%.2f is version*/ "USB %.2f Hub"), version); + } else { + product = g_strdup_printf(_("Unknown USB %.2f Device (class %d)"), version, classid); + } } - const gchar *url = vendor_get_url(manufacturer); - if (url) { - tmp = g_strdup_printf("%s (%s)", vendor_get_name(manufacturer), url); - - g_free(manufacturer); - manufacturer = tmp; + const gchar *v_url = vendor_get_url(manufacturer); + const gchar *v_name = vendor_get_name(manufacturer); + gchar *v_str; + if (v_url != NULL) { + v_str = g_strdup_printf("%s (%s)", v_name, v_url); + } else { + v_str = g_strdup_printf("%s", manufacturer); } tmp = g_strdup_printf("USB%d", n); usb_list = h_strdup_cprintf("$%s$%s=\n", usb_list, tmp, product); - strhash = g_strdup_printf("[Device Information]\n" - "Product=%s\n" - "Manufacturer=%s\n" - "Speed=%.2fMbit/s\n" - "Max Current=%s\n" - "[Misc]\n" - "USB Version=%.2f\n" - "Class=0x%x\n" - "Vendor=0x%x\n" - "Product ID=0x%x\n" - "Bus=%d\n", - product, - manufacturer, - speed, - mxpwr, - version, classid, vendor, prodid, bus); + strhash = g_strdup_printf("[%s]\n" + /* Product */ "%s=%s\n" + /* Manufacturer */ "%s=%s\n" + /* Speed */ "%s=%.2f %s\n" + /* Max Current */ "%s=%s\n" + "[%s]\n" + /* USB Version */ "%s=%.2f\n" + /* Class */ "%s=0x%x\n" + /* Vendor */ "%s=0x%x\n" + /* Product ID */ "%s=0x%x\n" + /* Bus */ "%s=%d\n", + _("Device Information"), + _("Product"), product, + _("Manufacturer"), v_str, + _("Speed"), speed, _("Mbit/s"), + _("Max Current"), mxpwr, + _("Misc"), + _("USB Version"), version, + _("Class"), classid, + _("Vendor ID"), vendor, + _("Product ID"), prodid, + _("Bus"), bus); moreinfo_add_with_prefix("DEV", tmp, strhash); g_free(tmp); + g_free(v_str); g_free(manufacturer); g_free(product); g_free(mxpwr); @@ -106,7 +114,7 @@ gboolean __scan_usb_sysfs(void) moreinfo_del_with_prefix("DEV:USB"); g_free(usb_list); } - usb_list = g_strdup("[USB Devices]\n"); + usb_list = g_strdup_printf("[%s]\n", _("USB Devices")); while ((filename = (gchar *) g_dir_read_name(sysfs))) { gchar *endpoint = @@ -145,7 +153,7 @@ gboolean __scan_usb_procfs(void) moreinfo_del_with_prefix("DEV:USB"); g_free(usb_list); } - usb_list = g_strdup("[USB Devices]\n"); + usb_list = g_strdup_printf("[%s]\n", _("USB Devices")); while (fgets(buffer, 128, dev)) { tmp = buffer; @@ -179,50 +187,68 @@ gboolean __scan_usb_procfs(void) if (product && *product == '\0') { g_free(product); if (classid == 9) { - product = g_strdup_printf("USB %.2f Hub", ver); + product = g_strdup_printf(_("USB %.2f Hub"), ver); } else { - product = g_strdup_printf("Unknown USB %.2f Device (class %d)", ver, classid); + product = g_strdup_printf(_("Unknown USB %.2f Device (class %d)"), ver, classid); } } - if (classid == 9) { /* hub */ - usb_list = h_strdup_cprintf("[%s#%d]\n", usb_list, product, n); - } else { /* everything else */ - usb_list = h_strdup_cprintf("$%s$%s=\n", usb_list, tmp, product); - - const gchar *url = vendor_get_url(manuf); - if (url) { - gchar *tmp = g_strdup_printf("%s (%s)", vendor_get_name(manuf), - url); - g_free(manuf); - manuf = tmp; - } - - gchar *strhash = g_strdup_printf("[Device Information]\n" "Product=%s\n", - product); - if (manuf && strlen(manuf)) - strhash = h_strdup_cprintf("Manufacturer=%s\n", strhash, manuf); - - strhash = h_strdup_cprintf("[Port #%d]\n" - "Speed=%.2fMbit/s\n" - "Max Current=%s\n" - "[Misc]\n" - "USB Version=%.2f\n" - "Revision=%.2f\n" - "Class=0x%x\n" - "Vendor=0x%x\n" - "Product ID=0x%x\n" - "Bus=%d\n" "Level=%d\n", - strhash, port, speed, mxpwr, ver, rev, classid, vendor, prodid, bus, level); - - moreinfo_add_with_prefix("DEV", tmp, strhash); - g_free(tmp); - } + if (classid == 9) { /* hub */ + usb_list = h_strdup_cprintf("[%s#%d]\n", usb_list, product, n); + } else { /* everything else */ + usb_list = h_strdup_cprintf("$%s$%s=\n", usb_list, tmp, product); + + EMPIFNULL(manuf); + const gchar *v_url = vendor_get_url(manuf); + const gchar *v_name = vendor_get_name(manuf); + gchar *v_str = NULL; + if (strlen(manuf)) { + if (v_url != NULL) + v_str = g_strdup_printf("%s (%s)", v_name, v_url); + else + v_str = g_strdup_printf("%s", manuf); + } + UNKIFNULL(v_str); + UNKIFNULL(product); + + gchar *strhash = g_strdup_printf("[%s]\n" "%s=%s\n" "%s=%s\n", + _("Device Information"), + _("Product"), product, + _("Manufacturer"), v_str); + + strhash = h_strdup_cprintf("[%s #%d]\n" + /* Speed */ "%s=%.2f %s\n" + /* Max Current */ "%s=%s\n" + "[%s]\n" + /* USB Version */ "%s=%.2f\n" + /* Revision */ "%s=%.2f\n" + /* Class */ "%s=0x%x\n" + /* Vendor */ "%s=0x%x\n" + /* Product ID */ "%s=0x%x\n" + /* Bus */ "%s=%d\n" + /* Level */ "%s=%d\n", + strhash, + _("Port"), port, + _("Speed"), speed, _("Mbit/s"), + _("Max Current"), mxpwr, + _("Misc"), + _("USB Version"), ver, + _("Revision"), rev, + _("Class"), classid, + _("Vendor ID"), vendor, + _("Product ID"), prodid, + _("Bus"), bus, + _("Level"), level); + + moreinfo_add_with_prefix("DEV", tmp, strhash); + g_free(v_str); + g_free(tmp); + } g_free(manuf); g_free(product); - manuf = g_strdup(""); - product = g_strdup(""); + manuf = NULL; + product = NULL; port = classid = 0; } } @@ -274,35 +300,63 @@ void __scan_usb_lsusb_add_device(char *buffer, int bufsize, FILE * lsusb, int us } if (dev_class && strstr(dev_class, "0 (Defined at Interface level)")) { - g_free(dev_class); - if (int_class) { - dev_class = int_class; - } else { - dev_class = g_strdup("Unknown"); - } + g_free(dev_class); + if (int_class) { + dev_class = int_class; + } else { + dev_class = g_strdup(_("(Unknown)")); + } } else - dev_class = g_strdup("Unknown"); + dev_class = g_strdup(_("(Unknown)")); tmp = g_strdup_printf("USB%d", usb_device_number); usb_list = h_strdup_cprintf("$%s$%s=\n", usb_list, tmp, name); - strhash = g_strdup_printf("[Device Information]\n" - "Product=%s\n" - "Manufacturer=%s\n" - "Max Current=%s\n" - "[Misc]\n" - "USB Version=%s\n" - "Class=%s\n" - "Vendor=0x%x\n" - "Product ID=0x%x\n" - "Bus=%d\n", - product ? g_strstrip(product) : "Unknown", - vendor ? g_strstrip(vendor) : "Unknown", - max_power ? g_strstrip(max_power) : "Unknown", - version ? g_strstrip(version) : "Unknown", - dev_class ? g_strstrip(dev_class) : "Unknown", vendor_id, product_id, bus); + const gchar *v_url = vendor_get_url(vendor); + const gchar *v_name = vendor_get_name(vendor); + gchar *v_str; + if (v_url != NULL) { + v_str = g_strdup_printf("%s (%s)", v_name, v_url); + } else { + v_str = g_strdup_printf("%s", g_strstrip(vendor) ); + } + + if (max_power != NULL) { + int mA = atoi(g_strstrip(max_power)); + gchar *trent_steel = g_strdup_printf("%d %s", mA, _("mA")); + g_free(max_power); + max_power = trent_steel; + } + + UNKIFNULL(product); + UNKIFNULL(v_str); + UNKIFNULL(max_power); + UNKIFNULL(version); + UNKIFNULL(dev_class); + + strhash = g_strdup_printf("[%s]\n" + /* Product */ "%s=%s\n" + /* Manufacturer */ "%s=%s\n" + /* Max Current */ "%s=%s\n" + "[%s]\n" + /* USB Version */ "%s=%s\n" + /* Class */ "%s=%s\n" + /* Vendor ID */ "%s=0x%x\n" + /* Product ID */ "%s=0x%x\n" + /* Bus */ "%s=%d\n", + _("Device Information"), + _("Product"), g_strstrip(product), + _("Vendor"), v_str, + _("Max Current"), g_strstrip(max_power), + _("Misc"), + _("USB Version"), g_strstrip(version), + _("Class"), g_strstrip(dev_class), + _("Vendor ID"), vendor_id, + _("Product ID"), product_id, + _("Bus"), bus); moreinfo_add_with_prefix("DEV", tmp, strhash); + g_free(v_str); g_free(vendor); g_free(product); g_free(max_power); @@ -356,25 +410,25 @@ gboolean __scan_usb_lsusb(void) if (usb_list) { moreinfo_del_with_prefix("DEV:USB"); - g_free(usb_list); + g_free(usb_list); } - usb_list = g_strdup("[USB Devices]\n"); + usb_list = g_strdup_printf("[%s]\n", _("USB Devices")); while (fgets(buffer, sizeof(buffer), temp_lsusb)) { if (g_str_has_prefix(buffer, "Bus ")) { __scan_usb_lsusb_add_device(buffer, sizeof(buffer), temp_lsusb, ++usb_device_number); } } - + fclose(temp_lsusb); - + return usb_device_number > 0; } void __scan_usb(void) { if (!__scan_usb_procfs()) { - if (!__scan_usb_sysfs()) { + if (!__scan_usb_sysfs()) { __scan_usb_lsusb(); } } diff --git a/modules/devices/x86/processor.c b/modules/devices/x86/processor.c index 25dc6c4a..ad3c7ca4 100644 --- a/modules/devices/x86/processor.c +++ b/modules/devices/x86/processor.c @@ -18,6 +18,10 @@ #include "hardinfo.h" #include "devices.h" +#include "cpu_util.h" + +#include "x86_data.h" +#include "x86_data.c" /* * This function is partly based on x86cpucaps @@ -148,10 +152,10 @@ static gchar *__cache_get_info_as_string(Processor *processor) for (cache_list = processor->cache; cache_list; cache_list = cache_list->next) { cache = (ProcessorCache *)cache_list->data; - result = h_strdup_cprintf("Level %d (%s)=%d-way set-associative, %d sets, %dKB size\n", + result = h_strdup_cprintf(_("Level %d (%s)=%d-way set-associative, %d sets, %dKB size\n"), result, cache->level, - cache->type, + C_("cache-type", cache->type), cache->ways_of_associativity, cache->number_of_sets, cache->size); @@ -160,6 +164,14 @@ static gchar *__cache_get_info_as_string(Processor *processor) return result; } +/* This is not used directly, but creates translatable strings for + * the type string returned from /sys/.../cache */ +static const char* cache_types[] = { + NC_("cache-type", /*/cache type, as appears in: Level 1 (Data)*/ "Data"), + NC_("cache-type", /*/cache type, as appears in: Level 1 (Instruction)*/ "Instruction"), + NC_("cache-type", /*/cache type, as appears in: Level 2 (Unified)*/ "Unified") +}; + static void __cache_obtain_info(Processor *processor) { ProcessorCache *cache; @@ -214,33 +226,6 @@ fail: g_free(endpoint); } -int processor_has_flag(gchar * strflags, gchar * strflag) -{ - gchar **flags; - gint ret = 0; - if (strflags == NULL || strflag == NULL) - return 0; - flags = g_strsplit(strflags, " ", 0); - ret = g_strv_contains((const gchar * const *)flags, strflag); - g_strfreev(flags); - return ret; -} - -static gint get_cpu_int(const gchar* file, gint cpuid) { - gchar *tmp0 = NULL; - gchar *tmp1 = NULL; - gint ret = 0; - - tmp0 = g_strdup_printf("/sys/devices/system/cpu/cpu%d/%s", cpuid, file); - g_file_get_contents(tmp0, &tmp1, NULL, NULL); - if (tmp1) - ret = atol(tmp1); - - g_free(tmp0); - g_free(tmp1); - return ret; -} - GSList *processor_scan(void) { GSList *procs = NULL, *l = NULL; @@ -248,7 +233,7 @@ GSList *processor_scan(void) FILE *cpuinfo; gchar buffer[512]; - cpuinfo = fopen("/proc/cpuinfo", "r"); + cpuinfo = fopen(PROC_CPUINFO, "r"); if (!cpuinfo) return NULL; @@ -280,6 +265,7 @@ GSList *processor_scan(void) get_str("flags", processor->flags); get_str("bugs", processor->bugs); get_str("power management", processor->pm); + get_str("microcode", processor->microcode); get_int("cache size", processor->cache_size); get_float("cpu MHz", processor->cpu_mhz); get_float("bogomips", processor->bogomips); @@ -290,6 +276,7 @@ GSList *processor_scan(void) get_str("hlt_bug", processor->bug_hlt); get_str("f00f_bug", processor->bug_f00f); get_str("coma_bug", processor->bug_coma); + /* sep_bug? */ get_int("model", processor->model); get_int("cpu family", processor->family); @@ -298,6 +285,8 @@ GSList *processor_scan(void) g_strfreev(tmp); } + fclose(cpuinfo); + /* finish last */ if (processor) procs = g_slist_append(procs, processor); @@ -305,9 +294,17 @@ GSList *processor_scan(void) for (l = procs; l; l = l->next) { processor = (Processor *) l->data; + STRIFNULL(processor->microcode, _("(Not Available)") ); + get_processor_strfamily(processor); __cache_obtain_info(processor); +#define NULLIFNOTYES(f) if (processor->f) if (strcmp(processor->f, "yes") != 0) { g_free(processor->f); processor->f = NULL; } + NULLIFNOTYES(bug_fdiv); + NULLIFNOTYES(bug_hlt); + NULLIFNOTYES(bug_f00f); + NULLIFNOTYES(bug_coma); + if (processor->bugs == NULL || g_strcmp0(processor->bugs, "") == 0) { g_free(processor->bugs); /* make bugs list on old kernels that don't offer one */ @@ -337,291 +334,38 @@ GSList *processor_scan(void) g_strchug(processor->pm); } - /* freq */ - processor->cpukhz_cur = get_cpu_int("cpufreq/scaling_cur_freq", processor->id); - processor->cpukhz_min = get_cpu_int("cpufreq/scaling_min_freq", processor->id); - processor->cpukhz_max = get_cpu_int("cpufreq/scaling_max_freq", processor->id); - if (processor->cpukhz_max) - processor->cpu_mhz = processor->cpukhz_max / 1000; - } - - fclose(cpuinfo); - - return procs; -} - -/* - * Sources: - * - Linux' cpufeature.h - * - http://gentoo-wiki.com/Cpuinfo - * - Intel IA-32 Architecture Software Development Manual - * - https://unix.stackexchange.com/questions/43539/what-do-the-flags-in-proc-cpuinfo-mean - */ -static struct { - char *name, *meaning; -} flag_meaning[] = { - { "3dnow", "3DNow! Technology" }, - { "3dnowext", "Extended 3DNow! Technology" }, - { "fpu", "Floating Point Unit" }, - { "vme", "Virtual 86 Mode Extension" }, - { "de", "Debug Extensions - I/O breakpoints" }, - { "pse", "Page Size Extensions (4MB pages)" }, - { "tsc", "Time Stamp Counter and RDTSC instruction" }, - { "msr", "Model Specific Registers" }, - { "pae", "Physical Address Extensions" }, - { "mce", "Machine Check Architecture" }, - { "cx8", "CMPXCHG8 instruction" }, - { "apic", "Advanced Programmable Interrupt Controller" }, - { "sep", "Fast System Call (SYSENTER/SYSEXIT)" }, - { "mtrr", "Memory Type Range Registers" }, - { "pge", "Page Global Enable" }, - { "mca", "Machine Check Architecture" }, - { "cmov", "Conditional Move instruction" }, - { "pat", "Page Attribute Table" }, - { "pse36", "36bit Page Size Extensions" }, - { "psn", "96 bit Processor Serial Number" }, - { "mmx", "MMX technology" }, - { "mmxext", "Extended MMX Technology" }, - { "cflush", "Cache Flush" }, - { "dtes", "Debug Trace Store" }, - { "fxsr", "FXSAVE and FXRSTOR instructions" }, - { "kni", "Streaming SIMD instructions" }, - { "xmm", "Streaming SIMD instructions" }, - { "ht", "HyperThreading" }, - { "mp", "Multiprocessing Capable" }, - { "sse", "SSE instructions" }, - { "sse2", "SSE2 (WNI) instructions" }, - { "acc", "Automatic Clock Control" }, - { "ia64", "IA64 Instructions" }, - { "syscall", "SYSCALL and SYSEXIT instructions" }, - { "nx", "No-execute Page Protection" }, - { "xd", "Execute Disable" }, - { "clflush", "Cache Line Flush instruction" }, - { "acpi", "Thermal Monitor and Software Controlled Clock" }, - { "dts", "Debug Store" }, - { "ss", "Self Snoop" }, - { "tm", "Thermal Monitor" }, - { "pbe", "Pending Break Enable" }, - { "pb", "Pending Break Enable" }, - { "pn", "Processor serial number" }, - { "ds", "Debug Store" }, - { "xmm2", "Streaming SIMD Extensions-2" }, - { "xmm3", "Streaming SIMD Extensions-3" }, - { "selfsnoop", "CPU self snoop" }, - { "rdtscp", "RDTSCP" }, - { "recovery", "CPU in recovery mode" }, - { "longrun", "Longrun power control" }, - { "lrti", "LongRun table interface" }, - { "cxmmx", "Cyrix MMX extensions" }, - { "k6_mtrr", "AMD K6 nonstandard MTRRs" }, - { "cyrix_arr", "Cyrix ARRs (= MTRRs)" }, - { "centaur_mcr","Centaur MCRs (= MTRRs)" }, - { "constant_tsc","TSC ticks at a constant rate" }, - { "up", "smp kernel running on up" }, - { "fxsave_leak","FXSAVE leaks FOP/FIP/FOP" }, - { "arch_perfmon","Intel Architectural PerfMon" }, - { "pebs", "Precise-Event Based Sampling" }, - { "bts", "Branch Trace Store" }, - { "sync_rdtsc", "RDTSC synchronizes the CPU" }, - { "rep_good", "rep microcode works well on this CPU" }, - { "mwait", "Monitor/Mwait support" }, - { "ds_cpl", "CPL Qualified Debug Store" }, - { "est", "Enhanced SpeedStep" }, - { "tm2", "Thermal Monitor 2" }, - { "cid", "Context ID" }, - { "xtpr", "Send Task Priority Messages" }, - { "xstore", "on-CPU RNG present (xstore insn)" }, - { "xstore_en", "on-CPU RNG enabled" }, - { "xcrypt", "on-CPU crypto (xcrypt insn)" }, - { "xcrypt_en", "on-CPU crypto enabled" }, - { "ace2", "Advanced Cryptography Engine v2" }, - { "ace2_en", "ACE v2 enabled" }, - { "phe", "PadLock Hash Engine" }, - { "phe_en", "PHE enabled" }, - { "pmm", "PadLock Montgomery Multiplier" }, - { "pmm_en", "PMM enabled" }, - { "lahf_lm", "LAHF/SAHF in long mode" }, - { "cmp_legacy", "HyperThreading not valid" }, - { "lm", "LAHF/SAHF in long mode" }, - { "ds_cpl", "CPL Qualified Debug Store" }, - { "vmx", "Virtualization support (Intel)" }, - { "svm", "Virtualization support (AMD)" }, - { "est", "Enhanced SpeedStep" }, - { "tm2", "Thermal Monitor 2" }, - { "ssse3", "Supplemental Streaming SIMD Extension 3" }, - { "cx16", "CMPXCHG16B instruction" }, - { "xptr", "Send Task Priority Messages" }, - { "pebs", "Precise Event Based Sampling" }, - { "bts", "Branch Trace Store" }, - { "ida", "Intel Dynamic Acceleration" }, - { "arch_perfmon","Intel Architectural PerfMon" }, - { "pni", "Streaming SIMD Extension 3 (Prescott New Instruction)" }, - { "rep_good", "rep microcode works well on this CPU" }, - { "ts", "Thermal Sensor" }, - { "sse3", "Streaming SIMD Extension 3" }, - { "sse4", "Streaming SIMD Extension 4" }, - { "tni", "Tejas New Instruction" }, - { "nni", "Nehalem New Instruction" }, - { "tpr", "Task Priority Register" }, - { "vid", "Voltage Identifier" }, - { "fid", "Frequency Identifier" }, - { "dtes64", "64-bit Debug Store" }, - { "monitor", "Monitor/Mwait support" }, - { "sse4_1", "Streaming SIMD Extension 4.1" }, - { "sse4_2", "Streaming SIMD Extension 4.2" }, - { "nopl", "NOPL instructions" }, - { "cxmmx", "Cyrix MMX extensions" }, - { "xtopology", "CPU topology enum extensions" }, - { "nonstop_tsc", "TSC does not stop in C states" }, - { "eagerfpu", "Non lazy FPU restor" }, - { "pclmulqdq", "Perform a Carry-Less Multiplication of Quadword instruction" }, - { "smx", "Safer mode: TXT (TPM support)" }, - { "pdcm", "Performance capabilities" }, - { "pcid", "Process Context Identifiers" }, - { "x2apic", "x2APIC" }, - { "popcnt", "Set bit count instructions" }, - { "aes", "Advanced Encryption Standard" }, - { "aes-ni", "Advanced Encryption Standard (New Instructions)" }, - { "xsave", "Save Processor Extended States" }, - { "avx", "Advanced Vector Instructions" }, - { NULL, NULL }, -}; - -static struct { - char *name, *meaning; -} bug_meaning[] = { - { "f00f", "Intel F00F bug" }, - { "fdiv", "FPU FDIV" }, - { "coma", "Cyrix 6x86 coma" }, - { "tlb_mmatch", "AMD Erratum 383" }, - { "apic_c1e", "AMD Erratum 400" }, - { "11ap", "Bad local APIC aka 11AP" }, - { "fxsave_leak", "FXSAVE leaks FOP/FIP/FOP" }, - { "clflush_monitor", "AAI65, CLFLUSH required before MONITOR" }, - { "sysret_ss_attrs", "SYSRET doesn't fix up SS attrs" }, - { "espfix", "IRET to 16-bit SS corrupts ESP/RSP high bits" }, - { "null_seg", "Nulling a selector preserves the base" }, /* see: detect_null_seg_behavior() */ - { "swapgs_fence","SWAPGS without input dep on GS" }, - { "monitor", "IPI required to wake up remote CPU" }, - { "amd_e400", "AMD Erratum 400" }, - { NULL, NULL }, -}; - -/* from arch/x86/kernel/cpu/powerflags.h */ -static struct { - char *name, *meaning; -} pm_meaning[] = { - { "ts", "temperature sensor" }, - { "fid", "frequency id control" }, - { "vid", "voltage id control" }, - { "ttp", "thermal trip" }, - { "tm", "hardware thermal control" }, - { "stc", "software thermal control" }, - { "100mhzsteps", "100 MHz multiplier control" }, - { "hwpstate", "hardware P-state control" }, -/* { "", "tsc invariant mapped to constant_tsc" }, */ - { "cpb", "core performance boost" }, - { "eff_freq_ro", "Readonly aperf/mperf" }, - { "proc_feedback", "processor feedback interface" }, - { "acc_power", "accumulated power mechanism" }, - { NULL, NULL }, -}; - -GHashTable *cpu_flags = NULL; - -static void -populate_cpu_flags_list_internal() -{ - int i; - - DEBUG("using internal CPU flags database"); + /* topo & freq */ + processor->cpufreq = cpufreq_new(processor->id); + processor->cputopo = cputopo_new(processor->id); - for (i = 0; flag_meaning[i].name != NULL; i++) { - g_hash_table_insert(cpu_flags, flag_meaning[i].name, - flag_meaning[i].meaning); + if (processor->cpufreq->cpukhz_max) + processor->cpu_mhz = processor->cpufreq->cpukhz_max / 1000; } - for (i = 0; bug_meaning[i].name != NULL; i++) { - g_hash_table_insert(cpu_flags, bug_meaning[i].name, - bug_meaning[i].meaning); - } - for (i = 0; pm_meaning[i].name != NULL; i++) { - g_hash_table_insert(cpu_flags, pm_meaning[i].name, - pm_meaning[i].meaning); - } -} - -void cpu_flags_init(void) -{ - gint i; - gchar *path; - - cpu_flags = g_hash_table_new(g_str_hash, g_str_equal); - - path = g_build_filename(g_get_home_dir(), ".hardinfo", "cpuflags.conf", NULL); - if (!g_file_test(path, G_FILE_TEST_EXISTS)) { - populate_cpu_flags_list_internal(); - } else { - GKeyFile *flags_file; - DEBUG("using %s as CPU flags database", path); - - flags_file = g_key_file_new(); - if (g_key_file_load_from_file(flags_file, path, 0, NULL)) { - gchar **flag_keys; - - flag_keys = g_key_file_get_keys(flags_file, "flags", - NULL, NULL); - if (!flag_keys) { - DEBUG("error while using %s as CPU flags database, falling back to internal", - path); - populate_cpu_flags_list_internal(); - } else { - for (i = 0; flag_keys[i]; i++) { - gchar *meaning; - - meaning = g_key_file_get_string(flags_file, "flags", - flag_keys[i], NULL); - - g_hash_table_insert(cpu_flags, g_strdup(flag_keys[i]), meaning); - - /* can't free meaning */ - } - - g_strfreev(flag_keys); - } - } - - g_key_file_free(flags_file); - } - - g_free(path); + return procs; } -gchar *processor_get_capabilities_from_flags(gchar * strflags) +gchar *processor_get_capabilities_from_flags(gchar *strflags, gchar *lookup_prefix) { - /* FIXME: - * - Separate between processor capabilities, additional instructions and whatnot. - */ gchar **flags, **old; + gchar tmp_flag[64] = ""; + const gchar *meaning; gchar *tmp = NULL; gint j = 0; - if (!cpu_flags) { - cpu_flags_init(); - } - flags = g_strsplit(strflags, " ", 0); old = flags; while (flags[j]) { - gchar *meaning = g_hash_table_lookup(cpu_flags, flags[j]); + sprintf(tmp_flag, "%s%s", lookup_prefix, flags[j]); + meaning = x86_flag_meaning(tmp_flag); - if (meaning) { - tmp = h_strdup_cprintf("%s=%s\n", tmp, flags[j], meaning); + if (meaning) { + tmp = h_strdup_cprintf("%s=%s\n", tmp, flags[j], meaning); } else { - tmp = h_strdup_cprintf("%s=\n", tmp, flags[j]); + tmp = h_strdup_cprintf("%s=\n", tmp, flags[j]); } - j++; + j++; } if (tmp == NULL || g_strcmp0(tmp, "") == 0) tmp = g_strdup_printf("%s=%s\n", "empty", _("Empty List")); @@ -632,96 +376,120 @@ gchar *processor_get_capabilities_from_flags(gchar * strflags) gchar *processor_get_detailed_info(Processor * processor) { - gchar *tmp_flags, *tmp_bugs, *tmp_pm, *ret, *cache_info; + gchar *tmp_flags, *tmp_bugs, *tmp_pm, *tmp_cpufreq, *tmp_topology, *ret, *cache_info; - tmp_flags = processor_get_capabilities_from_flags(processor->flags); - tmp_bugs = processor_get_capabilities_from_flags(processor->bugs); - tmp_pm = processor_get_capabilities_from_flags(processor->pm); + tmp_flags = processor_get_capabilities_from_flags(processor->flags, ""); + tmp_bugs = processor_get_capabilities_from_flags(processor->bugs, "bug:"); + tmp_pm = processor_get_capabilities_from_flags(processor->pm, "pm:"); cache_info = __cache_get_info_as_string(processor); - ret = g_strdup_printf(_("[Processor]\n" - "Name=%s\n" - "Family, model, stepping=%d, %d, %d (%s)\n" - "Vendor=%s\n" - "[Configuration]\n" - "Cache Size=%dkb\n" - "Frequency=%.2fMHz\n" - "BogoMIPS=%.2f\n" - "Byte Order=%s\n" - "[Frequency Scaling]\n" - "Minimum=%d kHz\n" - "Maximum=%d kHz\n" - "Current=%d kHz\n" - "[Features]\n" - "Has FPU=%s\n" - "[Cache]\n" - "%s\n" - "[Power Management]\n" - "%s" - "[Bugs]\n" - "%s" - "[Capabilities]\n" - "%s"), - processor->model_name, - processor->family, - processor->model, - processor->stepping, - processor->strmodel, - vendor_get_name(processor->vendor_id), - processor->cache_size, - processor->cpu_mhz, processor->bogomips, -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - "Little Endian", -#else - "Big Endian", -#endif - processor->cpukhz_min, - processor->cpukhz_max, - processor->cpukhz_cur, - processor->has_fpu ? processor->has_fpu : "no", - cache_info, - tmp_pm, tmp_bugs, tmp_flags); + tmp_topology = cputopo_section_str(processor->cputopo); + tmp_cpufreq = cpufreq_section_str(processor->cpufreq); + + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%d, %d, %d (%s)\n" /* family, model, stepping (decoded name) */ + "%s=%s\n" /* vendor */ + "%s=%s\n" /* microcode */ + "[%s]\n" /* configuration */ + "%s=%d %s\n" /* cache size (from cpuinfo) */ + "%s=%.2f %s\n" /* frequency */ + "%s=%.2f\n" /* bogomips */ + "%s=%s\n" /* byte order */ + "%s" /* topology */ + "%s" /* frequency scaling */ + "[%s]\n" /* cache */ + "%s\n" + "[%s]\n" /* pm */ + "%s" + "[%s]\n" /* bugs */ + "%s" + "[%s]\n" /* flags */ + "%s", + _("Processor"), + _("Model Name"), processor->model_name, + _("Family, model, stepping"), + processor->family, + processor->model, + processor->stepping, + processor->strmodel, + _("Vendor"), vendor_get_name(processor->vendor_id), + _("Microcode Version"), processor->microcode, + _("Configuration"), + _("Cache Size"), processor->cache_size, _("kb"), + _("Frequency"), processor->cpu_mhz, _("MHz"), + _("BogoMips"), processor->bogomips, + _("Byte Order"), byte_order_str(), + tmp_topology, + tmp_cpufreq, + _("Cache"), cache_info, + _("Power Management"), tmp_pm, + _("Bug Workarounds"), tmp_bugs, + _("Capabilities"), tmp_flags ); g_free(tmp_flags); g_free(tmp_bugs); g_free(tmp_pm); g_free(cache_info); + g_free(tmp_cpufreq); + g_free(tmp_topology); + return ret; +} + +gchar *processor_name(GSList * processors) { + return processor_name_default(processors); +} +gchar *processor_describe(GSList * processors) { + return processor_describe_default(processors); +} + +gchar *processor_meta(GSList * processors) { + gchar *meta_cpu_name = processor_name(processors); + gchar *meta_cpu_desc = processor_describe(processors); + gchar *ret = NULL; + UNKIFNULL(meta_cpu_desc); + ret = g_strdup_printf("[%s]\n" + "%s=%s\n" + "%s=%s\n", + _("Package Information"), + _("Name"), meta_cpu_name, + _("Description"), meta_cpu_desc); + g_free(meta_cpu_desc); return ret; } gchar *processor_get_info(GSList * processors) { Processor *processor; + gchar *ret, *tmp, *hashkey; + gchar *meta; /* becomes owned by more_info? no need to free? */ + GSList *l; - if (g_slist_length(processors) > 1) { - gchar *ret, *tmp, *hashkey; - GSList *l; - - tmp = g_strdup(""); + tmp = g_strdup_printf("$CPU_META$%s=\n", _("Package Information") ); - for (l = processors; l; l = l->next) { - processor = (Processor *) l->data; + meta = processor_meta(processors); + moreinfo_add_with_prefix("DEV", "CPU_META", meta); - tmp = g_strdup_printf(_("%s$CPU%d$%s=%.2fMHz\n"), - tmp, processor->id, - processor->model_name, - processor->cpu_mhz); - - hashkey = g_strdup_printf("CPU%d", processor->id); - moreinfo_add_with_prefix("DEV", hashkey, - processor_get_detailed_info(processor)); - g_free(hashkey); - } + for (l = processors; l; l = l->next) { + processor = (Processor *) l->data; - ret = g_strdup_printf("[$ShellParam$]\n" - "ViewType=1\n" - "[Processors]\n" - "%s", tmp); - g_free(tmp); + tmp = g_strdup_printf("%s$CPU%d$%s=%.2f %s\n", + tmp, processor->id, + processor->model_name, + processor->cpu_mhz, _("MHz")); - return ret; + hashkey = g_strdup_printf("CPU%d", processor->id); + moreinfo_add_with_prefix("DEV", hashkey, + processor_get_detailed_info(processor)); + g_free(hashkey); } - processor = (Processor *) processors->data; - return processor_get_detailed_info(processor); + ret = g_strdup_printf("[$ShellParam$]\n" + "ViewType=1\n" + "[Processors]\n" + "%s", tmp); + g_free(tmp); + + return ret; } + diff --git a/modules/devices/x86/x86_data.c b/modules/devices/x86/x86_data.c new file mode 100644 index 00000000..ebd434bb --- /dev/null +++ b/modules/devices/x86/x86_data.c @@ -0,0 +1,344 @@ +/* + * rpiz - https://github.com/bp0/rpiz + * Copyright (C) 2017 Burt P. <pburt0@gmail.com> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include "x86_data.h" + +#ifndef C_ +#define C_(Ctx, String) String +#endif +#ifndef NC_ +#define NC_(Ctx, String) String +#endif + +/* sources: + * https://unix.stackexchange.com/a/43540 + * https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git/tree/arch/x86/include/asm/cpufeatures.h?id=refs/tags/v4.9 + * hardinfo: modules/devices/x86/processor.c + */ +static struct { + char *name, *meaning; +} tab_flag_meaning[] = { +/* Intel-defined CPU features, CPUID level 0x00000001 (edx) + * See also Wikipedia and table 2-27 in Intel Advanced Vector Extensions Programming Reference */ + { "fpu", NC_("x86-flag", /*/flag:fpu*/ "Onboard FPU (floating point support)") }, + { "vme", NC_("x86-flag", /*/flag:vme*/ "Virtual 8086 mode enhancements") }, + { "de", NC_("x86-flag", /*/flag:de*/ "Debugging Extensions (CR4.DE)") }, + { "pse", NC_("x86-flag", /*/flag:pse*/ "Page Size Extensions (4MB memory pages)") }, + { "tsc", NC_("x86-flag", /*/flag:tsc*/ "Time Stamp Counter (RDTSC)") }, + { "msr", NC_("x86-flag", /*/flag:msr*/ "Model-Specific Registers (RDMSR, WRMSR)") }, + { "pae", NC_("x86-flag", /*/flag:pae*/ "Physical Address Extensions (support for more than 4GB of RAM)") }, + { "mce", NC_("x86-flag", /*/flag:mce*/ "Machine Check Exception") }, + { "cx8", NC_("x86-flag", /*/flag:cx8*/ "CMPXCHG8 instruction (64-bit compare-and-swap)") }, + { "apic", NC_("x86-flag", /*/flag:apic*/ "Onboard APIC") }, + { "sep", NC_("x86-flag", /*/flag:sep*/ "SYSENTER/SYSEXIT") }, + { "mtrr", NC_("x86-flag", /*/flag:mtrr*/ "Memory Type Range Registers") }, + { "pge", NC_("x86-flag", /*/flag:pge*/ "Page Global Enable (global bit in PDEs and PTEs)") }, + { "mca", NC_("x86-flag", /*/flag:mca*/ "Machine Check Architecture") }, + { "cmov", NC_("x86-flag", /*/flag:cmov*/ "CMOV instructions (conditional move) (also FCMOV)") }, + { "pat", NC_("x86-flag", /*/flag:pat*/ "Page Attribute Table") }, + { "pse36", NC_("x86-flag", /*/flag:pse36*/ "36-bit PSEs (huge pages)") }, + { "pn", NC_("x86-flag", /*/flag:pn*/ "Processor serial number") }, + { "clflush", NC_("x86-flag", /*/flag:clflush*/ "Cache Line Flush instruction") }, + { "dts", NC_("x86-flag", /*/flag:dts*/ "Debug Store (buffer for debugging and profiling instructions), or alternately: digital thermal sensor") }, + { "acpi", NC_("x86-flag", /*/flag:acpi*/ "ACPI via MSR (temperature monitoring and clock speed modulation)") }, + { "mmx", NC_("x86-flag", /*/flag:mmx*/ "Multimedia Extensions") }, + { "fxsr", NC_("x86-flag", /*/flag:fxsr*/ "FXSAVE/FXRSTOR, CR4.OSFXSR") }, + { "sse", NC_("x86-flag", /*/flag:sse*/ "Intel SSE vector instructions") }, + { "sse2", NC_("x86-flag", /*/flag:sse2*/ "SSE2") }, + { "ss", NC_("x86-flag", /*/flag:ss*/ "CPU self snoop") }, + { "ht", NC_("x86-flag", /*/flag:ht*/ "Hyper-Threading") }, + { "tm", NC_("x86-flag", /*/flag:tm*/ "Automatic clock control (Thermal Monitor)") }, + { "ia64", NC_("x86-flag", /*/flag:ia64*/ "Intel Itanium Architecture 64-bit (not to be confused with Intel's 64-bit x86 architecture with flag x86-64 or \"AMD64\" bit indicated by flag lm)") }, + { "pbe", NC_("x86-flag", /*/flag:pbe*/ "Pending Break Enable (PBE# pin) wakeup support") }, +/* AMD-defined CPU features, CPUID level 0x80000001 + * See also Wikipedia and table 2-23 in Intel Advanced Vector Extensions Programming Reference */ + { "syscall", NC_("x86-flag", /*/flag:syscall*/ "SYSCALL (Fast System Call) and SYSRET (Return From Fast System Call)") }, + { "mp", NC_("x86-flag", /*/flag:mp*/ "Multiprocessing Capable.") }, + { "nx", NC_("x86-flag", /*/flag:nx*/ "Execute Disable") }, + { "mmxext", NC_("x86-flag", /*/flag:mmxext*/ "AMD MMX extensions") }, + { "fxsr_opt", NC_("x86-flag", /*/flag:fxsr_opt*/ "FXSAVE/FXRSTOR optimizations") }, + { "pdpe1gb", NC_("x86-flag", /*/flag:pdpe1gb*/ "One GB pages (allows hugepagesz=1G)") }, + { "rdtscp", NC_("x86-flag", /*/flag:rdtscp*/ "Read Time-Stamp Counter and Processor ID") }, + { "lm", NC_("x86-flag", /*/flag:lm*/ "Long Mode (x86-64: amd64, also known as Intel 64, i.e. 64-bit capable)") }, + { "3dnow", NC_("x86-flag", /*/flag:3dnow*/ "3DNow! (AMD vector instructions, competing with Intel's SSE1)") }, + { "3dnowext", NC_("x86-flag", /*/flag:3dnowext*/ "AMD 3DNow! extensions") }, +/* Transmeta-defined CPU features, CPUID level 0x80860001 */ + { "recovery", NC_("x86-flag", /*/flag:recovery*/ "CPU in recovery mode") }, + { "longrun", NC_("x86-flag", /*/flag:longrun*/ "Longrun power control") }, + { "lrti", NC_("x86-flag", /*/flag:lrti*/ "LongRun table interface") }, +/* Other features, Linux-defined mapping */ + { "cxmmx", NC_("x86-flag", /*/flag:cxmmx*/ "Cyrix MMX extensions") }, + { "k6_mtrr", NC_("x86-flag", /*/flag:k6_mtrr*/ "AMD K6 nonstandard MTRRs") }, + { "cyrix_arr", NC_("x86-flag", /*/flag:cyrix_arr*/ "Cyrix ARRs (= MTRRs)") }, + { "centaur_mcr", NC_("x86-flag", /*/flag:centaur_mcr*/ "Centaur MCRs (= MTRRs)") }, + { "constant_tsc", NC_("x86-flag", /*/flag:constant_tsc*/ "TSC ticks at a constant rate") }, + { "up", NC_("x86-flag", /*/flag:up*/ "SMP kernel running on UP") }, + { "art", NC_("x86-flag", /*/flag:art*/ "Always-Running Timer") }, + { "arch_perfmon", NC_("x86-flag", /*/flag:arch_perfmon*/ "Intel Architectural PerfMon") }, + { "pebs", NC_("x86-flag", /*/flag:pebs*/ "Precise-Event Based Sampling") }, + { "bts", NC_("x86-flag", /*/flag:bts*/ "Branch Trace Store") }, + { "rep_good", NC_("x86-flag", /*/flag:rep_good*/ "rep microcode works well") }, + { "acc_power", NC_("x86-flag", /*/flag:acc_power*/ "AMD accumulated power mechanism") }, + { "nopl", NC_("x86-flag", /*/flag:nopl*/ "The NOPL (0F 1F) instructions") }, + { "xtopology", NC_("x86-flag", /*/flag:xtopology*/ "cpu topology enum extensions") }, + { "tsc_reliable", NC_("x86-flag", /*/flag:tsc_reliable*/ "TSC is known to be reliable") }, + { "nonstop_tsc", NC_("x86-flag", /*/flag:nonstop_tsc*/ "TSC does not stop in C states") }, + { "extd_apicid", NC_("x86-flag", /*/flag:extd_apicid*/ "has extended APICID (8 bits)") }, + { "amd_dcm", NC_("x86-flag", /*/flag:amd_dcm*/ "multi-node processor") }, + { "aperfmperf", NC_("x86-flag", /*/flag:aperfmperf*/ "APERFMPERF") }, + { "eagerfpu", NC_("x86-flag", /*/flag:eagerfpu*/ "Non lazy FPU restore") }, + { "nonstop_tsc_s3", NC_("x86-flag", /*/flag:nonstop_tsc_s3*/ "TSC doesn't stop in S3 state") }, + { "mce_recovery", NC_("x86-flag", /*/flag:mce_recovery*/ "CPU has recoverable machine checks") }, +/* Intel-defined CPU features, CPUID level 0x00000001 (ecx) + * See also Wikipedia and table 2-26 in Intel Advanced Vector Extensions Programming Reference */ + { "pni", NC_("x86-flag", /*/flag:pni*/ "SSE-3 (\"Prescott New Instructions\")") }, + { "pclmulqdq", NC_("x86-flag", /*/flag:pclmulqdq*/ "Perform a Carry-Less Multiplication of Quadword instruction - accelerator for GCM)") }, + { "dtes64", NC_("x86-flag", /*/flag:dtes64*/ "64-bit Debug Store") }, + { "monitor", NC_("x86-flag", /*/flag:monitor*/ "Monitor/Mwait support (Intel SSE3 supplements)") }, + { "ds_cpl", NC_("x86-flag", /*/flag:ds_cpl*/ "CPL Qual. Debug Store") }, + { "vmx", NC_("x86-flag", /*/flag:vmx*/ "Hardware virtualization, Intel VMX") }, + { "smx", NC_("x86-flag", /*/flag:smx*/ "Safer mode TXT (TPM support)") }, + { "est", NC_("x86-flag", /*/flag:est*/ "Enhanced SpeedStep") }, + { "tm2", NC_("x86-flag", /*/flag:tm2*/ "Thermal Monitor 2") }, + { "ssse3", NC_("x86-flag", /*/flag:ssse3*/ "Supplemental SSE-3") }, + { "cid", NC_("x86-flag", /*/flag:cid*/ "Context ID") }, + { "sdbg", NC_("x86-flag", /*/flag:sdbg*/ "silicon debug") }, + { "fma", NC_("x86-flag", /*/flag:fma*/ "Fused multiply-add") }, + { "cx16", NC_("x86-flag", /*/flag:cx16*/ "CMPXCHG16B") }, + { "xtpr", NC_("x86-flag", /*/flag:xtpr*/ "Send Task Priority Messages") }, + { "pdcm", NC_("x86-flag", /*/flag:pdcm*/ "Performance Capabilities") }, + { "pcid", NC_("x86-flag", /*/flag:pcid*/ "Process Context Identifiers") }, + { "dca", NC_("x86-flag", /*/flag:dca*/ "Direct Cache Access") }, + { "sse4_1", NC_("x86-flag", /*/flag:sse4_1*/ "SSE-4.1") }, + { "sse4_2", NC_("x86-flag", /*/flag:sse4_2*/ "SSE-4.2") }, + { "x2apic", NC_("x86-flag", /*/flag:x2apic*/ "x2APIC") }, + { "movbe", NC_("x86-flag", /*/flag:movbe*/ "Move Data After Swapping Bytes instruction") }, + { "popcnt", NC_("x86-flag", /*/flag:popcnt*/ "Return the Count of Number of Bits Set to 1 instruction (Hamming weight, i.e. bit count)") }, + { "tsc_deadline_timer", NC_("x86-flag", /*/flag:tsc_deadline_timer*/ "Tsc deadline timer") }, + { "aes/aes-ni", NC_("x86-flag", /*/flag:aes/aes-ni*/ "Advanced Encryption Standard (New Instructions)") }, + { "xsave", NC_("x86-flag", /*/flag:xsave*/ "Save Processor Extended States: also provides XGETBY,XRSTOR,XSETBY") }, + { "avx", NC_("x86-flag", /*/flag:avx*/ "Advanced Vector Extensions") }, + { "f16c", NC_("x86-flag", /*/flag:f16c*/ "16-bit fp conversions (CVT16)") }, + { "rdrand", NC_("x86-flag", /*/flag:rdrand*/ "Read Random Number from hardware random number generator instruction") }, + { "hypervisor", NC_("x86-flag", /*/flag:hypervisor*/ "Running on a hypervisor") }, +/* VIA/Cyrix/Centaur-defined CPU features, CPUID level 0xC0000001 */ + { "rng", NC_("x86-flag", /*/flag:rng*/ "Random Number Generator present (xstore)") }, + { "rng_en", NC_("x86-flag", /*/flag:rng_en*/ "Random Number Generator enabled") }, + { "ace", NC_("x86-flag", /*/flag:ace*/ "on-CPU crypto (xcrypt)") }, + { "ace_en", NC_("x86-flag", /*/flag:ace_en*/ "on-CPU crypto enabled") }, + { "ace2", NC_("x86-flag", /*/flag:ace2*/ "Advanced Cryptography Engine v2") }, + { "ace2_en", NC_("x86-flag", /*/flag:ace2_en*/ "ACE v2 enabled") }, + { "phe", NC_("x86-flag", /*/flag:phe*/ "PadLock Hash Engine") }, + { "phe_en", NC_("x86-flag", /*/flag:phe_en*/ "PHE enabled") }, + { "pmm", NC_("x86-flag", /*/flag:pmm*/ "PadLock Montgomery Multiplier") }, + { "pmm_en", NC_("x86-flag", /*/flag:pmm_en*/ "PMM enabled") }, +/* More extended AMD flags: CPUID level 0x80000001, ecx */ + { "lahf_lm", NC_("x86-flag", /*/flag:lahf_lm*/ "Load AH from Flags (LAHF) and Store AH into Flags (SAHF) in long mode") }, + { "cmp_legacy", NC_("x86-flag", /*/flag:cmp_legacy*/ "If yes HyperThreading not valid") }, + { "svm", NC_("x86-flag", /*/flag:svm*/ "\"Secure virtual machine\": AMD-V") }, + { "extapic", NC_("x86-flag", /*/flag:extapic*/ "Extended APIC space") }, + { "cr8_legacy", NC_("x86-flag", /*/flag:cr8_legacy*/ "CR8 in 32-bit mode") }, + { "abm", NC_("x86-flag", /*/flag:abm*/ "Advanced Bit Manipulation") }, + { "sse4a", NC_("x86-flag", /*/flag:sse4a*/ "SSE-4A") }, + { "misalignsse", NC_("x86-flag", /*/flag:misalignsse*/ "indicates if a general-protection exception (#GP) is generated when some legacy SSE instructions operate on unaligned data. Also depends on CR0 and Alignment Checking bit") }, + { "3dnowprefetch", NC_("x86-flag", /*/flag:3dnowprefetch*/ "3DNow prefetch instructions") }, + { "osvw", NC_("x86-flag", /*/flag:osvw*/ "indicates OS Visible Workaround, which allows the OS to work around processor errata.") }, + { "ibs", NC_("x86-flag", /*/flag:ibs*/ "Instruction Based Sampling") }, + { "xop", NC_("x86-flag", /*/flag:xop*/ "extended AVX instructions") }, + { "skinit", NC_("x86-flag", /*/flag:skinit*/ "SKINIT/STGI instructions") }, + { "wdt", NC_("x86-flag", /*/flag:wdt*/ "Watchdog timer") }, + { "lwp", NC_("x86-flag", /*/flag:lwp*/ "Light Weight Profiling") }, + { "fma4", NC_("x86-flag", /*/flag:fma4*/ "4 operands MAC instructions") }, + { "tce", NC_("x86-flag", /*/flag:tce*/ "translation cache extension") }, + { "nodeid_msr", NC_("x86-flag", /*/flag:nodeid_msr*/ "NodeId MSR") }, + { "tbm", NC_("x86-flag", /*/flag:tbm*/ "Trailing Bit Manipulation") }, + { "topoext", NC_("x86-flag", /*/flag:topoext*/ "Topology Extensions CPUID leafs") }, + { "perfctr_core", NC_("x86-flag", /*/flag:perfctr_core*/ "Core Performance Counter Extensions") }, + { "perfctr_nb", NC_("x86-flag", /*/flag:perfctr_nb*/ "NB Performance Counter Extensions") }, + { "bpext", NC_("x86-flag", /*/flag:bpext*/ "data breakpoint extension") }, + { "ptsc", NC_("x86-flag", /*/flag:ptsc*/ "performance time-stamp counter") }, + { "perfctr_l2", NC_("x86-flag", /*/flag:perfctr_l2*/ "L2 Performance Counter Extensions") }, + { "mwaitx", NC_("x86-flag", /*/flag:mwaitx*/ "MWAIT extension (MONITORX/MWAITX)") }, +/* Auxiliary flags: Linux defined - For features scattered in various CPUID levels */ + { "cpb", NC_("x86-flag", /*/flag:cpb*/ "AMD Core Performance Boost") }, + { "epb", NC_("x86-flag", /*/flag:epb*/ "IA32_ENERGY_PERF_BIAS support") }, + { "hw_pstate", NC_("x86-flag", /*/flag:hw_pstate*/ "AMD HW-PState") }, + { "proc_feedback", NC_("x86-flag", /*/flag:proc_feedback*/ "AMD ProcFeedbackInterface") }, + { "intel_pt", NC_("x86-flag", /*/flag:intel_pt*/ "Intel Processor Tracing") }, +/* Virtualization flags: Linux defined */ + { "tpr_shadow", NC_("x86-flag", /*/flag:tpr_shadow*/ "Intel TPR Shadow") }, + { "vnmi", NC_("x86-flag", /*/flag:vnmi*/ "Intel Virtual NMI") }, + { "flexpriority", NC_("x86-flag", /*/flag:flexpriority*/ "Intel FlexPriority") }, + { "ept", NC_("x86-flag", /*/flag:ept*/ "Intel Extended Page Table") }, + { "vpid", NC_("x86-flag", /*/flag:vpid*/ "Intel Virtual Processor ID") }, + { "vmmcall", NC_("x86-flag", /*/flag:vmmcall*/ "prefer VMMCALL to VMCALL") }, +/* Intel-defined CPU features, CPUID level 0x00000007:0 (ebx) */ + { "fsgsbase", NC_("x86-flag", /*/flag:fsgsbase*/ "{RD/WR}{FS/GS}BASE instructions") }, + { "tsc_adjust", NC_("x86-flag", /*/flag:tsc_adjust*/ "TSC adjustment MSR") }, + { "bmi1", NC_("x86-flag", /*/flag:bmi1*/ "1st group bit manipulation extensions") }, + { "hle", NC_("x86-flag", /*/flag:hle*/ "Hardware Lock Elision") }, + { "avx2", NC_("x86-flag", /*/flag:avx2*/ "AVX2 instructions") }, + { "smep", NC_("x86-flag", /*/flag:smep*/ "Supervisor Mode Execution Protection") }, + { "bmi2", NC_("x86-flag", /*/flag:bmi2*/ "2nd group bit manipulation extensions") }, + { "erms", NC_("x86-flag", /*/flag:erms*/ "Enhanced REP MOVSB/STOSB") }, + { "invpcid", NC_("x86-flag", /*/flag:invpcid*/ "Invalidate Processor Context ID") }, + { "rtm", NC_("x86-flag", /*/flag:rtm*/ "Restricted Transactional Memory") }, + { "cqm", NC_("x86-flag", /*/flag:cqm*/ "Cache QoS Monitoring") }, + { "mpx", NC_("x86-flag", /*/flag:mpx*/ "Memory Protection Extension") }, + { "avx512f", NC_("x86-flag", /*/flag:avx512f*/ "AVX-512 foundation") }, + { "avx512dq", NC_("x86-flag", /*/flag:avx512dq*/ "AVX-512 Double/Quad instructions") }, + { "rdseed", NC_("x86-flag", /*/flag:rdseed*/ "The RDSEED instruction") }, + { "adx", NC_("x86-flag", /*/flag:adx*/ "The ADCX and ADOX instructions") }, + { "smap", NC_("x86-flag", /*/flag:smap*/ "Supervisor Mode Access Prevention") }, + { "clflushopt", NC_("x86-flag", /*/flag:clflushopt*/ "CLFLUSHOPT instruction") }, + { "clwb", NC_("x86-flag", /*/flag:clwb*/ "CLWB instruction") }, + { "avx512pf", NC_("x86-flag", /*/flag:avx512pf*/ "AVX-512 Prefetch") }, + { "avx512er", NC_("x86-flag", /*/flag:avx512er*/ "AVX-512 Exponential and Reciprocal") }, + { "avx512cd", NC_("x86-flag", /*/flag:avx512cd*/ "AVX-512 Conflict Detection") }, + { "sha_ni", NC_("x86-flag", /*/flag:sha_ni*/ "SHA1/SHA256 Instruction Extensions") }, + { "avx512bw", NC_("x86-flag", /*/flag:avx512bw*/ "AVX-512 Byte/Word instructions") }, + { "avx512vl", NC_("x86-flag", /*/flag:avx512vl*/ "AVX-512 128/256 Vector Length extensions") }, +/* Extended state features, CPUID level 0x0000000d:1 (eax) */ + { "xsaveopt", NC_("x86-flag", /*/flag:xsaveopt*/ "Optimized XSAVE") }, + { "xsavec", NC_("x86-flag", /*/flag:xsavec*/ "XSAVEC") }, + { "xgetbv1", NC_("x86-flag", /*/flag:xgetbv1*/ "XGETBV with ECX = 1") }, + { "xsaves", NC_("x86-flag", /*/flag:xsaves*/ "XSAVES/XRSTORS") }, +/* Intel-defined CPU QoS sub-leaf, CPUID level 0x0000000F:0 (edx) */ + { "cqm_llc", NC_("x86-flag", /*/flag:cqm_llc*/ "LLC QoS") }, +/* Intel-defined CPU QoS sub-leaf, CPUID level 0x0000000F:1 (edx) */ + { "cqm_occup_llc", NC_("x86-flag", /*/flag:cqm_occup_llc*/ "LLC occupancy monitoring") }, + { "cqm_mbm_total", NC_("x86-flag", /*/flag:cqm_mbm_total*/ "LLC total MBM monitoring") }, + { "cqm_mbm_local", NC_("x86-flag", /*/flag:cqm_mbm_local*/ "LLC local MBM monitoring") }, +/* AMD-defined CPU features, CPUID level 0x80000008 (ebx) */ + { "clzero", NC_("x86-flag", /*/flag:clzero*/ "CLZERO instruction") }, + { "irperf", NC_("x86-flag", /*/flag:irperf*/ "instructions retired performance counter") }, +/* Thermal and Power Management leaf, CPUID level 0x00000006 (eax) */ + { "dtherm", NC_("x86-flag", /*/flag:dtherm*/ "digital thermal sensor") }, /* formerly dts */ + { "ida", NC_("x86-flag", /*/flag:ida*/ "Intel Dynamic Acceleration") }, + { "arat", NC_("x86-flag", /*/flag:arat*/ "Always Running APIC Timer") }, + { "pln", NC_("x86-flag", /*/flag:pln*/ "Intel Power Limit Notification") }, + { "pts", NC_("x86-flag", /*/flag:pts*/ "Intel Package Thermal Status") }, + { "hwp", NC_("x86-flag", /*/flag:hwp*/ "Intel Hardware P-states") }, + { "hwp_notify", NC_("x86-flag", /*/flag:hwp_notify*/ "HWP notification") }, + { "hwp_act_window", NC_("x86-flag", /*/flag:hwp_act_window*/ "HWP Activity Window") }, + { "hwp_epp", NC_("x86-flag", /*/flag:hwp_epp*/ "HWP Energy Performance Preference") }, + { "hwp_pkg_req", NC_("x86-flag", /*/flag:hwp_pkg_req*/ "HWP package-level request") }, +/* AMD SVM Feature Identification, CPUID level 0x8000000a (edx) */ + { "npt", NC_("x86-flag", /*/flag:npt*/ "AMD Nested Page Table support") }, + { "lbrv", NC_("x86-flag", /*/flag:lbrv*/ "AMD LBR Virtualization support") }, + { "svm_lock", NC_("x86-flag", /*/flag:svm_lock*/ "AMD SVM locking MSR") }, + { "nrip_save", NC_("x86-flag", /*/flag:nrip_save*/ "AMD SVM next_rip save") }, + { "tsc_scale", NC_("x86-flag", /*/flag:tsc_scale*/ "AMD TSC scaling support") }, + { "vmcb_clean", NC_("x86-flag", /*/flag:vmcb_clean*/ "AMD VMCB clean bits support") }, + { "flushbyasid", NC_("x86-flag", /*/flag:flushbyasid*/ "AMD flush-by-ASID support") }, + { "decodeassists", NC_("x86-flag", /*/flag:decodeassists*/ "AMD Decode Assists support") }, + { "pausefilter", NC_("x86-flag", /*/flag:pausefilter*/ "AMD filtered pause intercept") }, + { "pfthreshold", NC_("x86-flag", /*/flag:pfthreshold*/ "AMD pause filter threshold") }, + { "avic", NC_("x86-flag", /*/flag:avic*/ "Virtual Interrupt Controller") }, +/* Intel-defined CPU features, CPUID level 0x00000007:0 (ecx) */ + { "pku", NC_("x86-flag", /*/flag:pku*/ "Protection Keys for Userspace") }, + { "ospke", NC_("x86-flag", /*/flag:ospke*/ "OS Protection Keys Enable") }, +/* AMD-defined CPU features, CPUID level 0x80000007 (ebx) */ + { "overflow_recov", NC_("x86-flag", /*/flag:overflow_recov*/ "MCA overflow recovery support") }, + { "succor", NC_("x86-flag", /*/flag:succor*/ "uncorrectable error containment and recovery") }, + { "smca", NC_("x86-flag", /*/flag:smca*/ "Scalable MCA") }, + +/* bug workarounds */ + { "bug:f00f", NC_("x86-flag", /*/bug:f00f*/ "Intel F00F bug") }, + { "bug:fdiv", NC_("x86-flag", /*/bug:fdiv*/ "FPU FDIV") }, + { "bug:coma", NC_("x86-flag", /*/bug:coma*/ "Cyrix 6x86 coma") }, + { "bug:tlb_mmatch", NC_("x86-flag", /*/bug:tlb_mmatch*/ "AMD Erratum 383") }, + { "bug:apic_c1e", NC_("x86-flag", /*/bug:apic_c1e*/ "AMD Erratum 400") }, + { "bug:11ap", NC_("x86-flag", /*/bug:11ap*/ "Bad local APIC aka 11AP") }, + { "bug:fxsave_leak", NC_("x86-flag", /*/bug:fxsave_leak*/ "FXSAVE leaks FOP/FIP/FOP") }, + { "bug:clflush_monitor", NC_("x86-flag", /*/bug:clflush_monitor*/ "AAI65, CLFLUSH required before MONITOR") }, + { "bug:sysret_ss_attrs", NC_("x86-flag", /*/bug:sysret_ss_attrs*/ "SYSRET doesn't fix up SS attrs") }, + { "bug:espfix", NC_("x86-flag", /*/bug:espfix*/ "IRET to 16-bit SS corrupts ESP/RSP high bits") }, + { "bug:null_seg", NC_("x86-flag", /*/bug:null_seg*/ "Nulling a selector preserves the base") }, /* see: detect_null_seg_behavior() */ + { "bug:swapgs_fence", NC_("x86-flag", /*/bug:swapgs_fence*/ "SWAPGS without input dep on GS") }, + { "bug:monitor", NC_("x86-flag", /*/bug:monitor*/ "IPI required to wake up remote CPU") }, + { "bug:amd_e400", NC_("x86-flag", /*/bug:amd_e400*/ "AMD Erratum 400") }, +/* power management + * ... from arch/x86/kernel/cpu/powerflags.h */ + { "pm:ts", NC_("x86-flag", /*/flag:pm:ts*/ "temperature sensor") }, + { "pm:fid", NC_("x86-flag", /*/flag:pm:fid*/ "frequency id control") }, + { "pm:vid", NC_("x86-flag", /*/flag:pm:vid*/ "voltage id control") }, + { "pm:ttp", NC_("x86-flag", /*/flag:pm:ttp*/ "thermal trip") }, + { "pm:tm", NC_("x86-flag", /*/flag:pm:tm*/ "hardware thermal control") }, + { "pm:stc", NC_("x86-flag", /*/flag:pm:stc*/ "software thermal control") }, + { "pm:100mhzsteps", NC_("x86-flag", /*/flag:pm:100mhzsteps*/ "100 MHz multiplier control") }, + { "pm:hwpstate", NC_("x86-flag", /*/flag:pm:hwpstate*/ "hardware P-state control") }, + { "pm:cpb", NC_("x86-flag", /*/flag:pm:cpb*/ "core performance boost") }, + { "pm:eff_freq_ro", NC_("x86-flag", /*/flag:pm:eff_freq_ro*/ "Readonly aperf/mperf") }, + { "pm:proc_feedback", NC_("x86-flag", /*/flag:pm:proc_feedback*/ "processor feedback interface") }, + { "pm:acc_power", NC_("x86-flag", /*/flag:pm:acc_power*/ "accumulated power mechanism") }, + { NULL, NULL}, +}; + +static char all_flags[4096] = ""; + +#define APPEND_FLAG(f) strcat(all_flags, f); strcat(all_flags, " "); +const char *x86_flag_list() { + int i = 0, built = 0; + built = strlen(all_flags); + if (!built) { + while(tab_flag_meaning[i].name != NULL) { + APPEND_FLAG(tab_flag_meaning[i].name); + i++; + } + } + return all_flags; +} + +const char *x86_flag_meaning(const char *flag) { + int i = 0; + if (flag) + while(tab_flag_meaning[i].name != NULL) { + if (strcmp(tab_flag_meaning[i].name, flag) == 0) { + if (tab_flag_meaning[i].meaning != NULL) + return C_("x86-flag", tab_flag_meaning[i].meaning); + else return NULL; + } + i++; + } + return NULL; +} + +static void x86_flag_find_dups(void) { + int t, i; + + t = 0; + while(tab_flag_meaning[t].name != NULL) { + i = t+1; + while(tab_flag_meaning[i].name != NULL) { + if (strcmp(tab_flag_meaning[t].name, tab_flag_meaning[i].name) == 0) { + printf("x86-flag duplicate definition: %s\n ... %d: %s\n ... %d: %s\n", + tab_flag_meaning[i].name, + t, tab_flag_meaning[t].meaning, + i, tab_flag_meaning[i].meaning); + } + i++; + } + t++; + } +} diff --git a/modules/devices/x86/x86_data.h b/modules/devices/x86/x86_data.h new file mode 100644 index 00000000..66a4c80f --- /dev/null +++ b/modules/devices/x86/x86_data.h @@ -0,0 +1,28 @@ +/* + * rpiz - https://github.com/bp0/rpiz + * Copyright (C) 2017 Burt P. <pburt0@gmail.com> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef _X86DATA_H_ +#define _X86DATA_H_ + +/* cpu flags from /proc/cpuinfo */ +const char *x86_flag_list(void); /* list of all known flags */ +const char *x86_flag_meaning(const char *flag); /* lookup flag meaning */ + +#endif diff --git a/modules/devices/x86_64 b/modules/devices/x86_64 deleted file mode 120000 index de1ff735..00000000 --- a/modules/devices/x86_64 +++ /dev/null @@ -1 +0,0 @@ -./x86
\ No newline at end of file diff --git a/modules/network.c b/modules/network.c index 18f8ba65..f27a159a 100644 --- a/modules/network.c +++ b/modules/network.c @@ -80,51 +80,46 @@ void scan_statistics(gboolean reload) FILE *netstat; gchar buffer[256]; gchar *netstat_path; - + int line = 0; + SCAN_START(); - + g_free(__statistics); __statistics = g_strdup(""); - + if ((netstat_path = find_program("netstat"))) { gchar *command_line = g_strdup_printf("%s -s", netstat_path); - + if ((netstat = popen(command_line, "r"))) { while (fgets(buffer, 256, netstat)) { if (!isspace(buffer[0]) && strchr(buffer, ':')) { gchar *tmp; - + tmp = g_ascii_strup(strend(buffer, ':'), -1); - + __statistics = h_strdup_cprintf("[%s]\n", __statistics, tmp); - g_free(tmp); - } else if (isdigit(buffer[4])) { - gchar *tmp1 = buffer + 4, - *tmp2 = tmp1; - - while (*tmp2 && !isspace(*tmp2)) tmp2++; - *tmp2 = 0; - tmp2++; - - *tmp2 = toupper(*tmp2); - - __statistics = h_strdup_cprintf("%s=%s\n", + + } else { + gchar *tmp = buffer; + + while (*tmp && isspace(*tmp)) tmp++; + + __statistics = h_strdup_cprintf("<b> </b>#%d=%s\n", __statistics, - g_strstrip(tmp1), - g_strstrip(tmp2)); + line++, tmp); } } pclose(netstat); } - + g_free(command_line); g_free(netstat_path); } - + SCAN_END(); } @@ -133,24 +128,24 @@ void scan_dns(gboolean reload) { FILE *resolv; gchar buffer[256]; - + SCAN_START(); - + g_free(__nameservers); __nameservers = g_strdup(""); - + if ((resolv = fopen("/etc/resolv.conf", "r"))) { while (fgets(buffer, 256, resolv)) { if (g_str_has_prefix(buffer, "nameserver")) { gchar *ip; struct sockaddr_in sa; char hbuf[NI_MAXHOST]; - + ip = g_strstrip(buffer + sizeof("nameserver")); - + sa.sin_family = AF_INET; sa.sin_addr.s_addr = inet_addr(ip); - + if (getnameinfo((struct sockaddr *)&sa, sizeof(sa), hbuf, sizeof(hbuf), NULL, 0, NI_NAMEREQD)) { __nameservers = h_strdup_cprintf("%s=\n", __nameservers, @@ -159,15 +154,15 @@ void scan_dns(gboolean reload) __nameservers = h_strdup_cprintf("%s=%s\n", __nameservers, ip, hbuf); - - } - + + } + shell_status_pulse(); - } + } } fclose(resolv); } - + SCAN_END(); } @@ -184,15 +179,15 @@ void scan_route(gboolean reload) FILE *route; gchar buffer[256]; gchar *route_path; - + SCAN_START(); g_free(__routing_table); __routing_table = g_strdup(""); - + if ((route_path = find_program("route"))) { gchar *command_line = g_strdup_printf("%s -n", route_path); - + if ((route = popen(command_line, "r"))) { /* eat first two lines */ (void)fgets(buffer, 256, route); @@ -203,7 +198,7 @@ void scan_route(gboolean reload) buffer[31] = '\0'; buffer[47] = '\0'; buffer[53] = '\0'; - + __routing_table = h_strdup_cprintf("%s / %s=%s|%s|%s\n", __routing_table, g_strstrip(buffer), g_strstrip(buffer + 16), @@ -211,14 +206,14 @@ void scan_route(gboolean reload) g_strstrip(buffer + 48), g_strstrip(buffer + 32)); } - + pclose(route); } - + g_free(command_line); g_free(route_path); } - + SCAN_END(); } @@ -227,12 +222,12 @@ void scan_arp(gboolean reload) { FILE *arp; gchar buffer[256]; - + SCAN_START(); g_free(__arp_table); __arp_table = g_strdup(""); - + if ((arp = fopen("/proc/net/arp", "r"))) { /* eat first line */ (void)fgets(buffer, 256, arp); @@ -240,17 +235,17 @@ void scan_arp(gboolean reload) while (fgets(buffer, 256, arp)) { buffer[15] = '\0'; buffer[58] = '\0'; - + __arp_table = h_strdup_cprintf("%s=%s|%s\n", __arp_table, g_strstrip(buffer), g_strstrip(buffer + 72), g_strstrip(buffer + 41)); } - + fclose(arp); } - + SCAN_END(); } @@ -260,15 +255,15 @@ void scan_connections(gboolean reload) FILE *netstat; gchar buffer[256]; gchar *netstat_path; - + SCAN_START(); g_free(__connections); __connections = g_strdup(""); - + if ((netstat_path = find_program("netstat"))) { gchar *command_line = g_strdup_printf("%s -an", netstat_path); - + if ((netstat = popen("netstat -an", "r"))) { while (fgets(buffer, 256, netstat)) { buffer[6] = '\0'; @@ -284,91 +279,99 @@ void scan_connections(gboolean reload) g_strstrip(buffer + 68)); /* state */ } } - + pclose(netstat); } - + g_free(command_line); g_free(netstat_path); } - + SCAN_END(); } gchar *callback_arp() { - return g_strdup_printf(_("[ARP Table]\n" + return g_strdup_printf("[%s]\n" "%s\n" "[$ShellParam$]\n" "ReloadInterval=3000\n" - "ColumnTitle$TextValue=IP Address\n" - "ColumnTitle$Value=Interface\n" - "ColumnTitle$Extra1=MAC Address\n" - "ShowColumnHeaders=true\n"), - __arp_table); + "ColumnTitle$TextValue=%s\n" /* IP Address */ + "ColumnTitle$Value=%s\n" /* Interface */ + "ColumnTitle$Extra1=%s\n" /* MAC Address */ + "ShowColumnHeaders=true\n", + _("ARP Table"), __arp_table, + _("IP Address"), _("Interface"), _("MAC Address") ); } gchar *callback_shares() { - return g_strdup_printf("[SAMBA]\n" - "%s\n" - "[NFS]\n" - "%s", smb_shares_list, nfs_shares_list); + return g_strdup_printf("[%s]\n" + "%s\n" + "[%s]\n" + "%s", + _("SAMBA"), smb_shares_list, + _("NFS"), nfs_shares_list); } gchar *callback_dns() { - return g_strdup_printf(_("[Name servers]\n" + return g_strdup_printf("[%s]\n" "%s\n" "[$ShellParam$]\n" - "ColumnTitle$TextValue=IP Address\n" - "ColumnTitle$Value=Name\n" - "ShowColumnHeaders=true\n"), __nameservers); + "ColumnTitle$TextValue=%s\n" /* IP Address */ + "ColumnTitle$Value=%s\n" /* Name */ + "ShowColumnHeaders=true\n", + _("Name Servers"), __nameservers, + _("IP Address"), _("Name") ); } gchar *callback_connections() { - return g_strdup_printf(_("[Connections]\n" + return g_strdup_printf("[%s]\n" "%s\n" "[$ShellParam$]\n" "ReloadInterval=3000\n" - "ColumnTitle$TextValue=Local Address\n" - "ColumnTitle$Value=Protocol\n" - "ColumnTitle$Extra1=Foreign Address\n" - "ColumnTitle$Extra2=State\n" - "ShowColumnHeaders=true\n"), - __connections); + "ColumnTitle$TextValue=%s\n" /* Local Address */ + "ColumnTitle$Value=%s\n" /* Protocol */ + "ColumnTitle$Extra1=%s\n" /* Foreign Address */ + "ColumnTitle$Extra2=%s\n" /* State */ + "ShowColumnHeaders=true\n", + _("Connections"), __connections, + _("Local Address"), _("Protocol"), _("Foreign Address"), _("State") ); } gchar *callback_network() { - return g_strdup_printf(_("%s\n" - "[$ShellParam$]\n" - "ReloadInterval=3000\n" - "ViewType=1\n" - "ColumnTitle$TextValue=Interface\n" - "ColumnTitle$Value=IP Address\n" - "ColumnTitle$Extra1=Sent\n" - "ColumnTitle$Extra2=Received\n" - "ShowColumnHeaders=true\n" - "%s"), - network_interfaces, - network_icons); + return g_strdup_printf("%s\n" + "[$ShellParam$]\n" + "ReloadInterval=3000\n" + "ViewType=1\n" + "ColumnTitle$TextValue=%s\n" /* Interface */ + "ColumnTitle$Value=%s\n" /* IP Address */ + "ColumnTitle$Extra1=%s\n" /* Sent */ + "ColumnTitle$Extra2=%s\n" /* Received */ + "ShowColumnHeaders=true\n" + "%s", + network_interfaces, + _("Interface"), _("IP Address"), _("Sent"), _("Received"), + network_icons); } gchar *callback_route() { - return g_strdup_printf(_("[IP routing table]\n" + return g_strdup_printf("[%s]\n" "%s\n" "[$ShellParam$]\n" "ViewType=0\n" "ReloadInterval=3000\n" - "ColumnTitle$TextValue=Destination / Gateway\n" - "ColumnTitle$Value=Interface\n" - "ColumnTitle$Extra1=Flags\n" - "ColumnTitle$Extra2=Mask\n" - "ShowColumnHeaders=true\n"), - __routing_table); + "ColumnTitle$TextValue=%s\n" /* Destination / Gateway */ + "ColumnTitle$Value=%s\n" /* Interface */ + "ColumnTitle$Extra1=%s\n" /* Flags */ + "ColumnTitle$Extra2=%s\n" /* Mask */ + "ShowColumnHeaders=true\n", + _("IP routing table"), __routing_table, + _("Destination/Gateway"), _("Interface"), _("Flags"), _("Mask") ); } gchar *callback_statistics() @@ -411,12 +414,12 @@ void hi_module_init(void) void hi_module_deinit(void) { moreinfo_del_with_prefix("NET"); - + g_free(smb_shares_list); g_free(nfs_shares_list); g_free(network_interfaces); g_free(network_icons); - + g_free(__statistics); g_free(__nameservers); g_free(__arp_table); diff --git a/modules/network/net.c b/modules/network/net.c index ebb0612a..99a5e616 100644 --- a/modules/network/net.c +++ b/modules/network/net.c @@ -40,7 +40,7 @@ #include <linux/wireless.h> #else #include <net/if.h> -#endif /* HAS_LINUX_WE */ +#endif /* HAS_LINUX_WE */ #include "hardinfo.h" #include "network.h" @@ -57,18 +57,26 @@ struct _NetInfo { char broadcast[16]; #ifdef HAS_LINUX_WE - char wi_essid[IW_ESSID_MAX_SIZE + 1]; + char wi_essid[IW_ESSID_MAX_SIZE + 1]; int wi_rate; int wi_mode, wi_status; gboolean wi_has_txpower; struct iw_param wi_txpower; - int wi_quality_level, wi_signal_level, wi_noise_level; + int wi_quality_level, wi_signal_level, wi_noise_level; gboolean is_wireless; #endif }; #ifdef HAS_LINUX_WE -const gchar *wi_operation_modes[] = { "Auto", "Ad-Hoc", "Managed", "Master", "Repeater", "Secondary", "Unknown" }; +const gchar *wi_operation_modes[] = { + NC_("wi-op-mode", "Auto"), + NC_("wi-op-mode", "Ad-Hoc"), + NC_("wi-op-mode", "Managed"), + NC_("wi-op-mode", "Master"), + NC_("wi-op-mode", "Repeater"), + NC_("wi-op-mode", "Secondary"), + NC_("wi-op-mode", "(Unknown)") +}; void get_wireless_info(int fd, NetInfo *netinfo) { @@ -78,16 +86,16 @@ void get_wireless_info(int fd, NetInfo *netinfo) int r, trash; netinfo->is_wireless = FALSE; - + if ((wrls = fopen("/proc/net/wireless", "r"))) { while (fgets(wbuf, 256, wrls)) { if (strchr(wbuf, ':') && strstr(wbuf, netinfo->name)) { gchar *buf1 = wbuf; - + netinfo->is_wireless = TRUE; - + buf1 = strchr(buf1, ':') + 1; - + if (strchr(buf1, '.')) { sscanf(buf1, "%d %d. %d. %d %d %d %d %d %d %d", &(netinfo->wi_status), @@ -104,7 +112,7 @@ void get_wireless_info(int fd, NetInfo *netinfo) &trash, &trash, &trash, &trash, &trash, &trash); } - + break; } } @@ -113,14 +121,14 @@ void get_wireless_info(int fd, NetInfo *netinfo) if (!netinfo->is_wireless) return; - + strncpy(wi_req.ifr_name, netinfo->name, 16); - + /* obtain essid */ wi_req.u.essid.pointer = netinfo->wi_essid; wi_req.u.essid.length = IW_ESSID_MAX_SIZE + 1; wi_req.u.essid.flags = 0; - + if (ioctl(fd, SIOCGIWESSID, &wi_req) < 0) { strcpy(netinfo->wi_essid, ""); } else { @@ -133,7 +141,7 @@ void get_wireless_info(int fd, NetInfo *netinfo) } else { netinfo->wi_rate = wi_req.u.bitrate.value; } - + /* obtain operation mode */ if (ioctl(fd, SIOCGIWMODE, &wi_req) < 0) { netinfo->wi_mode = 0; @@ -144,19 +152,19 @@ void get_wireless_info(int fd, NetInfo *netinfo) netinfo->wi_mode = 6; } } - + #if WIRELESS_EXT >= 10 /* obtain txpower */ if (ioctl(fd, SIOCGIWTXPOW, &wi_req) < 0) { netinfo->wi_has_txpower = FALSE; } else { netinfo->wi_has_txpower = TRUE; - + memcpy(&netinfo->wi_txpower, &wi_req.u.txpower, sizeof(struct iw_param)); } #else netinfo->wi_has_txpower = FALSE; -#endif /* WIRELESS_EXT >= 10 */ +#endif /* WIRELESS_EXT >= 10 */ } #endif /* HAS_LINUX_WE */ @@ -174,47 +182,47 @@ void get_net_info(char *if_name, NetInfo * netinfo) /* MTU */ strcpy(ifr.ifr_name, if_name); if (ioctl(fd, SIOCGIFMTU, &ifr) < 0) { - netinfo->mtu = 0; + netinfo->mtu = 0; } else { - netinfo->mtu = ifr.ifr_mtu; + netinfo->mtu = ifr.ifr_mtu; } /* HW Address */ strcpy(ifr.ifr_name, if_name); if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) { - memset(netinfo->mac, 0, 8); + memset(netinfo->mac, 0, 8); } else { - memcpy(netinfo->mac, ifr.ifr_ifru.ifru_hwaddr.sa_data, 8); + memcpy(netinfo->mac, ifr.ifr_ifru.ifru_hwaddr.sa_data, 8); } /* IP Address */ strcpy(ifr.ifr_name, if_name); if (ioctl(fd, SIOCGIFADDR, &ifr) < 0) { - netinfo->ip[0] = 0; + netinfo->ip[0] = 0; } else { - snprintf(netinfo->ip, sizeof(netinfo->ip), "%s", - inet_ntoa(((struct sockaddr_in *) &ifr.ifr_addr)-> - sin_addr)); + snprintf(netinfo->ip, sizeof(netinfo->ip), "%s", + inet_ntoa(((struct sockaddr_in *) &ifr.ifr_addr)-> + sin_addr)); } /* Mask Address */ strcpy(ifr.ifr_name, if_name); if (ioctl(fd, SIOCGIFNETMASK, &ifr) < 0) { - netinfo->mask[0] = 0; + netinfo->mask[0] = 0; } else { - snprintf(netinfo->mask, sizeof(netinfo->mask), "%s", - inet_ntoa(((struct sockaddr_in *) &ifr.ifr_addr)-> - sin_addr)); + snprintf(netinfo->mask, sizeof(netinfo->mask), "%s", + inet_ntoa(((struct sockaddr_in *) &ifr.ifr_addr)-> + sin_addr)); } /* Broadcast Address */ strcpy(ifr.ifr_name, if_name); if (ioctl(fd, SIOCGIFBRDADDR, &ifr) < 0) { - netinfo->broadcast[0] = 0; + netinfo->broadcast[0] = 0; } else { - snprintf(netinfo->broadcast, sizeof(netinfo->broadcast), "%s", - inet_ntoa(((struct sockaddr_in *) &ifr.ifr_addr)-> - sin_addr)); + snprintf(netinfo->broadcast, sizeof(netinfo->broadcast), "%s", + inet_ntoa(((struct sockaddr_in *) &ifr.ifr_addr)-> + sin_addr)); } #ifdef HAS_LINUX_WE @@ -230,34 +238,41 @@ static struct { char *label; char *icon; } netdev2type[] = { - { "eth", "Ethernet", "network-interface" }, - { "lo", "Loopback", "network" }, - { "ppp", "Point-to-Point", "modem" }, - { "ath", "Wireless", "wireless" }, - { "wlan", "Wireless", "wireless" }, - { "ra", "Wireless", "wireless" }, - { "wl", "Wireless", "wireless" }, - { "wmaster", "Wireless", "wireless" }, - { "tun", "Virtual Point-to-Point (TUN)", "network" }, - { "tap", "Ethernet (TAP)", "network" }, - { "plip", "Parallel Line Internet Protocol", "network" }, - { "irlan", "Infrared", "network" }, - { "slip", "Serial Line Internet Protocol", "network" }, - { "isdn", "Integrated Services Digital Network", "modem" }, - { "sit", "IPv6-over-IPv4 Tunnel", "network" }, - { "vmnet8", "VMWare Virtual Network Interface (NAT)", "computer" }, - { "vmnet", "VMWare Virtual Network Interface", "computer" }, - { "pan", "Personal Area Network (PAN)", "bluetooth" }, - { "bnep", "Bluetooth", "bluetooth" }, - { "br", "Bridge Interface", "network" }, - { "ham", "Hamachi Virtual Personal Network", "network"}, - { "net", "Ethernet", "network-interface" }, - { "ifb", "Intermediate Functional Block", "network" }, - { "gre", "GRE Network Tunnel", "network" }, - { "msh", "Mesh Network", "wireless" }, - { "wmaster", "Wireless Master Interface", "wireless" }, - { "vboxnet", "VirtualBox Virtual Network Interface", "network" }, - { NULL, "Unknown", "network" }, + /* Classic */ + { "eth", NC_("net-if-type", "Ethernet"), "network-interface" }, + { "lo", NC_("net-if-type", "Loopback"), "network" }, + { "ppp", NC_("net-if-type", "Point-to-Point"), "modem" }, + { "ath", NC_("net-if-type", "Wireless"), "wireless" }, + { "wlan", NC_("net-if-type", "Wireless"), "wireless" }, + { "ra", NC_("net-if-type", "Wireless"), "wireless" }, + { "wmaster", NC_("net-if-type", "Wireless"), "wireless" }, + { "tun", NC_("net-if-type", "Virtual Point-to-Point (TUN)"), "network" }, + { "tap", NC_("net-if-type", "Ethernet (TAP)"), "network" }, + { "plip", NC_("net-if-type", "Parallel Line Internet Protocol"), "network" }, + { "irlan", NC_("net-if-type", "Infrared"), "network" }, + { "slip", NC_("net-if-type", "Serial Line Internet Protocol"), "network" }, + { "isdn", NC_("net-if-type", "Integrated Services Digital Network"), "modem" }, + { "sit", NC_("net-if-type", "IPv6-over-IPv4 Tunnel"), "network" }, + { "vmnet8", NC_("net-if-type", "VMWare Virtual Network Interface (NAT)"), "computer" }, + { "vmnet", NC_("net-if-type", "VMWare Virtual Network Interface"), "computer" }, + { "pan", NC_("net-if-type", "Personal Area Network (PAN)"), "bluetooth" }, + { "bnep", NC_("net-if-type", "Bluetooth"), "bluetooth" }, + { "br", NC_("net-if-type", "Bridge Interface"), "network" }, + { "ham", NC_("net-if-type", "Hamachi Virtual Personal Network"), "network"}, + { "net", NC_("net-if-type", "Ethernet"), "network-interface" }, + { "ifb", NC_("net-if-type", "Intermediate Functional Block"), "network" }, + { "gre", NC_("net-if-type", "GRE Network Tunnel"), "network" }, + { "msh", NC_("net-if-type", "Mesh Network"), "wireless" }, + { "wmaster", NC_("net-if-type", "Wireless Master Interface"), "wireless" }, + { "vboxnet", NC_("net-if-type", "VirtualBox Virtual Network Interface"), "network" }, + + /* Predictable network interface device names (systemd) */ + { "en", NC_("net-if-type", "Ethernet"), "network-interface" }, + { "sl", NC_("net-if-type", "Serial Line Internet Protocol"), "network" }, + { "wl", NC_("net-if-type", "Wireless"), "wireless" }, + { "ww", NC_("net-if-type", "Wireless (WAN)"), "wireless" }, + + { NULL, NC_("net-if-type", "(Unknown)"), "network" }, }; static void net_get_iface_type(gchar * name, gchar ** type, gchar ** icon, NetInfo *ni) @@ -266,19 +281,19 @@ static void net_get_iface_type(gchar * name, gchar ** type, gchar ** icon, NetIn #ifdef HAS_LINUX_WE if (ni->is_wireless) { - *type = "Wireless"; + *type = "Wireless"; /* translated when used */ *icon = "wireless"; - + return; } #endif for (i = 0; netdev2type[i].type; i++) { - if (g_str_has_prefix(name, netdev2type[i].type)) - break; + if (g_str_has_prefix(name, netdev2type[i].type)) + break; } - *type = netdev2type[i].label; + *type = netdev2type[i].label; /* translated when used */ *icon = netdev2type[i].icon; } @@ -288,6 +303,30 @@ remove_net_devices(gpointer key, gpointer value, gpointer data) return g_str_has_prefix(key, "NET"); } +#ifdef HAS_LINUX_WE +const char *wifi_bars(int signal, int noise) +{ + float quality; + + if (signal <= -100) + quality = 0.0; + else if (signal >= -50) + quality = 1.0; + else + quality = (2.0 * (signal + 100.0)) / 100.0; + + if (quality < 0.20) + return "▰▱▱▱▱"; + if (quality < 0.40) + return "▰▰▱▱▱"; + if (quality < 0.60) + return "▰▰▰▱▱"; + if (quality < 0.80) + return "▰▰▰▰▱"; + return "▰▰▰▰▰"; +} +#endif + static void scan_net_interfaces_24(void) { FILE *proc_net; @@ -303,20 +342,20 @@ static void scan_net_interfaces_24(void) gdouble trans_packets; if (!g_file_test("/proc/net/dev", G_FILE_TEST_EXISTS)) { - if (network_interfaces) { - g_free(network_interfaces); - network_interfaces = g_strdup("[Network Interfaces]\n" - "None found=\n"); - } + if (network_interfaces) { + g_free(network_interfaces); + network_interfaces = g_strdup_printf("[%s]]\n%s=\n", + _("Network Interfaces"), _("None Found") ); + } - return; + return; } g_free(network_interfaces); g_free(network_icons); - network_interfaces = g_strdup("[Network Interfaces]\n"); + network_interfaces = g_strdup_printf("[%s]\n", _("Network Interfaces")); network_icons = g_strdup(""); proc_net = fopen("/proc/net/dev", "r"); @@ -324,118 +363,126 @@ static void scan_net_interfaces_24(void) return; while (fgets(buffer, 256, proc_net)) { - if (strchr(buffer, ':')) { - gint trash; - gchar ifacename[16]; - gchar *buf = buffer; - gchar *iface_type, *iface_icon; - gint i; - - buf = g_strstrip(buf); - - memset(ifacename, 0, 16); - - for (i = 0; buffer[i] != ':' && i < 16; i++) { - ifacename[i] = buffer[i]; - } - - buf = strchr(buf, ':') + 1; - - /* iface: bytes packets errs drop fifo frame compressed multicast */ - sscanf(buf, "%lf %lf %lf %d %d %d %d %d %lf %lf %lf", - &recv_bytes, &recv_packets, - &recv_errors, &trash, &trash, &trash, &trash, - &trash, &trans_bytes, &trans_packets, &trans_errors); - - gdouble recv_mb = recv_bytes / 1048576.0; - gdouble trans_mb = trans_bytes / 1048576.0; - - get_net_info(ifacename, &ni); - - devid = g_strdup_printf("NET%s", ifacename); - - network_interfaces = - h_strdup_cprintf - ("$%s$%s=%s|%.2lfMiB|%.2lfMiB\n", - network_interfaces, devid, ifacename, ni.ip[0] ? ni.ip : "", - trans_mb, recv_mb); - net_get_iface_type(ifacename, &iface_type, &iface_icon, &ni); - - network_icons = h_strdup_cprintf("Icon$%s$%s=%s.png\n", - network_icons, devid, - ifacename, iface_icon); - - detailed = g_strdup_printf("[Network Adapter Properties]\n" - "Interface Type=%s\n" - "Hardware Address (MAC)=%02x:%02x:%02x:%02x:%02x:%02x\n" - "MTU=%d\n" - "[Transfer Details]\n" - "Bytes Received=%.0lf (%.2fMiB)\n" - "Bytes Sent=%.0lf (%.2fMiB)\n", - iface_type, - ni.mac[0], ni.mac[1], - ni.mac[2], ni.mac[3], - ni.mac[4], ni.mac[5], - ni.mtu, - recv_bytes, recv_mb, - trans_bytes, trans_mb); - + if (strchr(buffer, ':')) { + gint trash; + gchar ifacename[16]; + gchar *buf = buffer; + gchar *iface_type, *iface_icon; + gint i; + + buf = g_strstrip(buf); + + memset(ifacename, 0, 16); + + for (i = 0; buffer[i] != ':' && i < 16; i++) { + ifacename[i] = buffer[i]; + } + + buf = strchr(buf, ':') + 1; + + /* iface: bytes packets errs drop fifo frame compressed multicast */ + sscanf(buf, "%lf %lf %lf %d %d %d %d %d %lf %lf %lf", + &recv_bytes, &recv_packets, + &recv_errors, &trash, &trash, &trash, &trash, + &trash, &trans_bytes, &trans_packets, &trans_errors); + + gdouble recv_mb = recv_bytes / 1048576.0; + gdouble trans_mb = trans_bytes / 1048576.0; + + get_net_info(ifacename, &ni); + + devid = g_strdup_printf("NET%s", ifacename); + + network_interfaces = + h_strdup_cprintf + ("$%s$%s=%s|%.2lf%s|%.2lf%s\n", + network_interfaces, devid, ifacename, ni.ip[0] ? ni.ip : "", + trans_mb, _("MiB"), recv_mb, _("MiB")); + net_get_iface_type(ifacename, &iface_type, &iface_icon, &ni); + + network_icons = h_strdup_cprintf("Icon$%s$%s=%s.png\n", + network_icons, devid, + ifacename, iface_icon); + + detailed = g_strdup_printf("[%s]\n" + "%s=%s\n" /* Interface Type */ + "%s=%02x:%02x:%02x:%02x:%02x:%02x\n" /* MAC */ + "%s=%d\n" /* MTU */ + "[%s]\n" /*Transfer Details*/ + "%s=%.0lf (%.2f%s)\n" /* Bytes Received */ + "%s=%.0lf (%.2f%s)\n" /* Bytes Sent */, + _("Network Adapter Properties"), + _("Interface Type"), C_("net-if-type", iface_type), + _("Hardware Address (MAC)"), + ni.mac[0], ni.mac[1], + ni.mac[2], ni.mac[3], + ni.mac[4], ni.mac[5], + _("MTU"), ni.mtu, + _("Transfer Details"), + _("Bytes Received"), recv_bytes, recv_mb, _("MiB"), + _("Bytes Sent"), trans_bytes, trans_mb, _("MiB")); + #ifdef HAS_LINUX_WE - if (ni.is_wireless) { - gchar *txpower; - - if (ni.wi_has_txpower) { + if (ni.is_wireless) { + gchar *txpower; + + if (ni.wi_has_txpower) { gint mw, dbm; - + if (ni.wi_txpower.flags & IW_TXPOW_MWATT) { - mw = ni.wi_txpower.value; - dbm = (int) ceil(10.0 * log10((double) ni.wi_txpower.value)); + mw = ni.wi_txpower.value; + dbm = (int) ceil(10.0 * log10((double) ni.wi_txpower.value)); } else { - dbm = ni.wi_txpower.value; - mw = (int) floor(pow(10.0, ((double) dbm / 10.0))); + dbm = ni.wi_txpower.value; + mw = (int) floor(pow(10.0, ((double) dbm / 10.0))); } - - txpower = g_strdup_printf("%ddBm (%dmW)", dbm, mw); - } else { - txpower = g_strdup("Unknown"); - } - - detailed = h_strdup_cprintf("\n[Wireless Properties]\n" - "Network Name (SSID)=%s\n" - "Bit Rate=%dMb/s\n" - "Transmission Power=%s\n" - "Mode=%s\n" - "Status=%d\n" - "Link Quality=%d\n" - "Signal / Noise=%d dBm / %d dBm\n", - detailed, - ni.wi_essid, - ni.wi_rate / 1000000, - txpower, - wi_operation_modes[ni.wi_mode], - ni.wi_status, - ni.wi_quality_level, - ni.wi_signal_level, - ni.wi_noise_level); - - g_free(txpower); + + txpower = g_strdup_printf("%d%s (%d%s)", dbm, _("dBm"), mw, _("mW")); + } else { + txpower = g_strdup(_("(Unknown)")); } + + detailed = h_strdup_cprintf("\n[%s]\n" + "%s=%s\n" /* Network Name (SSID) */ + "%s=%d%s\n" /* Bit Rate */ + "%s=%s\n" /* Transmission Power */ + "%s=%s\n" /* Mode */ + "%s=%d\n" /* Status */ + "%s=%d\n" /* Link Quality */ + "%s=%d %s / %d %s (%s)\n", + detailed, + _("Wireless Properties"), + _("Network Name (SSID)"), ni.wi_essid, + _("Bit Rate"), ni.wi_rate / 1000000, _("Mb/s"), + _("Transmission Power"), txpower, + _("Mode"), C_("wi-op-mode", wi_operation_modes[ni.wi_mode]), + _("Status"), ni.wi_status, + _("Link Quality"), ni.wi_quality_level, + _("Signal / Noise"), + ni.wi_signal_level, _("dBm"), + ni.wi_noise_level, _("dBm"), + wifi_bars(ni.wi_signal_level, ni.wi_noise_level)); + + g_free(txpower); + } #endif - if (ni.ip[0] || ni.mask[0] || ni.broadcast[0]) { - detailed = - h_strdup_cprintf("\n[Internet Protocol (IPv4)]\n" - "IP Address=%s\n" "Mask=%s\n" - "Broadcast Address=%s\n", detailed, - ni.ip[0] ? ni.ip : "Not set", - ni.mask[0] ? ni.mask : "Not set", - ni.broadcast[0] ? ni. - broadcast : "Not set"); - } - - moreinfo_add_with_prefix("NET", devid, detailed); - g_free(devid); - } + if (ni.ip[0] || ni.mask[0] || ni.broadcast[0]) { + detailed = + h_strdup_cprintf("\n[%s]\n" + "%s=%s\n" + "%s=%s\n" + "%s=%s\n", detailed, + _("Internet Protocol (IPv4)"), + _("IP Address"), ni.ip[0] ? ni.ip : _("(Not set)"), + _("Mask"), ni.mask[0] ? ni.mask : _("(Not set)"), + _("Broadcast Address"), + ni.broadcast[0] ? ni.broadcast : _("(Not set)") ); + } + + moreinfo_add_with_prefix("NET", devid, detailed); + g_free(devid); + } } fclose(proc_net); } |