/home/fernape/Projects/lkmonitor/src/update.c

Go to the documentation of this file.

/*
        lkmonitor (Linux Kernel Monitor)

        Application for monitoring and tuning a Linux kernel.

        Copyright (C) 2005-2008  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.
*/

/* 
 * Update data functions
 *      Show updated data to user
 */     

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

#include <glib.h>

#include <gtk/gtk.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "processes.h"
#include "lininfo.h"
#include "support.h"
#include "lkmonitor.h"
#include "others.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;
extern struct cmd_ver cmdversion;
extern struct channels_info cn_info;
extern struct net_dev_info netinfo;
extern struct fs_info fsinfo;
extern struct modules_info modinfo;

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()
{
        if(get_devs_info(&devs)==-1){
                /*File doesn't exist. Don't do anything*/
                return;
        }
        
        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,TV_DEVS);
        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,TV_DEVS);
        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. */
        
        if(get_settings_info(&settings)==1){
                /* I leave this section just in case. Should the code in get_settings_info
                        doesn't find the date, default values are set. We can safely update
                        the gtk widgets.
                */
        }

        /* 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];
        int ret_stats, ret_acpi;        


        ret_acpi = get_acpi_info(&acpi);
        
        ret_stats = 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();
        
  if(ret_stats!=-1){
        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*/

  if(ret_acpi != -1){

        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,"")!=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,"")!=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();
}


static void update_process_list()
{
        static GSList *pidlist;
        int numfiles,i,j,p,pidtemp,dato;
        gboolean found;
        gchar cmdline[100];
        char path[20];
        struct dirent **proclist;
        struct lnode *mynode;
        FILE *fstatus;
        GtkTreeIter iter;
        GtkListStore *model;
        GtkTreeView *gtv;
        
        gdk_threads_enter();
        /*Get the GtkTreeView reference and associated objects*/
        gtv=GTK_TREE_VIEW(lookup_widget(window1,"gtv_processes"));
        model=GTK_LIST_STORE(gtk_tree_view_get_model(gtv));
        
        if ((numfiles=get_proc_list(&proclist))<0){
                g_warning("Error while scaning /proc");
        }
        else{
                for(i=0;i<numfiles;i++){
                        mynode=g_malloc(sizeof(struct lnode));
                        mynode->pid=atoi(proclist[i]->d_name);
                        if(g_slist_find_custom(pidlist,(gpointer)(mynode),list_com)==NULL){
                                /*The element is not found, so we need to attacht
                                the pid to the list */
                                /*Get the process command*/
                                sprintf(path,"/proc/%s/status",proclist[i]->d_name);
                                fstatus=fopen(path,"r");
                                fscanf(fstatus,"Name: %[^\n]",cmdline);
                                mynode->cmdname=g_string_new(cmdline);
                                pidlist=g_slist_append(pidlist,mynode);
                                gtk_list_store_append(model,&iter);
                                gtk_list_store_set(model,&iter,0,mynode->pid,1,cmdline,-1);
                                fclose(fstatus);
                        }else{
                                /* Free the node */
                                g_free(mynode);
                        }
                        
                }
                /*
                Now we should delete the process that are no more.
                */
                
                /*Initialize the iter*/
                
                if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model),&iter)==FALSE)
                        g_warning("Problem while getting iter first.\n");
                
                
                for(i=0;i<g_slist_length(pidlist);i++){
                        dato=0;
                        found=FALSE;
                        mynode=g_slist_nth_data(pidlist,i);
                        pidtemp=mynode->pid;
                        for (j=0;(j<numfiles && found==FALSE);j++){
                                if ((p=atoi(proclist[j]->d_name))==pidtemp){
                                        found=TRUE;  //The pid is still in the system
                                }
                        }
                        if (found==FALSE){
                                //We traverse all the list and the pid was not found. Delete it
                                pidlist=g_slist_remove(pidlist,(gpointer)mynode);
                                g_string_free(mynode->cmdname,TRUE);
                                g_free(mynode);
                                gtk_list_store_remove(model,&iter);
                                g_print("Deleted %d process\n",pidtemp);
                        }else{
                                gtk_tree_model_iter_next(GTK_TREE_MODEL(model),&iter);
                        }
                }               
        }

        
        gdk_threads_leave();

        /* Clean up */

        /*We need to free dirent structures allocated by scandir()*/
        for(i=0;i<numfiles;i++)
                free(proclist[i]);
        
        /*Free the list itself*/
        free(proclist);
        
}


void update_process()
{
  GtkLabel *lbl;
  GString *text;
  float one,five,fifteen;
  int pid,ret;
  char executing[15];   /*big enough to read that value*/
  

        /* First the process list */
  update_process_list();

  /*Now we want to update the load average information*/
  ret = get_loadavg_info(&cmdversion);  

  sscanf(cmdversion.loadavg->str,"%f %f %f %s %d",&one,&five,&fifteen, executing,&pid);
  text=g_string_new("");
  if(ret != -1)
        g_string_printf(text,"%.2f %.2f %.2f",one,five,fifteen);

  gdk_threads_enter();
    
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_load"));
  gtk_label_set_text(lbl,text->str);

  lbl=GTK_LABEL(lookup_widget(window1,"lbl_entities"));
  gtk_label_set_text(lbl,executing);

  gdk_threads_leave();

}

void update_cmd_ver()
{
  GtkLabel *lbl;

        /* Get the information */
  if(get_cmd_ver_info(&cmdversion)==-1){
                /* We don't need to do anything. The cmdversion structure
                        has the default values.
                */
  }

  gdk_threads_enter();

  lbl=GTK_LABEL(lookup_widget(window1,"lbl_cmd"));
  gtk_label_set_text(lbl,cmdversion.cmd->str);

  lbl=GTK_LABEL(lookup_widget(window1,"lbl_version"));
  gtk_label_set_text(lbl,cmdversion.version->str);

  gdk_threads_leave();

}


void update_channels()
{

/* 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.
*/
        
        GtkTextView *gtextv;
        GtkTextBuffer *gtbuffer;

        /* Getting information */
   if(get_channels_info(&cn_info)==-1){
                /* Values after calling get_channels info are safe
                        We don't need to do anything here.
                */
        }
   

        gtextv=GTK_TEXT_VIEW(lookup_widget(window1, "gtextv_ioports"));
        gtbuffer=gtk_text_view_get_buffer(gtextv);
        gtk_text_buffer_set_text(gtbuffer,cn_info.ioports->str,cn_info.ioports->len);
        
        gtextv=GTK_TEXT_VIEW(lookup_widget(window1, "gtextv_iomem"));
        gtbuffer=gtk_text_view_get_buffer(gtextv);
        gtk_text_buffer_set_text(gtbuffer,cn_info.iomem->str,cn_info.iomem->len);
        
        gtextv=GTK_TEXT_VIEW(lookup_widget(window1, "gtextv_dma"));
        gtbuffer=gtk_text_view_get_buffer(gtextv);
        gtk_text_buffer_set_text(gtbuffer,cn_info.dma->str,cn_info.dma->len);
   
}

void update_net_info()
{
  GtkComboBox *gcb_netdevs;
  GtkLabel *lbl;
  int ret;
 
        /* Get device list */
  gdk_threads_enter();
  gcb_netdevs=GTK_COMBO_BOX(lookup_widget(window1,"cb_net_devs"));
  gdk_threads_leave();

if(GTK_WIDGET_IS_SENSITIVE(gcb_netdevs)){
  /* Get info for the active device */ 
  ret = get_net_info(&netinfo,gtk_combo_box_get_active(gcb_netdevs));
  
 if(ret != -1){
  gdk_threads_enter();

  /* Show in the window... */  
  
  /* Bytes */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_bytes"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.bytes[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_bytes"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.bytes[1]));

  /* Packets */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_packets"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.packets[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_packets"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.packets[1]));

  /* Errors */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_errors"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.errs[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_errors"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.errs[1]));

  /* Drop */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_drop"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.drop[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_drop"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.drop[1]));
  
  /* Fifo */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_fifo"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.fifo[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_fifo"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.fifo[1]));

  /* Compressed */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_compressed"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.compressed[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_compressed"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.compressed[1]));


  /* Receiving specific data */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_frame"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.r_frame));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_multicast"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.r_multicast));

  /* Transmiting specific data */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_colls"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.t_colls));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_carrier"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.t_carrier));

  gdk_threads_leave();

 }

}

}


void update_fs_info()
{

  GtkTextBuffer *gtbuffer;
  GtkTextView *gtextv;
  int ret;

  /* Get information */
  ret = get_fs_info(&fsinfo);

  if(ret == -1){
        /* Return values in fsinfo are safe. Don't need do anything here*/
  }

  gdk_threads_enter();

  /* Show in the window*/

  gtextv=GTK_TEXT_VIEW(lookup_widget(window1,"gtextv_fs"));
  gtbuffer=gtk_text_view_get_buffer(gtextv);
  gtk_text_buffer_set_text(gtbuffer,fsinfo.devs->str,fsinfo.devs->len);
  

  gtextv=GTK_TEXT_VIEW(lookup_widget(window1,"gtextv_pfs"));
  gtbuffer=gtk_text_view_get_buffer(gtextv);
  gtk_text_buffer_set_text(gtbuffer,fsinfo.nodevs->str,fsinfo.nodevs->len);

  gdk_threads_leave();

  
}



void update_modules_info()
{

        GtkListStore *model;
        GtkTreeView *gtv;
        GtkTreeIter iter;
        int ret;

        /* Get information */
        ret = get_mod_info(&modinfo);

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

  if(ret != -1){
        /* We want the model of the GtkTreeView */
        gtv=GTK_TREE_VIEW(lookup_widget(window1,"gtv_modules"));
        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,modinfo.contents->str,TV_MODS);
        gtk_tree_view_set_model(gtv,GTK_TREE_MODEL(model));
  }

}

---