自己编写一个printk函数

makefile文件

# File: Makefile
# wangxiancai

MODEXT = ko
INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.13/wxc/driver/chardriver/ko
# INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.30/wxc/driver/chardriver/ko
CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-
# CROSS=/home/wangxc/linux/toolchain/crosstools_4.4.3_softfloat/bin/arm-linux-
KERNELDIR=/home/wangxc/linux/kernel/kernel-2.6.13
# KERNELDIR=/home/wangxc/linux/kernel/kerner-2.6.30

CC= $(CROSS)gcc
LD= $(CROSS)ld

#############################################################################
# Compiler Flags
#############################################################################
EXTRA_CFLAGS += -I$(KERNELDIR)/include
#############################################################################
# Make Targets
#############################################################################
obj-m := proc_mymsg.o mydriver_myprintk.o
default:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
# Otherwise we were called directly from the command line; invoke the kernel build system.

install: default
    rm -rf $(INSTALLDIR)/proc_mymsg.$(MODEXT)
    cp -rf $(PWD)/proc_mymsg.$(MODEXT) $(INSTALLDIR)
    rm -rf $(INSTALLDIR)/mydriver_myprintk.$(MODEXT)
    cp -rf $(PWD)/mydriver_myprintk.$(MODEXT) $(INSTALLDIR)

dis:
    $(CROSS)objdump -D proc_mymsg.ko > proc_mymsg.dis
    $(CROSS)objdump -D mydriver_myprintk.ko > mydriver_myprintk.dis

clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions *.bak modules.order Module.symvers

proc_mymsg.c文件

/*目的:printk()非常多时，一屏难以显示，怎么办？使用proc虚拟文件系统来实现。
* 让其他驱动程序，可以使用myprintk()函数，并且把日志保存在一个我们自己指定的文件中。
* 自己的驱动使用自己的打印函数，让自己打印的日志和内核打印的日志 分别存放。
仿照printk函数，自己建立一个mylog_buf，自己建立一个/proc/mymsg 文件，写一个驱动程序myprintk()
参考文件 : \kernel-2.6.13\fs\proc\proc_misc.c
*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/irq.h>
#include <linux/device.h>
#include <asm-arm/arch/regs-gpio.h>
#include <asm/arch/hardware.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/fcntl.h>
#include <linux/fs.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <linux/device.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>

#include <linux/proc_fs.h>

#define MYLOG_BUF_LEN 1024 /*环形缓冲区的长度*/
static char mylog_buf[MYLOG_BUF_LEN]; /*定义一个环形缓冲区，最后会留一个空间放\0*/
static char tmp_buf[MYLOG_BUF_LEN]; /*myprintk函数中要使用的一个临时变量*/
static int mylog_r = 0;        /*环形缓冲区读指针，每读取一个，则表示缓冲区少了一个数据，则读指针也要后移一位，读指针总是指向下一个要读取的位置，肯定是数据位的第1个位置。后移到缓冲区尾时，则跳到缓冲区最开始的位置重新开始*/
static int mylog_w = 0;        /*环形缓冲区写指针，每写入一个，则表示缓冲区多了一个数据，则写指针也要后移一位，写指针总是指向下一个要写入的位置，肯定是空位置的第1个位置。后移到缓冲区尾时，则跳到缓冲区最开始的位置重新开始*/

/*为了可以多次cat，做的一个小的技术性的修改，用另外一个变量 mylog_r_for_read 来表示 读取位置，
不使用mylog_r变量。在open()函数里面，让 mylog_r_for_read 的初始值 为
*/
static int mylog_r_for_read = 0;

struct proc_dir_entry * myentry;
static DECLARE_WAIT_QUEUE_HEAD(mymsg_waitq); /*申明一个等待队列头*/



/*函数功能 : 判断缓冲区是否是空的
*函数返回值 : 返回1 : 缓冲区空
* 返回0 : 缓冲区非空
*/
static int is_mylog_empty(void)
{
    /*如果读指针==写指针，则表示环形缓冲区是空的，则函数返回1*/
    return (mylog_r == mylog_w);
}

/*函数功能 : 同is_mylog_empty()函数
*/
static int is_mylog_empty_for_read(void)
{
    return (mylog_r_for_read == mylog_w);
}

/*函数功能 : 判断缓冲区是否是满的
*函数返回值 : 返回1 : 缓冲区满
* 返回0 : 缓冲区非满
*/
static int is_mylog_full(void)
{
    /*如果写指针的下一个位置是读指针，则表示环形缓冲区是满的，则函数返回1*/
    return ((mylog_w + 1)% MYLOG_BUF_LEN == mylog_r);
}

/*函数功能 : 向缓冲区里面写入1个字节的数据
*/
static void mylog_putc(char c)
{
    if(is_mylog_full()) //满了
    {
        /* 丢弃一个数据 : 向后移动(即向右边移动指针)一下读指针，这样，相当于丢弃了一个老的数据，腾出一个空位置出来，以便可以写进去新的数据。
        * 即当环形缓冲区已经写满了，还要继续写入的话，会覆盖掉原来的数据，继续写入。
        */
        mylog_r = (mylog_r + 1) % MYLOG_BUF_LEN;

        /*读取指针 mylog_r 后移了，另外一个读取指针mylog_r_for_read的位置，可能在 mylog_r 指向的位置，也可能在其后面一点，
        *所以，另外一个读取指针mylog_r_for_read的位置，可能也要后移，才对。
        *特例 : mylog_getc_for_read()之后，mylog_r_for_read 的位置后移了，如果这时myprintk继续使用，
        * 出来很多日志，写满了缓冲区，使得 mylog_r 指向的位置后移超过了 mylog_r_for_read，
        * 此时，再 mylog_getc_for_read()，则不会使用后来新覆盖的数据。
        */
        if((mylog_r_for_read + 1) % MYLOG_BUF_LEN == mylog_r) /*一旦 mylog_r 向后移的位置 超过了 mylog_r_for_read 的位置，则 mylog_r_for_read 也要跟着后移了。*/
        {
                mylog_r_for_read = mylog_r; /*mylog_r_for_read 后移到 读取指针 mylog_r 相同的位置*/
        }
    }
    //还没有满
    mylog_buf[mylog_w] = c; //写指针指向的位置，填充1个字符
    mylog_w = (mylog_w + 1) % MYLOG_BUF_LEN; //写指针后移1个位置

    /* 唤醒等待数据的进程 */
    wake_up_interruptible(&mymsg_waitq); /* 唤醒休眠的进程 */
}

/*函数功能 : 从缓冲区里面读取1个字节的数据
*函数参数 : 输出参数，保存读取的值
*返回值 : 0 : 读取不到数据
* 1 : 成功读取到1个字节的数据
*/
static int mylog_getc(char *p)
{
    if(is_mylog_empty()) //空的
    {
            return 0;
    }
    //有数据
    *p = mylog_buf[mylog_r]; //从读指针指向的位置读取1个字节
    mylog_r = (mylog_r + 1) % MYLOG_BUF_LEN; //读指针后移1个位置
    return 1;
}

/*函数功能 : 同mylog_getc()函数，不使用 读写位置指针:mylog_r
*函数参数 : 输出参数，保存读取的值
*返回值 : 0 : 读取不到数据
* 1 : 成功读取到1个字节的数据
*/
static int mylog_getc_for_read(char *p)
{
    if(is_mylog_empty_for_read())
    {
        return 0;
    }
    //有数据
    *p = mylog_buf[mylog_r_for_read]; /*用另外一个变量，不使用以前的位置指针 mylog_r*/
    mylog_r_for_read = (mylog_r_for_read + 1) % MYLOG_BUF_LEN;
    return 1;
}

/*自己创造的一个printk函数*/
int myprintk(const char *fmt, ...)
{
    va_list args;
    int i;
    int j;

    va_start(args, fmt);
    i = vsnprintf(tmp_buf, INT_MAX, fmt, args);
    va_end(args);
    //临时缓冲区中，已经有数据了,可以填充到环形缓冲区中了。
    for (j = 0; j < i; j++)
    {
        mylog_putc(tmp_buf[j]); //写到环形缓冲区中
    }

    return i;
}

/*函数功能 : 把mylog_buf的数据copy_to_user拷贝到用户空间
*注意 : 下面的驱动程序，在 cat 执行之后，肯定会先 mymsg_open()，再 mymsg_read()
* 其中 mylog_getc()函数，会将读指针 mylog_r 后移，再次cat的时候，mylog_r 已经后移了。
* 这样就不是我们想要的效果，我们想要每次cat，都可以读出全部内容，如何修改???
*思路 : 每次 mymsg_read() 前，mylog_r必须在起点位置。
*/
static ssize_t mymsg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    int error = 0;
    int i = 0;
    char c;

    /* 如果以非阻塞方式读取+缓冲区是空，则报错返回。*/
    /*if((file->f_flags & O_NONBLOCK) && is_mylog_empty())*/
    if((file->f_flags & O_NONBLOCK) && is_mylog_empty_for_read()) /*为了可以多次使用cat函数*/
    {
            return -EAGAIN;
    }

    /*以阻塞方式读取
    睡眠等待，直到缓冲区非空。即如果缓冲区是空，则本进程休眠*/
    /*error = wait_event_interruptible(mymsg_waitq, !is_mylog_empty());*/
    error = wait_event_interruptible(mymsg_waitq, !is_mylog_empty_for_read()); /*为了可以多次使用cat函数*/

    /* 缓冲区非空 或者 本进程被唤醒，则copy_to_user */
    /* while(!error && (mylog_getc(&c)) && i < count) */
    while(!error && (mylog_getc_for_read(&c)) && i < count) /*为了可以多次使用cat函数*/
    {
            error = __put_user(c, buf);
            buf++;
            i++;
    }

    if(!error) //如果没有错误，则error赋i值，再返回。
    {
            error = i;
    }

    return error;
}

/*open函数*/
static int mymsg_open(struct inode *inode, struct file *file)
{
    /*cat执行一次，则open执行一次，让mylog_r_for_read指向 当前 读取位置 mylog_r
    *目的 : 保持原来的值不变，用另外一个变量去表示读取位置。
    * 这样，无论执行多少次cat，读取位置都会保存不变。
    */
    mylog_r_for_read = mylog_r;
    return 0;
}

struct file_operations proc_mymsg_operations = {

    .read        = mymsg_read,
    .open        = mymsg_open,
};

static int __init mymsg_init(void)
{
    /*create_proc_entry函数功能 : 在虚拟文件系统/proc目录下面，生成一个文件 mymsg
    *参数 : mymsg : 目录名称
    * S_IRUSR : 文件权限，只读
    * proc_root : 父目录
    */
    myentry = create_proc_entry("mymsg", S_IRUSR, &proc_root);
    if(myentry)
    {
            /*注意 : 以后读写myentry条目指向的文件的时候，会调用到这里给出的操作函数。*/
            myentry->proc_fops = &proc_mymsg_operations;
    }

    return 0;
}

static void __exit mymsg_exit(void)
{
    remove_proc_entry("mymsg", &proc_root);

    return;
}

module_init(mymsg_init);
module_exit(mymsg_exit);

/*EXPORT_SYMBOL()功能 : 导出myprintk函数，以便其他驱动程序可以使用。*/
EXPORT_SYMBOL(myprintk);

MODULE_AUTHOR("wangxiancai");
MODULE_DESCRIPTION("DEVICE : key");
MODULE_LICENSE("GPL");


/*
*注意 : 本驱动程序提供的myprintk()函数，测试的驱动程序在: nfs_2.6.13\wxc\driver\chardriver\example\mydriver_myprintk.c
* 测试的应用程序在: nfs_2.6.13\wxc\app\example\mydrivertest_myprintk.c
*测试步骤 :
* 1,直接插入我们自己使用myprintk函数的驱动模块 : insmod mydriver_myprintk.ko
* 会报错如下 : mydriver_myprintk: Unknown symbol myprintk
* insmod: cannot insert `mydriver_myprintk.ko': Unknown symbol in module (-1): No such file or directory
*                2,所以需要我们先插入生成myprintk函数的驱动模块 :
*                        # insmod proc_mymsg.ko
* 3, insmod mydriver_myprintk.ko
*                        # cat /proc/mymsg //可以看见myprintk打印的日志已经保存在这个文件里面了。
*                        DEVICE:mydriver_init
*                        DEVICE:register mydriver  Major = [253]
*                        DEVICE:initialized
* mknod /dev/mydriver_myprintk c 253 0
* 4，应用程序 ：
*                        # ./mydrivertest_myprintk
*                        APP:open fd=[3]
*                        APP:0000000000000000000000000000000
*                        APP:readbuf = [zhangqiuping], ret=[12]
*                        APP:1111111111111111111111111111111
*                        APP:writebuf = [wangxiancai], ret=[11]
*                        APP:2222222222222222222222222222222
*
*                        # cat /proc/mymsg //可以看见myprintk新打印的日志已经保存在这个文件里面了。
*                        DEVICE:mydriver_open
*                        DEVICE:mydriver_read
*                        DEVICE:buf=[],count=[12],*f_pos=[0]
*                        DEVICE:mydriver_read:copy_to_user:ret=[0]
*                        DEVICE:readbuf=[zhangqiuping],buf=[zhangqiuping],count=[12],*f_pos=[0]
*                        DEVICE:mydriver_write
*                        DEVICE:buf=[wangxiancai],count=[11],*f_pos=[0]
*                        DEVICE:mydriver_write:copy_from_user:ret=[0], writebuf=[wangxiancai]
*                        DEVICE:buf =[wangxiancai],count=[11],*f_pos=[0]
*                        DEVICE:mydriver_release
*
* 注意 : cat一次，就会read一次全部的文件，文件位置指针会指向文件尾部，如果没有新数据加入到文件，则再次cat时，什么也看不见。
* 5, 解决cat的问题后，再测试。cat可以多次执行。
*/

mydriver_myprintk.c文件

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/irq.h>
#include <linux/device.h>

#include <asm-arm/arch/regs-gpio.h>
#include <asm/arch/hardware.h>

#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/fcntl.h>
#include <linux/fs.h>

#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/system.h>

#include <linux/device.h>

#define DEVICE_NAME    "mydriver_myprintk"
static int MYDRIVER_Major = 0;

static char readbuf[1024] = "zhangqiuping";
static char writebuf[1024] ="";

static struct class * mydriver_class;
static struct class_device    * mydriver_class_dev;

/*申明一个外部定义的函数，申明之后，本程序就可以使用了。
*要想使用myprintk函数需要先插入生成myprintk()函数的驱动模块 # insmod proc_mymsg.ko
*再插入本驱动程序的模块，才可以正常使用myprintk()函数。
*/
extern int myprintk(const char *fmt, ...);

static int mydriver_open(struct inode *inode, struct file *file)
{
    myprintk("DEVICE:mydriver_open Called!\n");
    return 0;
}

static int mydriver_release(struct inode *inode, struct file *file)
{
    myprintk("DEVICE:mydriver_release Called!\n");
    return 0;
}

/*
count : 应用程序传来的read的第3个参数。
*/
static int mydriver_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    int ret = -1;

    myprintk("DEVICE:mydriver_read Called!\n");
    myprintk("DEVICE:buf=[%s],count=[%ld],*f_pos=[%ld]\n", buf, (long)count, (long)(*f_pos));

    if(count < 1024)
    {
        /*
        put_user("zhangqiuping", buf);
        */
        ret=copy_to_user(buf, readbuf, count);
        myprintk("DEVICE:mydriver_read:copy_to_user:ret=[%d]\n", ret);
        myprintk("DEVICE:readbuf=[%s],buf=[%s],count=[%ld],*f_pos=[%ld]\n",readbuf, buf, (long)count, (long)(*f_pos));
        if(ret == 0) /*正常返回*/
        {
            return count;
        }
        else /*错误返回*/
        {
            myprintk("copy_to_user faile!\n");
            return -EFAULT;
        }
    }
    else
    {
        myprintk("buffer should less than 1024\n");
        return -EFAULT;
    }
}

static int mydriver_write(struct file *file, const char __user *buf, size_t count, loff_t *f_pos)
{
    int ret;

    myprintk("DEVICE:mydriver_write Called!\n");
    myprintk("DEVICE:buf=[%s],count=[%ld],*f_pos=[%ld]\n", buf, (long)count, (long)(*f_pos));

    if(count < 1024)
    {
        ret = copy_from_user(writebuf, buf, count);
        myprintk("DEVICE:mydriver_write:copy_from_user:ret=[%d], writebuf=[%s]\n", ret, writebuf);
        myprintk("DEVICE:buf =[%s],count=[%ld],*f_pos=[%ld]\n", buf, (long)count, (long)(*f_pos));
        if(ret == 0) /*正常返回*/
        {
            return count;
        }
        else /*错误返回*/
        {
            myprintk("copy_from_user faile\n");
            return -EFAULT;
        }
    }
    else
    {
        myprintk("buffer should less than 1024\n");
        return -EFAULT;
    }
}

static int mydriver_ioctl( struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    myprintk("DEVICE:mydriver_ioctl Called!\n");
    myprintk("DEVICE:cmd=[%d], arg=[%ld]\n", cmd, arg);

    return 0;
}

/*
static : 表示只在本文件中使用
*/
static struct file_operations mydriver_fops =
{
    .owner = THIS_MODULE, /*固定写这个*/
    .open = mydriver_open,
    .release = mydriver_release,
    .read = mydriver_read,
    .write = mydriver_write,
    .ioctl = mydriver_ioctl,
};

/*
__init __exit其实不要，也是可以运行的
这里加上的目的是：
当编译进内核时；
__init : 在初始化完成之后，丢弃该函数，并收回内存，无__init标示是，标示不收回内存。
__exit : 忽略“清理收尾”的函数，即忽略mydriver_exit()函数所占的空间，因为既然编译进内核了，就不可能再卸载了，就不需要这个函数了。

当编译成模块时，__init __exit : 用不用都一样，
*/
static int __init mydriver_init(void)
{
    myprintk("DEVICE:mydriver_init\n");
    /*
    老方法注册:
    int register_chrdev(unsigned int major, const char * name, struct file_operations * fops);
    register_chrdev函数功能：注册一个字符设备，并向内核添加一个设备了。
    只是在内核数组中，把mydriver_fops结构 填充进去。还不会生成文件系统的信息，也不会生成设备节点。
    第1个参数：主设备号，0：表示让内核自动分配一个设备号。也可以程序员自己指定：第1个参数指定为非0的数,比如233。
    第2个参数：要生成的设备的名称。
    第3个参数：文件操作的结构体。
    返回值：第1个参数是0，就返回主设备号。第1个参数是253，注册成功返回0，注册失败返回非0。
    */
    MYDRIVER_Major = register_chrdev(0, DEVICE_NAME, &mydriver_fops);
    if (MYDRIVER_Major < 0)
    {
        myprintk(DEVICE_NAME " can't register major number\n");
        return MYDRIVER_Major;
    }
    myprintk("DEVICE:register mydriver OK! Major = [%d]\n", MYDRIVER_Major);

    /*注册一个类，使mdev可以在"/dev/"目录下面建立设备节点
    静态编译进内核的，才可以依赖mdev来建立设备节点，
    编译成模块的，还是必须得使用，insmod，mknod，rmmod
    */
    mydriver_class = class_create(THIS_MODULE, DEVICE_NAME);
    if(IS_ERR(mydriver_class))
    {
        myprintk("DEVICE:class_create err!\n");
        return -1;
    }
    //创建一个设备节点，节点名为DEVICE_NAME
    //device_create(mydriver_class, NULL, MKDEV(MYDRIVER_Major, 0), NULL, DEVICE_NAME);
    mydriver_class_dev = class_device_create(mydriver_class, MKDEV(MYDRIVER_Major, 0), NULL, DEVICE_NAME); // dev/mydriver

    myprintk("DEVICE:initialized\n");
    return 0;
}

static void __exit mydriver_exit(void)
{
    myprintk("DEVICE:mydriver_exit####################\n");

  /*unregister_chrdev函数功能:
  老方法注销：将注册的字符设备撤销
  unregister_chrdev(unsigned int major, const char * name);
  */
    unregister_chrdev(MYDRIVER_Major, DEVICE_NAME);
    class_device_destroy(mydriver_class, MKDEV(MYDRIVER_Major, 0));
    class_destroy(mydriver_class);
}

module_init(mydriver_init);
module_exit(mydriver_exit);

MODULE_AUTHOR("wangxiancai");
MODULE_DESCRIPTION("DEVICE:mydriver");
MODULE_LICENSE("GPL");


/*
源码分析:

内核使用read，write函数来和用户传输数据:
因为，用户空间和内核空间，不能使用memcpy这样的拷贝，而是使用内核提供的接口来进行，如下2个函数，是内核提供的接口:
#include <asm/uaccess.h>
unsigned long copy_to_user(void __usr * to, const void * from, unsigned long count); //数据：内核空间->用户空间

ungigned long copy_from_user(void * to, const void * __user from, unsigned long count);//数据：用户空间->内核空间

*/

应用程序:

CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-gcc
all: myprintk regeditor
myprintk:myprintk.c
    $(CROSS) -o myprintk myprintk.c
clean:
    @rm -vf myprintk.o myprintk

myprintk.c文件

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

int main(int argc, char **argv)
{
    int fd = -1;
    int ret = -1;
    char readbuf[1024];
    char writebuf[1024];

    fd = open("/dev/mydriver_myprintk", O_RDWR|O_TRUNC);
    if (fd < 0)
    {
        perror("APP:open err!");
        exit(1);
    }
    printf("APP:open fd=[%d]\n", fd);

    printf("APP:0000000000000000000000000000000\n");

    memset(readbuf, 0, sizeof(readbuf));
    ret=read(fd, readbuf, 12);
    if(ret<0)
    {
        perror("APP:read err!");
        exit(1);
    }
    printf("APP:readbuf = [%s], ret=[%d]\n", readbuf, ret);

    printf("APP:1111111111111111111111111111111\n");

    memset(writebuf, 0, sizeof(writebuf));
    strcpy(writebuf, "wangxiancai");
    ret=write(fd, writebuf, 11); /*返回值还有问题*/
    printf("APP:writebuf = [%s], ret=[%d]\n", writebuf, ret);
    if(ret<0)
    {
        perror("APP:write err!");
        exit(1);
    }

    printf("APP:2222222222222222222222222222222\n");

    close(fd);

    return 0;
}