###1 实验目的与要求 基于模板 process.c 编写多进程的样本程序，实现如下功能： + 所有子进程都并行运行，每个子进程的实际运行时间一般不超过 30 秒； + 父进程向标准输出打印所有子进程的 id，并在所有子进程都退出后才退出； 在 Linux0.11 上实现进程运行轨迹的跟踪。 + 基本任务是在内核中维护一个日志文件 /var/process.log，把从操作系统启动到系统关机过程中所有进程的运行轨迹都记录在这一 log 文件中。 在修改过的 0.11 上运行样本程序，通过分析 log 文件，统计该程序建立的所有进程的等待时间、完成时间（周转时间）和运行时间，然后计算平均等待时间，平均完成时间和吞吐量。可以自己编写统计程序，也可以使用 python 脚本程序—— stat_log.py（在 /home/teacher/ 目录下） ——进行统计。 修改 0.11 进程调度的时间片，然后再运行同样的样本程序，统计同样的时间数据，和原有的情况对比，体会不同时间片带来的差异。 ####2 实验环境（软、硬件平台） - 蓝桥平台lanqiao.cn ####3 实验内容及步骤实验步骤： 1.编写样本程序 2.log文件 3.写log文件 4.寻找状态切换点 5.管理log文件 6.数据统计 7.修改时间片 -------- ####4 实验过程记录编写process.c文件 Vim创建process.c文件 ![图片描述](https://dn-simplecloud.shiyanlou.com/courses/uid1400145-20200607-1591530443278) 将其代码复制进去 ``` #include #include #include #include #define HZ 100 void cpuio_bound(int last, int cpu_time, int io_time); int main(int argc, char * argv[]) { int pid_fork, a; /* //假设系统现在只有一个进程，执行完下面的fork()函数后，系统就会由两个进程 //原来的进程叫做父进程，新创建的进程叫做子进程 //父进程中fork()会返回子进程的pid号且pid大于0，子进程中fork()会返回0，创建失败会返回负数. //利用此特点,假设创建进程成功，在子进程中pid_fork满足pid_fork == 0， //父进程中pid_fork 满足 pid_fork > 0. 所以从最后的结果来看，下面的代码 else if 和 else //中的代码都会被执行 */ pid_fork = fork(); /*创建一个子进程*/ if ( pid_fork < 0) { printf("Oops, failed to create child process！\n"); } else if (pid_fork == 0) { printf("Yes, create child process successfully！\n"); cpuio_bound(10, 1, 0); printf("cpu used 10s,io used 0s，总计10s \n"); } else { printf("The pid of child process：%d \n", pid_fork); } pid_fork = fork(); /*创建一个子进程*/ if ( pid_fork < 0) { printf("Oops, failed to create child process！\n"); } else if (pid_fork == 0) { printf("Yes, create child process successfully！\n"); cpuio_bound(10, 0, 1); printf("cpu used 0s,io used 10s，总计10s \n"); } else { printf("The pid of child process：%d \n", pid_fork); } pid_fork = fork(); /*创建一个子进程*/ if ( pid_fork < 0) { printf("Oops, failed to create child process！\n"); } else if (pid_fork == 0) { printf("Yes, create child process successfully！\n"); cpuio_bound(10, 1, 9); printf("cpu used 1s,io used 9s，总计10s \n"); } else { printf("The pid of child process：%d \n", pid_fork); } /*等待子进程全部退出后，父进程才退出*/ while ((a = wait(NULL)) != -1) printf("pid %d exit \n", a); printf("..... haha, byebye！....\n"); return 0; } void cpuio_bound(int last, int cpu_time, int io_time) { struct tms start_time, current_time; clock_t utime, stime; int sleep_time; while (last > 0) { /* CPU Burst */ times(&start_time); do { times(¤t_time); utime = current_time.tms_utime - start_time.tms_utime; stime = current_time.tms_stime - start_time.tms_stime; } while (((utime + stime) / HZ) < cpu_time); last -= cpu_time; if (last <= 0) break; sleep_time = 0; while (sleep_time < io_time) { sleep(1); sleep_time++; } last -= sleep_time; } } ``` 修改main.c添加下面的的代码 ![图片描述](https://dn-simplecloud.shiyanlou.com/courses/uid1400145-20200607-1591530482354) 内核状态下写log文件编写printk.c文件的代码，代码如下 ```/* * linux/kernel/printk.c * * (C) 1991 Linus Torvalds */ /* * When in kernel-mode, we cannot use printf, as fs is liable to * point to 'interesting' things. Make a printf with fs-saving, and * all is well. */ #include #include #include "linux/sched.h" #include "sys/stat.h" #include static char buf[1024]; static char logbuf[1024]; extern int vsprintf (char *buf, const char *fmt, va_list args); int printk (const char *fmt, ...) { va_list args; int i; va_start (args, fmt); i = vsprintf (buf, fmt, args); va_end (args); __asm__ ("push %%fs\n\t" "push %%ds\n\t" "pop %%fs\n\t" "pushl %0\n\t" "pushl $buf\n\t" "pushl $0\n\t" "call tty_write\n\t" "addl $8,%%esp\n\t" "popl %0\n\t" "pop %%fs" ::"r" (i):"ax", "cx", "dx"); return i; } int fprintk(int fd, const char *fmt, ...) { va_list args; int count; struct file * file; struct m_inode * inode; va_start(args, fmt); count=vsprintf(logbuf, fmt, args); va_end(args); if (fd < 3) { __asm__("push %%fs\n\t" "push %%ds\n\t" "pop %%fs\n\t" "pushl %0\n\t" "pushl $logbuf\n\t" "pushl %1\n\t" "call sys_write\n\t" "addl $8,%%esp\n\t" "popl %0\n\t" "pop %%fs" ::"r" (count),"r" (fd):"ax","cx","dx"); } else { if (!(file=task[0]->filp[fd])) return 0; inode=file->f_inode; __asm__("push %%fs\n\t" "push %%ds\n\t" "pop %%fs\n\t" "pushl %0\n\t" "pushl $logbuf\n\t" "pushl %1\n\t" "pushl %2\n\t" "call file_write\n\t" "addl $12,%%esp\n\t" "popl %0\n\t" "pop %%fs" ::"r" (count),"r" (file),"r" (inode):"ax","cx","dx"); } return count; } ``` 寻找状态切换点首先进入到kernel目录下找到fork.c、sched.c、exit.c这三个文件将其修改 ![图片描述](https://dn-simplecloud.shiyanlou.com/courses/uid1400145-20200607-1591530500525) fork.c的代码 ```/* * linux/kernel/fork.c * * (C) 1991 Linus Torvalds */ /* * 'fork.c' contains the help-routines for the 'fork' system call * (see also system_call.s), and some misc functions ('verify_area'). * Fork is rather simple, once you get the hang of it, but the memory * management can be a bitch. See 'mm/mm.c': 'copy_page_tables()' */ #include #include #include #include #include extern void write_verify(unsigned long address); long last_pid=0; void verify_area(void * addr,int size) { unsigned long start; start = (unsigned long) addr; size += start & 0xfff; start &= 0xfffff000; start += get_base(current->ldt[2]); while (size>0) { size -= 4096; write_verify(start); start += 4096; } } int copy_mem(int nr,struct task_struct * p) { unsigned long old_data_base,new_data_base,data_limit; unsigned long old_code_base,new_code_base,code_limit; code_limit=get_limit(0x0f); data_limit=get_limit(0x17); old_code_base = get_base(current->ldt[1]); old_data_base = get_base(current->ldt[2]); if (old_data_base != old_code_base) panic("We don't support separate I&D"); if (data_limit < code_limit) panic("Bad data_limit"); new_data_base = new_code_base = nr * 0x4000000; p->start_code = new_code_base; set_base(p->ldt[1],new_code_base); set_base(p->ldt[2],new_data_base); if (copy_page_tables(old_data_base,new_data_base,data_limit)) { printk("free_page_tables: from copy_mem\n"); free_page_tables(new_data_base,data_limit); return -ENOMEM; } return 0; } /* * Ok, this is the main fork-routine. It copies the system process * information (task[nr]) and sets up the necessary registers. It * also copies the data segment in it's entirety. */ int copy_process(int nr,long ebp,long edi,long esi,long gs,long none, long ebx,long ecx,long edx, long fs,long es,long ds, long eip,long cs,long eflags,long esp,long ss) { struct task_struct *p; int i; struct file *f; p = (struct task_struct *) get_free_page(); if (!p) return -EAGAIN; task[nr] = p; *p = *current; /* NOTE! this doesn't copy the supervisor stack */ p->state = TASK_UNINTERRUPTIBLE; /* new */ fprintk(3, "%ld\t%c\t%ld\n", last_pid, 'N', jiffies); p->pid = last_pid; p->father = current->pid; p->counter = p->priority; p->signal = 0; p->alarm = 0; p->leader = 0; /* process leadership doesn't inherit */ p->utime = p->stime = 0; p->cutime = p->cstime = 0; p->start_time = jiffies; p->tss.back_link = 0; p->tss.esp0 = PAGE_SIZE + (long) p; p->tss.ss0 = 0x10; p->tss.eip = eip; p->tss.eflags = eflags; p->tss.eax = 0; p->tss.ecx = ecx; p->tss.edx = edx; p->tss.ebx = ebx; p->tss.esp = esp; p->tss.ebp = ebp; p->tss.esi = esi; p->tss.edi = edi; p->tss.es = es & 0xffff; p->tss.cs = cs & 0xffff; p->tss.ss = ss & 0xffff; p->tss.ds = ds & 0xffff; p->tss.fs = fs & 0xffff; p->tss.gs = gs & 0xffff; p->tss.ldt = _LDT(nr); p->tss.trace_bitmap = 0x80000000; if (last_task_used_math == current) __asm__("clts ; fnsave %0"::"m" (p->tss.i387)); if (copy_mem(nr,p)) { task[nr] = NULL; free_page((long) p); return -EAGAIN; } for (i=0; ifilp[i])) f->f_count++; if (current->pwd) current->pwd->i_count++; if (current->root) current->root->i_count++; if (current->executable) current->executable->i_count++; set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss)); set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt)); p->state = TASK_RUNNING; /* do this last, just in case */ /* ready */ fprintk(3, "%ld\t%c\t%ld\n", p->pid, 'J', jiffies); return last_pid; } int find_empty_process(void) { int i; repeat: if ((++last_pid)<0) last_pid=1; for(i=0 ; ipid == last_pid) goto repeat; for(i=1 ; i #include #include #include #include #include #include int sys_pause(void); int sys_close(int fd); void release(struct task_struct * p) { int i; if (!p) return; for (i=1 ; i32) return -EINVAL; if (priv || (current->euid==p->euid) || suser()) p->signal |= (1<<(sig-1)); else return -EPERM; return 0; } static void kill_session(void) { struct task_struct **p = NR_TASKS + task; while (--p > &FIRST_TASK) { if (*p && (*p)->session == current->session) (*p)->signal |= 1<<(SIGHUP-1); } } /* * XXX need to check permissions needed to send signals to process * groups, etc. etc. kill() permissions semantics are tricky! */ int sys_kill(int pid,int sig) { struct task_struct **p = NR_TASKS + task; int err, retval = 0; if (!pid) while (--p > &FIRST_TASK) { if (*p && (*p)->pgrp == current->pid) if ((err=send_sig(sig,*p,1))) retval = err; } else if (pid>0) while (--p > &FIRST_TASK) { if (*p && (*p)->pid == pid) if ((err=send_sig(sig,*p,0))) retval = err; } else if (pid == -1) while (--p > &FIRST_TASK) { if ((err = send_sig(sig,*p,0))) retval = err; } else while (--p > &FIRST_TASK) if (*p && (*p)->pgrp == -pid) if ((err = send_sig(sig,*p,0))) retval = err; return retval; } static void tell_father(int pid) { int i; if (pid) for (i=0;ipid != pid) continue; task[i]->signal |= (1<<(SIGCHLD-1)); return; } /* if we don't find any fathers, we just release ourselves */ /* This is not really OK. Must change it to make father 1 */ printk("BAD BAD - no father found\n\r"); release(current); } int do_exit(long code) { int i; free_page_tables(get_base(current->ldt[1]),get_limit(0x0f)); free_page_tables(get_base(current->ldt[2]),get_limit(0x17)); for (i=0 ; ifather == current->pid) { task[i]->father = 1; if (task[i]->state == TASK_ZOMBIE) /* assumption task[1] is always init */ (void) send_sig(SIGCHLD, task[1], 1); } for (i=0 ; ifilp[i]) sys_close(i); iput(current->pwd); current->pwd=NULL; iput(current->root); current->root=NULL; iput(current->executable); current->executable=NULL; if (current->leader && current->tty >= 0) tty_table[current->tty].pgrp = 0; if (last_task_used_math == current) last_task_used_math = NULL; if (current->leader) kill_session(); current->state = TASK_ZOMBIE; /* 退出 */ fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'E', jiffies); current->exit_code = code; tell_father(current->father); schedule(); return (-1); /* just to suppress warnings */ } int sys_exit(int error_code) { return do_exit((error_code&0xff)<<8); } int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options) { int flag, code; struct task_struct ** p; verify_area(stat_addr,4); repeat: flag=0; for(p = &LAST_TASK ; p > &FIRST_TASK ; --p) { if (!*p || *p == current) continue; if ((*p)->father != current->pid) continue; if (pid>0) { if ((*p)->pid != pid) continue; } else if (!pid) { if ((*p)->pgrp != current->pgrp) continue; } else if (pid != -1) { if ((*p)->pgrp != -pid) continue; } switch ((*p)->state) { case TASK_STOPPED: if (!(options & WUNTRACED)) continue; put_fs_long(0x7f,stat_addr); return (*p)->pid; case TASK_ZOMBIE: current->cutime += (*p)->utime; current->cstime += (*p)->stime; flag = (*p)->pid; code = (*p)->exit_code; release(*p); put_fs_long(code,stat_addr); return flag; default: flag=1; continue; } } if (flag) { if (options & WNOHANG) return 0; current->state=TASK_INTERRUPTIBLE; /* 睡眠 */ fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies); schedule(); if (!(current->signal &= ~(1<<(SIGCHLD-1)))) goto repeat; else return -EINTR; } return -ECHILD; } ``` 修改Sched.c的代码 ```void schedule (void) { int i, next, c; struct task_struct **p; for (p = &LAST_TASK; p > &FIRST_TASK; --p) { if (*p) { if ((*p)->alarm && (*p)->alarm < jiffies) { (*p)->signal |= (1 << (SIGALRM - 1)); (*p)->alarm = 0; } if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) && (*p)->state == TASK_INTERRUPTIBLE) { //--------------------add start-------------------------- //进程由阻塞态切换到就绪状态，向process.log写入,进程pid、“N"、时钟滴答数 fprintk(3, "%ld\t%c\t%ld\n", (*p)->pid, 'J', jiffies); (*p)->state = TASK_RUNNING; //--------------------add end--------------------------- } } } while (1) { c = -1; next = 0; i = NR_TASKS; p = &task[NR_TASKS]; while (--i) { if (!*--p) continue; if ((*p)->state == TASK_RUNNING && (*p)->counter > c) c = (*p)->counter, next = i; } if (c) break; for (p = &LAST_TASK; p > &FIRST_TASK; --p) if (*p) (*p)->counter = ((*p)->counter >> 1) + (*p)->priority; } //---------------------add start-------------------------------- //next指向接下来要运行的进程，如果next指向的进程已经处于就绪态，那么switch_to(next); //函数就会将其放到处理机上运行 if(task[next]->pid !=current->pid ){ //下一个要运行进程如果是当前进程就不需要改变 if(current->state == TASK_RUNNING){ //一个处于运行态的进程如果时间片用完，就会被切换回就绪态 fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'J', jiffies); } //如果next指向的进程处于就绪态，接下来就将其切换到运行态 if(task[next]->state == TASK_RUNNING){ //进程由就绪态切换到运行态，向process.log写入,进程pid、“R"、时钟滴答数 fprintk(3, "%ld\t%c\t%ld\n", task[next]->pid, 'R', jiffies); } } //----------------------add end-------------------------------- switch_to (next); } ``` 修改完成后执行 ```make all ../run ``` 运行成功的示意图： ![图片描述](https://dn-simplecloud.shiyanlou.com/courses/uid1400145-20200607-1591530527869) 再执行 ```gcc process.c -o process && ./process``` ![图片描述](https://dn-simplecloud.shiyanlou.com/courses/uid1400145-20200607-1591530522123) 最后再用vim打开process.log文件 ![图片描述](https://dn-simplecloud.shiyanlou.com/courses/uid1400145-20200607-1591530510858)

“操作系统实验”实验报告