update.c

Go to the documentation of this file.

/*
lkmonitor (Linux Kernel Monitor)

Application for monitoring and tuning a Linux kernel.

Copyright (C) 2005-2006  Fernando Apesteguía

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.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <glib.h>

#include <gtk/gtk.h>
#include <signal.h>
#include "lininfo.h"
#include "support.h"
#include "lkmonitor.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

/* Some structures defined outside */
extern GtkWidget *window1;
extern struct mem_info mem;
extern struct cpu_info cpu;
extern struct dev_info devs;
extern struct settings_info settings;
extern struct stats_info stats;
extern struct acpi_info acpi;

void
update_mem ()
{

  GtkLabel *widget;
  GtkProgressBar *progreso;
  gfloat total, free;

  get_mem_info (&mem);
        
  //Get Gtk thread lock
  gdk_threads_enter();


  widget = GTK_LABEL(lookup_widget (window1, "lbl_total"));
  gtk_label_set_text (widget, (gchar *) mem.total);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_free"));
  gtk_label_set_text (widget, (gchar *) mem.free);

  widget = GTK_LABEL(lookup_widget (window1, "lbl_buffers"));
  gtk_label_set_text (widget, (gchar *) mem.buffers);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_cached"));
  gtk_label_set_text (widget, (gchar *) mem.cached);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_swap_cached"));
  gtk_label_set_text (widget, (gchar *) mem.swap_cached);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_active"));
  gtk_label_set_text (widget, (gchar *) mem.active);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_inactive"));
  gtk_label_set_text (widget, (gchar *) mem.inactive);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_dirty"));
  gtk_label_set_text (widget, (gchar *) mem.dirty);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_hp_total"));
  gtk_label_set_text (widget, (gchar *) mem.hugepages_total);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_hp_free"));
  gtk_label_set_text (widget, (gchar *) mem.hugepages_free);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_hp_size"));
  gtk_label_set_text (widget, (gchar *) mem.hugepages_size);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_high_total"));
  gtk_label_set_text (widget, (gchar *) mem.high_total);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_high_free"));
  gtk_label_set_text (widget, (gchar *) mem.high_free);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_low_total"));
  gtk_label_set_text (widget, (gchar *) mem.low_total);


  widget = GTK_LABEL( lookup_widget (window1, "lbl_low_free"));
  gtk_label_set_text (widget, (gchar *) mem.low_free);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_swap_total"));
  gtk_label_set_text (widget, (gchar *) mem.swap_total);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_swap_free"));
  gtk_label_set_text (widget, (gchar *) mem.swap_free);

  /*Compute percentage of memory use*/
  total = atoi (strtok (mem.total, " "));
  free = atoi (strtok (mem.free, " "));

  g_assert(total!=0);
  
  progreso = GTK_PROGRESS_BAR(lookup_widget (window1, "pb_mem"));
  gtk_progress_bar_set_fraction (progreso, 
                                                        (gfloat) CLAMP(((total - free) / total),0,1));


  /*Compute percentage of swap use. Reuse variables.*/


  total = atoi (strtok (mem.swap_total, " "));
  free = atoi (strtok (mem.swap_free, " "));
  
  progreso = GTK_PROGRESS_BAR (lookup_widget (window1, "pb_swap"));
  
  if(total!=0){
    gtk_progress_bar_set_fraction (progreso, 
                                                        (gfloat) CLAMP(((total - free) / total),0,1));
          }
  else
    gtk_progress_bar_set_text(progreso, (gchar *)_("Not present"));
  
  gdk_threads_leave();
}                               


void
update_cpu ()
{

  get_cpu_info (&cpu);

  GtkLabel *widget;

  /*Not updated so, we don't need thread locking*/
        
  widget = GTK_LABEL( lookup_widget (window1, "lbl_processor"));
  gtk_label_set_text (widget, (gchar *) cpu.processor);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_vendor"));
  gtk_label_set_text (widget, (gchar *) cpu.vendor_id);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_family"));
  gtk_label_set_text (widget, (gchar *) cpu.cpu_family);


  widget = GTK_LABEL( lookup_widget (window1, "lbl_model"));
  gtk_label_set_text (widget, (gchar *) cpu.model);

  widget = GTK_LABEL(lookup_widget (window1, "lbl_model_name"));
  gtk_label_set_text (widget, (gchar *) cpu.model_name);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_stepping"));
  gtk_label_set_text (widget, (gchar *) cpu.stepping);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_Mhz"));
  gtk_label_set_text (widget, (gchar *) cpu.Mhz);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_cache"));
  gtk_label_set_text (widget, (gchar *) cpu.cache);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_fpu"));
  gtk_label_set_text (widget, (gchar *) cpu.fpu);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_fpu_exception"));
  gtk_label_set_text (widget, (gchar *) cpu.fpu_exception);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_cpu_id_level"));
  gtk_label_set_text (widget, (gchar *) cpu.cpuid_level);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_wp"));
  gtk_label_set_text (widget, (gchar *) cpu.wp);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_bogomips"));
  gtk_label_set_text (widget, (gchar *) cpu.bogomips);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_flags"));
  gtk_label_set_text (widget, (gchar *) cpu.flags);

 
}

void update_cpu_mhz(void)
{
        GtkLabel *mhz_label;
        char str[10];
        
        get_mhz_info(str);
        
        gdk_threads_enter();
        
        mhz_label=GTK_LABEL(lookup_widget(window1,"lbl_Mhz"));
        gtk_label_set_text(mhz_label,str);
        
        gdk_threads_leave();
}

void update_devs()
{
  get_devs_info(&devs);
        
        GtkListStore *model;
        GtkTreeView *gtv;
        GtkTreeIter iter;

        /* IMPORTANT:
                We should not lock with gdk_threads_enter because this function is 
                called from a callback and callbacks are already running inside a gdk
                lock.
                In addition, this function is called from main thread before the collector
                thread is created, so we don't need to prevent the access from the other
                thread.
        */

/* We want the model of the GtkTreeView for char devices */
gtv=GTK_TREE_VIEW(lookup_widget(window1,"gtv_char"));
model=GTK_LIST_STORE(gtk_tree_view_get_model(gtv));

        gtk_tree_view_set_model(gtv,NULL);
        gtk_list_store_clear(model);
        lkmonitor_fill_tv(model,gtv,iter,devs.characters->str);
        gtk_tree_view_set_model(gtv,GTK_TREE_MODEL(model));

/* We want the model of the GtkTreeView for block devices */
gtv=GTK_TREE_VIEW(lookup_widget(window1,"gtv_block"));
model=GTK_LIST_STORE(gtk_tree_view_get_model(gtv));
gtk_tree_view_set_model(gtv,NULL);
        gtk_list_store_clear(model);
lkmonitor_fill_tv(model,gtv,iter,devs.blocks->str);
        gtk_tree_view_set_model(gtv,GTK_TREE_MODEL(model));

}

void update_settings()
{
        GtkSpinButton *spb;
        GtkLabel *lbl;
        GtkEntry *ent;
        gchar str[10]; /* For numeric conversion. */
        
        get_settings_info(&settings);

        /* IMPORTANT:
                We should not lock with gdk_threads_enter because this function is 
                called from a callback and callbacks are already running inside a gdk
                lock.
                In addition, this function is called from main thread before the collector
                thread is created, so we don't need to prevent the access from the other
                thread.
        */
        
        /* Identification */
        ent=GTK_ENTRY(lookup_widget(window1,"ent_hostname"));
        gtk_entry_set_text(ent,settings.host->str);
        
        ent=GTK_ENTRY(lookup_widget(window1,"ent_domainname"));
        gtk_entry_set_text(ent,settings.domain->str);
        
        
        /* threads */
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_maxthreads"));
        gtk_spin_button_set_value(spb,(gdouble)settings.threads);
        
        /* files */
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_fdmax"));
        gtk_spin_button_set_value(spb,(gdouble)settings.fdmax);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_inmax"));
        sprintf(str,"%d",settings.inmax);
        gtk_label_set_text(lbl,str);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_fda"));
        sprintf(str,"%d",settings.fdasig);
        gtk_label_set_text(lbl,str);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_ufd"));
        sprintf(str,"%d",settings.fdfreed);
        gtk_label_set_text(lbl,str);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_ina"));
        sprintf(str,"%d",settings.inasig);
        gtk_label_set_text(lbl,str);
        
        /* RT POSIX Signals */
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_mq"));
        gtk_spin_button_set_value(spb,(gdouble)settings.posix_mq);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_max_mpq"));
        gtk_spin_button_set_value(spb,(gdouble)settings.posix_mpq);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_max_ms"));
        gtk_spin_button_set_value(spb,(gdouble)settings.posix_ms);
        
        /* Shared Memory */
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_max_pages"));
        gtk_spin_button_set_value(spb,(gdouble)settings.page_max);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_max_segs"));
        gtk_spin_button_set_value(spb,(gdouble)settings.seg_max);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_seg_size"));
        gtk_spin_button_set_value(spb,(gdouble)settings.seg_size);
        
        /* Semaphores */
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_sem_per_id"));
        gtk_spin_button_set_value(spb,(gdouble)settings.max_seminset);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_sem_val"));
        gtk_spin_button_set_value(spb,(gdouble)settings.max_semsys);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_ops"));
        gtk_spin_button_set_value(spb,(gdouble)settings.max_opcall);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_sem_id"));
        gtk_spin_button_set_value(spb,(gdouble)settings.max_semsets);
        
        
}

void update_misc()
{
        GtkLabel *lbl;
        GtkProgressBar *pb;
        gfloat total,free;
        static float old_total,old_use;
        float use;
        gchar percent[4];
        gchar user[10];
        gchar nice[10];
        gchar system[10];
        gchar idle[10];
        gchar iowait[10];
        gchar irq[10];
        gchar softirq[10];

get_acpi_info(&acpi);
        
  get_stats_info(&stats);
  sscanf(stats.cpu->str,"%s %s %s %s %s %s %s",user,nice,system,idle,iowait,\
                                                                                                        irq,softirq);
        gdk_threads_enter();
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_user"));
        gtk_label_set_text(lbl,user);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_nice"));
        gtk_label_set_text(lbl,nice);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_system"));
        gtk_label_set_text(lbl,system);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_idle"));
        gtk_label_set_text(lbl,idle);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_iowait"));
        gtk_label_set_text(lbl,iowait);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_irq"));
        gtk_label_set_text(lbl,irq);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_softirq"));
        gtk_label_set_text(lbl,softirq);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_context"));
        gtk_label_set_text(lbl,stats.ctxt->str);
        
        total=atof(user)+atof(nice)+atof(system)+atof(idle)+atof(iowait)+
                        atof(irq)+atof(softirq);
                        
        free=atof(idle)+atof(iowait)+atof(irq)+atof(softirq);
        use=total-free;
                        
        pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_cpu"));
        gtk_progress_bar_set_fraction(pb,CLAMP((use-old_use)/(total-old_total),0,1));
        sprintf(percent,"%.0f%s",CLAMP((use-old_use),0,100),"%");
        gtk_progress_bar_set_text(pb,percent);
        
        old_use=use;
        old_total=total;
        
        /*Update ACPI*/
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_cap"));
        gtk_label_set_text(lbl,acpi.battery.cap->str);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_last_cap"));
        gtk_label_set_text(lbl,acpi.battery.last_cap->str);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_cap_warning"));
        gtk_label_set_text(lbl,acpi.battery.cap_warning->str);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_cap_low"));
        gtk_label_set_text(lbl,acpi.battery.cap_low->str);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_batt_type"));
        gtk_label_set_text(lbl,acpi.battery.type->str);
        
        if(strcmp(acpi.temp->str,_("Unknown"))!=0){
                total=atof(acpi.temp_critical->str);
                free=atof(acpi.temp->str);
        
                pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_temp"));
                gtk_progress_bar_set_fraction(pb,free/total);
                gtk_progress_bar_set_text(pb,acpi.temp->str);
        }else{
                pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_temp"));
                gtk_progress_bar_set_text(pb,_("Unknown"));
        }

        if(strcmp(acpi.battery.rem->str,_("Unknown"))!=0){
                total=atof(acpi.battery.cap->str);
                free=atof(acpi.battery.rem->str);
        
                pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_batt"));
                gtk_progress_bar_set_fraction(pb,free/total);
                gtk_progress_bar_set_text(pb,acpi.battery.rem->str);
        }else{
                pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_batt"));
                gtk_progress_bar_set_text(pb,_("Unknown"));
        }
  
  
        
  gdk_threads_leave();
}

---