linux内核源码实战_3.1理解进程管理和内存管理

已于 2022-02-12 18:34:29 修改
阅读量2.2k 收藏
点赞数
分类专栏： # linux 文章标签： linux 运维 服务器
于 2022-01-22 19:47:22 首次发布
xtan
本文链接：https://blog.csdn.net/tan1666/article/details/122637865
版权

img

理解进程管理和内存管理

linux内核源码实战_理解进程管理和内存管理

前面的博客我只是对知识点的整理， 没有对知识点进行理解， 准备从实战方面入手去理解进程管理和内存管理。

体验课(Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈)学习视频链接地址　
正课学习视频链接地址
第二个链接是我学习的链接，如果你有兴趣学习，我可以为你推荐，老学员推荐新学员会有相应的折扣 我的QQ号码: 852897652.

以前学习整理的
整理知识点 进程管理和内存管理 链接1。
整理知识点 设备驱动和文件系统 链接2。
整理知识点 中断和网络 链接3。
整理知识点 内核实战 链接3

理解进程管理和内存管理列表

1-内存管理4-获取系统内存数据信息
2-内存管理4-分配内存模式机制
3-内存管理4-Slab块分配器内存实现
4-内存管理4-进程地址空间在内核(VMA实现)
5-内存管理4-设计per-cpu变量应用
第019讲 Linux内核内存池
第008讲 内存映射原理及系统调用
vma

6-同步管理-RCU实现
第004讲 2进程优先级与调度策略实战

理解进程管理和内存管理列表详解

1-内存管理4-获取系统内存数据信息
#include <linux/version.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>

#define ARCH_PFN_OFFSET (0UL)

#define PRT(a, b) pr_info("%-15s=%10d %10ld %8ld\n", a, b, (PAGE_SIZE * b) / 10                                               24, (PAGE_SIZE * b) / 1024 / 1024)

static int __init my_init(void)
{
    struct page *p;
    unsigned long i, pfn, valid = 0;
    int free = 0, locked = 0, reserved = 0, swapcache = 0,referenced = 0, slab                                                = 0, private = 0, uptodate = 0,dirty = 0, active = 0, writeback = 0, mappedtodi                                               sk = 0;

    unsigned long num_physpages;

    num_physpages = get_num_physpages();
    for (i = 0; i < num_physpages; i++)
    {
        /* Most of ARM systems have ARCH_PFN_OFFSET */
        pfn = i + ARCH_PFN_OFFSET;
        /* may be holes due to remapping */
        if (!pfn_valid(pfn))
            continue;
        valid++;
        p = pfn_to_page(pfn);
        if (!p)
            continue;
        if (!page_count(p))
        {
            free++;
            continue;
        }
        if (PageLocked(p))
            locked++;
        if (PageReserved(p))
            reserved++;
        if (PageSwapCache(p))
            swapcache++;
        if (PageReferenced(p))
            referenced++;
        if (PageSlab(p))
            slab++;
        if (PagePrivate(p))
        private
        ++;
        if (PageUptodate(p))
            uptodate++;
        if (PageDirty(p))
            dirty++;
        if (PageActive(p))
            active++;
        if (PageWriteback(p))
            writeback++;
        if (PageMappedToDisk(p))
            mappedtodisk++;
    }

    pr_info("\nExamining %ld pages (num_phys_pages) = %ld MB\n",num_physpages,                                                num_physpages * PAGE_SIZE / 1024 / 1024);
    pr_info("Pages with valid PFN's=%ld, = %ld MB\n", valid,valid * PAGE_SIZE /                                                1024 / 1024);
    pr_info("\n Pages KB MB\n\n");

    PRT("free", free);
    PRT("locked", locked);
    PRT("reserved", reserved);
    PRT("swapcache", swapcache);
    PRT("referenced", referenced);
    PRT("slab", slab);
    PRT("private", private);
    PRT("uptodate", uptodate);
    PRT("dirty", dirty);
    PRT("active", active);
    PRT("writeback", writeback);
    PRT("mappedtodisk", mappedtodisk);

    return 0;
}

static void __exit my_exit(void)
{
    pr_info("Module exit\n");
}

module_init(my_init);
module_exit(my_exit);

MODULE_AUTHOR("VicoTeacher");
MODULE_LICENSE("GPL");
分析

原理不了解，没法分析，先整理在这里吧 。

2-内存管理4-分配内存模式机制
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/vmalloc.h>

static int mem = 1024;
#define MB (1024 * 1024)

static int __init my_init(void)
{
    char *kbuf;
    unsigned long order;
    unsigned long size;
    char *vm_buff;

    /* try __get_free_pages__ */
    for (size = PAGE_SIZE, order = 0; order < MAX_ORDER; order++, size *= 2)
    {
        pr_info(" order=%2lu, pages=%5lu, size=%8lu ", order,size / PAGE_SIZE, size);
        kbuf = (char *)__get_free_pages(GFP_ATOMIC, order);
        if (!kbuf)
        {
            pr_err("Testing Function:__get_free_pages failed\n");
            break;
        }
        pr_info("test --> __get_free_pages OK\n");
        free_pages((unsigned long)kbuf, order);
    }

    /* try kmalloc */
    pr_info("\n");
    for (size = PAGE_SIZE, order = 0; order < MAX_ORDER;order++, size *= 2)
    {
        pr_info(" order=%2lu, pages=%5lu, size=%8lu ", order,size / PAGE_SIZE, size);
        kbuf = kmalloc((size_t)size, GFP_ATOMIC);
        if (!kbuf)
        {
            pr_err("Testing Function:kmalloc failed\n");
            break;
        }
        pr_info("test --> kmalloc OK\n");
        kfree(kbuf);
    }

    /* try vmalloc */
    pr_info("\n");
    for (size = 20 * MB; size <= mem * MB; size += 20 * MB)
    {
        pr_info(" pages=%6lu, size=%8lu ", size / PAGE_SIZE, size / MB);
        vm_buff = vmalloc(size);
        if (!vm_buff)
        {
            pr_err("Testing Function:vmalloc failed\n");
            break;
        }
        pr_info("test --> vmalloc OK\n");
        vfree(vm_buff);
    }

    return 0;
}

static void __exit my_exit(void)
{
    pr_info("Module Exit OK \n");
}

module_init(my_init);
module_exit(my_exit);

MODULE_AUTHOR("vico 2021/09/02");
MODULE_LICENSE("GPL");
3-内存管理4-Slab块分配器内存实现

#include <linux/module.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/init.h>

static char *kbuf;

static int sizes=40;

static struct kmem_cache *my_caches;
module_param(sizes, int, 0644);

static int __init myslab_init(void)
{
    if(sizes>KMALLOC_MAX_SIZE)
    {
        pr_err(" Size=%d is too big , You can't have more than %lu.\n",sizes,KMALLOC_MAX_SIZE);
        return -1;
    }

    my_caches=kmem_cache_create("mycaches",sizes,0,SLAB_HWCACHE_ALIGN,NULL);
    if(!my_caches)
    {
        pr_err(" kmem_cache_create() Failed.\n");
        return -ENOMEM;
    }
    pr_info(" Create mycaches CORRECT.\n");

    kbuf=kmem_cache_alloc(my_caches,GFP_ATOMIC);
    if(!kbuf)
    {
        pr_err(" Create a cache object Failed.\n");
        (void)kmem_cache_destroy(my_caches);
        return -1;
    }
    pr_info(" Create a object Successfully,kbuf_address=0x%p\n",kbuf);


    return 0;
}

static void __exit myslab_exit(void)
{
    kmem_cache_free(my_caches,kbuf);
    pr_info(" Destroy a cache object.\n");

    kmem_cache_destroy(my_caches);
    pr_info(" Destroy mycaches.\n");

}

module_init(myslab_init);
module_exit(myslab_exit);

MODULE_AUTHOR("vico");
MODULE_LICENSE("GPL");
4-内存管理4-进程地址空间在内核(VMA实现)

NO.

5-内存管理4-设计per-cpu变量应用

#include <linux/module.h>
#include <linux/init.h>
#include <linux/percpu.h>
#include <linux/cpumask.h>
static DEFINE_PER_CPU(long, cpuvar) = 5;
static long __percpu *cpualloc;

static int __init my_init(void)
{
    int cpu;
    pr_info("module loaded at 0x%p\n", my_init);
    /* modify the cpuvar value */
    for_each_possible_cpu(cpu)
    {
        per_cpu(cpuvar, cpu) = 10;
        pr_info("init: cpuvar on cpu%d = %ld\n",
                cpu, get_cpu_var(cpuvar));
        put_cpu_var(cpuvar);
    }
    __this_cpu_write(cpuvar, 10);
    /* alloc a percpu value */
    cpualloc = alloc_percpu(long);
    /* set all cpu for this value */
    for_each_possible_cpu(cpu)
    {
        *per_cpu_ptr(cpualloc, cpu) = 666;
        pr_info("init: cpu:%d cpualloc = %ld\n",
                cpu, *per_cpu_ptr(cpualloc, cpu));
    }
    return 0;
}
static void __exit my_exit(void)
{
    int cpu;
    pr_info("exit module...\n");
    for_each_possible_cpu(cpu)
    {
        pr_info("cpuvar cpu%d = %ld\n", cpu, per_cpu(cpuvar, cpu));
        pr_info("exit: cpualloc%d = %ld\n", cpu, *per_cpu_ptr(cpualloc, cpu));
    }
    free_percpu(cpualloc);
    pr_info("Bye: module unloaded from 0x%p\n", my_exit);
}
module_init(my_init);
module_exit(my_exit);
MODULE_AUTHOR("Vico");
MODULE_LICENSE("GPL");
第019讲 Linux内核内存池

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ALLOC_SIZE 8
#define LOOP 5
#define MAX_POOL_SIZE 1024*1024
#define BLOCK_SIZE 64

typedef struct memory_map_table
{
    char *p_block;
    int index;
    int used;
}Memory_Map_Table;

typedef struct memory_alloc_table
{
    char *p_start;
    int used;
    int block_start_index;
    int block_cnt;
}Memory_Alloc_Table;

typedef struct memory_pool
{
    char *memory_start;
    Memory_Alloc_Table *alloc_table;
    Memory_Map_Table *map_table;
    int total_size;
    int internal_total_size;
    int increment;
    int used_size;
    int block_size;
    int block_cnt;
    int alloc_cnt;
}Memory_Pool;

Memory_Map_Table *map_table_pos(Memory_Pool *pool)
{
        Memory_Map_Table *pm = (Memory_Map_Table *)(pool->memory_start + sizeof(Memory_Pool));
        return pm;
}

Memory_Alloc_Table *alloc_table_pos(Memory_Pool *pool)
{
    Memory_Alloc_Table *pm=(Memory_Alloc_Table*)(pool->memory_start+sizeof(Memory_Pool)+sizeof(Memory_Map_Table)*(pool->block_cnt));
    return pm;
}

char *memory_pos(Memory_Pool *pool)
{
        char *pm = (char *)(pool->memory_start + sizeof(Memory_Pool) +
                        (sizeof(Memory_Map_Table) + sizeof(Memory_Alloc_Table))* pool->block_cnt);
        return pm;
}

Memory_Pool *memory_pool_init(int size,int increment)
{
    char *p = NULL;
        char *p_memory = NULL;
        Memory_Pool *pool = NULL;
        Memory_Alloc_Table *alloc_table = NULL;
        Memory_Alloc_Table *p_alloc_table = NULL;
        Memory_Map_Table *map_table = NULL;
        Memory_Map_Table *p_map_table = NULL;
        int block_cnt = 0;
        int all_size = 0;
        int i = 0;

        if (size < 0 || size > MAX_POOL_SIZE) {
                printf("memory_pool_init(): Invalid size(%d)\n", size);
                return pool;
        }

        block_cnt = ((size + BLOCK_SIZE - 1) / BLOCK_SIZE);
        all_size = sizeof(Memory_Pool) + (sizeof(Memory_Map_Table) +
                        sizeof(Memory_Alloc_Table)) * block_cnt + size;
        p = (char *)malloc(all_size);
        if (p == NULL) {
                perror("Malloc failed\n");
                return pool;
        }

        memset(p, 0, all_size);

        pool = (Memory_Pool *)p;
        pool->block_cnt = block_cnt;
        pool->block_size = BLOCK_SIZE;
        pool->increment = increment;
        pool->internal_total_size = BLOCK_SIZE * block_cnt;
        pool->total_size = size;
        pool->used_size = 0;
        pool->alloc_cnt = 0;
        pool->memory_start = p;

        p_memory = memory_pos(pool);
        map_table = map_table_pos(pool);
        for (i = 0; i < block_cnt; i++) {
                p_map_table = (Memory_Map_Table *)((char *)map_table + i * sizeof(Memory_Map_Table));
                p_map_table->index = 0;
                p_map_table->p_block = p_memory + i * BLOCK_SIZE;
                p_map_table->used = 0;
        }

        alloc_table=alloc_table_pos(pool);
        for (i = 0; i < block_cnt; i++) {
                p_alloc_table = (Memory_Alloc_Table *)((char *)alloc_table + i * sizeof(Memory_Alloc_Table));
                p_alloc_table->block_cnt = 0;
                p_alloc_table->block_start_index = -1;
                p_alloc_table->p_start = NULL;
                p_alloc_table->used = 0;
        }

        printf("memory_pool_init: total size: %d, block cnt: %d, block size: %d\n",
                        pool->total_size, pool->block_cnt, BLOCK_SIZE);
        return pool;
}

void *Memory_malloc(Memory_Pool *pool,int size)
{
    char *p_start = NULL;
        int need_block_cnt = 0;
    Memory_Alloc_Table *alloc_table = NULL;
        Memory_Alloc_Table *p_alloc_table = NULL;
        Memory_Map_Table *map_table = NULL;
        Memory_Map_Table *p_map_table = NULL;

        int block_cnt = 0;
        int start_index = -1;
        int i = 0;

        if (size <= 0) {
                printf("Invalid size(%d)\n", size);
                return p_start;
        }

        if (size > pool->total_size) {
                printf("%d is more than total size\n", size);
                return p_start;
        }

        if (size > pool->total_size - pool->used_size) {
                printf("Free memory(%d) is less than allocate(%d)\n",
                pool->total_size - pool->used_size, size);
                return NULL;
        }

        need_block_cnt = (size + BLOCK_SIZE - 1) / BLOCK_SIZE;
        map_table = map_table_pos(pool);

        start_index = -1;
        for (i = 0; i < pool->block_cnt; i++) {
                p_map_table = (Memory_Map_Table *)((char *)map_table + i * sizeof(Memory_Map_Table));
                if (p_map_table->used) {
                        block_cnt = 0;
                        start_index = -1;
                        continue;
                }

                if (start_index == -1) {
                        start_index = i;
                }
                block_cnt++;

                if (block_cnt == need_block_cnt) {
                        break;
                }
        }

        if (start_index == -1) {
                printf("No available memory to used\n");
                return NULL;
        }

        alloc_table = alloc_table_pos(pool);

        for (i = 0; i < pool->block_cnt; i++) {
                p_alloc_table = (Memory_Alloc_Table *)((char *)alloc_table + i * sizeof(Memory_Alloc_Table));
                if (p_alloc_table->used == 0) {
                        break;
                }
                p_alloc_table = NULL;
        }

        if (p_alloc_table == NULL) {
                return NULL;
        }
        p_map_table = (Memory_Map_Table *)((char *)map_table + sizeof(Memory_Map_Table) * start_index);
        p_alloc_table->p_start = p_map_table->p_block;
        p_alloc_table->block_start_index = p_map_table->index;
        p_alloc_table->block_cnt = block_cnt;
        p_alloc_table->used = 1;

        for (i = start_index; i < start_index + block_cnt; i++) {
                p_map_table = (Memory_Map_Table *)((char *)map_table + i * sizeof(Memory_Map_Table));
                p_map_table->used = 1;
        }

        printf("Alloc size: %d, Block: (start: %d, end: %d, cnt: %d)\n", size,
                        start_index, start_index + block_cnt - 1, block_cnt);
        pool->alloc_cnt++;
        pool->used_size += size;
        return p_alloc_table->p_start;
}

void memory_free(Memory_Pool *pool,void *memory)
{
    Memory_Alloc_Table *alloc_table=NULL;
    Memory_Alloc_Table *p_alloc_table=NULL;
    Memory_Map_Table *map_table=NULL;
    Memory_Map_Table *p_map_table=NULL;

    int i=0;
    int block_start_index=0;
    int block_cnt=0;

    if(memory==NULL)
    {
        printf("memory_free():memory is NULL.\n");
        return ;
    }

    if(pool==NULL)
    {
        printf("Pool is NULL.\n");
        return ;
    }

    alloc_table=alloc_table_pos(pool);
    for(i=0;i<pool->alloc_cnt;i++)
    {
        p_alloc_table=(Memory_Alloc_Table*)((char*)alloc_table)+i*sizeof(Memory_Alloc_Table);
        if(p_alloc_table->p_start==memory)
        {
            block_start_index=p_alloc_table->block_start_index;
            block_cnt=p_alloc_table->block_cnt;
        }
    }

    if(block_cnt==0)
    {
        return ;
    }

    map_table=map_table_pos(pool);
    printf("Block:Free:start:%d,end:%d,cnt:%d\n",block_start_index,block_start_index+block_cnt-1,block_cnt);
    for(i=block_start_index;i<block_start_index+block_cnt;i++)
    {
        p_map_table=(Memory_Map_Table*)((char*)map_table+i*sizeof(Memory_Map_Table));
        p_map_table->used=0;
    }

    p_alloc_table->used=0;
    pool->used_size=block_cnt*BLOCK_SIZE;
}

void memory_pool_destroy(Memory_Pool *pool)
{
    if(pool==NULL)
    {
        printf("memory_pool_destroy:pool is NULL.\n");
        return;
    }

    free(pool);

    pool=NULL;
}


int main()
{
    Memory_Pool *pool=NULL;
    char *p1=NULL;
    char *p2=NULL;
    int i=0;

    pool=memory_pool_init(1024,512);
    if(pool==NULL)
    printf("Memory pool init Failed.\n");

    for(i=0;i<2;i++)
    {
        p1=(char*)Memory_malloc(pool,ALLOC_SIZE);
        if(p1==NULL)
        {
            printf("malloc Failed.\n");
        }
        else{
            printf("Malloc success.\n");
        }
        memory_free(pool,p1);
    }


    return 0;
}
第008讲 内存映射原理及系统调用

#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

typedef struct
{
    /* data */
    char name[4];
    int age;
}people;


void main(int argc,char**argv)
{
    int fd,i;
    people *p_map;
    char temp;
    fd=open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777);

    lseek(fd,sizeof(people)*5-1,SEEK_SET);
    write(fd,"",1);

    p_map=(people*)mmap(NULL,sizeof(people)*10,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if(p_map==(void*)-1)
    {
        fprintf(stderr,"mmap : %s \n",strerror(errno));
        return ;
    }
    close(fd);

    temp='A';
    for(i=0;i<10;i++)
    {
        temp=temp+1;
        (*(p_map+i)).name[1]='\0';
        memcpy((*(p_map+i)).name,&temp,1);
        (*(p_map+i)).age=30+i;
    }

    printf("Initialize.\n");

    sleep(15);

    munmap(p_map,sizeof(people)*10);

    printf("UMA OK.\n");

}




#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

typedef struct
{
    /* data */
    char name[4];
    int age;
}people;

void main(int argc,char**argv)
{
    int fd,i;
    people *p_map;

    fd=open(argv[1],O_CREAT|O_RDWR,00777);
    p_map=(people*)mmap(NULL,sizeof(people)*10,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if(p_map==(void*)-1)
    {
        fprintf(stderr,"mmap : %s \n",strerror(errno));
        return ;
    }

    for(i=0;i<10;i++)
    {
        printf("name:%s age:%d\n",(*(p_map+i)).name,(*(p_map+i)).age);
    }

    munmap(p_map,sizeof(people)*10);

}


#include <unistd.h>
#include <signal.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/mman.h>

#define handle_error(msg) do{ perror(msg); exit(EXIT_FAILURE);}while(0)

static char *buffer;

static void handler(int sig,siginfo_t *si,void *unused)
{
    printf("Get SIGSEGV at address : %p\n",si->si_addr);
    exit(EXIT_FAILURE);
}

int main(int argc,char *argv[])
{
    int pagesize;
    struct sigaction sa;

    sa.sa_flags=SA_SIGINFO;
    sigemptyset(&sa.sa_mask);
    sa.sa_sigaction=handler;

    if(sigaction(SIGSEGV,&sa,NULL)==-1)
        handle_error("siaction");

    pagesize=sysconf(_SC_PAGE_SIZE);
    if(pagesize==-1)
        handle_error("sysconf");

    buffer=memalign(pagesize,4*pagesize);
    if(buffer==NULL)
        handle_error("memalign");

    printf("start of region : %p\n",buffer);

    if(mprotect(buffer+pagesize*2,pagesize,PROT_READ)==-1)
        handle_error("mprotect");

        for(char *p=buffer;;)
        *(p++)='A';

        printf("for completed.\n");
        exit(EXIT_SUCCESS);

    return 0;
}
vma
#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/sched.h>

static int pid;
module_param(pid,int,S_IRUGO);


static void PrintFunc(struct task_struct *task)
{
    struct mm_struct *mm;
    struct vm_area_struct *vma;

    int i=0;
    unsigned long start,end,length;

    mm=task->mm;
    pr_info(" mm=%p \n",mm);

    vma=mm->mmap;
    down_read(&mm->mmap_sem);

    pr_info("vmas:vma          start          end\t\tlength\n");

    while(vma)
    {
        i++;
        start=vma->vm_start;
        end=vma->vm_end;
        length=end-start;
        pr_info("%d:%p--%lx--%lx=%ld\n",i,vma,start,end,length);
        vma=vma->vm_next;
    }
    up_read(&mm->mmap_sem);

}

static int __init myvma_init(void)
{
    struct task_struct *task;
    if(pid==0)
    {
        task=current;
        pid=current->pid;
    }
    else
    {
        task=pid_task(find_vpid(pid),PIDTYPE_PID);
    }

    if(!task)
    {
        return -1;
    }
    pr_info("Exam vma's for pid=%d,command=%s\n",pid,task->comm);
    PrintFunc(task);

    return 0;
}

static void __exit myvma_exit(void)
{
    pr_info("\n Module uninstalled successfully.\n");
}

module_init(myvma_init);
module_exit(myvma_exit);

MODULE_AUTHOR("Vico");
MODULE_LICENSE("GPL");
6-同步管理-RCU实现
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/rcupdate.h>
#include <linux/kthread.h>
#include <linux/delay.h>

struct ftestrcu
{
    int a;
    struct rcu_head rcu;
};
static struct ftestrcu *g_ptr;

static int myrcu_reader_thread1(void *data)
{
    struct ftestrcu *p1 = NULL;
    while (1)
    {
        if (kthread_should_stop())
            break;
        msleep(10);

        rcu_read_lock();
        mdelay(100);
        p1 = rcu_dereference(g_ptr);
        if (p1)
            printk("%s: Read1 a1=%d\n", __func__, p1->a);
        rcu_read_unlock();
    }

    return 0;
}
static int myrcu_reader_thread2(void *data)
{
    struct ftestrcu *p2 = NULL;
    while (1)
    {
        if (kthread_should_stop())
            break;
        msleep(20);
        rcu_read_lock();
        mdelay(200);
        p2 = rcu_dereference(g_ptr);
        if (p2)
            printk("%s:Read2 a2=%d\n", __func__, p2->a);

        rcu_read_unlock();
    }

    return 0;
}

static void myrcu_del(struct rcu_head *rh)
{
    struct ftestrcu *p = container_of(rh, struct ftestrcu, rcu);
    printk("%s: a=%d\n", __func__, p->a);
    kfree(p);
}

static int myrcu_writer_thread(void *p)
{
    struct ftestrcu *old;
    struct ftestrcu *new_ptr;
    int value = (unsigned long)p;

    while (1)
    {
        if (kthread_should_stop())
            break;
        msleep(300);

        new_ptr = kmalloc(sizeof(struct ftestrcu), GFP_KERNEL);
        old = g_ptr;
        *new_ptr = *old;
        new_ptr->a = value;

        rcu_assign_pointer(g_ptr, new_ptr);
        call_rcu(&old->rcu, myrcu_del);
        printk("%s: Write to new %d\n", __func__, value);
        value++;
    }

    return 0;
}

static struct task_struct *reader_thread1;
static struct task_struct *reader_thread2;
static struct task_struct *writer_thread;

static int __init myrcu_init(void)
{
    int value = 5;
    printk("\n\nRCU Module Init OK.\n");
    g_ptr = kzalloc(sizeof(struct ftestrcu), GFP_KERNEL);
    reader_thread1 = kthread_run(myrcu_reader_thread1, NULL, "Rcu_reader1");
    reader_thread2 = kthread_run(myrcu_reader_thread2, NULL, "Rcu_reader2");
    writer_thread = kthread_run(myrcu_writer_thread, (void *)(unsigned long)value, "Rcu_Writer");

    return 0;
}

static void __exit myrcu_exit(void)
{
    printk("\nRCU Unloading Module Exit.\n\n");
    kthread_stop(reader_thread1);
    kthread_stop(reader_thread2);
    kthread_stop(writer_thread);
    if (g_ptr)
        kfree(g_ptr);
}

module_init(myrcu_init);
module_exit(myrcu_exit);

MODULE_AUTHOR("Vico");
MODULE_LICENSE("GPL");
第004讲 2进程优先级与调度策略实战
#include <stdio.h>
#include <pthread.h>
#include <sched.h>
#include <assert.h>

static int get_thread_policy(pthread_attr_t *attr)
{
    int plicy;
    int rs=pthread_attr_getschedpolicy(attr,&plicy);

    assert(rs==0);

    switch(plicy)
    {
        case SCHED_FIFO:
        printf("policy=SCHED_FIFO.\n");
        break;

        case SCHED_RR:
        printf("policy=SCHED_RR.\n");
        break;

        case SCHED_OTHER:
        printf("policy=SCHED_OTHER.\n");
        break;

        default:
        printf("policy=UNKNOWN.\n");
        break;
    }

    return plicy;
}

static void show_thread_priority(pthread_attr_t *attr,int policy)
{
    int priority=sched_get_priority_max(policy);
    assert(priority!=-1);
    printf("max_priority=%d\n",priority);

    priority=sched_get_priority_min(policy);
    assert(priority!=-1);
    printf("min_priority=%d\n",priority);
}


static int get_thread_priority(pthread_attr_t *attr)
{
    struct sched_param param;
    int rs=pthread_attr_getschedparam(attr,&param);
    assert(rs==0);

    printf("priority=%d",param.__sched_priority);


    return param.__sched_priority;
}


static void set_thread_policy(pthread_attr_t *attr,int policy)
{
    int rs=pthread_attr_setschedpolicy(attr,policy);

    assert(0==rs);

    get_thread_policy(attr);

}

int main()
{
    pthread_attr_t attr;
    struct sched_param sched;

    int rs=pthread_attr_init(&attr);
    assert(0==rs);

    int plicy=get_thread_policy(&attr);
    printf("output current configuration of priority.\n");
    show_thread_priority(&attr,plicy);

    printf("output SCHED_FIFO of priority.\n");
    show_thread_priority(&attr,SCHED_FIFO);

    printf("output SCHED_RR of priority.\n");
    show_thread_priority(&attr,SCHED_RR);
    printf("output priority of current thread.\n");

    int priority=get_thread_priority(&attr);
    printf("set thrad policy.\n");
    printf("set SCHED_FIFO polity.\n");
    set_thread_policy(&attr,SCHED_FIFO);

    printf("set SCHED_RR policy.\n");
    set_thread_policy(&attr,SCHED_RR);
    printf("restore current policy.\n");
    set_thread_policy(&attr,plicy);

    rs=pthread_attr_destroy(&attr);
    assert(0==rs);

    return 0;
}




#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>


void threadfunc1()
{
    sleep(1);
    int policy;
    struct sched_param praram;
    pthread_getschedparam(pthread_self(),&policy,&praram);

    if(policy==SCHED_OTHER)
    printf("SCHED_OTHER.\n");
    if(policy==SCHED_RR)
    ;
    printf("SCHED_RR 1.\n");
    if(policy==SCHED_FIFO)
    printf("SCHED_FIFO.\n");

    for(int i=1;i<=10;i++)
    {
        for(int j=1;j<4000000;j++){

        }
        printf("Threadfunc1.\n");
    }
    printf("pthreadfunc1 EXIT.\n");

}

void threadfunc2()
{
    sleep(1);
    int policy;
    struct sched_param praram;
    pthread_getschedparam(pthread_self(),&policy,&praram);

    if(policy==SCHED_OTHER)
    printf("SCHED_OTHER.\n");
    if(policy==SCHED_RR)
    ;
    printf("SCHED_RR 1.\n");
    if(policy==SCHED_FIFO)
    printf("SCHED_FIFO.\n");

    for(int i=1;i<=10;i++)
    {
        for(int j=1;j<4000000;j++){

        }
        printf("Threadfunc2.\n");
    }
    printf("pthreadfunc2 EXIT.\n");


}

void threadfunc3()
{
    sleep(1);
    int policy;
    struct sched_param praram;
    pthread_getschedparam(pthread_self(),&policy,&praram);

    if(policy==SCHED_OTHER)
    printf("SCHED_OTHER.\n");
    if(policy==SCHED_RR)
    ;
    printf("SCHED_RR 1.\n");
    if(policy==SCHED_FIFO)
    printf("SCHED_FIFO.\n");

    for(int i=1;i<=10;i++)
    {
        for(int j=1;j<4000000;j++){

        }
        printf("Threadfunc3.\n");
    }
    printf("pthreadfunc3 EXIT.\n");


}

int main()
{
    int i;
    i=getuid();

    if(i==0)
    printf("the current user is root.\n");
    else
    printf("the current user is not root.\n");

    pthread_t ppid1,ppid2,ppid3;
    struct sched_param param;

    pthread_attr_t attr1,attr2,attr3;

    pthread_attr_init(&attr2);
    pthread_attr_init(&attr1);
    pthread_attr_init(&attr3);

    param.sched_priority=51;

    pthread_attr_setschedpolicy(&attr3,SCHED_RR);
    pthread_attr_setschedparam(&attr3,&param);
    pthread_attr_setinheritsched(&attr3,PTHREAD_EXPLICIT_SCHED);

    param.sched_priority=22;
    pthread_attr_setschedpolicy(&attr2,SCHED_RR);
    pthread_attr_setschedparam(&attr2,&param);
    pthread_attr_setinheritsched(&attr2,PTHREAD_EXPLICIT_SCHED);

    pthread_create(&ppid3,&attr1,(void*)threadfunc3,NULL);
    pthread_create(&ppid2,&attr2,(void*)threadfunc2,NULL);
    pthread_create(&ppid1,&attr3,(void*)threadfunc1,NULL);

    pthread_join(ppid3,NULL);
    pthread_join(ppid2,NULL);
    pthread_join(ppid1,NULL);

    pthread_attr_destroy(&attr3);
    pthread_attr_destroy(&attr2);
    pthread_attr_destroy(&attr1);

    return 0;
}

总结

太花时间，原谅我，留着后面理解------

长友cy
关注
专栏目录
【0000】PostgreSQL V13.2内核源码剖析专栏（2018 ~ 2024.10.24 更新）
专注【PostgreSQL源码学习&研究】
12-13 4058
本专栏将会持续更新，直到将PostgreSQL V13.2源码涉及的所有原理、技术剖析完成为止。每一篇文章都是经过多次的源码阅读 + 调试，得以验证之后才梳理成文章形式。最终该专栏的文章数量应该在一万篇或以下，这也是文章序号从【0000】开始的缘故。通过本专栏的学习，能够让你掌握PostgreSQL数据库中的每个技术背后，底层的实现原理。
一步一图带你深入理解 Linux 物理内存管理
木牛的博客
11-26 1077
在我们理解了物理内存的 NUMA 架构，以及在 NUMA 架构下的内存分配策略之后，本小节笔者来为大家介绍下如何正确的利用 NUMA 提升我们应用程序的性能。前边我们介绍了这么多的理论知识，但是理论的东西总是很虚，正所谓眼见为实，大家一定想亲眼看一下 NUMA 架构在计算机中的具体表现形式，比如：在支持 NUMA 架构的机器上到底有多少个 NUMA 节点？每个 NUMA 节点包含哪些 CPU 核，具体是怎样的一个分布情况？前面也提到 CPU 在访问本地 NUMA 节点中的内存时，速度是最快的。
linux内存管理中的page
shenhuxi_yu的专栏
05-09 1261
内核中最初勾引我好奇心的还是内存管理方面，我们平时编写应用程序时，一个进程所能拥有的内存大小几乎可以趋近于物理内存最大值或是超越这个值，虽然知道内核做内存方面的映射或是swap然后向我们的用户空间呈现出所谓的虚拟内存，但还是对其中实现疑惑甚多，一些关于内存的名词也是有许多，什么虚拟地址，内核线性地址，内核逻辑地址，balablabla… 屁话不讲了，我们直接来看内核底层是如何来管理物
Linux内核内存管理：linux三种内存模型
最新发布
m0_74282605的博客
12-18 1207
Memory model也是一个演进过程，刚开始的时候，使用flat memory去抽象一个连续的内存地址空间（mem_maps[]），出现NUMA之后，整个不连续的内存空间被分成若干个node，每个node上是连续的内存地址空间，也就是说，原来的单一的一个mem_maps[]变成了若干个mem_maps[]了。为了不增加大家的阅读负担，关于sparse内存模型的介绍到此为止，关于它的具体实现，本人也没有研究过，实际工作中也没有接触到，所以以后有时间再研究。所以如果配置了多个结点，在编译的时候应该会报错。
STM32F103 ucLinux开发之四（内核启动后的调试）
weixin_30735391的博客
01-10 323
Stm32-uclinux启动后的调试 1、 修改__pfn_to_page使得能够启动 根据STM32F103 ucLinux开发之三（内核启动后不正常）的描述，内核无法启动是选择了平板内存模式后，下面两个宏定义，导致计算错误，从而Backtrace的。 #define __pfn_to_page(pfn) (mem_map + ((pfn) - ARCH_PFN_OFFSET)...
linux 逆向映射机制浅析
weixin_39094034的博客
12-11 446
闲话不多说，之前一个问题是想要根据物理页框号得到映射的虚拟地址，一时间不知道如何下手了，在群里和一个朋友讨论了一番，记得之前看swap机制的交换缓存时，记载说系统当要换出一个页面时，可以很容易找到使用该页面的所有进程，然后撤销映射。这一点也就成了我的突破口。经过对源码的一番研究结合相关书籍，便有了今天这篇文章。重点就是逆向映射机制。 顾名思义，有一个虚拟地址经过页面转换得到物理地址的过程为正向映射，那么根据物理地址推导虚拟地址呢？自然成了逆向映射。众所周知，Linux下每个物理页面对应一个page结构，物
linux内存模型
生活需要深度
04-11 2190
前面已经分析把物理内存添加到memblock以及给物理内存建立页表映射，这里我们分析内存模型。在Linux内核中支持3种内存模型，分别为 flat memory model Discontiguous memory model sparse memory model 所谓memory model，其实就是从cpu的角度看，其物理内存的分布情况，在linux kernel中，使用什么的方式来管理这些物理内存。某些体系架构支持多种内存模型，但在内核编译构建时只能选择使用一种内存模型。 1. 基本概念 1.
Linux内核源码分析：基于最新的Linux 4.0内核（学习路线总结）
Linuxhus的博客
04-27 699
今天给大家分享的是基于最新的Linux 4.0内核学习路线总结，本文由8个专题组成，文末附上学习路线思维导图。 一、进程管理专题 1、进程原理 1.1 进程生命周期 1.2 task_struct结构 1.3 进程优先级 1.4 进程系统调用 2、 进程调度机制 2.1 调度器实现schedule() 2.2 完全公平调度类CFS 2.3 实时调度类原理 2.4 多核模式调度SMP 3、进程竞争机制 3.1 RCU机制原理 3.2 内存优化与屏障 3.3 大内核锁 3.4 p
Linux内核性能优化实战演练
Chinese_big_boy的博客
08-25 775
整理了一些个人觉得比较好的Linux相关学习书籍、Linux内核视频资料共享在群里面，有需要的可以自行添加哦！】小编推荐自己的Linux内核源码交流群:【套路篇：磁盘 I/O 性能优化的几个思路。
Linux内核地址空间布局详解
m0_74282605的博客
03-10 1006
具体在init_mem_mapping()中创建的。init_mem_mapping()在创建线性地址空间(direct mapping)页表的过程中，使用alloc_low_pages()函数从pgt_buf中分配内存，用来当做p4d/pud/pmd/pte使用。并且使用__pa()来访问它的物理内存。是一个x86-64特有的功能，开启以后会随机化线性映射区域基址(page_offset_base)、vmalloc区域基址(vmalloc_base)、vmemmap区域基址(vmemmap_base)。
linux内核设计与实现
m0_74282605的博客
03-20 876
/禁止中断请求锁 spin_lock_irqsave(&mr_lock);//确保中断是激活的情况可用的方法 spin_lock_irq(&mr_lock) /**临界区**/ spin_unlock_irq(&mr_lock) spin_unlock_irqrestore(&mr_lock);/**只读临界区**/ read_unlock(&mr_rwlock) write_lock(&mr_rwlock) /**读写临界区**/ write_unlock(&mr_rwlock)以达到快速检索的目的。
linux内存伙伴算法(二：初始化内存域和数据结构)
云计算?
09-03 204
体系结构相关代码需要在启动期间建立以下信息： 1.系统中各个内存域的页帧边界，保存在max_zone_pfn中 2.个结点页帧的分配情况，保存在全局变量early_node_map中。 从内核版本2.6.10开始提供一个通用的框架，用于将上述信息转换为伙伴系统预期的结点和内存域数据结构。在这以前，各个体系结构必须自行建立相关结构。现在，体系结构相关代码只需要建立前述的简单结构，将繁重的工作留...
Linux物理内存管理：page、zone、node
weixin_42136255的博客
01-06 1289
Linux物理内存管理：page、zone、node
linux内存默认值,初始化内存域和数据结构 - Linux内存管理伙伴算法_Linux编程_Linux公社-Linux系统门户网站...
weixin_36348900的博客
04-30 326
体系结构相关代码需要在启动期间建立以下信息：1.系统中各个内存域的页帧边界，保存在max_zone_pfn中2.个结点页帧的分配情况，保存在全局变量early_node_map中。从内核版本2.6.10开始提供一个通用的框架，用于将上述信息转换为伙伴系统预期的结点和内存域数据结构。在这以前，各个体系结构必须自行建立相关结构。现在，体系结构相关代码只需要建立前述的简单结构，将繁重的工作留给free_...
linux 3.4.10 内核内存管理源代码分析4:伙伴系统内存释放
ancjf的专栏
05-21 1987
法律声 3.4.10 内核内存管理源代码分析》系列文章由机器人（ancjf@163.com）发表于http://blog.csdn.net/ancjf，文章遵循GPL协议。欢迎转载，转载请注明作者和此条款。
linux page结构定义,page结构体，何处安放你的灵魂？
weixin_30752653的博客
05-14 673
原创 理查德 Linux阅码场 7月14日随着硬件能力的提升，系统内存容量变得越来越大。尤其是在服务器上，过T级别的内存容量也已经不罕见了。如此海量内存给内核带来了很多挑战，其中之一就是page struct存放在哪里。page struct的三种存放方式在内核中，我们将物理内存按照页大小进行管理。这样每个页就对应一个page struct作为这个页的管理数据结构。随着内存容量的增加，相对应的...
Linux内存管理 | 四、物理地址空间设计模型
Donge's Blog
10-24 510
以上，我们先对物理内存空间有一个基础的了解，明白物理内存空间的内存访问模型和组织模型，下面我们再详细介绍物理内存空间的布局和管理。
linux pfn,ARM Linux下的page和pfn之间转换的宏。
weixin_36111677的博客
05-26 435
ARM Linux下的page和pfn之间转换的宏如下：1)page_to_pfn2)pfn_to_page这两个宏依赖于内核编译时，选择的内存模型。在include/asm-generic/memory_model.h文件中定义了这两个宏。include/asm-generic/memory_model.h1 #ifndef __ASM_MEMORY_MODEL_H2 #define __ASM...
Linux内存模型
weixin_33858485的博客
02-13 343
一、前言 在linux内核中支持3中内存模型，分别是flat memory model，Discontiguous memory model和sparse memory model。所谓memory model，其实就是从cpu的角度看，其物理内存的分布情况，在linux kernel中，使用什么的方式来管理这些物理内存。另外，需要说明的是：本文主要focus在share memory的系统，也就...
Linux内核源码解析：进程管理与硬件上下文
在Linux内核源代码的学习中，"硬件上下文-Linux内核源代码导读-陈香兰-进程管理"这一章节深入探讨了操作系统如何在进程管理和硬件资源交互中确保正确的执行流程。核心概念涉及到了硬件上下文，即在进程恢复执行前，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值