Linux内核态和用户态共享内存方式通信

//-----------------------------------用户态 芯片驱动层----------------------------//
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdlib.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <errno.h>
#include <sys/wait.h>
#include <ctype.h>
#include <net/if_arp.h>

uint8 g_port_smi_addr_list[] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
uint8 g_port_smi_serdes_addr_list[] = {0, 0, 0, 0, 0xc, 0xd, 0xe};

typedef struct shm_info{
    uint8     flag;

    uint8     port[SCC_DIP_2_DPORT_NUM];

}shm_info_t;

shm_info_t *g_shm_mem_addr;


//在用户态初始化时定义Linux内核映射文件,
//将初始值传递到内核态,后续可动态更新
uint8 sccSysMemMapInit(void)
{
    int fd;
    uint8  i = 0;

    if( (fd = open("/proc/shmfile", O_RDWR)) < 0){
        printf("open /proc/shmfile error!\n");
        return ERROR;
    }

    g_shm_mem_addr = (shm_info_t *)mmap(NULL, SCC_MEM_MAP_LEN, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); // ignored, because we don't use "vm->pgoff" in driver.
    if( MAP_FAILED == g_shm_mem_addr){
        printf("mmap() error:[%d]\n", errno);
        return ERROR;
    }

    memset(g_shm_mem_addr, 0, sizeof(shm_info_t));

    for (i = 0; i < SCC_DIP_2_DPORT_NUM; i++){
        g_shm_mem_addr->port[i] = 0;
    }

    return OK;
}


uint8 sccSysMemMapFlagSet(uint8 enable)
{
        if (TRUE != enable && FALSE != enable){
                return ERROR;
        }

    g_shm_mem_addr->flag = enable;
    
    return OK;
}


uint8 sccSysMemMapFlagGet(uint8 *enable)
{
    if (NULL == enable){
        return ERROR;
    }

    *enable = g_shm_mem_addr->flag;

    return OK;  
}


uint8  sccCtrlDevInit()
{
    uint8 rc = OK;
    
    rc = sccSysMemMapInit();

    return rc;
}




//--------------------------------------------------Linux内核  gianfar.c----------------//

#define PROC_SHM_FILE "shmfile"

struct proc_dir_entry *g_proc_file = NULL;
unsigned long g_shm_addr = 0;

#define DIP_2_DPORT_NUM        3


typedef struct  mem_shm_info{
    unsigned char   flag;

    unsigned char  port[DIP_2_DPORT_NUM];

}mem_shm_info_t;



static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
    int  ret = 0;          
    unsigned char *ptr_data = NULL;        
    unsigned char  port = 0;
    mem_shm_info_t  *info = NULL;
    unsigned char  port_num = 0;
    unsigned char  port_list[4] = {0};
    
        info = (mem_shm_info_t *)g_shm_addr;
    if ( 0 == info->flag ){
        ret = gfar_start_xmit_real(skb, dev);
        return ret;
    }
    
    ......
}


static int gfar_recv_port_check(unsigned char *skbdata, unsigned char port)
{
        
    mem_shm_info_t  *info = NULL;
    
        info = (mem_shm_info_t *)g_shm_addr;

    /* ipv4 packet , dest ip */
    
        if (0 != info->port[port-1]){
            ...
        }
    
    return 0;
}


/* gfar_process_frame() -- handle one incoming packet if skb
 * isn't NULL.  */
static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
                              int amount_pull)
{
    ...

     gfar_recv_port_check();
     
    ...
}



//Linux内核从用户态定义的文件名中，获取设置的值
int shm_mmap(struct file *filp, struct vm_area_struct *vma)
{
    unsigned long page;

    page = virt_to_phys((void *)g_shm_addr) >> PAGE_SHIFT;

    if(remap_pfn_range(vma, vma->vm_start, page, (vma->vm_end - vma->vm_start), vma->vm_page_prot)) {
        return -1;
    }
    vma->vm_flags |= VM_RESERVED;
    printk("remap_pfn_rang page:[%lu] ok.\n", page);

    return 0;
}

static const struct file_operations g_shm_fops ={
    .owner = THIS_MODULE,
    .mmap = shm_mmap,
};


static int shm_init(void)
{
        g_proc_file = proc_create(PROC_SHM_FILE, 0, NULL, &g_shm_fops);
    if (NULL == g_proc_file) {
        printk("proc create failed\n");
        return -1;
    }

    g_shm_addr = __get_free_page(GFP_KERNEL);
    if(!g_shm_addr) {
        printk("Allocate memory failure!/n");
        return -1;
    } else {
        SetPageReserved(virt_to_page(g_shm_addr));
        printk("Allocate memory success!. The phy mem addr=%lx\n", __pa(g_shm_addr));
    }

    return 0;
}


static void shm_fini(void)
{
    ClearPageReserved(virt_to_page(g_shm_addr));
    free_page(g_shm_addr);
    remove_proc_entry(PROC_SHM_FILE, NULL);

    return;
}

static int __init gfar_init(void)
{
#ifdef CONFIG_GFAR_SW_PKT_STEERING
        gfar_cpu_dev_init();
#endif
        gfar_1588_proc_init(gfar_match, sizeof(gfar_match));
        shm_init();

        return of_register_platform_driver(&gfar_driver);
}

static void __exit gfar_exit(void)
{
        shm_fini();
#ifdef CONFIG_GFAR_SW_PKT_STEERING
        gfar_cpu_dev_exit();
#endif
        gfar_1588_proc_exit();
        of_unregister_platform_driver(&gfar_driver);
}

module_init(gfar_init);
module_exit(gfar_exit);