linux设备：cdev和kobj_map

最新推荐文章于 2021-09-21 16:53:30 发布
最新推荐文章于 2021-09-21 16:53:30 发布
阅读量754 收藏
点赞数
文章标签： kobj-map linux-内核

本文转自 http://blog.chinaunix.net/uid-24631445-id-3415459.html
Linux kernel v3.6.7
先看kobj_map相关的代码
涉及到的文件

<linux/kobj_map.h>
<drivers/base/map.c>

    typedef struct kobject *kobj_probe_t(dev_t, int *, void *);
    struct kobj_map;`
    int kobj_map(struct kobj_map *, dev_t, unsigned long, struct module *, kobj_probe_t *, int (*)(dev_t, void *), void *);
    void kobj_unmap(struct kobj_map *, dev_t, unsigned long);
    struct kobject *kobj_lookup(struct kobj_map *, dev_t, int *);
    struct kobj_map *kobj_map_init(kobj_probe_t *, struct mutex *);

先看kobj_map结构体

    struct kobj_map {
        struct probe {
            struct probe *next;      /* 这样形成了链表结构 */
            dev_t dev;               /* 设备号 */
            unsigned long range;     /* 设备号的范围 */
            struct module *owner;
            kobj_probe_t *get;
            int (*lock) (dev_t, void *);
            void *data;              /* 指向struct cdev对象 */
        } *probes[255];
        struct mutex *lock;
    }

结构体中有一个互斥锁lock，一个probes[255]数组，数组元素为struct probe的指针。
根据下面的函数作用来看，kobj_map结构体是用来管理设备号及其对应的设备的。
kobj_map函数就是将指定的设备号加入到该数组，kobj_lookup则查找该结构体，然后返回对应设备号的kobject对象，利用
利用该kobject对象，我们可以得到包含它的对象如cdev。
struct probe结构体中的get函数指针就是用来获得kobject对象的，可能不同类型的设备获取的方式不同，我现在就看过cdev的exact_match函数。
kobj_map函数

    int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range, struct module *module, kobj_probe_t *probe, int (*lock)(dev_t, void *), void *data)
    {
        unsigned n = MAJOR(dev+range-1) - MAJOR(dev) + 1;
        unsigned index = MAJOR(dev);
        unsigned i;
        struct probe *p;
        if (n > 255)     /* 若n > 255，则超出了kobj_map中probes数组的大小 */
            n = 255;
        p = kmalloc(sizeof(struct probe) * n, GFP_KERNEL);  /* 分配n个struct probe */
        if(p == NULL)
            return -ENOMEM;
        for(i = 0; i < n; i++, p++) {     /* 用函数的参数初始化probe */
            p->owner = module;
            p->get = probe;
            p->lock = lock;
            p->dev = dev;
            p->range = range;
            p->data = data;
        }
        mutex_lock(domain->lock);
        for(i = 0, p-=n; i < n; i++, p++, index++) {
            struct probe **s = &domain->probes[index % 255];
            while(*s && (*s)->range < range)
                s = &(*s)->next;
            p->next = *s;
            *s = p;
        }
        mutex_unlock(domain->lock);
        return 0;
    }

dev_t的前12位为主设备号，后20位为次设备号。
n = MAJOR(dev + range - 1) - MAJOR(dev) + 1 表示设备号范围(dev, dev+range)中不同的主设备号的个数。
通常n的值为1。
从代码中的第二个for循环可以看出kobj_map中的probes数组中每个元素为一个struct probe链表的头指针。
每个链表中的probe对象有（MAJOR（probe.dev） % 255）值相同的关系。若主设备号小于255， 则每个链表中的probe都有相同的主设备号。
链表中的元素是按照range值从小到大排列的。
while循环即是找出该将p插入的位置。
kobj_unmap函数

 void kobj_unmap(struct kobj_map *domain, dev_t dev, unsigned long range)
    {
        unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;
        unsigned index = MAJOR(dev);
        unsigned i;
        struct probe *found = NULL;
        if (n > 255)
            n = 255;
        mutex_lock(domain->lock);
        for (i = 0; i < n; i++, index++) {
            struct probe **s;
            for (s = &domain->probes[index % 255]; *s; s = &(*s)->next) {
                struct probe *p = *s;
                if (p->dev == dev && p->range == range) {
                    *s = p->next;
                    if (!found)
                        found = p;
                    break;
                }
            }
        }
        mutex_unlock(domain->lock);
        kfree(found);
    }

在16行，找到对应设备号dev和range指定的probe对象后，退出，然后kfree释放空间。
kobj_lookup函数

 struct kobject *kobj_lookup(struct kobj_map *domain, dev_t dev, int *index)
    {
        struct kobject *kobj;
        struct probe *p;
        unsigned long best = ~0UL;
    retry:
        mutex_lock(domain->lock);
        for (p = domain->probes[MAJOR(dev) % 255]; p; p = p->next) {
            struct kobject *(*probe)(dev_t, int *, void *);
            struct module *owner;
            void *data;
            if (p->dev > dev || p->dev + p->range - 1 < dev)
                continue;
            if (p->range - 1 >= best)
                break;
            if (!try_module_get(p->owner))
                continue;
            owner = p->owner;
            data = p->data;
            probe = p->get;
            best = p->range - 1;
            *index = dev - p->dev;   /* 这个是用来干嘛的？ */
            if (p->lock && p->lock(dev, data) < 0) {
                module_put(owner);
                continue;
            }
            mutex_unlock(domain->lock);
            kobj = probe(dev, index, data);
            /* Currently ->owner protects _only_ ->probe() itself. */
            module_put(owner);
            if (kobj)
                return kobj;
            goto retry;
        }
        mutex_unlock(domain->lock);
        return NULL;
    }

对cdev_add函数，这里的p->probe函数即是exact_match, p->lock为exact_lock函数。
kobj_map_init函数

    struct kobj_map *kobj_map_init(kobj_probe_t *base_probe, struct mutex *lock)
    {
        struct kobj_map *p = kmalloc(sizeof(struct kobj_map), GFP_KERNEL);
        struct probe *base = kzalloc(sizeof(*base), GFP_KERNEL);
        int i;
        if ((p == NULL) || (base == NULL)) {
            kfree(p);
            kfree(base);
            return NULL;
        }
        base->dev = 1;
        base->range = ~0;
        base->get = base_probe;
        for (i = 0; i < 255; i++)
            p->probes[i] = base;
        p->lock = lock;
        return p;
    }

在初始化一个kobj_map对象时，将probes指针全部指向同一个base。
下面是cdev部分。
文件：

<linux/cdev.h>
<fs/char_dev.c>
cdev.h

    struct cdev {
        struct kobject kobj;
        struct module *owner;
        const struct file_operations *ops;
        struct list_head list;
        dev_t dev;
        unsigned int count;
    }
    void cdev_init(struct cdev *, const struct file_operations *);
    struct cdev *cdev_alloc(void);
    void cdev_put(struct cdev *p);
    int cdev_add(struct cdev *, dev_t, unsigned);
    void cdev_del(struct cdev *);

cdev_init函数
此函数首先调用kobject_init初始化cdev中的kobj，然后将cdev中的ops赋值。
cdev_alloc函数
先kzalloc分配一个cdev，然后用kobject_init初始化kobj
cdev_put函数

 void cdev_put(struct cdev *p)
    {
        if (p) {
            struct module *owner = p->owner;
            kobject_put(&p->kobj);
            module_put(owner);
        }
    }

此函数调用kobject_put和module_put，好像它们的作用就是减少引用计数
cdev_add函数

    int cdev_add(struct cdev *p, dev_t dev, unsigned count)
    {
        p->dev = dev;
        p->count = count;
        return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
    }

主要是调用kobj_map将cdev放入cdev_map中。
cdev_del函数

    static void cdev_unmap(dev_t dev, unsigned count)
    {
        kobj_unmap(cdev_map, dev, count);
    }
    void cdev_del(struct cdev *p)
    {
        cdev_unmap(p->dev, p->count);
        kobject_put(&p->kobj);
    }

这就不用说啥了。
LDD3上说“只要cdev_add返回了，我们的设备就‘活’了，它的操作就会被内核调用”，那么这句奇妙的话到底是个什么意思？
下面是我目前了解的情况
据说在open一个字符设备文件时，最终总会调用chrdev_open。
下面是该函数的源码
注意inode->i_rdev中保存了设备编号，inode->icdev指向了cdev结构。

 static int chrdev_open(struct inode *inode, struct file *filp)
    {
        struct cdev *p;
        struct cdev *new = NULL;
        int ret = 0;
        spin_lock(&cdev_lock);
        p = inode->i_cdev;
        if (!p) {
            struct kobject *kobj;
            int idx;
            spin_unlock(&cdev_lock);
            kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);   
            if (!kobj)
                return -ENXIO;
            new = container_of(kobj, struct cdev, kobj);   /* 找到字符设备的cdev */
            spin_lock(&cdev_lock);
            /* Check i_cdev again in case somebody beat us to it while
             we dropped the lock. */
            p = inode->i_cdev;
            if (!p) {
                inode->i_cdev = p = new;
                list_add(&inode->i_devices, &p->list);/* ZXG: 这是啥？ */
                new = NULL;
            } else if (!cdev_get(p))
                ret = -ENXIO;
        } else if (!cdev_get(p))
            ret = -ENXIO;
        spin_unlock(&cdev_lock);
        cdev_put(new);
        if (ret)
            return ret;
        ret = -ENXIO;
        filp->f_op = fops_get(p->ops);
        if (!filp->f_op)
            goto out_cdev_put;
        if (filp->f_op->open) {
            ret = filp->f_op->open(inode, filp); /* 调用cdev->ops中的open函数 */
            if (ret)
                goto out_cdev_put;
        }
        return 0;
     out_cdev_put:
        cdev_put(p);
        return ret;
    }
粑粑怪
关注
Linux 字符设备驱动（一）---cdev、file_operations、inode、file结构体详述，上层应用如何访问到底层驱动
the_wan的博客
09-06 2441
参考资料： 《Linux驱动开发入门与实战》，概念及源码主要参考《Linux驱动开发入门与实战》，务求准确。同时衷心感谢其他网友的分享。大部分内容都是手敲的，错漏之处望指正，谢谢！ linux设备驱动之字符设备驱动 https://www.linuxprobe.com/linux-device-driver.html Linux 字符设备驱动结构（一）—— cdev 结构体、设备号相关知识解析 https://blog.csdn.net/zqixiao_09/article/det...
使用NDB调试Linux字符设备
birdring_0xx0的博客
09-27 694
使用NDB调试Linux字符设备
linux kernel源码之kobj_map
power1952的专栏
09-21 790
源码 include/linux/kobj_map.h drivers/base/map.c 主要提供了4个函数 1 kobj_map_init 2 kobj_map 3 kobj_lookup 4 kobj_unmap chr_dev 、 block_dev 使用kobj_map 管理字符设备和块设备。 kobj_map的数据结构 kobj_map的基础数据结构是哈希表。 kobj_map结构体包含一个指针数组（指针是struct probe的指针）。数组长度为255 。 数组的每个元素是链表头。 初始化
字符设备的核心结构体 kobj_map 结构
one shot,one kill.
11-29 835
2.5 字符设备的注册 《深入Linux设备驱动程序内核机制》第2章字符设备驱动程序，本章描述了字符设备驱动程序内核框架的技术细节。本节为大家介绍字符设备的注册。 2.5  字符设备的注册 前面已经讨论了字符设备对象的分配、初始化及设备号等概念，在一个字符设备初始化阶段完成之后，就可以把它加入到系统中，这样别的模块才可以使用它。把一个字符设备加入到系统
linux设备模型的inode,cdev,kobj_map,char_device_struct
xiaoshengqdlg的专栏
03-16 1719
Char Device Driver 　　相关数据结构： 　　struct cdev { 　　struct kobject kobj; 　　struct module *owner; 　　const struct file_operations *ops; 　　struct list_head list; 　　dev_t dev; 　　unsigned int count;
Linux字符设备驱动详解：cdev与设备号
`cdev_add()`主要通过`kobj_map()`来完成设备的注册，这涉及到设备号的分配和`struct cdev`的链入。 总结起来，Linux字符设备驱动架构是通过一系列内核结构体和函数来实现的，它提供了从用户空间到内核空间的接口，...
cdev_alloc函数[归类].pdf
10-11
该函数接受`cdev`指针、起始设备号`dev`和设备范围号`count`，将`cdev`注册到系统中。其内部通过`kobj_map()`将设备号和`cdev`映射到`cdev_map`散列表，便于后续的设备查找。 当不再需要字符设备驱动时，可以使用`...
linux字符cdev和inode的联系
08-23
在Linux中，字符设备驱动模型是通过cdev和inode两个关键结构来实现的。下面我们将详细介绍这两个结构之间的联系。 1. 字符驱动模型 在Linux字符设备驱动模型中，每个字符驱动由一个cdev结构来表示。cdev结构是...
kobject_map
ljk0922的专栏
08-28 486
/* * linux/drivers/base/map.c * * (C) Copyright Al Viro 2002,2003 * Released under GPL v2. * * NOTE: data structure needs to be changed. It works, but for large dev_t * it will be too slow. It is isol
struct kobj_map
zdh_12的专栏
07-20 850
drivers/base/map.c struct kobj_map {     struct probe {         struct probe *next;         dev_t dev;         unsigned long range;         struct module *owner;         kobj_probe_t *get;  
Linux 内核中的 cdev_alloc和cdev_add
bindingfly的博客
07-18 1199
Linux内核中每个字符设备都对应一个 cdev 结构的变量，下面是它的定义： linux-2.6.22/include/linux/cdev.h struct cdev { struct kobject kobj;          // 每个 cdev 都是一个 kobject struct module *owner;       // 指向实现驱动的模块 const stru
linux的cdev
weixin_34014555的博客
07-18 145
一.前言以前对于cdev仅仅是知其然，而不知其所以然。在本文中，将深入理解cdev的架构以及具体的实现。二.真实的cdev2.1 设备号搞驱动的都应该知道的东西，在写gpio驱动时，往往会用到以下两个函数。alloc_chrdev_region --自动分配设备号register_chrdev_region --分配以设定的设备号。上面两个函数的调用很简单，当时却没...
[Linux Kernel] sysfs 与 kobject 介绍 & 使用
u012849539的博客
06-19 1059
文章目录sysfssysfs 简介创建目录属性子系统特有的回调函数读写属性数据顶层目录布局当前接口kobjectkobject 简介嵌入 kobjectkobjects 的初始化Uevents引用计数Creating "simple" kobjectsKtypes 和释放方法ksetsKobject removalExample code to copy from参考文献 sysfs sysfs 简介    sysfs 是一个最初基于 ramfs 且位于内存的文件系统。它提供导出内核数据结构及其属性，以及它
驱动之cdev
hj5225244的专栏
01-11 712
前面写到如何向系统申请一个设备号，设备号就像我们的身份证号一样，号本身并没有什么特殊的意义，只有把这个号和人对应才有意义，通用设备号也需要和一个特殊的东西对应，这就是cdev, cdev是linux下抽象出来的一个用来描述一个字符设备的结构体，在linux下定义如下： struct cdev {                 struct kobject kobj;            
cdev简单解析
ll148305879的博客
06-25 2198
1. cdev是linux用来管理字符设备的结构体，其在内核中采用数组结构设计，这样系统中有多少个主设备号就约定了数组大小，此设备号采用链表管理，同一主设备号下可以有多个子设备。设备即文件，上层应用要访问设备，必须通过文件，cdev中包含file_operations结构体，该结构体就是驱动的文件操作集合。 （根据于说得） 2. cdev定义在include/linux/cdev.h中，如下...
linux驱动之cdev
qq_40481255的博客
06-21 546
linux驱动之cdev 代码在fs/char_dev.c linux下每一个具体的字符设备都会对应一个cdev,cdev->ops就是设备的操作接口。 上层应用程序调用open()系统调用打开/dev/xxx设备节点时，最终会调用cdev->ops->open()。 struct cdev { struct kobject kobj; struct module *owner; const struct file_operations *ops; struct list_head
linux 设备驱动模型
keepdoingit的专栏
10-29 238
linux 设备驱动模型（linux device model）: usb转串口设备插入centos主机中，内核处理全过程，包括如果得到usb设备中的配置信息，如何为其找到并加载一个合适的驱动程序，直到最后为其在/dev/中创建一个设备名称。 设备驱动模型的生成（即/sys下的结点生成等工作）是bus-level logic和其它的子系统（如usb核心子系统）的工作，驱动工程师不需要针对设备驱动模型函数编程。 设备有个注册函数，比如usb设备， 参考资料：linux device driver.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值