Linux进程调用

定义：
linux内核中设置了一组用于实现系统功能的子程序，成为系统调用。系统调用和普通库函数调用非常相似，只是系统调用由操作系统核心提供，运行于核心态，而普通的函数调用由函数库或用户自己提供，运行于用户态。

如何工作：
一般的，进程是不能访问内核的。它不能访问内核所占内存空间也不能调用内核函数。CPU硬件决定了这些（这就是为什么它被称作"保护模式"）。系统调用是这些规则的一个例外。其原理是进程先用适当的值填充寄存器，然后调用一个特殊的指令，这个指令会跳到一个事先定义的内核中的一个位置（当然，这个位置是用户进程可读但是不可写的）。在Intel CPU中，这个由中断0x80实现。硬件知道一旦你跳到这个位置，你就不是在限制模式下运行的用户，而是作为操作系统的内核--所以你就可以为所欲为。 进程可以跳转到的内核位置叫做sysem_call。这个过程检查系统调用号，这个号码告诉内核进程请求哪种服务。然后，它查看系统调用表 (sys_call_table)找到所调用的内核函数入口地址。接着，就调用函数，等返回后，做一些系统检查，最后返回到进程（或到其他进程，如果这个进程时间用尽）。如果你希望读这段代码，它在<内核源码目录>/kernel/entry.S，Entry(system_call)的下一行。

什么是errno：
为防止和正常的返回值混淆，系统调用并不直接返回错误码，而是将错误码放入一个名为errno的全局变量中。如果一个系统调用失败，你可以读出errno的值来确定问题所在。
errno不同数值所代表的错误消息定义在errno.h中，你也可以通过命令"man 3 errno"来察看它们。
需要注意的是，errno的值只在函数发生错误时设置，如果函数不发生错误，errno的值就无定义，并不会被置为0。另外，在处理errno前最好先把它的值存入另一个变量，因为在错误处理过程中，即使像printf()这样的函数出错时也会改变errno的值。

###################################################################################

进程配置有唯一的进程控制块PCB，由proc结构和usr结构组成。
下面依次介绍进程相关的系统调用：
1：fork（）函数          创建一个子进程

	#include /* 提供类型pid_t的定义 */
	#include /* 提供函数的定义 */
	pid_t fork(void);

只看fork的名字，可能难得有几个人可以猜到它是做什么用的。fork系统调用的作用是复制一个进程。当一个进程调用它，完成后就出现两个几乎一模一样的进程，我们也由此得到了一个新进程。据说fork的名字就是来源于这个与叉子的形状颇有几分相似的工作流程。
在Linux 中，创造新进程的方法只有一个，就是我们正在介绍的fork。其他一些库函数，如system()，看起来似乎它们也能创建新的进程，如果能看一下它们的源码就会明白，它们实际上也在内部调用了fork。包括我们在命令行下运行应用程序，新的进程也是由shell调用fork制造出来的。fork有一些很有意思的特征，下面就让我们通过一个小程序来对它有更多的了解。

/* fork_test.c */
#include
#inlcude
main()
{
	pid_t pid;
	
	/*此时仅有一个进程*/
	pid=fork();
	/*此时已经有两个进程在同时运行*/
	if(pid<0)
		printf("error in fork!");
	else if(pid==0)
		printf("I am the child process, my process ID is %d\n",getpid());
	else
		printf("I am the parent process, my process ID is %d\n",getpid());
}

编译并运行：

$gcc fork_test.c -o fork_test
$./fork_test
I am the parent process, my process ID is 1991
I am the child process, my process ID is 1992

看这个程序的时候，头脑中必须首先了解一个概念：在语句pid=fork()之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了，这两个进程的代码部分完全相同，将要执行的下一条语句都是if(pid==0)……。

两个进程中，原先就存在的那个被称作“父进程”，新出现的那个被称作“子进程”。父子进程的区别除了进程标志符（process ID）不同外，变量pid的值也不相同，pid存放的是fork的返回值。fork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值：

1. 在父进程中，fork返回新创建子进程的进程ID；
2. 在子进程中，fork返回0；
3. 如果出现错误，fork返回一个负值；

#include
void exit(int status);

不像fork那么难理解，从exit的名字就能看出，这个系统调用是用来终止一个进程的。无论在程序中的什么位置，只要执行到exit系统调用，进程就会停止剩下的所有操作，清除包括PCB在内的各种数据结构，并终止本进程的运行。请看下面的程序：

/* exit_test1.c */
#include
main()
{
	printf("this process will exit!\n");
	exit(0);
	printf("never be displayed!\n");
}

编译后运行：

$gcc exit_test1.c -o exit_test1
$./exit_test1
this process will exit!

我们可以看到，程序并没有打印后面的"never be displayed!\n"，因为在此之前，在执行到exit(0)时，进程就已经终止了。
exit 系统调用带有一个整数类型的参数status，我们可以利用这个参数传递进程结束时的状态，比如说，该进程是正常结束的，还是出现某种意外而结束的，一般来说，0表示没有意外的正常结束；其他的数值表示出现了错误，进程非正常结束。我们在实际编程时，可以用wait系统调用接收子进程的返回值，从而针对不同的情况进行不同的处理。关于wait的详细情况，我们将在以后的篇幅中进行介绍。

 

###################################################################

作为系统调用而言，_exit和exit是一对孪生兄弟。
这时随便一个懂得C语言并且头脑清醒的人都会说，_exit和exit没有任何区别，但我们还要讲一下这两者之间的区别，这种区别主要体现在它们在函数库中的定义。_exit在Linux函数库中的原型是：

	#include
	void _exit(int status);

和exit比较一下，exit()函数定义在 stdlib.h中，而_exit()定义在unistd.h中，从名字上看，stdlib.h似乎比unistd.h高级一点，那么，它们之间到底有什么区别呢？让我们先来看流程图，通过下图，我们会对这两个系统调用的执行过程产生一个较为直观的认识。

从图中可以看出，_exit()函数的作用最为简单：直接使进程停止运行，清除其使用的内存空间，并销毁其在内核中的各种数据结构；exit()函数则在这些基础上作了一些包装，在执行退出之前加了若干道工序，也是因为这个原因，有些人认为exit已经不能算是纯粹的系统调用。
exit()函数与_exit()函数最大的区别就在于exit()函数在调用exit系统调用之前要检查文件的打开情况，把文件缓冲区中的内容写回文件，就是图中的“清理I/O缓冲”一项。
在Linux 的标准函数库中，有一套称作“高级I/O”的函数，我们熟知的printf()、fopen()、fread()、fwrite()都在此列，它们也被称作“缓冲I/O（buffered I/O）”，其特征是对应每一个打开的文件，在内存中都有一片缓冲区，每次读文件时，会多读出若干条记录，这样下次读文件时就可以直接从内存的缓冲区中读取，每次写文件的时候，也仅仅是写入内存中的缓冲区，等满足了一定的条件（达到一定数量，或遇到特定字符，如换行符\n和文件结束符EOF），再将缓冲区中的内容一次性写入文件，这样就大大增加了文件读写的速度，但也为我们编程带来了一点点麻烦。如果有一些数据，我们认为已经写入了文件，实际上因为没有满足特定的条件，它们还只是保存在缓冲区内，这时我们用_exit()函数直接将进程关闭，缓冲区中的数据就会丢失，反之，如果想保证数据的完整性，就一定要使用exit()函数。

请看以下例程：

/* exit2.c */
#include
main()
{
	printf("output begin\n");
	printf("content in buffer");
	exit(0);
}

编译并运行：

$gcc exit2.c -o exit2
$./exit2
output begin
content in buffer
/* _exit1.c */
#include
main()
{
	printf("output begin\n");
	printf("content in buffer");
	_exit(0);
}

编译并运行：

$gcc _exit1.c -o _exit1
$./_exit1
output begin

##########################################################

#include  /* 提供类型pid_t的定义 */
#include 
pid_t wait(int *status)
	
进程一旦调用了wait，就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已经变成僵尸的子进程，wait就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个出现为止。
参数status用来保存被收集进程退出时的一些状态，它是一个指向int类型的指针。但如果我们对这个子进程是如何死掉的毫不在意，只想把这个僵尸进程消灭掉，（事实上绝大多数情况下，我们都会这样想），我们就可以设定这个参数为NULL，就象下面这样： 
		pid = wait(NULL);
	
如果成功，wait会返回被收集的子进程的进程ID，如果调用进程没有子进程，调用就会失败，此时wait返回-1，同时errno被置为ECHILD。 

下面就让我们用一个例子来实战应用一下wait调用：
/* wait1.c */
#include 
#include 
#include 
#include 
main()
{
	pid_t pc,pr;
	pc=fork();
	if(pc<0) 		/* 如果出错 */
		printf("error ocurred!\n");
	else if(pc==0){		/* 如果是子进程 */ 
		printf("This is child process with pid of %d\n",getpid());
		sleep(10);	/* 睡眠10秒钟 */
	}
	else{			/* 如果是父进程 */
		pr=wait(NULL);	/* 在这里等待 */
		printf("I catched a child process with pid of %d\n"),pr);
	}		
	exit(0);
}

编译并运行:
$ cc wait1.c -o wait1
$ ./wait1
This is child process with pid of 1508
I catched a child process with pid of 1508
可以明显注意到，在第2行结果打印出来前有10 秒钟的等待时间，这就是我们设定的让子进程睡眠的时间，只有子进程从睡眠中苏醒过来，它才能正常退出，也就才能被父进程捕捉到。其实这里我们不管设定子进程睡眠的时间有多长，父进程都会一直等待下去，读者如果有兴趣的话，可以试着自己修改一下这个数值，看看会出现怎样的结果。 
如果参数status的值不是NULL，wait就会把子进程退出时的状态取出并存入其中，这是一个整数值（int），指出了子进程是正常退出还是被非正常结束的（一个进程也可以被其他进程用信号结束，我们将在以后的文章中介绍），以及正常结束时的返回值，或被哪一个信号结束的等信息。由于这些信息被存放在一个整数的不同二进制位中，所以用常规的方法读取会非常麻烦，人们就设计了一套专门的宏（macro）来完成这项工作，下面我们来学习一下其中最常用的两个：
1，WIFEXITED(status) 这个宏用来指出子进程是否为正常退出的，如果是，它会返回一个非零值。
（请注意，虽然名字一样，这里的参数status并不同于wait唯一的参数--指向整数的指针status，而是那个指针所指向的整数，切记不要搞混了。）
2， WEXITSTATUS(status) 当WIFEXITED返回非零值时，我们可以用这个宏来提取子进程的返回值，如果子进程调用exit(5)退出，WEXITSTATUS(status) 就会返回5；如果子进程调用exit(7)，WEXITSTATUS(status)就会返回7。请注意，如果进程不是正常退出的，也就是说， WIFEXITED返回0，这个值就毫无意义。
下面通过例子来实战一下我们刚刚学到的内容：
/* wait2.c */
#include 
#include 
#include 
main()
{
	int status;
	pid_t pc,pr;
	pc=fork();
	if(pc<0)	/* 如果出错 */
		printf("error ocurred!\n");
	else if(pc==0){	/* 子进程 */
		printf("This is child process with pid of %d.\n",getpid());
		exit(3);	/* 子进程返回3 */
	}
	else{		/* 父进程 */
		pr=wait(&status);
		if(WIFEXITED(status)){	/* 如果WIFEXITED返回非零值 */
			printf("the child process %d exit normally.\n",pr);
			printf("the return code is %d.\n",WEXITSTATUS(status));
		}else			/* 如果WIFEXITED返回零 */
			printf("the child process %d exit abnormally.\n",pr);
	}
}
编译并运行: 
$ cc wait2.c -o wait2
$ ./wait2
This is child process with pid of 1538.
the child process 1538 exit normally.
the return code is 3.
父进程准确捕捉到了子进程的返回值3，并把它打印了出来。 
当然，处理进程退出状态的宏并不止这两个，但它们当中的绝大部分在平时的编程中很少用到，就也不在这里浪费篇幅介绍了，有兴趣的读者可以自己参阅Linux man pages去了解它们的用法。
有时候，父进程要求子进程的运算结果进行下一步的运算，或者子进程的功能是为父进程提供了下一步执行的先决条件（如：子进程建立文件，而父进程写入数据），此时父进程就必须在某一个位置停下来，等待子进程运行结束，而如果父进程不等待而直接执行下去的话，可以想见，会出现极大的混乱。这种情况称为进程之间的同步，更准确地说，这是进程同步的一种特例。进程同步就是要协调好2个以上的进程，使之以安排好地次序依次执行。解决进程同步问题有更通用的方法，我们将在以后介绍，但对于我们假设的这种情况，则完全可以用wait系统调用简单的予以解决。请看下面这段程序：
#include 
#include 
main()
{
	pid_t pc, pr;
	int status;
	
	pc=fork();
	
            
            

              

			  
			  
				


				
			  
              阅读(1189) | 评论(0) | 转发(0) |
			                

            
            
            

              
0
              
上一篇：Linux开机的基本的流程 (转)
              
下一篇：IT名企面试题
    
            
            
          
          		  
        
      
      

		
给主人留下些什么吧！~~
				
				
		

        		
		
        

          
评论热议
		  		 
        

          
 请登录后评论。
            
登录 注册
          
        
       
		
        
        

            
        
      
    
  
  






  
  

    
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册
      
Copyright  2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有 
      
感谢所有关心和支持过ChinaUnix的朋友们
        
16024965号-6