Skip to main content
 首页 » 操作系统

Linux DRM(device resource management)介绍

2022年07月19日30davidwang456

一、DRM简介

1. 在DRM出现之前,在probe函数中要顺序申请多种资源(IRQ、Clock、memory、regions、ioremap、dma、等等),只要任意一种资源申请失败,就要回滚释放之前申请的所有资源。于是函数的最后,一定会出现很多的goto标签。最终Linux设备模型借助device resource management(设备资源管理)解决了这个问题。通过”devm_xxx()“函数申请的资源驱动只管申请,不用考虑释放,设备模型帮你释放。

2. devm_xxx()函数
它们由各个framework(如clock、regulator、gpio、等等)基于device resource management实现。使用时,直接忽略“devm_”的前缀,后面剩下的部分就是DRM出现之前驱动工程师使用的。虽然通过"devm_xxx()"驱动可以只申请,不释放,设备模型会帮忙释放,但是为了严谨,在driver remove时,也可以主动释。

3. 一个设备能工作,需要依赖的外部条件,如供电、时钟等等,这些外部条件称作设备资源。可能的资源包括:power、clock、memory(一般使用kzalloc分配)、GPIO、IRQ、DMA、虚拟地址空间(般使用ioremap、request_region等分配)。而在Linux kernel的眼中,“资源”的定义更为广义,比如PWM、RTC、Reset,都可以抽象为供driver使用的资源。下面列举出devm的一些常用函数:

void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp); 
void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res); 
void __iomem *devm_ioremap(struct device *dev, resource_size_t offset, unsigned long size); 
struct clk *devm_clk_get(struct device *dev, const char *id); 
int devm_gpio_request(struct device *dev, unsigned gpio, const char *label); 
struct pinctrl * devm_pinctrl_get_select(struct device *dev, const char *name); 
struct pwm_device *devm_pwm_get(struct device *dev,const char *consumer); 
struct regulator *devm_regulator_get(struct device *dev, const char *id); 
int devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler, unsigned long irqflags, const char *devname, void *dev_id); 
struct reset_control *devm_reset_control_get(struct device *dev, const char *id);

4.device resource management实现位于“drivers/base/devres.c”中,提供一种机制,将系统中某个设备的所有资源,以链表的形式,组织起来,以便在driver detach
的时候,自动释放。

5. devm实现框架简图

二、代码分析

struct device结构中有一个名称为“devres_head”的链表头,用于保存该设备申请的所有资源,如下:

struct device { 
    ... 
    spinlock_t devres_lock; 
    struct list_head devres_head; 
    ... 
};

那资源的数据结构在“drivers/base/devres.c”中定义为struct devres结构,如下。每一份资源都通过一个devres结构表示,通过其node域中的链表节点挂接到struct device结构中的devres_head链表中。

struct devres { 
    struct devres_node node; 
    /* -- 3 pointers -- */ 
    /* guarantee ull alignment */ 
    unsigned long long data[]; /*data边长数组就表示资源,资源是什么类型就分配多大的空间,然后将其转换成对应的类型*/ 
}; 
 
struct devres_node { 
    struct list_head entry; 
    dr_release_t release; 
    #ifdef CONFIG_DEBUG_DEVRES 
    const char *name; 
    size_t size; 
    #endif 
};

设备资源框架是不知道该怎么释放的,因此提供一个回调函数release来让调用者决定。

注意:devres有关的数据结构,是在devres.c中定义的(不是在.h文件中定义的哦!)。换句话说就是对其它模块透明的。尽量屏蔽细节,多么优雅的设计。

三、以irq为例的资源申请

1. irq的devm的申请和释放函数

/* include/linux/interrupt.h */ 
static inline int __must_check devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler, 
    unsigned long irqflags, const char *devname, void *dev_id) 
{ 
    return devm_request_threaded_irq(dev, irq, handler, NULL, irqflags, devname, dev_id); 
} 
 
/* kernel/irq/devres.c */ 
int devm_request_threaded_irq(struct device *dev, unsigned int irq, irq_handler_t handler, irq_handler_t thread_fn, 
    unsigned long irqflags, const char *devname, void *dev_id) 
{ 
    struct irq_devres *dr; 
    int rc; 
 
    /*分配data的大小是sizeof(struct irq_devres),对返回的data直接转换成irq_devres结构*/ 
    dr = devres_alloc(devm_irq_release, sizeof(struct irq_devres), GFP_KERNEL); 
    if (!dr) 
        return -ENOMEM; 
 
    rc = request_threaded_irq(irq, handler, thread_fn, irqflags, devname, dev_id); 
    if (rc) { 
        devres_free(dr); 
        return rc; 
    } 
 
    dr->irq = irq; 
    dr->dev_id = dev_id; 
    /*再将devres结构放到device结构中的链表上*/ 
    devres_add(dev, dr); 
 
    return 0; 
} 
EXPORT_SYMBOL(devm_request_threaded_irq); 
 
/*可以直接调用这个函数释放,也可以不调用让其自动释放*/ 
void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id) 
{ 
    struct irq_devres match_data = { irq, dev_id }; 
 
    WARN_ON(devres_destroy(dev, devm_irq_release, devm_irq_match, &match_data)); 
    free_irq(irq, dev_id); 
} 
EXPORT_SYMBOL(devm_free_irq);

2. 由上可知,irq的资源由irq模块的一个自定义的数据结构struct irq_devres来描述,用于保存和resource有关的信息(对中断来说,就是IRQ num),如下:

/* Device resource management aware IRQ request/free implementation.*/ 
struct irq_devres { 
    unsigned int irq; 
    void *dev_id; 
};

irq的释放资源的回调函数,如下:

static void devm_irq_release(struct device *dev, void *res) 
{ 
    struct irq_devres *this = res; 
    free_irq(this->irq, this->dev_id); 
}

3. devres_alloc函数以release回调和资源大小为参数来分配内存

void * devres_alloc(dr_release_t release, size_t size, gfp_t gfp) 
{ 
    struct devres *dr; 
    dr = alloc_dr(release, size, gfp); 
    if (unlikely(!dr)) 
        return NULL; 
    return dr->data; 
}

调用alloc_dr,分配一个struct devres类型的变量,并返回其中代表资源的data指针,alloc_dr的定义如下:

static __always_inline struct devres * alloc_dr(dr_release_t release, size_t size, gfp_t gfp) 
{ 
    size_t tot_size = sizeof(struct devres) + size; 
    struct devres *dr; 
 
    dr = kmalloc_track_caller(tot_size, gfp); 
    if (unlikely(!dr)) 
        return NULL; 
 
    memset(dr, 0, tot_size); 
    INIT_LIST_HEAD(&dr->node.entry); 
    dr->node.release = release; /*release回调赋值过去*/ 
    return dr; 
}

4. 将资源添加到device结构的链表上

void devres_add(struct device *dev, void *res) 
{ 
    struct devres *dr = container_of(res, struct devres, data); 
    unsigned long flags; 
    spin_lock_irqsave(&dev->devres_lock, flags); 
    add_dr(dev, &dr->node); 
    spin_unlock_irqrestore(&dev->devres_lock, flags); 
} 
 
static void add_dr(struct device *dev, struct devres_node *node) 
{ 
    devres_log(dev, node, "ADD"); 
    BUG_ON(!list_empty(&node->entry)); 
    list_add_tail(&node->entry, &dev->devres_head); /*注意这里是尾插法插入设备的资源链表的*/ 
}

三、资源的自动释放

1. DRM向设备模型提供的资源释放的接口为devres_release_all()函数,它是重点,用于自动释放资源。根据设备模型中probe的流程devres_release_all()接口被调用的时机有两个:

(1) probe失败时,调用过程如下

__driver_attach/__device_attach --> driver_probe_device —> really_probe,really_probe调用driver或者bus的probe接口,如果失败,则会调用devres_release_all()来释放资源。

(2) deriver dettach时(就是driver remove时)

driver_detach/bus_remove_device --> __device_release_driver --> devres_release_all

2. devres_release_all()的实现如下:

int devres_release_all(struct device *dev) 
{ 
    unsigned long flags; 
    /* Looks like an uninitialized device structure */ 
    /* 如果在函数probe()失败时驱动中自己已经释放了,这里就是NULL,就不再次释放了*/ 
    if (WARN_ON(dev->devres_head.next == NULL)) 
        return -ENODEV; 
    spin_lock_irqsave(&dev->devres_lock, flags); 
    return release_nodes(dev, dev->devres_head.next, &dev->devres_head, flags); 
} 
 
sstatic int release_nodes(struct device *dev, struct list_head *first, struct list_head *end, unsigned long flags) 
 __releases(&dev->devres_lock) /*此为内核代码静态分析工具Sparse的annotation。Sparse通过gcc的扩展属性__attribute__ 
 以及自己定义的__context__来对代码进行静态检查。*/ 
{ 
    LIST_HEAD(todo); 
    int cnt; 
    struct devres *dr, *tmp; 
 
    cnt = remove_nodes(dev, first, end, &todo); 
 
    spin_unlock_irqrestore(&dev->devres_lock, flags); 
 
    /* Release.  Note that both devres and devres_group are 
    * handled as devres in the following loop.  This is safe. 
    */ 
    /*最后申请的资源最先释放*/ 
    list_for_each_entry_safe_reverse(dr, tmp, &todo, node.entry) { 
        devres_log(dev, &dr->node, "REL"); 
        dr->node.release(dev, dr->data); 
        kfree(dr); 
    } 
 
    return cnt; 
}

release_nodes会先调用remove_nodes,将设备所有的struct devres指针从设备的devres_head中移除。然后,调用所有资源的release回调函数(如irq的devm_irq_release),回调函数会回收具体的资源(如free_irq)。最后,调用free,释放devres结构自身以及资源所占的空间。

参考:
Linux设备模型(9)_device resource management: http://www.wowotech.net/device_model/device_resource_management.html
Linux设备模型(5)_device和device driver: http://www.wowotech.net/linux_kenrel/device_and_driver.html
内核工具–Sparse 简介:https://www.cnblogs.com/wang_yb/p/3575039.html


本文参考链接:https://www.cnblogs.com/hellokitty2/p/12548225.html