Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317// 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);}