// SPDX-License-Identifier: GPL-2.0/* * Copyright (c) 2026 Christoph Hellwig. */#include <linux/debugfs.h>#include <linux/blkdev.h>#include <linux/parser.h>#include <linux/seq_file.h>#include "blk.h"#include "error-injection.h" struct blk_error_inject {	struct list_head		entry;	sector_t			start;	sector_t			end;	enum req_op			op;	blk_status_t			status; 	/* only inject every 1 / chance times */	unsigned int			chance;}; DEFINE_STATIC_KEY_FALSE(blk_error_injection_enabled); bool __blk_error_inject(struct bio *bio){	struct gendisk *disk = bio->bi_bdev->bd_disk;	struct blk_error_inject *inj; 	rcu_read_lock();	list_for_each_entry_rcu(inj, &disk->error_injection_list, entry) {		if (bio_op(bio) != inj->op)			continue;		/*		 * This never matches 0-sized bios like empty WRITEs with		 * REQ_PREFLUSH or ZONE_RESET_ALL.  While adding a special case		 * for them would be trivial, that means any WRITE rule would		 * trigger for flushes.  So before we can make this work		 * properly, we'll need to start using REQ_OP_FLUSH for pure		 * flushes at the bio level like we already do in blk-mq.		 */		if (bio->bi_iter.bi_sector > inj->end ||		    bio_end_sector(bio) <= inj->start)			continue;		if (inj->chance > 1 && (get_random_u32() % inj->chance) != 0)			continue; 		pr_info_ratelimited("%pg: injecting %s error for %s at sector %llu:%u\n",				disk->part0, blk_status_to_str(inj->status),				blk_op_str(inj->op), bio->bi_iter.bi_sector,				bio_sectors(bio));		bio->bi_status = inj->status;		rcu_read_unlock();		bio_endio(bio);		return true;	}	rcu_read_unlock();	return false;} static int error_inject_add(struct gendisk *disk, enum req_op op,		sector_t start, u64 nr_sectors, blk_status_t status,		unsigned int chance){	struct blk_error_inject *inj;	int error = -EINVAL; 	if (op == REQ_OP_LAST)		return -EINVAL;	if (status == BLK_STS_OK)		return -EINVAL; 	inj = kzalloc_obj(*inj);	if (!inj)		return -ENOMEM; 	if (nr_sectors) {		if (U64_MAX - nr_sectors < start)			goto out_free_inj;		inj->end = start + nr_sectors - 1;	} else {		inj->end = U64_MAX;	} 	inj->op = op;	inj->start = start;	inj->status = status;	inj->chance = chance; 	pr_debug_ratelimited("%pg: adding %s injection for %s at sector %llu:%llu\n",			disk->part0, blk_status_to_str(status),			blk_op_str(op),			start, nr_sectors); 	/*	 * Add to the front of the list so that newer entries can partially	 * override other entries.  This also intentionally allows duplicate	 * entries as there is no real reason to reject them.	 */	mutex_lock(&disk->error_injection_lock);	if (!disk_live(disk)) {		mutex_unlock(&disk->error_injection_lock);		error = -ENODEV;		goto out_free_inj;	}	if (list_empty(&disk->error_injection_list))		static_branch_inc(&blk_error_injection_enabled);	list_add_rcu(&inj->entry, &disk->error_injection_list);	set_bit(GD_ERROR_INJECT, &disk->state);	mutex_unlock(&disk->error_injection_lock);	return 0; out_free_inj:	kfree(inj);	return error;} static void error_inject_removeall(struct gendisk *disk){	struct blk_error_inject *inj; 	mutex_lock(&disk->error_injection_lock);	if (test_and_clear_bit(GD_ERROR_INJECT, &disk->state))		static_branch_dec(&blk_error_injection_enabled);	while ((inj = list_first_entry_or_null(&disk->error_injection_list,			struct blk_error_inject, entry))) {		list_del_rcu(&inj->entry);		kfree_rcu_mightsleep(inj);	}	mutex_unlock(&disk->error_injection_lock);} enum options {	Opt_add			= (1u << 0),	Opt_removeall		= (1u << 1), 	Opt_op			= (1u << 16),	Opt_start		= (1u << 17),	Opt_nr_sectors		= (1u << 18),	Opt_status		= (1u << 19),	Opt_chance		= (1u << 20), 	Opt_invalid,}; static const match_table_t opt_tokens = {	{ Opt_add,			"add",			},	{ Opt_removeall,		"removeall",		},	{ Opt_op,			"op=%s",		},	{ Opt_start,			"start=%u"		},	{ Opt_nr_sectors,		"nr_sectors=%u"		},	{ Opt_status,			"status=%s"		},	{ Opt_chance,			"chance=%u"		},	{ Opt_invalid,			NULL,			},}; static int match_op(substring_t *args, enum req_op *op){	const char *tag; 	tag = match_strdup(args);	if (!tag)		return -ENOMEM;	*op = str_to_blk_op(tag);	if (*op == REQ_OP_LAST)		pr_warn("invalid op '%s'\n", tag);	kfree(tag);	return 0;} static int match_status(substring_t *args, blk_status_t *status){	const char *tag; 	tag = match_strdup(args);	if (!tag)		return -ENOMEM;	*status = tag_to_blk_status(tag);	if (!*status)		pr_warn("invalid status '%s'\n", tag);	kfree(tag);	return 0;} static ssize_t blk_error_injection_parse_options(struct gendisk *disk,		char *options){	enum { Unset, Add, Removeall } action = Unset;	unsigned int option_mask = 0, chance = 1;	enum req_op op = REQ_OP_LAST;	u64 start = 0, nr_sectors = 0;	blk_status_t status = BLK_STS_OK;	substring_t args[MAX_OPT_ARGS];	char *p; 	while ((p = strsep(&options, ",\n")) != NULL) {		int error = 0;		ssize_t token; 		if (!*p)			continue;		token = match_token(p, opt_tokens, args);		option_mask |= token;		switch (token) {		case Opt_add:			if (action != Unset)				return -EINVAL;			action = Add;			break;		case Opt_removeall:			if (action != Unset)				return -EINVAL;			action = Removeall;			break;		case Opt_op:			error = match_op(args, &op);			break;		case Opt_start:			error = match_u64(args, &start);			break;		case Opt_nr_sectors:			error = match_u64(args, &nr_sectors);			break;		case Opt_status:			error = match_status(args, &status);			break;		case Opt_chance:			error = match_uint(args, &chance);			if (!error && chance == 0)				error = -EINVAL;			break;		default:			pr_warn("unknown parameter or missing value '%s'\n", p);			error = -EINVAL;		}		if (error)			return error;	} 	switch (action) {	case Add:		return error_inject_add(disk, op, start, nr_sectors, status,				chance);	case Removeall:		if (option_mask & ~Opt_removeall)			return -EINVAL;		error_inject_removeall(disk);		return 0;	default:		return -EINVAL;	}} static ssize_t blk_error_injection_write(struct file *file,		const char __user *ubuf, size_t count, loff_t *pos){	struct gendisk *disk = file_inode(file)->i_private;	char *options;	int error; 	options = memdup_user_nul(ubuf, count);	if (IS_ERR(options))		return PTR_ERR(options);	error = blk_error_injection_parse_options(disk, options);	kfree(options); 	if (error)		return error;	return count;} static int blk_error_injection_show(struct seq_file *s, void *private){	struct gendisk *disk = s->private;	struct blk_error_inject *inj; 	rcu_read_lock();	list_for_each_entry_rcu(inj, &disk->error_injection_list, entry) {		seq_printf(s, "%llu:%llu op=%s,status=%s,chance=%u",			   inj->start, inj->end,			   blk_op_str(inj->op),			   blk_status_to_tag(inj->status), inj->chance);		seq_putc(s, '\n');	}	rcu_read_unlock();	return 0;} static int blk_error_injection_open(struct inode *inode, struct file *file){	return single_open(file, blk_error_injection_show, inode->i_private);} static int blk_error_injection_release(struct inode *inode, struct file *file){	return single_release(inode, file);} static const struct file_operations blk_error_injection_fops = {	.owner		= THIS_MODULE,	.write		= blk_error_injection_write,	.read		= seq_read,	.open		= blk_error_injection_open,	.release	= blk_error_injection_release,}; void blk_error_injection_init(struct gendisk *disk){	debugfs_create_file("error_injection", 0600, disk->queue->debugfs_dir,			disk, &blk_error_injection_fops);} void blk_error_injection_exit(struct gendisk *disk){	error_inject_removeall(disk);}