Не компилируется простой драйвер устройства

#ifndef DOCUMENTATION_H
#define  DOCUMENTATION_H
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/ioctl.h>
 
#define SUCCESS 0
#define DEVICE_NAME "chardev"
#define BUF_LEN 10000
 
int init_module(void);
void cleanup_module(void);
 
static int device_open(struct inode *, struct file *);
static int device_release(struct inode *, struct file *);
static ssize_t device_read(struct file *, char *, size_t, loff_t *);
static ssize_t device_write(struct file *, const char *, size_t, loff_t *);
int device_ioctl(struct inode *inode, struct file *file, 
    unsigned int ioctl_num, unsigned long ioctl_param);
 
 
static int Major;
static int Device_Open = 0;
static bool is_dev_opened = false;
 
#define IOCTL_SET_MSG _IOR(Major, 0, char *)
#define IOCTL_GET_MSG _IOR(Major, 1, char *)
#define IOCTL_WRITE_FILE _IOR(Major, 2, int)
#define IOCTL_DELETE _IOR(Major, 3, int)
 
static char msg[BUF_LEN];
static char *buff_Ptr;
static bool deleted = false;
static bool is_fwd_dir = true;
 
static struct file_operations fops = {
        .read = device_read,
        .write = device_write,
    .ioctl = device_ioctl,
        .open = device_open,
        .release = device_release 
};
 
 
#endif
 
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include "documentation.h"
#include "Analyse.h"
#include "Read.h"
#include "Write.h"
 
int init_module(void)
 {
    Major = register_chrdev(0, DEVICE_NAME, &fops);
    if (Major < 0)
    {
        printk(KERN_ALERT "Registering device failed with %d\n", Major);
        return Major;
    }
    printk(KERN_INFO "Major number - %d\n", Major);
    printk(KERN_INFO "'mknod /dev/%s c %d 0'.\n", DEVICE_NAME, Major);
    printk(KERN_INFO "Available commands:\n");
    printk(KERN_INFO "delete, dir back\n");
    printk(KERN_INFO "use 'rm /dev/%s'.\n\n", DEVICE_NAME);
    return SUCCESS;
}
 
void cleanup_module(void)
{
    unregister_chrdev(Major, DEVICE_NAME);
    printk(KERN_ALERT "Closing.\n\n");
}
 
static int device_open(struct inode *inode, struct file *file) 
{
    printk(KERN_INFO "device-open- %d\n", Major);
    if (is_dev_opened)
    {
        return -EBUSY;
    }
    ++Device_Open;
    is_dev_opened = true;
    buff_Ptr = msg;
    try_module_get(THIS_MODULE);
    return SUCCESS;
}
 
static  int device_release(struct inode *inode, struct file *file) 
{
    printk(KERN_INFO "device-release - %d\n", Major);
    --Device_Open;
    is_dev_opened = false;
    module_put(THIS_MODULE);
    return 0;
}
 
int device_ioctl(struct inode *inode, struct file *file, 
    unsigned int ioctl_num, unsigned long ioctl_param)
{
    int i;
    char *temp;
    char ch;
 
    switch (ioctl_num) {
case IOCTL_SET_MSG:
 
    temp = (char *)ioctl_param;
    get_user(ch, temp);
    for (i = 0; ch && i < BUF_LEN; i++, temp++)
        get_user(ch, temp);
    device_write(file, (char *)ioctl_param, i, 0);
    break;
case IOCTL_GET_MSG:
    char bufer[BUF_LEN];
    i = device_read(file, (char *)ioctl_param, 99, 0);
    put_user('\0', (char *)ioctl_param + i);
    break;
case IOCTL_WRITE_FILE:
    char tempbuf[BUF_LEN];
    i = device_read(file, tempbuf, BUF_LEN, 0);
    device_write(file, tempbuf, i, 0);
    break;
case IOCTL_DELETE:
    char buf[BUF_LEN];
    for (i = 0; i < BUF_LEN; i++)
        buf[i] = ' ';
    
    device_write(file, buf, i, 0);
    delete_content();
    }
    return 0;
}
 
//ioctl.c 
 
#include "documentation.h"
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
 
ioctl_set_msg(int file_desc, char *message)
{
    int ret_val;
    ret_val = ioctl(file_desc, IOCTL_SET_MSG, message);
    if (ret_val < 0) {
        printf("ioctl_set_msg failed:%d\n", ret_val);
        exit(-1);
    }
}
 
ioctl_get_msg(int file_desc)
{
    int ret_val;
    char message[1000];
 
    ret_val = ioctl(file_desc, IOCTL_GET_MSG, message);
    if (ret_val < 0) {
        printf("ioctl_get_msg failed:%d\n", ret_val);
        exit(-1);
    }
}
 
ioctl_write_file(int file_desc, int file_write_desc)
{
    int ret_val;
    ret_val = ioctl(file_desc, IOCTL_WRITE_FILE, file_write_desc);
    if (ret_val < 0) {
        printf("ioctl_set_msg failed:%d\n", ret_val);
        exit(-1);
    }
 
}
 
ioctl_file_delete(int file_desc)
{
    int ret_val;
    ret_val = ioctl(file_desc, IOCTL_DELETE, 0);
    if (ret_val < 0) {
        printf("ioctl_set_msg failed:%d\n", ret_val);
        exit(-1);
    }
}
 
main()
{
    int file_desc1, file_desc2, ret_val;
    char *msg = "Message passed by ioctl\n";
    file_desc1= open("FIRST_FILE", 0);
    if (file_desc1 < 0) {
    printf("Can't open device file: %s\n", "FIRST_FILE");
    exit(-1);
    }
    file_desc2= open("SECOND_FILE", 0);
    if (file_desc2 < 0) {
    printf("Can't open device file: %s\n", "SECOND_FILE");
    exit(-1);
    }
    ioctl_set_msg(file_desc1, msg);
    iocle_write_file(file_desc1, file_desc2)
    iocle_file_delete(file_desc1);
    ioctl_get_msg(file_desc1);
    
    close(file_desc1);
    close(file_desc2);
}