__reserved_mem_init_node

kenrel: 5.10
arch: arm64

__reserved_mem_init_node通过将RESERVEDMEM_OF_DECLARE声明的of_device_id与reserved_mem 的compatible属性进行匹配，匹配成功则执行声明的回调，对于cma这个回调函数就是rmem_cma_setup，他会通过reserved_mem来初始化一个cma

/**
 * __reserved_mem_init_node() - call region specific reserved memory init code
 */
static int __init __reserved_mem_init_node(struct reserved_mem *rmem)
{
        extern const struct of_device_id __reservedmem_of_table[];
        const struct of_device_id *i; 
        int ret = -ENOENT;

        for (i = __reservedmem_of_table; i < &__rmem_of_table_sentinel; i++) {
          		reservedmem_of_init_fn initfn = i->data;
          		const char *compat = i->compatible;

                if (!of_flat_dt_is_compatible(rmem->fdt_node, compat))
                        continue;

                ret = initfn(rmem);
                if (ret == 0) {
                       pr_info("initialized node %s, compatible id %s\n",
                              rmem->name, compat);
                        break;
                }   
        }   
        return ret;
}

RESERVEDMEM_OF_DECLARE可以声明一个struct of_device_id结构体变量，struct of_device_id结构体定义如下，它代表reserved memory节点下的一个子节点：

struct of_device_id {                                                                                                                                           
        char    name[32];                                                                                                                                       
        char    type[32];                                                                                                                                       
        char    compatible[128];                                                                                                                                
        const void *data;                                                                                                                                       
};

所有声明的struct of_device_id结构体变量都会被放到__table_of_table段，比如对于cma则声明如下：

RESERVEDMEM_OF_DECLARE(cma, "shared-dma-pool", rmem_cma_setup);

__reservedmem_of_table是这个section的起始地址，__reserved_mem_init_node会遍历__table_of_table段的每个struct of_device_id，通过of_flat_dt_is_compatible比较它的compatible与当前参数传进的reserved_mem 的compable是否相等，如果相等则会调用声明的回调函数，对于cma，这个回调函数就是rmem_cma_setup

static int __init rmem_cma_setup(struct reserved_mem *rmem)
{
        phys_addr_t align = PAGE_SIZE << max(MAX_ORDER - 1, pageblock_order);
        phys_addr_t mask = align - 1;
        unsigned long node = rmem->fdt_node;
        bool default_cma = of_get_flat_dt_prop(node, "linux,cma-default", NULL);
        struct cma *cma;
        int err;
        /* 命令行的cma定义优先级大于dts? */
        if (size_cmdline != -1 && default_cma) {
                pr_info("Reserved memory: bypass %s node, using cmdline CMA params instead\n",
                        rmem->name);
                return -EBUSY;
        }   

        if (!of_get_flat_dt_prop(node, "reusable", NULL) ||
            of_get_flat_dt_prop(node, "no-map", NULL))
                return -EINVAL;

        if ((rmem->base & mask) || (rmem->size & mask)) {
                pr_err("Reserved memory: incorrect alignment of CMA region\n");
                return -EINVAL;
        }   

        err = cma_init_reserved_mem(rmem->base, rmem->size, 0, rmem->name, &cma);
        if (err) {
                pr_err("Reserved memory: unable to setup CMA region\n");
                return err;
        }
        /* Architecture specific contiguous memory fixup. */
        dma_contiguous_early_fixup(rmem->base, rmem->size);

        if (default_cma)
                dma_contiguous_default_area = cma;//设置默认的cma,保存到全局变量

        rmem->ops = &rmem_cma_ops;
        rmem->priv = cma;//私有数据设置为cma

        pr_info("Reserved memory: created CMA memory pool at %pa, size %ld MiB\n",
                &rmem->base, (unsigned long)rmem->size / SZ_1M);

        return 0;
}

cma_init_reserved_mem会从cma_areas全局数组中获取一个成员变量，用reserved_mem 对其进行初始化，并将初始化的cma通过参数cma返回，cma的定义参考如下：

struct cma {                                                                                                                                                    
        unsigned long   base_pfn;                                                                                                                               
        unsigned long   count;   //cma区域大小为多少个页                                                                                                                               
        unsigned long   *bitmap;                                                                                                                                
        unsigned int order_per_bit; /* Order of pages represented by one bit */                                                                                 
        struct mutex    lock;                                                                                                                                   
#ifdef CONFIG_CMA_DEBUGFS                                                                                                                                       
        struct hlist_head mem_head;                                                                                                                             
        spinlock_t mem_head_lock;                                                                                                                               
        struct debugfs_u32_array dfs_bitmap;                                                                                                                    
#endif                                                                                                                                                          
        char name[CMA_MAX_NAME];  //cma%d                                                                                                                              
};

值得注意的是，对于dma也有一个类似的RESERVEDMEM_OF_DECLARE声明：

RESERVEDMEM_OF_DECLARE(dma, "shared-dma-pool", rmem_dma_setup);

我们可以看到rmem_dma_setup实际就是通过初始化rmem->ops = &rmem_dma_ops;，这样保证dma_init_reserved_memory能调用到rmem_dma_ops .device_init 回调，device_init回调中初始化了compatable为"shared-dma-pool"的保留内存，它将来会用作dma pool来使用，可以有多个dma pool，通过链表进行管理，dma pool主要是为了应对小的dma内存分配，关于为何要出现dma pool可以参考下面的文章：
Generic DMA pools

static int __init rmem_dma_setup(struct reserved_mem *rmem)
{
        unsigned long node = rmem->fdt_node;

        if (of_get_flat_dt_prop(node, "reusable", NULL))
                return -EINVAL;

#ifdef CONFIG_ARM
        if (!of_get_flat_dt_prop(node, "no-map", NULL)) {
                pr_err("Reserved memory: regions without no-map are not yet supported\n");
                return -EINVAL;
        }   

        if (of_get_flat_dt_prop(node, "linux,dma-default", NULL)) {
                WARN(dma_reserved_default_memory,
                     "Reserved memory: region for default DMA coherent area is redefined\n");
                dma_reserved_default_memory = rmem;
        }   
#endif

        rmem->ops = &rmem_dma_ops;
        pr_info("Reserved memory: created DMA memory pool at %pa, size %ld MiB\n",
                &rmem->base, (unsigned long)rmem->size / SZ_1M);
        return 0;
}

最关键的就是初始化rmem->ops为rmem_dma_ops，rmem_dma_ops 定义如下：

static const struct reserved_mem_ops rmem_dma_ops = {
        .device_init    = rmem_dma_device_init,
        .device_release = rmem_dma_device_release,
};

而在dma_init_reserved_memory中会执行device_init 回调：

static int __init dma_init_reserved_memory(void)
{
        const struct reserved_mem_ops *ops;
        int ret;

        if (!dma_reserved_default_memory)
                return -ENOMEM;

        ops = dma_reserved_default_memory->ops;

        /*
         * We rely on rmem_dma_device_init() does not propagate error of
         * dma_assign_coherent_memory() for "NULL" device.
         */
        ret = ops->device_init(dma_reserved_default_memory, NULL);

        if (!ret) {
                dma_coherent_default_memory = dma_reserved_default_memory->priv;
                pr_info("DMA: default coherent area is set\n");
        }

        return ret;
}

core_initcall(dma_init_reserved_memory);

我们看下device_init 的内容，它初始化了dma_coherent_mem结构体，此处dev为null，是为了将保留区域用作dma pool来使用

static int rmem_dma_device_init(struct reserved_mem *rmem, struct device *dev)
{
        struct dma_coherent_mem *mem = rmem->priv;
        int ret;

        if (!mem) {
                ret = dma_init_coherent_memory(rmem->base, rmem->base,
                                               rmem->size, &mem);
                if (ret) {
                        pr_err("Reserved memory: failed to init DMA memory pool at %pa, size %ld MiB\n",
                                &rmem->base, (unsigned long)rmem->size / SZ_1M);
                        return ret;
                }
        }
        mem->use_dev_dma_pfn_offset = true;
        rmem->priv = mem;
        dma_assign_coherent_memory(dev, mem);
        return 0;
}