diff --git a/fun.h b/fun.h
index 967fdf1..0552a93 100644
--- a/fun.h
+++ b/fun.h
@@ -5,11 +5,10 @@
 #include "fun_1.c"
 #include "fun_2.c"
 
+//void history(char *cmdline);
+//void print_his(char *argv);
 
-void history(char *cmdline);
-void print_his(char *argv);
-
-void eval(char *cmdline);
-int parseline(const char *cmdline, char **argv);
+//void eval(char *cmdline);
+//int parseline(const char *cmdline, char **argv);
 
 #endif // FUN_H_INCLUDED
diff --git a/fun_1.c b/fun_1.c
index 02ae6ad..8fe04f9 100644
--- a/fun_1.c
+++ b/fun_1.c
@@ -1,9 +1,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <wait.h>
 #include <signal.h>
+#include<fcntl.h>
 
+#include "mytop.c"
 //#include "fun.h"
 
 
@@ -26,6 +27,9 @@ void eval(char *cmdline)
         {
             if(isBg)
             {
+                int fd = open( "/dev/null", O_RDWR );
+                dup2( fd, 0 );
+                dup2( fd, 1 );
                 signal(SIGCHLD, SIG_IGN);
             }
             if(execvp(argv[0],argv)<0)
@@ -109,7 +113,7 @@ int builtin_cmd(char **argv)
     {
         return 1;
     }
-    if(Is_open(argv)==1)
+    if(Is_redirect(argv)==1)
     {
         return 1;
     }
@@ -119,7 +123,7 @@ int builtin_cmd(char **argv)
 	}
     if(!strcmp(argv[0],"history"))
     {
-        print_his(argv[1]);
+        print_history(argv[1]);
 		return 1;
 	}
     if(!strcmp(argv[0],"cd"))
@@ -137,15 +141,10 @@ int builtin_cmd(char **argv)
 		    return 1;
 	    }
 	}
-
     if(!strcmp(argv[0],"mytop"))
     {
+        mytop();
 		return 1;
 	}
-    if(!strcmp(argv[0],"bg")||!strcmp(argv[0],"fg"))
-    {
-		return 1;
-	}
-
     return 0;
 }
\ No newline at end of file
diff --git a/fun_2.c b/fun_2.c
index 52d0b77..2ffb034 100644
--- a/fun_2.c
+++ b/fun_2.c
@@ -11,7 +11,7 @@ void history(char *cmdline)
     num++;
 }
 
-void print_his(char *argv)
+void print_history(char *argv)
 {
 
     int i = num - atoi(argv);
@@ -96,7 +96,7 @@ void shell_pip(char **prog1, char **prog2)
     return 0;
 }
 
-int Is_open(char **argv)
+int Is_redirect(char **argv)
 {
     int i = 0;
     int Isopen = 0;
@@ -129,15 +129,16 @@ int Is_open(char **argv)
         i++;
         j++;
     }    
-    cmd_1[j] = NULL;      
-    shell_open(cmd_0, cmd_1);
+    cmd_1[j] = NULL;
+
+    shell_direct(cmd_0, cmd_1);
     return 1;
 }
 
-void shell_open(char **prog1, char **prog2)
+void shell_direct(char **prog1, char **prog2)
 {    
-                //根据解析命令参数，创建/打开一文件
     int fd;
+    if(prog1)
     if(fork() == 0)
     {   
         if( (fd=open(prog2[0],O_RDWR | O_CREAT | O_NOCTTY | O_NDELAY))<0 )
@@ -149,8 +150,77 @@ void shell_open(char **prog1, char **prog2)
         dup(fd);
         close(fd);
         execvp(prog1[0], prog1);
-        exit(1);
+        remove(prog2[0]);
+        exit(0);
+    }
+    wait(0);
+    if(fork() == 0)
+    {   
+        if( (fd=open(prog1[0],O_RDWR | O_NOCTTY | O_NDELAY))<0 )
+        {
+            exit(0);
+        }
+        close(0);
+        dup(fd);
+        close(fd);
+        execvp(prog2[0], prog2);
+        exit(0);
     }
     wait(0);
-}    
+}
+
+/*   
+void mytop()
+{
+    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;
+}
 
+
+//tp 结构体
+//包含了进程指针p和ticks，对应某个进程和滴答
+struct tp {
+    struct proc *p;
+    u64_t ticks;
+};
+//计算cputicks 用到当前进程和其他进程的，还涉及CPUTIME
+u64_t cputicks(struct proc *p1, struct proc *p2, int timemode)
+{
+    int i;
+    u64_t t = 0;
+    //计算每个进程proc的滴答，通过proc和当前进程prev_proc做比较，如果endpoint相等，则在循环中分别计算
+    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];
+        }
+    }
+//    for(i = 0; i < CPUTIMENAMES; i++) {
+//           if(!CPUTIME(timemode, i))
+//               continue;
+//           if(proc->p_endpoint == prev_proc->p_endpoint) {
+//               t = t + prev_proc->p_cpucycles[i] - proc->p_cpucycles[i];
+//           } else {
+//               t = t + prev_proc->p_cpucycles[i];
+//           }
+//       }
+    return t;
+}
+*/
\ No newline at end of file
diff --git a/main b/main
index e9cf204..267af95 100755
Binary files a/main and b/main differ
diff --git a/main.c b/main.c
index d717389..5fb6948 100644
--- a/main.c
+++ b/main.c
@@ -15,6 +15,5 @@ int main()
         eval(cmdline);
         history(cmdline);
     }
-    
     return 0;
 }
diff --git a/mytop.c b/mytop.c
new file mode 100644
index 0000000..fce6b4e
--- /dev/null
+++ b/mytop.c
@@ -0,0 +1,407 @@
+/*
+#define mytop_h
+#include <stdio.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <curses.h>
+//#include <timers.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <termcap.h>
+#include <termios.h>
+#include <time.h>
+#include <string.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <dirent.h>
+#include <assert.h>
+
+typedef int endpoint_t;
+typedef uint64_t u64_t;
+typedef long unsigned int vir_bytes;
+
+#define  USED        0x1
+#define  IS_TASK    0x2
+#define  IS_SYSTEM    0x4
+#define  BLOCKED    0x8
+#define TYPE_TASK    'T'
+#define TYPE_SYSTEM    'S'
+#define STATE_RUN    'R'
+
+#define MAX_NR_TASKS 1023
+#define SELF    ((endpoint_t) 0x8ace)
+#define _MAX_MAGIC_PROC (SELF)
+#define _ENDPOINT_GENERATION_SIZE (MAX_NR_TASKS+_MAX_MAGIC_PROC+1)
+#define _ENDPOINT_P(e) \
+((((e)+MAX_NR_TASKS) % _ENDPOINT_GENERATION_SIZE) - MAX_NR_TASKS)
+#define  SLOT_NR(e) (_ENDPOINT_P(e) + 5)
+#define _PATH_PROC "/proc"
+#define CPUTIME(m, i) (m & (1L << (i)))
+const char *cputimenames[] = { "user", "ipc", "kernelcall" };
+
+#define CPUTIMENAMES (sizeof(cputimenames)/sizeof(cputimenames[0]))
+unsigned int nr_procs, nr_tasks;
+
+int nr_total=0;
+//int slot_a=0;
+//int pronum=0;
+//int filenum=0;
+//proc 结构体
+struct proc {
+    int p_flags;
+    endpoint_t p_endpoint;
+    pid_t p_pid;
+    u64_t p_cpucycles[CPUTIMENAMES];
+    int p_priority;
+    endpoint_t p_blocked;
+    time_t p_user_time;
+    vir_bytes p_memory;
+    uid_t p_effuid;
+    int p_nice;
+    char p_name[16+1];
+};
+
+struct proc *proc = NULL, *prev_proc = NULL;
+//u64_t 64位 high和low32位 拼接成64位 high+low
+static inline u64_t make64(unsigned long lo, unsigned long hi)
+{
+    return ((u64_t)hi << 32) | (u64_t)lo;
+}
+//把每个pid/psinfo的信息读出来
+//判断读取信息是否可用
+void parse_file(pid_t pid)
+{
+    char path[PATH_MAX], name[256], type, state;
+    int version, endpt, effuid;
+    unsigned long cycles_hi, cycles_lo;
+    FILE *fp;
+    struct proc *p;
+    int slot;
+    int i;
+
+    sprintf(path, "/proc/%d/psinfo", pid);
+    //按照/proc/%d/psinfo打开path中的文件
+    if ((fp = fopen(path, "r")) == NULL)
+        return;
+    //version是否为1，如果不是该进程不需要记录
+    if (fscanf(fp, "%d", &version) != 1) {
+        fclose(fp);
+        return;
+    }
+    //versions错误处理
+    if (version != 0) {
+        fputs("procfs version mismatch!\n", stderr);
+        exit(1);
+    }
+    //读入类型和端点 判断是否读入的是两个
+    if (fscanf(fp, " %c %d", &type, &endpt) != 2) {
+        fclose(fp);
+        return;
+    }
+    //统计总file数
+    //filenum+=1;
+    //原来的slot超出了nr_total
+    slot = SLOT_NR(endpt);
+    slot++;
+    //slot=slot_a;
+    //slot_a+=1;//赋值需保证在数组中不会重复
+    
+    //判断endpoint的值是否合理 在0到nr_total的范围内
+    if(slot < 0 || slot >= nr_total) {
+        fprintf(stderr, "top: unreasonable endpoint number %d\n", endpt);
+        fclose(fp);
+        return;
+    }
+     //slot为该进程结构体在数组中的位置
+    p = &proc[slot];//把slot地址赋值给p
+    
+    if (type == TYPE_TASK)
+        //标示task进程
+        p->p_flags |= IS_TASK;
+    else if (type == TYPE_SYSTEM)
+        //标示system进程
+        p->p_flags |= IS_SYSTEM;
+    //将endpt和pid存入对应进程结构体
+    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);
+    //数组置0
+    p->p_name[sizeof(p->p_name)-1] = 0;
+
+    if (state != STATE_RUN)//如果不是run的进程
+        p->p_flags |= BLOCKED;//标志阻塞
+    //拼接成64位，放在p_cpucycles[]数组中
+    p->p_cpucycles[0] = make64(cycles_lo, cycles_hi);
+    p->p_memory = 0L;
+    //判断是否为有效用户ID
+    if (!(p->p_flags & IS_TASK)) {
+        int j;
+        //读如内存 有效用户ID 和静态优先级
+        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;
+//连续读CPUTIMENAMES次cycles_hi,cycle_lo
+    for(i = 1; i < CPUTIMENAMES; i++) {
+        if(fscanf(fp, " %lu %lu",
+            &cycles_hi, &cycles_lo) == 2) {
+            //拼接成64位，放在p_cpucycles[]数组中
+            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);
+}
+void parse_dir(void)
+{
+    DIR *p_dir;
+    struct dirent *p_ent;
+    pid_t pid;
+    char *end;
+    //打开/proc
+    if ((p_dir = opendir("/proc/")) == NULL) {
+        perror("opendir on /proc");
+        exit(1);
+    }
+    //readdir()返回参数p_dir 目录流的下个目录进入点。
+    p_ent=readdir(p_dir);
+   while(p_ent != NULL){
+//        if(strncpy(p_ent->d_name,"/proc",1)==0)
+//            continue;
+        //分析出里面所有pid
+       pid=strtol(p_ent->d_name,&end,10);
+       if(pid!=0 && !end[0]){
+            //printf("%l\n",pid);
+           //一个pid调用一次parse_file
+           parse_file(pid);
+      }
+       
+       p_ent=readdir(p_dir);
+   }
+
+    closedir(p_dir);
+}
+int print_memory(void)
+{
+    FILE *fp;
+    unsigned int pagesize;
+    unsigned long total, free, largest, cached;
+    //打开meminfo
+    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);
+    //打印memory信息
+    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;
+}
+//tp 结构体
+//包含了进程指针p和ticks，对应某个进程和滴答
+struct tp {
+    struct proc *p;
+    u64_t ticks;
+};
+//计算cputicks 用到当前进程和其他进程的，还涉及CPUTIME
+
+//滴答并不是简单的结构体中的滴答，因为在写文件的时候需要更新。需要通过当前进程来和该进程一起计算
+u64_t cputicks(struct proc *p1, struct proc *p2, int timemode)
+{
+    int i;
+    u64_t t = 0;
+    //计算每个进程proc的滴答，通过proc和当前进程prev_proc做比较，如果endpoint相等，则在循环中分别计算
+    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];
+        }
+    }
+//    for(i = 0; i < CPUTIMENAMES; i++) {
+//           if(!CPUTIME(timemode, i))
+//               continue;
+//           if(proc->p_endpoint == prev_proc->p_endpoint) {
+//               t = t + prev_proc->p_cpucycles[i] - proc->p_cpucycles[i];
+//           } else {
+//               t = t + prev_proc->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;
+    if (tick_procs == NULL) {
+        //给tick_procs分配内存
+        //创建tp结构体tick_procs
+        tick_procs = malloc(nr_total * sizeof(tick_procs[0]));
+        //tick procs错误处理
+        if (tick_procs == NULL) {
+            fprintf(stderr, "Out of memory!\n");
+            exit(1);
+        }
+    }
+
+    for(p = nprocs = 0; p < nr_total; p++) {
+        u64_t uticks;
+        //如果当前进程标志不是used就continue 看下一个进程。
+        if(!(proc2[p].p_flags & USED))
+            continue;
+        tick_procs[nprocs].p = proc2 + p;
+        tick_procs[nprocs].ticks = cputicks(&proc1[p], &proc2[p], cputimemode);
+        //更新实时uticks
+        uticks = cputicks(&proc1[p], &proc2[p], 1);
+        //算出总的ticks
+        total_ticks = total_ticks + uticks;
+        //判断是否为idletick
+        //为0一直continue 不用计算
+        if(p-5 == 317) {
+            idleticks = uticks;
+            continue;
+        }
+        //判断是否为kerneltick
+        if(p-5 == ((endpoint_t) -1)) {
+            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;
+//               }
+        //判断是否为systemtick和usertick
+        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;
+    //打印user system kernel idle的情况
+    printf("CPU states: %6.2f%% user, ", 100.0 * userticks / total_ticks);
+    printf("%6.2f%% system, ", 100.0 * systemticks / total_ticks);
+    printf("%6.2f%% kernel, ", 100.0 * kernelticks/ total_ticks);
+    printf("%6.2f%% idle",100.00-(100.0 * (kernelticks+userticks+systemticks)/ total_ticks));
+    printf("\n");
+}
+ //get_procs将所有需要的信息放在结构体数组proc[]中，每个元素都是一个进程结构体。
+void get_procs(void)
+{
+   
+    struct proc *p;
+    int i;
+    
+    p = prev_proc;
+    //记录当前进程，赋值给prev_proc
+    prev_proc = proc;
+    proc = p;
+   
+    if (proc == NULL) {
+        //分配内存
+        //每个进程分配一个结构体
+        //分配nr_total个单位proc结构体内存空间,并把指针赋予proc
+        proc = malloc(nr_total * sizeof(proc[0]));
+        //错误处理
+        if (proc == NULL) {
+            fprintf(stderr, "Out of memory!\n");
+            exit(1);
+        }
+    }
+    //先将所有flag置0
+    for (i = 0; i < nr_total; i++)
+        proc[i].p_flags = 0;
+    //调用parse_dir分析pid
+    parse_dir();
+    
+}
+void getkinfo(void)
+{
+    FILE *fp;
+
+    if ((fp = fopen("/proc/kinfo", "r")) == NULL) {
+        
+        exit(1);
+    }
+    //读如nr_procs,nr_tasks
+    if (fscanf(fp, "%u %u", &nr_procs, &nr_tasks) != 2) {
+       
+        exit(1);
+    }
+
+    fclose(fp);
+    //算出总的nr_total
+    nr_total = (int) (nr_procs + nr_tasks);
+}
+int mytop(){
+    //跳转到/proc
+    if (chdir("/proc") != 0) {
+        perror("chdir to /proc" );
+        return 1;
+    }
+    print_memory();
+    getkinfo();
+    get_procs();
+    //当前进程为空的话 就要再调用get_procs
+    if(prev_proc==NULL)
+        get_procs();
+    
+    print_procs(prev_proc,proc,1);
+    //fflush(NULL);
+    
+    return 0;
+}
+*/
+int mytop()
+{
+    
+}
\ No newline at end of file