用户空间与内核空间共享内存demo

仓促之间，有些地方处理的还是比较简单。希望高手多多指正。需要了解这方面实现的可以参考一下，共同学习。

=============================================================================================================================

通过共享内存（文件）的方式可行 /*user.c*/ #include <stdio.h> #include <unistd.h> #include <sys/stat.h> #include <sys/mman.h> #include <fcntl.h> #define PAGES 512 #define MEM_WIDTH 1500 struct MEM_DATA { //int key; unsigned short width;/*缓冲区宽度*/ unsigned short length;/*缓冲区长度*/ //unsigned short wtimes;/*写进程记数,预留，为以后可以多个进程写*/ //unsigned short rtimes;/*读进程记数,预留，为以后可以多个进程读*/ unsigned short wi;/*写指针*/ unsigned short ri;/*读指针*/ } * mem_data; struct MEM_PACKET { unsigned int len; unsigned char packetp[MEM_WIDTH – 4];/*sizeof(unsigned int) == 4*/ }; int get_mem(char *aMem,char *aBuf,unsigned int *size) { register int i,s,width,length,mem_i; char *buf; struct MEM_PACKET * curr_pack; s = 0; mem_data = (void *)aMem; width = mem_data[0].width; length = mem_data[0].length; mem_i = mem_data[0].ri; buf = (void *)(aMem + width * mem_i); curr_pack = (struct MEM_PACKET *)buf; if (curr_pack->len != 0){/*第一个字节为0说明该部分为空*/ memcpy(aBuf,curr_pack->packetp,curr_pack->len); *size = curr_pack->len; curr_pack->len = 0; s = mem_data[0].ri; mem_data[0].ri++; if(mem_data[0].ri >= length) mem_data[0].ri = 1; goto ret; } for (i=1;i<length;i++){ mem_i++;/*继续向后找，最糟糕的情况是把整个缓冲区都找一遍*/ if (mem_i >= length) mem_i = 1; buf = (void *)(aMem + width*mem_i); curr_pack = (struct MEM_PACKET *)buf; if (curr_pack->len == 0) continue; memcpy(aBuf,curr_pack->packetp,curr_pack->len); *size = curr_pack->len; curr_pack->len = 0; s = mem_data[0].ri = mem_i; mem_data[0].ri++; if(mem_data[0].ri >= length) mem_data[0].ri = 1; break; } ret: return s; } int main() { char *su1_2; char receive[1500]; int i,j; int fd; int fd_procaddr; unsigned int size; char addr[9]; unsigned long ADDR; j = 0; /*open device ‘mem’ as a media to access the RAM*/ fd=open(“/dev/mem”,O_RDWR); fd_procaddr = open(“/proc/nf_addr”,O_RDONLY); read(fd_procaddr,addr,9); ADDR = atol(addr); close(fd_procaddr); printf(“%u[%8lx]/n”,ADDR,ADDR); /*Map the address in kernel to user space, use mmap function*/ su1_2 = mmap(0,PAGES*4*1024, PROT_READ|PROT_WRITE, MAP_SHARED, fd, ADDR); perror(“mmap”); while(1) { bzero(receive,1500); i = get_mem(su1_2,receive,&size); if (i != 0) { j++; printf(“%d:%s[size = %d]/n”,j,receive,size); } else { printf(“there have no data/n”); munmap(su1_2,PAGES*4*1024); close(fd); break; } } while(1); } Top

/*corem.c for zero-copy*/ #define __KERNEL__ #define MODULE #include <linux/version.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/wrapper.h> #include <asm/page.h> #include <linux/slab.h> #include <linux/proc_fs.h> #ifndef KERNEL_VERSION #define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) #endif #define PAGES_ORDER 9 #define PAGES 512 #define MEM_WIDTH 1500 struct MEM_DATA { //int key; unsigned short width;/*缓冲区宽度*/ unsigned short length;/*缓冲区长度*/ //unsigned short wtimes;/*写进程记数,预留，为以后可以多个进程写*/ //unsigned short rtimes;/*读进程记数,预留，为以后可以多个进程读*/ unsigned short wi;/*写指针*/ unsigned short ri;/*读指针*/ } *mem_data; struct MEM_PACKET { unsigned int len; unsigned char packetp[MEM_WIDTH – 4];/*sizeof(unsigned int) == 4*/ }; unsigned long su1_2; void del_mem() { int pages = 0; char *addr; addr = (char *)su1_2; while (pages <=PAGES -1) { mem_map_unreserve(virt_to_page(addr)); addr = addr + PAGE_SIZE; pages++; } free_pages(su1_2,PAGES_ORDER); } void init_mem() { int i; int pages = 0; char *addr; char *buf; struct MEM_PACKET * curr_pack; su1_2 = __get_free_pages(GFP_KERNEL,PAGES_ORDER); printk(“[%x]/n”,su1_2); addr = (char *)su1_2; while (pages <= PAGES -1) { mem_map_reserve(virt_to_page(addr)); addr = addr + PAGE_SIZE; pages++; } mem_data = (struct MEM_DATA *)su1_2; mem_data[0].ri = 1; mem_data[0].wi = 1; mem_data[0].length = PAGES*4*1024 / MEM_WIDTH; mem_data[0].width = MEM_WIDTH; /* initial su1_2 */ for(i=1;i<=mem_data[0].length;i++) { buf = (void *)((char *)su1_2 + MEM_WIDTH * i); curr_pack = (struct MEM_PACKET *)buf; curr_pack->len = 0; } } int put_mem(char *aBuf,unsigned int pack_size) { register int s,i,width,length,mem_i; char *buf; struct MEM_PACKET * curr_pack; s = 0; mem_data = (struct MEM_DATA *)su1_2; width = mem_data[0].width; length = mem_data[0].length; mem_i = mem_data[0].wi; buf = (void *)((char *)su1_2 + width * mem_i); for (i=1;i<length;i++){ curr_pack = (struct MEM_PACKET *)buf; if (curr_pack->len == 0){ memcpy(curr_pack->packetp,aBuf,pack_size); curr_pack->len = pack_size;; s = mem_i; mem_i++; if (mem_i >= length) mem_i = 1; mem_data[0].wi = mem_i; break; } mem_i++; if (mem_i >= length){ mem_i = 1; buf = (void *)((char *)su1_2 + width); } else buf = (char *)su1_2 + width*mem_i; } if(i >= length) s = 0; return s; } int read_procaddr(char *buf,char **start,off_t offset,int count,int *eof,void *data) { sprintf(buf,”%u/n”,__pa(su1_2)); *eof = 1; return 9; } int init_module(void) { put_pkt2mem_n = 0; init_mem(); put_mem(“data1dfadfaserty”,16); put_mem(“data2zcvbnm”,11); put_mem(“data39876543210poiuyt”,21); create_proc_read_entry(“nf_addr”,0,NULL,read_procaddr,NULL); return 0; } void cleanup_module(void) { del_mem(); remove_proc_entry(“nf_addr”,NULL); }Top

上面是两部分代码，分别是用户空间和内核空间程序的代码，只拷一些重要的，编译一下，这个两个程序运行在不同的空间就可以通信，好好研究一下

===================================================================================================

操，直接操作/dev/kmem吧 QQ：28286880

======================================================================================================

3．2．2 netlink 套接字 在 Linux 2.4 版以后版本的内核中，几乎全部的中断过程与用户态进程的通信都是使用 netlink 套接字实现的，同时还使用 netlink 实现了 ip queue 工具，但 ip queue 的使用有其局限性，不能自由地用于各种中断过程。内核的帮助文档和其他一些 Linux 相关文章都没有对 netlink 套接字在中断过程和用户空间通信的应用上作详细的说明，使得很多用户对此只有一个模糊的概念。 netlink 套接字的通信依据是一个对应于进程的标识，一般定为该进程的 ID。当通信的一端处于中断过程时，该标识为 0。当使用 netlink 套接字进行通信，通信的双方都是用户态进程，则使用方法类似于消息队列。但通信双方有一端是中断过程，使用方法则不同。netlink 套接字的最大特点是对中断过程的支持，它在内核空间接收用户空间数据时不再需要用户自行启动一个内核线程，而是通过另一个软中断调用用户事先指定的接收函数。工作原理如图【3】。 图【3】 很明显，这里使用了软中断而不是内核线程来接收数据，这样就可以保证数据接收的实时性。 当 netlink 套接字用于内核空间与用户空间的通信时，在用户空间的创建方法和一般套接字使用类似，但内核空间的创建方法则不同。图【4】是 netlink 套接字实现此类通信时创建的过程。 图【4】 以下举一个 netlink 套接字的应用示例。示例实现了从 netfilter 的 NF_IP_PRE_ROUTING 点截获的 ICMP 数据报，在将数据报的相关信息传递到一个用户态进程，由用户态进程将信息打印在终端上。源码在文件 imp2.tar.gz中。内核模块代码（分段详解）： （一）模块初始化与卸载 static struct sock *nlfd; struct { __u32 pid; rwlock_t lock; }user_proc; /*挂接在 netfilter 框架的 NF_IP_PRE_ROUTING 点上的函数为 get_icmp()*/ static struct nf_hook_ops imp2_ops = { .hook = get_icmp, /*netfilter 钩子函数*/ .pf = PF_INET, .hooknum = NF_IP_PRE_ROUTING, .priority = NF_IP_PRI_FILTER -1, }; static int __init init(void) { rwlock_init(&user_proc.lock); /*在内核创建一个 netlink socket，并注明由 kernel_recieve() 函数接收数据 这里协议 NL_IMP2 是自定的*/ nlfd = netlink_kernel_create(NL_IMP2, kernel_receive); if(!nlfd) { printk(“can not create a netlink socket/n”); return -1; } /*向 netfilter 的 NF_IP_PRE_ROUTING 点挂接函数*/ return nf_register_hook(&imp2_ops); } static void __exit fini(void) { if(nlfd) { sock_release(nlfd->socket); } nf_unregister_hook(&imp2_ops); } module_init(init); module_exit(fini); 其实片断（一）的工作很简单，模块加载阶段先在内核空间创建一个 netlink 套接字，再将一个函数挂接在 netfilter 框架的 NF_IP_PRE_ROUTING 钩子点上。卸载时释放套接字所占的资源并注销之前在 netfilter 上挂接的函数。 （二）接收用户空间的数据 DECLARE_MUTEX(receive_sem); 01: static void kernel_receive(struct sock *sk, int len) 02: { 03: do 04: { 05: struct sk_buff *skb; 06: if(down_trylock(&receive_sem)) 07: return; 08: 09: while((skb = skb_dequeue(&sk-<receive_queue)) != NULL) 10: { 11: { 12: struct nlmsghdr *nlh = NULL; 13: if(skb-<len <= sizeof(struct nlmsghdr)) 14: { 15: nlh = (struct nlmsghdr *)skb-<data; 16: if((nlh-<nlmsg_len <= sizeof(struct nlmsghdr)) 17: && (skb-<len <= nlh-<nlmsg_len)) 18: { 19: if(nlh-<nlmsg_type == IMP2_U_PID) 20: { 21: write_lock_bh(&user_proc.pid); 22: user_proc.pid = nlh-<nlmsg_pid; 23: write_unlock_bh(&user_proc.pid); 24: } 25: else if(nlh-<nlmsg_type == IMP2_CLOSE) 26: { 27: write_lock_bh(&user_proc.pid); 28: if(nlh-<nlmsg_pid == user_proc.pid) user_proc.pid = 0; 29: write_unlock_bh(&user_proc.pid); 30: } 31: } 32: } 33: } 34: kfree_skb(skb); 35: } 36: up(&receive_sem); 37: }while(nlfd && nlfd-<receive_queue.qlen); 38: } 如果读者看过 ip_queue.c 或 rtnetlink.c中的源码会发现片断（二）中的 03～18 和 31～38 是 netlink socket 在内核空间接收数据的框架。在框架中主要是从套接字缓存中取出全部的数据，然后分析是不是合法的数据报，合法的 netlink 数据报必须有nlmsghdr 结构的报头。在这里笔者使用了自己定义的消息类型：IMP2_U_PID（消息为用户空间进程的ID），IMP2_CLOSE（用户空间进程关闭）。因为考虑到 SMP，所以在这里使用了读写锁来避免不同 CPU 访问临界区的问题。kernel_receive() 函数的运行在软中断环境。 （三）截获 IP 数据报 static unsigned int get_icmp(unsigned int hook, struct sk_buff **pskb, const struct net_device *in, const struct net_device *out, int (*okfn)(struct sk_buff *)) { struct iphdr *iph = (*pskb)->nh.iph; struct packet_info info; if(iph->protocol == IPPROTO_ICMP) /*若传输层协议为 ICMP*/ { read_lock_bh(&user_proc.lock); if(user_proc.pid != 0) { read_unlock_bh(&user_proc.lock); info.src = iph->saddr; /*记录源地址*/ info.dest = iph->daddr; /*记录目的地址*/ send_to_user(&info); /*发送数据*/ } else read_unlock_bh(&user_proc.lock); } return NF_ACCEPT; } （四）发送数据 static int send_to_user(struct packet_info *info) { int ret; int size; unsigned char *old_tail; struct sk_buff *skb; struct nlmsghdr *nlh; struct packet_info *packet; size = NLMSG_SPACE(sizeof(*info)); /*开辟一个新的套接字缓存*/ skb = alloc_skb(size, GFP_ATOMIC); old_tail = skb->tail; /*填写数据报相关信息*/ nlh = NLMSG_PUT(skb, 0, 0, IMP2_K_MSG, size-sizeof(*nlh)); packet = NLMSG_DATA(nlh); memset(packet, 0, sizeof(struct packet_info)); /*传输到用户空间的数据*/ packet->src = info->src; packet->dest = info->dest; /*计算经过字节对其后的数据实际长度*/ nlh->nlmsg_len = skb->tail – old_tail; NETLINK_CB(skb).dst_groups = 0; read_lock_bh(&user_proc.lock); ret = netlink_unicast(nlfd, skb, user_proc.pid, MSG_DONTWAIT); /*发送数据*/ read_unlock_bh(&user_proc.lock); return ret; nlmsg_failure: /*若发送失败，则撤销套接字缓存*/ if(skb) kfree_skb(skb); return -1; } 片断（四）中所使用的宏参考如下： /*字节对齐*/ #define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) ) /*计算包含报头的数据报长度*/ #define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(sizeof(struct nlmsghdr))) /*字节对齐后的数据报长度*/ #define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len)) /*填写相关报头信息，这里使用了nlmsg_failure标签，所以在程序中要定义*/ #define NLMSG_PUT(skb, pid, seq, type, len) / ({ if (skb_tailroom(skb) < (int)NLMSG_SPACE(len)) goto nlmsg_failure; / __nlmsg_put(skb, pid, seq, type, len); }) static __inline__ struct nlmsghdr * __nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len) { struct nlmsghdr *nlh; int size = NLMSG_LENGTH(len); nlh = (struct nlmsghdr*)skb_put(skb, NLMSG_ALIGN(size)); nlh->nlmsg_type = type; nlh->nlmsg_len = size; nlh->nlmsg_flags = 0; nlh->nlmsg_pid = pid; nlh->nlmsg_seq = seq; return nlh; } /*跳过报头取实际数据*/ #define NLMSG_DATA(nlh) ((void*)(((char*)nlh) + NLMSG_LENGTH(0))) /*取 netlink 控制字段*/ #define NETLINK_CB(skb) (*(struct netlink_skb_parms*)&((skb)->cb)) 运行示例时，先编译 imp2_k.c 模块，然后使用 insmod 将模块加载入内核。再运行编译好的 imp2_u 命令，此时就会显示出本机当前接收的 ICMP 数据报的源地址和目的地址。用户可以使用 Ctrl+C 来终止用户空间的进程，再次启动也不会带来问题。 4 总结 本文从内核态代码的不同运行环境来实现不同方法的内核空间与用户空间的通信，并分析了它们的实际效果。最后推荐使用 netlink 套接字实现中断环境与用户态进程通信，因为 netlink 套接字是专为此类通信定制的。 Top

通过驱动程序吧。Top

看了通过NetLink获取内核中网络接口名称的一个实现，各个参数设置的眼花缭乱： static int netlink_request(struct nl_handle *nl, int family, int type) { int status; struct sockaddr_nl snl; struct { struct nlmsghdr nlh; struct rtgenmsg g; } req; /* Cleanup the room */ memset(&snl, 0, sizeof (snl)); snl.nl_family = AF_NETLINK; req.nlh.nlmsg_len = sizeof (req); req.nlh.nlmsg_type = type; req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST; req.nlh.nlmsg_pid = 0; req.nlh.nlmsg_seq = ++nl->seq; req.g.rtgen_family = family; status = sendto(nl->fd, (void *) &req, sizeof (req) , 0, (struct sockaddr *) &snl, sizeof (snl)); if (status < 0) { FW_LOG(“Netlink: sendto() failed: %s/n”, strerror(errno)); return -1; } return 0; } /* Our netlink parser */ static int netlink_parse_info(int (*filter) (struct sockaddr_nl *, struct nlmsghdr *), struct nl_handle *nl) { int status; int ret = 0; int error; while (1) { char buf[4096]; struct iovec iov = { buf, sizeof buf }; struct sockaddr_nl snl; struct msghdr msg = { (void *) &snl, sizeof snl, &iov, 1, NULL, 0, 0 }; struct nlmsghdr *h; status = recvmsg(nl->fd, &msg, 0); if (status < 0) { if (errno == EINTR) continue; if (errno == EWOULDBLOCK) break; FW_LOG(“Netlink: Received message overrun/n”); continue; } if (status == 0) { FW_LOG(“Netlink: EOF/n”); return -1; } if (msg.msg_namelen != sizeof snl) { FW_LOG(“Netlink: Sender address length error: length %d/n”, msg.msg_namelen); return -1; } for (h = (struct nlmsghdr *) buf; NLMSG_OK(h, status); h = NLMSG_NEXT(h, status)) { /* Finish of reading. */ if (h->nlmsg_type == NLMSG_DONE) return ret; /* Error handling. */ if (h->nlmsg_type == NLMSG_ERROR) { struct nlmsgerr *err = (struct nlmsgerr *) NLMSG_DATA(h); if (h->nlmsg_len < NLMSG_LENGTH(sizeof (struct nlmsgerr))) { FW_LOG(“Netlink: error: message truncated/n”); return -1; } FW_LOG(“Netlink: error: %s, type=(%u), seq=%u, pid=%d/n”, strerror(-err->error), err->msg.nlmsg_type, err->msg.nlmsg_seq, err->msg.nlmsg_pid); return -1; } error = (*filter) (&snl, h); if (error < 0) { FW_LOG(“Netlink: filter function error/n”); ret = error; } } /* After error care. */ if (msg.msg_flags & MSG_TRUNC) { FW_LOG(“Netlink: error: message truncated/n”); continue; } if (status) { FW_LOG(“Netlink: error: data remnant size %d/n”, status); return -1; } } return ret; } /* Netlink interface link lookup filter */ static int netlink_if_link_filter(struct sockaddr_nl *snl, struct nlmsghdr *h) { struct ifinfomsg *ifi; struct rtattr *tb[IFLA_MAX + 1]; interface *ifp; int i, len; char *name; ifi = NLMSG_DATA(h); if (h->nlmsg_type != RTM_NEWLINK) return 0; len = h->nlmsg_len – NLMSG_LENGTH(sizeof (struct ifinfomsg)); if (len < 0) return -1; /* Interface name lookup */ memset(tb, 0, sizeof (tb)); parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len); if (tb[IFLA_IFNAME] == NULL) return -1; name = (char *) RTA_DATA(tb[IFLA_IFNAME]); /* Return if loopback */ if (ifi->ifi_type == ARPHRD_LOOPBACK) return 0; /* Fill the interface structure */ ifp = (interface *) MALLOC(sizeof (interface)); memcpy(ifp->ifname, name, strlen(name)); ifp->ifindex = ifi->ifi_index; ifp->flags = ifi->ifi_flags; ifp->mtu = *(int *) RTA_DATA(tb[IFLA_MTU]); ifp->hw_type = ifi->ifi_type; if (tb[IFLA_ADDRESS]) { int hw_addr_len = RTA_PAYLOAD(tb[IFLA_ADDRESS]); if (hw_addr_len > IF_HWADDR_MAX) FW_LOG(“MAC address for %s is too large: %d/n”, name, hw_addr_len); else { ifp->hw_addr_len = hw_addr_len; memcpy(ifp->hw_addr, RTA_DATA(tb[IFLA_ADDRESS]), hw_addr_len); for (i = 0; i < hw_addr_len; i++) if (ifp->hw_addr[i] != 0) break; if (i == hw_addr_len) ifp->hw_addr_len = 0; else ifp->hw_addr_len = hw_addr_len; } } /* Queue this new interface */ if_add_queue(ifp); return 0; } ===============================================================================================================

之所以想写这篇文章，是有两个方面原因。其一是内核版有一个关于《内核可以从线性地址直接计算物理地址，用来做什么呢？》的讨论，偶说计算出物理地址可以共享给用户空间读写。dreamice兄说能否说一下详细的应用。其二是alb*版主提到wheelz曾经写过这样一个例程，拜读了一把，发现在传递物理地址和内存大小上，wheelz的例程还有些不够灵活。alb*版主提到可以通过文件的方式实现动态的传递。

因此，本人也写了这样一个例程，可以动态的将内核空间的物理地址和大小传给用户空间。

本文欢迎自由转载，但请标明作者，并保证本文的完整性。

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

/*This program is used to allocate memory in kerneland 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)); kernel_memsize = PAGES_NUMBER0, 204);”>* 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.”);

文章出处：http://www.diybl.com/course/6_system/linux/Linuxjs/2008106/148265_2.html

文章出处：http://www.diybl.com/course/6_system/linux/Linuxjs/2008106/148265.html