Linux 网络编程笔记3 | 内存 系统调用

七、内存

1、虚拟内存、物理内存、半导体内存和换页文件

虚拟内存：地址空间，虚拟的存储区域，应用程序所访问的都是虚拟内存。
物理内存：存储空间，实际的存储区域，只有系统内核可以访问物理内存。
虚拟内存和物理内存之间存在对应关系，当应用程序访问虚拟内存时，系统内核会依据这种对应关系找到与之相应的物理内存。上述对应关系存储在内核中的内存映射表中。
物理内存包括半导体内存和换页文件两部分。
当半导体内存不够用时，可以把一些长期闲置的代码和数据从半导体内存中缓存到换页文件中，这叫页面换出，一旦需要使用被换出的代码和数据，再把它们从换页文件恢复到半导体内存中，这叫页面换入。因此，系统中的虚拟内存比半导体内存大得多。

2、进程映射(Process Maps)

每个进程都拥有独立的4G字节的虚拟内存，分别被映射到不同的物理内存区域。
内存映射和换入换出都是以页为单位，1页=4096字节。
4G虚拟内存中高地址的1G被映射到内核的代码和数据区，这1个G在各个进程间共享。用户的应用程序只能直接访问低地址的3个G虚拟内存，因此该区域被称为用户空间，而高地址的1个G虚拟内存则被称为内核空间。用户空间中的代码只能直接访问用户空间的数据，如果要想访问内核空间中的代码和数据必须借助专门的系统调用完成。
用户空间的3G虚拟内存可以进一步被划分为如下区域：
------------------
系统内核(1G)
高地址------------------
命令行参数
和环境变量
------------------
栈区：非静态局部变量
- - - - - - - -
v
3G
^
- - - - - - - -
堆区：动态内存分配(malloc函数族)
-----------------
BSS区：无初值的全局和静态局部变量
-----------------
数据区：非const型有初值的全局和静态局部变量
-----------------
只读常量：字面值常量，const型有初值的全局
和静态局部变量
代码区(正文段)：可执行指令
低地址-----------------
代码：maps.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
const int const_global = 10; // 常全局变量
int init_global = 10; // 初始化全局变量
int uninit_global; // 未初始化全局变量
int main(int argc, char* argv[]) {
    // 常静态变量
    const static int const_static = 10;
    // 初始化静态变量
    static int init_static = 10;
    // 未初始化静态变量
    static int uninit_static;
    // 常局部变量
    const int const_local = 10;
    int prev_local; // 前局部变量
    int next_local; // 后局部变量
    // 前堆变量
    int* prev_heap = malloc(sizeof(int));
    // 后堆变量
    int* next_heap = malloc(sizeof(int));
    // 字面值常量
    char const* literal = "literal";
    extern char** environ; // 环境变量
    printf("--------------高地址 ------------\n");
    printf("---- 命令行参数与环境变量 ----\n");
    printf("         环境变量：%p\n", environ);
    printf("       命令行参数：%p\n", argv);
    
    printf("-------------- 栈 ------------\n");
    printf("       后局部变量：%p\n",&next_local);
    printf("       前局部变量：%p\n", &prev_local);
    printf("       常局部变量：%p\n", &const_local);
    
    printf("-------------- 堆 ------------\n");
    printf("         后堆变量：%p\n", next_heap);
    printf("         前堆变量：%p\n", prev_heap);
    printf("------------- BSS ------------\n");
    
    printf(" 未初始化全局变量：%p\n",&uninit_global);
    printf(" 未初始化静态变量：%p\n",&uninit_static);
    
    printf("------------ 数据 ------------\n");
    printf("   初始化静态变量：%p\n", &init_static);
    printf("   初始化全局变量：%p\n", &init_global);
    
    printf("------------ 代码 ------------\n");
    printf("       常静态变量：%p\n",
        &const_static);
    printf("       字面值常量：%p\n", literal);
    printf("       常全局变量：%p\n",
        &const_global);
    printf("             函数：%p\n",
        main);
    printf("---------------低地址---------------\n");
    return 0;
}

命令：size
通过size命令查看一个可执行程序的代码区、数据区和BSS区的大小。
每个进程的用户空间都拥有独立的从虚拟内存到物理内存的映射，为之进程间的内存壁垒。
代码：vm.c

#include <stdio.h>
int g_vm = 0;
int main(void) {
    printf("虚拟内存地址：%p\n", &g_vm);
    printf("输入一个整数：");
    scanf("%d%*c", &g_vm);//%*c的意思是清理丢弃回车
    printf("启动另一个进程，输入不同数据，"
        "按<回车>键继续...");
    getchar();
    printf("虚拟内存数据：%d\n", g_vm);
    return 0;
}

代码：vm2.c

#include <stdio.h>
int g_vm = 0;
int main(void) {
    printf("虚拟内存地址：%p\n", &g_vm);
    printf("输入一个整数：");
    scanf("%d%*c", &g_vm);//%*c的意思是清理丢弃回车
    printf("启动另一个进程，输入不同数据，"
        "按<回车>键继续...");
    getchar();
    printf("虚拟内存数据：%d\n", g_vm);
    return 0;
}

3、内存的分配与释放

malloc/calloc/realloc/free
|
v
brk/sbrk
|
v
mmap/munmap
|
v
kmalloc/kfree
以增加方式分配或释放虚拟内存
分配：映射+占有
| ____________
在地址空间(虚拟内存)和
存储空间(物理内存)之间 指定内存空
建立映射关系 间的归属性
释放：放弃占有+解除映射
| |
解除对内存空 消除地址空间(虚拟内存)和存储
间的归属约束 空间(物理内存)之间的映射关系
#include <unistd.h>
void* sbrk(intptr_t increment);
堆顶->- - - - - - - -
堆区
-----------------
sbrk(10)
堆顶->- - - - - - - -
10字节
- - - - - - - -<-返回值
堆区
-----------------
sbrk(-10)
- - - - - - - -<-返回值
10字节
堆顶->- - - - - - - -
堆区
-----------------
成功返回调用该函数之前的堆顶指针，失败返回-1。
increment
>0 - 堆顶指针上移，增大堆空间，分配虚拟内存
<0 - 堆顶指针下移，缩小堆空间，释放虚拟内存
=0 - 不分配也不释放虚拟内存，仅仅返回当前堆顶指针
系统内核维护一个指针，指向堆内存的顶端，即有效堆内存中最后一个字节的下一个位置。sbrk函数根据增量参数increment调整该指针的位置，同时返回该指针原来的位置，期间若发生内存耗尽或空闲，则自动追加或取消相应内存页的映射。
123____~~~~~~~~…
^ ^ ^ ^
堆顶
代码：sbrk.c

#include <stdio.h>
#include <unistd.h>
int main(void) {
    setbuf(stdout, NULL);
    int* p1 = (int*)sbrk(sizeof(int));
    if (p1 == (int*)-1) {
        perror("sbrk");
        return -1;
    }
    *p1 = 0;
    printf("%d\n", *p1);
    double* p2 = (double*)sbrk(sizeof(double));
    if (p2 == (double*)-1) {
        perror("sbrk");
        return -1;
    }
    *p2 = 1.2;
    printf("%g\n", *p2);
    char* p3 = (char*)sbrk(256 * sizeof(char));
    if (p3 == (char*)-1) {
        perror("sbrk");
        return -1;
    }
    sprintf(p3, "Hello, World!");
    printf("%s\n", p3);
    /*
    if (sbrk(-(256 * sizeof(char) +
        sizeof(double) +
        sizeof(int))) == (void*)-1) {
        perror("sbrk");
        return -1;
    }
    */
    if (brk(p1) == -1) {
        perror("brk");
        return -1;
    }
    return 0;

以绝对地址的方式分配或释放虚拟内存
int brk(void* end_data_segment);
成功返回0，失败返回-1。
end_data_segment
>当前堆顶，分配虚拟内存
<当前堆顶，释放虚拟内存
=当前堆顶，空操作
堆顶->- - - - - - - -<-void* p = sbrk(0);
堆区
-----------------
brk(p+10)
- - - - - - - -<-p+10
10字节
堆顶->- - - - - - - -
堆区
-----------------
brk§
堆顶->- - - - - - - -<-p
堆区
-----------------
系统内核维护一个指针，指向当前堆顶，brk函数根据指针参数end_data_segment设置堆顶的新位置，期间若发生内存耗尽或空闲，则自动追加或取消相应内存页的映射。
代码：brk.c

#include <stdio.h>
#include <unistd.h>
/*
 * xxxIIIIDDDDDDDDCC...C
 *    ^   ^       ^     ^
 *    p1  p2      p3
 */
int main(void) {
    setbuf(stdout, NULL);//setbuf函数用于打开和关闭缓冲机制，因为没遇到换行也
                         //没有填满缓冲区，所以会导致printf()打印不出来，
                         //将标准输出设置为不带缓冲的.printf()也有缓冲区，
                         //它的缓冲区也在堆内分布。
    int* p1 = (int*)sbrk(0);
    if (p1 == (int*)-1) {
        perror("sbrk");
        return -1;
    }
    double* p2 = (double*)(p1 + 1);
    if (brk(p2) == -1) {
        perror("brk");
        return -1;
    }
    *p1 = 0;
    printf("%d\n", *p1);
    char* p3 = (char*)(p2 + 1);
    if (brk(p3) == -1) {
        perror("brk");
        return -1;
    }
    *p2 = 1.2;
    printf("%g\n", *p2);
    void* p4 = p3 + 256;
    if (brk(p4) == -1) {
        perror("brk");
        return -1;
    }
    sprintf(p3, "Hello, World!");
    printf("%s\n", p3);
    if (brk(p1) == -1) {
        perror("brk");
        return -1;
    }
    return 0;
}

void* mmap(void* start, size_t length, int prot, int flags, int fd, off_t offset);

建立虚拟内存到物理内存或文件的映射
#include <sys/mman.h>
void* mmap(void* start, size_t length, int prot, int flags, int fd, off_t offset);
成功返回映射区虚拟内存的起始地址，失败返回MAP_FAILED(void类型的-1)。
start - 映射区虚拟内存的起始地址，NULL表示自动选择
length - 映射区的字节数，自动按页取整
prot - 访问权限，可取以下值：
PROT_READ - 可读
PROT_WRITE - 可写
PROT_EXEC - 可执行
PROT_NONE - 不可访问
flags - 映射标志，可取以下值：
MAP_ANONYMOUS - 匿名映射，将虚拟内存映射到物理内存，函数的最后两个参数fd和offset被忽略
MAP_PRIVATE - 私有映射，将虚拟内存映射到文件的内存缓冲区中而非磁盘文件
MAP_SHARED - 共享映射，将虚拟内存映射到磁盘文件中
MAP_DENYWRITE - 拒写映射，文件中被映射区域不能存在其它写入操作
MAP_FIXED - 固定映射，若在start上无法创建映射，则失败(无此标志系统会自动调整)
MAP_LOCKED - 锁定映射，禁止被换出到换页文件
fd - 文件描述符
offset - 文件偏移量，自动按页对齐
解除虚拟内存到物理内存或文件的映射
int munmap(void start, size_t length);
成功返回0，失败返回-1。
start - 映射区的起始地址
length - 映射区的字节数
代码：mmap.c

#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
int main(void) {
    char* psz = mmap(NULL, 8192,
        PROT_READ | PROT_WRITE,
        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
    if (psz == MAP_FAILED) {
        perror("mmap");
        return -1;
    }
    sprintf(psz, "第一页");
    sprintf(psz + 4096, "第二页");
    printf("%s\n", psz);
    printf("%s\n", psz + 4096);
    if (munmap(psz, 4096) == -1) {
        perror("munmap");
        return -1;
    }
    //printf("%s\n", psz);
    printf("%s\n", psz + 4096);
    if (munmap(psz + 4096, 4096) == -1) {
        perror("munmap");
        return -1;
    }
    return 0;
}

八、系统调用

应用程序--------------+
vi/emacs/gftp/firefox |
| |
标准库、第三方库 |
C/C++/Qt/X11 |
| |
系统调用<------------+
brk/sbrk/mmap/munmap
1.Linux系统内核提供了一套用于实现各种系统功能的子程序，谓之系统调用。程序编写者可以象调用普通C语言函数一样调用这些系统调用函数，以访问系统内核提供的各种服务。
2.系统调用函数在形式上与普通C语言函数并无差别。二者的不同之处在于，前者工作在内核态，而后者工作在用户态。
3.在Intel的CPU上运行代码分为四个安全级别：Ring0、Ring1、Ring2和Ring3。Linux系统只使用了Ring0和Ring3。用户代码工作在Ring3级，而内核代码工作在Ring0级。一般而言用户代码无法访问Ring0级的资源，除非借助系统调用，使用户代码得以进入Ring0级，使用系统内核提供的功能。
4.系统内核内部维护一张全局表sys_call_table，表中的每个条目记录着每个系统调用在内核代码中的实现入口地址。
5.当用户代码调用某个系统调用函数时，该函数会先将参数压入堆栈，将系统调用标识存入eax寄存器，然后通过int 80h指令触发80h中断。
6.这时程序便从用户态(Ring3)进入内核态(Ring0)。
7.工作系统内核中的中断处理函数被调用，80h中断的处理函数名为system_call，该函数先从堆栈中取出参数，再从eax寄存器中取出系统调用标识，然后再从sys_call_table表中找到与该系统调用标识相对应的实现代码入口地址，挈其参数调用该实现，并将处理结果逐层返回到用户代码中。