RAID5 IO处理之对齐读代码详解

1 总体流程

当一个读请求的覆盖范围落在一个chunk范围内时为对齐读，流程图如下所示：

2 入口

在RAID5的IO处理函数 make_request() 一开始进行了对齐读的判断和处理，代码如下所示：

/*
 * rw == READ 判断是不是读请求
 * mddev->reshape_position == MaxSector 判断是否正在reshape
 *   reshape时数据分布发生变化且以条带为单位进行，故此时只能通过条带读数据
 * chunk_aligned_read(mddev,bi) 调用该函数判断并执行对齐读
 */
if (rw == READ
    && mddev->reshape_position == MaxSector
    && chunk_aligned_read(mddev, bi))
	return;

3 下发

对齐读通过函数 chunk_aligned_read() 下发，其代码逻辑如下所示：

static int chunk_aligned_read(struct mddev *mddev, struct bio *raid_bio)
{
	struct r5conf *conf = mddev->private;
	int dd_idx;
	struct bio* align_bi;
	struct md_rdev *rdev;
	sector_t end_sector;

	/*
	 * 行判断IO是否在chunk范围内，如果不在则返回0到make_request中
	 * 继续向下执行通过条带读取数据
	 */
	if (!in_chunk_boundary(mddev, raid_bio)) {
		pr_debug("chunk_aligned_read : non aligned\n");
		return 0;
	}

	/* 克隆一个新的bio用于对齐读 */
	align_bi = bio_clone_mddev(raid_bio, GFP_NOIO, mddev);
	if (!align_bi)
		return 0;

	/* 设置回调函数 */
	align_bi->bi_end_io  = raid5_align_endio;
	/* 在向上层返回IO结果或重试条带读时使用原始bio */
	align_bi->bi_private = raid_bio;

	/*
	 * 根据原始bio的起始位置计算其在RAID成员磁盘中的位置
	 * 并获取所属成员磁盘索引dd_idx
	 */
	align_bi->bi_sector = raid5_compute_sector(conf, raid_bio->bi_sector,
						   0,
						   &dd_idx, NULL);

	/*
	 * 获取成员磁盘指针
	 * 如果在做磁盘替换且新盘状态正常且重构进度大于bio的结束位置
	 * 说明此时新盘包含了要读的数据，此时通过新盘读取，否则判断旧盘是否可读
	 * 如果旧盘状态正常，且重构进度大于bio的结束位置，则可以通过旧盘读取
	 * 如果新盘旧盘两者条件都不满足，则rdev会设置为NULL
	 */
	end_sector = bio_end_sector(align_bi);
	rcu_read_lock();
	rdev = rcu_dereference(conf->disks[dd_idx].replacement);
	if (!rdev || test_bit(Faulty, &rdev->flags) ||
		rdev->recovery_offset < end_sector) {
		rdev = rcu_dereference(conf->disks[dd_idx].rdev);
		if (rdev &&
			(test_bit(Faulty, &rdev->flags) ||
			!(test_bit(In_sync, &rdev->flags) ||
			  rdev->recovery_offset >= end_sector)))
			rdev = NULL;
	}

	/* 处理成员磁盘可读的场景 */
	if (rdev) {
		sector_t first_bad;
		int bad_sectors;

		/* 自增成员磁盘的pending io计数 */
		atomic_inc(&rdev->nr_pending);
		rcu_read_unlock();
		/*
		 * 将成员磁盘指针赋值给原始bio的bi_next域用于在回调函数中获取bio所属成员磁盘
		 * 在对齐读中，使用克隆的bio所以原始bio的bi_next域不会被使用
		 */
		raid_bio->bi_next = (void*)rdev;
		/* 设置bio所属成员磁盘的块设备指针 */
		align_bi->bi_bdev = rdev->bdev;
		/*
		 * 设置BIO_SEG_VALID标记，表明bi_phys_segments是有效的
		 * bi_phys_segments是bio要处理的“物理地址连续数据段”的计数
		 * 即有多少段连续的数据
		 */
		align_bi->bi_flags &= ~(1 << BIO_SEG_VALID);

		/**
		 * 判断bio能否下发。
		 * 首先调用bio_fits_rdev判断bio的属性是否满足底层块设备的限制
		 * 然后调用is_badblock判断bio覆盖的范围是否有坏块
		 * 如果不满足底层块设备限制或有坏块，则不能进行对齐读
		 * 释放克隆的bio自减成员磁盘pending io计数后返回0到make_request中
		 * 使其向下执行，通过条带读取数据
		 */
		if (!bio_fits_rdev(align_bi) ||
			is_badblock(rdev, align_bi->bi_sector, bio_sectors(align_bi),
				&first_bad, &bad_sectors)) {
			/* too big in some way, or has a known bad block */
			bio_put(align_bi);
			rdev_dec_pending(rdev, mddev);
			return 0;
		}

		/* 设置bio相对于底层磁盘的起始位置 */
		align_bi->bi_sector += rdev->data_offset;

		/* 等待RAID解除“静默”。RAID可被用户手动设置为“静默”状态即不处理业务 */
		spin_lock_irq(&conf->device_lock);
		wait_event_lock_irq(conf->wait_for_stripe,
				    conf->quiesce == 0,
				    conf->device_lock);
		atomic_inc(&conf->active_aligned_reads);
		spin_unlock_irq(&conf->device_lock);

		if (mddev->gendisk)
			/* 用于块设备的IO统计 */
			trace_block_bio_remap(bdev_get_queue(align_bi->bi_bdev),
					      align_bi, disk_devt(mddev->gendisk),
					      raid_bio->bi_sector);

		/* 调用generic_make_request将bio提交到底层块设备处理 */
		generic_make_request(align_bi);
		/* 返回1到make_request中，make_request结束，等待IO完成后的回调 */
		return 1;
	} else {
		/*
		 * 处理rdev被赋值为NULL的情况，此时释放克隆的bio
		 * 返回0到make_request中继续向下执行，通过条带读取数据
		 */
		rcu_read_unlock();
		bio_put(align_bi);
		return 0;
	}
}

4 回调

对齐读请求的回调函数为 raid5_align_endio() ，其代码逻辑如下所示：

/* error参数表示IO执行是否异常 */
static void raid5_align_endio(struct bio *bi, int error)
{
	struct bio* raid_bi  = bi->bi_private;
	struct mddev *mddev;
	struct r5conf *conf;
	/* 获取IO执行结果。如果成功则设置BIO_UPTODATE标记，uptodate为真 */
	int uptodate = test_bit(BIO_UPTODATE, &bi->bi_flags);
	struct md_rdev *rdev;

	/* 无论IO执行是否成功，都可以将之前克隆的bio释放掉 */
	bio_put(bi);
	/* 获取bio所在RAID的成员磁盘 */
	rdev = (void*)raid_bi->bi_next;
	raid_bi->bi_next = NULL;
	mddev = rdev->mddev;
	conf = mddev->private;

	/* IO执行完毕，自减成员磁盘的pending io计数 */
	rdev_dec_pending(rdev, conf->mddev);

	/*
	 * IO执行成功，调用trace_block_bio_complete设置IO统计信息
	 * 调用bio_endio向上层返回成功，当正在处理的对齐读为0时唤醒等待条带的进程
	 */
	if (!error && uptodate) {
		trace_block_bio_complete(bdev_get_queue(raid_bi->bi_bdev),
					 raid_bi, 0);
		bio_endio(raid_bi, 0);
		if (atomic_dec_and_test(&conf->active_aligned_reads))
			wake_up(&conf->wait_for_stripe);
		return;
	}

	/* 对齐读失败，调用add_bio_to_retry将bio添加到重试链表中进行重试 */
	pr_debug("raid5_align_endio : io error...handing IO for a retry\n");
	add_bio_to_retry(raid_bi, conf);
}

5 重试

先将bio加入到重试链表中，再有 raid5d() 统一处理，代码逻辑如下所示：

static void add_bio_to_retry(struct bio *bi,struct r5conf *conf)
{
	unsigned long flags;

	spin_lock_irqsave(&conf->device_lock, flags);

	/* 将bio插入到重试链表retry_read_aligned_list的头部 */
	bi->bi_next = conf->retry_read_aligned_list;
	conf->retry_read_aligned_list = bi;

	spin_unlock_irqrestore(&conf->device_lock, flags);

	/* 唤醒raid5d线程处理请求 */
	md_wakeup_thread(conf->mddev->thread);
}

/* 这里只截取了对齐读重试的代码 */
static void raid5d(struct md_thread *thread)
{
	...

	/* 从重试链表中获取一个待重试的bio */
	while ((bio = remove_bio_from_retry(conf))) {
		int ok;
		spin_unlock_irq(&conf->device_lock);
		/* 进行重试 */
		ok = retry_aligned_read(conf, bio);
		spin_lock_irq(&conf->device_lock);
		if (!ok)
			break;
		handled++;
	}

	...
}

static struct bio *remove_bio_from_retry(struct r5conf *conf)
{
	struct bio *bi;

	/*
	 * retry_read_aligned中保存上一次重试未完成的对齐读
	 * 所以这里优先返回上一次未重试完成的对齐读请求
	 */
	bi = conf->retry_read_aligned;
	if (bi) {
		conf->retry_read_aligned = NULL;
		return bi;
	}

	/*
	 * 从retry_read_aligned_list链表头部取出第一个需要重试的对齐读请求
	 * 调用raid5_set_bi_stripes设置bi_phys_segments计数为1
	 */
	bi = conf->retry_read_aligned_list;
	if(bi) {
		conf->retry_read_aligned_list = bi->bi_next;
		bi->bi_next = NULL;
		/*
		 * this sets the active strip count to 1 and the processed
		 * strip count to zero (upper 8 bits)
		 */
		raid5_set_bi_stripes(bi, 1); /* biased count of active stripes */
	}

	/* 返回请求到raid5d中 */
	return bi;
}

static int retry_aligned_read(struct r5conf *conf, struct bio *raid_bio)
{
	/* We may not be able to submit a whole bio at once as there
	 * may not be enough stripe_heads available.
	 * We cannot pre-allocate enough stripe_heads as we may need
	 * more than exist in the cache (if we allow ever large chunks).
	 * So we do one stripe head at a time and record in
	 * ->bi_hw_segments how many have been done.
	 *
	 * We *know* that this entire raid_bio is in one chunk, so
	 * it will be only one 'dd_idx' and only need one call to raid5_compute_sector.
	 */
	struct stripe_head *sh;
	int dd_idx;
	sector_t sector, logical_sector, last_sector;
	int scnt = 0;
	int remaining;
	int handled = 0;

	/* 获取bio所在条带头的起始位置 */
	logical_sector = raid_bio->bi_sector & ~((sector_t)STRIPE_SECTORS-1);
	/* 获取bio相对于其所属RAID成员磁盘的起始位置的偏移 */
	sector = raid5_compute_sector(conf, logical_sector,
				      0, &dd_idx, NULL);
	/* 获取bio的结束扇区数 */
	last_sector = bio_end_sector(raid_bio);

	/*
	 * 由于RAID5处理数据的单位是条带，所以这里使用for循环进行bio逻辑上的“切割”
	 * 将bio挂载到相应的条带上。scnt是bio处理的条带计数，随着条带的下发进行自增
	 */
	for (; logical_sector < last_sector;
		 logical_sector += STRIPE_SECTORS,
			 sector += STRIPE_SECTORS,
			 scnt++) {

		/*
		 * 跳过该bio已经处理的部分
		 * bio可能在没有全部下发的情况下退出该函数（如获取不到空闲条带）
		 * 此时会通过raid5_set_bi_processed_stripes函数设置已处理过的条带计数
		 */
		if (scnt < raid5_bi_processed_stripes(raid_bio))
			/* already done this stripe */
			continue;

		/*
		 * 获取一个空闲的条带
		 * 如果获取失败，则设置已处理条带计数，将bio挂载到
		 * 未处理完成的对齐读重试链表retry_read_aligned中返回
		 */
		sh = get_active_stripe(conf, sector, 0, 1, 0);
		if (!sh) {
			/* failed to get a stripe - must wait */
			raid5_set_bi_processed_stripes(raid_bio, scnt);
			conf->retry_read_aligned = raid_bio;
			return handled;
		}

		/* 将bio添加到链表中，如果添加失败处理同上 */
		if (!add_stripe_bio(sh, raid_bio, dd_idx, 0)) {
			release_stripe(sh);
			raid5_set_bi_processed_stripes(raid_bio, scnt);
			conf->retry_read_aligned = raid_bio;
			return handled;
		}

		/* 设置不合并属性 */
		set_bit(R5_ReadNoMerge, &sh->dev[dd_idx].flags);
		/* 将条带推入状态机处理 */
		handle_stripe(sh);
		release_stripe(sh);
		handled++;
	}

	/*
	 * 如果bio的bi_phys_segments计数为0则说明已处理完毕
	 * 调用bio_endio向上层返回
	 */
	remaining = raid5_dec_bi_active_stripes(raid_bio);
	if (remaining == 0) {
		trace_block_bio_complete(bdev_get_queue(raid_bio->bi_bdev),
					 raid_bio, 0);
		bio_endio(raid_bio, 0);
	}

	/* 如果正在重试的对齐读为0则唤醒等待条带的线程 */
	if (atomic_dec_and_test(&conf->active_aligned_reads))
		wake_up(&conf->wait_for_stripe);
	return handled;
}

自此，重试的对齐读改为通过条带获取其数据，剩下的流程和条带读相同，统一放到条带读流程中进行分析。