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

#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_critical("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;
        int ret = 0;

        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);
                ret = -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);
                ret = -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(ret);
}

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)
{
#define TAM 10
        gchar *contents;
        gchar *unk_string=_("Unknown");
        int ret=0;
        gchar data[TAM];
        gchar dest[TAM];

        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{  
                strncpy(data,parse_batt("design capacity",contents,dest),TAM);
                battery->cap=g_string_new(data);
                strncpy(data,parse_batt("last full capacity",contents,dest),TAM);
                battery->last_cap=g_string_new(data);
                strncpy(data,parse_batt("design capacity warning",contents,dest),TAM);
                battery->cap_warning=g_string_new(data);
                strncpy(data,parse_batt("design capacity low",contents,dest),TAM);
                battery->cap_low=g_string_new(data);
                strncpy(data,parse_batt("battery type",contents,dest),TAM);
                battery->type=g_string_new(data);
        }

        g_free(contents);
        return ret;
}

int get_acpi_info(struct acpi_info *acpi)
{
        #define TAM 10
        gchar *contents;
        int ret=0;
        gchar data[TAM];
        gchar dest[TAM];

        //Read the current battery status.
        if(g_file_get_contents(BATT_STATE,&contents,NULL,NULL)==FALSE){
                acpi->battery.rem=g_string_new("");
                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){
                        g_warning("Failed to read %s file\n",BATT_STATE1);
                        g_free(contents);
                        ret=-1;
                }else{  
                        strncpy(data,parse_batt("remaining capacity",contents,dest),TAM);
                        g_free(contents);
                        g_string_append(acpi->battery.rem,data);
                }

                //ret=-1;
        }else{  
                strncpy(data,parse_batt("remaining capacity",contents,dest),TAM);
                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("");
                g_warning("Failed to read %s file\n",TEMPERATURE);
                g_free(contents);
                ret=-1;
        }else{  
                /* parse_batt also works for this file. */
                strncpy(data,parse_batt("temperature",contents,dest),TAM);
                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("");
                g_free(contents);
                g_warning("Failed to read %s file\n",TEMP_TRIP);
                ret=-1;
        }else{  
                /* parse_batt also works for this file. */
                strncpy(data,parse_batt("critical",contents,dest),TAM);
                g_free(contents);
                acpi->temp_critical=g_string_new(data);
        }


        return(ret);
}

int get_cmd_ver_info(struct cmd_ver *cmdversion)
{
        gchar *contents;
        gchar *unk_string=_("Unknown");
        int ret_val=0;

        if(g_file_get_contents(CMD_FILE,&contents,NULL,NULL)==FALSE){
                g_free(contents);
                cmdversion->cmd=g_string_new(unk_string);
                ret_val=-1;
        }
        else{
                cmdversion->cmd=g_string_new(contents);
                g_free(contents);        
        }

        if(g_file_get_contents(VER_FILE,&contents,NULL,NULL)==FALSE){
                g_free(contents);
                cmdversion->version=g_string_new(unk_string);
                ret_val=-11;
        }
        else{
                cmdversion->version=g_string_new(contents);
                g_free(contents);        
        }



        return(ret_val);
}

int get_loadavg_info(struct cmd_ver *cmdversion)
{
        g_assert(cmdversion!=NULL);

        char *unk_string=_("Unknown");
        gchar *contents;
        int ret_val=0;

        if(g_file_get_contents(LOAD_FILE,&contents,NULL,NULL)==FALSE){
                g_free(contents);
                cmdversion->loadavg=g_string_new(unk_string);
                ret_val=-1;
        }else{
                cmdversion->loadavg=g_string_new(contents);
                g_free(contents);
        }

        return(ret_val);
}


int get_channels_info(struct channels_info *channels)
{
        g_assert(channels!=NULL);

        gchar *contents;
        char *unk_string=_("Not available");
        int ret_val=-1;

        if(g_file_get_contents(IOMEM_FILE,&contents,NULL,NULL)==FALSE){
                g_free(contents);
                channels->iomem=g_string_new(unk_string);
                ret_val=-1;
        }else{
                channels->iomem=g_string_new(contents);
                g_free(contents);
        }


        if(g_file_get_contents(IOPORTS_FILE,&contents,NULL,NULL)==FALSE){
                g_free(contents);
                channels->ioports=g_string_new(unk_string);
                ret_val=-1;
        }else{
                channels->ioports=g_string_new(contents);
                g_free(contents);
        }

        if(g_file_get_contents(DMA_FILE,&contents,NULL,NULL)==FALSE){
                g_free(contents);
                channels->dma=g_string_new(unk_string);
                ret_val=-1;
        }else{
                channels->dma=g_string_new(contents);
                g_free(contents);
        }

        return(ret_val);
}


int get_net_info(struct net_dev_info *netinfo,const int index)
{
        g_assert(netinfo!=NULL && index >=0);

        gchar *contents;
        char *p;
        char name[10];
        #define BASE 2  /* Base for skip's jump */

        if(g_file_get_contents(NET_DEVS,&contents,NULL,NULL)==FALSE){
                g_free(contents);
                return -1;
        }

        /* File exists */
        p=skip_lines((char *)contents,BASE+index);
        
        /* 
        *       Change the ':' by a " " (white space) 
        *       This is to make easier the sscanf pattern
        *       
        */

        {
                char *p2=NULL;
                if((p2=strchr(p,':'))!=NULL)
                        *p2=' ';
                
        }

        /* Now we are ready to read */
        sscanf(p,"%s %llu %lu %d %d %d %d %d %d %llu %lu %d %d %d %d %d %d",
                        name,
                        &netinfo->bytes[0],&netinfo->packets[0],&netinfo->errs[0],
                        &netinfo->drop[0],&netinfo->fifo[0],&netinfo->r_frame,
                        &netinfo->compressed[0],&netinfo->r_multicast,
                        &netinfo->bytes[1],&netinfo->packets[1],&netinfo->errs[1],
                        &netinfo->drop[1],&netinfo->fifo[1],&netinfo->t_colls,
                        &netinfo->t_carrier,&netinfo->compressed[1]);

        /* Remove the ':' character */
        if((p=strchr(name,':'))!=NULL)
                *p='\0';

        /* Clean up */
        g_free(contents);
        
        return 0;
}



int get_fs_info(struct fs_info *fsinfo)
{
        g_assert(fsinfo!=NULL);

        #define STR_DEFAULT _("No info.")
        gchar *contents,*p;
        char second[20];
        char first[20];
        char line[80];


        if(g_file_get_contents(FS_FILE,&contents,NULL,NULL)==FALSE){
                /* Clean up and exit */
                g_warning("No filesystems file");
                g_free(contents);
                fsinfo->devs=g_string_new(STR_DEFAULT);
                fsinfo->nodevs=g_string_new(STR_DEFAULT);
                return -1;
        }

        /* Create GString instances */
        fsinfo->devs=g_string_new("");
        fsinfo->nodevs=g_string_new("");

        p=contents;
        /* Pseudo and normal in separate lists */
        while(sscanf(p,"%[^\n]",line)!=EOF){
                sscanf(line,"%s %s",first,second);
                if(line[0]!='n'){
                        fsinfo->devs=g_string_append(fsinfo->devs,first);
                        fsinfo->devs=g_string_append(fsinfo->devs,"\n");
                }else{
                        fsinfo->nodevs=g_string_append(fsinfo->nodevs,second);
                        fsinfo->nodevs=g_string_append(fsinfo->nodevs,"\n");
                }


                p=strchr(p,'\n') +1; 
        }

        g_free(contents);

        return 0;
}


int get_mod_info(struct modules_info *modinfo)
{
        g_assert(modinfo!=NULL);

        gchar *contents,*p,*p2;
        gsize length;
        int i;
        char *states[]={"Live", "Loading", "Unloading"};
        char name[20];
        char size[10];
        char refcount[5];
        char status[10];
        char address[20];


        if((g_file_get_contents(MOD_FILE,&contents,&length,NULL))==FALSE){
                g_warning("No modules information file!");
                g_free(contents);
                return -1;
        }


        /* In case we have the buffer filled... */
        modinfo->contents=g_string_new("");

        p=contents;

        /* Traverse and process the buffer */
        while(p-contents!=length){
                sscanf(p,"%s %s %s",name,size,refcount);
                /* Try to find the status */
                for(i=0;i<3;i++){
                        if((p2=strstr(p,states[i]))!=NULL){
                                /* We found the state */
                                sscanf(p2,"%s %s",status,address);
                                break;
                        }
                }
                if(p2!=NULL){
                        modinfo->contents=g_string_append(modinfo->contents,name);
                        modinfo->contents=g_string_append(modinfo->contents," ");
                        modinfo->contents=g_string_append(modinfo->contents, size);
                        modinfo->contents=g_string_append(modinfo->contents, " ");
                        modinfo->contents=g_string_append(modinfo->contents, refcount);
                        modinfo->contents=g_string_append(modinfo->contents," ");
                        modinfo->contents=g_string_append(modinfo->contents,status);
                        modinfo->contents=g_string_append(modinfo->contents," ");
                        modinfo->contents=g_string_append(modinfo->contents, address);
                        modinfo->contents=g_string_append(modinfo->contents,"\n");
                }

                /* Let's point to the next line */
                p=strchr(p2,'\n')+1;
        }

        /* Cleaning up and going back to system */

        g_free(contents);  

        return 0;

}

---