/home/fernape/Projects/lkmonitor/src/lininfo.c File Reference

#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"

Go to the source code of this file.

Defines
#define	TAM   10
#define	TAM   10
#define	BASE   2
#define	STR_DEFAULT   _("No info.")
Functions
int	get_cpu_info (struct cpu_info *cpu)
int	get_mhz_info (char *mhz)
	End get_cpu_info.
int	get_mem_info (struct mem_info *mem)
int	get_devs_info (struct dev_info *devs)
	End get_mem_info.
int	get_settings_info (struct settings_info *settings)
int	get_stats_info (struct stats_info *stats)
int	get_battery_info (struct battery_info *battery, const char *file)
int	get_acpi_info (struct acpi_info *acpi)
int	get_cmd_ver_info (struct cmd_ver *cmdversion)
int	get_loadavg_info (struct cmd_ver *cmdversion)
int	get_channels_info (struct channels_info *channels)
int	get_net_info (struct net_dev_info *netinfo, const int index)
int	get_fs_info (struct fs_info *fsinfo)
int	get_mod_info (struct modules_info *modinfo)

---

Define Documentation

#define BASE   2

Referenced by get_net_info().

#define STR_DEFAULT   _("No info.")

Referenced by get_fs_info().

#define TAM   10

#define TAM   10

Referenced by find_data_for(), get_acpi_info(), and get_battery_info().

---

Function Documentation

int get_acpi_info

(

struct acpi_info *

acpi

)

Collects ACPI information (Battery state and system temperature).

Parameters:

acpi

Structure to fill with collected information

Returns:

0 if success, -1 otherwise

Definition at line 285 of file lininfo.c.

References acpi, BATT_STATE, BATT_STATE1, acpi_info::battery, parse_batt(), battery_info::rem, TAM, acpi_info::temp, acpi_info::temp_critical, TEMP_TRIP, and TEMPERATURE.

Referenced by update_misc().

{
        #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_battery_info	(	struct battery_info *	battery,
		const char *	file
	)

Collects battery information.

Parameters:

	battery	Structure to fill with collected information
	file	File to read data

Returns:

0 if success, -1 otherwise

Definition at line 245 of file lininfo.c.

References battery_info::cap, battery_info::cap_low, battery_info::cap_warning, battery_info::last_cap, parse_batt(), TAM, and battery_info::type.

Referenced by main().

{
#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_channels_info

(

struct channels_info *

channels

)

Get communication channels information

Parameters:

channels

channels_info structure pointer

Returns:

0 on success, -1 on error

Definition at line 412 of file lininfo.c.

References channels_info::dma, DMA_FILE, channels_info::iomem, IOMEM_FILE, channels_info::ioports, and IOPORTS_FILE.

Referenced by update_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_cmd_ver_info

(

struct cmd_ver *

cmdversion

)

Get cmdline version kernel information

Parameters:

cmdversion

pointer to cmd_ver to store the data

Returns:

0 on success, 1 on error

Definition at line 352 of file lininfo.c.

References cmd_ver::cmd, CMD_FILE, cmdversion, VER_FILE, and cmd_ver::version.

Referenced by update_cmd_ver().

{
        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_cpu_info

(

struct cpu_info *

cpu

)

Collects cpu information.

Parameters:

cpu

Structure to fill with collected information

Returns:

0 if success

Definition at line 43 of file lininfo.c.

References cpu_info::bogomips, cpu_info::cache, cpu, cpu_info::cpu_family, CPU_FILE, cpu_info::cpuid_level, find_data_for(), cpu_info::flags, cpu_info::fpu, cpu_info::fpu_exception, cpu_info::Mhz, cpu_info::model, cpu_info::model_name, cpu_info::processor, cpu_info::stepping, cpu_info::vendor_id, and cpu_info::wp.

Referenced by update_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_devs_info

(

struct dev_info *

devs

)

End get_mem_info.

Collects devices information.

Parameters:

devs

Structure to fill with collected information

Returns:

0 if success, -1 otherwise

Definition at line 135 of file lininfo.c.

References dev_info::blocks, dev_info::characters, DEV_FILE, devs, and skip_lines().

Referenced by update_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_fs_info

(

struct fs_info *

fsinfo

)

Get information about filesystems

Parameters:

fsinfo

fs_info structure pointer

Returns:

0

Definition at line 513 of file lininfo.c.

References fs_info::devs, FS_FILE, fsinfo, fs_info::nodevs, and STR_DEFAULT.

Referenced by update_fs_info().

{
        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_loadavg_info

(

struct cmd_ver *

cmdversion

)

Get load average information

Parameters:

cmdversion

pointer to cmd_ver to store the data

Returns:

0 on success, 1 on error

Definition at line 387 of file lininfo.c.

References cmdversion, LOAD_FILE, and cmd_ver::loadavg.

Referenced by update_process().

{
        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_mem_info

(

struct mem_info *

mem

)

Collects memory information.

Parameters:

mem

Structure to fill with collected information

Returns:

0 if success

Definition at line 99 of file lininfo.c.

References mem_info::active, mem_info::buffers, mem_info::cached, mem_info::dirty, find_data_for(), mem_info::free, mem_info::high_free, mem_info::high_total, mem_info::hugepages_free, mem_info::hugepages_size, mem_info::hugepages_total, mem_info::inactive, mem_info::low_free, mem_info::low_total, mem, MEM_FILE, mem_info::swap_cached, mem_info::swap_free, mem_info::swap_total, and mem_info::total.

Referenced by update_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_mhz_info

(

char *

mhz

)

End get_cpu_info.

Updates CPU processor frequency.

Parameters:

mhz

string to put the updated data

Returns:

0 if success

Definition at line 77 of file lininfo.c.

References CPU_FILE, and find_data_for().

Referenced by update_cpu_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_mod_info

(

struct modules_info *

modinfo

)

Get information about modules

Parameters:

modinfo

modules_info structure pointer

Returns:

0 on success, -1 otherwise

Definition at line 563 of file lininfo.c.

References modules_info::contents, MOD_FILE, and modinfo.

Referenced by update_modules_info().

{
        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;

}

int get_net_info	(	struct net_dev_info *	netinfo,
		const int	index
	)

Get information about a network interface

Parameters:

	netinfo	net_dev_info structure pointer
	index	device index.

Returns:

0 on success, -1 on error

Definition at line 457 of file lininfo.c.

References BASE, net_dev_info::bytes, net_dev_info::compressed, net_dev_info::drop, net_dev_info::errs, net_dev_info::fifo, NET_DEVS, netinfo, net_dev_info::packets, net_dev_info::r_frame, net_dev_info::r_multicast, skip_lines(), net_dev_info::t_carrier, and net_dev_info::t_colls.

Referenced by update_net_info().

{
        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_settings_info

(

struct settings_info *

settings

)

Collects settings information.

Parameters:

settings

Structure to fill with collected information

Returns:

0 if success, -1 otherwise

Definition at line 163 of file lininfo.c.

References settings_info::domain, DOMAIN_NAME, settings_info::fdasig, settings_info::fdfreed, settings_info::fdmax, FILES, settings_info::host, HOST_NAME, settings_info::inasig, settings_info::inmax, INODES, settings_info::max_opcall, settings_info::max_seminset, settings_info::max_semsets, settings_info::max_semsys, P_MAX_M, P_MAX_Q, P_MAX_S, settings_info::page_max, PAGE_MAX, settings_info::posix_mpq, settings_info::posix_mq, settings_info::posix_ms, read_values_from_file(), settings_info::seg_max, SEG_MAX, settings_info::seg_size, SEG_SIZE, SEM, settings, settings_info::threads, and THREADS_MAX.

Referenced by update_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

)

Collects status information. Times for the cpu usage.

Parameters:

stats

Structure to fill with collected information

Returns:

0 if success, -1 otherwise

Definition at line 212 of file lininfo.c.

References stats_info::cpu, stats_info::cpu0, stats_info::cpu1, stats_info::ctxt, find_data_for(), stats, and STATS_FILE.

Referenced by update_misc().

{
        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);
}

---