简单字符驱动设备

雨点打透心脏的1/2处 2022-06-16 00:15 253阅读 0赞

scull 字符设备驱动程序的设备描述
    
    字符设备驱动程序是分配一段内存，然后提供对这个设备的管理方式，我们通过它提供的操作来操纵字符驱动设备，本质上是一个我们分配的模拟内存来模拟驱动设备。
    
     
    
    结构如下：
    
     
    
    
    
    
    几个重要方法，我们最初只提供几个简单的接口函数。
    
     
    
    read : 拷贝数据到应用程序空间。
    
    write: 拷贝数据到内核空间，在这里就是我们的字符驱动设备。
    
    open : 打开并且初始化设备。
    
    字符设备驱动程序几个重要的数据结构：
    
     
    
    ```
    
    struct scull_dev {
    
    struct scull_qset *data;  /* Pointer to first quantum set */
    
    int quantum;              /* the current quantum size */
    
    int qset;                 /* the current array size */
    
    unsigned long size;       /* amount of data stored here */
    
    unsigned int access_key;  /* used by sculluid and scullpriv */
    
    struct semaphore sem;     /* mutual exclusion semaphore     */
    
    struct cdev cdev;   /* Char device structure */
    
    };
    
    ```
    
     
    
    ```
    
    struct cdev {
    
    struct kobject kobj;
    
    struct module *owner;
    
    const struct file_operations *ops;
    
    struct list_head list;
    
    dev_t dev;
    
    unsigned int count;
    
    };
    
    ```
    
     
    
    ```
    
    struct inode {
    
    umode_t i_mode;
    
    unsigned short i_opflags;
    
    kuid_t i_uid;
    
    kgid_t i_gid;
    
    unsigned int i_flags;
    
     
    
    #ifdef CONFIG_FS_POSIX_ACL
    
    struct posix_acl *i_acl;
    
    struct posix_acl *i_default_acl;
    
    #endif
    
     
    
    const struct inode_operations *i_op;
    
    struct super_block *i_sb;
    
    struct address_space *i_mapping;
    
     
    
    #ifdef CONFIG_SECURITY
    
    void *i_security;
    
    #endif
    
     
    
    /* Stat data, not accessed from path walking */
    
    unsigned long i_ino;
    
    /*
    
    * Filesystems may only read i_nlink directly.  They shall use the
    
    * following functions for modification:
    
    *
    
    *    (set|clear|inc|drop)_nlink
    
    *    inode_(inc|dec)_link_count
    
    */
    
    union {
    
    const unsigned int i_nlink;
    
    unsigned int __i_nlink;
    
    };
    
    dev_t i_rdev;
    
    loff_t i_size;
    
    struct timespec i_atime;
    
    struct timespec i_mtime;
    
    struct timespec i_ctime;
    
    spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
    
    unsigned short          i_bytes;
    
    unsigned int i_blkbits;
    
    blkcnt_t i_blocks;
    
     
    
    #ifdef __NEED_I_SIZE_ORDERED
    
    seqcount_t i_size_seqcount;
    
    #endif
    
     
    
    /* Misc */
    
    unsigned long i_state;
    
    struct mutex i_mutex;
    
     
    
    unsigned long dirtied_when; /* jiffies of first dirtying */
    
    unsigned long dirtied_time_when;
    
     
    
    struct hlist_node i_hash;
    
    struct list_head i_io_list; /* backing dev IO list */
    
    #ifdef CONFIG_CGROUP_WRITEBACK
    
    struct bdi_writeback *i_wb; /* the associated cgroup wb */
    
     
    
    /* foreign inode detection, see wbc_detach_inode() */
    
    int i_wb_frn_winner;
    
    u16 i_wb_frn_avg_time;
    
    u16 i_wb_frn_history;
    
    #endif
    
    struct list_head i_lru; /* inode LRU list */
    
    struct list_head i_sb_list;
    
    union {
    
    struct hlist_head i_dentry;
    
    struct rcu_head i_rcu;
    
    };
    
    u64 i_version;
    
    atomic_t i_count;
    
    atomic_t i_dio_count;
    
    atomic_t i_writecount;
    
    #ifdef CONFIG_IMA
    
    atomic_t i_readcount; /* struct files open RO */
    
    #endif
    
    const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
    
    struct file_lock_context *i_flctx;
    
    struct address_space i_data;
    
    struct list_head i_devices;
    
    union {
    
    struct pipe_inode_info *i_pipe;
    
    struct block_device *i_bdev;
    
    struct cdev *i_cdev;
    
    char *i_link;
    
    };
    
     
    
    __u32 i_generation;
    
     
    
    #ifdef CONFIG_FSNOTIFY
    
    __u32 i_fsnotify_mask; /* all events this inode cares about */
    
    struct hlist_head i_fsnotify_marks;
    
    #endif
    
     
    
    void *i_private; /* fs or device private pointer */
    
    };
    
    ```
    
     
    
    ```
    
    struct file {
    
    union {
    
    struct llist_node fu_llist;
    
    struct rcu_head fu_rcuhead;
    
    } f_u;
    
    struct path f_path;
    
    struct inode *f_inode; /* cached value */
    
    const struct file_operations *f_op;
    
     
    
    /*
    
    * Protects f_ep_links, f_flags.
    
    * Must not be taken from IRQ context.
    
    */
    
    spinlock_t f_lock;
    
    atomic_long_t f_count;
    
    unsigned int f_flags;
    
    fmode_t f_mode;
    
    struct mutex f_pos_lock;
    
    loff_t f_pos;
    
    struct fown_struct f_owner;
    
    const struct cred *f_cred;
    
    struct file_ra_state f_ra;
    
     
    
    u64 f_version;
    
    #ifdef CONFIG_SECURITY
    
    void *f_security;
    
    #endif
    
    /* needed for tty driver, and maybe others */
    
    void *private_data;
    
     
    
    #ifdef CONFIG_EPOLL
    
    /* Used by fs/eventpoll.c to link all the hooks to this file */
    
    struct list_head f_ep_links;
    
    struct list_head f_tfile_llink;
    
    #endif /* #ifdef CONFIG_EPOLL */
    
    struct address_space *f_mapping;
    
    } __attribute__((aligned(4))); /* lest something weird decides that 2 is OK */
    
     
    
    struct file_handle {
    
    __u32 handle_bytes;
    
    int handle_type;
    
    /* file identifier */
    
    unsigned char f_handle[0];
    
    };
    
    ```
    
     
    
    ```
    
    struct file_operations {
    
    struct module *owner;
    
    loff_t (*llseek) (struct file *, loff_t, int);
    
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    
    ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
    
    ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
    
    int (*iterate) (struct file *, struct dir_context *);
    
    unsigned int (*poll) (struct file *, struct poll_table_struct *);
    
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    
    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    
    int (*mmap) (struct file *, struct vm_area_struct *);
    
    int (*open) (struct inode *, struct file *);
    
    int (*flush) (struct file *, fl_owner_t id);
    
    int (*release) (struct inode *, struct file *);
    
    int (*fsync) (struct file *, loff_t, loff_t, int datasync);
    
    int (*aio_fsync) (struct kiocb *, int datasync);
    
    int (*fasync) (int, struct file *, int);
    
    int (*lock) (struct file *, int, struct file_lock *);
    
    ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    
    unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    
    int (*check_flags)(int);
    
    int (*flock) (struct file *, int, struct file_lock *);
    
    ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    
    ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    
    int (*setlease)(struct file *, long, struct file_lock **, void **);
    
    long (*fallocate)(struct file *file, int mode, loff_t offset,
    
    loff_t len);
    
    void (*show_fdinfo)(struct seq_file *m, struct file *f);
    
    #ifndef CONFIG_MMU
    
    unsigned (*mmap_capabilities)(struct file *);
    
    #endif
    
    };
    
    ```
    
     
    
     
    
    设备驱动程序设计的基本框架
    
     
    
     
    
    
    正在上传…
    取消
    
    
    1.申请设备号，主，次设备号。
    
     
    
    2.构建我们的设备结构。
    
     
    
    3.编写fops的内核提供的操作方法，更新fops指针。
    
     
    
    4.注册我们的设备。
    
     
    
     
    
    测试结果
    
     
    
    我们可以看到，当给我们的scull新设备写入数据的时候，使用free命令就可以看到内存被成功占用。
    
     
    
    这里有一个重要问题：
    
     
    
    如何安全的将数据在用户空间和逻辑空间之间拷贝？
    
     
    
    解决方法：内核提供了安全的拷贝函数：
    
    copy_to_user
    
    copy_from_user
    
     
    
    关于这两个函数有一篇博客描述的比较清楚：
    
     
    
    http://blog.csdn.net/ce123_zhouwei/article/details/8454226
    
     
    
     
    
    unsigned long copy_to_user(void __user *to, const void *from, unsigned long n);
    
     
    
    如果数据拷贝成功，则返回零；否则，返回没有拷贝成功的数据字节数。
    
     
    
    *to是用户空间的指针，
    
     
    
    *from是内核空间指针，
    
     
    
    n表示从内核空间向用户空间拷贝数据的字节数。
    
    功能：用于将用户空间的数据传送到内核空间。
    
     
    
    unsigned long copy_from_user(void * to, const void __user * from, unsigned long n)
    
     
    
    第一个参数to是内核空间的数据目标地址指针，
    
     
    
    第二个参数from是用户空间的数据源地址指针，
    
     
    
    第三个参数n是数据的长度。
    
     
    
    如果数据拷贝成功，则返回零；否则，返回没有拷贝成功的数据字节数。
    
     
    
    此函数将from指针指向的用户空间地址开始的连续n个字节的数据产送到to指针指向的内核空间地址.