Linux进程管理 进程状态和时钟滴答[哈工大操作系统实验]

进程管理和创建记录，是哈工大操作系统实验的内容。

涉及的技术内容包括“进程状态转换点定位”和“内核状态下写文件”。

 

本文主要讲解linux 0.11 系统[进程的调度转换知识]，并给出哈工大实验自带的[内核文件读写代码]。

先讲简单的，内核文件读写：

一，搞定文件读写。

内核状态下的文件读写主要靠filp_open() ; filp_clos() ; vfs_read() ; vfs_write()，但是linux0.11的时候，这些东西还没出生呢，内核下只有个printk(String format , vars ...)来打印到屏幕，用法和printf()一样;

还好，工大给出了在内核态打印到文件的代码。这是一个添加到kernel/printk.c的外加系统调用，其实就是一个printk()函数的加强版本，你只需要用之前学过的添加系统调用的手法，在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 <stdarg.h>
#include <stddef.h>

#include <linux/kernel.h>
#include <linux/sched.h>
#include <sys/stat.h>
static char buf[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;
}
static char logbuf[1024];
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)	/* 如果输出到stdout或stderr，直接调用sys_write即可 */
	{
		__asm__("push %%fs\n\t"
			"push %%ds\n\t"
			"pop %%fs\n\t"
			"pushl %0\n\t"
			"pushl $logbuf\n\t" /* 注意对于Windows环境来说，是_logbuf,下同 */
			"pushl %1\n\t"
			"call sys_write\n\t" /* 注意对于Windows环境来说，是_sys_write,下同 */
			"addl $8,%%esp\n\t"
			"popl %0\n\t"
			"pop %%fs"
			::"r" (count),"r" (fd):"ax","cx","dx");
	}
	else	/* 假定>=3的描述符都与文件关联。事实上，还存在很多其它情况，这里并没有考虑。*/
	{
		if (!(file=task[0]->filp[fd]))	/* 从进程0的文件描述符表中得到文件句柄 */
			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;
}

然后相应修改unistd.h , system_call.s  sys.h 就搞定了这个函数，向文件中写东西的语句如下：

fprintk(3,"%d",a);

二，理清思路

我们要做的事情总的来说就是两步：

1，找到进程小朋友们在哪里转换状态。

2，在转换状态的地方记录这次变化到文件。（直接调用fprintk就能自动生成process.log并按格式写入）；

问题2其实已经解决了，就剩下1了，这里有一些知识需要了解：

一个进程的状态有如下几种宏：

TASK_RUNNING（准备好随时运行或正在运行）

TASK_INTERRUPTIBLE（进入睡眠，可以打断其 “进入睡眠” 直接改状态）

TASK_UNINTERRUPTIBLE（进入不可中断睡眠，完全进入睡眠后方可正式唤醒）

TASK_ZOMBIE（僵死状态，进程同学一路走好）

不同时间进入这三种状态，会产生一些教授们定义出来的状态：New /Ready /Running /Wait /Exit

三，开始找状态点：

1，fork.c  包含状态：new，ready

/*
 *  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 <errno.h>

#include <linux/sched.h>
#include <linux/kernel.h>
#include <asm/segment.h>
#include <asm/system.h>
#include <linux/fs.h>
#ifndef timep
#define timep jiffies
#endif
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;
	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; i<NR_OPEN;i++)
		if ((f=p->filp[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 */
//这里有修改
         fprintk(3,"%ld\tN\t%ld\n",last_pid,timep);//进程新建好了	，这里的timep宏就是 jiffies
	fprintk(3,"%ld\tJ\t%ld\n",last_pid,timep);//进程肯定准备好了
	//printk("%d J %d\n",last_pid,jiffies);
	return last_pid;
}

int find_empty_process(void)
{
	int i;

	repeat:
		if ((++last_pid)<0) last_pid=1;
		for(i=0 ; i<NR_TASKS ; i++)
			if (task[i] && task[i]->pid == last_pid) goto repeat;
	for(i=1 ; i<NR_TASKS ; i++)
		if (!task[i])
			return i;
	return -EAGAIN;
}

 

2.sched.c 包含状态：ready, sleep ,run

/*
 *  linux/kernel/sched.c
 *
 *  (C) 1991  Linus Torvalds
 */

/*
 * 'sched.c' is the main kernel file. It contains scheduling primitives
 * (sleep_on, wakeup, schedule etc) as well as a number of simple system
 * call functions (type getpid(), which just extracts a field from
 * current-task
 */
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/sys.h>
#include <linux/fdreg.h>
#include <asm/system.h>
#include <asm/io.h>
#include <asm/segment.h>

#include <signal.h>

#define _S(nr) (1<<((nr)-1))
#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))

void show_task(int nr,struct task_struct * p)
{
	int i,j = 4096-sizeof(struct task_struct);

	printk("%d: pid=%d, state=%d, ",nr,p->pid,p->state);
	i=0;
	while (i<j && !((char *)(p+1))[i])
		i++;
	printk("%d (of %d) chars free in kernel stack\n\r",i,j);
}

void show_stat(void)
{
	int i;

	for (i=0;i<NR_TASKS;i++)
		if (task[i])
			show_task(i,task[i]);
}

#define LATCH (1193180/HZ)

extern void mem_use(void);

extern int timer_interrupt(void);
extern int system_call(void);

union task_union {
	struct task_struct task;
	char stack[PAGE_SIZE];
};

static union task_union init_task = {INIT_TASK,};

long volatile jiffies=0;
long startup_time=0;
struct task_struct *current = &(init_task.task);
struct task_struct *last_task_used_math = NULL;

struct task_struct * task[NR_TASKS] = {&(init_task.task), };

long user_stack [ PAGE_SIZE>>2 ] ;

struct {
	long * a;
	short b;
	} stack_start = { & user_stack [PAGE_SIZE>>2] , 0x10 };
/*
 *  'math_state_restore()' saves the current math information in the
 * old math state array, and gets the new ones from the current task
 */
void math_state_restore()
{
	if (last_task_used_math == current)
		return;
	__asm__("fwait");
	if (last_task_used_math) {
		__asm__("fnsave %0"::"m" (last_task_used_math->tss.i387));
	}
	last_task_used_math=current;
	if (current->used_math) {
		__asm__("frstor %0"::"m" (current->tss.i387));
	} else {
		__asm__("fninit"::);
		current->used_math=1;
	}
}

/*
 *  'schedule()' is the scheduler function. This is GOOD CODE! There
 * probably won't be any reason to change this, as it should work well
 * in all circumstances (ie gives IO-bound processes good response etc).
 * The one thing you might take a look at is the signal-handler code here.
 *
 *   NOTE!!  Task 0 is the 'idle' task, which gets called when no other
 * tasks can run. It can not be killed, and it cannot sleep. The 'state'
 * information in task[0] is never used.
 */
void schedule(void)
{
	int i,next,c;
	struct task_struct ** p;

/* check alarm, wake up any interruptible tasks that have got a signal */

	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)
			{
				(*p)->state=TASK_RUNNING;
				//there is a ready
				fprintk(3,"%ld\tJ\t%ld\n",(*p)->pid,jiffies);//这里转换，进入就绪
			}
		}

/* this is the scheduler proper: */

	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;
	}
	if(current != p) 
	{if(current->state == 0)//这里转换：如果下一个要 RUN 的不是正在 RUN 的，给你补上一条ready，因为你将停下来进入就绪状态，换下一个跑。current指针指向当前正在运行的进程。
		fprintk(3,"%ld\tJ\t%ld\n",current->pid,jiffies);
				  //下面转换：如果下一个要 RUN 的就是当前正在 RUN 的，那就不用打印了，否则打印RUN。
	//there is a running
	fprintk(3,"%ld\tR\t%ld\n",p->pid,jiffies);
	}
	switch_to(next);//切到 p 去运行
}

int sys_pause(void)
{
	if(current->state!=TASK_INTERRUPTIBLE){
	current->state = TASK_INTERRUPTIBLE;
	//there is one
	if(current->pid!=0) //这里有一个，可中断的睡眠，就是sleep（wait），守护进程0总在等待，就不用显示它了，闹心。
	fprintk(3,"%ld\tW\t%ld\n",current->pid,jiffies);
	}
	schedule();
	return 0;
}

void sleep_on(struct task_struct **p)
{
	struct task_struct *tmp;

	if (!p)
		return;
	if (current == &(init_task.task))
		panic("task[0] trying to sleep");
	tmp = *p;
	*p = current;
	current->state = TASK_UNINTERRUPTIBLE;
		//there is one
		if(current->pid!=0) //这里有一个，不可中断的睡眠，就是sleep（wait），守护进程0总在等待，就不用显示它了，闹心。
		fprintk(3,"%ld\tW\t%ld\n",current->pid,jiffies);
	schedule();
	*p=tmp;
	if (tmp ){//&& tmp->state!=0){
		tmp->state=TASK_RUNNING;
		//there is one
		//if(tmp->pid!=current->pid)//这里，temp被唤醒就绪，判断防止重复打印
		fprintk(3,"%ld\tJ\t%ld\n",tmp->pid,jiffies);
	}
}

void interruptible_sleep_on(struct task_struct **p)
{
	struct task_struct *tmp;

	if (!p)
		return;
	if (current == &(init_task.task))
		panic("task[0] trying to sleep");
	tmp=*p;
	*p=current;
repeat:	current->state = TASK_INTERRUPTIBLE;
	//there is one wait
	if(current->pid!=0)//这里和上面同理
	fprintk(3,"%ld\tW\t%ld\n",current->pid,jiffies);
	schedule();
	if (*p && *p != current) {
		
		//这里，从调度返回，意味着p被唤醒
		fprintk(3,"%ld\tJ\t%ld\n",(*p)->pid,jiffies);
			(**p).state=0;//这里就唤醒了p
			goto repeat;
	}
	*p=tmp;
	if (tmp){
		//if(tmp->state!=0){
			tmp->state=0;
		//	if(tmp->pid!=current->pid)//此处与上同理
			fprintk(3,"%ld\tJ\t%ld\n",tmp->pid,jiffies);
		//	}
		}
}

void wake_up(struct task_struct **p)
{
	if (p && *p) {
		if((*p)->state!=TASK_RUNNING){
		fprintk(3,"%ld\tJ\t%ld\n",(*p)->pid,jiffies);//这里，同理。
		(**p).state=TASK_RUNNING;
		}
	}
}

//下边是软盘驱动什么的，不改。

3，exit.c 包含状态：exit,

/*
 *  linux/kernel/exit.c
 *
 *  (C) 1991  Linus Torvalds
 */

#include <errno.h>
#include <signal.h>
#include <sys/wait.h>

#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/tty.h>
#include <asm/segment.h>
#define VARCHEN 0
#define timep jiffies
int sys_pause(void);
int sys_close(int fd);

void release(struct task_struct * p)
{
	int i;

	if (!p)
		return;
	for (i=1 ; i<NR_TASKS ; i++)
		if (task[i]==p) {
			task[i]=NULL;
			free_page((long)p);
			schedule();
			return;
		}
	panic("trying to release non-existent task");
}

static inline int send_sig(long sig,struct task_struct * p,int priv)
{
	if (!p || sig<1 || sig>32)
		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;i<NR_TASKS;i++) {
			if (!task[i])
				continue;
			if (task[i]->pid != 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 ; i<NR_TASKS ; i++)
		if (task[i] && task[i]->father == 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);    //发出子进程退出的信号
				//printk("\nPID:%d Zombie %d\n",task[i]->pid,jiffies);
				fprintk(3,"%ld\tE\t%ld\n",task[i]->pid,timep);    //恭喜这位进程获得将死称号
			}
		}
	for (i=0 ; i<NR_OPEN ; i++)
		if (current->filp[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;   //这里是状态转换，但是因为EXIT这种状态转换很分散，“赋值为将死”可能出现在任何涉及关闭操作的系统调用中，不好找。然而对zombie的检查却都在上方。所以exit的打印就都截在了循环判断中。
	//如解除下面注释，就会让一些程序“死两遍”...
	//fprintk(3,"%d E %d\n",current->pid,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:    fprintk(3,"%ld\tE\t%ld\n",(*p)->pid,timep);     //这里有一个状态转换，state=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;
		if(current->state!=TASK_INTERRUPTIBLE){
			current->state=TASK_INTERRUPTIBLE;    //这里变成了等待状态
			if(current->pid!=VARCHEN)              //还是防止0进程捣乱。
			fprintk(3,"%ld\tW\t%ld\n",current->pid,timep);
		}
		schedule();
		if (!(current->signal &= ~(1<<(SIGCHLD-1))))
			goto repeat;
		else
			return -EINTR;
	}
	return -ECHILD;
}

 

这样，状态的寻找就结束了，目标是尽快完成实验的同学可以不用往下看了。

下面简单说说进程调度时间片的事情。

1，什么是时间片？

我们知道，机器的最小时间单位叫做“时钟周期”，也就是晶振11.88MHZ，是执行一条原子指令的时间。几个时钟周期凑合在一起，就是“机器周期”，用于完成一小套动作。

jiffie滴答类似时钟周期，时间片类似机器周期。

时间片标志着CPU对进程的关注程度，高权限的进程得到的时间片大，包含很多滴答，低权限的就小，滴答数相应就少。

2，修改了又怎样？

进程得到的平均时间片大，则进程间切换就不频繁，当时间片无限制时，就是FIFO先来先服务，你完事儿了下一个。反之就来回折腾。

3，怎么修改啊？

[1]让每个滴答的时间变大，这样时间片的绝对时间就变长了。可以在sched.h头文件修改滴答的定义：#define ....  200  . 200HZ的滴答就是每个滴答5ms。

你把它调成100，就是10ms了。

[2]让时间片包含的滴答数目普遍增多，在schedule()里面有一个级数优先级算法 count = count/2 + priority，你给count再加一个常数，就让每个count变大了。

 

 

 

 

 

 

 

Aurora 极光城

講技術，說人話。