2010-01-04 17:06:14 +00:00
|
|
|
/* -*- mode: c++; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*-
|
|
|
|
* vim: ts=4 sw=4 noet ai cindent syntax=cpp
|
2009-07-28 21:44:22 +00:00
|
|
|
*
|
|
|
|
* Conky, a system monitor, based on torsmo
|
2005-08-05 01:06:17 +00:00
|
|
|
*
|
2007-08-10 19:53:44 +00:00
|
|
|
* Any original torsmo code is licensed under the BSD license
|
|
|
|
*
|
|
|
|
* All code written since the fork of torsmo is licensed under the GPL
|
|
|
|
*
|
|
|
|
* Please see COPYING for details
|
|
|
|
*
|
|
|
|
* Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
|
2010-01-01 23:46:17 +00:00
|
|
|
* Copyright (c) 2005-2010 Brenden Matthews, Philip Kovacs, et. al.
|
2008-02-20 20:30:45 +00:00
|
|
|
* (see AUTHORS)
|
2007-08-10 19:53:44 +00:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* 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 3 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
|
2008-02-20 20:30:45 +00:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2005-08-05 01:06:17 +00:00
|
|
|
*
|
2008-12-09 23:35:49 +00:00
|
|
|
*/
|
2005-08-05 01:06:17 +00:00
|
|
|
|
2008-12-15 21:40:24 +00:00
|
|
|
#include "config.h"
|
2009-08-07 07:24:24 +00:00
|
|
|
#include "conky.h"
|
2008-12-15 21:40:24 +00:00
|
|
|
#include "fs.h"
|
|
|
|
#include "logging.h"
|
2009-10-17 14:43:12 +00:00
|
|
|
#include "net_stat.h"
|
2009-10-25 12:49:10 +00:00
|
|
|
#include "specials.h"
|
2009-11-26 00:38:53 +00:00
|
|
|
#include "temphelper.h"
|
2009-11-19 22:39:08 +00:00
|
|
|
#include "timeinfo.h"
|
2009-11-26 00:30:58 +00:00
|
|
|
#include "top.h"
|
2005-07-20 00:30:40 +00:00
|
|
|
#include <ctype.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sys/time.h>
|
2009-03-28 23:15:20 +00:00
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <netinet/in.h>
|
2007-08-30 17:21:30 +00:00
|
|
|
#include <pthread.h>
|
2009-09-20 01:11:38 +00:00
|
|
|
#include <semaphore.h>
|
2009-03-30 05:35:42 +00:00
|
|
|
#include <unistd.h>
|
2009-07-22 20:08:31 +00:00
|
|
|
#include <fcntl.h>
|
2010-01-04 17:06:14 +00:00
|
|
|
#include <vector>
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2008-12-15 21:40:24 +00:00
|
|
|
/* check for OS and include appropriate headers */
|
|
|
|
#if defined(__linux__)
|
|
|
|
#include "linux.h"
|
|
|
|
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
|
|
|
|
#include "freebsd.h"
|
|
|
|
#elif defined(__OpenBSD__)
|
|
|
|
#include "openbsd.h"
|
|
|
|
#endif
|
|
|
|
|
2009-07-21 21:41:47 +00:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2008-04-02 19:46:09 +00:00
|
|
|
#ifndef HAVE_STRNDUP
|
|
|
|
// use our own strndup() if it's not available
|
|
|
|
char *strndup(const char *s, size_t n)
|
|
|
|
{
|
2008-12-08 23:12:23 +00:00
|
|
|
if (strlen(s) > n) {
|
|
|
|
char *ret = malloc(n + 1);
|
2008-04-02 19:46:09 +00:00
|
|
|
strncpy(ret, s, n);
|
2008-12-08 23:12:23 +00:00
|
|
|
ret[n] = 0;
|
2008-04-02 19:46:09 +00:00
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
return strdup(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* HAVE_STRNDUP */
|
|
|
|
|
2009-08-07 07:24:24 +00:00
|
|
|
void update_uname(void)
|
2005-07-20 00:30:40 +00:00
|
|
|
{
|
2009-08-07 07:24:24 +00:00
|
|
|
uname(&info.uname_s);
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
|
2008-03-29 02:01:03 +00:00
|
|
|
double get_time(void)
|
2005-07-20 00:30:40 +00:00
|
|
|
{
|
|
|
|
struct timeval tv;
|
2008-02-20 20:30:45 +00:00
|
|
|
|
2005-07-20 00:30:40 +00:00
|
|
|
gettimeofday(&tv, 0);
|
2005-11-27 06:56:35 +00:00
|
|
|
return tv.tv_sec + (tv.tv_usec / 1000000.0);
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
|
2009-05-25 04:33:47 +00:00
|
|
|
/* 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 {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("$HOME environment variable doesn't exist");
|
2009-05-25 04:33:47 +00:00
|
|
|
strncpy(dest, source, DEFAULT_TEXT_BUFFER_SIZE);
|
|
|
|
}
|
2009-12-28 20:21:28 +00:00
|
|
|
} else if (dest != source) { //see changelog 2009-06-29 if you doubt that this check is necessary
|
2009-05-25 04:33:47 +00:00
|
|
|
strncpy(dest, source, DEFAULT_TEXT_BUFFER_SIZE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-22 20:08:31 +00:00
|
|
|
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) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("can't open %s: %s", file, strerror(errno));
|
2009-07-22 20:08:31 +00:00
|
|
|
if (reported) {
|
|
|
|
*reported = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
2005-07-20 00:30:40 +00:00
|
|
|
FILE *open_file(const char *file, int *reported)
|
|
|
|
{
|
2009-05-25 04:33:47 +00:00
|
|
|
char path[DEFAULT_TEXT_BUFFER_SIZE];
|
|
|
|
FILE *fp = 0;
|
|
|
|
|
|
|
|
to_real_path(path, file);
|
|
|
|
fp = fopen(file, "r");
|
2008-02-20 20:30:45 +00:00
|
|
|
|
2005-07-20 00:30:40 +00:00
|
|
|
if (!fp) {
|
|
|
|
if (!reported || *reported == 0) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("can't open %s: %s", file, strerror(errno));
|
2008-02-20 20:30:45 +00:00
|
|
|
if (reported) {
|
2005-07-20 00:30:40 +00:00
|
|
|
*reported = 1;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
2009-07-22 20:08:31 +00:00
|
|
|
return NULL;
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return fp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void variable_substitute(const char *s, char *dest, unsigned int n)
|
|
|
|
{
|
|
|
|
while (*s && n > 1) {
|
|
|
|
if (*s == '$') {
|
|
|
|
s++;
|
|
|
|
if (*s != '$') {
|
|
|
|
char buf[256];
|
|
|
|
const char *a, *var;
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
/* variable is either $foo or ${foo} */
|
|
|
|
if (*s == '{') {
|
|
|
|
s++;
|
|
|
|
a = s;
|
2008-02-20 20:30:45 +00:00
|
|
|
while (*s && *s != '}') {
|
2005-07-20 00:30:40 +00:00
|
|
|
s++;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
} else {
|
|
|
|
a = s;
|
2008-02-20 20:30:45 +00:00
|
|
|
while (*s && (isalnum((int) *s) || *s == '_')) {
|
2005-07-20 00:30:40 +00:00
|
|
|
s++;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* copy variable to buffer and look it up */
|
|
|
|
len = (s - a > 255) ? 255 : (s - a);
|
|
|
|
strncpy(buf, a, len);
|
|
|
|
buf[len] = '\0';
|
|
|
|
|
2008-02-20 20:30:45 +00:00
|
|
|
if (*s == '}') {
|
2005-07-20 00:30:40 +00:00
|
|
|
s++;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
|
|
|
|
var = getenv(buf);
|
|
|
|
|
|
|
|
if (var) {
|
|
|
|
/* add var to dest */
|
|
|
|
len = strlen(var);
|
2008-02-20 20:30:45 +00:00
|
|
|
if (len >= n) {
|
2005-07-20 00:30:40 +00:00
|
|
|
len = n - 1;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
strncpy(dest, var, len);
|
|
|
|
dest += len;
|
|
|
|
n -= len;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*dest++ = *s++;
|
|
|
|
n--;
|
|
|
|
}
|
|
|
|
|
|
|
|
*dest = '\0';
|
|
|
|
}
|
|
|
|
|
2008-06-19 07:04:11 +00:00
|
|
|
void format_seconds(char *buf, unsigned int n, long seconds)
|
2005-07-20 00:30:40 +00:00
|
|
|
{
|
2008-06-19 07:04:11 +00:00
|
|
|
long days;
|
|
|
|
int hours, minutes;
|
|
|
|
|
2009-11-19 22:39:08 +00:00
|
|
|
if (times_in_seconds()) {
|
|
|
|
snprintf(buf, n, "%ld", seconds);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-06-19 07:04:11 +00:00
|
|
|
days = seconds / 86400;
|
|
|
|
seconds %= 86400;
|
|
|
|
hours = seconds / 3600;
|
|
|
|
seconds %= 3600;
|
|
|
|
minutes = seconds / 60;
|
|
|
|
seconds %= 60;
|
|
|
|
|
|
|
|
if (days > 0) {
|
|
|
|
snprintf(buf, n, "%ldd %dh %dm", days, hours, minutes);
|
2008-02-20 20:30:45 +00:00
|
|
|
} else {
|
2008-06-19 07:04:11 +00:00
|
|
|
snprintf(buf, n, "%dh %dm %lds", hours, minutes, seconds);
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
|
2008-06-19 07:04:11 +00:00
|
|
|
void format_seconds_short(char *buf, unsigned int n, long seconds)
|
2005-07-20 00:30:40 +00:00
|
|
|
{
|
2008-06-19 07:04:11 +00:00
|
|
|
long days;
|
|
|
|
int hours, minutes;
|
|
|
|
|
2009-11-19 22:39:08 +00:00
|
|
|
if (times_in_seconds()) {
|
|
|
|
snprintf(buf, n, "%ld", seconds);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-06-19 07:04:11 +00:00
|
|
|
days = seconds / 86400;
|
|
|
|
seconds %= 86400;
|
|
|
|
hours = seconds / 3600;
|
|
|
|
seconds %= 3600;
|
|
|
|
minutes = seconds / 60;
|
|
|
|
seconds %= 60;
|
|
|
|
|
|
|
|
if (days > 0) {
|
|
|
|
snprintf(buf, n, "%ldd %dh", days, hours);
|
|
|
|
} else if (hours > 0) {
|
|
|
|
snprintf(buf, n, "%dh %dm", hours, minutes);
|
2008-02-20 20:30:45 +00:00
|
|
|
} else {
|
2008-06-19 07:04:11 +00:00
|
|
|
snprintf(buf, n, "%dm %lds", minutes, seconds);
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
|
2009-09-09 22:12:56 +00:00
|
|
|
/* Linked list containing the functions to call upon each update interval.
|
|
|
|
* Populated while initialising text objects in construct_text_object(). */
|
2010-01-04 17:06:14 +00:00
|
|
|
struct update_cb {
|
2009-09-06 22:14:54 +00:00
|
|
|
struct update_cb *next;
|
|
|
|
void (*func)(void);
|
2009-09-10 23:18:38 +00:00
|
|
|
pthread_t thread;
|
2009-09-20 01:11:38 +00:00
|
|
|
sem_t start_wait, end_wait;
|
2010-01-04 17:06:14 +00:00
|
|
|
update_cb() : next(NULL), func(NULL) {}
|
2009-09-22 16:19:08 +00:00
|
|
|
|
|
|
|
/* set to 1 when starting the thread
|
|
|
|
* set to 0 to request thread termination */
|
|
|
|
volatile char running;
|
2009-09-06 22:14:54 +00:00
|
|
|
};
|
|
|
|
|
2010-01-04 17:06:14 +00:00
|
|
|
static struct update_cb update_cb_head;
|
|
|
|
|
2010-01-02 21:31:09 +00:00
|
|
|
static void *run_update_callback(void *) __attribute__((noreturn));
|
|
|
|
|
|
|
|
static int threading_started = 0;
|
2009-09-20 01:11:38 +00:00
|
|
|
|
2009-09-09 22:12:56 +00:00
|
|
|
/* Register an update callback. Don't allow duplicates, to minimise side
|
|
|
|
* effects and overhead. */
|
2009-09-06 22:14:54 +00:00
|
|
|
void add_update_callback(void (*func)(void))
|
|
|
|
{
|
|
|
|
struct update_cb *uc = &update_cb_head;
|
|
|
|
|
2009-09-06 23:22:16 +00:00
|
|
|
if (!func)
|
|
|
|
return;
|
|
|
|
|
2009-09-06 22:14:54 +00:00
|
|
|
while (uc->next) {
|
|
|
|
if (uc->next->func == func)
|
|
|
|
return;
|
|
|
|
uc = uc->next;
|
|
|
|
}
|
2009-09-20 01:11:38 +00:00
|
|
|
|
2010-01-04 17:06:14 +00:00
|
|
|
uc->next = new update_cb;
|
2009-09-20 01:11:38 +00:00
|
|
|
uc = uc->next;
|
|
|
|
|
|
|
|
memset(uc, 0, sizeof(struct update_cb));
|
|
|
|
uc->func = func;
|
|
|
|
sem_init(&uc->start_wait, 0, 0);
|
|
|
|
sem_init(&uc->end_wait, 0, 0);
|
|
|
|
|
2009-09-22 16:19:08 +00:00
|
|
|
if (threading_started) {
|
2010-01-02 21:31:09 +00:00
|
|
|
if (!uc->running) {
|
|
|
|
uc->running = 1;
|
|
|
|
pthread_create(&uc->thread, NULL, &run_update_callback, uc);
|
|
|
|
}
|
2009-09-22 16:19:08 +00:00
|
|
|
}
|
2009-09-06 22:14:54 +00:00
|
|
|
}
|
|
|
|
|
2009-09-09 22:12:56 +00:00
|
|
|
/* Free the list element uc and all decendants recursively. */
|
2009-09-06 22:14:54 +00:00
|
|
|
static void __free_update_callbacks(struct update_cb *uc)
|
|
|
|
{
|
|
|
|
if (uc->next)
|
|
|
|
__free_update_callbacks(uc->next);
|
2009-09-20 01:11:38 +00:00
|
|
|
|
2009-09-22 16:19:08 +00:00
|
|
|
if (uc->running) {
|
|
|
|
/* send cancellation request, then trigger and join the thread */
|
|
|
|
uc->running = 0;
|
|
|
|
sem_post(&uc->start_wait);
|
2010-01-02 21:31:09 +00:00
|
|
|
}
|
|
|
|
if (pthread_join(uc->thread, NULL)) {
|
|
|
|
NORM_ERR("Error destroying thread");
|
2009-09-22 16:19:08 +00:00
|
|
|
}
|
2009-09-20 01:11:38 +00:00
|
|
|
|
|
|
|
/* finally destroy the semaphores */
|
|
|
|
sem_destroy(&uc->start_wait);
|
|
|
|
sem_destroy(&uc->end_wait);
|
|
|
|
|
2010-01-05 03:20:47 +00:00
|
|
|
delete uc;
|
2009-09-06 22:14:54 +00:00
|
|
|
}
|
|
|
|
|
2009-09-09 22:12:56 +00:00
|
|
|
/* Free the whole list of update callbacks. */
|
2009-09-06 22:14:54 +00:00
|
|
|
void free_update_callbacks(void)
|
|
|
|
{
|
|
|
|
if (update_cb_head.next)
|
|
|
|
__free_update_callbacks(update_cb_head.next);
|
|
|
|
update_cb_head.next = NULL;
|
|
|
|
}
|
|
|
|
|
2009-09-22 16:19:08 +00:00
|
|
|
/* 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;
|
|
|
|
|
|
|
|
threading_started = 1;
|
|
|
|
|
2010-01-02 21:31:09 +00:00
|
|
|
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);
|
|
|
|
}
|
2009-09-22 16:19:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-10 23:18:38 +00:00
|
|
|
static void *run_update_callback(void *data)
|
|
|
|
{
|
2010-01-04 17:06:14 +00:00
|
|
|
struct update_cb *ucb = static_cast<struct update_cb *>(data);
|
2009-09-10 23:18:38 +00:00
|
|
|
|
2010-01-02 21:31:09 +00:00
|
|
|
if (!ucb || !ucb->func) pthread_exit(NULL);
|
|
|
|
|
2009-09-20 01:11:38 +00:00
|
|
|
while (1) {
|
2010-01-02 21:31:09 +00:00
|
|
|
if (sem_wait(&ucb->start_wait)) pthread_exit(NULL);
|
|
|
|
if (ucb->running == 0) pthread_exit(NULL);
|
2009-09-20 01:11:38 +00:00
|
|
|
(*ucb->func)();
|
2010-01-02 21:31:09 +00:00
|
|
|
if (sem_post(&ucb->end_wait)) pthread_exit(NULL);
|
2009-09-20 01:11:38 +00:00
|
|
|
}
|
2009-09-10 23:18:38 +00:00
|
|
|
}
|
|
|
|
|
2010-01-04 17:06:14 +00:00
|
|
|
extern int no_buffers;
|
2009-08-07 07:24:24 +00:00
|
|
|
|
|
|
|
void update_stuff(void)
|
2005-07-20 00:30:40 +00:00
|
|
|
{
|
2009-05-24 20:02:33 +00:00
|
|
|
int i;
|
2009-09-06 22:14:54 +00:00
|
|
|
struct update_cb *uc;
|
2008-02-20 20:30:45 +00:00
|
|
|
|
2005-07-20 00:30:40 +00:00
|
|
|
/* clear speeds and up status in case device was removed and doesn't get
|
2008-02-20 20:30:45 +00:00
|
|
|
* updated */
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2009-05-24 15:41:35 +00:00
|
|
|
#ifdef HAVE_OPENMP
|
2009-07-18 19:46:36 +00:00
|
|
|
#pragma omp parallel for schedule(dynamic,10)
|
2009-05-24 15:41:35 +00:00
|
|
|
#endif /* HAVE_OPENMP */
|
2009-11-07 22:46:46 +00:00
|
|
|
for (i = 0; i < MAX_NET_INTERFACES; i++) {
|
2005-07-20 00:30:40 +00:00
|
|
|
if (netstats[i].dev) {
|
|
|
|
netstats[i].up = 0;
|
|
|
|
netstats[i].recv_speed = 0.0;
|
|
|
|
netstats[i].trans_speed = 0.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
prepare_update();
|
|
|
|
|
2010-01-02 21:31:09 +00:00
|
|
|
for (uc = update_cb_head.next; uc; uc = uc->next) {
|
|
|
|
if (sem_post(&uc->start_wait)) {
|
|
|
|
NORM_ERR("Semaphore error");
|
|
|
|
}
|
|
|
|
}
|
2009-09-10 23:18:38 +00:00
|
|
|
/* need to synchronise here, otherwise locking is needed (as data
|
|
|
|
* would be printed with some update callbacks still running) */
|
2009-09-06 22:14:54 +00:00
|
|
|
for (uc = update_cb_head.next; uc; uc = uc->next)
|
2009-09-20 01:11:38 +00:00
|
|
|
sem_wait(&uc->end_wait);
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2009-09-06 23:05:33 +00:00
|
|
|
/* XXX: move the following into the update_meminfo() functions? */
|
|
|
|
if (no_buffers) {
|
|
|
|
info.mem -= info.bufmem;
|
|
|
|
info.memeasyfree += info.bufmem;
|
2008-06-21 20:37:58 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
2005-08-30 14:59:37 +00:00
|
|
|
|
2009-05-18 05:30:10 +00:00
|
|
|
/* Ohkie to return negative values for temperatures */
|
|
|
|
int round_to_int_temp(float f)
|
2005-08-30 14:59:37 +00:00
|
|
|
{
|
2008-02-19 03:33:12 +00:00
|
|
|
if (f >= 0.0) {
|
|
|
|
return (int) (f + 0.5);
|
|
|
|
} else {
|
|
|
|
return (int) (f - 0.5);
|
|
|
|
}
|
2005-08-30 14:59:37 +00:00
|
|
|
}
|
2009-05-18 05:30:10 +00:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
}
|
2009-07-13 05:31:57 +00:00
|
|
|
|
2009-10-25 12:49:10 +00:00
|
|
|
void scan_loadavg_arg(struct text_object *obj, const char *arg)
|
|
|
|
{
|
2009-10-25 13:13:26 +00:00
|
|
|
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;
|
2009-10-25 12:49:10 +00:00
|
|
|
}
|
|
|
|
}
|
2009-10-25 13:13:26 +00:00
|
|
|
/* convert to array index (or the default (-1)) */
|
|
|
|
obj->data.i--;
|
2009-10-25 12:49:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void print_loadavg(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
float *v = info.loadavg;
|
|
|
|
|
2009-10-25 13:13:26 +00:00
|
|
|
if (obj->data.i < 0) {
|
|
|
|
snprintf(p, p_max_size, "%.2f %.2f %.2f", v[0], v[1], v[2]);
|
|
|
|
} else {
|
|
|
|
snprintf(p, p_max_size, "%.2f", v[obj->data.i]);
|
2009-10-25 12:49:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef X11
|
|
|
|
void scan_loadgraph_arg(struct text_object *obj, const char *arg)
|
|
|
|
{
|
|
|
|
char *buf = 0;
|
2009-10-25 13:13:26 +00:00
|
|
|
|
2009-11-05 23:05:08 +00:00
|
|
|
buf = scan_graph(obj, arg, 0);
|
2009-10-25 13:13:26 +00:00
|
|
|
if (buf)
|
2009-10-25 12:49:10 +00:00
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
|
2009-12-04 00:49:31 +00:00
|
|
|
double loadgraphval(struct text_object *obj)
|
2009-10-25 12:49:10 +00:00
|
|
|
{
|
2009-11-23 23:24:17 +00:00
|
|
|
(void)obj;
|
2009-11-15 23:54:15 +00:00
|
|
|
|
2009-12-04 00:49:31 +00:00
|
|
|
return info.loadavg[0];
|
2009-10-25 12:49:10 +00:00
|
|
|
}
|
|
|
|
#endif /* X11 */
|
2009-11-22 17:02:56 +00:00
|
|
|
|
2009-11-25 00:30:21 +00:00
|
|
|
uint8_t cpu_percentage(struct text_object *obj)
|
|
|
|
{
|
|
|
|
if (obj->data.i > info.cpu_count) {
|
|
|
|
NORM_ERR("obj->data.i %i info.cpu_count %i",
|
|
|
|
obj->data.i, info.cpu_count);
|
|
|
|
CRIT_ERR(NULL, NULL, "attempting to use more CPUs than you have!");
|
|
|
|
}
|
2010-01-05 15:59:50 +00:00
|
|
|
if (info.cpu_usage) {
|
|
|
|
return round_to_int(info.cpu_usage[obj->data.i] * 100.0);
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
2009-11-25 00:30:21 +00:00
|
|
|
}
|
|
|
|
|
2009-12-04 00:19:07 +00:00
|
|
|
double cpu_barval(struct text_object *obj)
|
2009-11-22 17:02:56 +00:00
|
|
|
{
|
2010-01-05 15:59:50 +00:00
|
|
|
if (info.cpu_usage) {
|
|
|
|
return info.cpu_usage[obj->data.i];
|
|
|
|
} else {
|
|
|
|
return 0.;
|
|
|
|
}
|
2009-11-23 22:15:34 +00:00
|
|
|
}
|
|
|
|
|
2009-11-25 23:09:38 +00:00
|
|
|
#define PRINT_HR_GENERATOR(name) \
|
|
|
|
void print_##name(struct text_object *obj, char *p, int p_max_size) \
|
|
|
|
{ \
|
|
|
|
(void)obj; \
|
|
|
|
human_readable(info.name * 1024, p, p_max_size); \
|
|
|
|
}
|
|
|
|
|
|
|
|
PRINT_HR_GENERATOR(mem)
|
|
|
|
PRINT_HR_GENERATOR(memeasyfree)
|
|
|
|
PRINT_HR_GENERATOR(memfree)
|
|
|
|
PRINT_HR_GENERATOR(memmax)
|
|
|
|
PRINT_HR_GENERATOR(swap)
|
|
|
|
PRINT_HR_GENERATOR(swapfree)
|
|
|
|
PRINT_HR_GENERATOR(swapmax)
|
|
|
|
|
2009-11-25 00:33:13 +00:00
|
|
|
uint8_t mem_percentage(struct text_object *obj)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
|
|
|
|
return (info.memmax ? round_to_int(info.mem * 100 / info.memmax) : 0);
|
|
|
|
}
|
|
|
|
|
2009-12-04 00:22:36 +00:00
|
|
|
double mem_barval(struct text_object *obj)
|
2009-11-23 22:15:34 +00:00
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
|
2009-12-04 00:22:36 +00:00
|
|
|
return info.memmax ? ((double)info.mem / info.memmax) : 0;
|
2009-11-22 17:02:56 +00:00
|
|
|
}
|
2009-11-30 22:55:48 +00:00
|
|
|
|
2009-11-25 00:34:54 +00:00
|
|
|
uint8_t swap_percentage(struct text_object *obj)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
|
|
|
|
return (info.swapmax ? round_to_int(info.swap * 100 / info.swapmax) : 0);
|
|
|
|
}
|
|
|
|
|
2009-12-04 00:25:41 +00:00
|
|
|
double swap_barval(struct text_object *obj)
|
2009-11-30 22:55:48 +00:00
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
|
2009-12-04 00:25:41 +00:00
|
|
|
return info.swapmax ? ((double)info.swap / info.swapmax) : 0;
|
2009-11-30 22:55:48 +00:00
|
|
|
}
|
2009-11-25 23:12:44 +00:00
|
|
|
|
|
|
|
void print_kernel(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
snprintf(p, p_max_size, "%s", info.uname_s.release);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_machine(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
snprintf(p, p_max_size, "%s", info.uname_s.machine);
|
|
|
|
}
|
2009-11-25 23:22:25 +00:00
|
|
|
|
|
|
|
void print_nodename(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
snprintf(p, p_max_size, "%s", info.uname_s.nodename);
|
|
|
|
}
|
2009-11-25 23:29:50 +00:00
|
|
|
|
|
|
|
void print_sysname(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
snprintf(p, p_max_size, "%s", info.uname_s.sysname);
|
|
|
|
}
|
2009-11-25 23:34:01 +00:00
|
|
|
|
|
|
|
void print_uptime(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
format_seconds(p, p_max_size, (int)info.uptime);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_uptime_short(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
format_seconds_short(p, p_max_size, (int)info.uptime);
|
|
|
|
}
|
2009-11-26 00:06:53 +00:00
|
|
|
|
|
|
|
void print_processes(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
spaced_print(p, p_max_size, "%hu", 4, info.procs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_running_processes(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
spaced_print(p, p_max_size, "%hu", 4, info.run_procs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_running_threads(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
spaced_print(p, p_max_size, "%hu", 4, info.run_threads);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_threads(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
spaced_print(p, p_max_size, "%hu", 4, info.threads);
|
|
|
|
}
|
2009-11-26 00:10:19 +00:00
|
|
|
|
|
|
|
void print_buffers(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
human_readable(info.buffers * 1024, p, p_max_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_cached(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
human_readable(info.cached * 1024, p, p_max_size);
|
|
|
|
}
|
2009-11-26 00:15:33 +00:00
|
|
|
|
|
|
|
void print_evaluate(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
evaluate(obj->data.s, p, p_max_size);
|
|
|
|
}
|
2009-11-26 00:30:58 +00:00
|
|
|
|
|
|
|
int if_empty_iftest(struct text_object *obj)
|
|
|
|
{
|
2010-01-04 17:06:14 +00:00
|
|
|
std::vector<char> buf(max_user_text);
|
2009-11-26 00:30:58 +00:00
|
|
|
int result = 1;
|
|
|
|
|
2010-01-04 17:06:14 +00:00
|
|
|
generate_text_internal(&(buf[0]), max_user_text, *obj->sub);
|
2009-11-26 00:30:58 +00:00
|
|
|
|
2010-01-04 17:06:14 +00:00
|
|
|
if (strlen(&(buf[0])) != 0) {
|
2009-11-26 00:30:58 +00:00
|
|
|
result = 0;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int check_contains(char *f, char *s)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
FILE *where = open_file(f, 0);
|
|
|
|
|
|
|
|
if (where) {
|
|
|
|
char buf1[256];
|
|
|
|
|
|
|
|
while (fgets(buf1, 256, where)) {
|
|
|
|
if (strstr(buf1, s)) {
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(where);
|
|
|
|
} else {
|
|
|
|
NORM_ERR("Could not open the file");
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int if_existing_iftest(struct text_object *obj)
|
|
|
|
{
|
|
|
|
char *spc;
|
|
|
|
int result = 1;
|
|
|
|
|
|
|
|
spc = strchr(obj->data.s, ' ');
|
|
|
|
if (!spc && access(obj->data.s, F_OK)) {
|
|
|
|
result = 0;
|
|
|
|
} else if (spc) {
|
|
|
|
*spc = '\0';
|
|
|
|
if (check_contains(obj->data.s, spc + 1))
|
|
|
|
result = 0;
|
|
|
|
*spc = ' ';
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
int if_running_iftest(struct text_object *obj)
|
|
|
|
{
|
|
|
|
#ifdef __linux__
|
|
|
|
if (!get_process_by_name(obj->data.s)) {
|
|
|
|
#else
|
|
|
|
if ((obj->data.s) && system(obj->data.s)) {
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
2009-11-26 00:38:53 +00:00
|
|
|
|
|
|
|
#ifndef __OpenBSD__
|
|
|
|
void print_acpitemp(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
temp_print(p, p_max_size, get_acpi_temperature(obj->data.i), TEMP_CELSIUS);
|
|
|
|
}
|
|
|
|
|
|
|
|
void free_acpitemp(struct text_object *obj)
|
|
|
|
{
|
|
|
|
close(obj->data.i);
|
|
|
|
}
|
|
|
|
#endif /* !__OpenBSD__ */
|
2009-11-26 00:42:54 +00:00
|
|
|
|
|
|
|
void print_freq(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
static int ok = 1;
|
|
|
|
if (ok) {
|
|
|
|
ok = get_freq(p, p_max_size, "%.0f", 1, obj->data.i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_freq_g(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
static int ok = 1;
|
|
|
|
if (ok) {
|
|
|
|
#ifndef __OpenBSD__
|
|
|
|
ok = get_freq(p, p_max_size, "%'.2f", 1000, obj->data.i);
|
|
|
|
#else
|
|
|
|
/* OpenBSD has no such flag (SUSv2) */
|
|
|
|
ok = get_freq(p, p_max_size, "%.2f", 1000, obj->data.i);
|
|
|
|
#endif /* __OpenBSD */
|
|
|
|
}
|
|
|
|
}
|
2009-11-26 00:51:41 +00:00
|
|
|
|
|
|
|
#ifndef __OpenBSD__
|
|
|
|
void print_acpifan(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
get_acpi_fan(p, p_max_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_acpiacadapter(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
get_acpi_ac_adapter(p, p_max_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_battery(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
get_battery_stuff(p, p_max_size, obj->data.s, BATTERY_STATUS);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_battery_time(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
get_battery_stuff(p, p_max_size, obj->data.s, BATTERY_TIME);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t battery_percentage(struct text_object *obj)
|
|
|
|
{
|
|
|
|
return get_battery_perct(obj->data.s);
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_battery_short(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
get_battery_short_status(p, p_max_size, obj->data.s);
|
|
|
|
}
|
|
|
|
#endif /* !__OpenBSD__ */
|
2009-11-29 11:47:11 +00:00
|
|
|
|
2009-11-29 11:56:09 +00:00
|
|
|
|
|
|
|
void print_blink(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
//blinking like this can look a bit ugly if the chars in the font don't have the same width
|
2010-01-04 17:06:14 +00:00
|
|
|
std::vector<char> buf(max_user_text);
|
2009-11-29 11:56:09 +00:00
|
|
|
static int visible = 1;
|
|
|
|
static int last_len = 0;
|
2009-12-01 11:35:23 +00:00
|
|
|
int i;
|
2009-11-29 11:56:09 +00:00
|
|
|
|
|
|
|
if (visible) {
|
2010-01-04 17:06:14 +00:00
|
|
|
generate_text_internal(&(buf[0]), max_user_text, *obj->sub);
|
|
|
|
last_len = strlen(&(buf[0]));
|
2009-11-29 11:56:09 +00:00
|
|
|
} else {
|
2009-12-01 11:35:23 +00:00
|
|
|
for (i = 0; i < last_len; i++)
|
2009-11-29 11:56:09 +00:00
|
|
|
buf[i] = ' ';
|
|
|
|
}
|
|
|
|
|
2010-01-04 17:06:14 +00:00
|
|
|
snprintf(p, p_max_size, "%s", &(buf[0]));
|
2009-11-29 11:56:09 +00:00
|
|
|
visible = !visible;
|
|
|
|
}
|
2009-11-29 11:59:04 +00:00
|
|
|
|
|
|
|
void print_include(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
2010-01-04 17:06:14 +00:00
|
|
|
std::vector<char> buf(max_user_text);
|
2009-11-29 11:59:04 +00:00
|
|
|
|
|
|
|
if (!obj->sub)
|
|
|
|
return;
|
|
|
|
|
2010-01-04 17:06:14 +00:00
|
|
|
generate_text_internal(&(buf[0]), max_user_text, *obj->sub);
|
|
|
|
snprintf(p, p_max_size, "%s", &(buf[0]));
|
2009-11-29 11:59:04 +00:00
|
|
|
}
|
2009-11-29 18:48:24 +00:00
|
|
|
|
2010-01-04 17:06:14 +00:00
|
|
|
void print_to_bytes(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
std::vector<char> buf(max_user_text);
|
|
|
|
long long bytes;
|
|
|
|
char unit[16]; // 16 because we can also have long names (like mega-bytes)
|
|
|
|
|
|
|
|
generate_text_internal(&(buf[0]), max_user_text, *obj->sub);
|
|
|
|
if(sscanf(&(buf[0]), "%lli%s", &bytes, unit) == 2 && strlen(unit) < 16){
|
|
|
|
if(strncasecmp("b", unit, 1) == 0) snprintf(&(buf[0]), max_user_text, "%lli", bytes);
|
|
|
|
else if(strncasecmp("k", unit, 1) == 0) snprintf(&(buf[0]), max_user_text, "%lli", bytes * 1024);
|
|
|
|
else if(strncasecmp("m", unit, 1) == 0) snprintf(&(buf[0]), max_user_text, "%lli", bytes * 1024 * 1024);
|
|
|
|
else if(strncasecmp("g", unit, 1) == 0) snprintf(&(buf[0]), max_user_text, "%lli", bytes * 1024 * 1024 * 1024);
|
|
|
|
else if(strncasecmp("t", unit, 1) == 0) snprintf(&(buf[0]), max_user_text, "%lli", bytes * 1024 * 1024 * 1024 * 1024);
|
|
|
|
}
|
|
|
|
snprintf(p, p_max_size, "%s", &(buf[0]));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-29 18:48:24 +00:00
|
|
|
void print_updates(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
|
|
|
(void)obj;
|
|
|
|
snprintf(p, p_max_size, "%d", get_total_updates());
|
|
|
|
}
|
2009-11-29 18:50:59 +00:00
|
|
|
|
|
|
|
int updatenr_iftest(struct text_object *obj)
|
|
|
|
{
|
|
|
|
if (get_total_updates() % get_updatereset() != obj->data.i - 1)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|