printkd

#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/namei.h>
#include <linux/vmalloc.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/workqueue.h>

#define BUFSIZE (1024)

static struct file *pFile = NULL;
static char *pBuf = NULL;
static struct delayed_work printkd_work;
static struct workqueue_struct *printkd_workqueue = NULL;

int printkd2sd(const char *buf, int bufLength)
{
    mm_segment_t old_fs;
    if(NULL == buf)
    {
        printk("%s pBuf pFile null\n", __func__);
        ;
    }
    if (IS_ERR(pFile))
    {
        printk("%s pFile null\n", __func__ );
        ;
    }
    old_fs = get_fs();
    set_fs(KERNEL_DS);
    if(bufLength != pFile->f_op->write(pFile, (char *)buf, bufLength, &pFile->f_pos) )
    {
        printk("%s: write err\n", __FUNCTION__);
        set_fs(old_fs);
        ;
    }
    set_fs(old_fs);
    ;
}

int printkd2buf(char *buf, unsigned short len)
{
    ;
    ;
     == len))
    {
        printk("%s(), par err\n");
        ;
    }
    if(len >= BUFSIZE)
    {
        ret = printkd2sd(pBuf, p);
        p = ;
        ret = printkd2sd(buf, len);
    }
     - p) )
    {
        memcpy( (pBuf + p), buf, len);
        p = p + len;
    }
    else
    {
        ret = printkd2sd(pBuf, p);
        memcpy(pBuf, buf, len);
        p = len;
    }
    return ret;
}

static asmlinkage int vscnprintkd(const char *fmt, va_list args)
{
    ];
    int ret;
    unsigned int printed_len;
    printed_len = vscnprintf( printk_buf , (),  fmt,  args);
    ret = printkd2buf(printk_buf,  printed_len );
    return ret;
}

static void  printkd_init_work(struct work_struct *work)
{
    mm_segment_t old_fs;
    pFile = filp_open();
    if (IS_ERR(pFile))
    {
        printk("%s filp_open error\n", __func__ );
        ;
    }
    pBuf = vmalloc(BUFSIZE + );
    if(NULL == pBuf)
    {
        printk("%s vmalloc err\n", __func__);
        goto close_file;
    }
    printkd2buf("printkd log start...\n", sizeof("printkd log start...\n") );
    printk("%s(), ok!\n",  __func__);
    return;

close_file:
    filp_close(pFile, NULL);
    pFile = NULL;
    printk("%s(), err!\n",  __func__);
    queue_delayed_work(printkd_workqueue, &printkd_work, HZ * );
    return;
}

int printkd_init(void )
{
    printkd_workqueue = create_workqueue("printkd_init");
    INIT_DELAYED_WORK(&printkd_work, printkd_init_work);
    queue_delayed_work(printkd_workqueue, &printkd_work, HZ * );
}

int printkd_read_log( char **pBuf)
{
    struct inode *inode = NULL;
    mm_segment_t oldfs;
    char *buf = NULL;
    unsigned ;
    int ret;
    if((NULL == pFile) || (NULL == pBuf) )
    {
        printk("%s pFile pBuf null\n",  __func__);
        ;
    }
    oldfs = get_fs();
    set_fs(KERNEL_DS);
    if (!pFile->f_op)
    {
        printk("%s: File Operation Method Error\n", __FUNCTION__);
        goto __fs_close;
    }
    inode = pFile->f_path.dentry->d_inode;
    if (!inode)
    {
        printk("%s: Get inode from pFile failed\n", __FUNCTION__);
        goto __fs_close;
    }
    file_length = i_size_read(inode->i_mapping->host);
     && (file_length <  * ) ))
    {
        printk("%s file size error\n", __FUNCTION__);
        goto __fs_close;
    }
    buf = vmalloc(file_length +  );
    if (!buf)
    {
        printk("%s alloctation memory failed\n", __FUNCTION__);
        goto __fs_close;
    }
    pFile->f_op->llseek(pFile, , SEEK_SET);
    ret = vfs_read(pFile, buf, file_length, &pFile->f_pos);
    if (ret  != file_length)
    {
        printk("%s: vfs_read error, file_length:%d, ret:%d\n", __FUNCTION__, file_length, ret);
        pFile->f_op->llseek(pFile, , SEEK_END);
        goto free_buf;
    }
    pFile->f_op->llseek(pFile, , SEEK_END);
    printk("%s file_length:0x%x\n", __func__, file_length);
    *pBuf = buf;
    set_fs(oldfs);
    printk("%s(), ok!\n",  __func__);
    return file_length;

free_buf:
    vfree(buf);
__fs_close:
    set_fs(oldfs);
    printk("%s(), error!\n",  __func__);
    ;
}

asmlinkage int printkd(const char *fmt, ...)
{
    va_list args;
    int r;
    va_start(args, fmt);
    r = vscnprintkd(fmt, args);
    va_end(args);
    return r;
}