/home/fernape/Projects/lkmonitor/src/procupdate.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.
*/

/* 
 * Process specific information file
*/

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

#include <glib.h>
#include <gtk/gtk.h>
#include <gnome.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "lkmonitor.h"
#include "procinfo.h"
#include "support.h"




static void treeviews_construct(GtkWindow *window)
{
        g_assert(window!=NULL);

  GtkTreeView *tv;
  GtkTreeView *tv_files;
  GtkListStore *ls;
  GtkListStore *ls_files;
  GtkCellRenderer *cr;
  GtkCellRenderer *cr_files;

  
  /* For Memory maps */  
                                             
  tv= GTK_TREE_VIEW(lookup_widget(GTK_WIDGET(window),"tv_maps"));
  ls=gtk_list_store_new(6,G_TYPE_STRING, G_TYPE_STRING,G_TYPE_STRING,
                        G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING);
  
  gtk_tree_view_set_model(GTK_TREE_VIEW(tv),GTK_TREE_MODEL(ls));
 
  /*First column*/
  cr = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
                                               -1,      
                                               _("Address"),  
                                               cr,
                                               "text", 0,
                                               NULL);

  /*Second column*/

  cr = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
                                               -1,      
                                               _("Flags"),  
                                               cr,
                                               "text", 1,
                                               NULL); 

  /*Third column*/
  cr = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
                                               -1,      
                                               _("Size"),  
                                               cr,
                                               "text", 2,
                                               NULL);

  /*Forth column*/

  cr = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
                                               -1,      
                                               _("Device"),  
                                               cr,
                                               "text", 3,
                                               NULL); 

  /*Fifth column*/

  cr = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
                                               -1,      
                                               _("Inode"),  
                                               cr,
                                               "text", 4,
                                               NULL); 
  
  /*Sixth column*/

  cr = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
                                               -1,      
                                               _("Object"),  
                                               cr,
                                               "text",5,
                                               NULL); 

  /* For files */  
                                             
  tv_files= (GtkTreeView *)lookup_widget(GTK_WIDGET(window),"tv_files");
  ls_files=gtk_list_store_new(3,G_TYPE_STRING, G_TYPE_STRING,G_TYPE_STRING);
  
  gtk_tree_view_set_model(GTK_TREE_VIEW(tv_files),GTK_TREE_MODEL(ls_files));
 
  /*First column*/
  cr_files = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv_files),
                                               -1,      
                                               _("FD"),  
                                               cr_files,
                                               "text", 0,
                                               NULL);

  /*Second column*/

  cr_files = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv_files),
                                               -1,      
                                               _("Type"),  
                                               cr_files,
                                               "text", 1,
                                               NULL); 

  /*Third column*/

  cr_files = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv_files),
                                               -1,      
                                               _("Object"),  
                                               cr_files,
                                               "text", 2,
                                               NULL); 
}


static int gtktextbuffers_construct(GtkWindow *window)
{
        g_assert(window!=NULL);

        GtkTextView *gtv;
        GtkTextBuffer *gtktextb;

        /* First, create the GtkTextBuffers */

        gtktextb=gtk_text_buffer_new(NULL);

        /* Attach them */
        gtv=GTK_TEXT_VIEW(lookup_widget(GTK_WIDGET(window),"textv_environ"));
        gtk_text_view_set_buffer(gtv,gtktextb);

        return 0;
}


void update_memory_maps(GtkTreeView *gtv,char *maps)
{

  GtkTreeIter iter;
  GtkListStore *model;
  char *pointer;
  //char address[24],flags[4],size[10],dev[8],inode[16],object[200];
  /* --FIXME: Sizes for teh variables... */
  char address[100],flags[100],size[100],dev[100],inode[100],object[200];

  model=GTK_LIST_STORE(gtk_tree_view_get_model(gtv)); 
  
  pointer=maps;

  while(*pointer!='\0'){
        gtk_list_store_append(model,&iter);
        sscanf(pointer,"%s %s %s %s %s %s",address,flags,size,dev,inode,object);
        gtk_list_store_set(model,&iter,0,address,1,flags,2,size,3,dev,4,
                                inode,5,object,-1);
        pointer=strchr(pointer,'\n')+1;
  }

}

static void link_get_name(char *path, GString *gs)
{

#define UNK_STR _("Unknown")
        char buf[50];
        int numchars;

        if((numchars=readlink(path, buf, sizeof(buf)))!=-1){
                /* readlink doesn't include '\0' at the end */
                *(buf+numchars)='\0';
                g_string_printf(gs,"%s",buf);
        }else{
                g_string_printf(gs,"%s",UNK_STR);
        }

}


static void get_type_by_fd(GString *gs,GString *gs_additional,mode_t mode,char *path)
{

 if(S_ISREG(mode)){
        g_string_printf(gs,_("Regular file"));
        return;
 }

 if(S_ISDIR(mode)){
        g_string_printf(gs,_("Directory"));
        return;
 }

 if(S_ISCHR(mode)){
        g_string_printf(gs,_("Character Device"));
        link_get_name(path,gs_additional);
        return;
 }

 if(S_ISBLK(mode)){
        g_string_printf(gs,_("Block Device"));
        link_get_name(path,gs_additional);
        return;
 }

 if(S_ISFIFO(mode)){
        g_string_printf(gs,_("Fifo"));
        link_get_name(path,gs_additional);
        return;
 }

 if(S_ISLNK(mode)){
        g_string_printf(gs,_("Symbolic link"));
        link_get_name(path,gs_additional);
        return;
 }

 if(S_ISSOCK(mode)){
        g_string_printf(gs,_("Socket"));
        link_get_name(path,gs_additional);
        return;
 }

}


void update_fd_info(int pid,GtkTreeView *gtv,struct dirent **file_list,int numfiles)
{

#define UNK_STR _("Unknown")
        int i;
        GtkTreeIter iter;
        GtkListStore *model;
        GString *path;
        GString *type;
        GString *object;
        struct stat file_info;

        /* Initialize the GStrings */
   path=g_string_new("");
   type=g_string_new("");
   object=g_string_new("");

        /* Take the model */
        model=GTK_LIST_STORE(gtk_tree_view_get_model(gtv)); 

        /* For every file, get some information */
        for(i=0;i<numfiles;i++){
                g_string_printf(path,"/proc/%d/fd/%s",pid,file_list[i]->d_name);
                if(stat(path->str,&file_info)){
                        /* Put here default values */
                        g_string_printf(type,"%s",UNK_STR);
                        g_string_printf(object,"%s",UNK_STR);
                }else{
                        /* We got information for the file */
                        get_type_by_fd(type,object,file_info.st_mode,path->str);
                }

                gtk_list_store_append(model,&iter);
                gtk_list_store_set(model,&iter,0,file_list[i]->d_name,1,type->str,2,object->str,-1);

        }


        /* Free the dirent data structures and the list itself 
         * only in case the list has been filled some time before
         */
        if(numfiles!=-1){
                int i;
                for(i=0;i<numfiles;i++)
                        free(file_list[i]);

                free(file_list);
        }

        /* Freeing GStrings */
        g_string_free(path,TRUE);
        g_string_free(type,TRUE);
        g_string_free(object,TRUE);

}

void update_mm_details(char *mmregion, GtkWindow *window,int pid)
{
        struct mm_details details;
        GtkLabel *lbl;
        GString *gs=g_string_new("");

        get_mm_details(pid,&details,mmregion);

        /* Update the widgets */
        lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_size"));
        gtk_label_set_text(lbl,details.size);
        lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_rss"));
        gtk_label_set_text(lbl,details.rss);
        lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_shared"));
        g_string_printf(gs,"%s / %s",details.sh_clean,details.sh_dirty);
        gtk_label_set_text(lbl,gs->str);
        lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_private"));
        g_string_printf(gs,"%s / %s",details.priv_clean,details.priv_dirty);
        gtk_label_set_text(lbl,gs->str);


        /* Cleaning up */
        g_string_free(gs,TRUE);
}

void update_process_window(int pid, char *name,GtkWindow *window)
{
        g_assert(pid>0 && name!=NULL && window!=NULL);

  struct procinfo pi;
  struct dirent **file_list;
  int numfiles;

  /* Construct the GtkTreeView for memory maps */
  treeviews_construct(window);
  gtktextbuffers_construct(window);
  
  /* Put the window title */
  {
        /* Construct the title */
        GString *title=g_string_new("");
        g_string_printf(title,"%s (PID: %d)",name,pid);

        gtk_window_set_title(window,title->str);

        /* Free things in this block */
        g_string_free(title,TRUE);
  }

  /* Get Process information */
  get_process_info(pid,&pi,&file_list,&numfiles);
  /* Display data */

  /*
   * NOTICE: This is inside the global gdk lock cause this is call from a
   * callback associated to a double click event.
   * So we don't need gdk_threads_enter/gdk_threads_leave
  */

  /* Command line */
  {
        GtkLabel *lbl;
        lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_cmdline"));
        gtk_label_set_text(lbl,pi.cmdline->str);
  }

  /* Environment variables */
  {
        GtkTextBuffer *gtb;
        GtkTextView *gtv;
        gtv=GTK_TEXT_VIEW(lookup_widget(GTK_WIDGET(window),"textv_environ"));
        gtb=gtk_text_view_get_buffer(gtv);
        gtk_text_buffer_set_text(gtb,pi.env->str,pi.env->len);
  }

  /* Memory maps */
  {
        GtkTreeView *gtv_mmaps;
        gtv_mmaps=GTK_TREE_VIEW(lookup_widget(GTK_WIDGET(window),"tv_maps"));
        update_memory_maps(gtv_mmaps,pi.maps->str);
  }

        /* Opened files */
        {
                GtkTreeView *gtv_fd;
                GtkLabel *lbl;
                gtv_fd=GTK_TREE_VIEW(lookup_widget(GTK_WIDGET(window),"tv_files"));
                update_fd_info(pid,gtv_fd,file_list,numfiles);

                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_files"));
                if(numfiles!=-1)
                        gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(numfiles));
                else
                        gtk_label_set_text(lbl,"No info.");
                /* 
                 * The file_list structure and associated data are
                 * freed in the update_fd_info function
                */
        }

        /* VM info and other status file bits... */
        {
                GtkLabel *lbl;

                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_vmsize"));
                gtk_label_set_text(lbl,pi.size);
                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_vmlocked"));
                gtk_label_set_text(lbl,pi.locked);
                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_vmrss"));
                gtk_label_set_text(lbl,pi.rss);
                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_vmdata"));
                gtk_label_set_text(lbl,pi.data);
                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_vmstack"));
                gtk_label_set_text(lbl,pi.stack);
                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_vmexecutable"));
                gtk_label_set_text(lbl,pi.exe);
                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_vmlibraries"));
                gtk_label_set_text(lbl,pi.lib);
                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_state"));
                gtk_label_set_text(lbl,pi.state);
                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_sleepavg"));
                gtk_label_set_text(lbl,pi.sleepavg);
                lbl=GTK_LABEL(lookup_widget(GTK_WIDGET(window),"lbl_threads"));
                gtk_label_set_text(lbl,pi.threads);
        
        }

}

---