ceph存储 字符设备驱动示例x86Linux平台

1、驱动头文件：

#ifndef __ICFS_MOD_CMM_H__
#define __ICFS_MOD_CMM_H__

extern int icfs_cmd_init(void);
extern void icfs_cmd_exit(void);

extern int icfs_ksym_init(void);
extern void icfs_ksym_exit(void);

extern int icfs_stat_init(void);
extern void icfs_stat_exit(void);

#endif

2、驱动C文件：

#include <linux/ctype.h>
#include <asm/uaccess.h>
#include <linux/mm.h>
#include <asm/io.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("inspur icfs develop group");

#define ICFS_DEBUG_DEV    "ICFS_DEBUG_DEV"

#define STATISTICS_BUF_SIZE  256
//add by zyl for debug
#define MAJOR_NUM 200 //主设备号

static struct class *pstICFSDebugDrv_class;
static struct device *pstICFSSDebugDrv_class_dev;

volatile unsigned long *gpfcon = NULL;
volatile unsigned long *gpfdat = NULL;

extern char *icfs_kernel_version;
extern int icfs_stat_start(void);
extern int icfs_stat_stop(void);

#if ICFS_KERN_VERSION <=2006032000
int icfs_debug_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
#else
long icfs_debug_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
#endif
{
    char buf[STATISTICS_BUF_SIZE];
    unsigned long ret;
   
 printk(KERN_ALERT" icfs_debug_ioctl arg %lu\n", arg);
 
 ret = copy_from_user(buf, (struct ioctl_data *)arg, STATISTICS_BUF_SIZE);
 switch (cmd)
 {
  case 0:
   printk(KERN_ALERT"icfs_debug_ioctl case 0: \n");
   break;
  case 2:
   if(NULL != icfs_kernel_version)
   {
    printk(KERN_ALERT"version zhuo: %s\n", icfs_kernel_version);
   }
   else
   {
    printk(KERN_ALERT"icfs_kernel_version Failed!\n");
   }
   break;
  case 3:
   if(icfs_stat_start())
   {
    printk(KERN_ALERT"icfs_stat_start Failed!\n");
   }
   else
   {
    printk(KERN_ALERT"icfs_stat_start Success!\n");
   }
   break;
  case 4:
   if(icfs_stat_stop())
   {
    printk(KERN_ALERT"icfs_stat_stop Failed\n");
   }
   else
   {
    printk(KERN_ALERT"icfs_stat_stop Success!\n");
   }
   break;
  default:
   printk(KERN_ALERT"icfs_debug_ioctl default: \n");
 }
 //strcpy((char*)arg, "hello world,too\n");
 //printk(KERN_ALERT"%s", buf);
 //copy_to_user((void *)arg, buf, 100);
 
 return 0;

}

struct file_operations icfs_debug_fops = {
#if ICFS_KERN_VERSION <=2006032000
  .ioctl = icfs_debug_ioctl,
#else
  .unlocked_ioctl = icfs_debug_ioctl,
#endif
};

int icfs_cmd_init(void)
{
 int ret;
 
 ret = register_chrdev(MAJOR_NUM,ICFS_DEBUG_DEV, &icfs_debug_fops);
 if(ret)
 {
  printk(KERN_ALERT"icfs_debug_dev register failure\n");
  return ret;
 }
 else
 {
     pstICFSDebugDrv_class = class_create(THIS_MODULE, ICFS_DEBUG_DEV);
  
  pstICFSSDebugDrv_class_dev = device_create(pstICFSDebugDrv_class,
                                          NULL,
                                          MKDEV(MAJOR_NUM, 0),
                                          NULL,
                                          "icfs_debug_dev");

  printk(KERN_ALERT"icfs_debug_dev register success!\n");
 }
 return 0;
}

void icfs_cmd_exit(void)
{
 unregister_chrdev(MAJOR_NUM, ICFS_DEBUG_DEV);
 device_unregister(pstICFSSDebugDrv_class_dev);
 class_destroy(pstICFSDebugDrv_class);

 return;
}

module_init(icfs_cmd_init);
module_exit(icfs_cmd_exit);

3、Makefile：

export C_INCLUDE_PATH=/root/ceph-client-kernel/include
obj-m := icfsmod.o
KVERSION = $(shell uname -r)
KERNELDIR :=/usr/src/kernels/2.6.32-358.el6.x86_64/
ccflags-y += -DICFS_KERN_VERSION=2006032000
PWD := $(shell pwd)
icfsmod-y := icfscmm.o icfsstat.o icfscmd.o icfsksym.o
modules:
 $(MAKE) -C  $(KERNELDIR) M=$(PWD) modules
modules_install:
 $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
clean:
 $(MAKE) -C /lib/modules/$(KVERSION)/build M=$(PWD) clean

4、upper_call:

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

#include "statistics.h"

struct icfs_cmd_func_t
{
 char cmd[32];
 int (*call_back_t)(int argc, char **agrv);
 char help[128];
};

int icfs_cmd_help(int, char **);
int icfs_cmd_showversion(int, char **);
int icfs_cmd_stat_start(int, char **);
int icfs_cmd_stat_stop(int, char **);

struct icfs_cmd_func_t g_stat_cmds[ICFS_CMD_COUNT] =
{
 {"-h",   icfs_cmd_help,     "help",     },
 {"-v",   icfs_cmd_showversion, "show version", },
 {"-stat_start",  icfs_cmd_stat_start,        "stat_start",         },
    {"-stat_stop",  icfs_cmd_stat_stop,  "stat_stop",    },
};

void usage()
{
  printf("-------------------------------------------------\n");
  printf(" ./ioctl statistics [parameter]\n");
  printf(" for example: \n");
  printf("   ./ioctl statistics -h\n");
  printf("--------------------------------------------------\n");
}

int icfs_cmd_help(int argc, char **agrv)
{
 int i = 0;

 for(i=0; i<ICFS_CMD_COUNT; i++)
 {
     printf("%s %s\n", g_stat_cmds[i].cmd, g_stat_cmds[i].help);
 }
 
    return 0;
}

int icfs_cmd_showversion(int argc, char **agrv)
{
 int iFd = 0;
 char acBuf[STATISTICS_BUF_SIZE];

    iFd = open("/dev/icfs_debug_dev", O_RDONLY);
    if(iFd < 0)
    {
          printf("open df error!\n");
          return -1;
    }
 
    ioctl(iFd, STATISTIC_CMD_VERSION, acBuf);
    close(iFd);
 
 return 0;
}

int icfs_cmd_stat_start(int argc, char **agrv)
{
 int iFd = 0;
 char acBuf[STATISTICS_BUF_SIZE];

    iFd = open("/dev/icfs_debug_dev", O_RDONLY);
    if(iFd < 0)
    {
          printf("open df error!\n");
          return -1;
    }
 
    ioctl(iFd, STATISTIC_CMD_STAT, acBuf);
    close(iFd);
 
 return 0;
}

int icfs_cmd_stat_stop(int argc, char **agrv)
{
 int iFd = 0;
 char acBuf[STATISTICS_BUF_SIZE];

    iFd = open("/dev/icfs_debug_dev", O_RDONLY);
    if(iFd < 0)
    {
          printf("open df error!\n");
          return -1;
    }
 
    ioctl(iFd, STATISTIC_CMD_STOP, acBuf);
    close(iFd);
 
 return 0;
}

int icfs_cmd_dispatch(int argc, char **argv)
{
 int i;

 for (i=0; i<ICFS_CMD_COUNT; i++)
 {
  if (!strcmp(argv[1], g_stat_cmds[i].cmd))
  {
   g_stat_cmds[i].call_back_t(argc, argv);
  }
 }

 return 0;
}

int main(int argc, char *argv[])
{
  int ret;

  if(argc < 2){
    usage();
    return -1;
  }

  ret = icfs_cmd_dispatch(argc, argv);
 
  return 0;
}