-/* Conky, a system monitor, based on torsmo
+/* -*- mode: c; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*-
+ * vim: ts=4 sw=4 noet ai cindent syntax=c
+ *
+ * Conky, a system monitor, based on torsmo
*
* Any original torsmo code is licensed under the BSD license
*
* Please see COPYING for details
*
* Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
- * Copyright (c) 2005-2009 Brenden Matthews, Philip Kovacs, et. al.
+ * Copyright (c) 2005-2010 Brenden Matthews, Philip Kovacs, et. al.
* (see AUTHORS)
* All rights reserved.
*
#include "conky.h"
#include "fs.h"
#include "logging.h"
+#include "net_stat.h"
+#include "specials.h"
+#include "timeinfo.h"
#include <ctype.h>
#include <errno.h>
#include <sys/time.h>
#include <net/if.h>
#include <netinet/in.h>
#include <pthread.h>
+#include <semaphore.h>
#include <unistd.h>
#include "diskio.h"
+#include <fcntl.h>
/* check for OS and include appropriate headers */
#if defined(__linux__)
#include "openbsd.h"
#endif
-/* OS specific prototypes to be implemented by linux.c & Co. */
-void update_entropy(void);
+/* folds a string over top of itself, like so:
+ *
+ * if start is "blah", and you call it with count = 1, the result will be "lah"
+ */
+void strfold(char *start, int count)
+{
+ char *curplace;
+ for (curplace = start + count; *curplace != 0; curplace++) {
+ *(curplace - count) = *curplace;
+ }
+ *(curplace - count) = 0;
+}
#ifndef HAVE_STRNDUP
// use our own strndup() if it's not available
}
#endif /* HAVE_STRNDUP */
-void update_uname(void)
+int update_uname(void)
{
uname(&info.uname_s);
+ return 0;
}
double get_time(void)
return tv.tv_sec + (tv.tv_usec / 1000000.0);
}
+/* Converts '~/...' paths to '/home/blah/...' assumes that 'dest' is at least
+ * DEFAULT_TEXT_BUFFER_SIZE. It's similar to variable_substitute, except only
+ * cheques for $HOME and ~/ in path */
+void to_real_path(char *dest, const char *source)
+{
+ char tmp[DEFAULT_TEXT_BUFFER_SIZE];
+ if (sscanf(source, "~/%s", tmp) || sscanf(source, "$HOME/%s", tmp)) {
+ char *homedir = getenv("HOME");
+ if (homedir) {
+ snprintf(dest, DEFAULT_TEXT_BUFFER_SIZE, "%s/%s", homedir, tmp);
+ } else {
+ NORM_ERR("$HOME environment variable doesn't exist");
+ strncpy(dest, source, DEFAULT_TEXT_BUFFER_SIZE);
+ }
+ } else if (dest != source) { //see changelog 2009-06-29 if you doubt that this check is necessary
+ strncpy(dest, source, DEFAULT_TEXT_BUFFER_SIZE);
+ }
+}
+
+int open_fifo(const char *file, int *reported)
+{
+ char path[DEFAULT_TEXT_BUFFER_SIZE];
+ int fd = 0;
+
+ to_real_path(path, file);
+ fd = open(file, O_RDONLY | O_NONBLOCK);
+
+ if (fd == -1) {
+ if (!reported || *reported == 0) {
+ NORM_ERR("can't open %s: %s", file, strerror(errno));
+ if (reported) {
+ *reported = 1;
+ }
+ }
+ return -1;
+ }
+
+ return fd;
+}
+
FILE *open_file(const char *file, int *reported)
{
- FILE *fp = fopen(file, "r");
+ char path[DEFAULT_TEXT_BUFFER_SIZE];
+ FILE *fp = 0;
+
+ to_real_path(path, file);
+ fp = fopen(file, "r");
if (!fp) {
if (!reported || *reported == 0) {
- ERR("can't open %s: %s", file, strerror(errno));
+ NORM_ERR("can't open %s: %s", file, strerror(errno));
if (reported) {
*reported = 1;
}
}
- return 0;
+ return NULL;
}
return fp;
*dest = '\0';
}
-/* network interface stuff */
-
-static struct net_stat netstats[16];
-
-struct net_stat *get_net_stat(const char *dev)
-{
- unsigned int i;
-
- if (!dev) {
- return 0;
- }
-
- /* find interface stat */
- for (i = 0; i < 16; i++) {
- if (netstats[i].dev && strcmp(netstats[i].dev, dev) == 0) {
- return &netstats[i];
- }
- }
-
- /* wasn't found? add it */
- if (i == 16) {
- for (i = 0; i < 16; i++) {
- if (netstats[i].dev == 0) {
- netstats[i].dev = strndup(dev, text_buffer_size);
- return &netstats[i];
- }
- }
- }
-
- CRIT_ERR("too many interfaces used (limit is 16)");
- return 0;
-}
-
-void clear_net_stats(void)
-{
- memset(netstats, 0, sizeof(netstats));
-}
-
-/* We should check if this is ok with OpenBSD and NetBSD as well. */
-int interface_up(const char *dev)
-{
- int fd;
- struct ifreq ifr;
-
- if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
- CRIT_ERR("could not create sockfd");
- return 0;
- }
- strncpy(ifr.ifr_name, dev, IFNAMSIZ);
- if (ioctl(fd, SIOCGIFFLAGS, &ifr)) {
- /* if device does not exist, treat like not up */
- if (errno != ENODEV && errno != ENXIO)
- perror("SIOCGIFFLAGS");
- goto END_FALSE;
- }
-
- if (!(ifr.ifr_flags & IFF_UP)) /* iface is not up */
- goto END_FALSE;
- if (ifup_strictness == IFUP_UP)
- goto END_TRUE;
-
- if (!(ifr.ifr_flags & IFF_RUNNING))
- goto END_FALSE;
- if (ifup_strictness == IFUP_LINK)
- goto END_TRUE;
-
- if (ioctl(fd, SIOCGIFADDR, &ifr)) {
- perror("SIOCGIFADDR");
- goto END_FALSE;
- }
- if (((struct sockaddr_in *)&(ifr.ifr_ifru.ifru_addr))->sin_addr.s_addr)
- goto END_TRUE;
-
-END_FALSE:
- close(fd);
- return 0;
-END_TRUE:
- close(fd);
- return 1;
-}
-
-void free_dns_data(void)
-{
- int i;
- struct dns_data *data = &info.nameserver_info;
- for (i = 0; i < data->nscount; i++)
- free(data->ns_list[i]);
- if (data->ns_list)
- free(data->ns_list);
- memset(data, 0, sizeof(struct dns_data));
-}
-
-//static double last_dns_update;
-
-static void update_dns_data(void)
-{
- FILE *fp;
- char line[256];
- struct dns_data *data = &info.nameserver_info;
-
- /* maybe updating too often causes higher load because of /etc lying on a real FS
- if (current_update_time - last_dns_update < 10.0)
- return;
- else
- last_dns_update = current_update_time;
- */
-
- free_dns_data();
-
- if ((fp = fopen("/etc/resolv.conf", "r")) == NULL)
- return;
- while(!feof(fp)) {
- if (fgets(line, 255, fp) == NULL) {
- break;
- }
- if (!strncmp(line, "nameserver ", 11)) {
- line[strlen(line) - 1] = '\0'; // remove trailing newline
- data->nscount++;
- data->ns_list = realloc(data->ns_list, data->nscount * sizeof(char *));
- data->ns_list[data->nscount - 1] = strndup(line + 11, text_buffer_size);
- }
- }
- fclose(fp);
-}
-
void format_seconds(char *buf, unsigned int n, long seconds)
{
long days;
int hours, minutes;
+ if (times_in_seconds()) {
+ snprintf(buf, n, "%ld", seconds);
+ return;
+ }
+
days = seconds / 86400;
seconds %= 86400;
hours = seconds / 3600;
long days;
int hours, minutes;
+ if (times_in_seconds()) {
+ snprintf(buf, n, "%ld", seconds);
+ return;
+ }
+
days = seconds / 86400;
seconds %= 86400;
hours = seconds / 3600;
}
}
-static double last_meminfo_update;
-static double last_fs_update;
-
-unsigned long long need_mask;
-int no_buffers;
-
-#define NEED(a) ((need_mask & (1 << a)) && ((info.mask & (1 << a)) == 0))
-
-void update_stuff(void)
+/* Linked list containing the functions to call upon each update interval.
+ * Populated while initialising text objects in construct_text_object(). */
+static struct update_cb {
+ struct update_cb *next;
+ int (*func)(void);
+ pthread_t thread;
+ sem_t start_wait, end_wait;
+
+ /* set to 1 when starting the thread
+ * set to 0 to request thread termination */
+ volatile char running;
+} update_cb_head = {
+ .next = NULL,
+ .func = NULL,
+};
+
+static void *run_update_callback(void *) __attribute__((noreturn));
+
+static int threading_started = 0;
+
+/* Register an update callback. Don't allow duplicates, to minimise side
+ * effects and overhead. */
+void add_update_callback(int (*func)(void))
{
- unsigned int i;
+ struct update_cb *uc = &update_cb_head;
- info.mask = 0;
+ if (!func)
+ return;
- if (no_buffers) {
- need_mask |= 1 << INFO_BUFFERS;
+ while (uc->next) {
+ if (uc->next->func == func)
+ return;
+ uc = uc->next;
}
- /* clear speeds and up status in case device was removed and doesn't get
- * updated */
+ uc->next = malloc(sizeof(struct update_cb));
+ uc = uc->next;
- for (i = 0; i < 16; i++) {
- if (netstats[i].dev) {
- netstats[i].up = 0;
- netstats[i].recv_speed = 0.0;
- netstats[i].trans_speed = 0.0;
+ memset(uc, 0, sizeof(struct update_cb));
+ uc->func = func;
+ sem_init(&uc->start_wait, 0, 0);
+ sem_init(&uc->end_wait, 0, 0);
+
+ if (threading_started) {
+ if (!uc->running) {
+ uc->running = 1;
+ pthread_create(&uc->thread, NULL, &run_update_callback, uc);
}
}
+}
- prepare_update();
+/* Free the list element uc and all decendants recursively. */
+static void __free_update_callbacks(struct update_cb *uc)
+{
+ if (uc->next)
+ __free_update_callbacks(uc->next);
- if (NEED(INFO_UPTIME)) {
- update_uptime();
+ if (uc->running) {
+ /* send cancellation request, then trigger and join the thread */
+ uc->running = 0;
+ sem_post(&uc->start_wait);
}
-
- if (NEED(INFO_PROCS)) {
- update_total_processes();
+ if (pthread_join(uc->thread, NULL)) {
+ NORM_ERR("Error destroying thread");
}
- if (NEED(INFO_RUN_PROCS)) {
- update_running_processes();
- }
+ /* finally destroy the semaphores */
+ sem_destroy(&uc->start_wait);
+ sem_destroy(&uc->end_wait);
- if (NEED(INFO_CPU)) {
- update_cpu_usage();
- }
+ free(uc);
+}
- if (NEED(INFO_NET)) {
- update_net_stats();
- }
+/* Free the whole list of update callbacks. */
+void free_update_callbacks(void)
+{
+ if (update_cb_head.next)
+ __free_update_callbacks(update_cb_head.next);
+ update_cb_head.next = NULL;
+}
- if (NEED(INFO_DISKIO)) {
- update_diskio();
- }
+/* We cannot start threads before we forked to background, because the threads
+ * would remain in the wrong process. Because of that, add_update_callback()
+ * doesn't create threads before start_update_threading() is called.
+ * start_update_threading() starts all threads previously registered, and sets a
+ * flag so that future threads are automagically started by
+ * add_update_callback().
+ * This text is almost longer than the actual code.
+ */
+void start_update_threading(void)
+{
+ struct update_cb *uc;
-#if defined(__linux__)
- if (NEED(INFO_I8K)) {
- update_i8k();
- }
-#endif /* __linux__ */
+ threading_started = 1;
-#ifdef MPD
- if (NEED(INFO_MPD)) {
- update_mpd();
+ for (uc = update_cb_head.next; uc; uc = uc->next) {
+ if (!uc->running) {
+ uc->running = 1;
+ pthread_create(&uc->thread, NULL, &run_update_callback, uc);
+ }
}
-#endif
+}
-#ifdef MOC
- if (NEED(INFO_MOC)) {
- run_moc_thread(info.music_player_interval * 100000);
+static void *run_update_callback(void *data)
+{
+ struct update_cb *ucb = data;
+
+ if (!ucb || !ucb->func) pthread_exit(NULL);
+
+ while (1) {
+ if (sem_wait(&ucb->start_wait)) pthread_exit(NULL);
+ if (ucb->running == 0) pthread_exit(NULL);
+ if((*ucb->func)()) {
+ ucb->next = ucb; //this is normally not be possible, so we use it to show that there was a critical error
+ sem_post(&ucb->end_wait);
+ sem_post(&ucb->end_wait);
+ pthread_exit(NULL);
+ }
+ if (sem_post(&ucb->end_wait)) pthread_exit(NULL);
}
-#endif
+}
-#ifdef XMMS2
- if (NEED(INFO_XMMS2)) {
- update_xmms2();
- }
-#endif
+int no_buffers;
-#ifdef AUDACIOUS
- if (NEED(INFO_AUDACIOUS)) {
- update_audacious();
- }
-#endif
+void update_stuff(void)
+{
+ int i;
+ struct update_cb *uc;
-#ifdef BMPX
- if (NEED(INFO_BMPX)) {
- update_bmpx();
- }
-#endif
+ /* clear speeds and up status in case device was removed and doesn't get
+ * updated */
- if (NEED(INFO_LOADAVG)) {
- update_load_average();
+ #ifdef HAVE_OPENMP
+ #pragma omp parallel for schedule(dynamic,10)
+ #endif /* HAVE_OPENMP */
+ for (i = 0; i < MAX_NET_INTERFACES; i++) {
+ if (netstats[i].dev) {
+ netstats[i].up = 0;
+ netstats[i].recv_speed = 0.0;
+ netstats[i].trans_speed = 0.0;
+ }
}
- if ((NEED(INFO_MEM) || NEED(INFO_BUFFERS) || NEED(INFO_TOP))
- && current_update_time - last_meminfo_update > 6.9) {
- update_meminfo();
- if (no_buffers) {
- info.mem -= info.bufmem;
- info.memeasyfree += info.bufmem;
+ prepare_update();
+
+ for (uc = update_cb_head.next; uc; uc = uc->next) {
+ if (sem_post(&uc->start_wait)) {
+ NORM_ERR("Semaphore error");
}
- last_meminfo_update = current_update_time;
}
-
-#ifdef X11
- if (NEED(INFO_X11)) {
- update_x11info();
+ /* need to synchronise here, otherwise locking is needed (as data
+ * would be printed with some update callbacks still running) */
+ for (uc = update_cb_head.next; uc; uc = uc->next) {
+ sem_wait(&uc->end_wait);
+ if(uc == uc->next) {
+ pthread_join(uc->thread, NULL);
+ free(uc);
+ exit(EXIT_FAILURE);
+ }
}
-#endif
- if (NEED(INFO_TOP)) {
- update_top();
+ /* XXX: move the following into the update_meminfo() functions? */
+ if (no_buffers) {
+ info.mem -= info.bufmem;
+ info.memeasyfree += info.bufmem;
}
+}
- /* update_fs_stat() won't do anything if there aren't fs -things */
- if (NEED(INFO_FS) && current_update_time - last_fs_update > 12.9) {
- update_fs_stats();
- last_fs_update = current_update_time;
- }
-#ifdef TCP_PORT_MONITOR
- if (NEED(INFO_TCP_PORT_MONITOR)) {
- tcp_portmon_update();
- }
-#endif
- if (NEED(INFO_ENTROPY)) {
- update_entropy();
- }
-#if defined(__linux__)
- if (NEED(INFO_USERS)) {
- update_users();
+/* Ohkie to return negative values for temperatures */
+int round_to_int_temp(float f)
+{
+ if (f >= 0.0) {
+ return (int) (f + 0.5);
+ } else {
+ return (int) (f - 0.5);
}
- if (NEED(INFO_GW)) {
- update_gateway_info();
+}
+/* Don't return negative values for cpugraph, bar, gauge, percentage.
+ * Causes unreasonable numbers to show */
+unsigned int round_to_int(float f)
+{
+ if (f >= 0.0) {
+ return (int) (f + 0.5);
+ } else {
+ return 0;
}
-#endif /* __linux__ */
- if (NEED(INFO_DNS)) {
- update_dns_data();
+}
+
+void scan_loadavg_arg(struct text_object *obj, const char *arg)
+{
+ obj->data.i = 0;
+ if (arg && !arg[1] && isdigit(arg[0])) {
+ obj->data.i = atoi(arg);
+ if (obj->data.i > 3 || obj->data.i < 1) {
+ NORM_ERR("loadavg arg needs to be in range (1,3)");
+ obj->data.i = 0;
+ }
}
+ /* convert to array index (or the default (-1)) */
+ obj->data.i--;
}
-int round_to_int(float f)
+void print_loadavg(struct text_object *obj, char *p, int p_max_size)
{
- if (f >= 0.0) {
- return (int) (f + 0.5);
+ float *v = info.loadavg;
+
+ if (obj->data.i < 0) {
+ snprintf(p, p_max_size, "%.2f %.2f %.2f", v[0], v[1], v[2]);
} else {
- return (int) (f - 0.5);
+ snprintf(p, p_max_size, "%.2f", v[obj->data.i]);
}
}
+
+#ifdef X11
+void scan_loadgraph_arg(struct text_object *obj, const char *arg)
+{
+ char *buf = 0;
+
+ buf = scan_graph(obj, arg, 0);
+ if (buf)
+ free(buf);
+}
+
+void print_loadgraph(struct text_object *obj, char *p, int p_max_size)
+{
+ new_graph(obj, p, p_max_size, info.loadavg[0]);
+}
+#endif /* X11 */
projects / monky / blobdiff