【Linux驱动】字符设备驱动内核源码深度解析

/* 定义在 fs/char_dev.c */#define CHRDEV_MAJOR_HASH_SIZE 255
staticstructchar_device_struct{
structchar_device_struct*next;/* 将相同哈希值的节点链接成链表 */
unsignedintmajor;        /* 主设备号 */
    unsignedintbaseminor;    /* 次设备号起始值 */
    intminorct;               /* 次设备号数量 */
charname[64];             /* 设备名称 */
    structcdev*cdev;         /* 内核字符对象（已废弃） */
} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];

/* 定义在 fs/char_dev.c */
staticstructchar_device_struct*__register_chrdev_region(unsignedintmajor,unsignedintbaseminor,intminorct,constchar*name) {
    structchar_device_struct*cd, **cp;
    intret=0;    inti;
    /* 1. 分配新的 char_device_struct 节点 */
    cd=kzalloc(sizeof(structchar_device_struct),GFP_KERNEL);
    if(cd==NULL)
        returnERR_PTR(-ENOMEM);
    mutex_lock(&chrdevs_lock);
    /* 2. 如果 major == 0，动态分配主设备号 */
    if(major==0) {
ret=find_dynamic_major();
            if(ret<0) {
                pr_err("CHRDEV \"%s\" dynamic allocation region is full\n",name);
                gotoout;
            }
            major=ret; 
    }
    /* 3. 主设备号范围校验 */
    if(major>=CHRDEV_MAJOR_MAX) {
        pr_err("CHRDEV \"%s\" major requested (%u) greater than max (%u)\n",name,major,CHRDEV_MAJOR_MAX-1);
ret= -EINVAL;
        gotoout;
    }
    cd->major=major;
    cd->baseminor=baseminor;
    cd->minorct=minorct;
    strlcpy(cd->name,name,sizeof(cd->name));
    /* 4. 计算哈希桶位置 */
    i=major_to_index(major);
    /* 5. 在链表中找到合适的插入位置（按主设备号、次设备号排序） */
    for(cp= &chrdevs[i]; *cp;cp= &(*cp)->next) {
        if((*cp)->major>major||
           ((*cp)->major==major&& 
           ((*cp)->baseminor>=baseminor|| 
           (*cp)->baseminor+ (*cp)->minorct>baseminor)))
break; 
        }
    /* 6. 检查次设备号是否冲突（三种重叠检测） */
    if(*cp&& (*cp)->major==major) {
        intold_min= (*cp)->baseminor;
        intold_max= (*cp)->baseminor+ (*cp)->minorct-1;        intnew_min=baseminor;        intnew_max=baseminor+minorct-1;
        /* 新范围与已有范围重叠 → 冲突 */
        if(new_max>=old_min&&new_max<=old_max) {
            ret= -EBUSY;
            gotoout;
        }
        if(new_min<=old_max&&new_min>=old_min) {
            ret= -EBUSY;
            gotoout;
        }
        /* 新范围完全覆盖已有范围 */
        if(new_min<old_min&&new_max>old_max) {
            ret= -EBUSY;
            gotoout;
        }
    }
    /* 7. 插入链表 */
    cd->next= *cp;
    *cp=cd;
    mutex_unlock(&chrdevs_lock);
    return cd;
out:
    mutex_unlock(&chrdevs_lock);
    kfree(cd);
    returnERR_PTR(ret);
}

staticintfind_dynamic_major(void){
    inti;
    structchar_device_struct*cd;
    /* 高优先级：在 234~254 范围内查找 */
    for(i=ARRAY_SIZE(chrdevs) -1;i>=CHRDEV_MAJOR_DYN_END;i--) {
        if(chrdevs[i] ==NULL)
        returni;
    }
    /* 低优先级：在 511~384 范围内查找 */
    for(i=CHRDEV_MAJOR_DYN_EXT_START;i>=CHRDEV_MAJOR_DYN_EXT_END;i--) {
        for(cd=chrdevs[major_to_index(i)];cd;cd=cd->next) {
            if(cd->major==i)
                break;
        }
        if(cd==NULL)
            returni; 
        }
    return-EBUSY;
}

• CHRDEV_MAJOR_MAX 512

• CHRDEV_MAJOR_DYN_END 234

• CHRDEV_MAJOR_DYN_EXT_START 511

• CHRDEV_MAJOR_DYN_EXT_END 384

/* 摘自 include/linux/cdev.h */
structcdev{
    structkobjectkobj;     /* 内嵌的kobject，用于设备模型管理 */
    structmodule*owner;    /* 指向所属模块，通常为THIS_MODULE */
    conststructfile_operations*ops; /* 设备操作函数集 */
    structlist_headlist;   /* 用于将cdev链接到对应设备号的cdev列表 */
    dev_tdev;               /* 记录该字符设备关联的起始设备号 */
    unsignedintcount;      /* 从dev开始连续占用的次设备号数量 */
}__randomize_layout;

/* 摘自 drivers/base/map.c */
structkobj_map{
    structprobe{
        structprobe*next;    /* 链表下一个节点 */
        dev_tdev;             /* 起始设备号 */
        unsignedlongrange;   /* 次设备号范围 */
        structmodule*owner;  /* 模块所有者 */
        kobj_probe_t*get;     /* 获取kobject的函数（用于查找） */
        int(*lock)(dev_t,void*); /* 锁定函数 */
        void*data;            /* 私有数据，通常指向cdev */
    } *probes[255];            /* 255个桶的哈希表 */
    structmutex*lock;        /* 保护映射表的锁 */
};

voidcdev_init(structcdev*cdev,conststructfile_operations*fops) {
    memset(cdev,0,sizeof*cdev); /* 清零结构体 */
    INIT_LIST_HEAD(&cdev->list);   /* 初始化链表头 */
    kobject_init(&cdev->kobj, &ktype_cdev_default); /* 初始化内嵌kobject */
    cdev->ops=fops;              /* 绑定文件操作集 */
}EXPORT_SYMBOL(cdev_init);

intcdev_add(structcdev*p,dev_tdev,unsignedcount) {
    interror;
    p->dev=dev; /* 记录起始设备号 */
    p->count=count; /* 记录次设备号数量 */
    /* 调用kobj_map注册，将设备号范围映射到该cdev */
    error=kobj_map(cdev_map,dev,count,NULL,exact_match,exact_lock,p);
    if(error)
        returnerror;
    /* 增加模块引用计数，防止模块被卸载 */
    kobject_get(p->kobj.parent);
    return0;
}
EXPORT_SYMBOL(cdev_add);

intkobj_map(structkobj_map*domain,dev_tdev,unsignedlongrange,
             structmodule*module,kobj_probe_t*probe,
             int(*lock)(dev_t,void*),void*data) {
    /* 1. 计算跨越了几个不同的主设备号 */
    unsignedn=MAJOR(dev+range-1) -MAJOR(dev) +1;
    unsigned index = MAJOR(dev);    unsigned i;    struct probe *p;    if (n > 255) n = 255;    /* 安全限制 */
    /* 2. 分配 n 个连续的 probe 结构体 */
    p=kmalloc_array(n,sizeof(structprobe),GFP_KERNEL);
    if (p == NULL) return-ENOMEM;
    /* 3. 初始化 n 个 probe（每个的 data 都指向同一个 cdev） */
    for(i=0;i<n;i++,p++) {
        p->owner=module;
        p->get=probe;
        p->lock=lock;
        p->dev=dev;
        p->range=range;
        p->data=data; 
    }
    /* 4. 将 probe 节点插入哈希表，按 range 排序 */
    mutex_lock(domain->lock);
    for(i=0,p-=n;i<n;i++,p++,index++) {
        structprobe**s= &domain->probes[index%255];
        /* 按 range 大小排序，range 小的在前 */
        while(*s&& (*s)->range<range)
            s= &(*s)->next;
        p->next= *s; 
        *s=p; 
    }
    mutex_unlock(domain->lock);
    return0;
}

dev_tdevno=MKDEV(major,0); /* 起始次设备号 0 */
cdev_init(&my_cdev, &fops);
cdev_add(&my_cdev,devno,3);  /* 占用次设备号 0, 1, 2 */

structmy_device{
    void__iomem*regs;   /* 该设备的寄存器映射地址 */
    structmutexlock;    /* 互斥锁 */
    /* ... 其他私有数据 */};staticstructmy_devicedevs[3];  /* 三个实例 */

staticintmy_open(structinode*inode,structfile*filp) {
    intminor=iminor(inode);   /* 获取次设备号 */
    if(minor<0||minor>=3)
        return-ENODEV;
    structmy_device*dev= &devs[minor]; /* 根据次设备号选择设备 */
    filp->private_data=dev;             /* 保存到私有数据中 */
    return0;
}

mknod/dev/mydevicec2500

voidinit_special_inode(structinode*inode,umode_tmode,dev_trdev) {
    inode->i_mode=mode;             /* 保存文件类型和权限 */
    if(S_ISCHR(mode)) {
        /* 字符设备文件 */
        inode->i_fop= &def_chr_fops; /* 默认字符设备操作表 */
        inode->i_rdev=rdev;         /* 保存设备号 */
    }elseif(S_ISBLK(mode)) {
        /* 块设备文件 */
        inode->i_fop= &def_blk_fops;
        inode->i_rdev=rdev; 
    }elseif(S_ISFIFO(mode))
        /* 命名管道 */
        inode->i_fop= &pipefifo_fops;
    elseif(S_ISSOCK(mode)) ;
/* 套接字不设置操作表 */
    else
        printk(KERN_DEBUG"bogus i_mode for inode %s:%lu\n",inode->i_sb->s_id,inode->i_ino);
}

/* 来源: fs/char_dev.c */
conststructfile_operationsdef_chr_fops= {
    .open=chrdev_open, /* 只定义了一个 open 方法 */
    .llseek=noop_llseek, /* 一个什么都不做的寻址函数 */
};

/* 来源: fs/char_dev.c */
staticintchrdev_open(structinode*inode,structfile*filp) {
    structcdev*p;
    struct cdev *new = NULL;    int ret=0;
    /* 第一步：获取或查找 cdev */
    p=inode->i_cdev;
    if(!p) {
        structkobject*kobj;
        intidx;
        /* 根据设备号在全局哈希表 cdev_map 中查找对应的 cdev */
        kobj=kobj_lookup(cdev_map,inode->i_rdev, &idx);
        if(!kobj)
            return-ENXIO;
        /* 通过 kobject 反推出包含它的 cdev */
        new=container_of(kobj,structcdev,kobj);
        /* 并发安全：再次检查并设置 inode->i_cdev（缓存优化） */
p=inode->i_cdev;
        if(!p) {
            inode->i_cdev=p=new;
            inode->i_cindex=idx;
            list_add(&inode->i_devices, &p->list);
            new=NULL; 
        }
    }
    /* 第二步 ★核心★ 替换文件操作表 */
    /* 将 file 的 f_op 从 def_chr_fops 替换为驱动自己的 fops */
    filp->f_op=fops_get(p->ops);
    if(!filp->f_op)
        return-ENXIO;
    /* 第三步：调用驱动自身的 open 函数 */
    if(filp->f_op->open) {
        ret=filp->f_op->open(inode,filp);
    }
    returnret;
}

SYSCALL_DEFINE3(open,constchar__user*,filename,
                int,flags,umode_t,mode) {
    returndo_sys_open(AT_FDCWD,filename,flags,mode);
}
longdo_sys_open(intdfd,constchar__user*filename,
                 intflags,umode_tmode) {
    structopen_howhow=build_open_how(flags,mode);
    returndo_sys_openat2(dfd,filename, &how);
}

staticlongdo_sys_openat2(intdfd,constchar__user*filename,
                           structopen_how*how) {
    structfilename*tmp=getname(filename);     /* 拷贝路径到内核空间 */
    intfd=get_unused_fd_flags(how->flags);     /* 分配空闲fd */
    structfile*f=do_filp_open(dfd,tmp,how); /* ★路径查找并打开★ */
    d_install(fd,f);                             /* 关联 fd 与 file */
    returnfd;
}

staticintdo_dentry_open(structfile*f,structinode*inode,
                          int(*open)(structinode*,structfile*)) {
    f->f_mode=OPEN_FMODE(f->f_flags) |FMODE_LSEEK|FMODE_PREAD|FMODE_PWRITE;
    f->f_inode=inode;
    f->f_mapping=inode->i_mapping;
    /* ★获取文件操作表：优先使用 inode->i_fop★ */
    f->f_op=fops_get(inode->i_fop);
    if(!f->f_op)
        return-ENXIO;
    if(open)
        error=open(inode,f);
    /* 否则调用文件操作表中的 open 方法 */
    /* 对于字符设备 = chrdev_open！ */
    if(!error&& (f->f_mode&FMODE_OPENED) &&f->f_op->open)
        error=f->f_op->open(inode,f);
    returnerror;
}

/*** container_of - 通过结构体成员指针获取父结构体指针* @ptr: 成员变量的指针* @type: 包含该成员的结构体类型* @member: 成员变量在结构体中的名称*/#definecontainer_of(ptr, type, member) ({ \    void *__mptr = (void *)(ptr); \    BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \    !__same_type(*(ptr), void), \    "pointer type mismatch in container_of"); \    ((type *)(__mptr - offsetof(type, member))); })/* 简化理解版本： */#definecontainer_of(ptr, type, member) \    ((type *)((char *)(ptr) - offsetof(type, member)))

/*** register_chrdev_region - 注册字符设备编号范围* @first: dev_t 类型，指定要注册的起始设备号（使用 MKDEV(major, minor) 宏生成）* @count: 需要注册的连续设备号数量（次设备号的范围）* @name: 设备名称，会出现在 /proc/devices 文件中* 返回值: 成功返回 0* 参数无效返回 -EINVAL* 设备号被占用返回 -EBUSY*/intregister_chrdev_region(dev_t first, unsignedint count, constchar *name);

staticstructfile_operationsmy_fops= {
    .owner=THIS_MODULE,  /* 防止模块在使用中被卸载 */
    .open=my_open, .read=my_read,
    .write=my_write,
    .release=my_release,
};
structcdevmy_cdev;
cdev_init(&my_cdev, &my_fops);
my_cdev.owner=THIS_MODULE;
cdev_add(&my_cdev,devno,count);

#include <linux/init.h>#include <linux/errno.h>#include <linux/mm.h>#include <linux/sched.h>#include <linux/module.h>#include <linux/ioctl.h>#include <linux/io.h>#include <linux/fs.h>#include <linux/cdev.h>#include <linux/uaccess.h>#include <linux/slab.h>#define GLOBALMEM_SIZE 1024#define GLOBALMEM_MAGIC 'M'#define MEM_CLEAR _IO(GLOBALMEM_MAGIC, 0)

/* ===== 设备私有数据结构体 ===== */
structglobalmem_dev{
    structcdevm_cdev;                /* 内嵌的字符设备 */
    unsignedcharmem[GLOBALMEM_SIZE]; /* 共享内存区域（1KB） */
};staticint globalmem_major = 266;struct globalmem_dev *globalmem_devp;/* 两个设备实例 *//* ===== open：用户打开设备文件时调用 ===== */
staticintglobalmem_open(structinode*inode,structfile*filp) {
    structglobalmem_dev*dev;
    /* 通过 inode->i_cdev (指向内嵌的 m_cdev) 反推出 globalmem_dev */
    dev=container_of(inode->i_cdev,structglobalmem_dev,m_cdev);
    /* 保存到 file->private_data，供后续 read/write 使用 */
    filp->private_data=dev;
    return0;
}
/* ===== release：用户关闭设备文件时调用 ===== */
staticintglobalmem_release(structinode*inode,structfile*filp) {
    return0;
}
/* ===== read：用户读取设备数据 ===== */
staticssize_tglobalmem_read(structfile*filp,char__user*buf,size_tcount,loff_t*ppos) {
    unsignedlongp= *ppos;
    structglobalmem_dev*dev=filp->private_data;
    if(p>=GLOBALMEM_SIZE)
        return0;
    if(count>GLOBALMEM_SIZE-p)
        count=GLOBALMEM_SIZE-p;
    /* 从内核空间拷贝数据到用户空间 */
    copy_to_user(buf, (void*)(dev->mem+p),count); *ppos=p+count;
    returncount;
}
/* ===== write：用户写入设备数据 ===== */
staticssize_tglobalmem_write(structfile*filp,constchar__user*buf,size_tcount,loff_t*ppos) {
    unsignedlongp= *ppos;
    structglobalmem_dev*dev=filp->private_data;
    if(p>=GLOBALMEM_SIZE)
        return0;
    if(count>GLOBALMEM_SIZE-p)
        count=GLOBALMEM_SIZE-p;
    /* 从用户空间拷贝数据到内核空间 */
    copy_from_user(dev->mem+p,buf,count); *ppos=p+count;
    returncount;
}
/* ===== llseek：用户调整文件读写位置 ===== */
staticloff_tglobalmem_llseek(structfile*filp,loff_toffset,intorig) {
    loff_tret;
    switch(orig) {
    case0:
    /* SEEK_SET：从起始位置移动 */
        if(offset<0|| (unsignedint)offset>GLOBALMEM_SIZE) {
            ret= -EINVAL;
            break;
        }
        filp->f_pos= (unsignedint)offset;
        ret=filp->f_pos;
    break;
    case1:
    /* SEEK_CUR：从当前位置移动 */
    if((filp->f_pos+offset) >GLOBALMEM_SIZE|| (filp->f_pos+offset) <0) {
        ret= -EINVAL;
        break;
    }
    filp->f_pos+=offset;
    ret=filp->f_pos;
    break;
    default:
        ret= -EINVAL;
    }
    returnret;
}
/* ===== unlocked_ioctl：用户发送设备控制命令 ===== */
staticlongglobalmem_ioctl(structfile*filp,unsignedintcmd,unsignedlongarg) {
    structglobalmem_dev*dev=filp->private_data;
    switch(cmd) {
    caseMEM_CLEAR:
        memset(dev->mem,0,GLOBALMEM_SIZE);   /* 清空共享内存 */
    break;
    default:
        return-EINVAL;
    }
    return0;
}
/* ===== 文件操作函数集 ===== */
staticconststructfile_operationsglobalmem_fops= {
    .owner=THIS_MODULE,
    .open=globalmem_open,
    .release=globalmem_release, 
    .llseek=globalmem_llseek,
    .read=globalmem_read,
    .write=globalmem_write,
    .unlocked_ioctl=globalmem_ioctl,
};
/* ===== 模块加载函数 ===== */staticint__initglobalmem_init(void) {
    /* 1. 注册设备号：主 266，次 0~1，共 2 个 */
    register_chrdev_region(MKDEV(globalmem_major,0),2,"globalmem");
    /* 2. 为两个设备分配内存 */
    globalmem_devp=kmalloc(2*sizeof(structglobalmem_dev),GFP_KERNEL);
    memset(globalmem_devp,0,2*sizeof(structglobalmem_dev));
    /* 3. 初始化并注册次设备号 0 */
    cdev_init(&(globalmem_devp[0].m_cdev), &globalmem_fops);
    globalmem_devp[0].m_cdev.owner=THIS_MODULE;
    cdev_add(&(globalmem_devp[0].m_cdev),MKDEV(globalmem_major,0),1);
    /* 4. 初始化并注册次设备号 1 */
    dev_init(&(globalmem_devp[1].m_cdev), &globalmem_fops);
    globalmem_devp[1].m_cdev.owner=THIS_MODULE;
    cdev_add(&(globalmem_devp[1].m_cdev),MKDEV(globalmem_major,1),1);
    return0;
}
/* ===== 模块卸载函数 ===== */
staticvoid__exitglobalmem_exit(void) {
    cdev_del(&(globalmem_devp[0].m_cdev));
    cdev_del(&(globalmem_devp[1].m_cdev));
    kfree(globalmem_devp);
    dev_tdevno=MKDEV(globalmem_major,0);
    unregister_chrdev_region(devno,2);
}
MODULE_AUTHOR("punch");MODULE_LICENSE("GPL");MODULE_DESCRIPTION("A simple shared memory character device driver");module_param(globalmem_major,int,S_IRUGO);module_init(globalmem_init);module_exit(globalmem_exit);

# 1. 加载驱动模块

sudo insmod globalmem.ko# 2. 查看驱动是否加载成功（应看到主设备号 266 和 "globalmem"）cat /proc/devices | grep globalmem# 3. 创建设备节点sudo mknod /dev/globalmem0 c 266 0sudo mknod /dev/globalmem1 c 266 1# 4. 设置权限sudo chmod 666 /dev/globalmem0 /dev/globalmem1# 5. 测试读写echo "Hello Linux Driver!" > /dev/globalmem0cat /dev/globalmem0# 6. 卸载驱动sudo rmmod globalmem