11.html

网上一个牛人整理的关于linux内核编译

}<p>
&nbsp;&nbsp;&nbsp; 下面是一个实际应用的例子：<p>
#defineMAX_PRINTERS5<br>
printer_usage()<br>
{<br>
int x;<br>
for(x=0;x&lt;MAX_PRINTERS;x++)<br>
printf(&quot;Printer%d:%d\n\r&quot;,x,get_sem_val(sid,x));<br>
}<p>
&nbsp;&nbsp;&nbsp; 下面的程序可以用来初始化一个新的信号量值：<p>
void init_semaphore(int sid,int semnum,int initval)<br>
{<br>
union semunsemopts;<br>
semopts.val=initval;<br>
semctl(sid,semnum,SETVAL,semopts);<br>
}<p>
&nbsp;&nbsp;&nbsp; 注意系统调用semctl中的最后一个参数是一个联合类型的副本，而不是一个指向联合类型的指针。<p>
<p>
<p>



<center><A HREF="#Content">[目录]</A></center>
<hr><br><A NAME="I255" ID="I255"></A><center><b><font size=+2>共享内存</font></b></center><br>
&nbsp;&nbsp;&nbsp; 共享内存就是由几个进程共享一段内存区域。这可以说是最快的IPC形式，因为它无须任何的中间操作（例如，管道、消息队列等）。它只是把内存段直接映射到调用进程的地址空间中。这样的内存段可以是由一个进程创建的，然后其他的进程可以读写此内存段。<p>
&nbsp;&nbsp;&nbsp; 每个系统的共享内存段在系统内核中也保持着一个内部的数据结构shmid_ds。此数据结构是在linux/shm.h中定义的，如下所示：<p>
/* One shmid data structure for each shared memory segment in the system. */<br>
struct shmid_ds {<br>
struct ipc_perm shm_perm; /* operation perms */<br>
int shm_segsz; /* size of segment (bytes) */<br>
time_t shm_atime; /* last attach time */<br>
time_t shm_dtime; /* last detach time */<br>
time_t shm_ctime; /* last change time */<br>
unsigned short shm_cpid; /* pid of creator */<br>
unsigned short shm_lpid; /* pid of last operator */<br>
short shm_nattch; /* no. of current attaches */<br>
/* the following are private */<br>
unsigned short shm_npages; /* size of segment (pages) */<br>
unsigned long *shm_pages; /* array of ptrs to frames -&gt; SHMMAX */<br>
struct vm_area_struct *attaches; /* descriptors for attaches */<br>
};<p>
shm_perm 是数据结构ipc_perm的一个实例。这里保存的是内存段的存取权限，和其他的有关内存段创建者的信息。<br>
shm_segsz 内存段的字节大小。<br>
shm_atime 最后一个进程存取内存段的时间。<br>
shm_dtime 最后一个进程离开内存段的时间。<br>
shm_ctime 内存段最后改动的时间。<br>
shm_cpid 内存段创建进程的P I D。<br>
shm_lpid 最后一个使用内存段的进程的P I D。<br>
shm_nattch 当前使用内存段的进程总数。<br>



<center><A HREF="#Content">[目录]</A></center>
<hr><br><A NAME="I256" ID="I256"></A><center><b><font size=+2>shmget()</font></b></center><br>
系统调用：shmget();<br>
原型：int shmget(key_t key,int size,int shmflg);<br>
返回值：如果成功，返回共享内存段标识符。如果失败，则返回-1：errno=EINVAL(无效的内存段大小)<br>
EEXIST(内存段已经存在，无法创建)<br>
EIDRM(内存段已经被删除)<br>
ENOENT(内存段不存在)<br>
EACCES(权限不够)<br>
ENOMEM(没有足够的内存来创建内存段)<p>
&nbsp;&nbsp;&nbsp; 系统调用shmget()中的第一个参数是关键字值（它是用系统调用ftok()返回的）。其他的操作都要依据shmflg中的命令进行。<br>
&nbsp;&nbsp;&nbsp; &middot;IPC_CREAT如果系统内核中没有共享的内存段，则创建一个共享的内存段。<br>
&nbsp;&nbsp;&nbsp; &middot;IPC_EXCL当和IPC_CREAT一同使用时，如果共享内存段已经存在，则调用失败。<br>
&nbsp;&nbsp;&nbsp; 当IPC_CREAT单独使用时，系统调用shmget()要么返回一个新创建的共享内存段的标识符，要么返回一个已经存在的共享内存段的关键字值。如果IPC_EXCL和IPC_CREAT一同使用，则要么系统调用新创建一个共享的内存段，要么返回一个错误值-1。IPC_EXCL单独使用没有意义。<p>
&nbsp;&nbsp;&nbsp; 下面是一个定位和创建共享内存段的程序：<p>
int open_segment(key_t keyval,int segsize)<br>
{<br>
int shmid;<br>
if((shmid=shmget(keyval,segsize,IPC_CREAT|0660))==-1)<br>
{<br>
return(-1);<br>
}<br>
return(shmid);<br>
}<p>
&nbsp;&nbsp;&nbsp; 一旦一个进程拥有了一个给定的内存段的有效IPC标识符，它的下一步就是将共享的内存段映射到自己的地址空间中。<p>
<p>
<p>
<p>



<center><A HREF="#Content">[目录]</A></center>
<hr><br><A NAME="I257" ID="I257"></A><center><b><font size=+2>shmat()</font></b></center><br>
系统调用： shmat();<br>
原型：int shmat ( int shmid, char *shmaddr, int shmflg);<br>
返回值：如果成功，则返回共享内存段连接到进程中的地址。如果失败，则返回- 1：errno = EINVAL (无效的IPC ID 值或者无效的地址)<br>
ENOMEM (没有足够的内存)<br>
EACCES (存取权限不够)<p>
&nbsp;&nbsp;&nbsp; 如果参数a d d r的值为0，那么系统内核则试图找出一个没有映射的内存区域。我们推荐使用这种方法。你可以指定一个地址，但这通常是为了加快对硬件设备的存取，或者解决和其他程序的冲突。<br>
&nbsp;&nbsp;&nbsp; 下面的程序中的调用参数是一个内存段的I P C标识符，返回内存段连接的地址：<p>
char *attach_segment(int shmid)<br>
{<br>
return(shmat(shmid, 0, 0));<br>
}<p>
&nbsp;&nbsp;&nbsp; 一旦内存段正确地连接到进程以后，进程中就有了一个指向该内存段的指针。这样，以后就可以使用指针来读取此内存段了。但一定要注意不能丢失该指针的初值。<p>
<p>
<p>



<center><A HREF="#Content">[目录]</A></center>
<hr><br><A NAME="I258" ID="I258"></A><center><b><font size=+2>shmctl()</font></b></center><br>
系统调用：shmctl ( ) ;<br>
原型：int shmctl( int shmqid, int cmd, struct shmid_ds *buf );<br>
返回值： 0 ，如果成功。<br>
-1，如果失败：errno = EACCES (没有读的权限，同时命令是IPC_STAT)<br>
EFAULT(buf指向的地址无效，同时命令是IPC_SET和IPC_STAT )<br>
EIDRM (内存段被移走)<br>
EINVAL (shmqid 无效)<br>
EPERM (使用IPC_SET 或者IPC_RMID 命令，但调用进程没有写的权限)<br>
IPC_STAT 读取一个内存段的数据结构shmid_ds，并将它存储在buf参数指向的地址中。<br>
IPC_SET 设置内存段的数据结构shmid_ds中的元素ipc_perm的值。从参数buf中得到要设置的值。<br>
IPC_RMID 标志内存段为移走。<p>
&nbsp;&nbsp;&nbsp; 命令IPC_RMID并不真正从系统内核中移走共享的内存段，而是把内存段标记为可移除。进程调用系统调用shmdt(）脱离一个共享的内存段。<p>
<p>
<p>



<center><A HREF="#Content">[目录]</A></center>
<hr><br><A NAME="I259" ID="I259"></A><center><b><font size=+2>shmdt()</font></b></center><br>
系统调用：shmdt();<br>
调用原型：int shmdt ( char *shmaddr );<br>
返回值：如果失败，则返回- 1：errno = EINVAL (无效的连接地址)<p>
&nbsp;&nbsp;&nbsp; 当一个进程不在需要共享的内存段时，它将会把内存段从其地址空间中脱离。但这不等于将共享内存段从系统内核中移走。当进程脱离成功后，数据结构shmid_ds中元素shm_nattch将减1。当此数值减为0以后，系统内核将物理上把内存段从系统内核中移走。<p>
<p>
<p>



<center><A HREF="#Content">[目录]</A></center>
<hr><br><A NAME="I260" ID="I260"></A><center><b><font size=+2>线程</font></b></center><br>
&nbsp;&nbsp;&nbsp; 线程通常叫做轻型的进程。虽然这个叫法有些简单化，但这有利于了解线程的概念。因为线程和进程比起来很小，所以相对来说，线程花费更少的CPU资源。进程往往需要它们自己的资源，但线程之间可以共享资源，所以线程更加节省内存。Mach的线程使得程序员可以编写并发运行的程序，而这些程序既可以运行在单处理器的机器上，也可以运行在多处理器的机器中。另外，在单处理器环境中，当应用程序执行容易引起阻塞和延迟的操作时，线程可以提高效率。<p>
&nbsp;&nbsp;&nbsp; 用子函数pthread_create创建一个新的线程。它有四个参数：一个用来保存线程的线程变量、一个线程属性、当线程执行时要调用的函数和一个此函数的参数。例如：<br>
pthread_ta_thread ;<br>
pthread_attr_ta_thread_attribute ;<br>
void thread_function(void *argument);<br>
char * some_argument;<br>
pthread_create( &amp;a_thread, a_thread_attribute, (void *)&amp;thread_function,<br>
(void *) &amp;some_argument);<br>
&nbsp;&nbsp;&nbsp; 线程属性只指明了需要使用的最小的堆栈大小。在以后的程序中，线程的属性可以指定其他的值，但现在大部分的程序可以使用缺省值。不像UNIX系统中使用fork系统调用创建的进程，它们和它们的父进程使用同一个执行点，线程使用在pthread_create中的参数指明要开始执行的函数。<p>
&nbsp;&nbsp;&nbsp; 现在我们可以编制第一个程序了。我们编制一个多线程的应用程序，在标准输出中打印“Hello Wo r l d”。首先我们需要两个线程变量，一个新线程开始执行时可以调用的函数。我们还需要指明每一个线程应该打印的信息。一个做法是把要打印的字符串分开，给每一个线程一个字符串作为开始的参数。请看下面的代码：<br>
void print_message_function( void *ptr );<br>
main( )<br>
{<br>
pthread_t thread1, thread2;<br>
char *message1 = &quot;Hello&quot;;<br>
char *message2 = &quot;Wo r l d &quot; ;<br>
pthread_create( &amp;thread1, pthread_attr_default,<br>
(void*)&amp;print_message_function, (void*) message1);<br>
pthread_create(&amp;thread2, pthread_attr_default,<br>
(void*)&amp;print_message_function, (void*) message2);<br>
exit( 0 ) ;<br>
}<br>
void print_message_function( void *ptr )<br>
{<br>
char *message;<br>
message = (char *) ptr;<br>
printf(&quot;%s &quot;, message);<br>
}<p>
&nbsp;&nbsp;&nbsp; 程序通过调用pthread_create创建第一个线程，并将“Hello”作为它的启动参数。第二个线程的参数是“World”。当第一个线程开始执行时，它使用参数“Hello”执行函数print_message_function。它在标准输出中打印“Hello”，然后结束对函数的调用。线程当离开它的初始化函数时就将终止，所以第一个线程在打印完“Hello”后终止。当第二个线程执行时，它打印“World”然后终止。但这个程序有两个主要的缺陷。<br>
&nbsp;&nbsp;&nbsp; 首先也是最重要的是线程是同时执行的。这样就无法保证第一个线程先执行打印语句。所以你很可能在屏幕上看到“World Hello”，而不是“Hello World”。请注意对exit的调用是父线程在主程序中使用的。这样，如果父线程在两个子线程调用打印语句之前调用exit，那么将不会有任何的打印输出。这是因为exit函数将会退出进程，同时释放任务，所以结束了所有的线程。任何线程(不论是父线程或者子线程)调用exit 都会终止所有其他线程。如果希望线程分别终止，可以使用pthread_exit函数。<br>
我们可以使用一个办法弥补此缺陷。我们可以在父线程中插入一个延迟程序，给子线程足够的时间完成打印的调用。同样，在调用第二个之前也插入一个延迟程序保证第一个线程在第二个线程执行之前完成任务。<p>
void print_message_function( void *ptr );<br>
main ( )<br>
{<br>
pthread_t thread1, thread2;<br>
char *message1 = &quot;Hello”;<br>
char *message2 = &quot;Wo r l d &quot; ;<br>
pthread_create( &amp;thread1, pthread_attr_default,<br>
(void *) &amp;print_message_function, (void *) message1);<br>
sleep (10) ;<br>
pthread_create(&amp;thread2, pthread_attr_default,<br>
(void *) &amp;print_message_function, (void *) message2);<br>
sleep ( 10 ) ;<br>
exit (0) ;<br>
}<br>
void print_message_function( void *ptr )<br>
{<br>
char *message;<br>
message = (char *) ptr;<br>
printf(&quot;%s&quot;, message);<br>
pthread_exit(0) ;<br>
}<p>
&nbsp;&nbsp;&nbsp; 这样是否达到了我们的要求了呢？不尽如此，因为依靠时间的延迟执行同步是不可靠的。这里遇到的情形和一个分布程序和共享资源的情形一样。共享的资源是标准的输出设备，分布计算的程序是三个线程。<br>
其实这里还有另外一个错误。函数sleep和函数e x i t一样和进程有关。当线程调用sleep时，整个的进程都处于睡眠状态，也就是说，所有的三个线程都进入睡眠状态。这样我们实际上没有解决任何的问题。希望使一个线程睡眠的函数是pthread_delay_np。例如让一个线程睡眠2秒钟，用如下程序：<p>
struct timespec delay;<br>
delay.tv_sec = 2;<br>
delay.tv_nsec = 0;<br>
pthread_delay_np( &amp;delay );<br>
}<br>



<center><A HREF="#Content">[目录]</A></center>
<hr><br><A NAME="I261" ID="I261"></A><center><b><font size=+2>线程同步</font></b></center><br>
POSIX提供两种线程同步的方法，mutex和条件变量。mutex是一种简单的加锁的方法来控制对共享资源的存取。我们可以创建一个读/写程序，它们共用一个共享缓冲区，使用mutex来控制对缓冲区的存取。<br>
void reader_function(void);<br>
void writer_function(void);<br>
char buf f e r ;<br>
int buffer_has_item = 0;<br>
pthread_mutex_t mutex;<br>
struct timespec delay;<br>
main( )<br>
{<br>
pthread_t reader;<br>
delay.tv_sec = 2;<br>
delay.tv_nsec = 0;<br>
pthread_mutex_init(&amp;mutex, pthread_mutexattr_default);<br>
pthread_create( &amp;reader, pthread_attr_default, (void*)&amp;reader_function,<br>
N U L L ) ;<br>
writer_function( )<br>
void writer_function(void)<br>
{<br>
while( 1 )<br>
{<br>
pthread_mutex_lock( &amp;mutex );<br>
if ( buffer_has_item == 0 )<br>
{<br>
buffer = make_new_item();<br>
buffer_has_item = 1;<br>
}<br>
pthread_mutex_unlock( &amp;mutex );<br>
pthread_delay_np( &amp;delay );<br>
}<br>
}<br>
void reader_function(void)<br>
{<br>
while( 1 )<br>
{<br>
pthread_mutex_lock( &amp;mutex );<br>
if ( buffer_has_item == 1)<br>
{<br>
consume_item( buffer );<br>
buffer_has_item = 0;<br>
}<br>
pthread_mutex_unlock( &amp;mutex );<br>
pthread_delay_np( &amp;delay );<br>
}<br>
}<br>
在上面的程序中，我们假定缓冲区只能保存一条信息，这样缓冲区只有两个状态，有一条信息或者没有信息。使用延迟是为了避免一个线程永远占有mutex。<br>
但mutex的缺点在于它只有两个状态，锁定和非锁定。POSIX的条件变量通过允许线程阻塞和等待另一个线程的信号方法，从而弥补了mutex的不足。当接受到一个信号时，阻塞线程将会被唤起，并试图获得相关的mutex的锁。<p>
<p>
<p>



<center><A HREF="#Content">[目录]</A></center>
<hr><br><A NAME="I262" ID="I262"></A><center><b><font size=+2>使用信号量协调程序</font></b></center><br>
我们可以使用信号量重新看一下上面的读/写程序。涉及信号量的操作是semaphore_up、semaphore_down、semaphore_init、semaphore_destroy和semaphore_decrement。所有这些操作都只有一个参数，一个指向信号量目标的指针。<br>
void reader_function(void);<br>
void writer_function(void);<br>
char buffer ;<br>
Semaphore writers_turn;<br>
Semaphore readers_turn;<br>
main( )<br>
{<br>
pthread_t reader;<br>