linux设备：cdev和kobj_map

最新推荐文章于 2021-09-21 16:53:30 发布
最新推荐文章于 2021-09-21 16:53:30 发布
阅读量444 收藏 1
点赞数
先看kobj_map相关的代码
涉及到的文件
<linux/kobj_map.h>
<drivers/base/map.c>
[objc] view plain copy
print ?
  1. typedef struct kobject *kobj_probe_t(dev_t, intint *, voidvoid *);  
  2. struct kobj_map;  
  3. int kobj_map(struct kobj_map *, dev_t, unsigned long, struct module *, kobj_probe_t *, int (*)(dev_t, voidvoid *), voidvoid *);  
  4. void kobj_unmap(struct kobj_map *, dev_t, unsigned long);  
  5. struct kobject *kobj_lookup(struct kobj_map *, dev_t, intint *);  
  6. struct kobj_map *kobj_map_init(kobj_probe_t *, struct mutex *);  
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结构体
[objc] view plain copy
print ?
  1. struct kobj_map {  
  2.     struct probe {  
  3.         struct probe *next;      /* 这样形成了链表结构 */  
  4.         dev_t dev;               /* 设备号 */  
  5.         unsigned long range;     /* 设备号的范围 */  
  6.         struct module *owner;  
  7.         kobj_probe_t *get;  
  8.         int (*lock) (dev_t, voidvoid *);  
  9.         voidvoid *data;              /* 指向struct cdev对象 */  
  10.     } *probes[255];  
  11.     struct mutex *lock;  
  12. }  
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函数
[objc] view plain copy
print ?
  1. int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range, struct module *module, kobj_probe_t *probe, int (*lock)(dev_t, voidvoid *), voidvoid *data)  
  2. {  
  3.     unsigned n = MAJOR(dev+range-1) - MAJOR(dev) + 1;  
  4.     unsigned index = MAJOR(dev);  
  5.     unsigned i;  
  6.     struct probe *p;  
  7.   
  8.     if (n > 255)     /* 若n > 255，则超出了kobj_map中probes数组的大小 */  
  9.         n = 255;  
  10.     p = kmalloc(sizeof(struct probe) * n, GFP_KERNEL);  /* 分配n个struct probe */  
  11.     if(p == NULL)  
  12.         return -ENOMEM;  
  13.     for(i = 0; i < n; i++, p++) {     /* 用函数的参数初始化probe */  
  14.         p->owner = module;  
  15.         p->get = probe;  
  16.         p->lock = lock;  
  17.         p->dev = dev;  
  18.         p->range = range;  
  19.         p->data = data;  
  20.     }  
  21.     mutex_lock(domain->lock);  
  22.     for(i = 0, p-=n; i < n; i++, p++, index++) {  
  23.         struct probe **s = &domain->probes[index % 255];  
  24.         while(*s && (*s)->range < range)  
  25.             s = &(*s)->next;  
  26.         p->next = *s;  
  27.         *s = p;  
  28.     }  
  29.     mutex_unlock(domain->lock);  
  30.     return 0;  
  31. }  
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函数
[objc] view plain copy
print ?
  1. void kobj_unmap(struct kobj_map *domain, dev_t dev, unsigned long range)  
  2. {  
  3.     unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;  
  4.     unsigned index = MAJOR(dev);  
  5.     unsigned i;  
  6.     struct probe *found = NULL;  
  7.   
  8.     if (n > 255)  
  9.         n = 255;  
  10.   
  11.     mutex_lock(domain->lock);  
  12.     for (i = 0; i < n; i++, index++) {  
  13.         struct probe **s;  
  14.         for (s = &domain->probes[index % 255]; *s; s = &(*s)->next) {  
  15.             struct probe *p = *s;  
  16.             if (p->dev == dev && p->range == range) {  
  17.                 *s = p->next;  
  18.                 if (!found)  
  19.                     found = p;  
  20.                 break;  
  21.             }  
  22.         }  
  23.     }  
  24.     mutex_unlock(domain->lock);  
  25.     kfree(found);  
  26. }  
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函数
[objc] view plain copy
print ?
  1. struct kobject *kobj_lookup(struct kobj_map *domain, dev_t dev, intint *index)  
  2. {  
  3.     struct kobject *kobj;  
  4.     struct probe *p;  
  5.     unsigned long best = ~0UL;  
  6.   
  7. retry:  
  8.     mutex_lock(domain->lock);  
  9.     for (p = domain->probes[MAJOR(dev) % 255]; p; p = p->next) {  
  10.         struct kobject *(*probe)(dev_t, intint *, voidvoid *);  
  11.         struct module *owner;  
  12.         voidvoid *data;  
  13.   
  14.         if (p->dev > dev || p->dev + p->range - 1 < dev)  
  15.             continue;  
  16.         if (p->range - 1 >= best)  
  17.             break;  
  18.         if (!try_module_get(p->owner))  
  19.             continue;  
  20.         owner = p->owner;  
  21.         data = p->data;  
  22.         probe = p->get;  
  23.         best = p->range - 1;  
  24.         *index = dev - p->dev;   /* 这个是用来干嘛的？ */  
  25.         if (p->lock && p->lock(dev, data) < 0) {  
  26.             module_put(owner);  
  27.             continue;  
  28.         }  
  29.         mutex_unlock(domain->lock);  
  30.         kobj = probe(dev, index, data);  
  31.         /* Currently ->owner protects _only_ ->probe() itself. */  
  32.         module_put(owner);  
  33.         if (kobj)  
  34.             return kobj;  
  35.         goto retry;  
  36.     }  
  37.     mutex_unlock(domain->lock);  
  38.     return NULL;  
  39. }  
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函数
[objc] view plain copy
print ?
  1. struct kobj_map *kobj_map_init(kobj_probe_t *base_probe, struct mutex *lock)  
  2. {  
  3.     struct kobj_map *p = kmalloc(sizeof(struct kobj_map), GFP_KERNEL);  
  4.     struct probe *base = kzalloc(sizeof(*base), GFP_KERNEL);  
  5.     int i;  
  6.   
  7.     if ((p == NULL) || (base == NULL)) {  
  8.         kfree(p);  
  9.         kfree(base);  
  10.         return NULL;  
  11.     }  
  12.   
  13.     base->dev = 1;  
  14.     base->range = ~0;  
  15.     base->get = base_probe;  
  16.     for (i = 0; i < 255; i++)  
  17.         p->probes[i] = base;  
  18.     p->lock = lock;  
  19.     return p;  
  20. }  
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
[objc] view plain copy
print ?
  1. struct cdev {  
  2.     struct kobject kobj;  
  3.     struct module *owner;  
  4.     const struct file_operations *ops;  
  5.     struct list_head list;  
  6.     dev_t dev;  
  7.     unsigned int count;  
  8. }  
  9. void cdev_init(struct cdev *, const struct file_operations *);  
  10. struct cdev *cdev_alloc(void);  
  11. void cdev_put(struct cdev *p);  
  12. int cdev_add(struct cdev *, dev_t, unsigned);  
  13. void cdev_del(struct cdev *);  
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函数

[objc] view plain copy
print ?
  1. void cdev_put(struct cdev *p)  
  2. {  
  3.     if (p) {  
  4.         struct module *owner = p->owner;  
  5.         kobject_put(&p->kobj);  
  6.         module_put(owner);  
  7.     }  
  8. }  
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函数
[objc] view plain copy
print ?
  1. int cdev_add(struct cdev *p, dev_t dev, unsigned count)  
  2. {  
  3.     p->dev = dev;  
  4.     p->count = count;  
  5.     return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);  
  6. }  
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函数
[objc] view plain copy
print ?
  1. static void cdev_unmap(dev_t dev, unsigned count)  
  2. {  
  3.     kobj_unmap(cdev_map, dev, count);  
  4. }  
  5.   
  6. void cdev_del(struct cdev *p)  
  7. {  
  8.     cdev_unmap(p->dev, p->count);  
  9.     kobject_put(&p->kobj);  
  10. }  
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结构。
[objc] view plain copy
print ?
  1. static int chrdev_open(struct inode *inode, struct file *filp)  
  2. {  
  3.     struct cdev *p;  
  4.     struct cdev *new = NULL;  
  5.     int ret = 0;  
  6.   
  7.     spin_lock(&cdev_lock);  
  8.     p = inode->i_cdev;  
  9.     if (!p) {  
  10.         struct kobject *kobj;  
  11.         int idx;  
  12.         spin_unlock(&cdev_lock);  
  13.         kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);     
  14.         if (!kobj)  
  15.             return -ENXIO;  
  16.         new = container_of(kobj, struct cdev, kobj);   /* 找到字符设备的cdev */  
  17.         spin_lock(&cdev_lock);  
  18.         /* Check i_cdev again in case somebody beat us to it while 
  19.          we dropped the lock. */  
  20.         p = inode->i_cdev;  
  21.         if (!p) {  
  22.             inode->i_cdev = p = new;  
  23.             list_add(&inode->i_devices, &p->list);/* ZXG: 这是啥？ */  
  24.             new = NULL;  
  25.         } else if (!cdev_get(p))  
  26.             ret = -ENXIO;  
  27.     } else if (!cdev_get(p))  
  28.         ret = -ENXIO;  
  29.     spin_unlock(&cdev_lock);  
  30.     cdev_put(new);  
  31.     if (ret)  
  32.         return ret;  
  33.   
  34.     ret = -ENXIO;  
  35.     filp->f_op = fops_get(p->ops);  
  36.     if (!filp->f_op)  
  37.         goto out_cdev_put;  
  38.   
  39.     if (filp->f_op->open) {  
  40.         ret = filp->f_op->open(inode, filp); /* 调用cdev->ops中的open函数 */  
  41.         if (ret)  
  42.             goto out_cdev_put;  
  43.     }  
  44.   
  45.     return 0;  
  46.   
  47.  out_cdev_put:  
  48.     cdev_put(p);  
  49.     return ret;  
  50. }  
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 2472
参考资料： 《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 715
使用NDB调试Linux字符设备
linux kernel源码之kobj_map
power1952的专栏
09-21 810
源码 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 。 数组的每个元素是链表头。 初始化
linux设备模型的inode,cdev,kobj_map,char_device_struct
xiaoshengqdlg的专栏
03-16 1731
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结构是...
字符设备的核心结构体 kobj_map 结构
one shot,one kill.
11-29 846
2.5 字符设备的注册 《深入Linux设备驱动程序内核机制》第2章字符设备驱动程序，本章描述了字符设备驱动程序内核框架的技术细节。本节为大家介绍字符设备的注册。 2.5  字符设备的注册 前面已经讨论了字符设备对象的分配、初始化及设备号等概念，在一个字符设备初始化阶段完成之后，就可以把它加入到系统中，这样别的模块才可以使用它。把一个字符设备加入到系统
kobject_map
ljk0922的专栏
08-28 494
/* * 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
GNU C typedef定义函数类型
06-14 141
1.假设有如下函数定义： static struct kobject *base_probe(dev_t dev, int *part, void *data) { ..... } 2.现在要将base_probe函数作为参数传入 void __init chrdev_init(void) { cdev_map = kobj_map_init(base_probe, &chrdevs_lock); } 3.kobj_map_init函数参数类型为kobj_probe_t *，...
驱动之cdev
hj5225244的专栏
01-11 725
前面写到如何向系统申请一个设备号，设备号就像我们的身份证号一样，号本身并没有什么特殊的意义，只有把这个号和人对应才有意义，通用设备号也需要和一个特殊的东西对应，这就是cdev, cdev是linux下抽象出来的一个用来描述一个字符设备的结构体，在linux下定义如下： struct cdev {                 struct kobject kobj;            
linux 设备驱动模型
keepdoingit的专栏
10-29 246
linux 设备驱动模型（linux device model）: usb转串口设备插入centos主机中，内核处理全过程，包括如果得到usb设备中的配置信息，如何为其找到并加载一个合适的驱动程序，直到最后为其在/dev/中创建一个设备名称。 设备驱动模型的生成（即/sys下的结点生成等工作）是bus-level logic和其它的子系统（如usb核心子系统）的工作，驱动工程师不需要针对设备驱动模型函数编程。 设备有个注册函数，比如usb设备， 参考资料：linux device driver.
linux的cdev
weixin_34014555的博客
07-18 151
一.前言以前对于cdev仅仅是知其然，而不知其所以然。在本文中，将深入理解cdev的架构以及具体的实现。二.真实的cdev2.1 设备号搞驱动的都应该知道的东西，在写gpio驱动时，往往会用到以下两个函数。alloc_chrdev_region --自动分配设备号register_chrdev_region --分配以设定的设备号。上面两个函数的调用很简单，当时却没...
Linux 系统调用之open(三）
bgao86的博客
05-05 2855
前面我们以及其简单的例子分析了linux的open系统调用过程。下面换一个例子，假如我们有个字符驱动：my_kmem.ko。使用如下脚本将其加载入内核空间：#!/bin/sh module="my_kmem" device="my_chr_dev" mod="664" insmod $module.ko || exit 1 rm -f /dev/${device}0 major=`awk ...
Linux字符设备驱动详解：cdev与file_operations
"Linux设备驱动开发详解的第6章，深入探讨了Linux字符设备驱动的编程技术，包括cdev结构体、file_operations、字符设备的创建与管理，以及用户空间的验证。" 在Linux设备驱动开发中，字符设备驱动是基础且重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值