fs.c

系统任务管理器

/* GKrellM
|  Copyright (C) 1999-2006 Bill Wilson
|
|  Author:  Bill Wilson    [e-mail]
|  Latest versions might be found at:  http://gkrellm.net
|
|  This program is free software which I release under the GNU General Public
|  License. You may redistribute and/or modify this program under the terms
|  of that 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.  Version 2 is in the
|  COPYRIGHT file in the top level directory of this distribution.
| 
|  To get a copy of the GNU General Puplic License, write to the Free Software
|  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "gkrellm.h"
#include "gkrellm-private.h"
#include "gkrellm-sysdeps.h"


#define	DEFAULT_DATA_FORMAT	_("$t - $f free")

  /* Values for force_fs_check	*/
#define	FORCE_REDRAW	1
#define	FORCE_UPDATE	2

#define	FS_MOUNTING_ENABLED(fs)	\
				((fs)->fstab_mounting || *((fs)->launch_umount.command))

typedef struct
	{
	gchar		*directory;
	gchar		*device;
	gchar		*type;
	gchar		*options;
	}
	Mount;

typedef struct
	{
	gint		idx;
	GkrellmPanel *panel;
	GkrellmDecalbutton *md_button,
				*eject_button,
				*drawer_button;
	GkrellmDecal *mount_decal,
				*eject_decal,
				*text_decal;
	GkrellmKrell *krell;
	gchar		*label,			/* Actual utf8 label */
				*label_shadow;	/* Shadow label for gdk_draw functions */
	gboolean	label_is_data,
				restore_label,
				mouse_entered;

	Mount		mount;
	gboolean	fstab_mounting;
	GkrellmLauncher	launch_mount,
				launch_umount;

	GkrellmAlert *alert;

	gboolean	secondary,
				show_if_mounted,
				is_mounted,
				ejectable,
				is_nfs_fs;
	gchar		*eject_device;
	gint		eject_pending;
	gint		x_eject_button_target;

	GString		*pipe_gstring;		/* output of mount commands */

	gulong		krell_factor;		/* avoid krell math overflow */

	gboolean	busy;
	glong		blocks,
				bfree,
				bavail,
				bsize;
	}
	FSmon;

static void cb_alert_config(GkrellmAlert *ap, FSmon *fs);

static GkrellmMonitor
				*mon_fs;

static GList	*fs_mon_list,
				*mounts_list;
static GList	*fstab_list;

static gint		uid;

void			(*get_mounts_list)(),
				(*get_fsusage)(),
				(*get_fstab_list)();
gboolean		(*get_fstab_modified)();


/* If ejecting is available via an ioctl() or if there is an eject command,
|  set these up in gkrellm_sys_fs_init() by calling gkrellm_fs_setup_eject().
*/
void			(*eject_cdrom_func)(),
				(*close_cdrom_func)();
static gchar	*eject_cdrom_command,
				*close_cdrom_command;
static gboolean	cdrom_thread_busy;		/* for the cdrom_funcs */


static GtkWidget
				*fs_main_vbox,
				*fs_secondary_vbox;

static gboolean	fs_check_timeout	= 2,
				nfs_check_timeout	= 16;
static gint		check_tick;

static gint		secondary_monitors_shown;

static gint		n_fs_monitors;
static gint		force_fs_check;
static FSmon	*fs_in_motion;
static gint		x_fs_motion;
static gint		x_moved;
static gint		x_eject_button_open,
				x_eject_button_closed;

static gint		x_scroll;
static gint		text_decal_width;
static gint		cdrom_auto_eject;
static gint		binary_units;
static gboolean	mounting_supported = TRUE,
				ejecting_supported = FALSE;
static gboolean	have_secondary_panels;
static gchar	*data_format,
				*data_format_locale;

static gint		style_id;

static gchar *remote_fs_types[]	=
	{
	"nfs",
	"smbfs"
	};


static gboolean
setup_fs_interface(void)
    {
	uid = getuid();	/* only real root is allowed to mount/umount always */

	if (!get_fsusage && !_GK.client_mode && gkrellm_sys_fs_init())
		{
		get_fsusage = gkrellm_sys_fs_get_fsusage;
		get_mounts_list = gkrellm_sys_fs_get_mounts_list;
		get_fstab_list = gkrellm_sys_fs_get_fstab_list;
		get_fstab_modified = gkrellm_sys_fs_fstab_modified;
		}
	return get_fsusage ? TRUE : FALSE;
	}

void
gkrellm_fs_client_divert(void (*get_fsusage_func)(),
                void (*get_mounts_func)(), void (*get_fstab_func)(),
                gboolean (*fstab_modified_func)())
	{
	get_fsusage = get_fsusage_func;
	get_mounts_list = get_mounts_func;
	get_fstab_list = get_fstab_func;
	get_fstab_modified = fstab_modified_func;
	}

void
gkrellm_fs_setup_eject(gchar *eject_tray, gchar *close_tray,
			void (*eject_func)(), void (*close_func)())
	{
	eject_cdrom_command = g_strdup(eject_tray);
	close_cdrom_command = g_strdup(close_tray);
	eject_cdrom_func = eject_func;
	close_cdrom_func = close_func;
	if (eject_cdrom_command || eject_cdrom_func)
		ejecting_supported = TRUE;
	}

void
gkrellm_fs_add_to_mounts_list(gchar *dir, gchar *dev, gchar *type)
	{
	Mount	*m;

	m = g_new0(Mount, 1);
	m->directory = g_strdup(dir);
	m->device = g_strdup(dev);
	m->type = g_strdup(type);
	mounts_list = g_list_append(mounts_list, m);
	}

void
gkrellm_fs_add_to_fstab_list(gchar *dir, gchar *dev, gchar *type, gchar *opt)
	{
	Mount	*m;

	m = g_new0(Mount, 1);
	m->directory = g_strdup(dir);
	m->device = g_strdup(dev);
	m->type = g_strdup(type);
	m->options =  g_strdup(opt);
	fstab_list = g_list_append(fstab_list, m);
	}

void
gkrellm_fs_assign_fsusage_data(gpointer fspointer,
			glong blocks, glong bavail, glong bfree, glong bsize)
	{
	FSmon	*fs = (FSmon *) fspointer;

	fs->blocks = blocks;
	fs->bavail = bavail;
	fs->bfree  = bfree;
	fs->bsize  = bsize;
	}

void
gkrellm_fs_mounting_unsupported(void)
	{
	mounting_supported = FALSE;
	}

/* ======================================================================== */


static Mount *
in_fstab_list(gchar *s)
	{
	GList	*list;
	Mount	*m;

	for (list = fstab_list; list; list = list->next)
		{
		m = (Mount *)list->data;
		if (strcmp(s, m->directory) == 0)
			return m;
		}
	return NULL;
	}

static void
refresh_mounts_list(void)
	{
	Mount	*m;

	while (mounts_list)
		{
		m = (Mount *) mounts_list->data;
		g_free(m->directory);
		g_free(m->device);
		g_free(m->type);
		g_free(mounts_list->data);
		mounts_list = g_list_remove(mounts_list, mounts_list->data);
		}
	(*get_mounts_list)();
	}

static void
refresh_fstab_list(void)
	{
	Mount	*m;

	while (fstab_list)
		{
		m = (Mount *) fstab_list->data;
		g_free(m->device);
		g_free(m->directory);
		g_free(m->type);
		g_free(m->options);
		g_free(m);
		fstab_list = g_list_remove(fstab_list, fstab_list->data);
		}
	(*get_fstab_list)();
	}

static gint
fs_is_mounted(FSmon *fs)
	{
	Mount	*m_fs, *m_mounted;
	GList	*list;
	gint	i;

	fs->is_mounted = FALSE;
	m_fs = &fs->mount;
	for (list = mounts_list; list; list = list->next)
		{
		m_mounted = (Mount *) list->data;
		if (strcmp(m_fs->directory, m_mounted->directory))
			continue;
		fs->is_mounted = TRUE;
		fs->is_nfs_fs = FALSE;
		for (i = 0; i < (sizeof(remote_fs_types) / sizeof(gchar *)); ++i)
			{
			if (!strcmp(m_mounted->type, remote_fs_types[i]))
				{
				fs->is_nfs_fs = TRUE;
				break;
				}
			}
		}
	return fs->is_mounted;
	}

static GkrellmSizeAbbrev	fs_decimal_abbrev[] =
	{
	{ MB_SIZE(10),		MB_SIZE(1),		"%.2fM" },
	{ GB_SIZE(1),		MB_SIZE(1),		"%.0fM" },
	{ GB_SIZE(10),		GB_SIZE(1),		"%.2fG" },
	{ GB_SIZE(100),		GB_SIZE(1),		"%.1fG" },
	{ TB_SIZE(1),		GB_SIZE(1),		"%.0fG" },
	{ TB_SIZE(10),		TB_SIZE(1),		"%.2fT" },
	{ TB_SIZE(100),		TB_SIZE(1),		"%.1fT" }
	};

static GkrellmSizeAbbrev	fs_binary_abbrev[] =
	{
	{ MiB_SIZE(10),		MiB_SIZE(1),	"%.2fM" },
	{ GiB_SIZE(1),		MiB_SIZE(1),	"%.0fM" },
	{ GiB_SIZE(10),		GiB_SIZE(1),	"%.2fG" },
	{ GiB_SIZE(100),	GiB_SIZE(1),	"%.1fG" },
	{ TiB_SIZE(1),		GiB_SIZE(1),	"%.0fG" },
	{ TiB_SIZE(10),		TiB_SIZE(1),	"%.2fT" },
	{ TiB_SIZE(100),	TiB_SIZE(1),	"%.1fT" }
	};

static gint
format_fs_data(FSmon *fs, gchar *src_string, gchar *buf, gint size)
	{
	glong		b, u, a;
	gint		len;
	gchar		*s;
	gchar		tbuf[32], ubuf[32], abuf[32];
	gfloat		bsize, val;
	GkrellmSizeAbbrev *tbl;
	size_t		tbl_size;

	if (!buf || size < 1)
		return -1;
	--size;
	*buf = '\0';
	if (!src_string)
		return -1;

	b = fs->blocks;
	u = fs->blocks - fs->bfree;
	a = fs->bavail;					/* Can be negative on BSD	*/
	bsize = (gfloat) fs->bsize;

	tbl = binary_units ? &fs_binary_abbrev[0] : &fs_decimal_abbrev[0];
	tbl_size = binary_units
			? (sizeof(fs_binary_abbrev) / sizeof(GkrellmSizeAbbrev))
			: (sizeof(fs_decimal_abbrev) / sizeof(GkrellmSizeAbbrev));

	gkrellm_format_size_abbrev(tbuf, sizeof(tbuf), (gfloat) b * bsize, tbl, tbl_size);
	gkrellm_format_size_abbrev(ubuf, sizeof(ubuf), (gfloat) u * bsize, tbl, tbl_size);
	gkrellm_format_size_abbrev(abuf, sizeof(abuf), (gfloat) a * bsize, tbl, tbl_size);

	for (s = src_string; *s != '\0' && size > 0; ++s)
		{
		len = 1;
		if (*s == '$' && *(s + 1) != '\0')
			{
			switch(*(s + 1))
				{
				case 'D':
					if (fs->mount.directory)
						len = snprintf(buf, size, "%s", fs->mount.directory);
					break;
				case 'l':
				case 'L':
					len = snprintf(buf, size, "%s", fs->label_shadow);
					break;
				case 't':
					len = snprintf(buf, size, "%s", tbuf);
					break;
				case 'u':
					len = snprintf(buf, size, "%s", ubuf);
					break;
				case 'U':
					if (u + a > 0)
						val = 100.0 * (gfloat) u / (gfloat) (u + a);
					else
						val = 0;
					len = snprintf(buf, size, "%.0f%%", val);
					break;
				case 'f':
					len = snprintf(buf, size, "%s", abuf);
					break;
				case 'F':
					if (u + a > 0)
						val = 100.0 * (gfloat) a / (gfloat) (u + a);
					else
						val = 0;
					len = snprintf(buf, size, "%.0f%%", val);
					break;
				case 'H':
					len = snprintf(buf, size, "%s",
									gkrellm_sys_get_host_name());
					break;
				default:
					*buf = *s;
					if (size > 1)
						{
						*(buf + 1) = *(s + 1);
						++len;
						}
					break;
				}
			++s;
			}
		else
			*buf = *s;
		size -= len;
		buf += len;
		}
	*buf = '\0';
	return u + 1;
	}

  /* Draw the fs label or toggle the fs total blocks and blocks avail.
  */
static gint
draw_fs_text_decal(FSmon *fs, gint value)
	{
	GkrellmDecal		*d;
	GkrellmTextstyle	ts_save;
	gchar				buf[128];
	gint				x_off, w;

	d = fs->text_decal;
	if (value == 0)
		{
		gkrellm_decal_text_set_offset(d, 0, 0);
		gkrellm_draw_decal_text(fs->panel, d, fs->label_shadow, 0);
		}
	else if (!fs->busy)
		{
		ts_save = d->text_style;
		d->text_style = *gkrellm_meter_alt_textstyle(style_id);

		format_fs_data(fs, data_format_locale, buf, sizeof(buf));
		gkrellm_decal_scroll_text_set_markup(fs->panel, d, buf);
		gkrellm_decal_scroll_text_get_size(d, &w, NULL);
		if (w > d->w)
			x_off = d->w / 3 - x_scroll;
		else
			x_off = 0;
		gkrellm_decal_text_set_offset(d, x_off, 0);

		d->text_style = ts_save;
		}
	return w;
	}

static void
cb_command_process(GkrellmAlert *alert, gchar *src, gchar *dst, gint len,
			FSmon *fs)
	{
	format_fs_data(fs, src, dst, len);
	}

static gpointer
close_cdrom_thread(void *device)
	{
	(*close_cdrom_func)((gchar *) device);
	cdrom_thread_busy = FALSE;
	return NULL;
	}

static void
close_tray(FSmon *fs)
	{
	Mount			*m;
	static gchar	*close_target;
	gchar			buf[512];

	close_target = fs->eject_device;
	if (close_cdrom_command)
		{
		snprintf(buf, sizeof(buf), close_cdrom_command,
			*close_target ? close_target : fs->mount.directory);