You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
924 lines
22 KiB
924 lines
22 KiB
#include <stdio.h> //标准I/O库
|
|
#include <stdlib.h> //实用程序库函数
|
|
#include <string.h> //字符串操作
|
|
#include <signal.h> // 信号
|
|
#include <curses.h>
|
|
#include <limits.h> //实现常量
|
|
#include <termcap.h>
|
|
#include <termios.h>
|
|
#include <time.h> //时间和日期
|
|
#include <errno.h> //出错码
|
|
#include <assert.h> //验证程序断言
|
|
|
|
#include <dirent.h> //目录项
|
|
#include <fcntl.h> //文件控制
|
|
#include <pwd.h> //口令文件
|
|
#include <unistd.h> //符号常量
|
|
|
|
#include <minix/com.h>
|
|
#include <minix/config.h>
|
|
#include <minix/type.h>
|
|
#include <minix/endpoint.h>
|
|
#include <minix/const.h>
|
|
#include <minix/u64.h>
|
|
#include <paths.h>
|
|
#include <minix/procfs.h>
|
|
|
|
#include <sys/stat.h> //文件状态
|
|
#include <sys/types.h> //基本系统数据类型
|
|
#include <sys/wait.h> //进程控制
|
|
#include <sys/times.h> //进程时间
|
|
#include <sys/time.h>
|
|
#include <sys/select.h> //select函数
|
|
|
|
//一般的命令0
|
|
//输出重定向1
|
|
//输入重定向2
|
|
//命令中有管道3
|
|
//#define SELF ((endpoint_t) 0x8ace) /* used to indicate 'own process' */
|
|
//#define _MAX_MAGIC_PROC (SELF) /* used by <minix/endpoint.h> */
|
|
//#define MAX_NR_TASKS 1023
|
|
//#define _ENDPOINT_GENERATION_SIZE (MAX_NR_TASKS+_MAX_MAGIC_PROC+1)
|
|
//#define _ENDPOINT_P(e)
|
|
//((((e)+1023) % (1023+((endpoint_t) 0x8ace)+1)) - 1023)
|
|
//#define SLOT_NR(e) (_ENDPOINT_P(e) + nr_tasks)
|
|
|
|
#define _PATH_PROC "/proc/"
|
|
#define PSINFO_VERSION 0
|
|
#define TYPE_TASK 'T'
|
|
#define TYPE_SYSTEM 'S'
|
|
#define TYPE_USER 'U'
|
|
#define STATE_RUN 'R'
|
|
#define TIMECYCLEKEY 't'
|
|
#define ORDERKEY 'o'
|
|
|
|
#define USED 0x1
|
|
#define IS_TASK 0x2
|
|
#define IS_SYSTEM 0x4
|
|
#define BLOCKED 0x8
|
|
|
|
#define ORDER_CPU 0
|
|
#define ORDER_MEMORY 1
|
|
#define ORDER_HIGHEST ORDER_MEMORY
|
|
|
|
#define TC_BUFFER 1024 /* Size of termcap(3) buffer */
|
|
#define TC_STRINGS 200 /* Enough room for cm,cl,so,se */
|
|
|
|
/* name of cpu cycle types, in the order they appear in /psinfo. */
|
|
const char *cputimenames[] = {"user", "ipc", "kernelcall"};
|
|
#define CPUTIMENAMES (sizeof(cputimenames) / sizeof(cputimenames[0]))
|
|
|
|
#define CPUTIME(m, i) (m & (1L << (i)))
|
|
|
|
struct proc
|
|
{
|
|
int p_flags; //
|
|
endpoint_t p_endpoint; //端点
|
|
pid_t p_pid; //进程号
|
|
u64_t p_cpucycles[CPUTIMENAMES]; //cpu周期
|
|
int p_priority; //动态优先级
|
|
endpoint_t p_blocked; //阻塞状态
|
|
time_t p_user_time; //用户时间
|
|
vir_bytes p_memory; //内存
|
|
uid_t p_effuid; //有效用户ID
|
|
int p_nice; //静态优先级
|
|
char p_name[PROC_NAME_LEN + 1]; //名字
|
|
};
|
|
|
|
struct proc *proc = NULL, *prev_proc = NULL;
|
|
|
|
struct tp
|
|
{
|
|
struct proc *p;
|
|
u64_t ticks;
|
|
};
|
|
|
|
void getOrder(char *); //得到输入的命令
|
|
void anaOrder(char *, int *, char (*)[256]); //对输入的命令进行解析
|
|
void exeCommand(int, char (*)[256]); //执行命令
|
|
int checkCommand(char *command); //查找命令中的可执行程序
|
|
void getkinfo(); //读取/proc/kinfo得到总的进程和任务数nr_total
|
|
int print_memory(); //输出内存信息
|
|
void get_procs(); //记录当前进程，赋值给prev_proc
|
|
void parse_dir(); //获取到/proc/下的所有进程pid
|
|
void parse_file(pid_t pid); //获取每一个进程信息
|
|
u64_t cputicks(struct proc *p1, struct proc *p2, int timemode); //计算每个进程的滴答
|
|
void print_procs(struct proc *proc1, struct proc *proc2, int cputimemode); //输出CPU使用时间
|
|
|
|
char *message; //用于myshell提示信息的输出
|
|
int whilecnt = 0;
|
|
char msg[40][256];
|
|
unsigned int nr_procs, nr_tasks; //进程数和任务数
|
|
int nr_total; //进程和任务总数
|
|
int order = ORDER_CPU;
|
|
int blockedverbose = 0;
|
|
char *Tclr_all;
|
|
int slot = 1;
|
|
|
|
/*static inline u64_t make64(unsigned long lo, unsigned long hi)
|
|
{
|
|
return ((u64_t)hi << 32) | (u64_t)lo;
|
|
}
|
|
*/
|
|
|
|
/*
|
|
函数名: memset
|
|
功 能: 设置s中的所有字节为ch, s数组的大小由n给定
|
|
用 法: void *memset(void *s, char ch, unsigned n);
|
|
程序例:
|
|
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <mem.h>
|
|
|
|
int main(void)
|
|
{
|
|
char buffer[] = "Hello world\n";
|
|
|
|
printf("Buffer before memset: %s\n", buffer);
|
|
memset(buffer, '*', strlen(buffer) - 1);
|
|
printf("Buffer after memset: %s\n", buffer);
|
|
return 0;
|
|
}
|
|
*/
|
|
/*
|
|
函数名: getcwd
|
|
功 能: 取当前工作目录
|
|
用 法: char *getcwd(char *buf, int n);
|
|
程序例:
|
|
#include <stdio.h>
|
|
#include <dir.h>
|
|
int main(void)
|
|
{
|
|
char buffer[MAXPATH];
|
|
|
|
getcwd(buffer, MAXPATH);
|
|
printf("The current directory is: %s\n", buffer);
|
|
return 0;
|
|
}
|
|
*/
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int i;
|
|
int wordcount = 0;
|
|
char wordmatrix[100][256];
|
|
char **arg = NULL;
|
|
char *buf = NULL; //用户输入
|
|
|
|
if ((buf = (char *)malloc(256)) == NULL)
|
|
{
|
|
perror("malloc failed");
|
|
exit(-1);
|
|
}
|
|
|
|
while (1)
|
|
{
|
|
memset(buf, 0, 256); //将buf所指的空间清零
|
|
message = (char *)malloc(100);
|
|
getcwd(message, 100);
|
|
printf("myshell:%s# ", message);
|
|
free(message);
|
|
getOrder(buf);
|
|
strcpy(msg[whilecnt], buf);
|
|
whilecnt++;
|
|
if (strcmp(buf, "exit\n") == 0)
|
|
{
|
|
break;
|
|
}
|
|
for (i = 0; i < 100; i++)
|
|
{
|
|
wordmatrix[i][0] = '\0';
|
|
}
|
|
wordcount = 0;
|
|
anaOrder(buf, &wordcount, wordmatrix);
|
|
exeCommand(wordcount, wordmatrix);
|
|
}
|
|
|
|
if (buf != NULL)
|
|
{
|
|
free(buf);
|
|
buf = NULL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//获取用户输入
|
|
void getOrder(char *buf)
|
|
{
|
|
int cnt = 0;
|
|
|
|
int c = getchar();
|
|
while (cnt < 256 && c != '\n')
|
|
{
|
|
buf[cnt++] = c;
|
|
c = getchar();
|
|
}
|
|
buf[cnt++] = '\n';
|
|
buf[cnt] = '\0';
|
|
if (cnt == 256)
|
|
{
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
//解析buf中的命令，将结果存入wordmatrix中，命令以回车符号\n结束
|
|
void anaOrder(char *buf, int *wordcount, char (*wordmatrix)[256])
|
|
{
|
|
char *p = buf;
|
|
char *q = buf;
|
|
int number = 0;
|
|
int i;
|
|
while (1)
|
|
{
|
|
if (p[0] == '\n')
|
|
{
|
|
break;
|
|
}
|
|
if (p[0] == ' ')
|
|
{
|
|
p++;
|
|
}
|
|
else
|
|
{
|
|
q = p;
|
|
number = 0;
|
|
while ((q[0] != ' ') && (q[0] != '\n'))
|
|
{
|
|
if (q[0] == 92)
|
|
{
|
|
q[0] = ' ';
|
|
q[1] = q[2];
|
|
for (i = 2;; i++)
|
|
{
|
|
q[i] = q[i + 1];
|
|
if ((q[i] == ' ') || (q[i] == '\n'))
|
|
break;
|
|
}
|
|
}
|
|
number++;
|
|
q++;
|
|
}
|
|
strncpy(wordmatrix[*wordcount], p, number + 1);
|
|
wordmatrix[*wordcount][number] = '\0';
|
|
*wordcount = *wordcount + 1;
|
|
p = q;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
函数名: dup2
|
|
功 能: 复制文件句柄
|
|
用 法: int dup2(int oldhandle, int newhandle);
|
|
程序例:
|
|
|
|
#include <sys\stat.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <io.h>
|
|
|
|
int main(void)
|
|
{
|
|
#define STDOUT 1
|
|
|
|
int nul, oldstdout;
|
|
char msg[] = "This is a test";
|
|
|
|
//create a file
|
|
nul = open("DUMMY.FIL", O_CREAT | O_RDWR,
|
|
S_IREAD | S_IWRITE);
|
|
|
|
//create a duplicate handle for standard output
|
|
oldstdout = dup(STDOUT);
|
|
redirect standard output to DUMMY.FIL
|
|
by duplicating the file handle onto the
|
|
file handle for standard output.
|
|
dup2(nul, STDOUT);
|
|
|
|
close the handle for DUMMY.FIL
|
|
close(nul);
|
|
|
|
will be redirected into DUMMY.FIL
|
|
write(STDOUT, msg, strlen(msg));
|
|
|
|
restore original standard output handle
|
|
dup2(oldstdout, STDOUT);
|
|
|
|
//close duplicate handle for STDOUT
|
|
close(oldstdout);
|
|
|
|
return 0;
|
|
}
|
|
*/
|
|
|
|
void exeCommand(int wordcount, char (*wordmatrix)[256])
|
|
{
|
|
pid_t pid;
|
|
char *file;
|
|
int correct = 1;
|
|
int way = 0;
|
|
int status;
|
|
int i;
|
|
int fd;
|
|
char *word[wordcount + 1];
|
|
char *wordnext[wordcount + 1];
|
|
|
|
//将命令取出
|
|
for (i = 0; i < wordcount; i++)
|
|
{
|
|
word[i] = (char *)wordmatrix[i];
|
|
}
|
|
word[wordcount] = NULL;
|
|
|
|
//查看命令行是否有后台运行符
|
|
for (i = 0; i < wordcount; i++)
|
|
{
|
|
if (strncmp(word[i], "&", 1) == 0)
|
|
{
|
|
way = 4;
|
|
word[wordcount - 1] = NULL;
|
|
}
|
|
}
|
|
|
|
for (i = 0; word[i] != NULL; i++)
|
|
{
|
|
if (strcmp(word[i], ">") == 0)
|
|
{
|
|
way = 1;
|
|
if (word[i + 1] == NULL)
|
|
{
|
|
correct = 0;
|
|
}
|
|
}
|
|
if (strcmp(word[i], "<") == 0)
|
|
{
|
|
way = 2;
|
|
if (i == 0)
|
|
{
|
|
correct = 0;
|
|
}
|
|
}
|
|
if (strcmp(word[i], "|") == 0)
|
|
{
|
|
way = 3;
|
|
if (word[i + 1] == NULL)
|
|
{
|
|
correct = 0;
|
|
}
|
|
if (i == 0)
|
|
{
|
|
correct = 0;
|
|
}
|
|
}
|
|
}
|
|
//correct=0,说明命令格式不对
|
|
if (correct == 0)
|
|
{
|
|
printf("wrong format\n");
|
|
return;
|
|
}
|
|
|
|
if (way == 1)
|
|
{
|
|
//输出重定向
|
|
for (i = 0; word[i] != NULL; i++)
|
|
{
|
|
if (strcmp(word[i], ">") == 0)
|
|
{
|
|
file = word[i + 1];
|
|
word[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (way == 2)
|
|
{
|
|
//输入重定向
|
|
for (i = 0; word[i] != NULL; i++)
|
|
{
|
|
if (strcmp(word[i], "<") == 0)
|
|
{
|
|
file = word[i + 1];
|
|
word[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (way == 3)
|
|
{
|
|
//把管道符后面的部分存入wordnext中，管道后面的部分是一个可执行的shell命令
|
|
for (i = 0; word[i] != NULL; i++)
|
|
{
|
|
if (strcmp(word[i], "|") == 0)
|
|
{
|
|
word[i] = NULL;
|
|
int j;
|
|
for (j = i + 1; word[j] != NULL; j++)
|
|
{
|
|
wordnext[j - i - 1] = word[j];
|
|
}
|
|
wordnext[j - i - 1] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (strcmp(word[0], "cd") == 0)
|
|
{
|
|
if (word[1] == NULL)
|
|
{
|
|
return;
|
|
}
|
|
if (chdir(word[1]) == -1)
|
|
{
|
|
perror("cd");
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ((pid = fork()) < 0)
|
|
{ //创建子进程
|
|
printf("fork error\n");
|
|
return;
|
|
}
|
|
|
|
if (strcmp(word[0], "history") == 0)
|
|
{ //实现history n
|
|
if (pid == 0)
|
|
{
|
|
char cnum = word[1][0];
|
|
int num = cnum - 48;
|
|
for (int i = whilecnt - 1; i > whilecnt - num - 1; i--)
|
|
{
|
|
printf("command %d:", i);
|
|
printf("%s", msg[i]);
|
|
}
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
if (strcmp(word[0], "mytop") == 0)
|
|
{
|
|
if (pid == 0)
|
|
{
|
|
int cputimemode = 1;
|
|
getkinfo();
|
|
print_memory();
|
|
get_procs();
|
|
if (prev_proc == NULL)
|
|
get_procs();
|
|
print_procs(prev_proc, proc, cputimemode);
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
switch (way)
|
|
{
|
|
case 0:
|
|
//pid为0说明是子进程，在子进程中执行输入的命令
|
|
//输入的命令中不含> < | &
|
|
if (pid == 0)
|
|
{
|
|
if (!(checkCommand(word[0])))
|
|
{
|
|
printf("%s : command not found\n", word[0]);
|
|
exit(0);
|
|
}
|
|
execvp(word[0], word);
|
|
exit(0);
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
//输入的命令中含有输出重定向符
|
|
if (pid == 0)
|
|
{
|
|
if (!(checkCommand(word[0])))
|
|
{
|
|
printf("%s : command not found\n", word[0]);
|
|
exit(0);
|
|
}
|
|
fd = open(file, O_RDWR | O_CREAT | O_TRUNC, 0644);
|
|
dup2(fd, 1);
|
|
execvp(word[0], word);
|
|
exit(0);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
//输入的命令中含有输入重定向<
|
|
if (pid == 0)
|
|
{
|
|
if (!(checkCommand(word[0])))
|
|
{
|
|
printf("%s : command not found\n", word[0]);
|
|
exit(0);
|
|
}
|
|
fd = open(file, O_RDONLY);
|
|
dup2(fd, 0);
|
|
execvp(word[0], word);
|
|
exit(0);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
//输入的命令中含有管道符|
|
|
if (pid == 0)
|
|
{
|
|
int pid2;
|
|
int status2;
|
|
int fd[2];
|
|
|
|
if (pipe(fd) < 0)
|
|
{
|
|
printf("pipe error\n");
|
|
exit(0);
|
|
}
|
|
|
|
if ((pid2 = fork()) < 0)
|
|
{
|
|
printf("fork2 error\n");
|
|
return;
|
|
}
|
|
else if (pid2 == 0)
|
|
{
|
|
if (!(checkCommand(word[0])))
|
|
{
|
|
printf("%s : command not found\n", word[0]);
|
|
exit(0);
|
|
}
|
|
dup2(fd[1], 1);
|
|
execvp(word[0], word);
|
|
exit(0);
|
|
}
|
|
if (waitpid(pid2, &status2, 0) == -1)
|
|
{
|
|
printf("wait for child process error\n");
|
|
}
|
|
if (!(checkCommand(wordnext[0])))
|
|
{
|
|
printf("%s : command not found\n", wordnext[0]);
|
|
exit(0);
|
|
}
|
|
dup2(fd[0], 0);
|
|
execvp(wordnext[0], wordnext);
|
|
exit(0);
|
|
}
|
|
break;
|
|
case 4: //若命令中有&，表示后台执行，父进程直接返回，不等待子进程结束
|
|
signal(SIGCHLD, SIG_IGN);
|
|
if (pid == 0)
|
|
{
|
|
//int pidbg;
|
|
//pidbg=fork();
|
|
//if(pidbg==0){
|
|
printf("[process id: %d]\n", pid);
|
|
int a = open("/dev/null", O_RDONLY);
|
|
dup2(a, 0);
|
|
dup2(a, 1);
|
|
if (!(checkCommand(word[0])))
|
|
{
|
|
printf("%s : command not found\n", word[0]);
|
|
exit(0);
|
|
}
|
|
execvp(word[0], word);
|
|
exit(0);
|
|
//}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
//父进程等待子进程结束
|
|
if (waitpid(pid, &status, 0) == -1)
|
|
{
|
|
printf("wait for child process error\n");
|
|
}
|
|
}
|
|
|
|
//查找命令中的可执行程序
|
|
int checkCommand(char *command)
|
|
{
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
char *path[] = {"./", "/bin", "/usr/bin", NULL};
|
|
|
|
if (strncmp(command, "./", 2) == 0)
|
|
{
|
|
command = command + 2;
|
|
}
|
|
|
|
//分别在当前目录，/bin和/usr/bin目录查找要执行的程序
|
|
int i = 0;
|
|
while (path[i] != NULL)
|
|
{
|
|
if ((dp = opendir(path[i])) == NULL)
|
|
{
|
|
printf("can not open /bin \n");
|
|
}
|
|
while ((dirp = readdir(dp)) != NULL)
|
|
{
|
|
if (strcmp(dirp->d_name, command) == 0)
|
|
{
|
|
closedir(dp);
|
|
return 1;
|
|
}
|
|
}
|
|
closedir(dp);
|
|
i++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void getkinfo()
|
|
{
|
|
FILE *fp;
|
|
|
|
if ((fp = fopen("/proc/kinfo", "r")) == NULL)
|
|
{
|
|
fprintf(stderr, "opening " _PATH_PROC "kinfo failed\n");
|
|
exit(1);
|
|
}
|
|
|
|
if (fscanf(fp, "%u %u", &nr_procs, &nr_tasks) != 2)
|
|
{
|
|
fprintf(stderr, "reading from " _PATH_PROC "kinfo failed\n");
|
|
exit(1);
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
nr_total = (int)(nr_procs + nr_tasks);
|
|
}
|
|
|
|
int print_memory()
|
|
{
|
|
FILE *fp;
|
|
unsigned int pagesize;
|
|
unsigned long total, free, largest, cached;
|
|
|
|
if ((fp = fopen("/proc/meminfo", "r")) == NULL)
|
|
return 0;
|
|
|
|
if (fscanf(fp, "%u %lu %lu %lu %lu", &pagesize, &total, &free,
|
|
&largest, &cached) != 5)
|
|
{
|
|
fclose(fp);
|
|
return 0;
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
printf("main memory: %ldK total, %ldK free, %ldK contig free, "
|
|
"%ldK cached\n",
|
|
(pagesize * total) / 1024, (pagesize * free) / 1024,
|
|
(pagesize * largest) / 1024, (pagesize * cached) / 1024);
|
|
|
|
return 1;
|
|
}
|
|
|
|
void get_procs()
|
|
{
|
|
struct proc *p;
|
|
int i;
|
|
|
|
p = prev_proc;
|
|
prev_proc = proc;
|
|
proc = p;
|
|
|
|
if (proc == NULL)
|
|
{
|
|
proc = malloc(nr_total * sizeof(proc[0]));
|
|
|
|
if (proc == NULL)
|
|
{
|
|
fprintf(stderr, "Out of memory!\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < nr_total; i++)
|
|
proc[i].p_flags = 0;
|
|
|
|
parse_dir();
|
|
}
|
|
|
|
void parse_dir()
|
|
{
|
|
DIR *p_dir;
|
|
struct dirent *p_ent;
|
|
pid_t pid;
|
|
char *end; //end是指向第一个不可转换的字符位置的指针
|
|
|
|
if ((p_dir = opendir("/proc")) == NULL)
|
|
{
|
|
perror("opendir on " _PATH_PROC);
|
|
exit(1);
|
|
}
|
|
|
|
for (p_ent = readdir(p_dir); p_ent != NULL; p_ent = readdir(p_dir))
|
|
{
|
|
pid = strtol(p_ent->d_name, &end, 10); //long strtol(char *str, char **endptr, int base)将串转换为长整数,base是基数，表示要转换的是几进制的数
|
|
|
|
if (!end[0] && pid != 0)
|
|
parse_file(pid);
|
|
}
|
|
|
|
closedir(p_dir);
|
|
}
|
|
|
|
void parse_file(pid_t pid)
|
|
{
|
|
char path[PATH_MAX], name[256], type, state;
|
|
int version, endpt, effuid; //版本，端点，有效用户ID
|
|
unsigned long cycles_hi, cycles_lo; //高周期，低周期
|
|
FILE *fp;
|
|
struct proc *p;
|
|
//int slot; //插槽?
|
|
int i;
|
|
//printf("parse_file\n");
|
|
|
|
sprintf(path, "/proc/%d/psinfo", pid);
|
|
|
|
if ((fp = fopen(path, "r")) == NULL)
|
|
return;
|
|
|
|
if (fscanf(fp, "%d", &version) != 1)
|
|
{
|
|
fclose(fp);
|
|
return;
|
|
}
|
|
|
|
if (version != PSINFO_VERSION)
|
|
{ //0
|
|
fputs("procfs version mismatch!\n", stderr);
|
|
exit(1);
|
|
}
|
|
|
|
if (fscanf(fp, " %c %d", &type, &endpt) != 2)
|
|
{
|
|
fclose(fp);
|
|
return;
|
|
}
|
|
|
|
slot++;
|
|
//slot = SLOT_NR(endpt);
|
|
|
|
if (slot < 0 || slot >= nr_total)
|
|
{
|
|
fprintf(stderr, "top: unreasonable endpoint number %d\n", endpt);
|
|
fclose(fp);
|
|
return;
|
|
}
|
|
|
|
p = &proc[slot];
|
|
|
|
if (type == TYPE_TASK)
|
|
p->p_flags |= IS_TASK;
|
|
else if (type == TYPE_SYSTEM)
|
|
p->p_flags |= IS_SYSTEM;
|
|
|
|
p->p_endpoint = endpt;
|
|
p->p_pid = pid;
|
|
|
|
if (fscanf(fp, " %255s %c %d %d %lu %*u %lu %lu",
|
|
name, &state, &p->p_blocked, &p->p_priority,
|
|
&p->p_user_time, &cycles_hi, &cycles_lo) != 7)
|
|
{
|
|
|
|
fclose(fp);
|
|
return;
|
|
}
|
|
|
|
strncpy(p->p_name, name, sizeof(p->p_name) - 1);
|
|
p->p_name[sizeof(p->p_name) - 1] = 0;
|
|
|
|
if (state != STATE_RUN)
|
|
p->p_flags |= BLOCKED;
|
|
p->p_cpucycles[0] = make64(cycles_lo, cycles_hi);
|
|
p->p_memory = 0L;
|
|
|
|
if (!(p->p_flags & IS_TASK))
|
|
{
|
|
int j;
|
|
if ((j = fscanf(fp, " %lu %*u %*u %*c %*d %*u %u %*u %d %*c %*d %*u",
|
|
&p->p_memory, &effuid, &p->p_nice)) != 3)
|
|
{
|
|
|
|
fclose(fp);
|
|
return;
|
|
}
|
|
|
|
p->p_effuid = effuid;
|
|
}
|
|
else
|
|
p->p_effuid = 0;
|
|
|
|
for (i = 1; i < CPUTIMENAMES; i++)
|
|
{
|
|
if (fscanf(fp, " %lu %lu",
|
|
&cycles_hi, &cycles_lo) == 2)
|
|
{
|
|
p->p_cpucycles[i] = make64(cycles_lo, cycles_hi);
|
|
}
|
|
else
|
|
{
|
|
p->p_cpucycles[i] = 0;
|
|
}
|
|
}
|
|
|
|
if ((p->p_flags & IS_TASK))
|
|
{
|
|
if (fscanf(fp, " %lu", &p->p_memory) != 1)
|
|
{
|
|
p->p_memory = 0;
|
|
}
|
|
}
|
|
|
|
p->p_flags |= USED;
|
|
|
|
fclose(fp);
|
|
}
|
|
|
|
u64_t cputicks(struct proc *p1, struct proc *p2, int timemode)
|
|
{
|
|
int i;
|
|
u64_t t = 0;
|
|
for (i = 0; i < CPUTIMENAMES; i++)
|
|
{
|
|
if (!CPUTIME(timemode, i))
|
|
continue;
|
|
if (p1->p_endpoint == p2->p_endpoint)
|
|
{
|
|
t = t + p2->p_cpucycles[i] - p1->p_cpucycles[i];
|
|
}
|
|
else
|
|
{
|
|
t = t + p2->p_cpucycles[i];
|
|
}
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
void print_procs(struct proc *proc1, struct proc *proc2, int cputimemode)
|
|
{
|
|
int p, nprocs;
|
|
//u64_t idleticks = 0;
|
|
//u64_t kernelticks = 0;
|
|
u64_t systemticks = 0;
|
|
u64_t userticks = 0;
|
|
u64_t total_ticks = 0;
|
|
int blockedseen = 0;
|
|
static struct tp *tick_procs = NULL; //tp结构体的数组tick_procs,对所有的进程和任务(即上面读出来的nr_total)计算ticks
|
|
|
|
if (tick_procs == NULL)
|
|
{
|
|
tick_procs = malloc(nr_total * sizeof(tick_procs[0]));
|
|
|
|
if (tick_procs == NULL)
|
|
{
|
|
fprintf(stderr, "Out of memory!\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
for (p = nprocs = 0; p < nr_total; p++)
|
|
{
|
|
u64_t uticks;
|
|
if (!(proc2[p].p_flags & USED))
|
|
continue;
|
|
tick_procs[nprocs].p = proc2 + p;
|
|
tick_procs[nprocs].ticks = cputicks(&proc1[p], &proc2[p], cputimemode);
|
|
uticks = cputicks(&proc1[p], &proc2[p], 1);
|
|
total_ticks = total_ticks + uticks;
|
|
//printf("total_ticks:%llu\n",total_ticks);
|
|
/*if(p-NR_TASKS == IDLE) {
|
|
idleticks = uticks;
|
|
continue;
|
|
}
|
|
if(p-NR_TASKS == KERNEL) {
|
|
kernelticks = uticks;
|
|
}
|
|
*/
|
|
if (!(proc2[p].p_flags & IS_TASK))
|
|
{
|
|
if (proc2[p].p_flags & IS_SYSTEM)
|
|
systemticks = systemticks + tick_procs[nprocs].ticks;
|
|
else
|
|
userticks = userticks + tick_procs[nprocs].ticks;
|
|
}
|
|
|
|
nprocs++;
|
|
}
|
|
|
|
if (total_ticks == 0)
|
|
return;
|
|
|
|
printf("CPU states: %6.2f%% user, ", 100.0 * userticks / total_ticks);
|
|
printf("%6.2f%% system", 100.0 * systemticks / total_ticks);
|
|
printf("%6.2f%% in total\n", 100.0 * (systemticks + userticks) / total_ticks);
|
|
//printf("%6.2f%% kernel, ", 100.0 * kernelticks/ total_ticks);
|
|
//printf("%6.2f%% idle", 100.0 * idleticks / total_ticks);
|
|
}
|