diff --git a/include/zjunix/pc.h b/include/zjunix/pc.h
index 8ae41b9..a69cc6c 100644
--- a/include/zjunix/pc.h
+++ b/include/zjunix/pc.h
@@ -72,6 +72,7 @@ extern struct list_head tasks;                      //存放所有进程
 extern struct list_head sched[PRORITY_NUM + 1];     //调度链表
 extern task_struct *current_task;                   //当前进程           
 unsigned char pro_map[PRORITY_BYTES];               //优先级位图
+// int argsc = 0;
 
 void init_pc_list();
 void init_pro_map();
@@ -100,7 +101,7 @@ void add_terminal(task_struct * task);
 void task_files_delete(task_struct * task);
 int pc_kill(pid_t pid);
 int kernel_proc(unsigned int argc, void * argv);
-int exec_kernel(void *argv, int is_wait, int is_user);
+int exec_kernel(int argc, void *argv, int is_wait, int is_user);
 task_struct * wait_check(pid_t pid);
 void task_exit();
 void wakeup_parent();
diff --git a/kernel/init.c b/kernel/init.c
index 3d8019a..20795c5 100644
--- a/kernel/init.c
+++ b/kernel/init.c
@@ -7,6 +7,7 @@
 #include <zjunix/bootmm.h>
 #include <zjunix/buddy.h>
 #include <zjunix/fs/fat.h>
+#include <zjunix/mfs/fat32.h>
 #include <zjunix/log.h>
 #include <zjunix/pc.h>
 #include <zjunix/slab.h>
@@ -68,7 +69,7 @@ void init_kernel() {
     log(LOG_END, "Memory Modules.");
     // File system
     log(LOG_START, "File System.");
-    init_fs();
+    init_fat32();
     log(LOG_END, "File System.");
     // System call
     log(LOG_START, "System Calls.");
diff --git a/kernel/mfs/dir.c b/kernel/mfs/dir.c
index bcb215a..df8f9e1 100644
--- a/kernel/mfs/dir.c
+++ b/kernel/mfs/dir.c
@@ -20,7 +20,7 @@ DIR * opendir(u8 *path) {
         ans->crt_index = 0;
         return ans;
     }
-    else if (path[0] == '/') {
+    else {
         MY_FILE *myfile;
         fat32_open(myfile, path);
         ans->start_clus = get_start_clu_num(myfile);
@@ -52,11 +52,6 @@ dirent *readdir(DIR *dir) {
 
     while (crt_clu != 0x0FFFFFFF) {
 
-#ifdef FS_DEBUG
-        disk_name_str[11] = 0;
-        kernel_printf("The current searching is %s\n", disk_name_str);
-#endif
-
         // Traverse every sector in current cluster
         for (u32 i = 0; i < SEC_PER_CLU; i++) {
             // Traverse every dentry in current sector
@@ -83,15 +78,6 @@ dirent *readdir(DIR *dir) {
                 if (tmp->dentry_data.data[0] == 0x00)   // Not found
                     return 0;
                 print_disk_name(tmp->dentry_data.data);
-#ifdef FS_DEBUG
-                    kernel_printf("found!%d\n", 1);
-                    kernel_printf("entry size %d\n", get_u32(tmp->dentry_data.data+28));
-#endif
-#ifdef FS_DEBUG
-                else {
-                    kernel_printf("Not found h.txt\n");
-                }
-#endif
             }
         }
         // Get the next cluster
@@ -101,7 +87,7 @@ dirent *readdir(DIR *dir) {
 #endif
         crt_clu = get_next_clu_num(crt_clu);
 #ifdef FS_DEBUG
-        kernel_printf("next clu:%d\n", next_clu);
+        kernel_printf("next clu:%d\n", crt_clu);
 #endif
     }
 }
\ No newline at end of file
diff --git a/kernel/mfs/fat32.c b/kernel/mfs/fat32.c
index 95eb3a2..83dbd00 100644
--- a/kernel/mfs/fat32.c
+++ b/kernel/mfs/fat32.c
@@ -89,11 +89,11 @@ u32 load_root_dentries() {
     pwd_dentry->name[0] = 0;
     pwd_dentry->spinned = 1;
     pwd_dentry->dentry_data.short_attr.attr = 0x10;
-    pwd_dentry->dentry_data.short_attr.starthi = 0;
-    pwd_dentry->dentry_data.short_attr.startlow = 2;
+    set_u16(pwd_dentry->dentry_data.data+20, 0);
+    set_u16(pwd_dentry->dentry_data.data+26, 2);
     pwd_dentry->abs_sector_num = total_info.data_start_sector;
     pwd_dentry->sector_dentry_offset = 0;
-    
+
     dcache_add(dcache, pwd_dentry);
 
     struct mem_FATbuffer * result;
@@ -110,38 +110,48 @@ u32 load_root_dentries() {
 }
 
 u32 fat32_find(MY_FILE *file) {
+
     u8 *path = file->path;
     u8 disk_name_str[12];
 
-    int slash_traverser = 1;
+    int slash_traverser;
     struct mem_dentry *crt_directory;
-    if (path[0] == '/') {       // Wrong Path
+    if (path[0] == '/') {
         if (path[1] == 0) {
             file->disk_dentry_sector_num = root_dentry->abs_sector_num;
             file->disk_dentry_num_offset = root_dentry->sector_dentry_offset;
             return 0;
         }
         crt_directory = root_dentry;
+        slash_traverser = 1;
+        
     } else if (path[0] == 0) {
         file->disk_dentry_sector_num = pwd_dentry->abs_sector_num;
         file->disk_dentry_num_offset = pwd_dentry->sector_dentry_offset;
         return 0;
     } else {
         crt_directory = pwd_dentry;
+        slash_traverser = 0;
     }
 
     u32 crt_clu;
     u32 next_clu;
     u32 slash_offset = fs_cut_slash(path+slash_traverser, disk_name_str);
+    disk_name_str[11] = 0;
 
     // Traverse every file name in the path
     while ( slash_offset != 0 && slash_offset != 0xFFFFFFFF ) {
         if ( (crt_directory->dentry_data.short_attr.attr & 0x10) == 0 )      // Path isn't finished, but it is't sub directory
+        {
+            // kernel_printf("before return 1\n");
             return 1;
+        }
         // The address in FAT block
         // Root -> 2
         crt_clu = get_clu_by_dentry(crt_directory);
 
+        // kernel_printf("crt_clu = %d\n", crt_clu);
+
         // Traverse every cluster of current direcroty
         while (crt_clu != 0x0FFFFFFF) {
 
@@ -289,11 +299,6 @@ u32 fat32_write(MY_FILE *file, u8 *buf, u32 count) {
 
     u32 crt_clus = get_start_clu_num(file);
     u32 filesize = get_file_size(file);
-    kernel_printf("start clus got!\n");
-
-
-    kernel_printf("crt_clus : %d\n", crt_clus);
-    kernel_printf("file size is : %d\n", filesize);
 
     // This file has no data before
     if (crt_clus == 0) {
@@ -307,8 +312,6 @@ u32 fat32_write(MY_FILE *file, u8 *buf, u32 count) {
         update_FAT(crt_clus, 0x0FFFFFFF);
     }
 
-    if (file->crt_pointer_position + count > filesize)
-        count = filesize - file->crt_pointer_position;
     u32 start_clus_num = file->crt_pointer_position / CLUSTER_SIZE;
     u32 start_byte_num = file->crt_pointer_position % CLUSTER_SIZE;
     u32 end_clus_num = (file->crt_pointer_position + count) / CLUSTER_SIZE;
@@ -334,15 +337,16 @@ u32 fat32_write(MY_FILE *file, u8 *buf, u32 count) {
         if (clus_index >= start_clus_num && clus_index <= end_clus_num) {
             // Get start and end byte num
             if (clus_index == start_clus_num) 
-                _start = start_clus_num;
+                _start = start_byte_num;
             else 
                 _start = 0;
             if (clus_index == end_clus_num)
-                _end = end_clus_num;
+                _end = end_byte_num;
             else
                 _end = CLUSTER_SIZE;
             
             struct mem_page *crt_page =  get_page(crt_clus-2);
+            // kernel_printf("_start = %d _end = %d\n", _start, _end);
             kernel_memcpy(crt_page->p_data+_start, (void*)buf + buf_index, _end-_start);
             crt_page->state = PAGE_DIRTY;
             buf_index += _end - _start;
@@ -366,7 +370,15 @@ u32 fat32_write(MY_FILE *file, u8 *buf, u32 count) {
     if (file->crt_pointer_position + count > filesize) {
         u32 sec_num = file->disk_dentry_sector_num, offset = file->disk_dentry_num_offset;
         u16 new_size = file->crt_pointer_position + count;
-        update_dentry(sec_num, offset, size, new_size);
+        // kernel_printf("newsize is %d\n", new_size);
+        // update_dentry(sec_num, offset, size, new_size);
+        struct mem_dentry * tmp_dentry = get_dentry(sec_num, offset);
+        u32 page_cluster_num = (sec_num - total_info.data_start_sector) / SEC_PER_CLU;
+        struct mem_page * tmp_page = get_page(page_cluster_num);
+        set_u32(tmp_dentry->dentry_data.data+28, new_size);
+        union disk_dentry *attributes = (union disk_dentry *)(tmp_page->p_data + offset * DENTRY_SIZE);
+        set_u32(attributes->data+28, new_size);
+        tmp_page->state = PAGE_DIRTY;
     }
 
     return buf_index;
diff --git a/kernel/mfs/fat32cache.c b/kernel/mfs/fat32cache.c
index d5e6567..130fa32 100644
--- a/kernel/mfs/fat32cache.c
+++ b/kernel/mfs/fat32cache.c
@@ -1,4 +1,5 @@
 #include <zjunix/log.h>
+#include <driver/vga.h>
 #include <zjunix/slab.h>
 #include <zjunix/utils.h>
 
@@ -59,6 +60,7 @@ struct mem_dentry * get_dentry(u32 sector_num, u32 offset) {
         dcache_add(dcache, result);
         return result;
     } else {
+        kernel_printf("dcache look up found!\n");
         return result;
     }
 }
diff --git a/kernel/mfs/usr.c b/kernel/mfs/usr.c
index ee2df8e..0bcfc61 100644
--- a/kernel/mfs/usr.c
+++ b/kernel/mfs/usr.c
@@ -11,10 +11,6 @@ extern struct Total_FAT_Info total_info;
 extern struct mem_dentry * pwd_dentry;
 
 u32 fat32_cat(u8 *path) {
-#ifdef FS_DEBUG
-    kernel_printf("In my cat function.\n");
-#endif
-
 
     u8 filename[12];
     MY_FILE cat_file;
@@ -31,14 +27,11 @@ u32 fat32_cat(u8 *path) {
     kernel_printf("The file size is %d\n", file_size);
 #endif 
     u8 *buf = (u8 *)kmalloc(file_size + 1);
+    u8 *new_buf = (u8 *)kmalloc(2*file_size+1);
 
-    fat32_read(&cat_file, buf, file_size);
     fat32_read(&cat_file, buf, file_size);
     buf[file_size] = 0;
-    // fat32_write(&cat_file, buf, file_size);
-    //new_buf[2*file_size] = 0;
     kernel_printf("%s\n", buf);
-    //kernel_printf("%s\n", new_buf);
 
     fat32_close(&cat_file);
     kfree(buf);
diff --git a/kernel/mm/buddy.c b/kernel/mm/buddy.c
index 734af67..6cbaa90 100644
--- a/kernel/mm/buddy.c
+++ b/kernel/mm/buddy.c
@@ -135,22 +135,22 @@ struct page *__alloc_pages(unsigned int bplevel) {
     unsigned int current_order, size;
     struct page *page, *buddy_page;
     struct freelist *free;
-    kernel_printf("enter __alloc_pages\n");
+    // kernel_printf("enter __alloc_pages\n");
     lockup(&buddy.lock);
     //search pages
     for (current_order = bplevel; current_order <= MAX_BUDDY_ORDER; ++current_order) {
         free = buddy.freelist + current_order;
-        kernel_printf("free == %x\n", free);
+        // kernel_printf("free == %x\n", free);
         if (!list_empty(&(free->free_head)))
             goto found;
     }
     //if not found
     unlock(&buddy.lock);
-    kernel_printf("__alloc_pages not found\n");
+    // kernel_printf("__alloc_pages not found\n");
     return 0;
 
 found:
-    kernel_printf("have found\n");
+    // kernel_printf("have found\n");
     page = container_of(free->free_head.next, struct page, list);
     list_del_init(&(page->list));
     set_bplevel(page, bplevel);
@@ -174,7 +174,7 @@ struct page *__alloc_pages(unsigned int bplevel) {
     }
 
     unlock(&buddy.lock);
-    kernel_printf("\n return page \n");
+    // kernel_printf("\n return page \n");
     return page;
 }
 
@@ -187,17 +187,17 @@ void *alloc_pages(unsigned int level) {
     while(1<<bplevel<level)
         bplevel++;
 
-    kernel_printf("bplevel == %x", bplevel);
+    // kernel_printf("bplevel == %x", bplevel);
 
     struct page *page = __alloc_pages(bplevel);
 
     if (!page)
         {
-            kernel_printf("page ==0\n");
+            // kernel_printf("page ==0\n");
             return 0;
         }
 
-    kernel_printf("return (void *)((page - pages) << PAGE_SHIFT) \n");
+    // kernel_printf("return (void *)((page - pages) << PAGE_SHIFT) \n");
     return (void *)((page - pages) << PAGE_SHIFT);
 }
 
diff --git a/kernel/mm/slab.c b/kernel/mm/slab.c
index 8dae9c8..97aa186 100644
--- a/kernel/mm/slab.c
+++ b/kernel/mm/slab.c
@@ -72,7 +72,7 @@ void *slab_alloc(struct kmem_cache *cache) {
     struct slab_head *s_head;
     void *object = 0;
     struct page *newpage;
-    kernel_printf("enter slab_alloc\n");
+    // kernel_printf("enter slab_alloc\n");
     if (cache->cpu.page==0)
         goto fullPage;
     newpage = cache->cpu.page;
@@ -90,14 +90,14 @@ void *slab_alloc(struct kmem_cache *cache) {
         kernel_printf("From Free-list\nnr_objs:%d\tobject:%x\tnew slabp:%x\n", s_head->nr_objs, object, newpage7s->slabp);
         // kernel_getchar();
 #endif  // ! SLAB_DEBUG
-        kernel_printf("return FreeList-object\n");
+        // kernel_printf("return FreeList-object\n");
         return object;
     }
 
 fullPage:
     if(list_empty(&(cache->node.partial))){
 
-    kernel_printf("Page is Full\n");
+    // kernel_printf("Page is Full\n");
 
     // call the buddy system to allocate one more page to be slab-cache
     newpage = __alloc_pages(0);// get bplevel = 0 page === one page
@@ -118,7 +118,7 @@ void *slab_alloc(struct kmem_cache *cache) {
 notFullPage:
     if(s_head->isFull==0)
     {   
-        kernel_printf("enter notFullPage\n");
+        // kernel_printf("enter notFullPage\n");
         object = s_head->end_ptr;
         s_head->end_ptr = object + cache->size;
         ++(s_head->nr_objs);
@@ -157,7 +157,7 @@ void slab_free(struct kmem_cache *cache, void *object) {
     struct slab_head *s_head = (struct slab_head *)KMEM_ADDR(opage, pages);
 
     if (!(s_head->nr_objs)) {
-        kernel_printf("ERROR : slab_free error!\n");
+        // kernel_printf("ERROR : slab_free error!\n");
         // die();
         while (1) ;
     }
@@ -201,7 +201,7 @@ unsigned int get_slab(unsigned int size) {
     unsigned int bf_num = (1 << (PAGE_SHIFT - 1));  // half page
     unsigned int bf_index = PAGE_SHIFT;             // record the best fit num & index
 
-    kernel_printf("enter get_slab\n");
+    // kernel_printf("enter get_slab\n");
     for (i = 0; i < itop; i++) {
         if ((kmalloc_caches[i].objsize >= size) && (kmalloc_caches[i].objsize < bf_num)) {
             bf_num = kmalloc_caches[i].objsize;
@@ -213,12 +213,12 @@ unsigned int get_slab(unsigned int size) {
 
 void *kmalloc(unsigned int size) {
     void *result;
-    kernel_printf("kmalloc size==%d\n", size);
+    // kernel_printf("kmalloc size==%d\n", size);
     if (!size)
         return 0;
     
     result = phy_kmalloc(size);
-    kernel_printf("kmalloc reuslt==%x\n ", result);
+    // kernel_printf("kmalloc reuslt==%x\n ", result);
     if (result) 
         return (void*)(KERNEL_ENTRY | (unsigned int)result);
     else 
@@ -228,7 +228,7 @@ void *kmalloc(unsigned int size) {
 void *phy_kmalloc(unsigned int size) {
     struct kmem_cache *cache;
     unsigned int bf_index;
-    kernel_printf("enter phy_kmalloc\n");
+    // kernel_printf("enter phy_kmalloc\n");
     if (!size)
         return 0;
 
@@ -237,17 +237,17 @@ void *phy_kmalloc(unsigned int size) {
     if (size > kmalloc_caches[PAGE_SHIFT - 1].objsize) {
 
         size =Allign(size, 1<<PAGE_SHIFT);
-        kernel_printf("\n pyh_kmalloc size == %x\n", size);
+        // kernel_printf("\n pyh_kmalloc size == %x\n", size);
         return alloc_pages(size >> PAGE_SHIFT);
     }
 
     bf_index = get_slab(size);
     if (bf_index >= PAGE_SHIFT) {
-        kernel_printf("ERROR: No available slab\n");
+        // kernel_printf("ERROR: No available slab\n");
         while (1)
             ;
     }
-    kernel_printf("return slab_alloc\n");
+    // kernel_printf("return slab_alloc\n");
     return slab_alloc(&(kmalloc_caches[bf_index]));
 }
 
diff --git a/kernel/pc/pc.c b/kernel/pc/pc.c
index 9b957b2..6742a5d 100644
--- a/kernel/pc/pc.c
+++ b/kernel/pc/pc.c
@@ -22,6 +22,8 @@ unsigned int sched_time[PRORITY_NUM];
 //当前运行进程指针
 task_struct * current_task = 0;
 
+int argsc = 0;
+
 //初始化所有进程链表
 //在init_pc()中调用
 void init_pc_list(){
@@ -143,15 +145,16 @@ void init_pc(){
 int task_create(char * task_name, long static_prority, void (*entry)(unsigned int argc, void * argv),
                 unsigned int argc, void * argv, pid_t * ret_pid, int is_user){
     //检查静态优先级
+    //print_proc();
     if(static_prority >= PRORITY_NUM || static_prority < 0){
-        kernel_printf("Task_create: static_prority out of range!\n");
+        // kernel_printf("Task_create: static_prority out of range!\n");
         return 1;
     }
     
     //分配PID
     pid_t new_pid;
     if(pid_alloc(&new_pid)){
-        kernel_printf("Task_create: pid allocated failed!\n");
+        // kernel_printf("Task_create: pid allocated failed!\n");
         return 1;
     }
 
@@ -173,6 +176,8 @@ int task_create(char * task_name, long static_prority, void (*entry)(unsigned in
     new_union->task.ppid = current_task->pid;
     kernel_strcpy(new_union->task.name, task_name);
     
+    //print_proc();
+
     // #ifdef PC_DEBUG
     //     kernel_printf("task_name = %s\n", task_name);
     // #endif
@@ -189,6 +194,7 @@ int task_create(char * task_name, long static_prority, void (*entry)(unsigned in
         new_union->task.dynamic_prority = new_union->task.static_prority;
         new_union->task.counter = sched_time[new_union->task.static_prority];
     }
+    argsc++;
     char temp_time[START_TIME_LEN];
     get_time(temp_time, START_TIME_LEN);
     kernel_strcpy(new_union->task.start_time, temp_time);
@@ -206,7 +212,7 @@ int task_create(char * task_name, long static_prority, void (*entry)(unsigned in
     asm volatile("la %0, _gp\n\t" : "=r"(init_gp));
     new_union->task.context.gp = init_gp;
     //设置新进程参数
-    new_union->task.context.a0 = argc;
+    new_union->task.context.a0 = argsc - 1;
     new_union->task.context.a1 = (unsigned int)argv;
 
     INIT_LIST_HEAD(&(new_union->task.sched));
@@ -811,7 +817,7 @@ int kernel_proc(unsigned int argc, void * argv){
 //kernel创建进程
 //新进程的入口函数相同
 //成功返回0，否则返回1
-int exec_kernel(void * argv, int is_wait, int is_user){
+int exec_kernel(int argc, void * argv, int is_wait, int is_user){
     //获得进程名
     char name[TASK_NAME_LEN];
     char * ptr;
@@ -834,7 +840,7 @@ int exec_kernel(void * argv, int is_wait, int is_user){
 
     if(!is_user){
         //内核线程，新进程入口为kernel_proc函数
-        res = task_create(name, s_prority, (void *)kernel_proc, 1, name, &new_pid, 0);
+        res = task_create(name, s_prority, (void *)kernel_proc, argc, name, &new_pid, 0);
     }
     if(res != 0){
         kernel_printf("Exec_kernel: task created failed!\n");
diff --git a/usr/ps.c b/usr/ps.c
index 056351f..b7c2a61 100644
--- a/usr/ps.c
+++ b/usr/ps.c
@@ -184,13 +184,13 @@ void parse_cmd() {
     //     kernel_printf("proc return with %d\n", result);
     }else if(kernel_strcmp(ps_buffer, "execk") == 0){
         kernel_printf("Enter execk\n");
-        result = exec_kernel((void *)param, 0, 0);
+        result = exec_kernel(1, (void *)param, 0, 0);
         kernel_printf("execk return with %d\n", result);
     } else if(kernel_strcmp(ps_buffer, "execk2") == 0){
         kernel_printf("Enter execk2\n");
-        result = exec_kernel((void *)param, 1, 0);
+        result = exec_kernel(1, (void *)param, 1, 0);
         kernel_printf("execk2 return with %d\n", result);
-    }else if (kernel_strcmp(ps_buffer, "cat") == 0) {
+    } else if (kernel_strcmp(ps_buffer, "cat") == 0) {
         result = fat32_cat(param);
         kernel_printf("cat return with %d\n", result);
     } else if (kernel_strcmp(ps_buffer, "ls") == 0) {