Linux进程间通信内存映射（mmap）实现篇

原创 于 2025-12-16 17:51:43 发布 · 369 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #运维 #服务器

Linux 内核中 mmap 的实现(基于 2.6.12)

概述

基于 2.6.12 内核, 说明 mmap 系统调用的核心数据结构、系统调用路径及关键实现. 主要文件: mm/mmap.c、mm/msync.c、mm/filemap.c、include/linux/mm.h、include/linux/mman.h.

核心数据结构

mm_struct (进程地址空间描述符)

// include/linux/mm_types.h
struct mm_struct {
    struct vm_area_struct *mmap;        // VMA 链表头
    struct rb_root mm_rb;               // VMA 红黑树根节点
    struct vm_area_struct *mmap_cache;   // 最近使用的 VMA 缓存
    unsigned long free_area_cache;       // 空闲区域搜索的起始地址
    unsigned long mmap_base;             // mmap 区域的基地址
    unsigned long total_vm;               // 总虚拟内存页数
    unsigned long locked_vm;              // 锁定的内存页数
    struct rw_semaphore mmap_sem;        // 保护地址空间的读写信号量
    // ... 其他字段
};

vm_area_struct (虚拟内存区域)

// include/linux/mm_types.h
struct vm_area_struct {
    struct mm_struct *vm_mm;             // 所属的地址空间
    unsigned long vm_start;              // 虚拟地址区间起始地址
    unsigned long vm_end;                // 虚拟地址区间结束地址(不包含)
    struct vm_area_struct *vm_next;       // 链表中的下一个 VMA
    struct rb_node vm_rb;                // 红黑树节点
    unsigned long vm_flags;              // 权限与属性标志
    pgprot_t vm_page_prot;               // 页保护属性
    pgoff_t vm_pgoff;                    // 文件页偏移(文件映射时使用)
    struct file *vm_file;                // 关联的文件对象(文件映射时使用)
    void *vm_private_data;               // 私有数据
    struct vm_operations_struct *vm_ops;  // VMA 操作函数指针
    // ... 其他字段
};

file (文件对象)

// include/linux/fs.h
struct file {
    struct dentry *f_dentry;             // 目录项
    struct vfsmount *f_vfsmnt;           // 文件系统挂载点
    struct file_operations *f_op;         // 文件操作函数指针
    struct address_space *f_mapping;      // 地址空间(用于页缓存)
    fmode_t f_mode;                      // 文件打开模式
    // ... 其他字段
};

系统调用路径(x86_64 类推)

  • sys_mmap/sys_mmap2 (架构层入口) → do_mmap_pgoff (核心实现)
  • sys_munmap → do_munmap (解除映射)
  • sys_msync → msync_interval (同步映射区域到文件)
  • sys_mprotect → do_mprotect (修改保护属性)

核心流程

创建映射(mmap)

流程概述:

  1. 参数校验与页对齐: 检查长度、偏移、权限标志
  2. 选择/验证地址: 非 MAP_FIXED 由 get_unmapped_area 选择合适空洞, MAP_FIXED 必须满足对齐且不与现有 VMA 冲突
  3. 权限检查与文件映射: 共享映射需要写权限匹配, 文件映射调用 file->f_op->mmap 建立关联
  4. 建立 VMA: 分配 vm_area_struct, 设置 vm_flags、vm_pgoff、vm_file, 插入 mm_struct 的 VMA 红黑树和链表
  5. 返回映射起始地址
sys_mmap2 系统调用入口
// arch/x86_64/kernel/sys_x86_64.c (简化示意)
asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
                          unsigned long prot, unsigned long flags,
                          unsigned long fd, unsigned long pgoff)
{
    struct file *file = NULL;
    unsigned long error;

    // 如果不是匿名映射, 获取文件指针
    if (!(flags & MAP_ANONYMOUS)) {
        file = fget(fd);
        if (!file)
            return -EBADF;
    }

    // 获取写锁保护地址空间操作
    down_write(&current->mm->mmap_sem);
    // do_mmap_pgoff 完成核心逻辑
    error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
    up_write(&current->mm->mmap_sem);

    if (file)
        fput(file);
    return error;
}
do_mmap_pgoff 核心实现
// mm/mmap.c
unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
                            unsigned long len, unsigned long prot,
                            unsigned long flags, unsigned long pgoff)
{
    struct mm_struct *mm = current->mm;
    struct vm_area_struct *vma, *prev;
    struct inode *inode;
    unsigned int vm_flags;
    int correct_wcount = 0;
    int error;
    struct rb_node **rb_link, *rb_parent;
    int accountable = 1;
    unsigned long charged = 0, reqprot = prot;

    // 1. 文件映射的初步检查
    if (file) {
        // 检查文件是否支持 mmap 操作
        if (!file->f_op || !file->f_op->mmap)
            return -ENODEV;
        // 检查执行权限与文件系统挂载标志
        if ((prot & PROT_EXEC) &&
            (file->f_vfsmnt->mnt_flags & MNT_NOEXEC))
            return -EPERM;
    }

    // 2. 处理 READ_IMPLIES_EXEC 个性标志
    // 某些架构/程序期望 PROT_READ 隐含 PROT_EXEC
    if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
        if (!(file && (file->f_vfsmnt->mnt_flags & MNT_NOEXEC)))
            prot |= PROT_EXEC;

    // 3. 参数校验: 长度不能为 0
    if (!len)
        return -EINVAL;

    // 4. 长度页对齐并检查溢出
    len = PAGE_ALIGN(len);
    if (!len || len > TASK_SIZE)
        return -ENOMEM;

    // 5. 检查文件偏移溢出
    if ((pgoff + (len >> PAGE_SHIFT)) < pgoff)
        return -EOVERFLOW;

    // 6. 检查 VMA 数量限制
    if (mm->map_count > sysctl_max_map_count)
        return -ENOMEM;

    // 7. 获取或选择映射地址
    // 非 MAP_FIXED 时由 get_unmapped_area 选择合适地址
    addr = get_unmapped_area(file, addr, len, pgoff, flags);
    if (addr & ~PAGE_MASK)
        return addr;  // 返回错误码

    // 8. 计算 VMA 标志位
    // 将用户空间的 prot 和 flags 转换为内核的 vm_flags
    vm_flags = calc_vm_prot_bits(prot) | calc_vm_flag_bits(flags) |
               mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;

    // 9. 处理 MAP_LOCKED 标志(锁定内存)
    if (flags & MAP_LOCKED) {
        if (!can_do_mlock())
            return -EPERM;
        vm_flags |= VM_LOCKED;
        // 检查内存锁定限制
        unsigned long locked, lock_limit;
        locked = len >> PAGE_SHIFT;
        locked += mm->locked_vm;
        lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
        lock_limit >>= PAGE_SHIFT;
        if (locked > lock_limit && !capable(CAP_IPC_LOCK))
            return -EAGAIN;
    }

    inode = file ? file->f_dentry->d_inode : NULL;

    // 10. 根据映射类型设置 VMA 标志
    if (file) {
        switch (flags & MAP_TYPE) {
        case MAP_SHARED:
            // 共享映射: 需要写权限时检查文件是否可写
            if ((prot & PROT_WRITE) && !(file->f_mode & FMODE_WRITE))
                return -EACCES;
            // 不能对追加模式文件进行共享写映射
            if (IS_APPEND(inode) && (file->f_mode & FMODE_WRITE))
                return -EACCES;
            // 检查是否有强制锁
            if (locks_verify_locked(inode))
                return -EAGAIN;
            vm_flags |= VM_SHARED | VM_MAYSHARE;
            // 如果文件不可写, 清除写权限标志
            if (!(file->f_mode & FMODE_WRITE))
                vm_flags &= ~(VM_MAYWRITE | VM_SHARED);
            break;
        case MAP_PRIVATE:
            // 私有映射: 至少需要读权限
            if (!(file->f_mode & FMODE_READ))
                return -EACCES;
            break;
        default:
            return -EINVAL;
        }
    } else {
        // 匿名映射
        switch (flags & MAP_TYPE) {
        case MAP_SHARED:
            vm_flags |= VM_SHARED | VM_MAYSHARE;
            break;
        case MAP_PRIVATE:
            // 设置 pgoff 为虚拟地址对应的页号
            pgoff = addr >> PAGE_SHIFT;
            break;
        default:
            return -EINVAL;
        }
    }

    // 11. LSM (Linux Security Module) 安全检查
    error = security_file_mmap(file, reqprot, prot, flags);
    if (error)
        return error;

    // 12. 清除可能冲突的旧映射
    error = -ENOMEM;
munmap_back:
    vma = find_vma_prepare(mm, addr, &prev, &rb_link, &rb_parent);
    if (vma && vma->vm_start < addr + len) {
        // 如果新映射与现有 VMA 冲突, 先解除旧映射
        if (do_munmap(mm, addr, len))
            return -ENOMEM;
        goto munmap_back;
    }

    // 13. 检查地址空间限制
    if (!may_expand_vm(mm, len >> PAGE_SHIFT))
        return -ENOMEM;

    // 14. 内存记账(accounting)
    if (accountable && (!(flags & MAP_NORESERVE) ||
                        sysctl_overcommit_memory == OVERCOMMIT_NEVER)) {
        if (vm_flags & VM_SHARED) {
            // 共享映射需要记账
            vm_flags |= VM_ACCOUNT;
        } else if (vm_flags & VM_WRITE) {
            // 私有可写映射需要预留内存
            charged = len >> PAGE_SHIFT;
            if (security_vm_enough_memory(charged))
                return -ENOMEM;
            vm_flags |= VM_ACCOUNT;
        }
    }

    // 15. 尝试合并相邻的匿名私有映射
    if (!file && !(vm_flags & VM_SHARED) &&
        vma_merge(mm, prev, addr, addr + len, vm_flags,
                  NULL, NULL, pgoff, NULL))
        goto out;

    // 16. 分配 VMA 结构体
    vma = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
    if (!vma) {
        error = -ENOMEM;
        goto unacct_error;
    }
    memset(vma, 0, sizeof(*vma));

    // 17. 初始化 VMA 基本字段
    vma->vm_mm = mm;
    vma->vm_start = addr;
    vma->vm_end = addr + len;
    vma->vm_flags = vm_flags;
    vma->vm_page_prot = protection_map[vm_flags & 0x0f];
    vma->vm_pgoff = pgoff;

    // 18. 处理文件映射或匿名共享映射
    if (file) {
        // 处理 MAP_DENYWRITE 标志(禁止其他进程写入文件)
        if (vm_flags & VM_DENYWRITE) {
            error = deny_write_access(file);
            if (error)
                goto free_vma;
            correct_wcount = 1;
        }
        vma->vm_file = file;
        get_file(file);  // 增加文件引用计数
        // 调用文件系统的 mmap 方法(通常是 generic_file_mmap)
        error = file->f_op->mmap(file, vma);
        if (error)
            goto unmap_and_free_vma;
    } else if (vm_flags & VM_SHARED) {
        // 匿名共享映射: 使用 shmem (共享内存文件系统)
        error = shmem_zero_setup(vma);
        if (error)
            goto free_vma;
    }

    // 19. 清理共享映射的 VM_ACCOUNT 标志(由 shmem 负责记账)
    if ((vm_flags & (VM_SHARED|VM_ACCOUNT)) == (VM_SHARED|VM_ACCOUNT))
        vma->vm_flags &= ~VM_ACCOUNT;

    // 20. 保存可能被文件系统 mmap 方法修改的地址和偏移
    addr = vma->vm_start;
    pgoff = vma->vm_pgoff;
    vm_flags = vma->vm_flags;

    // 21. 尝试与相邻 VMA 合并, 或插入新的 VMA
    if (!file || !vma_merge(mm, prev, addr, vma->vm_end,
                            vma->vm_flags, NULL, file, pgoff, vma_policy(vma))) {
        // 不能合并, 插入新的 VMA
        file = vma->vm_file;
        vma_link(mm, vma, prev, rb_link, rb_parent);
        if (correct_wcount)
            atomic_inc(&inode->i_writecount);
    } else {
        // 可以合并, 释放刚分配的 VMA
        if (file) {
            if (correct_wcount)
                atomic_inc(&inode->i_writecount);
            fput(file);
        }
        mpol_free(vma_policy(vma));
        kmem_cache_free(vm_area_cachep, vma);
    }

out:
    // 22. 更新统计信息
    mm->total_vm += len >> PAGE_SHIFT;
    __vm_stat_account(mm, vm_flags, file, len >> PAGE_SHIFT);
    if (vm_flags & VM_LOCKED) {
        mm->locked_vm += len >> PAGE_SHIFT;
        // MAP_LOCKED 时立即分配物理页
        make_pages_present(addr, addr + len);
    }
    // 23. 处理 MAP_POPULATE 标志(预分配页)
    if (flags & MAP_POPULATE) {
        up_write(&mm->mmap_sem);
        sys_remap_file_pages(addr, len, 0, pgoff, flags & MAP_NONBLOCK);
        down_write(&mm->mmap_sem);
    }
    return addr;

unmap_and_free_vma:
    // 错误处理: 文件系统 mmap 失败
    if (correct_wcount)
        atomic_inc(&inode->i_writecount);
    vma->vm_file = NULL;
    fput(file);
    unmap_region(mm, vma, prev, vma->vm_start, vma->vm_end);
    charged = 0;
free_vma:
    kmem_cache_free(vm_area_cachep, vma);
unacct_error:
    if (charged)
        vm_unacct_memory(charged);
    return error;
}
get_unmapped_area 地址选择
// mm/mmap.c
unsigned long get_unmapped_area(struct file *file, unsigned long addr,
                                unsigned long len, unsigned long pgoff,
                                unsigned long flags)
{
    unsigned long ret;

    // 非 MAP_FIXED 时选择地址
    if (!(flags & MAP_FIXED)) {
        unsigned long (*get_area)(struct file *, unsigned long,
                                  unsigned long, unsigned long, unsigned long);
        // 优先使用文件系统提供的地址选择函数
        get_area = current->mm->get_unmapped_area;
        if (file && file->f_op && file->f_op->get_unmapped_area)
            get_area = file->f_op->get_unmapped_area;
        addr = get_area(file, addr, len, pgoff, flags);
        if (IS_ERR_VALUE(addr))
            return addr;
    }

    // 检查地址范围是否有效
    if (addr > TASK_SIZE - len)
        return -ENOMEM;
    // 检查地址是否页对齐
    if (addr & ~PAGE_MASK)
        return -EINVAL;
    // 处理大页映射的特殊检查
    if (file && is_file_hugepages(file)) {
        ret = prepare_hugepage_range(addr, len);
    } else {
        ret = is_hugepage_only_range(current->mm, addr, len);
    }
    if (ret)
        return -EINVAL;
    return addr;
}

// 默认的地址选择算法(自底向上)
unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr,
                                     unsigned long len, unsigned long pgoff,
                                     unsigned long flags)
{
    struct mm_struct *mm = current->mm;
    struct vm_area_struct *vma;
    unsigned long start_addr;

    if (len > TASK_SIZE)
        return -ENOMEM;

    // 如果指定了建议地址, 先检查是否可用
    if (addr) {
        addr = PAGE_ALIGN(addr);
        vma = find_vma(mm, addr);
        if (TASK_SIZE - len >= addr &&
            (!vma || addr + len <= vma->vm_start))
            return addr;
    }
    // 从上次搜索的缓存地址开始
    start_addr = addr = mm->free_area_cache;

full_search:
    // 遍历 VMA 链表查找空闲区域
    for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {
        // 检查是否超出地址空间
        if (TASK_SIZE - len < addr) {
            // 从头开始重新搜索
            if (start_addr != TASK_UNMAPPED_BASE) {
                start_addr = addr = TASK_UNMAPPED_BASE;
                goto full_search;
            }
            return -ENOMEM;
        }
        // 找到合适的空洞
        if (!vma || addr + len <= vma->vm_start) {
            // 更新缓存地址
            mm->free_area_cache = addr + len;
            return addr;
        }
        addr = vma->vm_end;
    }
}
generic_file_mmap 文件映射设置
// mm/filemap.c
int generic_file_mmap(struct file *file, struct vm_area_struct *vma)
{
    struct address_space *mapping = file->f_mapping;

    // 检查地址空间是否支持 readpage 操作(用于缺页处理)
    if (!mapping->a_ops->readpage)
        return -ENOEXEC;
    // 更新文件的访问时间
    file_accessed(file);
    // 设置 VMA 的操作函数指针(包含 fault、populate 等)
    vma->vm_ops = &generic_file_vm_ops;
    return 0;
}
vma_link 插入 VMA
// mm/mmap.c
static void vma_link(struct mm_struct *mm, struct vm_area_struct *vma,
                     struct vm_area_struct *prev, struct rb_node **rb_link,
                     struct rb_node *rb_parent)
{
    // 插入到 VMA 链表
    __vma_link_list(mm, vma, prev);
    // 插入到 VMA 红黑树
    __vma_link_rb(mm, vma, rb_link, rb_parent);
    // 如果文件映射, 还需要插入到文件的地址空间树
    if (vma->vm_file) {
        struct address_space *mapping = vma->vm_file->f_mapping;
        spin_lock(&mapping->i_mmap_lock);
        __vma_link_file(vma);
        spin_unlock(&mapping->i_mmap_lock);
    }
    // 更新 VMA 计数
    mm->map_count++;
}

解除映射(munmap)

流程概述:

  1. 对齐地址与长度: 地址必须页对齐, 长度页对齐
  2. 查找覆盖的 VMA: 找到与解除区域重叠的所有 VMA
  3. 拆分 VMA: 如果解除区域只覆盖 VMA 的一部分, 需要拆分
  4. 移除 VMA: 从链表、红黑树、文件地址空间树中移除
  5. 释放页表和资源: 调用 unmap_region 释放页表项和物理页
sys_munmap 系统调用入口
// mm/mmap.c
asmlinkage long sys_munmap(unsigned long addr, size_t len)
{
    int ret;
    struct mm_struct *mm = current->mm;

    profile_munmap(addr);

    // 获取写锁保护地址空间操作
    down_write(&mm->mmap_sem);
    ret = do_munmap(mm, addr, len);
    up_write(&mm->mmap_sem);
    return ret;
}
do_munmap 核心实现
// mm/mmap.c
int do_munmap(struct mm_struct *mm, unsigned long start, size_t len)
{
    unsigned long end;
    struct vm_area_struct *vma, *prev, *last;

    // 1. 参数校验: 地址必须页对齐, 范围必须有效
    if ((start & ~PAGE_MASK) || start > TASK_SIZE || len > TASK_SIZE - start)
        return -EINVAL;

    // 2. 长度页对齐
    if ((len = PAGE_ALIGN(len)) == 0)
        return -EINVAL;

    // 3. 查找第一个重叠的 VMA
    vma = find_vma_prev(mm, start, &prev);
    if (!vma)
        return 0;  // 没有重叠的 VMA, 直接返回成功
    // 此时 start < vma->vm_end

    // 4. 检查是否真的重叠
    end = start + len;
    if (vma->vm_start >= end)
        return 0;  // 不重叠

    // 5. 如果解除区域不是从 VMA 起始处开始, 需要拆分 VMA
    if (start > vma->vm_start) {
        int error = split_vma(mm, vma, start, 0);
        if (error)
            return error;
        prev = vma;  // 拆分后 prev 指向前半部分
    }

    // 6. 检查是否需要拆分最后一个 VMA
    last = find_vma(mm, end);
    if (last && end > last->vm_start) {
        int error = split_vma(mm, last, end, 1);
        if (error)
            return error;
    }
    // 重新定位到要解除的第一个 VMA
    vma = prev ? prev->vm_next : mm->mmap;

    // 7. 从链表和红黑树中分离要解除的 VMA
    detach_vmas_to_be_unmapped(mm, vma, prev, end);

    // 8. 解除页表映射并释放物理页
    unmap_region(mm, vma, prev, start, end);

    // 9. 释放 VMA 结构体和相关资源
    unmap_vma_list(mm, vma);

    return 0;
}

同步映射区域(msync)

流程概述:

  1. 参数校验: 地址页对齐, 标志位检查
  2. 查找覆盖的 VMA: 遍历所有与同步区域重叠的 VMA
  3. 同步脏页: 对于共享映射, 将脏页写回文件
  4. 文件系统同步: MS_SYNC 时调用文件系统的 fsync 方法
sys_msync 系统调用入口
// mm/msync.c
asmlinkage long sys_msync(unsigned long start, size_t len, int flags)
{
    unsigned long end;
    struct vm_area_struct *vma;
    int unmapped_error, error = -EINVAL;

    // 1. 设置同步写标志(用于 I/O 调度)
    if (flags & MS_SYNC)
        current->flags |= PF_SYNCWRITE;

    down_read(&current->mm->mmap_sem);

    // 2. 参数校验: 标志位检查
    if (flags & ~(MS_ASYNC | MS_INVALIDATE | MS_SYNC))
        goto out;
    // 地址必须页对齐
    if (start & ~PAGE_MASK)
        goto out;
    // MS_ASYNC 和 MS_SYNC 不能同时设置
    if ((flags & MS_ASYNC) && (flags & MS_SYNC))
        goto out;

    // 3. 长度页对齐并检查溢出
    error = -ENOMEM;
    len = (len + ~PAGE_MASK) & PAGE_MASK;
    end = start + len;
    if (end < start)
        goto out;
    error = 0;
    if (end == start)
        goto out;

    // 4. 查找第一个覆盖的 VMA
    vma = find_vma(current->mm, start);
    unmapped_error = 0;

    // 5. 遍历所有覆盖的 VMA 进行同步
    for (;;) {
        error = -ENOMEM;
        if (!vma)
            goto out;
        // 处理未映射的区域
        if (start < vma->vm_start) {
            unmapped_error = -ENOMEM;
            start = vma->vm_start;
        }
        // 同步当前 VMA 覆盖的部分
        if (end <= vma->vm_end) {
            if (start < end) {
                error = msync_interval(vma, start, end, flags);
                if (error)
                    goto out;
            }
            error = unmapped_error;
            goto out;
        }
        // 同步到当前 VMA 的结束
        error = msync_interval(vma, start, vma->vm_end, flags);
        if (error)
            goto out;
        start = vma->vm_end;
        vma = vma->vm_next;
    }

out:
    up_read(&current->mm->mmap_sem);
    current->flags &= ~PF_SYNCWRITE;
    return error;
}
msync_interval 同步区间
// mm/msync.c
static int msync_interval(struct vm_area_struct *vma,
                          unsigned long addr, unsigned long end, int flags)
{
    int ret = 0;
    struct file *file = vma->vm_file;

    // 1. MS_INVALIDATE 与 VM_LOCKED 冲突
    if ((flags & MS_INVALIDATE) && (vma->vm_flags & VM_LOCKED))
        return -EBUSY;

    // 2. 只处理共享文件映射
    if (file && (vma->vm_flags & VM_SHARED)) {
        // 同步页表中的脏页到页缓存
        filemap_sync(vma, addr, end);

        // 3. MS_SYNC 时同步到磁盘
        if (flags & MS_SYNC) {
            struct address_space *mapping = file->f_mapping;
            int err;

            // 将页缓存中的脏页写回磁盘
            ret = filemap_fdatawrite(mapping);
            // 调用文件系统的 fsync 方法
            if (file->f_op && file->f_op->fsync) {
                err = file->f_op->fsync(file, file->f_dentry, 1);
                if (err && !ret)
                    ret = err;
            }
            // 等待写操作完成
            err = filemap_fdatawait(mapping);
            if (!ret)
                ret = err;
        }
    }
    return ret;
}

保护属性变更(mprotect)

流程概述:

  1. 对齐区间: 地址和长度页对齐
  2. 遍历相关 VMA: 找到所有需要修改的 VMA
  3. 校验新权限: 检查新权限是否合法(如文件不可写时不能设置写权限)
  4. 拆分 VMA: 如果只修改部分 VMA, 需要拆分
  5. 更新 vm_flags: 修改 VMA 标志位和页保护属性
  6. 刷新 TLB: 使页表缓存失效

关键限制(2.6.12 默认)

  • vm.max_map_count: 每个进程最大 VMA 数量(/proc/sys/vm/max_map_count)
  • RLIMIT_AS: 进程虚拟地址空间限制
  • RLIMIT_MEMLOCK: 进程可锁定内存限制
  • TASK_SIZE: 用户空间地址空间大小(架构相关)

等待与唤醒

  • mmap 本身不涉及等待队列, 但缺页时会在 handle_mm_fault 中可能因 I/O 阻塞
  • MAP_LOCKED/SHM_LOCK 等锁定内存场景, 会受内存限额和锁定限制影响
  • msync 的 MS_SYNC 模式会等待 I/O 完成

文件与路径

  • mm/mmap.c: mmap/munmap 系统调用实现、VMA 管理
  • mm/msync.c: msync 系统调用实现
  • mm/mprotect.c: mprotect 系统调用实现
  • mm/filemap.c: 文件映射相关操作(generic_file_mmap 等)
  • include/linux/mm.h: 内存管理相关结构体和函数声明
  • include/linux/mman.h: mmap 相关常量定义

小结

  • mmap 的核心在于 do_mmap_pgoff: 地址选择、VMA 构建、文件/匿名映射、插入 VMA 结构
  • munmap 通过 do_munmap 实现: 查找重叠 VMA、拆分、移除、释放页表
  • msync 通过 msync_interval 实现: 同步共享映射的脏页到文件
  • 2.6.12 不支持后续特性(如 memfd, userfaultfd, MAP_POPULATE 扩展行为等), 描述保持 2.6.12 视角
Linux系统编程-进程间通信(mmap内存映射)
02-15 577
前面文章介绍了进程间常用的通信方式: 无名管道和命名管道，这篇文章介绍内存映射，内存映射在多进程访问文件读写的时候非常方便。
Linux 系统编程 - 进程间通信 (mmap 内存映射)
走向CTO的路上...
05-20 407
内存映射是一种进程间通信 (IPC) 机制，允许进程将文件或其他对象映射到自己的地址空间。本指南介绍如何在 Linux 系统中使用 mmap 内存映射。mmap是Linux系统提供的一种将文件或其他对象映射到进程虚拟地址空间的机制。通过mmap，进程可以直接访问文件的内容，如同操作内存一样，而无需通过传统的文件I/O系统调用（如read()write()此外，mmap还可以用于实现进程间共享内存，提供一种高效的IPC方式。mmap()
Linux中进程间的通信方式--内存映射区mmap()
04-05 1319
文章目录编程环境：mmap内存映射原理:创建内存映射区 mmap()：释放内存映射区 munmap()：写一个例子，验证内存内容和磁盘文件会同步：对于 mmap() 的一些思考：mmap 实现内存映射？父子进程间永远共享的东西？例子实现父子进程间的通信：创建匿名内存映射区：匿名内存映射区（有血缘关系进程通信）：有名内存映射区（无血缘关系进程通信）：借鉴博客与总结：下载地址： 简 述：　本篇讲解...
linux 进程间通信mmap,linux 进程间通信——内存共享映射mmap和munmap
weixin_26741799的博客
04-29 151
IPC三种通信机制是指：信号量、共享内存、消息队列，信号量：通过操作系统中的PV操作来实现；共享内存：申请一块内存，进程A往共享内存中写，其他的进程就可以通过读出共享内存中的内容来获取进程A所传送的信息；消息队列：创建一个消息队列，进程A往队列里面写，那么进程B通过读队列中的容来获取进程A传送的信息。mmap可以把磁盘文件的一部分直接映射到内存，这样文件中的位置直接就有对应的内存地址，对文件的读写...
【Linux进程间通信】四、mmap共享存储映射
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
07-21 1631
Linux进程间通信专题——mmap共享存储映射。
Linux多进程开发——进程间通信 内存映射
qq_55862397的博客
06-28 276
可以通过open的时候O_CREAT一个新文件来创建映射区，但是创建的文件大小不能为0，否则会调用失败，可以用lseek或者truncate函数对新的文件进行扩展。-MAP_PRIVATE:不同步，内存映射区的数据改变了，对原来的文件不会修改，会重新创建一个新的文件（copy on write)-length:要释放的内存的大小，要和mmap函数中的length参数的值一样。内存映射是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件。-length:要映射的数据的长度，不能为0。
Linux 共享内存mmap,进程通信
wuyiyu_的博客
08-11 1154
进程间通信是操作系统中重要的概念之一，使得不同的进程可以相互交换数据和进行协作。其中，共享内存是一种高效的进程间通信机制，而内存映射（mmap）是实现共享内存的一种常见方法。进程间共享内存映射（mmap）通信是一种高效、灵活的进程间通信机制。通过内存映射，不同的进程可以共享相同的数据区域，提高数据访问速度和性能。然而，在使用该机制时需要注意同步机制、内存管理和安全性等问题，以确保共享数据的正确性和安全性。
Linux内存映射mmap
m0_49476241的博客
07-24 1720
本篇文章我们来讲解一下内存映射。mmap（memory map）函数是用于在应用程序和内核之间建立内存映射的系统调用函数。它允许应用程序将一个文件或者匿名内存映射到其地址空间，从而实现对文件或内存区域的直接访问。addr：指定欲映射的首地址，通常设为0，表示由系统自己选择映射的地址。length：指定映射的内存区域长度，以字节为单位。prot：指定映射区域的保护方式（权限）。
linux进程的通信文件映射,Linux进程间通信 -- mmap函数的使用
weixin_31201737的博客
05-04 210
mmap/munmap函数函数原型#include void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);int munmap(void *addr, size_t length);函数功能mmap可以把磁盘文件的一部分直接映射到内存，这样文件中的位置直接就有对应的内存 地址，对文件的读写可...
Linux进程间通信-内存映射
dc爱傲雪和技术
05-05 736
内存映射（Memory Mapping）是一种高效的文件访问技术，它将文件的一部分或全部映射到进程的地址空间。通过这种方式，文件可以像访问内存一样进行读写操作，这通常由操作系统来管理。内存映射提供了对文件的高效随机访问，并能显著提高大量数据处理的性能。
linux下通过共享内存和mmap实现进程间通讯
JavaMonsterr的博客
06-05 590
最近在学习GNU/Linux内核，看到mmap的时候书上说：这句话说的很正确，虽然我们日常没有直接使用mmap，但是其实我们都间接地使用了mmap/mumap函数。举个例子，我们使用动态链接库的时候，我们都知道，动态链接不会把动态库中的代码整合到目标文件中，相反，动态库跟目标文件独立。那为什么运行时，程序能够获得指定的符号链接？这正是mmap的力量，程序运行时，他将保存在物理内存的动态库的内容（如果物理内存中没有，则先加载如内存）映射到自身的进程地址空间，这样符号所对应的指令数据便存在了。mmap将一个文件
Linux进程间通信(mmap)
m0_49476241的博客
07-25 588
本篇文章继续讲解进程间通信，之前我们已经讲解完管道，FIFO来进行进程间通信了，这篇文章将讲解使用mmap来进行进程间通信。本篇文章就讲解到这里，Linux全系列学习路线放在公众号号，回复7即可获取到全系列学习路线。
Ubuntu桌面图标快捷方式以root用户启动
荒坡_KingRumn
06-03 8477
Title: Ubuntu桌面图标快捷方式以root用户启动(16.04) 与桌面图标相关的几个文件夹 /usr/share/icons 系统图标文件夹 /usr/share/applications 系统快捷方式文件夹 ~/.local/share/applications 用户菜单文件夹 ~/.local/share/icons 用户图标文件夹 点击图标以root用户运行程序 很多应用程序在...
hexo 添加标签和分类
荒坡_KingRumn
08-02 7659
整个过程分类 与 标签 极其类似，只需要将对应的categories换成了tags 即可 创建页面 新建一个页面命名为categories $ hexo new page categories #tags 编辑页面 编辑新建的页面source/categories/index.md --- title: 分类 date: 2018-04-25 22:34:08 ...
vim复制内容到剪贴板
荒坡_KingRumn
08-02 2878
问题背景 VIM使用过程中需要将内容直接复制到系统剪贴板，使用场景： 在vim编辑过程中，需要将某些内容直接复制，并粘贴到博客或gedit中； 在2个窗口中分别用vim编辑，此时无法通过vim操作完成，只能借助系统剪贴板 解决方案 判断支持性 首先需要检查vim是否支持系统剪贴板 $ vim --version | grep &quot;clipboard&quot; &amp;gt; -clip...
Ubuntu 64位编译32位程序
荒坡_KingRumn
05-20 2769
title: Ubuntu 64位编译32位程序 背景 一般情况下,一个平台上只能编译当前平台对应的应用程序,比如,64位平台编译64位应用程序,但是随着64位平台的普及,多数采用了64位操作系统,而有时又基于某些原因需要编译出32位的应用程序. 本文旨在说明如何在64位操作系统上编译出32位应用程序. 准备 确认主机为64位架构的内核，应该输出为amd64 $ dpkg --print-ar...
Yolo安装（Ubuntu14.04）
荒坡_KingRumn
08-02 1574
最近在同事的建议下想要学习一下深度学习的知识，作为环境搭建的第一步，配置Yolo环境。电脑不支持CUDA，该环境仅用来学习，故未对CUDA进行配置和支持。 在环境配置过程中也遇到一些问题，记录以作参考。 经验总结 做一件事的时候，最基础的是去官网按照说明走一遍，往往这才是最官方的，也是最正确的，出了问题才去其他地方寻找答案 如果开源的代码出了问题，不妨先在Github上搜一搜看看有没有...
hexo 简介
荒坡_KingRumn
08-02 1419
基本介绍 Hexo是一个快速/简洁/高效的博客框架，使用Markdown作为渲染引擎解析文章，结合丰富的主题，分分钟生成绚丽的静态网页，是博客写作的首选。 . ├── _config.yml # 站点配置文件 ├── node_modules # 中间产物 ├── package.json # 应用程序信息，包括markdown渲染器等 ├── public ...
Linux进程间通信之共享内存与消息队列的竞争问题(同步策略)对比
最新发布
荒坡_KingRumn
12-12 1405
消息队列与共享内存的竞争问题对比分析 消息队列在内核层面实现了原子操作保护，确保发送、接收和删除操作的并发安全性，但应用层仍需处理逻辑竞争（如消息接收顺序、队列删除竞争等）。相比之下，共享内存缺乏内核保护，存在严重的数据竞争风险，必须借助信号量等同步机制实现互斥访问。消息队列适合简单通信场景，而共享内存虽高效但需额外同步开销。开发者应根据场景需求选择：消息队列适用于无需复杂同步的通信，共享内存则适合高性能但能承担同步成本的数据共享。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值