教员布置的操作系统的第一个大作业，其中有一些知识相对而言比较重要，包括一些操作过程都具有重复实验的价值；所以写一个blog记录一下，方便一下以后重复这个大实验或是复现。
分为三个部分：实验环境的配置、实验5的实现、实验6的实现。
实验环境的配置：
KylinOS应该是可以实现的，实现的原理同我下面所叙述的过程。
资源下载：
我这里采取的实验环境是VMware上的Ubuntu 20.04 64bit，采取的子环境是从助教学长那里下载的rar压缩包，在windows的环境下解压后会有一个xxx.tar.gz的压缩包文件以及一个gcc，g++的3.4版本的安装版，由于这个实验在3.4环境下做是比较合适的，所以我们需要将我们的gcc，g++的版本调整至3.4；
环境更改，gcc多版本共存
dpkg表示“Debian Packager”，是Debian开发的套件管理系统，
在对应的gcc，g++的那个文件夹里面，运行如下的指令：
sudo dpkg --force-depends -i gcc-3.4-base_3.4.6-6ubuntu3_amd64.deb sudo dpkg --force-depends -i gcc-3.4_3.4.6-6ubuntu3_amd64.deb sudo dpkg --force-depends -i cpp-3.4_3.4.6-6ubuntu3_amd64.deb sudo dpkg --force-depends -i g++-3.4_3.4.6-6ubuntu3_amd64.deb sudo dpkg --force-depends -i libstdc++6-dev_3.4.6-6ubuntu3_amd64.deb
接着可以用
gcc --version g++ --version
来查看自己所安装的版本是不是正确的版本，此时应该显示的是3.4
环境配置并make
我们需要解压xxx.tar.gz压缩包（在linux环境下），然后对于在其解压后的linux-0.11的文件夹内进行make。
大概率此时的make是会显示各种错误的，所以我们需要配置一些环境。
sudo apt-get install bin86 sudo apt-get install gcc-multilib sudo apt-get install build-essential sudo apt-get install bochs bochs-x bochs-sdl sudo dpkg --add-architecture i386 sudo apt-get update sudo apt install libsm6:i386 sudo apt install libx11-6:i386 sudo apt install libxpm4:i386
按顺序尝试以上的命令进行配置环境，如果还是不成功make就试试非i386版本的安装。（其实以上的命令就是根据显示的出的make中的error来配置修改的）
最后make成功之后，会显示sync的结果，尝试./run与./dbg-asm测试，成功之后则说明之前的步骤都是没问题的。
实验5的实现：
实践目标
实验五的主要实现部分是sem.c，实质就是一个信号量的交换。
这个地方我在实现的时候关于系统调用的函数写错了，在大佬的帮助下才改正的，卡了很久。
实验5的实践目标有两个：
1. 在Linux0.11（没有实现信号量）上实现信号量有关的如下系统调用：
1 sem_t *sem_open(const char *name, unsigned int value); 2 int sem_wait(sem_t *sem); 3 int sem_post(sem_t *sem); 4 int sem_unlink(const char *name);
第一个函数的功能是创建一个名字为name的信号量或者打开名字为name的信号量；
第二个函数的功能是信号量的P操作：将信号量计数器减一，表示“申请占用一个资源”；
第三个函数的功能是信号量的V操作：将信号量计数器加一，表示“释放信号量”；
第四个函数的功能是删除名字为name的信号量；
2. 利用上面实现的信号量系统调用，编写bochs上的测试程序"pc.c"来模拟生产者-消费者之间的同步，类似于握手的操作。
根据题例，建立1个生产者进程(producer)，5个消费者进程(consumer)；用文件建立一个共享缓存区；
生产者依次向缓存区写入整数0,1,2,...,499，每个消费者进程从缓存区中读取100个数，对于其读取的每一个数字均需要打印到stdout上。（须注意，缓存区文件最多只能保存10个数。）
实现信号量有关的系统调用
首先要先在oslab/linux-0.11/include/linux文件夹下添加sem.h头文件，需要实现的内容很简单，就是实现对于信号量的结构定义，此处我们借助了sched.h中的tss的队列结构，节省了一些代码量，内容如下：
#ifndef _SEM_H_
#define _SEM_H_
#include<linux/sched.h>
typedef struct semaphore_t
{
char name[20];
int value;
struct task_struct *queue;
} sem_t;
#endif
最主要的是sem.c文件的编写，此处我们选择在oslab/linux-0.11/kernel中编写sem.c（其实在别的地方也一样，都要修改对应位置的Makefile）
关于sem.c的实现：
#include <unistd.h>
#include <string.h>
#include <linux/sem.h>
#include <asm/segment.h>
#include <asm/system.h>
#include <linux/kernel.h>
#define SEM_LIST_LENGTH 5 //信号量最多多少，原题为10，此处设为5
sem_t sem_list[SEM_LIST_LENGTH] = {
{"\0",0,NULL}, {"\0",0,NULL}, {"\0",0,NULL}, {"\0",0,NULL}, {"\0",0,NULL}
};
sem_t *sys_sem_open(const char *name, unsigned int value)
{
if(name == NULL)
{
printk("name == NULL\n"); //name not initial
return NULL;
}
char nbuf[20];
int i = 0;
for(i = 0; i < 20; i++)
nbuf[i] = get_fs_byte(name + i); //from asm/segment.h
//从(name+i)中取出一个char
sem_t * result = NULL;
for(i = 0; i < SEM_LIST_LENGTH; i++) //遍历查找
{
if(sem_list[i].name[0] == '\0')
break;
if(!strcmp(sem_list[i].name, nbuf))
{
result = &sem_list[i];
printk("Found sem %s.\n", result->name);
return result; //找到了，返回
}
}
// 没找到，新创建一个
strcpy(sem_list[i].name, nbuf);
sem_list[i].value = value;
sem_list[i].queue = NULL;
result = &sem_list[i];
printk("Have created a sem %s, value = %d.\n", result->name, result->value);
return result;
}
//P operation
//0 succeed, 1 fail
int sys_sem_wait(sem_t * sem)
{
if(sem == NULL || sem < sem_list || sem > sem_list + SEM_LIST_LENGTH)
{
printk("P(sem) error!\n"); //非有效地址
return -1;
}
cli(); //close trap
while(sem->value <= 0)
sleep_on(&(sem->queue));
sem->value--;
sti(); //open trap
return 0;
}
//V operation
//0 succeed, 1 fail
int sys_sem_post(sem_t * sem)
{
if(sem == NULL || sem < sem_list || sem > sem_list + SEM_LIST_LENGTH)
{
printk("V(sem) error!\n");
return -1;
}
cli(); //close trap
sem->value++;
if(sem->value <= 1) //ATTENTION! 前面加1了这里应是和1比较
wake_up(&(sem->queue));
sti();
return 0;
}
//delete sem(name)
//0 succeed, 1 fail
int sys_sem_unlink(const char *name)
{
if(name == NULL)
return -1;
char nbuf[20];
int i = 0;
for(i = 0; i < 20; i++)
{
nbuf[i] = get_fs_byte(name + i); //同上
if(nbuf[i] == '\0') break;
}
i = 0;
for(i = 0; i < SEM_LIST_LENGTH; i++)
{
if(strcmp(sem_list[i].name, nbuf))
{
sem_list[i].name[0] == '\0';
sem_list[i].value = 0;
sem_list[i].queue = NULL;
} //operate
}
if(i == SEM_LIST_LENGTH) return -1; //Not Found
return 0; //succeed
}
在编写完这一部分的程序之后，我们记得要去修改对应文件夹里的Makefile，比如我们这里是在kernel/文件夹下修改的，那么我们就要对应地修改kernel/文件夹下的Makefile，增添如下信息：
...
OBJS = sched.o system_call.o traps.o asm.o fork.o \
panic.o printk.o vsprintf.o sys.o exit.o \
signal.o mktime.o sem.o
...
### Dependencies:
sem.s sem.o: sem.c ../include/linux/kernel.h ../include/unistd.h \
../include/linux/sem.h ../include/linux/sched.h
...
然后为了实现对应的系统调用的完整呈现，我们需要修改linux-0.11/include/unistd.h和linux-0.11/include/linux/sys.h，产生完整的系统调用。
对于unistd.h的修改：
#define __NR_sem_open 72 #define __NR_sem_wait 73 #define __NR_sem_post 74 #define __NR_sem_unlink 75
对于sys.h的修改：
extern int sys_sem_open(); extern int sys_sem_wait(); extern int sys_sem_post(); extern int sys_sem_unlink(); sys_call_table[]加上 , sys_sem_open, sys_sem_wait, sys_sem_post, sys_sem_unlink...
修改系统调用的总数，在kernel/system_call.s中修改：
nr_system_calls = 76
实现完上述修改后，在linux-0.11/下进行make clean并make，出现sync之后则表示make成功，可以进行下一步的操作了。
实现bochs中的生产者、消费者的调用
为了方便代码的编写，我们可以先将bochs挂载到我们编写代码的环境下面，在oslab/的文件夹下采用命令：
sudo ./mount-hdc
然后在hdc/usr/root文件夹下编写对应的程序，此处我们把他命名为pc.c程序：
第一个版本是我自己编写的pc.c：
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <sys/types.h>
#include <sys/wait.h>
#define M 530
#define N 5 /*消费者进程数*/
#define BUFSIZE 10
int main()
{
sem_t *empty, *full, *mutex;
int fd, i, j, k, child, data;
pid_t pid;
int buf_out = 0; //pos out
int buf_in = 0; //pos in
empty = sem_open("empty", O_CREAT | O_EXCL, 0644, BUFSIZE);
full = sem_open("full", O_CREAT | O_EXCL, 0644, 0);
mutex = sem_open("mutex", O_CREAT | O_EXCL, 0644, 1);
fd = open("buffer.txt", O_CREAT | O_TRUNC | O_RDWR,0666);
lseek(fd,BUFSIZE*sizeof(int),SEEK_SET);
write(fd,(char *)&buf_out,sizeof(int));
if(!(pid = fork())) /*Producer*/
{
printf("Producer pid = %d\n", getpid());
for (i = 0 ; i < M; i++)
{
sem_wait(empty);
sem_wait(mutex);
/*写入一个字符*/
lseek(fd, buf_in*sizeof(int), SEEK_SET);
write(fd,(char *)&i,sizeof(int));
buf_in = (buf_in + 1) % BUFSIZE;
sem_post(mutex);
sem_post(full); /*唤醒消费者*/
}
printf("Producer end.\n");
fflush(stdout);
return 0;
}
else if(pid < 0)
{
perror("Fail to fork!\n");
return -1;
}
/*Consumer*/
for( j = 0; j < N ; j++ )
{
if((pid=fork())==0)
{
for( k = 0; k < M/N; k++ )
{
sem_wait(full);/*一开始为0会阻塞此处*/
sem_wait(mutex);
lseek(fd,BUFSIZE*sizeof(int),SEEK_SET);
read(fd,(char *)&buf_out,sizeof(int));
/*读取数据*/
lseek(fd,buf_out*sizeof(int),SEEK_SET);
read(fd,(char *)&data,sizeof(int));
buf_out = (buf_out + 1) % BUFSIZE;
lseek(fd,BUFSIZE*sizeof(int),SEEK_SET);
write(fd,(char *)&buf_out,sizeof(int));
sem_post(mutex);
sem_post(empty);/*唤醒生产者*/
/*Consume*/
printf("%d: %d\n",getpid(),data);
fflush(stdout);
}
printf("child-%d: pid = %d end.\n", j, getpid());
return 0;
}
else if(pid<0)
{
perror("Fail to fork!\n");
return -1;
}
}
child = N + 1;
while(child--)
wait(NULL);
/*释放信号量*/
sem_unlink("full");
sem_unlink("empty");
sem_unlink("mutex");
/*释放资源*/
close(fd);
return 0;
}
第二个版本是大佬编写的pc.c：
#define __LIBRARY__
#include <unistd.h>
#include <linux/sem.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/sched.h>
_syscall2(sem_t *, sem_open, const char *, name, unsigned int, value)
_syscall1(int, sem_wait, sem_t *, sem)
_syscall1(int, sem_post, sem_t *, sem)
_syscall1(int, sem_unlink, const char *, name)
sem_t *mutex, *fill, *empty;
const int product_num = 12;
const int buffer = 4;
const int consumer_num = 2;
int product_finished = 0;
int item_consumed = 0;
int main()
{
int pid;
int i;
mutex = sem_open("mutex", 1);
fill = sem_open("fill", 0);
empty = sem_open("empty", buffer);
if (mutex == NULL) {
printf("null\n");
return 0;
}
if ((pid = fork()))
{
printf("pid: %d, producer start\n", pid);
fflush(stdout);
while(product_finished <= product_num)
{
sem_wait(empty);
sem_wait(mutex);
printf("pid: %d, produced item %d\n", pid, product_finished);
fflush(stdout);
product_finished++;
sem_post(fill);
sem_post(mutex);
}
}
else
{ /* consumer */
i = consumer_num;
while(i--)
{
if (!(pid = fork()))
{
pid = getpid();
printf("pid: %d, consumer start\n", pid);
fflush(stdout);
while(1)
{
sem_wait(fill);
sem_wait(mutex);
printf("pid: %d, consumed item %d\n", pid, item_consumed);
fflush(stdout);
item_consumed++;
sem_post(empty);
sem_post(mutex);
if (item_consumed == product_num)
return 0;
}
}
}
}
return 0;
}
View Code
之后还要修改hdc中的unistd.h，要将这个的unistd.h修改的和linux-0.11下的一致。
修改完之后，我们在oslab文件夹下运行：sudo umount hdc取消hdc的挂载。
测试
最后我们在bochs下运行./run，测试一下信号量的实现过程，在运行之前要对之前的pc.c用gcc编译一下再运行，运行结果如下所示：
经过以上的操作，我们就把信号量的实现完成了，接下来我们就要正式开始实验6的任务工作了。
实验6的实现：
实践目标
在开始之前，我们仍然是要先明确我们的实践目标，这个实践的目标有两个：(1)用Bochs调试工具跟踪Linux 0.11的地址转换过程；(2)实现基于共享物理页框的进程间内存共享。
其中第一个实践的目标比较基于理论上的一些知识，需要我们对于概念的理解有一定的要求；第二个实践的目标与实践5有一些相像的地方，均需要通过实现相应的函数来达到进程间内存共享的目的。
跟踪地址转换过程-获得虚拟地址
在之前的环境中是已经配置好了我们的过程所需要的环境的，接下来我们直接跟着实践所描述的步骤进行操作(这个过程实践所指导的就已经非常详细了，以下我们将重视演示过程)：
要在Linux 0.11上编写一个test.c程序，要跟踪的地址就是这个程序中的地址：
#include<stdio.h>
int i = 0x12345678;
int main(void)
{
printf("The logical address of i is 0x%08x", &i);
fflush(stdout);
wihle(i); //控制程序加载
return 0;
}
要记得用./dbg-asm加载，以方便我们对于bochs进行调试运行；
此时对其进行编译执行之后会呈现的内容是"The logical address of i is 0x00003004"；
此时打印的是i的逻辑地址，又因为while(i);语句控制了test程序一直运行，不会主动退出，此时我们可以利用此来进行调试命令查看。
在非内核的运行状态下时(如果是内核，就在命令行窗口里面接着使用c+crtl c的组合操作)，此后显示的是000f:00000062的jz指令，我们需要跟踪到的指令是cmp指令，所以我们采用n命令单步执行直到cmp指令：
接下来使用“u/7”命令，显示从当前位置开始的七条指令的反汇编代码，然后是要开始寻找和逻辑地址DS:0x3004对应的物理地址，开始跟踪地址转换过程，先采用sreg看一下各个寄存器的信息：
LDTR此时，s=0x68，表示的是当前进程的LDT存在GDT的13号位置上（二进制表示后，低三位为控制符），此时我们通过GDTR知道GDT的起始位置在0x54b8（不同机器此处可能不同），每一项占64位（即8个字节），所以要查找的物理地址是0x54b8+13*8，用命令"xp/2w 0x5cb8+13*8"可以查看此处的内容：
对应的数0xc2d00068 0x000082f9中的标红加粗数字组合以后为“0x00f9c2d0”，这里是根据了x86的格式转换，具体内容请查看x86文档，此处注意是高8字节在右，低8字节在左。
接下来我们就可以通过"xp/8w 0x00f9c2d0"查看LDT表的前四项内容：
此时DS的索引值为0x17，表示的是LDT中的第16个字节开始的内容，LDT每项占8个字节，所以第三项"0x00003fff 0x10c0f300"即为所要查找的内容，以同样的方法可以得到DS段在虚拟内存空间中的起始地址，加上偏移量0x3004可得DS:0x3004对应的虚拟地址：0x10000000 + 0x3004 = 0x10003004，可知虚拟地址为0x10003004。
跟踪地址转换过程-虚拟地址转化到物理地址
这一步的内容核心是查找页表，主要应用的是页式管理的内容。我们需要算出虚拟地址中的页目录号、页表号和页内偏移，他们分别对应32位虚拟地址的前10位、中间10位和末尾12位。
我们已知虚拟地址位0x10003004，所以我们可以通过转换得知页目录号、页表号和页内偏移分别为：64，3，4。
采用creg指令查看CR3寄存器的指向，CR3即指向的页目录表的基址，可得知：
接着我们查看第65个页目录项，第三个页表项，查询过程如下：
注意后三位为控制位，在查找的时候要分辨清楚。最后我们可以知道转化成的物理地址是：0x00fa7004.
此时查看一下0x00fa7004的值，发现值确实为test.c中i的初值，说明过程是正确的。
最后我们通过直接修改内存来改变i的值，使用命令"setpmem 0x00fa7004 4 0"实现，表示从0x00fa7004地址开始的4个字节均设置为0，然后再用c命令继续bochs的运行，则此时while(i);就会退出循环，我们看到了进程test成功退出了，说明i的修改成功了，即说明我们的修改是成功的。
内存的共享的实现
首先，在开始之前，我们先要明确我们的目的，即实现两个系统调用，来完成内存的共享。这两个系统调用分别是shmget()和shmat()，在Linux0.11中其本身是没有这种系统调用的。
系统调用的实现
我们需要实现的两个调用为shmget()和shmat()，两个调用的原型为：
int shmget(key_t key, size_t size, int shmflg); void *shmat(int shmid, const void *shmaddr, int shmflg);
shmget()的调用会新建或者打开一页的物理内存作为共享内存，并返回该页共享内存的shmid，即共享内存在操作系统中的标识。生成的shmid唯一地与key相关，如果多个进程使用相同的key来调用shmget()，则会返回相同的shmid。同时如果size>MAX_SIZE，则返回-1，置errno为EINVAL，若无空闲内存，也返回-1，置errno为ENOMEM。
shmat()会将shmid指定的共享页面映射到当前进程的虚拟地址空间中，并返回一个逻辑地址p，调用进程可以读写p来读写这一页的共享内存，两个进程都调用shmat可以关联到同一页内存上，形成共享内存页结构，实现了基于共享内存的进程间通信。如果shmid非法，返回-1，置errno为EINVAL。
我们先从添加系统调用号开始：
同时在unistd中添加shm_ds的结构体声明以及函数调用：
然后我们在include/linux/sys.h中添加系统调用的定义：
之后我们在kernel/system_call.s中增加系统调用数为78
然后我们就可以正式地来编写shm.c了，此处我们选择在linux-0.11/kernel/文件夹下编写：
#define __LIBRARY__
#include <unistd.h> //引入调用
#include <linux/kernel.h>
#include <errno.h> //引入错误提示
#include <linux/sched.h> //引入结构
#include <linux/mm.h>
static shm_ds shm_list[SHM_SIZE]; //严格的来说，其初始值应该默认是0?
int sys_shmget(unsigned int key, size_t size)
{
int i;
unsigned long page;
if (size > PAGE_SIZE)
{
printk("Shmget size overflow (%u > %ud). \n", size, PAGE_SIZE);
return -ENOMEM; //error1
}
if (key == 0)
{
printk("Shmget key number cannot be 0.\n");
return -EINVAL; //error2
}
for (i = 0; i < SHM_SIZE; i++) //先进行查询
if (shm_list[i].key == key)
return i; //查询到，则(打开这个界面)返回
page = get_free_page(); //没查询到，新建立一个非空页面
if (!page)
return -ENOMEM;
printk("Shmget get page address: 0x%08x\n", page);
for (i = 0; i < SHM_SIZE; i++)
{
if (shm_list[i].key == 0)
{
shm_list[i].key = key; //赋值占用
shm_list[i].size = size;
shm_list[i].page = page;
return i;
}
}
return -1;
}
void *sys_shmat(int shmid)
{
unsigned long data_base, brk;
if (shmid < 0 || SHM_SIZE <= shmid || shm_list[shmid].page == 0 || shm_list[shmid].key <= 0) //如果此shmid对应地无效
return (void *)-EINVAL;
data_base = get_base(current->ldt[2]);
printk("Shmat data_base = 0x%08x, page = 0x%08x\n", data_base, shm_list[shmid].page);
brk = current->brk + data_base;
current->brk += PAGE_SIZE;
if (!put_page(shm_list[shmid].page, brk)) //如果put_page失败
return (void *)-ENOMEM;
return (void *)(current->brk - PAGE_SIZE); //返回p
}
具体的内容此处都写了注释，关键的应用函数是get_free_page()，get_base()，put_page()。
在shmat()函数中，我们利用了在进程的PCB中记录了brk指针的逻辑地址的信息，通过进程开始的虚拟地址就可以得到brk指针的虚拟地址/线性地址(段基址+逻辑地址)。
然后我们修改一下shm.c文件在其中的kernel/下的Makefile：
然后我们在linux-0.11文件夹下make clean之后再make一下，出现sync则表示我们修改内核成功了：
producer&consumer的实现
此时我们可以采取挂载一下sudo ./mount-hdc，实现较为便捷的编程。
采用如下命令进入Linux-0.11的root文件夹下编程：
sudo ./mount-hdc cd /oslab/hdc/usr/root vim producer.c vim consumer.c
记得在开始之前，我们要把linux-0.11/中的unistd.h文件拷贝到hdc/usr/root/中去：
(sudo ./mount-hdc) cp ./linux-0.11/include/unistd.h ./hdc/usr/include/
接下来我们将编写producer.c和consumer.c：
producer.c：
#define __LIBRARY__
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <stdio.h>
#include <linux/sem.h>
_syscall2(sem_t*,sem_open,const char *,name,unsigned int,value);
_syscall1(int,sem_wait,sem_t*,sem);
_syscall1(int,sem_post,sem_t*,sem);
_syscall1(int,sem_unlink,const char *,name);
_syscall1(void*,shmat,int,shmid);
_syscall2(int,shmget,int,key,int,size);
#define NUMBER 520
#define BUFSIZE 10
sem_t *empty, *full, *mutex;
int i,shmid;
int *p;
int buf_in = 0;
int main()
{
if((mutex = sem_open("mutex",1)) == NULL)
{
perror("sem open error!\n");
return -1;
}
if((empty = sem_open("empty",10)) == NULL)
{
perror("sem open error!\n");
return -1;
}
if((full = sem_open("full",0)) == NULL)
{
perror("sem open error!\n");
return -1;
}
shmid = shmget(1234, BUFSIZE);
printf("Shmid %d\n",shmid);
if(shmid == -1)
return -1;
p = (int*) shmat(shmid);
printf("Producer start.\n");
fflush(stdout);
for( i = 0 ; i < NUMBER; i++)
{
sem_wait(empty);
sem_wait(mutex);
p[buf_in] = i; //输入数据, produce
buf_in = ( buf_in + 1)% BUFSIZE;
sem_post(mutex);
sem_post(full);
}
printf("Producer end.\n");
fflush(stdout);
sem_unlink("full");
sem_unlink("empty");
sem_unlink("mutex");
return 0;
}
consumer.c：
#define __LIBRARY__
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <stdio.h>
#include <linux/sem.h>
_syscall2(sem_t*,sem_open,const char *,name,unsigned int,value);
_syscall1(int,sem_wait,sem_t*,sem);
_syscall1(int,sem_post,sem_t*,sem);
_syscall1(int,sem_unlink,const char *,name);
_syscall1(void*,shmat,int,shmid);
_syscall2(int,shmget,int,key,int,size);
#define NUMBER 520
#define BUFSIZE 10
sem_t *empty, *full, *mutex;
int i,shmid,data;
int *p;
int buf_out = 0;
int main()
{
if((mutex = sem_open("mutex",1)) == NULL)
{
perror("sem open error!\n");
return -1;
}
if((empty = sem_open("empty",10)) == NULL)
{
perror("sem open error!\n");
return -1;
}
if((full = sem_open("full",0)) == NULL)
{
perror("sem open error!\n");
return -1;
}
printf("consumer start.\n");
fflush(stdout);
shmid = shmget(1234, BUFSIZE);
printf("shmid:%d\n",shmid);
if(shmid == -1)
return -1;
p = (int *)shmat(shmid);
for (i = 0; i < NUMBER; i++ )
{
sem_wait(full);
sem_wait(mutex);
data = p[buf_out];
buf_out = (buf_out + 1) % BUFSIZE;
sem_post(mutex);
sem_post(empty);
printf("%d: %d\n",getpid(),data); //consume
fflush(stdout);
}
printf("consumer end.\n");
fflush(stdout);
sem_unlink("full");
sem_unlink("empty");
sem_unlink("mutex");
return 0;
}
之后我们再编译一下：
gcc -o producer producer.c gcc -o consumer consumer.c
sudo umount hdc
最后我们在linux-0.11中运行以下命令：
./producer & ./consumer
运行测试：
以上的编写方式会出现Kernel Panic。
所以我们可以采取以下的方案将Kernel Panic转化为Segmentation Fault，通过修改memory.c的内存管理方式，具体的代码内容在这里：（内核修改部分+测试程序）。
最终呈现的内容如下所示：
完结撒花！
标签：信号量,return,name,int,实践,地址映射,sem,include,open From： https://www.cnblogs.com/lyp-Bird/p/17276044.html