精华内容
下载资源
问答
  • 本文也演示了内核空间和用户空间进行通信可以使用两种常用方法: proc文件系统和mmap共享内存。 整个内核模块,在模块插入时建立proc文件,分配内存。卸载模块时候将用户空间写入内容打印出来。 以下是内核...

    动态的将内核空间的物理地址和大小传给用户空间。本文也演示了内核空间和用户空间进行通信可以使用的两种常用方法:

    proc文件系统和mmap共享内存
    整个内核模块,在模块插入时建立proc文件,分配内存。卸载模块的时候将用户空间写入的内容打印出来。
    以下是内核模块的代码和用户空间的测试代码。

    /*This program is used to allocate memory in kernel
    and pass the physical address to userspace through proc file.*/


    #include <Linux/version.h>
    #include <linux/module.h>
    #include <linux/proc_fs.h>
    #include <linux/mm.h>

    #define PROC_MEMSHARE_DIR "memshare"
    #define PROC_MEMSHARE_PHYADDR "phymem_addr"
    #define PROC_MEMSHARE_SIZE "phymem_size"

    /*alloc one page. 4096 bytes*/
    #define PAGE_ORDER 0
    /*this value can get from PAGE_ORDER*/
    #define PAGES_NUMBER 1

    struct proc_dir_entry *proc_memshare_dir ;
    unsigned long kernel_memaddr = 0;
    unsigned long kernel_memsize= 0;

    static int proc_read_phymem_addr(char *page, char **start, off_t off, int count)
    {
            return sprintf(page, "%08lx/n", __pa(kernel_memaddr));
    }
    static int proc_read_phymem_size(char *page, char **start, off_t off, int count)
    {
            return sprintf(page, "%lu/n", kernel_memsize);
    }

    static int __init init(void)
    {
            /*build proc dir "memshare"and two proc files: phymem_addr, phymem_size in the dir*/
             proc_memshare_dir = proc_mkdir(PROC_MEMSHARE_DIR, NULL);
             create_proc_info_entry(PROC_MEMSHARE_PHYADDR, 0, proc_memshare_dir,proc_read_phymem_addr);
             create_proc_info_entry(PROC_MEMSHARE_SIZE, 0, proc_memshare_dir,proc_read_phymem_size);

            /*alloc one page*/
             kernel_memaddr =__get_free_pages(GFP_KERNEL, PAGE_ORDER);
            if(!kernel_memaddr)
            {
                     printk("Allocate memory failure!/n");
            }
            else
            {
                     SetPageReserved(virt_to_page(kernel_memaddr));

    内核中申请到页面之后,要调用一下SetPageReserved,相当于告诉系统,这个页面我已经占了。对于每一个申请到的页面,应该都要这样做

                     kernel_memsize = PAGES_NUMBER * PAGE_SIZE;
                     printk("Allocate memory success!. The phy mem addr=%08lx, size=%lu/n",__pa(kernel_memaddr), kernel_memsize);
            }
            return 0;
    }

    static void __exit fini(void)
    {
             printk("The content written by user is: %s/n", (unsigned char *) kernel_memaddr);
             ClearPageReserved(virt_to_page(kernel_memaddr));
             free_pages(kernel_memaddr, PAGE_ORDER);
             remove_proc_entry(PROC_MEMSHARE_PHYADDR, proc_memshare_dir);
             remove_proc_entry(PROC_MEMSHARE_SIZE, proc_memshare_dir);
             remove_proc_entry(PROC_MEMSHARE_DIR, NULL);

            return;
    }
    module_init(init);
    module_exit(fini);
    MODULE_LICENSE("GPL");
    MODULE_AUTHOR("Godbach ([email]nylzhaowei@163.com[/email])");
    MODULE_DESCRIPTION("Kernel memory share module.");


    用户空间的测试代码:

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

    int main(int argc, char* argv[])
    {
            if(argc != 2)
            {
                    printf("Usage: %s string/n", argv[0]);
                    return 0;
            }
            
            unsigned long phymem_addr, phymem_size;
            char *map_addr;
            char s[256];
            int fd;
            
            /*get the physical address of allocated memory in kernel*/
             fd = open("/proc/memshare/phymem_addr", O_RDONLY);
            if(fd < 0)
            {
                    printf("cannot open file /proc/memshare/phymem_addr/n");
                    return 0;
            }
            read(fd, s, sizeof(s));
            sscanf(s, "%lx", &phymem_addr);
            close(fd);

            /*get the size of allocated memory in kernel*/
             fd = open("/proc/memshare/phymem_size", O_RDONLY);
            if(fd < 0)
            {
                    printf("cannot open file /proc/memshare/phymem_size/n");
                    return 0;
            }
            read(fd, s, sizeof(s));
            sscanf(s, "%lu", &phymem_size);
            close(fd);
            
            printf("phymem_addr=%lx, phymem_size=%lu/n", phymem_addr, phymem_size);
            /*memory map*/
            int map_fd = open("/dev/mem", O_RDWR);
            if(map_fd < 0)
            {
                    printf("cannot open file /dev/mem/n");
                    return 0;
            }
            
             map_addr = mmap(0, phymem_size, PROT_READ|PROT_WRITE, MAP_SHARED, map_fd, phymem_addr);
            strcpy(map_addr, argv[1]);
             munmap(map_addr, phymem_size);
            close(map_fd);
            return 0;
            
    }

    测试的内核是2.6.25.以下是执行结果。

    debian:/home/km/memshare# insmod memshare_kernel.ko
    debian:/home/km/memshare# ./memshare_user 'hello,world!'
    phymem_addr=e64e000, phymem_size=4096
    debian:/home/km/memshare# cat /proc/memshare/phymem_addr 
    0e64e000
    debian:/home/km/memshare# cat /proc/memshare/phymem_size 
    4096
    debian:/home/km/memshare# rmmod memshare_kernel
    debian:/home/km/memshare# tail /var/log/messages
    Sep 27 18:14:24 debian kernel: [50527.567931] Allocate memory success!. The phy mem addr=0e64e000, size=4096
    Sep 27 18:15:31 debian kernel: [50592.570986] The content written by user is: hello,world!


    用你这种方式,想申请4M的内存,
    static int __init init(void) 
    { 
         char * paddr; 
         int order = 0; 
         int offset = 0; 
         int tmp = 0; 
         
             /*build proc dir "memshare"and two proc files: phymem_addr, phymem_size in the dir*/ 
             proc_memshare_dir = proc_mkdir(PROC_MEMSHARE_DIR, NULL); 
             create_proc_info_entry(PROC_MEMSHARE_PHYADDR, 0, proc_memshare_dir, proc_read_phymem_addr); 
             create_proc_info_entry(PROC_MEMSHARE_SIZE,     0, proc_memshare_dir, proc_read_phymem_size); 

             /*alloc one page*/ 
             //kernel_memaddr =__get_free_pages(GFP_KERNEL, PAGE_ORDER); 
            order = get_order(4000000); 
             kernel_memaddr =__get_free_pages(GFP_KERNEL, order);

             if(!kernel_memaddr) 
             { 
                     printk("Allocate memory failure!/n"); 
             } 
             else 
             { 
                     SetPageReserved(virt_to_page(kernel_memaddr)); 

                     //kernel_memsize = PAGES_NUMBER * PAGE_SIZE; 
                    kernel_memsize = ((4000000 - 1) >> PAGE_SHIFT)* PAGE_SIZE;
    我在内核中往第一页(4k范围内)写数据,在用户态是能够读出来的,但是如果向以后的其它页写数据时,用户态就读不出了, 
    用户态写也这样。 

    需要对每个4k的页面执行:SetPageReserved(virt_to_page(kernel_memaddr));

    内核中申请到页面之后,要调用一下SetPageReserved,相当于告诉系统,这个页面我已经占了。对于每一个申请到的页面,应该都要这样做。

    create_proc_info_entry(PROC_MEMSHARE_PHYADDR, 0, proc_memshare_dir,proc_read_phymem_addr);
             create_proc_info_entry(PROC_MEMSHARE_SIZE, 0, proc_memshare_dir,proc_read_phymem_size);

            /*alloc one page*/
             kernel_memaddr =__get_free_pages(GFP_KERNEL, PAGE_ORDER);
            if(!kernel_memaddr)
            {
                     printk("Allocate memory failure!/n");
            }
            else
            {
                     SetPageReserved(virt_to_page(kernel_memaddr));

    内核中申请到页面之后,要调用一下SetPageReserved,相当于告诉系统,这个页面我已经占了。对于每一个申请到的页面,应该都要这样做

                     kernel_memsize = PAGES_NUMBER * PAGE_SIZE;
                     printk("Allocate memory success!. The phy mem addr=%08lx, size=%lu/n",__pa(kernel_memaddr), kernel_memsize);
            }
            return 0;
    }

    static void __exit fini(void)
    {
             printk("The content written by user is: %s/n", (unsigned char *) kernel_memaddr);
             ClearPageReserved(virt_to_page(kernel_memaddr));
             free_pages(kernel_memaddr, PAGE_ORDER);
             remove_proc_entry(PROC_MEMSHARE_PHYADDR, proc_memshare_dir);
             remove_proc_entry(PROC_MEMSHARE_SIZE, proc_memshare_dir);
             remove_proc_entry(PROC_MEMSHARE_DIR, NULL);

            return;
    }
    module_init(init);
    module_exit(fini);
    MODULE_LICENSE("GPL");
    MODULE_AUTHOR("Godbach ([email]nylzhaowei@163.com[/email])");
    MODULE_DESCRIPTION("Kernel memory share module.");


    用户空间的测试代码:

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

    int main(int argc, char* argv[])
    {
            if(argc != 2)
            {
                    printf("Usage: %s string/n", argv[0]);
                    return 0;
            }
            
            unsigned long phymem_addr, phymem_size;
            char *map_addr;
            char s[256];
            int fd;
            
            /*get the physical address of allocated memory in kernel*/
             fd = open("/proc/memshare/phymem_addr", O_RDONLY);
            if(fd < 0)
            {
                    printf("cannot open file /proc/memshare/phymem_addr/n");
                    return 0;
            }
            read(fd, s, sizeof(s));
            sscanf(s, "%lx", &phymem_addr);
            close(fd);

            /*get the size of allocated memory in kernel*/
             fd = open("/proc/memshare/phymem_size", O_RDONLY);
            if(fd < 0)
            {
                    printf("cannot open file /proc/memshare/phymem_size/n");
                    return 0;
            }
            read(fd, s, sizeof(s));
            sscanf(s, "%lu", &phymem_size);
            close(fd);
            
            printf("phymem_addr=%lx, phymem_size=%lu/n", phymem_addr, phymem_size);
            /*memory map*/
            int map_fd = open("/dev/mem", O_RDWR);
            if(map_fd < 0)
            {
                    printf("cannot open file /dev/mem/n");
                    return 0;
            }
            
             map_addr = mmap(0, phymem_size, PROT_READ|PROT_WRITE, MAP_SHARED, map_fd, phymem_addr);
            strcpy(map_addr, argv[1]);
             munmap(map_addr, phymem_size);
            close(map_fd);
            return 0;
            
    }

    测试的内核是2.6.25.以下是执行结果。

    debian:/home/km/memshare# insmod memshare_kernel.ko
    debian:/home/km/memshare# ./memshare_user 'hello,world!'
    phymem_addr=e64e000, phymem_size=4096
    debian:/home/km/memshare# cat /proc/memshare/phymem_addr 
    0e64e000
    debian:/home/km/memshare# cat /proc/memshare/phymem_size 
    4096
    debian:/home/km/memshare# rmmod memshare_kernel
    debian:/home/km/memshare# tail /var/log/messages
    Sep 27 18:14:24 debian kernel: [50527.567931] Allocate memory success!. The phy mem addr=0e64e000, size=4096
    Sep 27 18:15:31 debian kernel: [50592.570986] The content written by user is: hello,world!


    展开全文
  • 本文也演示了内核空间和用户空间进行通信可以使用两种常用方法:proc文件系统和mmap共享内存。 整个内核模块,在模块插入时建立proc文件,分配内存。卸载模块时候将用户空间写入内容打印出来。 以下是内核...

    原文

    动态的将内核空间的物理地址和大小传给用户空间。本文也演示了内核空间和用户空间进行通信可以使用的两种常用方法:proc文件系统和mmap共享内存。

    整个内核模块,在模块插入时建立proc文件,分配内存。卸载模块的时候将用户空间写入的内容打印出来。
    以下是内核模块的代码和用户空间的测试代码。

    /*This program is used to allocate memory in kernel
    and pass the physical address to userspace through proc file.*/


    #include <linux/version.h>
    #include <linux/module.h>
    #include <linux/proc_fs.h>
    #include <linux/mm.h>

    #define PROC_MEMSHARE_DIR"memshare"
    #define PROC_MEMSHARE_PHYADDR"phymem_addr"
    #define PROC_MEMSHARE_SIZE"phymem_size"

    /*alloc one page. 4096 bytes*/
    #define PAGE_ORDER 0
    /*this value can get from PAGE_ORDER*/
    #define PAGES_NUMBER 1

    struct proc_dir_entry *proc_memshare_dir ;
    unsigned long kernel_memaddr= 0;
    unsigned long kernel_memsize= 0;

    static int proc_read_phymem_addr(char*page, char **start, off_t off,int count)
    {
            return sprintf(page,"%08lx\n", __pa(kernel_memaddr));
    }
    static int proc_read_phymem_size(char*page, char **start, off_t off,int count)
    {
            return sprintf(page,"%lu\n", kernel_memsize);
    }

    static int __init init(void)
    {
            /*build proc dir "memshare"and two proc files: phymem_addr, phymem_size in the dir*/
             proc_memshare_dir = proc_mkdir(PROC_MEMSHARE_DIR,NULL);
             create_proc_info_entry(PROC_MEMSHARE_PHYADDR, 0, proc_memshare_dir, proc_read_phymem_addr);
             create_proc_info_entry(PROC_MEMSHARE_SIZE, 0, proc_memshare_dir, proc_read_phymem_size);

            /*alloc one page*/
             kernel_memaddr =__get_free_pages(GFP_KERNEL, PAGE_ORDER);
            if(!kernel_memaddr)
            {
                     printk("Allocate memory failure!\n");
            }
            else
            {
                     SetPageReserved(virt_to_page(kernel_memaddr));

    内核中申请到页面之后,要调用一下SetPageReserved,相当于告诉系统,这个页面我已经占了。对于每一个申请到的页面,应该都要这样做

                     kernel_memsize = PAGES_NUMBER * PAGE_SIZE;
                     printk("Allocate memory success!. The phy mem addr=%08lx, size=%lu\n", __pa(kernel_memaddr), kernel_memsize);
            }
            return 0;
    }

    static void __exit fini(void)
    {
             printk("The content written by user is: %s\n",(unsigned char *) kernel_memaddr);
             ClearPageReserved(virt_to_page(kernel_memaddr));
             free_pages(kernel_memaddr, PAGE_ORDER);
             remove_proc_entry(PROC_MEMSHARE_PHYADDR, proc_memshare_dir);
             remove_proc_entry(PROC_MEMSHARE_SIZE, proc_memshare_dir);
             remove_proc_entry(PROC_MEMSHARE_DIR,NULL);

            return;
    }
    module_init(init);
    module_exit(fini);
    MODULE_LICENSE("GPL");
    MODULE_AUTHOR("Godbach ([email]nylzhaowei@163.com[/email])");
    MODULE_DESCRIPTION("Kernel memory share module.");


    用户空间的测试代码:

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

    int main(int argc,char* argv[])
    {
            if(argc!= 2)
            {
                    printf("Usage: %s string\n", argv[0]);
                    return 0;
            }
            
            unsigned long phymem_addr, phymem_size;
            char *map_addr;
            char s[256];
            int fd;
            
            /*get the physical address of allocated memory in kernel*/
             fd = open("/proc/memshare/phymem_addr", O_RDONLY);
            if(fd < 0)
            {
                    printf("cannot open file /proc/memshare/phymem_addr\n");
                    return 0;
            }
            read(fd, s,sizeof(s));
            sscanf(s,"%lx", &phymem_addr);
            close(fd);

            /*get the size of allocated memory in kernel*/
             fd = open("/proc/memshare/phymem_size", O_RDONLY);
            if(fd < 0)
            {
                    printf("cannot open file /proc/memshare/phymem_size\n");
                    return 0;
            }
            read(fd, s,sizeof(s));
            sscanf(s,"%lu", &phymem_size);
            close(fd);
            
            printf("phymem_addr=%lx, phymem_size=%lu\n", phymem_addr, phymem_size);
            /*memory map*/
            int map_fd =open("/dev/mem", O_RDWR);
            if(map_fd< 0)
            {
                    printf("cannot open file /dev/mem\n");
                    return 0;
            }
            
             map_addr = mmap(0, phymem_size, PROT_READ|PROT_WRITE, MAP_SHARED, map_fd, phymem_addr);
            strcpy(map_addr, argv[1]);
             munmap(map_addr, phymem_size);
            close(map_fd);
            return 0;
            
    }

    测试的内核是2.6.25.以下是执行结果。

    debian:/home/km/memshare# insmod memshare_kernel.ko
    debian:/home/km/memshare# ./memshare_user 'hello,world!'
    phymem_addr=e64e000, phymem_size=4096
    debian:/home/km/memshare# cat /proc/memshare/phymem_addr
    0e64e000
    debian:/home/km/memshare# cat /proc/memshare/phymem_size
    4096
    debian:/home/km/memshare# rmmod memshare_kernel
    debian:/home/km/memshare# tail /var/log/messages
    Sep 27 18:14:24 debian kernel: [50527.567931] Allocate memory success!. The phy mem addr=0e64e000, size=4096
    Sep 27 18:15:31 debian kernel: [50592.570986] The content written by user is: hello,world!

    用你这种方式,想申请4M的内存,

    static int __init init(void)
    {
         char * paddr;
         int order = 0;
         int offset = 0;
         int tmp = 0;
        
             /*build proc dir "memshare"and two proc files: phymem_addr, phymem_size in the dir*/
             proc_memshare_dir = proc_mkdir(PROC_MEMSHARE_DIR, NULL);
             create_proc_info_entry(PROC_MEMSHARE_PHYADDR, 0, proc_memshare_dir, proc_read_phymem_addr);
             create_proc_info_entry(PROC_MEMSHARE_SIZE,     0, proc_memshare_dir, proc_read_phymem_size);

             /*alloc one page*/
             //kernel_memaddr =__get_free_pages(GFP_KERNEL, PAGE_ORDER);
       [color=royalblue]        order = get_order(4000000);
             kernel_memaddr =__get_free_pages(GFP_KERNEL, order);
    [/color]
             if(!kernel_memaddr)
             {
                     printk("Allocate memory failure!\n");
             }
             else
             {
                     SetPageReserved(virt_to_page(kernel_memaddr));

                     //kernel_memsize = PAGES_NUMBER * PAGE_SIZE;
                    [color=royalblue] kernel_memsize = ((4000000 - 1) >> PAGE_SHIFT)* PAGE_SIZE;[/color]
    [color=#4169e1][/color]
    [color=black]...[/color]
    [color=black]}[/color]
    [color=black][/color]
    [color=black][/color]
    我在内核中往第一页(4k范围内)写数据,在用户态是能够读出来的,但是如果向以后的其它页写数据时,用户态就读不出了,
    用户态写也这样。

    需要对每个4k的页面执行:SetPageReserved(virt_to_page(kernel_memaddr));

    内核中申请到页面之后,要调用一下SetPageReserved,相当于告诉系统,这个页面我已经占了。对于每一个申请到的页面,应该都要这样做。


    展开全文
  • 1.ioctl等系统调用 2.netlink 3.input子系统 4.kmod(内核态通过call_usermodehelper()调用用户空间的可执行程序,比如/sbin/hotplug,/sbin/reboot,/sbin/poweroff)

    1.ioctl等系统调用

    2.netlink

    3.input子系统

    4.kmod(内核态Uevent模块通过kmod上报Uevent,通过call_usermodehelper()调用用户空间的可执行程序,比如/sbin/hotplug,/sbin/reboot,/sbin/poweroff,这种方式会为每个event fork一个进程,如果数量过多,会导致内存溢出等问题,不建议使用.现在的kernel已经不使用,CONFIG_UEVENT_HELPER_PATH配置为空)

    展开全文
  • 下面总结了7种方式,主要对以前不是很熟悉的方式做了编程实现,以便加深印象。 1.使用API:这是最常使用的一种方式了 A.get_user(x,ptr):在内核中被调用,获取用户空间指定地址的数值并保存到内核变量x中。 B...

    下面总结了7种方式,主要对以前不是很熟悉的方式做了编程实现,以便加深印象。

     

    1.使用API:这是最常使用的一种方式了

    A.get_user(x,ptr):在内核中被调用,获取用户空间指定地址的数值并保存到内核变量x中。

    B.put_user(x,ptr):在内核中被调用,将内核空间的变量x的数值保存到到用户空间指定地址处。

    C.Copy_from_user()/copy_to_user():主要应用于设备驱动读写函数中,通过系统调用触发。

     

    2.使用proc文件系统:和sysfs文件系统类似,也可以作为内核空间和用户空间交互的手段。

    /proc 文件系统是一种虚拟文件系统,通过他可以作为一种linux内核空间和用户空间的。与普通文件不同,这里的虚拟文件的内容都是动态创建的。

    使用/proc文件系统的方式很简单。调用create_proc_entry,返回一个proc_dir_entry指针,然后去填充这个指针指向的结构就好了,我下面的这个测试用例只是填充了其中的read_proc属性。

       下面是一个简单的测试用例,通过读虚拟出的文件可以得到内核空间传递过来的“proc ! test by qiankun!”字符串。

     

    3.使用sysfs文件系统+kobject:其实这个以前是编程实现过得,但是那天太紧张忘记了,T_T。每个在内核中注册的kobject都对应着sysfs系统中的一个目录。可以通过读取根目录下的sys目录中的文件来获得相应的信息。除了sysfs文件系统和proc文件系统之外,一些其他的虚拟文件系统也能同样达到这个效果。

     

    4.netlink:netlink socket提供了一组类似于BSD风格的API,用于用户态和内核态的IPC。相比于其他的用户态和内核态IPC机制,netlink有几个好处:1.使用自定义一种协议完成数据交换,不需要添加一个文件等。2.可以支持多点传送。3.支持内核先发起会话。4.异步通信,支持缓存机制。

    对于用户空间,使用netlink比较简单,因为和使用socket非常的类似,下面说一下内核空间对netlink的使用,主要说一下最重要的create函数,函数原型如下:

    extern struct sock *netlink_kernel_create(struct net *net,

                             int unit,unsigned int groups,
                                        void (*input)(struct sk_buff *skb),
                                               struct mutex *cb_mutex,
                                                struct module *module);

    第一个参数一般传入&init_net。

    第二个参数指的是netlink的类型,系统定义了16个,我们如果使用的话最好自己定义。这个需和用户空间所使用的创建socket的第三个参数一致,才可以完成通信。

    第四个参数指的是一个回调函数,当接受到一个消息的时候会调用这个函数。回调函数的参数为struct sk_buff类型的结构体。通过分析其结构成员可以得到传递过来的数据

    第六个参数一般传入的是THIS_MODULE。指当前模块。

        

    下面是对netlink的一个简单测试,将字符串“netlink test by qiankun”通过netlink输出到内核,内核再把字符串返回。Netlink类型使用的是22.

     

    5.文件:应该说这是一种比较笨拙的做法,不过确实可以这样用。当处于内核空间的时候,直接操作文件,将想要传递的信息写入文件,然后用户空间可以读取这个文件便可以得到想要的数据了。下面是一个简单的测试程序,在内核态中,程序会向“/home/melody/str_from_kernel”文件中写入一条字符串,然后我们在用户态读取这个文件,就可以得到内核态传输过来的数据了。

     

    6.使用mmap系统调用:可以将内核空间的地址映射到用户空间。在以前做嵌入式的时候用到几次。一方面可以在driver中修改Struct file_operations结构中的mmap函数指针来重新实现一个文件对应的映射操作。另一方面,也可以直接打开/dev/mem文件,把物理内存中的某一页映射到进程空间中的地址上。

    其实,除了重写Struct file_operations中mmap函数,我们还可以重写其他的方法如ioctl等,来达到驱动内核空间和用户空间通信的方式。

     

    7.信号:从内核空间向进程发送信号。这个倒是经常遇到,用户程序出现重大错误,内核发送信号杀死相应进程。

     

     

     

    展开全文
  • Linux内核用户空间通信的方式目前主要有9种,分别是内核启动参数、模块参数与 sysfs、sysctl、系统调用、netlink、procfs、seq_file、debugfsrelayfs。Netlink是一种特殊的文件描述符(套结字),为2.6.14及更高...
  • linux内核空间和用户空间通信

    千次阅读 2012-12-21 10:45:09
    因网上已有很多介绍各种通信方式的示例代码,所以在本文中只是给出各种内核空间和用户空间通信方式的介绍说明。希望给像我一样初学者提供一定指导。因水平有限,欢迎各位批评指点。   1 概述 Linux内核将这...
  • procfs:常用,l7length 示例中使用 sysctl:常用 ioctl:ifconfig 使用 mmap netlink: route,IP queue 使用 sockopt:iptables 使用
  • 一、netlink简介 Netlink是linux继承于unix的一种基于...Netlink的方式有很多优点,最为重要的是其可以支持内核和用户态进程间的通信。 1. Netlink与sysfs和ioctl的区别 linux中支持用户态和内核态的进程通信方式还
  • 4次:1,由用户空间的buf中将数据拷贝到内核中。2,内核将数据拷贝到内存中。3,内存到内核。4,内核用户空间的buf. 2次: 1,用户空间到内存。 2,内存到用户空间。 消息队列管道都是内核对象,所执行...
  • linux用户空间内核空间通信——Netlink通信机制

    万次阅读 多人点赞 2018-07-06 17:19:42
    一:什么是Netlink通信机制Netlink是linux提供用于内核和用户态进程之间的通信方式。但是注意虽然Netlink主要用于用户空间和内核空间的通信,但是也能用于用户空间的两个进程通信。只是进程间通信有其他很多方式,...
  • 我们平常在写代码时,一般是在用户空间,通过系统调用函数来访问内核空间,这是最常用的一种用户态和内核通信的方式。(关于 Linux 用户态和内核态可以参考 xx)除此之外,还有以下四种方式:procfs(/proc)sysctl(/p...
  • 一、采用Netlink进行内核用户空间交互优势Netlink相对于系统调用、ioctl以及proc文件系统等其他内核用户空间的数据交换方式而言具有以下优点:1、使用 netlink,用户仅需要在 include/linux/netlink.h 中增加...
  • 用户空间内核通信方式主要有两种:/procnetlink netlink涉及数据结构 struct msghdr { void *msg_name; //数据包目的地址(对应sockaddr_in) int msg_namelen; //数据
  • 作者:harveywang邮箱:因网上已有很多介绍各种通信方式的示例代码,所以在本文中只是给出各种内核空间和用户空间通信方式的介绍说明。希望给像我一样初学者提供一定指导。因水平有限,欢迎各位批评指点。1概述...
  • 一般地,在使用虚拟内存技术多任务系统上,内核和应用有不同地址空间,因此,在内核和应用之间以及在应用与应用之间进行数据交换需要专门机制来实现,众所周知,进程间通信(IPC)机制就是为实现应用与应用...
  • 我们平常在写代码时,一般是在用户空间,通过系统调用函数来访问内核空间,这是最常用的一种用户态和内核通信的方式。(关于 Linux 用户态和内核态可以参考 xx) 除此之外,还有以下四种方式: procfs(/proc) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 791
精华内容 316
关键字:

内核和用户空间通信的方式