linux内核bio子系统学习记录一：

bio子系统学习一：

主要源码目录 :block/bio.c include/linux/bio.h
内核版本：4.19.1

这部分先总结下bio子系统的初始化部分，后续再总结bio的申请以及释放，还有其它api的使用等介绍。

bio的涉及到频繁的内存申请以及释放，包括bio结构体本身以及它比较重要的成员bi_io_vec*的内存申请和释放，所以初始化部分主要是相关的内存池的初始化，用于后面bio和bi_io_vec的内存申请和释放。

其中bio结构体和bio_vec结构体定义如下：

/*
 * main unit of I/O for the block layer and lower layers (ie drivers and
 * stacking drivers)
 */
struct bio {
	struct bio		*bi_next;	/* request queue link */
	struct gendisk		*bi_disk;
	unsigned int		bi_opf;		/* bottom bits req flags,
						 * top bits REQ_OP. Use
						 * accessors.
						 */
	unsigned short		bi_flags;	/* status, etc and bvec pool number */
	unsigned short		bi_ioprio;
	unsigned short		bi_write_hint;
	blk_status_t		bi_status;
	u8			bi_partno;
	/* Number of segments in this BIO after
	 * physical address coalescing is performed.
	 */
	unsigned int		bi_phys_segments;
	/*
	 * To keep track of the max segment size, we account for the
	 * sizes of the first and last mergeable segments in this bio.
	 */
	unsigned int		bi_seg_front_size;
	unsigned int		bi_seg_back_size;
	struct bvec_iter	bi_iter; //用来遍历bvec，标记bio的处理进度
	
	atomic_t		__bi_remaining;
	bio_end_io_t		*bi_end_io;
	void			*bi_private;
#ifdef CONFIG_BLK_CGROUP
	/*
	 * Optional ioc and css associated with this bio.  Put on bio
	 * release.  Read comment on top of bio_associate_current().
	 */
	struct io_context	*bi_ioc;
	struct cgroup_subsys_state *bi_css;
	struct blkcg_gq		*bi_blkg;
	struct bio_issue	bi_issue;
#endif
	union {
#if defined(CONFIG_BLK_DEV_INTEGRITY)
		struct bio_integrity_payload *bi_integrity; /* data integrity */
#endif
	};
	unsigned short		bi_vcnt;	/* how many bio_vec's */
	/*
	 * Everything starting with bi_max_vecs will be preserved by bio_reset()
	 */
	unsigned short		bi_max_vecs;	/* max bvl_vecs we can hold */
	atomic_t		__bi_cnt;	/* pin count */
	struct bio_vec		*bi_io_vec;	/* the actual vec list */
	struct bio_set		*bi_pool;
	/*
	 * We can inline a number of vecs at the end of the bio, to avoid
	 * double allocations for a small number of bio_vecs. This member
	 * MUST obviously be kept at the very end of the bio.
	 */
	struct bio_vec		bi_inline_vecs[0];
};
/*
 * was unsigned short, but we might as well be ready for > 64kB I/O pages
 */
struct bio_vec {
	struct page	*bv_page;
	unsigned int	bv_len;
	unsigned int	bv_offset;
};

入口函数init_bio：

其中，bio_integrity_init函数和bioset_integrity_create函数先不看吧。

//这个是涉及到的结构体定义
struct bio_slab {
	struct kmem_cache *slab; //指向cache描述符，cache描述符描述了slab信息
	unsigned int slab_ref; //bio_slab结构体的引用计数
	unsigned int slab_size; //内存池中object大小
	char name[8]; //内存池名称，/proc/slabinfo可以看到
};

static DEFINE_MUTEX(bio_slab_lock);
static struct bio_slab *bio_slabs;
static unsigned int bio_slab_nr, bio_slab_max;

/*
	1:https://zhuanlan.zhihu.com/p/596543999?utm_id=0
	2:https://blog.csdn.net/geshifei/article/details/119959905
*/
static int __init init_bio(void)
{
	/*全局数组*/
	bio_slab_max = 2;
	bio_slab_nr = 0;
	bio_slabs = kcalloc(bio_slab_max, sizeof(struct bio_slab), GFP_KERNEL);
	if (!bio_slabs)
		panic("bio: can't allocate bios\n");
	/*
		这部分先不看
	*/
	bio_integrity_init();

	//bvec_slabs数组管理bvec内存池
	biovec_init_slabs(); //分配bio_vec的高速内存池

	/*
		参数1:需要初始化的bio_set指针
		参数二:内存池中bio的最小数量
		参数三:struct bio结构体前附加数据块的大小，front_pad+sizeof(struct bio)就是内存池中object的大小。
			从fs_bio_set类型内存池中申请bio内存块，bio前无附加数据
		参数四:
			BIOSET_NEED_BVECS ：创建一个单独的内存池用于分配iovecs，fs_bio_set需设置该标记
			BIOSET_NEED_RESCUER：创建一个workqueue，处理函数为bio_alloc_rescue，当内存不足无法从内存池中申请到bio时，
			该workqueue把处理stack device时（比如raid）暂存在list中的bio（参考后文“bio的提交”）提交处理，从而回收bio。
			对于非stack device场景，不需要这个工作队列。

		对fs_bio_set这个变量进行初始化
	*/
	if (bioset_init(&fs_bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS)) //2, 0 ,1
		panic("bio: can't allocate bios\n");

	/*
		这部分先不看
	*/
	if (bioset_integrity_create(&fs_bio_set, BIO_POOL_SIZE)) //2
		panic("bio: can't create integrity pool\n");

	return 0;
}
subsys_initcall(init_bio);

这里先分析下bio_slabs 这个结构体，，看变量名字也比较容易分析，它是后续用于申请bio这个结构体时使用的，只是初始化时，它的数组下标只有两个，且其成员也没有初始化，在实际使用时，它的成员才会进行初始化，而且在必要时也会进行扩容，也就是它的数组下标不是2了。(这个见bio_find_or_create_slab函数)，，所以在申请bio的时候根据算法的设计，它有可能是从任何一个下标的成员(slab)当中申请内存的。

biovec_init_slabs函数分析

这个函数，看名称也不难分析，是对后续在申请biovec相关内存时做的一些初始化。

#define BIO_INLINE_VECS 4
/*
	1://https://blog.csdn.net/sinat_32960911/article/details/132237781
	2:__read_mostly gcc编译选项 标记该变量会被频繁访问 提高系统性能
	struct biovec_slab {
		int nr_vecs;
		char *name;
		struct kmem_cache *slab;
	};
*/
#define BV(x, n) { .nr_vecs = x, .name = "biovec-"#n }
static struct biovec_slab bvec_slabs[BVEC_POOL_NR] __read_mostly = { 
	BV(1, 1), BV(4, 4), BV(16, 16), BV(64, 64), BV(128, 128), BV(BIO_MAX_PAGES, max), //这个当作是256吧
};
#undef BV //取消该宏定义

static void __init biovec_init_slabs(void)
{
	int i;
	for (i = 0; i < BVEC_POOL_NR; i++) { //6
		int size;
		struct biovec_slab *bvs = bvec_slabs + i; //指向结构体数组的首地址

		if (bvs->nr_vecs <= BIO_INLINE_VECS) { //4, 前面两个成员
			bvs->slab = NULL; 
			continue;
		}
		/*
			这个size比较关键
		*/
		size = bvs->nr_vecs * sizeof(struct bio_vec);
		bvs->slab = kmem_cache_create(bvs->name, size, 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
	}
}

bioset_init函数分析

这里比较重要的是调用的bio_find_or_create_slab函数，其余的就是对fs_bio_set这个结构体的一些成员变量进行初始化。

struct bio_set {
	struct kmem_cache *bio_slab;
	unsigned int front_pad;
	mempool_t bio_pool;
	mempool_t bvec_pool;
#if defined(CONFIG_BLK_DEV_INTEGRITY)
	mempool_t bio_integrity_pool;
	mempool_t bvec_integrity_pool;
#endif
	//Deadlock avoidance for stacking block drivers: see comments in bio_alloc_bioset() for details
	spinlock_t		rescue_lock;
	struct bio_list		rescue_list;
	struct work_struct	rescue_work;
	struct workqueue_struct	*rescue_workqueue;
};

/*
 * fs_bio_set is the bio_set containing bio and iovec memory pools used by
 * IO code that does not need private memory pools.
 */
struct bio_set fs_bio_set;
EXPORT_SYMBOL(fs_bio_set);

int bioset_init(struct bio_set *bs,unsigned int pool_size, unsigned int front_pad, int flags)
{
	//sizeof(bio)的多余部分
	unsigned int back_pad = BIO_INLINE_VECS * sizeof(struct bio_vec); //4 * sizeof(struct bio_vec)

	bs->front_pad = front_pad; //0

	spin_lock_init(&bs->rescue_lock); //自旋锁初始化
	bio_list_init(&bs->rescue_list); //bio_list 初始化
	INIT_WORK(&bs->rescue_work, bio_alloc_rescue); //工作队列初始化

	/*返回的这个值，也记录在这个bio_slabs全局数组里了
		看函数名称，bio当中寻找slab或者创建一个slab
	*/
	bs->bio_slab = bio_find_or_create_slab(front_pad + back_pad); //0+back_pad
	if (!bs->bio_slab)
		return -ENOMEM;
	/*
		bio_pool的初始化，后面分配内存使用mempool_alloc
		pool_size内存池至少保留两个元素

		mempool_init(pool, min_nr, mempool_alloc_slab, mempool_free_slab, (void *) kc);
		后续申请内存走的是这个路线 -> mempool_alloc_slab -> kmem_cache_alloc
	*/
	if (mempool_init_slab_pool(&bs->bio_pool, pool_size, bs->bio_slab))//2
		goto bad;

	//1 & （1 << 0)
	if ((flags & BIOSET_NEED_BVECS) && biovec_init_pool(&bs->bvec_pool, pool_size)) //2
		goto bad;

	if (!(flags & BIOSET_NEED_RESCUER)) // 1 & (1 << 1)   -> 0001 & 0010
		return 0;

	bs->rescue_workqueue = alloc_workqueue("bioset", WQ_MEM_RECLAIM, 0); //申请一个工作队列
	if (!bs->rescue_workqueue)
		goto bad;
	return 0;
bad:
	bioset_exit(bs);
	return -ENOMEM;
}
EXPORT_SYMBOL(bioset_init);

bio_find_or_create_slab函数分析

static struct kmem_cache *bio_find_or_create_slab(unsigned int extra_size)
{
	unsigned int sz = sizeof(struct bio) + extra_size; 
	struct kmem_cache *slab = NULL;
	struct bio_slab *bslab, *new_bio_slabs;
	unsigned int new_bio_slab_max;
	unsigned int i, entry = -1;

	mutex_lock(&bio_slab_lock);
	/*
		遍历bio_slabs数组，若某个bio_slab->slab_size等于sz,
		那么就选择这个bio_slab.
	*/
	i = 0;
	while (i < bio_slab_nr) { //这个一开始是0
		bslab = &bio_slabs[i];
		//若bio_slabs有空闲未用的bio_slab，选择该bio_slab
		if (!bslab->slab && entry == -1)
			entry = i;
		else if (bslab->slab_size == sz) {
			slab = bslab->slab;
			bslab->slab_ref++;
			break;
		}
		i++;
	}
	//找到bio_slab了
	if (slab)
		goto out_unlock;
	/*
		经过上面两步依然未找到可用的bio_slab，
		通过krealloc将bio_slabs数组长度扩大一倍，
		并选择其中一个空闲的bio_slab。
	*/
	if (bio_slab_nr == bio_slab_max && entry == -1) {
		new_bio_slab_max = bio_slab_max << 1; //相当于乘以2
		new_bio_slabs = krealloc(bio_slabs, new_bio_slab_max * sizeof(struct bio_slab), GFP_KERNEL);
		if (!new_bio_slabs)
			goto out_unlock;
		bio_slab_max = new_bio_slab_max;
		bio_slabs = new_bio_slabs;
	}
	if (entry == -1)
		entry = bio_slab_nr++;

	bslab = &bio_slabs[entry];

	snprintf(bslab->name, sizeof(bslab->name), "bio-%d", entry);
	slab = kmem_cache_create(bslab->name, sz, ARCH_KMALLOC_MINALIGN, SLAB_HWCACHE_ALIGN, NULL);
	if (!slab)
		goto out_unlock;

	bslab->slab = slab;
	bslab->slab_ref = 1;
	bslab->slab_size = sz;
out_unlock:
	mutex_unlock(&bio_slab_lock);
	return slab;
}

其初始化过程基本就是这样了，如果对内存池用的不多也不要紧，可以看看相关源码，也不多。

总结：初始化部分，如果光光看这部分，会比较晦涩，后面在涉及到bio的申请和释放时，再回头来看初始化部分，就清晰许多了。