./--+-- Makefile 
     |
     +-- jsms.cc
     |
     +-- main.cc
     | 
     +-- include/ ------ jsms.h
			

#############################################################################
# Makefile for building jsms
# Generated by tmake at 15:32, 2003/06/13
#     Project: jsms
#    Template: app
#############################################################################

####### Compiler, tools and options

CC  =   gcc
CXX =   g++
CFLAGS  =   -pipe -Wall -W -O2 -DNO_DEBUG
CXXFLAGS=   -pipe -Wall -W -O2 -DNO_DEBUG

# ./include의 헤더파일을 참조하도록 하기 위해서
INCPATH =   -I./include
LINK    =   g++
LFLAGS  =

TAR =   tar -cf
GZIP    =   gzip -9f

####### Files

HEADERS =   include/jsms.h
SOURCES =   jsms.cc \
        main.cc
OBJECTS =   jsms.o \
        main.o
INTERFACES =
UICDECLS =
UICIMPLS =
SRCMOC  =
OBJMOC  =
DIST    =
TARGET  =   jsms
INTERFACE_DECL_PATH = .

####### Implicit rules

.SUFFIXES: .cpp .cxx .cc .C .c

.cpp.o:
    $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.cxx.o:
    $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.cc.o:
    $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.C.o:
    $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.c.o:
    $(CC) -c $(CFLAGS) $(INCPATH) -o $@ $<
    
####### Build rules
    

all: $(TARGET)
    
$(TARGET): $(UICDECLS) $(OBJECTS) $(OBJMOC) 
    $(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJMOC) $(LIBS)
    
dist:
    $(TAR) jsms.tar jsms.pro $(SOURCES) $(HEADERS) $(INTERFACES) $(DIST)
    $(GZIP) jsms.tar

clean:
    -rm -f $(OBJECTS) $(OBJMOC) $(SRCMOC) $(UICIMPLS) $(UICDECLS) $(TARGET)
    -rm -f *~ core

####### Sub-libraries


###### Combined headers


####### Compile

jsms.o: jsms.cc

main.o: main.cc
			

#ifndef _JSMS_H_
#define _JSMS_H_
#include <vector>
#include <algorithm>
#include <unistd.h>
#include <stdio.h>
#include <set>
#include <iostream>
#include <sys/vfs.h>

#define MOUNT_STR_LEN 255
#define DEVICE_STR_LEN 80
#define MAX_CPU_NUM 32

#define DF_LINE_LEN MOUNT_STR_LEN + DEVICE_STR_LEN

using namespace std;

// 디스크 정보를 저장하기 위한 구조체
typedef struct _df
{
    int blocks;       // 할당된 블럭
    int used;         // 사용하고 있는 블럭
    int avail;        // 사용할 수 있는 블럭
    char mount[MOUNT_STR_LEN];   // 마운트 디렉토리
    char device[DEVICE_STR_LEN]; // 장치명 
} df;

// cpu 사용율
// 여러개의 CPU를 사용할 수도 있음으로 
// CPU의 갯수를 저장하며, 
// CPU의 사용율은 (CPU갯수 만큼)배열에 저장된다.  
typedef struct _cpu_usage
{
    int cpuid;          // 특별히 사용되지 않는다.
    int countcpu;       // 등록된 CPU의 수
    int cpuusage[MAX_CPU_NUM]; // 각 CPU의 사용율
} cpu_usage;


// 메모리 정보 
// 물리적 메모리와 스왑 메모리 저장용
typedef struct _mem_data
{
    ulong real;   // 물리적 메모리 크기
    ulong free;   // 물리적 메모리 남은 크기 
    ulong swap_use;  // 스왑 사용량
    ulong swap_free; // 스왑 남은량
} mem_data;

// 나중에 /etc/mtab과 /proc/mounts의 정보를 
// 비교하기 위한 목적으로 사용한다.  
// 사용법은 jsms.cc를 참고
struct ltstr
{
    bool operator()(const df m1, const df m2) const
    {
        return strcmp(m1.mount, m2.mount) < 0;
    }
};


class JSms
{

    private:
        // 현재 CPU사용율 (jiffly 갯수)
        int mcurrent_usage[MAX_CPU_NUM][3];
        // 바로전의 CPU사용율
        int mold_usage[MAX_CPU_NUM][3];

    public :
    // 디스크 정보를 얻기 위한 메서드 
    vector<df> GetDf();
    // CPU사용율을 얻기 위한 메서드
    cpu_usage GetCpuIdle();
    // 메모리 정보를 얻기 위한 메서드
    mem_data GetMem();
};

#endif
			

#include <jsms.h>
#include <vector>
#include <algorithm>
#include <unistd.h>
#include <stdio.h>
#include <set>
#include <iostream>
#include <sys/vfs.h>


// /etc/mtab와 /proc/mounts의 파일내용을 이용해서 
// 마운트된 디스크의 정보를 얻어온다. 
vector<df> JSms::GetDf()
{
    FILE *fp = NULL;
    struct statfs lstatfs;
    unsigned int i = 0;

    set<df, ltstr> smtab, smount;
    vector<df> vmtab;

    char line[DF_LINE_LEN];

    df ldf_data;

    // 먼저 /etc/mtab을 열어서 각 장치와 
    // 장치에 마운트된 파일의 이름을 얻어온다. 
    // 얻어온 데이터는 smtab set컨테이너에 저장한다. 
    // smtab에 저장된 데이터는 나중에 /proc/mounts 데이터와 
    // 비교하게 된다. 
    // 왜냐하면 마운트 파일에 대한 디바이스 이름이 잘못 지정되어 
    // 있을 수 있음으로 이경우 /proc/mounts의 내용을 참조해야 하기 
    // 때문이다. 
    fp = fopen("/etc/mtab", "r");
    if (fp == NULL)
    {
        cout << "Open Error mtab" << endl;
        exit(0);
    }

    while(fgets(line, DF_LINE_LEN, fp) != NULL)
    {
        if ((strstr(line, "/dev/") - line) == 0)
        {
            sscanf(line, "%s %s", ldf_data.device, ldf_data.mount);
            smtab.insert(ldf_data);
        }
    }
    fclose(fp);
    fp = NULL;

    // /proc/mounts로 부터 디바이스와 마운트파일 정보를 
    // 얻어온다.  
    fp = fopen("/proc/mounts", "r");
    if (fp == NULL)
    {
        cout << "Open Error mounts" << endl;
        exit(0);
    }
    while(fgets(line, DF_LINE_LEN, fp) != NULL)
    {
        if ((strstr(line, "/dev/") - line) == 0)
        {
            sscanf(line, "%s %s", ldf_data.device, ldf_data.mount);
            smount.insert(ldf_data);
        }
    }
    fclose(fp);
    fp = NULL; 

    // /proc/mount와 /etc/mtab의 내용을 intersection(교집합)연산을 시킨다. 
    // 연산에 사용할 비교함수는 jsms.h에 정의 되어있는 ltstr이다.  
    // 교집합에 사용될 비교 데이터는 마운트 디렉토리 이름이다. 
    // 이렇게 할경우 비록 /etc/mtab에 있는 장치이름이 잘못되었다고 하더라도 
    // /proc/mount의 제대로된 장치이름으로 덮어 쓸 수 있다.  
    // 이 데이터는 vmtab에 저장된다. 
    set_intersection( smtab.begin(), smtab.end(),
               smount.begin(), smount.end(),
               back_inserter(vmtab), ltstr());
    
    // 마운트된 파일시스템에 대한 디스크 사용율을 구한다. 
    {
        for (i = 0; i < vmtab.size(); i++)
        { 
            statfs(vmtab[i].mount, &lstatfs);
            vmtab[i].blocks = lstatfs.f_blocks*(lstatfs.f_bsize/1024);
            vmtab[i].avail  = lstatfs.f_bavail*(lstatfs.f_bsize/1024);
            vmtab[i].used   = vmtab[i].blocks - vmtab[i].avail;
        }
    }
    return vmtab;
}

// CPU사용율을 체크한다. 
// CPU사용율을 위해서는 현재의 jiffies값을 구하고 
// 과거의 jiffies의 값과 비교해서 얼마만큼 증가 했는지를 
// 판단해서 백분율로 나타내게 된다.
// 그러므로 이 메서드는 두번 호출해야 한다. 
// 처음 호출로 알아낸 jiffies값은 별도의 변수에 저장되고 
// sleep를 호출한 후 잠시후 다시 이 메서드를 호출해야 현재의 
// jiffies값과 과거의 jiffies를 이용한 계산이 가능해 진다. 
cpu_usage JSms::GetCpuIdle()
{
    FILE *fp = NULL;
    char line[80];
    cpu_usage lcpu_usage;
    char cpuid[32];
    int nulldata;
    int totaldiff;
    int diff[3];
    int cpu_num = 0;

    memset((void *)&lcpu_usage, 0x00, sizeof(cpu_usage));

    // /proc/stat파일을 읽어서 jiffies값을 계산한다. 
    fp = fopen("/proc/stat", "r");
    if(fp == NULL)
    {
        cout << "Cannot open stat" << endl;
        return lcpu_usage;
    }
    while(1)
    {
        fgets(line,80, fp);
        if (strstr(line, "cpu") == NULL)
        {
            fclose(fp);
            // cpu 갯수를 세팅하고 리턴한다. 
            lcpu_usage.countcpu = cpu_num -1;
            return lcpu_usage;
        }
        else
        {
            // /proc/stat에서 최초에 읽어 들이는 데이터는 
            // 전체 CPU에 대한 통계 데이터다. 
            // 그러므로 개별 CPU에 대한 데이터를 얻기 위해서는 처음 라인은 
            // 무시하고 넘어가야 한다. 
            if (cpu_num > 0)
            {
                // sscanf를 이용해서 jiffies값을 얻어온다. 
                // 그리고 과거의 jiffies값과의 연산을 통해서 
                // 각각의 jiffies가 얼마만큼 변했는지를 확인하고 
                // 이 값을 백분율로 나타낸다. 
                sscanf(line, "%s %d %d %d %d",
                               cpuid,
                               &mcurrent_usage[cpu_num-1][0],
                               &nulldata,
                               &mcurrent_usage[cpu_num-1][1],
                               &mcurrent_usage[cpu_num-1][2]);
                diff[0] = mcurrent_usage[cpu_num-1][0] - mold_usage[cpu_num-1][0];
                diff[1] = mcurrent_usage[cpu_num-1][1] - mold_usage[cpu_num-1][1];
                diff[2] = mcurrent_usage[cpu_num-1][2] - mold_usage[cpu_num-1][2];

                totaldiff = diff[0] + diff[1] + diff[2];
                lcpu_usage.cpuusage[cpu_num-1] = (diff[2]*100)/totaldiff;

                memcpy((void *)&mold_usage,
                                (void *)&mcurrent_usage,
                                sizeof(mcurrent_usage));
            }
            cpu_num ++;
        }
    }
    if(fp != NULL)
        fclose(fp);
}

// 메모리 정보를 얻어온다.
mem_data JSms::GetMem()
{
    FILE *fp = NULL;
    int index = 0;
    char line[128];
    mem_data lmem_data;
    int nulldata;
    char null[12];

    fp = fopen("/proc/meminfo", "r");
    if (fp == NULL)
    {
        cout << "Meminfo open error" << endl;
        exit(0);
    }
    
    while(1)
    {
        fgets(line, 128, fp);
        if(index == 0)
        {
            index ++;
            continue;
        }
        else if(index == 1)
        {
            sscanf(line, "%s %lu %d %lu", null, &lmem_data.real, &nulldata, &lmem_data.free
);  
        }
        else if(index == 2)
        {
            sscanf(line, "%s %lu %lu %lu", null, &nulldata, &lmem_data.swap_use,
                                        &lmem_data.swap_free);
        }
        else
        {
            fclose(fp);
            return lmem_data;
        }
        index ++;
    }
}
			

#include <jsms.h>
#include <unistd.h>

void help()
{
    printf("Usage : jsms -[mcf] \n"
           "-m    : mem info\n"
           "-c    : cpu usage\n"
           "-h    : help message\n"
           "-f    : disk info\n");
    exit(0);
}

int main(int argc, char **argv )
{
    class JSms lSms;
    vector<df> ldf;
    mem_data lmem_data;
    int opt;


    while((opt = getopt(argc, argv, "mcfh")) != -1)
    {
        // 메모리 정보를 요청했을때
        switch (opt)
        {
            case 'm':
            {
                ulong swap_real;
                lmem_data = lSms.GetMem();
                printf("REAL : %15lu %15lu %lu\n", lmem_data.real,
                    lmem_data.free,
                    ((lmem_data.real - lmem_data.free)*100)/lmem_data.real);
                swap_real = lmem_data.swap_use + lmem_data.swap_free;
                printf("Swap : %15lu %15lu %lu\n", swap_real,lmem_data.swap_free,
                        (swap_real - lmem_data.swap_free)*100/swap_real);
                break;
            }
            // CPU사용율을 요청했을때
            // sleep()을 이용해서 시간차를 두고 GetCpuIdle를 두번 호출했음에 
            // 유의 한다.  
            case 'c':
            {
                cpu_usage lcpu_usage;
                lcpu_usage = lSms.GetCpuIdle();
                sleep(1);
                lcpu_usage = lSms.GetCpuIdle();
                for (int i = 0; i < lcpu_usage.countcpu; i++)
                {
                    printf("[%d] : %d\n", i+1, lcpu_usage.cpuusage[i]);
                }
                break;
            }
            // 디스크 사용량 체크 
            case 'f':
            {
                ldf = lSms.GetDf();
                for (int i = 0; i < ldf.size(); i++)
                {
                    printf("%10s %-15s %12d %12d\n", ldf[i].device,
                                         ldf[i].mount,
                                         ldf[i].blocks,
                                         ldf[i].used);
                }
                break;
            }
            // 도움말
            case 'h':
            {
                help();
                break;
            }
            default :
            {
                help();
                break;
            }
        }
    }
}