disk.c

系统任务管理器

			continue;
		if (!disk->enabled || !disk->chart || !disk->chart->panel->decal_list)
			{
			display_possible |= disk->enabled;	/* Not created or rebuilding */
			continue;
			}
		decal = disk->temp_decal;
		p = disk->chart->panel;
		if (display_done)
			{
			if (gkrellm_is_decal_visible(decal))
				{
				gkrellm_make_decal_invisible(p, decal);
				p->label->position = disk->save_label_position;
				gkrellm_draw_panel_label(p);
				gkrellm_draw_panel_layers(p);
				}
			continue;
			}
		if (!gkrellm_is_decal_visible(decal))
			{
			gkrellm_make_decal_visible(p, decal);
			disk->save_label_position = p->label->position;
			if (p->label->position >= 0)
				{
				p->label->position = 0;
				gkrellm_draw_panel_label(p);
				}
			gkrellm_sensor_alert_connect(sr, cb_disk_temp_alert_trigger, disk);
			}
		gkrellm_sensor_draw_temperature_decal(p, decal, t, units);
		gkrellm_draw_panel_layers(p);
		display_done = TRUE;
		}
	return (display_possible || display_done);
	}

void
gkrellm_disk_temperature_remove(gchar *id_name)
	{
	GList			*list;
	DiskMon			*disk;
	GkrellmPanel	*p;
	GkrellmDecal	*decal;
	gchar			*disk_name;
	gint			len;

	if ((disk_name = strrchr(id_name, '/')) != NULL)
		++disk_name;
	else
		disk_name = id_name;

	len = strlen(disk_name);
	for (list = disk_mon_list; list; list = list->next)
		{
		disk = (DiskMon *) list->data;
		if (!disk->chart)
			continue;
		if (   strncmp(disk->name, disk_name, len)
			|| (disk->name[len] != '\0' && !isdigit(disk->name[len]))
		   )
			continue;
		p = disk->chart->panel;
		decal = disk->temp_decal;
		if (gkrellm_is_decal_visible(decal))
			{
			gkrellm_make_decal_invisible(p, decal);
			p->label->position = disk->save_label_position;
			gkrellm_draw_panel_label(p);
			gkrellm_draw_panel_layers(p);
			}
		}
	}


static void
update_disk(void)
	{
	GList			*list;
	DiskMon			*disk;
	GkrellmChart	*cp;
	gint			bytes;

	if (!sys_handles_composite_reset)
		{
		composite_disk->rb = 0;
		composite_disk->wb = 0;
		}
	(*read_disk_data)();
	if (n_disks == 0)
		return;

	for (list = disk_mon_list; list; list = list->next)
		{
		disk = (DiskMon *) list->data;
		if ((cp = disk->chart) == NULL)		/* or disk->enabled FALSE */
			continue;
		if (GK.second_tick)
			{
			gkrellm_store_chartdata(cp, 0,
						(gulong) disk->wb, (gulong) disk->rb);
			if (disk->alert)
				{
				bytes = 0;
				if (disk->alert_uses_read)
					bytes += gkrellm_get_current_chartdata(disk->read_cd);
				if (disk->alert_uses_write)
					bytes += gkrellm_get_current_chartdata(disk->write_cd);
				gkrellm_check_alert(disk->alert, bytes);
				}
			gkrellm_panel_label_on_top_of_decals(cp->panel,
						gkrellm_alert_decal_visible(disk->alert));
			draw_disk_chart(disk);
			}
		gkrellm_update_krell(cp->panel, KRELL(cp->panel),
					(gulong) (disk->wb + disk->rb));
		gkrellm_draw_panel_layers(cp->panel);
		}
	}


static gint
disk_expose_event(GtkWidget *widget, GdkEventExpose *ev)
	{
	GList			*list;
	GkrellmChart	*cp;
	GdkPixmap		*pixmap	= NULL;

	for (list = disk_mon_list; list; list = list->next)
		{
		if ((cp = ((DiskMon *) list->data)->chart) == NULL)
			continue;
		if (widget == cp->drawing_area)
			pixmap = cp->pixmap;
		else if (widget == cp->panel->drawing_area)
			pixmap = cp->panel->pixmap;
		if (pixmap)
			{
			gdk_draw_drawable(widget->window, gkrellm_draw_GC(1), pixmap,
				  ev->area.x, ev->area.y, ev->area.x, ev->area.y,
				  ev->area.width, ev->area.height);
			break;
			}
		}
	return FALSE;
	}

static gint
cb_disk_extra(GtkWidget *widget, GdkEventButton *ev)
	{
	GList	*list;
	DiskMon	*disk;

	for (list = disk_mon_list; list; list = list->next)
		{
		disk = (DiskMon *) list->data;
		if (!disk->enabled || widget != disk->chart->drawing_area)
			continue;
		if (ev->button == 1 && ev->type == GDK_BUTTON_PRESS)
			{
			disk->extra_info = !disk->extra_info;
			draw_disk_chart(disk);
			gkrellm_config_modified();
			}
		else if (   ev->button == 3
				 || (ev->button == 1 && ev->type == GDK_2BUTTON_PRESS)
				)
			gkrellm_chartconfig_window_create(disk->chart);
		break;
		}
	return FALSE;
	}

static void
setup_disk_scaling(GkrellmChartconfig *cf, GkrellmChart *cp)
	{
	gint	grids, res;

	grids = gkrellm_get_chartconfig_fixed_grids(cf);
	if (!grids)
		grids = FULL_SCALE_GRIDS;
	res = gkrellm_get_chartconfig_grid_resolution(cf);

	KRELL(cp->panel)->full_scale = res * grids / gkrellm_update_HZ();
	}

  /* Destroy everything in a DiskMon structure except for the vbox which
  |  is preserved so disk ordering will be maintained.  Compare this to
  |  destroying an InetMon where really everything is destroyed including
  |  the InetMon structure.  Here the DiskMon structure is not destroyed.
  */
static void
destroy_disk_monitor(DiskMon *disk)
	{
	if (disk->launch_table)
		gtk_widget_destroy(disk->launch_table);
	disk->launch_table = NULL;
	if (disk->launch.button)
		gkrellm_destroy_button(disk->launch.button);
	disk->launch.button = NULL;
	disk->launch.tooltip = NULL;
	gkrellm_dup_string(&disk->launch.command, "");
	gkrellm_dup_string(&disk->launch.tooltip_comment, "");
	gkrellm_chart_destroy(disk->chart);
	disk->chart = NULL;
	disk->enabled = FALSE;
	}

static gint
cb_panel_press(GtkWidget *widget, GdkEventButton *ev)
	{
	if (ev->button == 3)
		gkrellm_open_config_window(mon_disk);
	return FALSE;
	}

static void
create_disk_monitor(DiskMon *disk, gint first_create)
	{
	GkrellmChart		*cp;
	GkrellmPanel		*p;
	GkrellmDecal		*d;
	GkrellmStyle		*style;
	GkrellmTextstyle	*ts;
	GkrellmMargin		*m;

	if (first_create)
		{
		disk->chart = gkrellm_chart_new0();
		disk->chart->panel = gkrellm_panel_new0();
		}
	cp = disk->chart;
	p = cp->panel;

	style = gkrellm_panel_style(style_id);
	gkrellm_create_krell(p, gkrellm_krell_panel_piximage(style_id), style);

	gkrellm_chart_create(disk->vbox, mon_disk, cp, &disk->chart_config);
	disk->write_cd = gkrellm_add_default_chartdata(cp, _("Write bytes"));
	disk->read_cd = gkrellm_add_default_chartdata(cp, _("Read bytes"));
	gkrellm_set_draw_chart_function(cp, draw_disk_chart, disk);

	gkrellm_chartconfig_fixed_grids_connect(cp->config,
				setup_disk_scaling, cp);
	gkrellm_chartconfig_grid_resolution_connect(cp->config,
				setup_disk_scaling, cp);
	gkrellm_chartconfig_grid_resolution_adjustment(cp->config, TRUE,
				0, (gfloat) MIN_GRID_RES, (gfloat) MAX_GRID_RES, 0, 0, 0, 0);
	gkrellm_chartconfig_grid_resolution_label(cp->config,
				units_are_blocks ?
				_("Disk I/O blocks per sec") : _("Disk I/O bytes per sec"));
	if (gkrellm_get_chartconfig_grid_resolution(cp->config) < MIN_GRID_RES)
		gkrellm_set_chartconfig_grid_resolution(cp->config, DEFAULT_GRID_RES);
	gkrellm_alloc_chartdata(cp);

	setup_disk_scaling(cp->config, cp);

	ts = gkrellm_panel_alt_textstyle(style_id);
	disk->temp_decal = gkrellm_create_decal_text(p, "188.8F",
					ts, style, -1, -1, 0);
	gkrellm_make_decal_invisible(p, disk->temp_decal);

	gkrellm_panel_configure(p, disk->label, style);
	gkrellm_panel_create(disk->vbox, mon_disk, p);
	disk->enabled = TRUE;
	disk->new_text_format = TRUE;

	/* Position the temp decal to right edge and vertically align it
	|  wrt the label.
	*/
	d = disk->temp_decal;
	m = gkrellm_get_style_margins(style);
	gkrellm_move_decal(p, d,
				gkrellm_chart_width() - m->right - d->w,
 				m->top + (p->label->height - d->h + 1) / 2);

	if (first_create)
		{
		g_signal_connect(G_OBJECT(cp->drawing_area), "expose_event",
				G_CALLBACK(disk_expose_event), NULL);
		g_signal_connect(G_OBJECT (p->drawing_area), "expose_event",
				G_CALLBACK(disk_expose_event), NULL);

		g_signal_connect(G_OBJECT(cp->drawing_area), "button_press_event",
				G_CALLBACK(cb_disk_extra), NULL);
		g_signal_connect(G_OBJECT(p->drawing_area), "button_press_event",
				G_CALLBACK(cb_panel_press), NULL);
		}
	else
		draw_disk_chart(disk);

	gkrellm_configure_tooltip(p, &disk->launch);
	if (*(disk->launch.command) != '\0')
		disk->launch.button = gkrellm_put_label_in_panel_button(p,
				gkrellm_launch_button_cb, &disk->launch, disk->launch.pad);
	}


static GtkWidget	*disk_vbox;

static void
create_disk(GtkWidget *vbox, gint first_create)
	{
	GList		*list;
	DiskMon		*disk;
	gboolean	any = FALSE;

	ascent = 0;
	disk_vbox = vbox;
	for (list = disk_mon_list; list; list = list->next)
		{
		disk = (DiskMon *) list->data;
		if (first_create)
			{
			disk->vbox = gtk_vbox_new(FALSE, 0);
			gtk_box_pack_start(GTK_BOX(vbox), disk->vbox, FALSE, FALSE, 0);
			gtk_widget_show(disk->vbox);
			}
		gkrellm_setup_launcher(NULL, &disk->launch, CHART_PANEL_TYPE, 4);
		if (disk->enabled)
			{
			create_disk_monitor(disk, first_create);
			any = TRUE;
			}
		}
	if (any)
		gkrellm_spacers_show(mon_disk);
	else
		gkrellm_spacers_hide(mon_disk);
	}

  /* Kernel 2.4 will not show a disk until it has I/O, and some systems
  |  may dynamically add a drive.
  */
static void
check_for_new_disks(void)
	{
	GList	*list;
	DiskMon	*disk;

	for (list = disk_mon_list; list; list = list->next)
		{
		disk = (DiskMon *) list->data;
		if (disk->vbox == NULL)
			{
			disk->vbox = gtk_vbox_new(FALSE, 0);
			gtk_box_pack_start(GTK_BOX(disk_vbox), disk->vbox, FALSE, FALSE,0);
			gtk_widget_show(disk->vbox);
			gkrellm_setup_launcher(NULL, &disk->launch, CHART_PANEL_TYPE, 4);
			}
		}
	}

static void
cb_alert_trigger(GkrellmAlert *alert, DiskMon *disk)
	{
	/* Full panel alert, default decal.
	*/
	alert->panel = disk->chart->panel;
	}


static void
create_alert(DiskMon *disk)
	{
	disk->alert = gkrellm_alert_create(NULL, disk->name,
			_("Bytes per second"),
			TRUE, FALSE, TRUE,
			1e9, 1000, 1000, 10000, 0);
	gkrellm_alert_delay_config(disk->alert, 1, 60 * 180, 0);

	gkrellm_alert_trigger_connect(disk->alert, cb_alert_trigger, disk);
	gkrellm_alert_config_connect(disk->alert, cb_alert_config, disk);
	gkrellm_alert_config_create_connect(disk->alert,
							cb_alert_config_create, disk);
	gkrellm_alert_command_process_connect(disk->alert,
				cb_command_process, disk);
	}

static gboolean
any_enabled_subdisks(GList *dlist)
	{
	GList	*list;
	DiskMon	*disk;

	for (list = dlist; list; list = list->next)
		{
		disk = (DiskMon *) list->data;
		if (disk->subdisk == -1)
			break;
		if (disk->enabled)
			return TRUE;
		}
	return FALSE;
	}

static void
save_disk_config(FILE *f)
	{
	GList		*list;
	DiskMon		*disk;
	gboolean	have_enabled_subdisks;

	if (n_disks == 0)
		return;
	fprintf(f, "%s assign_method %d\n", DISK_CONFIG_KEYWORD, assign_method);
	for (list = disk_mon_list; list; list = list->next)
		{
		disk = (DiskMon *) list->data;

		/* To deal with possible disk hardware/partition changes at next load
		|  of the config, record if any subdisks are enabled to determine if
		|  a disk saved into the config here should be artificially created
		|  should it not be present at next gkrellm startup.
		*/
		have_enabled_subdisks = (disk->subdisk == -1) ? 
					any_enabled_subdisks(list->next) : FALSE;

		fprintf(f, "%s device %s %d %d %d %d %d %d %d\n",
					DISK_CONFIG_KEYWORD,
					disk->name, disk->major, disk->minor, disk->order,
					disk->enabled, disk->extra_info, disk->subdisk,
					have_enabled_subdisks);
		if (*(disk->launch.command) != '\0')
			fprintf(f, "%s launch %s %s\n", DISK_CONFIG_KEYWORD,
						disk->name, disk->launch.command);
		if (*(disk->launch.tooltip_comment) != '\0')
			fprintf(f, "%s tooltip_comment %s %s\n", DISK_CONFIG_KEYWORD,
						disk->name, disk->launch.tooltip_comment);
		gkrellm_save_chartconfig(f, disk->chart_config,
					DISK_CONFIG_KEYWORD, disk->name);
		if (disk->alert && disk->enabled)
			{
			gkrellm_save_alertconfig(f, disk->alert,
						DISK_CONFIG_KEYWORD, disk->name);
			fprintf(f, "%s extra_alert_config %s %d %d\n", DISK_CONFIG_KEYWORD,
						disk->name,
						disk->alert_uses_read, disk->alert_uses_write);
			}
		}
	fprintf(f, "%s text_format %s\n", DISK_CONFIG_KEYWORD, text_format);
	}

static void
load_disk_config(gchar *arg)
	{
	DiskMon		*disk = NULL;
	gchar		config[32], item[CFG_BUFSIZE],
				name[32], item1[CFG_BUFSIZE];
	gint		major, minor, enabled, extra, order, subdisk = -1;
	gint		n;
	gboolean	enabled_subdisks = TRUE;
	static gchar *parent;
	static gint	config_assign_method;

	n = sscanf(arg, "%31s %[^\n]", config, item);
	if (n == 2)
		{
		if (!strcmp(config, "text_format"))
			gkrellm_locale_dup_string(&text_format, item, &text_format_locale);
		else if (!strcmp(config, "assign_method"))
			sscanf(item, "%d", &config_assign_method);
		else if (sscanf(item, "%31s %[^\n]", name, item1) == 2)
			disk = lookup_disk_by_name(name);

		if (!strcmp(config, "device"))
			{
			/* Disk config can be invalid (different disk naming scheme)
			|  if user changes kernel version.
			*/
			if (   config_assign_method == assign_method
				&& sscanf(item1, "%d %d %d %d %d %d %d",
							&major, &minor, &order,
							&enabled, &extra,
							&subdisk, &enabled_subdisks) >= 5
			   )
				{
				/* A disk in the config may not have been found in the above
				|  lookup because of removable drives or hardware/partition
				|  changes since last gkrellm run.
				|  Also Linux <= 2.4 may be getting disk stats from /proc/stat
				|  where disks won't appear until they have I/O.
				|  So, artificially create these not present disks if they
				|  were previously enabled.
				*/
				if (subdisk == -1)
					gkrellm_dup_string(&parent, name);
				if (   !disk && subdisk == -1
					&& (enabled || enabled_subdisks)
				   )
					disk = add_disk(name, name, major, minor, order - 1);
				else if (!disk && subdisk >= 0 && enabled)
					disk = add_subdisk(name, parent, subdisk);
				if (disk)
					{
					disk->enabled = enabled;
					disk->extra_info = extra;