리눅스 커널의 주된임무중 하나는 프로세스를 실행시키고 이들을 유지하는 일이며, 이를 위해서 커널데이타구조체를 내부적으로 사용하게 된다. 그런데 이런 프로세스정보는 커널에게만 필요한게 아니고 시스템 관리자혹은 프로그래머들에게도 절대적으로 필요한 정보이다.
그렇다면 필요한 정보를 얻어내기 위해서 어떻게 해야할까? 직접 커널에게 커널데이타구조체를 요청해서 그걸 일일이 분석해야 할까 ? 물론 그렇게도 할수 있겠지만, 이것은 매우 복잡한 작업이며, 또한 (커널모드에서 직접이루어지는 작업임으로)위험한작업이기도 하다. 그래서 리눅스시스템은 사용자레벨에서 프로세스의 상태를 간단하게 확인가능하도록 하기위해서 proc파일시스템을 제공한다.
우리는 복잡하게 커널로부터 여러가지 커널데이타구조체를 요청할필요 없이 proc파일시스템에서 제공하는 정보들을 읽어들이는 정도로 간단하게 프로세스 상태를 얻어올수 있다.
작은 정보: proc파일시스템은 대부분의 유닉스운영체제에서 채택되어지고 있지만, 데이타를 저장하는 범위와 포맷에 있어서 운영체제간 차이점을 보인다. 저장하는 범위의 경우 대부분의 유닉스운영체제는 단지 프로세스 정보만을 제공하는 반면, 리눅스는 프로세스 정보뿐만 아니라 네트웍정보, 파일시스템, 디바이스 정보, 메모리정보, CPU정보등 다양한 정보들을 제공한다.
특히 리눅스의 경우 몇몇정보들에 대해서는 단지 열람만 가능한 수준이 아닌 직접수정을 통해서 커널의 행동을 변경시켜줄수도 있다. 이것은 다른 유닉스에 비해서 매우 확장된 부분이라고 할수 있다.
예를 들어 ICMP요청에 대한 응답을 막고 싶다면 "echo 0 /proc/sys/net/ipv4/icmp_echo_ignore_all"하는 정도로 간단하게 커널의 행동을 변경시켜줄수 있다. 다른운영체제에서의 이러한 작업은 전용관리도구를 사용하든지 리붓팅을 시키든지 해야한다.
저장되는 포맷을 보자면 리눅스는 일반 ASCII문자로 이루어진 반면 다른 유닉스들은 구조체로 정보가 이루어져 있다. 리눅스의 경우 프로세스 정보가 일반문자로 이루어져 있어서 직관적으로 확인하기에 좋기는 하지만 프로그래밍을 할경우 이를 파싱해야되기 때문에 다른 유닉스들에 비해서 좀 불편한점이 되기도 한다.
리눅스의 경우 기능이 확장되긴 했지만 proc파일시스템의 가장큰 사용목적은 뭐니뭐니 해도 프로세스정보를 얻어오는 일이다.
기본적으로 proc파일시스템은 /proc디렉토리안에서 이루어지며, 프로세스정보는 /proc디렉토리밑에 각 프로세스의 PID를 이름으로하는 서브디렉토리 밑에 위치하게 된다. 예를들어 PID가 912인 프로세스라면, 912 프로세스의 정보는 /proc/912(이하 /proc/[PID])밑에 위치하게 된다.
/proc/[PID] 디렉토리밑에는 다시 몇개의 디렉토리와 몇개의 파일들로 이루어져 있다.
실질적으로 stat를 분석해서 프로세스데이타를 얻어오는 함수들을 포함한다. opendir(2)함수를 이용해서 /proc 디렉토리밑에 있는 파일들의 목록을 얻어오고, 만약 얻어온 파일이 디렉토리이면서 숫자로되어있을경우 프로세스정보 디렉토리라고 판단하고, 서브디렉토리에 있는 stat 파일을 읽어들인다.
읽어들인 stat정보는 " "를 기준으로 파싱해서 배열(vector)에 집어넣는다. 더불어 우리가 만들고자하는 qps프로그램은 해당프로세스의 유저이름도 가져와야 한다. /proc/[PID]/stat 파일은 프로세스소유자의 권한으로 만들어진다. 우리는 stat(2)계열함수를 사용하면 해당 파일의 UID를 얻어올수 있다는걸 알수있다. 또한 getpwuid(3)를 이용하면 해당 UID에 대한 유저이름도 얻어올수 있다.
이렇게 해서 하나의 프로세스에 대한정보가 만들어졌다. 그런데 우리는 프로세스의 목록을 가져와야 함으로 이들 정보는 다시 배열의 원소로 들어가야 할것이다. 이러한 자료구조(배열의 배열)를 위해서 필자는 (속편하게)vector를 사용했다.
다음은 실제 코드들이다. 위의 내용들은 코드를 통해서 이해하기 바란다. 그리어려운 코드들은 아님으로 주석만으로도 충분히 이해가능할것이다.
예제 : include/proc.h
#ifndef _PROC_H_
#define _PROC_H_
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <vector>
#include <dirent.h>
#include <string>
using namespace std;
// 프로세스 데이타 저장
typedef struct _process_info
{
char username[32]; // 유저이름
vector<string> process; // stat정보들이 들어간다
} process_info;
// 프로세스의 리스트를 유지하기 위한 자료구조
// 결국은 배열의 배열이다.
typedef vector<process_info> Plist;
class Proc
{
private:
int Processnum; // 현재 프로세스 갯수
Plist ProcList; // 프로세스정보 리스트
public:
// 생성자및 소멸자
Proc();
~Proc();
void MakeProcInfo(); // 프로세스 정보를 얻어온다.
vector<string> ProcParser(char *); // stat파일을 파싱한다
int ProcNum(); // 현재프로세스 갯수를 넘겨준다.
int IsDigit(char *); // 문자열이 숫자인지 확인한다.
Plist GetProcList(); // 프로세스정보 리스트를 되돌려준다.
};
#endif
예제 : proc.cc
#include "proc.h"
#include <iostream>
#include <pwd.h>
#include <sys/types.h>
#include <sys/stat.h>
Proc::Proc()
{
}
Proc::~Proc()
{
}
/*
* 프로세스 정보를 가져온다.
* 그러기 위해서 /proc/[PID]/stat파일을 읽어들이고 이를
* 필드별로 파싱한다. 파싱은 " "문자를 기준으로 한다.
* 또한 프로세스를 생성한 유저 이름도 얻어온다.
*/
void Proc::MakeProcInfo()
{
DIR *directory;
struct dirent *entry = NULL;
char proc_file[40];
vector<string> procinfo;
process_info lprocess_info;
struct stat lstat;
ProcList.clear();
// proc 디렉토리를 열어서 파일(디렉토리포함)의 리스트를
// 얻어온다.
if ((directory = opendir("/proc")) == NULL)
{
perror("opendir error :");
exit(0);
}
while((entry = readdir(directory)) != NULL)
{
if (strcmp(entry->d_name, ".") !=0 &&
strcmp(entry->d_name, "..") != 0)
{
sprintf(proc_file,"/proc/%s/stat", entry->d_name);
// stat 파일이 존재하는지 확인하고 확인하고
if (access(proc_file, F_OK) != 0)
{
continue;
}
// 디렉토리 이름이 숫자인지 확인한다.
// 디렉토리 이름이 숫자라면 이를 파싱한다.
// 또한 stat파일의 소유 UID를 이용해서 유저이름도 얻어온다.
if (IsDigit(entry->d_name))
{
struct passwd *upasswd;
stat(proc_file,&lstat);
lprocess_info.process = ProcParser(proc_file);
upasswd = getpwuid(lstat.st_uid);
strncpy(lprocess_info.username, upasswd->pw_name, 32);
if(atoi(lprocess_info.process[0].c_str()) == atoi(entry->d_name))
{
ProcList.push_back(lprocess_info);
}
}
else
{
}
}
}
}
/*
* MakeProcInfo를 통해만들어진 프로세스정보 리스트를 되돌려준다.
*/
Plist Proc::GetProcList()
{
return ProcList;
}
/*
* 프로세스의 갯수를 되돌려준다.
* 갯수는 프로세스자료구조(vector)의 원소의 크기가 된다.
*/
int Proc::ProcNum()
{
return ProcList.size();
}
/*
* stat 파일을 열어서 " "문자를 기준으로 파싱해서
* 배열(vector)에 집어넣는다.
*/
vector<string> Proc::ProcParser(char *proc_file)
{
FILE *fp;
char buf[512] = {0x00,};
char field[80];
int index = 0;
unsigned int i, j = 0;
vector<string> vproc;
fp = fopen(proc_file, "r");
if (fp == NULL)
{
perror("error : ");
exit(0);
}
memset(field, 0x00, 80);
fgets(buf, 511, fp);
for(i = 0; i < strlen(buf); i++)
{
if (buf[i] != ' ' && i != (strlen(buf) -1))
{
field[j++] = buf[i];
}
else
{
if (index == 1)
{
field[strlen(field)-1] = 0x00;
vproc.push_back(field+1);
}
else
vproc.push_back(field);
memset(field, 0x00, 80);
j = 0;
index++;
}
}
fclose(fp);
return vproc;
}
/*
* 파일이름이 숫자인지 확인한다.
*/
int Proc::IsDigit(char *str)
{
int i;
for (i = 0; i < strlen(str); i++)
{
if (isdigit(str[i])==0)
return 0;
}
return 1;
}
위에서 설명한 proc.cc를 통해서 stat를 분석한 프로세스데이타가 만들어졌음으로 이제 이것을 가지고 와서 화면에 적당히 뿌려줘야 할것이다. 다음은 이와 관련된 함수들이다. 프로세세의 CPU사용율을 가져오기 위한 getcputime()함수외에는 별특별한건 없을것이다.
include/qps.h
#ifndef _QPS_H_
#define _QPS_H_
#include "proc.h"
// 프로세스 목록을 적당히 가공해서 출력한다.
int viewProc();
// 각프로세스의 CPU 사용율을 얻어온다.
int getcputime(ulong utime, ulong stime, ulong starttime, int seconds);
// OS의 uptime(부팅후 지금까지의 가동시간)을 얻어온다.
int uptime();
#endif
qps.cc
// Local 헤더파일
#include "qps.h"
// 표준 C++ 헤더파일들
#include <iostream>
#include <vector>
#include <string>
// 표준 C 헤더파일
#include <stdio.h>
using namespace std;
/*
* 프로세스정보 리스트를 얻어와서 보기좋게 출력한다.
*/
int viewProc()
{
Proc *mproc;
unsigned i;
int pcpu;
int seconds = 0;
Plist ProcList;
mproc = new Proc;
mproc->MakeProcInfo();
// 프로세스정보 리스트를 얻어온다.
ProcList = mproc->GetProcList();
int total_cpu = 0;
// OS의 uptime을 얻어온다.
// 얻어온 정보는 프로세스의 CPU 사용율을 구하기 위한 기초정보로
// 사용된다.
seconds = uptime();
printf("%-10s %7s %7s %2s %16s %4s %9s\n", "USER", "PID", "PPID",
"ST", "NAME", "CPU", "VMEM");
printf("==============================================================\n");
for (i = 0; i < mproc->ProcNum(); i++)
{
// CPU사용율을 얻어온다.
pcpu = getcputime(atol(ProcList[i].process[13].c_str()),
atol(ProcList[i].process[14].c_str()),
atol(ProcList[i].process[21].c_str()), seconds);
// 보기좋게 출력한다.
printf("%-10s %7s %7s %2s %16s %2d.%d %9s\n", ProcList[i].username,
ProcList[i].process[0].c_str(),
ProcList[i].process[3].c_str(),
ProcList[i].process[2].c_str(),
ProcList[i].process[1].c_str(), pcpu/10, pcpu%10,
ProcList[i].process[22].c_str());
}
return 1;
}
/*
* 프로세스의 CPU사용율을 얻기 위해서 사용한다.
* utime : 유저모드에서 프로세스가 스케쥴링되면서 사용한 jiffies 수이다.
* 프로세스가 스케쥴링될때마다 증가되는 수치이다.
* stime : 커널모드에서 프로세스가 스케쥴링되면서 사용한 jiffies 수이다.
* starttime : 운영체제가 시작되고나서 몇 jiffies가 지난후
* 프로세스가 시작되었는지
*/
int getcputime(ulong utime, ulong stime, ulong starttime, int seconds)
{
unsigned long long total_time;
int pcpu=0;
// 유저 jiffies 와 커널 jiffies를 더한다.
total_time = utime + stime;
// 100은 HZ값이다. HZ이 작아질수록 context switching가 빨라진다.
// 이값은 /usr/include/asm/param.h에 선언되어 있다.
// 100. 대신에 (unsigned long long)HZ 정도로 코드를
// 작성하는게 좀더 안전할것이다. 여기에서는 직관적으로 설명하기
// 위해서 하드코딩했다.
seconds = seconds - (int)(starttime/100.);
if(seconds)
{
pcpu = (int)(total_time * 1000ULL/100.)/seconds;
}
return pcpu;
}
/*
* 운영체제가 부팅하고 나서 얼마의 시간이 지났는지
*/
int uptime()
{
FILE *fp;
char buf[36];
double stime;
double idletime;
if ((fp = fopen("/proc/uptime", "r")) == NULL)
{
perror("fopen error : ");
exit(0);
}
fgets(buf, 36, fp);
sscanf(buf, "%lf %lf", &stime, &idletime);
fclose(fp);
return (int)stime;
}
