struct vm_area_struct {  
    /* The first cache line has the info for VMA tree walking. */  
    unsigned long vm_start;         /* Our start address within vm_mm. */  
    unsigned long vm_end;           /* The first byte after our end address 
                                           within vm_mm. */  
    /* linked list of VM areas per task, sorted by address */  
    struct vm_area_struct *vm_next, *vm_prev;  
    struct rb_node vm_rb;  
    unsigned long rb_subtree_gap;  
	  
    struct mm_struct *vm_mm;        /* The address space we belong to. */  
    pgprot_t vm_page_prot;          /* Access permissions of this VMA. */  
    unsigned long vm_flags;         /* Flags, see mm.h. */  
    struct {  
        struct rb_node rb;  
        unsigned long rb_subtree_last;  
    } shared;  
  
    struct list_head anon_vma_chain; /* Serialized by mmap_sem & 
                                          * page_table_lock */  
    struct anon_vma *anon_vma;      /* Serialized by page_table_lock */  
  
    /* Function pointers to deal with this struct. */  
    const struct vm_operations_struct *vm_ops;  
  
    /* Information about our backing store: */  
    unsigned long vm_pgoff;         /* Offset (within vm_file) in PAGE_SIZE 
                                           units, *not* PAGE_CACHE_SIZE */  
    struct file * vm_file;          /* File we map to (can be NULL). */  
    void * vm_private_data;         /* was vm_pte (shared mem) */  
    ...  
};  

struct vm_operations_struct {  
    void (*open)(struct vm_area_struct * area);  
    void (*close)(struct vm_area_struct * area);  
    int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);  
    void (*map_pages)(struct vm_area_struct *vma, struct vm_fault *vmf);  
    int (*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);  
    int (*pfn_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);  
    int (*access)(struct vm_area_struct *vma, unsigned long addr,  
                  void *buf, int len, int write);  
    const char *(*name)(struct vm_area_struct *vma);  
    struct page *(*find_special_page)(struct vm_area_struct *vma,  
                                          unsigned long addr);  
};  

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

int main(int argc, char **argv)  
{  
    char *filename = "/tmp/foo.data";  
    struct stat stat;  
    int fd = open(filename, O_RDWR, 0);  
    fstat(fd, &stat);  
    void *bufp = mmap(NULL, stat.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);  
    memcpy(bufp, "Linuxdd", 7); 
    munmap(bufp, stat.st_size); 
    close(fd);
    return 0;  
}  

SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,  
        unsigned long, prot, unsigned long, flags,  
        unsigned long, fd, unsigned long, off)  
{  
    long error;  
    error = -EINVAL;  
    if (off & ~PAGE_MASK)  
        goto out;  
 
    error = sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);  
out:  
    return error;  
} 

unsigned long do_mmap_pgoff(struct file *file,  
                unsigned long addr,  
                unsigned long len,  
                unsigned long prot,  
                unsigned long flags,  
                unsigned long pgoff,  
                unsigned long *populate)  
{  
    // 申请一个vm_area_struct结构体  
    struct vm_area_struct *vma;  
      
    // ...  
  
    // 为vma分配内存  
    vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);  
    if (!vma)  
        goto error_getting_vma;  
  
    // ... 初始化相关  
  
    // 如果是文件映射，给文件添加一个引用计数  
    if (file) {  
        region->vm_file = get_file(file);  
        vma->vm_file = get_file(file);  
    }  
  
    down_write(&nommu_region_sem);  
  
    // ...  
  
    // 真正去做文件映射  
    if (file && vma->vm_flags & VM_SHARED)  
        ret = do_mmap_shared_file(vma);  
    else  
        ret = do_mmap_private(vma, region, len, capabilities);  
  
    // ...  
    // 将vma插入到链表中  
    add_vma_to_mm(current->mm, vma);  
    // ...  
}  

static int do_mmap_private(struct vm_area_struct *vma,  
               struct vm_region *region,  
               unsigned long len,  
               unsigned long capabilities)  
{  
    // ...  
    if (capabilities & NOMMU_MAP_DIRECT) {  
        // 调用文件映射的方法  
        ret = vma->vm_file->f_op->mmap(vma->vm_file, vma);  
        // ...  
    }  
  
    // ...  
}  

int generic_file_mmap(struct file * file, struct vm_area_struct * vma)  
{  
    struct address_space *mapping = file->f_mapping;  
  
    if (!mapping->a_ops->readpage)  
        return -ENOEXEC;  
    file_accessed(file);  
    vma->vm_ops = &generic_file_vm_ops;  
    return 0;  
}  

const struct vm_operations_struct generic_file_vm_ops = {  
    .fault      = filemap_fault,  
    .map_pages  = filemap_map_pages,  
    .page_mkwrite   = filemap_page_mkwrite,  
};  

int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)  
{  
    // ...  
      
    // 先判断当前页有没有被cache  
    page = find_get_page(mapping, offset);  
    if (likely(page) && !(vmf->flags & FAULT_FLAG_TRIED)) {  
        // 预读机制，从cache中拿到数据  
       do_async_mmap_readahead(vma, ra, file, page, offset);  
    } else if (!page) {  
        // 未cache到，直接同步读取  
        do_sync_mmap_readahead(vma, ra, file, offset);  
        count_vm_event(PGMAJFAULT);  
        mem_cgroup_count_vm_event(vma->vm_mm, PGMAJFAULT);  
        ret = VM_FAULT_MAJOR;  
retry_find:  
        page = find_get_page(mapping, offset);  
        if (!page)  
            goto no_cached_page;  
    }  
  
    // ...  
  
    // 找到对应页将其赋值给vmf，并返回  
    vmf->page = page;  
    return ret | VM_FAULT_LOCKED;  
    // ...  
}  

#include <stdio.h>

int a = 100;

void foo() {
        while (a > 10) {}
}

int main() {
        foo();
        return 0;
}

typedef struct {
    uint8_t *c;
    uint64_t l;
} ts_bitmap_t;

#define PREALLOC 128
int mem_align(int size) {
    if (size <= PREALLOC) {
        return PREALLOC;
    }
    // 求size是PREALLOC的多少倍
    // 向上取整并乘以PREALLOC
    int multiple = ceil(size / PREALLOC);
    return multiple * PREALLOC;
}

#ifndef TS_BITMAP_PREALLOC
#define TS_BITMAP_PREALLOC 128LL
#endif

#define ts_bmp_align(s) ((s + TS_BITMAP_PREALLOC - 1) & ~(TS_BITMAP_PREALLOC - 1))

#define ts_bitmap_reserve(bm, n) { \
    if ((n) > ((bm)->l)) {  \
        uint64_t __len = ts_bmp_align(n); \
        (bm)->c = ts_realloc((bm)->c, __len); \
        assert((bm)->c != NULL); \
        bzero((void *)((bm)->c + (bm)->l), __len - (bm)->l); \
        (bm)->l = __len; \
    } \
}

uint64_t mem_align(uint64_t i, int align)
{
        return (i + align - 1) & ~(align - 1);
}

#define ts_bmp_dig(p) ((p) >> 0x3)

#define ts_bmp_mod(p) ((p) & 0x7)

#define ts_bitmap_set(bm, p) { \
    ts_bitmap_reserve(ts_bitmap_p(bm), ts_bmp_dig(p) + 1); \
    ts_bitmap_p(bm)->c[ts_bmp_dig(p)] |= (1 << ts_bmp_mod(p)); \
}

#define ts_bitmap_unset(bm, p) { \
    if (ts_bmp_dig(p) < (bm)->l) ts_bitmap_p(bm)->c[ts_bmp_dig(p)] &=  ~(1 << (ts_bmp_mod(p))); \
}

#define ts_bitmap_get(bm, p) ((ts_bmp_dig(p) >= ((ts_bitmap_p(bm))->l) ? 0 : \
            ((ts_bitmap_p(bm)->c[ts_bmp_dig(p)]) >> ts_bmp_mod(p))) & 1)