diff options
Diffstat (limited to 'deps/sysobj_early/src')
| -rw-r--r-- | deps/sysobj_early/src/appf.c | 63 | ||||
| -rw-r--r-- | deps/sysobj_early/src/auto_free.c | 61 | ||||
| -rw-r--r-- | deps/sysobj_early/src/nice_name.c | 157 | ||||
| -rw-r--r-- | deps/sysobj_early/src/util_sysobj.c | 303 |
4 files changed, 568 insertions, 16 deletions
diff --git a/deps/sysobj_early/src/appf.c b/deps/sysobj_early/src/appf.c new file mode 100644 index 00000000..432e0f30 --- /dev/null +++ b/deps/sysobj_early/src/appf.c @@ -0,0 +1,63 @@ +/* + * sysobj - https://github.com/bp0/verbose-spork + * Copyright (C) 2018 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 "appf.h" +#define _GNU_SOURCE /* for vasprintf() */ +#include <stdlib.h> +#include <stdarg.h> +#include <stdio.h> +#include <string.h> + +char *appf(char *str, const char *sep, const char *fmt, ...) { + char *buf = NULL; + int inlen, seplen, len; + va_list args; + va_start(args, fmt); + len = vasprintf(&buf, fmt, args); + va_end(args); + if (len < 0) return str; + if (!str) return buf; + inlen = strlen(str); + seplen = (inlen && sep) ? strlen(sep) : 0; + str = realloc(str, inlen + seplen + len + 1); + if (seplen) strcpy(str + inlen, sep); + strcpy(str + inlen + seplen, buf); + free(buf); + return str; +} + +char *appfdup(const char *str, const char *sep, const char *fmt, ...) { + char *buf = NULL, *ret = NULL; + int inlen, seplen, len; + va_list args; + va_start(args, fmt); + len = vasprintf(&buf, fmt, args); + va_end(args); + if (len < 0) return NULL; + if (!str) return buf; + inlen = strlen(str); + seplen = (inlen && sep) ? strlen(sep) : 0; + ret = malloc(inlen + seplen + len + 1); + strcpy(ret, str); + if (seplen) strcpy(ret + inlen, sep); + strcpy(ret + inlen + seplen, buf); + free(buf); + return ret; +} diff --git a/deps/sysobj_early/src/auto_free.c b/deps/sysobj_early/src/auto_free.c index 78f11690..3d75c169 100644 --- a/deps/sysobj_early/src/auto_free.c +++ b/deps/sysobj_early/src/auto_free.c @@ -19,15 +19,26 @@ */ #include "auto_free.h" +#if (AF_USE_SYSOBJ) +#include "sysobj.h" +#else #include <stdio.h> -//#include "sysobj.h" +#define sysobj_elapsed() af_elapsed() +#define sysobj_stats af_stats +static struct { + double auto_free_next; + unsigned long long + auto_freed, + auto_free_len; +} af_stats; +#endif static GMutex free_lock; static GSList *free_list = NULL; static gboolean free_final = FALSE; static GTimer *auto_free_timer = NULL; static guint free_event_source = 0; -#define _elapsed() (auto_free_timer ? g_timer_elapsed(auto_free_timer, NULL) : 0) +#define af_elapsed() (auto_free_timer ? g_timer_elapsed(auto_free_timer, NULL) : 0) #define auto_free_msg(msg, ...) fprintf (stderr, "[%s] " msg "\n", __FUNCTION__, ##__VA_ARGS__) /**/ @@ -49,7 +60,7 @@ gboolean free_auto_free_sf(gpointer trash) { return G_SOURCE_REMOVE; } free_auto_free(); - //sysobj_stats.auto_free_next = sysobj_elapsed() + AF_SECONDS; + sysobj_stats.auto_free_next = sysobj_elapsed() + AF_SECONDS; return G_SOURCE_CONTINUE; } @@ -73,7 +84,7 @@ gpointer auto_free_ex_(gpointer p, GDestroyNotify f, const char *file, int line, * will be called at sysobj_cleanup() and when exiting * threads, as in sysobj_foreach(). */ free_event_source = g_timeout_add_seconds(AF_SECONDS, (GSourceFunc)free_auto_free_sf, NULL); - //sysobj_stats.auto_free_next = sysobj_elapsed() + AF_SECONDS; + sysobj_stats.auto_free_next = sysobj_elapsed() + AF_SECONDS; } auto_free_item *z = g_new0(auto_free_item, 1); @@ -83,22 +94,41 @@ gpointer auto_free_ex_(gpointer p, GDestroyNotify f, const char *file, int line, z->file = file; z->line = line; z->func = func; - z->stamp = _elapsed(); + z->stamp = af_elapsed(); g_mutex_lock(&free_lock); free_list = g_slist_prepend(free_list, z); - //sysobj_stats.auto_free_len++; + sysobj_stats.auto_free_len++; g_mutex_unlock(&free_lock); return p; } -gpointer auto_free_(gpointer p, const char *file, int line, const char *func) { - return auto_free_ex_(p, (GDestroyNotify)g_free, file, line, func); +gpointer auto_free_on_exit_ex_(gpointer p, GDestroyNotify f, const char *file, int line, const char *func) { + if (!p) return p; + + auto_free_item *z = g_new0(auto_free_item, 1); + z->ptr = p; + z->f_free = f; + z->thread = g_thread_self(); + z->file = file; + z->line = line; + z->func = func; + z->stamp = -1.0; + g_mutex_lock(&free_lock); + free_list = g_slist_prepend(free_list, z); + sysobj_stats.auto_free_len++; + g_mutex_unlock(&free_lock); + return p; } static struct { GDestroyNotify fptr; char *name; } free_function_tab[] = { { (GDestroyNotify) g_free, "g_free" }, - // ... +#if (AF_USE_SYSOBJ) + { (GDestroyNotify) sysobj_free, "sysobj_free" }, + { (GDestroyNotify) class_free, "class_free" }, + { (GDestroyNotify) sysobj_filter_free, "sysobj_filter_free" }, + { (GDestroyNotify) sysobj_virt_free, "sysobj_virt_free" }, +#endif { NULL, "(null)" }, }; @@ -106,18 +136,17 @@ static void free_auto_free_ex(gboolean thread_final) { GThread *this_thread = g_thread_self(); GSList *l = NULL, *n = NULL; long long unsigned fc = 0; - double now = _elapsed(); + double now = af_elapsed(); if (!free_list) return; g_mutex_lock(&free_lock); - if (DEBUG_AUTO_FREE) { - unsigned long long ll = g_slist_length(free_list); - auto_free_msg("%llu total items in queue, but will free from thread %p only... ", ll, this_thread); - } + if (DEBUG_AUTO_FREE) + auto_free_msg("%llu total items in queue, but will free from thread %p only... ", sysobj_stats.auto_free_len, this_thread); for(l = free_list; l; l = n) { auto_free_item *z = (auto_free_item*)l->data; n = l->next; + if (!free_final && z->stamp < 0) continue; double age = now - z->stamp; if (free_final || (z->thread == this_thread && (thread_final || age > AF_DELAY_SECONDS) ) ) { if (DEBUG_AUTO_FREE == 2) { @@ -143,8 +172,8 @@ static void free_auto_free_ex(gboolean thread_final) { } if (DEBUG_AUTO_FREE) auto_free_msg("... freed %llu (from thread %p)", fc, this_thread); - //sysobj_stats.auto_freed += fc; - //sysobj_stats.auto_free_len -= fc; + sysobj_stats.auto_freed += fc; + sysobj_stats.auto_free_len -= fc; g_mutex_unlock(&free_lock); } diff --git a/deps/sysobj_early/src/nice_name.c b/deps/sysobj_early/src/nice_name.c new file mode 100644 index 00000000..c3c8d3ce --- /dev/null +++ b/deps/sysobj_early/src/nice_name.c @@ -0,0 +1,157 @@ +/* + * sysobj - https://github.com/bp0/verbose-spork + * Copyright (C) 2018 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. + * + */ + +#define _GNU_SOURCE +#include <string.h> +#include <ctype.h> + +#include "nice_name.h" +#include "util_sysobj.h" + +/* export */ +/* replaces the extra chars with spaces, then when done with a series of + * str_shorten()s, use util_compress_space() to squeeze. */ +gboolean str_shorten(gchar *str, const gchar *find, const gchar *replace) { + if (!str || !find || !replace) return FALSE; + long unsigned lf = strlen(find); + long unsigned lr = strlen(replace); + gchar *p = strstr(str, find); + if (p) { + if (lr > lf) lr = lf; + gchar *buff = g_strnfill(lf, ' '); + strncpy(buff, replace, lr); + strncpy(p, buff, lf); + g_free(buff); + return TRUE; + } + return FALSE; +} + +void nice_name_x86_cpuid_model_string(char *cpuid_model_string) { + static gboolean move_vendor_to_front = TRUE; + static gboolean remove_amd_compute_cores = FALSE; + static gboolean remove_amd_xn_ncore_redundancy = TRUE; + static gboolean remove_processor_cpu_apu_etc = TRUE; + static gboolean remove_mhz_ghz = TRUE; + + if (!cpuid_model_string) return; + g_strstrip(cpuid_model_string); + + while(str_shorten(cpuid_model_string, "Genuine Intel", "Intel")) {}; + while(str_shorten(cpuid_model_string, "(R)", "")) {}; + while(str_shorten(cpuid_model_string, "(r)", "")) {}; + while(str_shorten(cpuid_model_string, "(TM)", "")) {}; + while(str_shorten(cpuid_model_string, "(tm)", "")) {}; + while(str_shorten(cpuid_model_string, "(c)", "")) {}; + while(str_shorten(cpuid_model_string, "(C)", "")) {}; + while(str_shorten(cpuid_model_string, "@", "")) {}; + + if (move_vendor_to_front) { + /* vendor not at the beginning, try to move there. + * ex: Mobile AMD Sempron(tm) Processor 3600+ + * ex: Dual Core AMD Opteron(tm) Processor 165 */ + char *intel = strstr(cpuid_model_string, "Intel "); + char *amd = strstr(cpuid_model_string, "AMD "); + if (amd || intel) { + if (amd && !intel) { + if (amd != cpuid_model_string) { + int l = amd - cpuid_model_string; + memmove(cpuid_model_string+4, cpuid_model_string, l); + memcpy(cpuid_model_string, "AMD ", 4); + } + } else if (intel && !amd) { + int l = intel - cpuid_model_string; + memmove(cpuid_model_string+6, cpuid_model_string, l); + memcpy(cpuid_model_string, "Intel ", 6); + } + } + } + + if (g_str_has_prefix(cpuid_model_string, "AMD")) { + while(str_shorten(cpuid_model_string, "Mobile Technology", "Mobile")) {}; + + if (remove_amd_compute_cores) { + if (strcasestr(cpuid_model_string, " COMPUTE CORES ")) { + /* ex: AMD FX-9800P RADEON R7, 12 COMPUTE CORES 4C+8G */ + char *comma = strchr(cpuid_model_string, ','); + if (comma) *comma = 0; + } + } + + if (remove_amd_xn_ncore_redundancy) { + /* remove Xn n-core redundancy */ + if (strstr(cpuid_model_string, "X2")) { + str_shorten(cpuid_model_string, "Dual Core", ""); + str_shorten(cpuid_model_string, "Dual-Core", ""); + } + if (strstr(cpuid_model_string, "X3")) + str_shorten(cpuid_model_string, "Triple-Core", ""); + if (strstr(cpuid_model_string, "X4")) + str_shorten(cpuid_model_string, "Quad-Core", ""); + } + } + + if (g_str_has_prefix(cpuid_model_string, "Cyrix")) { + while(str_shorten(cpuid_model_string, "tm ", "")) {}; + } + + if (remove_processor_cpu_apu_etc) { + while(str_shorten(cpuid_model_string, " CPU", "")) {}; + while(str_shorten(cpuid_model_string, " APU", "")) {}; + while(str_shorten(cpuid_model_string, " Integrated Processor", "")) {}; + while(str_shorten(cpuid_model_string, " Processor", "")) {}; + while(str_shorten(cpuid_model_string, " processor", "")) {}; + } else { + while(str_shorten(cpuid_model_string, " processor", " Processor")) {}; + } + + if (remove_mhz_ghz) { + /* 1400MHz, 1.6+ GHz, etc */ + char *u = NULL; + while((u = strcasestr(cpuid_model_string, "GHz")) + || (u = strcasestr(cpuid_model_string, "MHz")) ) { + if (u[3] == '+') u[3] = ' '; + strncpy(u, " ", 3); + while(isspace(*u)) {u--;} + while (isdigit(*u) || *u == '.' || *u == '+') + { *u = ' '; u--;} + } + } + + /* finalize */ + util_compress_space(cpuid_model_string); + g_strstrip(cpuid_model_string); +} + +/* Intel Graphics may have very long names, + * like "Intel Corporation Seventh Generation Something Core Something Something Integrated Graphics Processor Revision Ninety-four" */ +void nice_name_intel_gpu_device(char *pci_ids_device_string) { + while(str_shorten(pci_ids_device_string, "(R)", "")) {}; /* Intel(R) -> Intel */ + str_shorten(pci_ids_device_string, "Graphics Controller", "Graphics"); + str_shorten(pci_ids_device_string, "Graphics Device", "Graphics"); + str_shorten(pci_ids_device_string, "Generation", "Gen"); + str_shorten(pci_ids_device_string, "Core Processor", "Core"); + str_shorten(pci_ids_device_string, "Atom Processor", "Atom"); + str_shorten(pci_ids_device_string, "Xeon Processor", "Xeon"); + str_shorten(pci_ids_device_string, "Celeron Processor", "Celeron"); + str_shorten(pci_ids_device_string, "Pentium Processor", "Pentium"); + util_compress_space(pci_ids_device_string); + g_strstrip(pci_ids_device_string); +} diff --git a/deps/sysobj_early/src/util_sysobj.c b/deps/sysobj_early/src/util_sysobj.c new file mode 100644 index 00000000..de3ec8b2 --- /dev/null +++ b/deps/sysobj_early/src/util_sysobj.c @@ -0,0 +1,303 @@ +/* + * sysobj - https://github.com/bp0/verbose-spork + * Copyright (C) 2018 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. + * + */ + +#define _GNU_SOURCE +#include <string.h> +#include <stdio.h> +#include <stdlib.h> /* for realpath() */ +#include <unistd.h> /* for getuid() */ +#include <ctype.h> /* for isxdigit(), etc. */ + +#include "util_sysobj.h" + +gchar *util_build_fn(const gchar *base, const gchar *name) { + gchar *ret = NULL; + gboolean slash = TRUE; + + if (!base) return NULL; + if (base[strlen(base)-1] == '/') + slash = FALSE; + + if (name) { + if (*name == '/') slash = FALSE; + ret = g_strdup_printf("%s%s%s", base, slash ? "/" : "", name); + } else + ret = g_strdup(base); + + util_null_trailing_slash(ret); + return ret; +} + +gboolean util_have_root() { + return (getuid() == 0) ? TRUE : FALSE; +} + +void util_compress_space(gchar *str) { + gchar *p = str, *t = str; + if (str && *str) { + int n = 0; + while(*p) { + if (isspace(*p) ) { + if (!n) + *t++ = ' '; + n++; + } else { + n = 0; + if (t != p) + *t = *p; + t++; + } + p++; + } + } + if (t != p) + *t = 0; +} + +void util_null_trailing_slash(gchar *str) { + if (str && *str) { + if (str[strlen(str)-1] == '/' ) + str[strlen(str)-1] = 0; + } +} + +gsize util_count_lines(const gchar *str) { + gchar **lines = NULL; + gsize count = 0; + + if (str) { + lines = g_strsplit(str, "\n", 0); + count = g_strv_length(lines); + if (count && *lines[count-1] == 0) { + /* if the last line is empty, don't count it */ + count--; + } + g_strfreev(lines); + } + + return count; +} + +int util_get_did(gchar *str, const gchar *lbl) { + int id = -2; + gchar tmpfmt[128] = ""; + gchar tmpchk[128] = ""; + sprintf(tmpfmt, "%s%s", lbl, "%d"); + if ( sscanf(str, tmpfmt, &id) ) { + sprintf(tmpchk, tmpfmt, id); + if ( SEQ(str, tmpchk) ) + return id; + } + return -1; +} + +gchar *util_escape_markup(gchar *v, gboolean replacing) { + gchar *clean, *tmp; + gchar **vl; + if (v == NULL) return NULL; + + vl = g_strsplit(v, "&", -1); + if (g_strv_length(vl) > 1) + clean = g_strjoinv("&", vl); + else + clean = g_strdup(v); + g_strfreev(vl); + + vl = g_strsplit(clean, "<", -1); + if (g_strv_length(vl) > 1) { + tmp = g_strjoinv("<", vl); + g_free(clean); + clean = tmp; + } + g_strfreev(vl); + + vl = g_strsplit(clean, ">", -1); + if (g_strv_length(vl) > 1) { + tmp = g_strjoinv(">", vl); + g_free(clean); + clean = tmp; + } + g_strfreev(vl); + + if (replacing) + g_free((gpointer)v); + return clean; +} + +void util_strstrip_double_quotes_dumb(gchar *str) { + if (!str) return; + g_strstrip(str); + gchar *front = str, *back = str + strlen(str) - 1; + if (back <= front) return; + while(*front == '"') { *front = 'X'; front++; } + while(*back == '"') { *back = 0; back--; } + int nl = strlen(front); + memmove(str, front, nl); + str[nl] = 0; +} + +/* "194.110 MHz" -> "194.11 MHz" + * "5,0 golden rings" -> "5 golden rings" */ +gchar *util_strchomp_float(gchar* str_float) { + if (!str_float) return NULL; + char *dot = strchr(str_float, '.'); + char *comma = strchr(str_float, ','); + char *p = NULL, *dec = NULL, *src = NULL, *target = NULL; + if (!dot && !comma) return str_float; + if (dot > comma) + dec = dot; + else + dec = comma; + p = dec + 1; + while(isdigit(*p)) p++; + target = src = p; + p--; + while(*p == '0') { target = p; p--; }; + if (target == dec + 1) + target = dec; + if (target != src) + memmove(target, src, strlen(src)+1); + return str_float; +} + +/* resolve . and .., but not symlinks */ +gchar *util_normalize_path(const gchar *path, const gchar *relto) { + gchar *resolved = NULL; +#if GLIB_CHECK_VERSION(2, 58, 0) + resolved = g_canonicalize_filename(path, relto); +#else + /* burt's hack version */ + gchar *frt = relto ? g_strdup(relto) : NULL; + util_null_trailing_slash(frt); + gchar *fpath = frt + ? g_strdup_printf("%s%s%s", frt, (*path == '/') ? "" : "/", path) + : g_strdup(path); + g_free(frt); + + /* note: **parts will own all the part strings throughout */ + gchar **parts = g_strsplit(fpath, "/", -1); + gsize i, pn = g_strv_length(parts); + GList *lparts = NULL, *l = NULL, *n = NULL, *p = NULL; + for (i = 0; i < pn; i++) + lparts = g_list_append(lparts, parts[i]); + + i = 0; + gchar *part = NULL; + l = lparts; + while(l) { + n = l->next; p = l->prev; + part = l->data; + + if (SEQ(part, ".") ) + lparts = g_list_delete_link(lparts, l); + + if (SEQ(part, "..") ) { + if (p) + lparts = g_list_delete_link(lparts, p); + lparts = g_list_delete_link(lparts, l); + } + + l = n; + } + + resolved = g_strdup(""); + l = lparts; + while(l) { + resolved = g_strdup_printf("%s%s/", resolved, (gchar*)l->data ); + l = l->next; + } + g_list_free(lparts); + util_null_trailing_slash(resolved); + g_free(fpath); + + g_strfreev(parts); +#endif + + return resolved; +} + +/* resolve . and .. and symlinks */ +gchar *util_canonicalize_path(const gchar *path) { + char *resolved = realpath(path, NULL); + gchar *ret = g_strdup(resolved); /* free with g_free() instead of free() */ + free(resolved); + return ret; +} + +int util_maybe_num(gchar *str) { + int r = 10, i = 0, l = (str) ? strlen(str) : 0; + if (!l || l > 32) return 0; + gchar *chk = g_strdup(str); + g_strstrip(chk); + l = strlen(chk); + if (l > 2 && !strncmp(chk, "0x", 2)) { + i = 2; r = 16; + } + for (; i < l; i++) { + if (isxdigit(chk[i])) { + if (!isdigit(chk[i])) + r = 16; + } else { + r = 0; + break; + } + } + g_free(chk); + return r; +} + +gchar *util_safe_name(const gchar *name, gboolean lower_case) { + if (!name) return NULL; + const gchar *p = name; + gchar *buff = g_new0(gchar, strlen(name) + 1); + gchar *t = buff; + while(*p) { + gboolean ok = g_ascii_isalnum(*p); + if (*p == '.' || *p == '-') ok = TRUE; + if (*p == '/') ok = FALSE; + *t = ok ? *p : '_'; + t++; + p = g_utf8_next_char(p); + } + gchar *ret = lower_case ? g_ascii_strdown(buff, -1) : g_strdup(buff); + g_free(buff); + return ret; +} + +gchar *util_find_line_value(gchar *data, gchar *key, gchar delim) { + gchar *ret = NULL; + gchar **lines = g_strsplit(data, "\n", -1); + gsize line_count = g_strv_length(lines); + gsize i = 0; + for (i = 0; i < line_count; i++) { + gchar *line = lines[i]; + gchar *value = g_utf8_strchr(line, -1, delim); + if (!value) continue; + *value = 0; + value = g_strstrip(value+1); + gchar *lkey = g_strstrip(line); + + if (SEQ(lkey, key) ) { + ret = g_strdup(value); + } + } + g_strfreev(lines); + return ret; +} |