Linux驅(qū)動-inode,file,file_operations關(guān)系

//include/linux/fs.h 596

/*

 * Keep mostly read-only and often accessed (especially for

 * the RCU path lookup and 'stat' data) fields at the beginning

 * of the 'struct inode'

 */

struct inode {

    umode_t            i_mode;

    unsigned short        i_opflags;

    kuid_t            i_uid;

    kgid_t            i_gid;

    unsigned int        i_flags;

    dev_t            i_rdev;

#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 */

    struct hlist_node    i_hash;

    struct list_head    i_wb_list;    /* backing dev IO list */

    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;

    const struct file_operations    *i_fop;    /* former ->i_op->default_file_ops */

    struct file_lock    *i_flock;

    struct address_space    i_data;

#ifdef CONFIG_QUOTA

    struct dquot        *i_dquot[MAXQUOTAS];

#endif

    struct list_head    i_devices;

    union {

        struct pipe_inode_info    *i_pipe;

        struct block_device    *i_bdev;

        struct cdev        *i_cdev;

    };

    __u32            i_generation;

#ifdef CONFIG_FSNOTIFY

    __u32            i_fsnotify_mask; /* all events this inode cares about */

    struct hlist_head    i_fsnotify_marks;

#endif

#ifdef CONFIG_IMA

    atomic_t        i_readcount; /* struct files open RO */

#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;

#define f_dentry    f_path.dentry

    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;

#ifdef CONFIG_DEBUG_WRITECOUNT

    unsigned long f_mnt_write_state;

#endif

} __attribute__((aligned(4)));    /* lest something weird decides that 2 is OK */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
static int major = 250;
static int minor = 0;
static dev_t devno;

#define MAX_COM_NUM 2

struct mydev{
    struct cdev cdev;
    char *reg;
    int test;
};
struct mydev *pmydev[MAX_COM_NUM];

ssize_t dev_fifo_read (struct file *file, char __user *buf, size_t size, loff_t *pos)
{
    int minor = MINOR(file->f_dentry->d_inode->i_rdev);
    struct mydev *cd;
    
    printk("read() MINOR(file->f_dentry->d_inode->i_rdev)=%d\n",minor);

    cd = (struct mydev *)file->private_data;
    printk("read()       file->private_data         cd->test=%d\n",cd->test);

    if(copy_to_user(buf, &minor, size)){
        return -EFAULT;
    }

    return size;
}
int dev_fifo_close (struct inode *inode, struct file *file)
{
    printk("dev_fifo_close()\n");
    return 0;
}
//打開設備
static int dev_fifo_open (struct inode *inode, struct file *file)
{
    struct mydev *cd;
    
    cd = container_of(inode->i_cdev, struct mydev, cdev);
    file->private_data = cd;
    return 0;
}
static struct file_operations dev_fifo_ops =
{
    .open = dev_fifo_open,
    .read = dev_fifo_read,
    .release = dev_fifo_close,
};
static int dev_fifo_init(void)
{
    int result;
    int error;
    int i = 0;
    
    printk("dev_fifo_init \n");
    devno = MKDEV(major,minor);    
    result = register_chrdev_region(devno, MAX_COM_NUM, "test");
    if(result<0)
    {
        printk("register_chrdev_region fail \n");
        goto ERR1;
    }
    
    
    for(i=0;i<MAX_COM_NUM;i++)
    {
        pmydev[i] =kmalloc(sizeof(struct mydev), GFP_KERNEL);
    }
    
    for(i=0;i<MAX_COM_NUM;i++)
    {
        pmydev[i]->test = i;
        
        cdev_init(&pmydev[i]->cdev,&dev_fifo_ops);

        devno = MKDEV(major,i);    
        
        error = cdev_add(&pmydev[i]->cdev,devno,1);
        if(error < 0)
        {
            printk("cdev_add fail \n");
            goto ERR2;
        }
    }
    return 0;
ERR2:
    devno = MKDEV(major,0);    
    unregister_chrdev_region(devno,MAX_COM_NUM);
    for(i=0;i<MAX_COM_NUM;i++)
    {
        kfree(pmydev[i]);
    }
    return error;
ERR1:
    return result;
}
static void dev_fifo_exit(void)
{
    int i;
    
    printk("dev_fifo_exit \n");
    
    for(i=0;i<MAX_COM_NUM;i++)
    {
        cdev_del(&pmydev[i]->cdev);
    }
    for(i=0;i<MAX_COM_NUM;i++)
    {
        kfree(pmydev[i]);
    }

    devno = MKDEV(major,0);    
    unregister_chrdev_region(devno,MAX_COM_NUM);
    return;
}
MODULE_LICENSE("GPL");
MODULE_AUTHOR("daniel.peng");
module_init(dev_fifo_init);
module_exit(dev_fifo_exit);

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
    int fd0,fd1;
    int minor;
    
    fd0 = open("/dev/com0",O_RDWR);
    if(fd0<0)
    {
        perror("open fail \n");
        return;
    }
    printf("open /dev/com0 OK\n");

    read(fd0,&minor,sizeof(minor));
    printf("minor of /dev/com0 =%d\n",minor);
    close(fd0);
    
    fd1 = open("/dev/com1",O_RDWR);
    if(fd1<0)
    {
        perror("open fail \n");
        return;
    }
    printf("open /dev/com1 OK\n");

    read(fd1,&minor,sizeof(minor));
    printf("minor of /dev/com1 =%d\n",minor);


    close(fd1);