lininfo.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 <gnome.h>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <sys/types.h>
#include <stdlib.h>
#include <glib.h>

#include "lininfo.h"
#include "others.h"

int
get_cpu_info (struct cpu_info *cpu)
{
  gchar* contents;
  char* str;
  
  if(g_file_get_contents(CPU_FILE,&contents,NULL,NULL)==FALSE)
          //Error accesing file. Stop program 
        g_error("Can't read %s file",CPU_FILE);
  
  str=contents;
  find_data_for("processor : %[^\n]",cpu->processor,str);
  find_data_for("vendor_id : %[^\n]",cpu->vendor_id,str);
  find_data_for("cpu family : %[^\n]",cpu->cpu_family,str);
  find_data_for("model : %[^\n]",cpu->model,str);
  find_data_for("model name : %[^\n]",cpu->model_name,str)      ;
  find_data_for("stepping : %[^\n]",cpu->stepping,str);
  find_data_for("cpu MHz : %[^\n]",cpu->Mhz,str);
  find_data_for("cache size : %[^\n]",cpu->cache,str);
  find_data_for("fpu : %[^\n]",cpu->fpu,str);
  find_data_for("fpu_exception : %[^\n]",cpu->fpu_exception,str);
  find_data_for("cpuid level : %[^\n]",cpu->cpuid_level,str);
  find_data_for("wp : %[^\n]",cpu->wp,str);
  find_data_for("flags : %[^\n]",cpu->flags,str);
  find_data_for("bogomips : %[^\n]",cpu->bogomips,str);
        
  g_free(contents);

  return (0);
}                               

int get_mhz_info(char *mhz)
{
        gchar *contents;
        
        if(g_file_get_contents(CPU_FILE,&contents,NULL,NULL)==FALSE){
          //Error accesing file. Stop program 
                g_error("Can't read %s file",CPU_FILE);
                return -1;
        }
        
        find_data_for("cpu MHz : %[^\n]",mhz,contents);
        
        g_free(contents);
        
        return(0);
}


int
get_mem_info (struct mem_info *mem)
{
        gchar* contents;
        
        if(g_file_get_contents(MEM_FILE,&contents,NULL,NULL)==FALSE)
                //Can't read file. Stop program
                g_error("Can't read %s file",MEM_FILE);

  find_data_for ("MemTotal: %[^\n]",mem->total, contents);
  find_data_for ("MemFree: %[^\n]",mem->free, contents);
  find_data_for ("Buffers: %[^\n]",mem->buffers, contents);
  find_data_for ("Cached: %[^\n]",mem->cached, contents);
  find_data_for ("SwapCached: %[^\n]",mem->swap_cached, contents);
  find_data_for ("Active: %[^\n]",mem->active, contents);
  find_data_for ("Inactive: %[^\n]",mem->inactive,contents);
  find_data_for ("Dirty: %[^\n]",mem->dirty, contents);
  find_data_for ("HighTotal: %[^\n]",mem->high_total, contents);
  find_data_for ("HighFree: %[^\n]",mem->high_free, contents);
  find_data_for ("LowTotal: %[^\n]",mem->low_total, contents);
  find_data_for ("LowFree: %[^\n]",mem->low_free, contents);
  find_data_for ("SwapTotal: %[^\n]",mem->swap_total, contents);
  find_data_for ("SwapFree: %[^\n]",mem->swap_free, contents);
  find_data_for ("HugePages_Total: %[^\n]",mem->hugepages_total, contents);
  find_data_for ("HugePages_Free: %[^\n]",mem->hugepages_free, contents);
  find_data_for ("Hugepagesize: %[^\n]",mem->hugepages_size, contents);

  g_free(contents);
  
  return (0);
}                               


int get_devs_info(struct dev_info *devs)
{
  gchar *contents;
  gsize tam;
  char *p;

   if(g_file_get_contents(DEV_FILE,&contents,&tam,NULL)==FALSE){
            //Can't read file. Stop program
                g_error("Can't read %s file",DEV_FILE);
            return -1;
   }
        
    p=strstr(contents,"Block devices:");
    *p='\0';
    p=skip_lines(p,1);
    devs->blocks=g_string_new((gchar*) p);
    p=skip_lines(contents,1);
    devs->characters=g_string_new(p);
   
    g_free(contents);
   
    return(0);
}

int get_settings_info(struct settings_info *settings)
{
        gchar *unk_string=_("Unknown");
        gchar *contents;
        
        if(g_file_get_contents(HOST_NAME,&contents,NULL,NULL)==FALSE){
                g_warning("Failed to read %s file\n",HOST_NAME);
                settings->host=g_string_new(unk_string);
                g_free(contents);
                return (-1);
        }else{
                settings->host=g_string_new(contents);
                g_free(contents);
        }
        
        if(g_file_get_contents(DOMAIN_NAME,&contents,NULL,NULL)==FALSE){
                settings->domain=g_string_new(unk_string);
                g_warning("Failed to read %s file\n",DOMAIN_NAME);
                g_free(contents);
                return (-1);
        }else{
                settings->domain=g_string_new(contents);
                g_free(contents);               
        }
        /* We need to read the current values for the settings */
        
        read_values_from_file(3,FILES,&settings->fdasig,&settings->fdfreed,\
        &settings->fdmax);
        read_values_from_file(1,THREADS_MAX,&settings->threads);
        read_values_from_file(1,P_MAX_Q,&settings->posix_mq);
        read_values_from_file(1,P_MAX_M,&settings->posix_mpq);
        read_values_from_file(1,P_MAX_S,&settings->posix_ms);
        read_values_from_file(2,INODES,&settings->inmax,&settings->inasig);
        read_values_from_file(1,PAGE_MAX,&settings->page_max);
        read_values_from_file(1,SEG_MAX,&settings->seg_max);
        read_values_from_file(1,SEG_SIZE,&settings->seg_size);
        read_values_from_file(4,SEM,&settings->max_seminset, &settings->max_semsys,\
                                                        &settings->max_opcall, &settings->max_semsets);
        
        //g_free(contents);
        
        return(0);
}

int get_stats_info (struct stats_info *stats)
{
        gchar *contents;
        gchar str[50];
        
        if(g_file_get_contents(STATS_FILE,&contents,NULL,NULL)==FALSE){
                //Can't read file.
                g_warning("Failed to read %s file",STATS_FILE);
                g_free(contents);
                stats->cpu=g_string_new("Unknown");
                return -1;
        }else{
                find_data_for ("cpu %[^\n]",str, contents);
                stats->cpu=g_string_new(str);
                find_data_for ("cpu0 %[^\n]",str, contents);
                stats->cpu0=g_string_new(str);
                find_data_for ("cpu1 %[^\n]",str, contents);
                stats->cpu1=g_string_new(str);
                find_data_for ("ctxt %[^\n]",str, contents);
                stats->ctxt=g_string_new(str);
        }
        
        g_free(contents);

        return (0);
}


int get_battery_info(struct battery_info *battery,const char *file)
{
        gchar *contents;
        gchar *unk_string=_("Unknown");
        int ret=0;
        gchar data[10];
        
        if(g_file_get_contents(file,&contents,NULL,NULL)==FALSE){
                battery->cap=g_string_new(unk_string);
                battery->last_cap=g_string_new(unk_string);
                battery->type=g_string_new(unk_string);
                battery->cap_warning=g_string_new(unk_string);
                battery->cap_low=g_string_new(unk_string);
                
                g_free(contents);
                g_warning("Failed to read %s file\n",file);
                ret=-1;
        }else{  
                strcpy(data,parse_batt("design capacity",contents));
                battery->cap=g_string_new(data);
                strcpy(data,parse_batt("last full capacity",contents));
                battery->last_cap=g_string_new(data);
                strcpy(data,parse_batt("design capacity warning",contents));
                battery->cap_warning=g_string_new(data);
                strcpy(data,parse_batt("design capacity low",contents));
                battery->cap_low=g_string_new(data);
                strcpy(data,parse_batt("battery type",contents));
                battery->type=g_string_new(data);
        }
        
        g_free(contents);
        return ret;
}

int get_acpi_info(struct acpi_info *acpi)
{
        gchar *contents;
        int ret=0;
        gchar *unk_string=_("Unknown");
        gchar data[10];
        
        //Read the current battery status.
        if(g_file_get_contents(BATT_STATE,&contents,NULL,NULL)==FALSE){
                acpi->battery.rem=g_string_new(unk_string);
                g_free(contents);
                g_warning("Failed to read %s file\n",BATT_STATE);
                
                /* Try with BAT1 subdirectory */
                if(g_file_get_contents(BATT_STATE1,&contents,NULL,NULL)==FALSE){
                        acpi->battery.rem=g_string_new(unk_string);
                        g_warning("Failed to read %s file\n",BATT_STATE1);
                        g_free(contents);
                        ret=-1;
                }else{  
                        strcpy(data,parse_batt("remaining capacity",contents));
                        g_free(contents);
                        acpi->battery.rem=g_string_new(data);
                }
                
                //ret=-1;
        }else{  
                strcpy(data,parse_batt("remaining capacity",contents));
                g_free(contents);
                acpi->battery.rem=g_string_new(data);
        }
        
        //Read the current temperature.
        if(g_file_get_contents(TEMPERATURE,&contents,NULL,NULL)==FALSE){
                acpi->temp=g_string_new(unk_string);
                g_warning("Failed to read %s file\n",TEMPERATURE);
                g_free(contents);
                ret=-1;
        }else{  
                //parse_batt also works for this file.
                strcpy(data,parse_batt("temperature",contents));
                g_free(contents);
                acpi->temp=g_string_new(data);
        }
        
        
                //Read the current temperature.
        if(g_file_get_contents(TEMP_TRIP,&contents,NULL,NULL)==FALSE){
                acpi->temp_critical=g_string_new(unk_string);
                g_free(contents);
                g_warning("Failed to read %s file\n",TEMP_TRIP);
                ret=-1;
        }else{  
                //parse_batt also works for this file.
                strcpy(data,parse_batt("critical",contents));
                g_free(contents);
                acpi->temp_critical=g_string_new(data);
        }
        
        //g_free(contents);
        
        return(ret);
}

---