/home/fernape/Projects/lkmonitor/src/procinfo.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 widgets in a process specific window
*/

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

#include <gnome.h>
#include <dirent.h>
#include <errno.h>
#include <glib.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "lkmonitor.h"
#include "others.h"
#include "procinfo.h"
#include "update.h"

#define UNK_STR _("Unknown")

static int filter (const struct dirent *entry)
{

  if ((strcmp (entry->d_name, ".") == 0) ||
      (strcmp (entry->d_name, "..") == 0))
    return (0); /*We're not interested in '.' or '..' directories*/

  return(1);
}                       

static int get_fd_list(const char *path,struct dirent ***filelist)
{
        g_assert(path!=NULL);

        int numfich;
        
        if ((numfich = scandir (path, filelist, &filter, numsort)) == -1)
    {
      perror ("scandir error");
      return (-1);
    }
        
        return(numfich);
}


static int get_files_info(const char *path, struct procinfo *pi,
                                                                        struct dirent ***file_list,int *numfiles)
{
        g_assert(path!=NULL && pi!=NULL);

  GString *files_path=g_string_new(path);

  g_string_append(files_path, "/fd/");

  if((*numfiles=get_fd_list(files_path->str, file_list))<0){
        g_warning("Can't read fd directory");
        g_string_free(files_path,TRUE);
        return -1;
  }
        
        g_string_free(files_path,TRUE);
        return 0;

}


static int get_cmdline_info(const char *path, struct procinfo *pi)
{
        g_assert(path!=NULL && pi!=NULL);

  gchar *contents;
  gsize len;
  GString *cmdline_file=g_string_new(path);

  g_string_append(cmdline_file,"/cmdline");
  
  if((g_file_get_contents(cmdline_file->str,&contents,&len,NULL))==FALSE){
        /* Can't read file */
        pi->cmdline=g_string_new(UNK_STR);
        g_string_free(cmdline_file,TRUE);
        g_free(contents);
        return -1;
  }

        /* We've read the file */
        /*
         * Parse the file, cause null characters are
         * instead blank spaces...
         * 
         */
  {
        int i;
        char *p;

        p=contents;
        for(i=0;i<len;i++){
                if(*p=='\0')
                        *p=' ';
                p++;
        }

  *(--p)='\0';
  }
  

  /* Creating the GString */
  pi->cmdline=g_string_new(contents);

  /* Cleaning up and returning... */
  g_string_free(cmdline_file,TRUE);
  
  return 0;

}


static int get_env_info(const char *path, struct procinfo *pi)
{
        g_assert(path!=NULL && pi!=NULL);

  char *p;
  gchar *contents;
  gsize len;
  GString *env_file=g_string_new(path);

  g_string_append(env_file,"/environ");


  if((g_file_get_contents(env_file->str,&contents,&len,NULL))==FALSE){
        /* Something bad happend... */
        pi->env=g_string_new(UNK_STR);
        g_string_free(env_file,TRUE);
        g_free(contents);
        return -1;
  }



  /* Let's change the ugly NULL characters by \n characters */
{
  int i;
  p=contents;
  for(i=0;i<len;i++){
        if(*p=='\0')
                *p='\n';
        p++;
  }
}
 
 
  pi->env=g_string_new(contents);

  /* Cleaning up... */
  g_string_free(env_file,TRUE);
  g_free(contents);

  return 0;
  

}


static int get_maps_info(const char *path, struct procinfo *pi)
{
        g_assert(path!=NULL && pi!=NULL);

  gchar *contents;
  GString *maps_file=g_string_new(path);

  g_string_append(maps_file,"/maps");

  if((g_file_get_contents(maps_file->str, &contents,NULL,NULL))==FALSE){
        /* Something bad happend */
        g_string_free(maps_file,TRUE);
        pi->maps=g_string_new("");
        g_free(contents);
        return -1;
  }

  /* We've read the file */

  pi->maps=g_string_new(contents);

  /* Cleaning... */

  g_string_free(maps_file,TRUE);
  g_free(contents);

  return 0;

}

static int get_vm_info(const char *path,struct procinfo *pi)
{
        g_assert(path!=NULL && pi!=NULL);

        gchar *contents;
        GString *status_file=g_string_new(path);

        g_string_append(status_file,"/status");

  if((g_file_get_contents(status_file->str, &contents,NULL,NULL))==FALSE){
        /* Something bad happend */
        g_string_free(status_file,TRUE);
        /* Set all the variables to a default value */
        strncpy(pi->size,UNK_STR,DEF_SZ);
        strncpy(pi->locked,UNK_STR,DEF_SZ);
        strncpy(pi->rss,UNK_STR,DEF_SZ);
        strncpy(pi->data,UNK_STR,DEF_SZ);
        strncpy(pi->stack,UNK_STR,DEF_SZ);
        strncpy(pi->exe,UNK_STR,DEF_SZ);
        strncpy(pi->lib,UNK_STR,DEF_SZ);
        strncpy(pi->state,UNK_STR,DEF_SZ+5);
        strncpy(pi->sleepavg,UNK_STR,DEF_SZ/3);
        strncpy(pi->threads,UNK_STR,DEF_SZ/3);

        g_free(contents);
        return -1;
  }

  /* 
        * We've read the file 
        * Use the find_data_for function to parse the file
        */
        find_data_for("VmSize: %[^\n]",pi->size,contents);
        find_data_for("VmLck: %[^\n]",pi->locked,contents);
        find_data_for("VmRSS: %[^\n]",pi->rss,contents);
        find_data_for("VmData: %[^\n]",pi->data,contents);
        find_data_for("VmStk: %[^\n]",pi->stack,contents);
        find_data_for("VmExe: %[^\n]",pi->exe,contents);
        find_data_for("VmLib: %[^\n]",pi->lib,contents);
        find_data_for("State: %[^\n]",pi->state,contents);
        find_data_for("SleepAVG: %[^\n]",pi->sleepavg,contents);
        find_data_for("Threads: %[^\n]",pi->threads,contents);

  /* Cleaning... */

  g_string_free(status_file,TRUE);
  g_free(contents);

  return 0;

}

int get_mm_details(const int pid, struct mm_details *details,
                                                        const char *mmregion)
{
        g_assert(pid>0 && details!=NULL && mmregion!=NULL);

        /* We use mmregion to make the search */
        GString *smaps_file=g_string_new("");
        gchar *contents;
        char *p;

        /* Construct the path */
        g_string_printf(smaps_file,"/proc/%d/smaps",pid);

        if((g_file_get_contents(smaps_file->str,&contents,NULL,NULL))==FALSE){
                /* Something wrong with the file... 
                 * So put default values
                */
                strncpy(details->size,UNK_STR,DEF_SZ);
                strncpy(details->rss,UNK_STR,DEF_SZ);
                strncpy(details->sh_clean,UNK_STR,DEF_SZ);
                strncpy(details->sh_dirty,UNK_STR,DEF_SZ);
                strncpy(details->priv_clean,UNK_STR,DEF_SZ);
                strncpy(details->priv_dirty,UNK_STR,DEF_SZ);
                
                /* Cleaning up */
                g_string_free(smaps_file,TRUE);
                g_free(contents);

                return -1;
        }

        /* OK, the file is in the buffer */

        if ((p=strstr(contents,mmregion))!=NULL){
                /* Use the find_data_for function again */      
                find_data_for("Size: %[^\n]",details->size,p);
                find_data_for("Rss: %[^\n]",details->rss,p);
                find_data_for("Shared_Clean: %[^\n]",details->sh_clean,p);
                find_data_for("Shared_Dirty: %[^\n]",details->sh_dirty,p);
                find_data_for("Private_Clean: %[^\n]",details->priv_clean,p);
                find_data_for("Private_Dirty: %[^\n]",details->priv_dirty,p);
        }

        /* Clean up ... */

        g_string_free(smaps_file,TRUE);

        return 0;
}

int get_process_info(const int pid, struct procinfo *pi,
                                                        struct dirent ***file_list, int *numfiles)
{
        g_assert(pid>0 && pi!=NULL);

  GString *path=g_string_new("/proc/");

  g_string_append(path,(gchar *)lkmonitor_itoa(pid));

  /* Get cmdline info */
  if(get_cmdline_info(path->str,pi)!=0)
        g_warning("Can't get cmdline info.");

  /* Get environment info */
  if(get_env_info(path->str,pi)!=0)
        g_warning("Can't get environment info for process");
 
  /* Get maps info */
  if(get_maps_info(path->str,pi)!=0)
        g_warning("Can't get memory maps info.");

  /* Get files info */
  if(get_files_info(path->str,pi,file_list,numfiles)!=0)
        g_warning("Can't get file descriptors info.");

        /* Get VM info and other status file information */
        if(get_vm_info(path->str,pi)!=0)
                g_warning("Can't get VM info.");

  /* Cleaning up... */
  g_string_free(path,TRUE);
  
  return 0;
}

---