root/foundation-apps/gmemusage-maxx/processlist.c

/*
        gmemusage

        Copyright 1998, Michael Pruett
        Copyright 1999, Mark B. Allan
        Copyright 2000-2008, Eric Masson
        Copyright 2008-2009, Genirix Systems

        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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
        USA.
*/



#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <stdio.h>
#include <errno.h>

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
//#include <sys/types.h>
//#include <sys/uio.h>

#include "process.h"
#include "extern.h"

/****************************************************************************/

void init(void);
void checkProc(void);
void list (void);


void getKernelMemory(void);
void getSystemMemory(void);

long getMemoryIOMEM (char *data);
long getByteSize(char * range);

long get_time (void);
long get_time_in_milliseconds (void);



/****************************************************************************/

long get_time (void)
{
        struct timeval tv;
        struct timezone tz;
        gettimeofday (&tv, &tz);

         //return (long)tv.tv_usec;
        return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

long get_time_in_milliseconds ()
{
    struct timeval  tv;
    struct timezone tz;
    gettimeofday (&tv, &tz);
    return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

void init(void)
{
        kilobyte = 1024;
        megabyte = kilobyte * 1024;
        gigabyte =  megabyte * 1024;

//      char *content;
//      content =fastload("./meminfo.txt");
//      fprintf(stdout, "%s", content);

        // verify the /proc filesystem
        checkProc();

        // load the kernel memory details
        getKernelMemory();

        // load the system memory details
        getSystemMemory();
}

void checkProc(void)
{
        FILE*   procfile;

        procfile = fopen("/proc/iomem", "r");
        if (!procfile)
        {
//              printf("gmemusage info: /proc/iomem not present!\n");
                system_detail.iomem_present = FALSE;
        }
        else
        {
                system_detail.iomem_present = TRUE;
//              printf("gmemusage info: /proc/iomem present.\n");
                fclose(procfile);
        }
}

void getKernelMemory(void)
{

        system_detail.kernel_code = getMemoryIOMEM("Kernel code");
        system_detail.kernel_data = getMemoryIOMEM("Kernel data");

        system_detail.kernel_size = system_detail.kernel_code + system_detail.kernel_data;

//      printf("Kernel Size = %lu KB\n", system_detail.kernel_size / kilobyte );
}

void getSystemMemory(void)
{
        system_detail.system_ram= getMemoryIOMEM("System RAM");

//      printf("TotalMemory = %f2.2 MB\n", (float)(system_detail.system_ram / megabyte));

}


/* get the requested memory size in bytes */
long getMemoryIOMEM (char *data)
{
        FILE*   memfile;
        char    s[1024];
        char    range[1024];
        size_t  size =0;
        int     buf_size = 128;
        memfile = fopen("/proc/iomem", "r");
//      memfile = fopen("./iomem.txt", "r");


        if (!memfile)
        {
                printf("gmemusage error:  unable to open /proc/iomem !  Terminating the process.\n");
                return (0);
        }

        char* result = NULL;
        while (fgets(s,buf_size, memfile)!=NULL)
        {
                result = strstr( s, data);
                if( result != NULL )
                {
                //      printf( "Found a substring: %s", result);
                        sscanf(s, "%s% %*s", &range);
                        size += getByteSize(range);
                        //printf( " with %lu bytes\n", size);
                }
        }

        fclose( memfile );

//      printf( "Memory size for /proc/iomem::%s (%lu) \n",data,size );

        return size;
}

long getByteSize(char * range)
{
        char    slow[64];
        char    dash[1];
        char    shigh[64];
        char    *t;
        long    low, high, size;

        char    delims[] = "-";
        char    *result = NULL;

        // get low bytes
        result = strtok( range, delims );
        low =  strtoul(result,&t,16);
        //printf( "low [%s]:%lu \n",result,low );

        // get high bytes
        result = strtok( NULL, delims );
        high =  strtoul(result,&t,16);

        //printf( "high [%s]%lu \n",result,high );

        size = high-low;

        return size;

}

void list (void)
{
        DIR                             *directory;
        struct dirent   *entry;
        int                             i = 0;
        int                     buf_size = 128;

        int                     pid;
        char            path[PATH_MAX];
        FILE*           statusFile;
        char            s[1024];
        char            comm[256];
        char            tmpString[1024];
        int                     tmpInt;
        long            tmpLong;
        size_t          proc_size;
        int                     ppid;
        char            *cp;
        int                     x;
        char            file[16];
        int                     found=0;
        long            start_time, total_time;
        long            start_time2, total_time2, end_time2;


//  start_time = get_time();

        directory = opendir("/proc");


        while ( (entry = readdir(directory)) )
        {

                if (*entry->d_name < '0' || *entry->d_name > '9')
                        continue;

                strcpy(file, entry->d_name);
                sprintf(path, "/proc/%s/status",file );

                // opent the status file for that specific PID
                statusFile = fopen(path, "r");

                //  file = fastload(path);
                //      printf("%d",sizeof(file));

        /**
         * Check if the file is open... Maybe the process is already gone!
         * Fix null pointer bug when.  Thx Peter Kovar
         */
                if (statusFile == NULL)
                        continue;


                // initialize iteration variables
                s[buf_size] = 0;

                processes[i].pid = atoi(file);
                processes[i].live = 0;
                processes[i].vsize = 0;
                processes[i].hwm = 0;
                processes[i].rss = 0;
                processes[i].data = 0;
                processes[i].stack = 0;
                processes[i].exe = 0;
                processes[i].lib = 0;
                processes[i].threads = 0;

                fgets(s, buf_size, statusFile); /* Name */
                sscanf(s, "%*s %s", tmpString);
                strncpy(processes[i].name, tmpString, 31);

                // find VmSize
                char* result;
                
                while (fgets(s,buf_size, statusFile)!=NULL)
                {
                        //fgets(s, buf_size, statusFile);
                        //printf(">>%s",s);
                        
                        result = 0;
                        result = strstr( s, "VmSize");

                        if( result != NULL )
                                break;
                }

                // detect the presence of the VmSize field (if not, it is more likely to be a kernel related process
                cp = index(s, 'k');

                if (cp == NULL)
                {
                        //printf("oops!, no VmSize for %s\n", entry->d_name);
                }
                else
                {
                        sscanf(s, "%*s %lu %*s ", &tmpLong);
                        processes[i].vsize = (tmpLong * 1024); // convert KB into bytes

                        fgets(s, buf_size, statusFile); /* VmLck  */

                        fgets(s, buf_size, statusFile); /* VmHWM  */
                        sscanf(s, "%*s %lu %*s ", &tmpLong);
                        processes[i].hwm = (tmpLong * 1024); // convert KB into bytes

                        fgets(s, buf_size, statusFile); /* VmRSS  */
                        sscanf(s, "%*s %lu %*s ", &tmpLong);
                        processes[i].rss = (tmpLong * 1024); // convert KB into bytes


                        fgets(s, buf_size, statusFile); /* VmData */
                        sscanf(s, "%*s %lu %*s ", &tmpLong);
                        processes[i].data = (tmpLong * 1024); // convert KB into bytes

                        fgets(s, buf_size, statusFile); /* VmStk  */
                        sscanf(s, "%*s %lu %*s ", &tmpLong);
                        processes[i].stack = (tmpLong * 1024); // convert KB into bytes

                        fgets(s, buf_size, statusFile); /* VmExe */
                        sscanf(s, "%*s %lu %*s ", &tmpLong);
                        processes[i].exe = (tmpLong * 1024); // convert KB into bytes

                        fgets(s, buf_size, statusFile); /* VmLib  */
                        sscanf(s, "%*s %lu %*s ", &tmpLong);
                        processes[i].lib = (tmpLong * 1024); // convert KB into bytes

                        processes[i].live = processes[i].rss;

                }
                fclose(statusFile);
                
//              end_time2 = get_time();
//              printf ("\nTime elapsed in each %d uSec\n", end_time2 - start_time2);
//              printf("Pid=%d\t name=%s \t\t\tVMSize=%lu \t\tLive=%lu \ttDatas=%d\n", processes[i].pid, processes[i].name, processes[i].vsize, processes[i].live ,processes[i].data );

                i++;
        }

        closedir(directory);
//      printf("--------------------------------------------------------------\n");
//  total_time = get_time () - start_time;
//      printf ("\nTime elapsed in list() for %duSec processes=%d \n", total_time, i);

        processCount = i;
//      exit(0);
}