实验6：地址映射与共享

本文以记录实验过程为主，具体实验内容与要求参考实验指导书。此外本文并没有完全按照实验指导书的要求来做这个实验，本文主要介绍共享内存的实现过程。

1 添加系统调用

1、在 unistd.h 文件（注意：有两个unistd.h文件，一个在Linux0.11内核程序文件中，另一个在hdc/usr/include/ 目录下） 中添加系统调用号。并在 system_call.s 文件中将系统调用号总数修改为74： nr_system_calls = 74。

...
#define __NR_setregid	71
/*新增的系统调用号*/
#define __NR_shmget     72
#define __NR_shmat      73
...

2、在 unistd.h 文件中添加与共享内存相关的数据类型。

...
#endif /* __LIBRARY__ */

typedef int key_t;
/*共享内存节点*/
struct shm_node{
    key_t key;
    int id;           
    unsigned int size;
    unsigned long addr;      /*物理地址*/
    struct shm_node *next;   /*下一个节点*/
};

extern int errno;
...

3、在 sys.h 文件中添加系统调用声明，并将新增的系统调用函数添加到 sys_call_table[] 中。

...
/*新增系统调用声明*/
extern int sys_shmget();
extern void *sys_shmat();

fn_ptr sys_call_table[] = { ..., sys_sigaction, sys_sgetmask, sys_ssetmask,
sys_setreuid,sys_setregid, sys_shmget, sys_shmat };

2 新建shm.c

图2.1，图2.2 为编写shm.c 提供了一个整体思路。

图2.1 内核的代码段和数据段

图2.2 进程代码和数据在其逻辑地址空间的分布

在 mm 目录下新建 shm.c 文件，修改 mm/Makefile 文件：

...
OBJS	= memory.o page.o shm.o
...
### Dependencies:
shm.o: shm.c ../include/linux/kernel.h ../include/linux/mm.h ../include/string.h \
  ../include/errno.h ../include/unistd.h ../include/linux/sched.h
...

shm.c 的内容如下：

#include <linux/kernel.h>
#include <string.h>
#include <linux/mm.h>
#include <errno.h>
#include <unistd.h>
#include <linux/sched.h>

//共享内存的头节点
struct shm_node *shmHead =&((struct shm_node *){0, 0, 0, NULL, NULL});
/**
 * 根据key，获取或新建一片共享内存。
 */ 
int sys_shmget(key_t key, size_t size, int shmflg)
{  
    struct shm_node *tmp = shmHead;
    //检查参数
    if(size > PAGE_SIZE || key == 0)    //最多分配4KB内存,且key不能为0，这是被头节点占用的
    {
        errno = EINVAL;
        return(-1);
    }
    //查找链表
    while(tmp != NULL)
    {
        if(key == tmp->key)
        {
            return(tmp->id);
        }
        tmp = tmp->next;
    }
    //若没有找到则分配一页新的内存
    tmp = (struct shm_node *)malloc(sizeof(struct shm_node));
    //分配一页内存。get_free_page()返回的是空闲内存的物理地址，
    //不过在内核空间中：偏移地址(32bit) = 线性地址(32bit) = 物理地址(32bit)
    tmp->addr = get_free_page();   
    printk("tmp->addr = %d\n", tmp->addr);
    if(tmp->addr == 0)
    {
        errno = ENOMEM;
        return(-1);
    }
    tmp->key = key;    //shmid和key都是用来标识共享内存的，因此为了简化，
    tmp->id = (int)key;//这里直接将shmid = key。
    tmp->size = size;
    tmp->next = shmHead->next;
    shmHead->next = tmp;
    printk("sys_shmget succeed !\n");
    return(tmp->id);
}
/**
 * 将shmid指定的共享页面映射到当前进程的虚拟地址空间中，并将其首地址返回。
 * 注意这里返回的是偏移地址。
 */ 
void *sys_shmat(int shmid, const void *shmaddr, int shmflg)
{
    struct shm_node *tmp = shmHead;
    unsigned long address = 0;   //线性地址
    //检查参数
    while(tmp != NULL)
    {
        if(shmid == tmp->id)
            break;
        tmp = tmp->next;
    }
    if(tmp == NULL)
    {
        errno = EINVAL;
        return(-1);
    }
    //寻找空闲的虚拟地址空间
    //current->start_code + current->brk就是我们要的空闲线性地址
    printk("start_code = %d, brk = %d\n", current->start_code, current->brk);
    printk("data base = %d\n", get_base(current->ldt[2]) );
    address = current->start_code + current->brk;
    if( 0 == put_page(tmp->addr, address) )
    {
        printk("put_page fail !\n");
        return(NULL);
    }
    current->brk += PAGE_SIZE;
    printk("sys_shmat succeed !\n");
    //注意：address是线性地址，不能直接返回，我们要返回的是偏移地址
    //return((void *)(address));
    return(address - current->start_code);
}

3 实验结果

共享内存的测试程序如下，其中子进程负责向共享内存中写入0，2，4…，18。而父进程负责将子进程写入的内容打印出来：

/**
 * 共享内存测试程序
 */
#define __LIBRARY__
#include <unistd.h>
#include <linux/mm.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>

_syscall3(int, shmget, key_t, key, size_t, size, int, shmflg)
/**
 * shmat 本来应该返回void * 类型的，但是为了消除编译器的警告，改为返回int类型
 */ 
_syscall3(int, shmat, int, shmid, const void *, shmaddr, int, shmflg)

int *share;

void main(){
    int pid = -1;
    int i = 0;
    int shmid = -1;
    key_t key = 1;

    pid = fork();
    if(pid == -1)
        perror("fork()");
    else if(pid == 0)
    {   /*子进程*/
        shmid = shmget(key, 10 * sizeof(int), 0);
        if(shmid == -1)
        {
            perror("son : shmget()");
            return;
        }
        share = (int *)shmat(shmid, NULL, 0);
        if(share == NULL)
        {
            perror("son : shmat()");
            return;
        }
        for(i = 0; i < 10; ++i)
            share[i] = 2 * i;
    }
    else if(pid > 0)
    {   /*父进程*/
        wait(NULL);
        shmid = shmget(key, 10 * sizeof(int), 0);
        if(shmid == -1)
        {
            perror("parent : shmget()");
            return;
        }
        share = (int *)shmat(shmid, NULL, 0);
        if(share == NULL)
        {
            perror("parent : shmat()");
            return;
        }
        for(i = 0; i < 10; ++i)
            printf("%d, ", share[i]);
        printf("\n");

    }
}

实验结果如下：

图2.3 共享内存实验结果

参考

图2.1和图2.2 截取自《Linux内核完全剖析——基于0.12内核》。

[1]哈工大操作系统实验指导书 - 4.5地址映射与共享

[2] 《Linux内核完全剖析——基于0.12内核》