698 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Copyright (c) International Business Machines Corp., 20064 *5 * Author: Artem Bityutskiy (Битюцкий Артём)6 */7 8#include "ubi.h"9#include <linux/debugfs.h>10#include <linux/uaccess.h>11#include <linux/module.h>12#include <linux/seq_file.h>13#include <linux/fault-inject.h>14 15#ifdef CONFIG_MTD_UBI_FAULT_INJECTION16static DECLARE_FAULT_ATTR(fault_eccerr_attr);17static DECLARE_FAULT_ATTR(fault_bitflips_attr);18static DECLARE_FAULT_ATTR(fault_read_failure_attr);19static DECLARE_FAULT_ATTR(fault_write_failure_attr);20static DECLARE_FAULT_ATTR(fault_erase_failure_attr);21static DECLARE_FAULT_ATTR(fault_power_cut_attr);22static DECLARE_FAULT_ATTR(fault_io_ff_attr);23static DECLARE_FAULT_ATTR(fault_io_ff_bitflips_attr);24static DECLARE_FAULT_ATTR(fault_bad_hdr_attr);25static DECLARE_FAULT_ATTR(fault_bad_hdr_ebadmsg_attr);26 27#define FAIL_ACTION(name, fault_attr) \28bool should_fail_##name(void) \29{ \30 return should_fail(&fault_attr, 1); \31}32 33FAIL_ACTION(eccerr, fault_eccerr_attr)34FAIL_ACTION(bitflips, fault_bitflips_attr)35FAIL_ACTION(read_failure, fault_read_failure_attr)36FAIL_ACTION(write_failure, fault_write_failure_attr)37FAIL_ACTION(erase_failure, fault_erase_failure_attr)38FAIL_ACTION(power_cut, fault_power_cut_attr)39FAIL_ACTION(io_ff, fault_io_ff_attr)40FAIL_ACTION(io_ff_bitflips, fault_io_ff_bitflips_attr)41FAIL_ACTION(bad_hdr, fault_bad_hdr_attr)42FAIL_ACTION(bad_hdr_ebadmsg, fault_bad_hdr_ebadmsg_attr)43#endif44 45/**46 * ubi_dump_flash - dump a region of flash.47 * @ubi: UBI device description object48 * @pnum: the physical eraseblock number to dump49 * @offset: the starting offset within the physical eraseblock to dump50 * @len: the length of the region to dump51 */52void ubi_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len)53{54 int err;55 size_t read;56 void *buf;57 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;58 59 buf = vmalloc(len);60 if (!buf)61 return;62 err = mtd_read(ubi->mtd, addr, len, &read, buf);63 if (err && err != -EUCLEAN) {64 ubi_err(ubi, "err %d while reading %d bytes from PEB %d:%d, read %zd bytes",65 err, len, pnum, offset, read);66 goto out;67 }68 69 ubi_msg(ubi, "dumping %d bytes of data from PEB %d, offset %d",70 len, pnum, offset);71 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);72out:73 vfree(buf);74 return;75}76 77/**78 * ubi_dump_ec_hdr - dump an erase counter header.79 * @ec_hdr: the erase counter header to dump80 */81void ubi_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr)82{83 pr_err("Erase counter header dump:\n");84 pr_err("\tmagic %#08x\n", be32_to_cpu(ec_hdr->magic));85 pr_err("\tversion %d\n", (int)ec_hdr->version);86 pr_err("\tec %llu\n", (long long)be64_to_cpu(ec_hdr->ec));87 pr_err("\tvid_hdr_offset %d\n", be32_to_cpu(ec_hdr->vid_hdr_offset));88 pr_err("\tdata_offset %d\n", be32_to_cpu(ec_hdr->data_offset));89 pr_err("\timage_seq %d\n", be32_to_cpu(ec_hdr->image_seq));90 pr_err("\thdr_crc %#08x\n", be32_to_cpu(ec_hdr->hdr_crc));91 pr_err("erase counter header hexdump:\n");92 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,93 ec_hdr, UBI_EC_HDR_SIZE, 1);94}95 96/**97 * ubi_dump_vid_hdr - dump a volume identifier header.98 * @vid_hdr: the volume identifier header to dump99 */100void ubi_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr)101{102 pr_err("Volume identifier header dump:\n");103 pr_err("\tmagic %08x\n", be32_to_cpu(vid_hdr->magic));104 pr_err("\tversion %d\n", (int)vid_hdr->version);105 pr_err("\tvol_type %d\n", (int)vid_hdr->vol_type);106 pr_err("\tcopy_flag %d\n", (int)vid_hdr->copy_flag);107 pr_err("\tcompat %d\n", (int)vid_hdr->compat);108 pr_err("\tvol_id %d\n", be32_to_cpu(vid_hdr->vol_id));109 pr_err("\tlnum %d\n", be32_to_cpu(vid_hdr->lnum));110 pr_err("\tdata_size %d\n", be32_to_cpu(vid_hdr->data_size));111 pr_err("\tused_ebs %d\n", be32_to_cpu(vid_hdr->used_ebs));112 pr_err("\tdata_pad %d\n", be32_to_cpu(vid_hdr->data_pad));113 pr_err("\tsqnum %llu\n",114 (unsigned long long)be64_to_cpu(vid_hdr->sqnum));115 pr_err("\thdr_crc %08x\n", be32_to_cpu(vid_hdr->hdr_crc));116 pr_err("Volume identifier header hexdump:\n");117 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,118 vid_hdr, UBI_VID_HDR_SIZE, 1);119}120 121/**122 * ubi_dump_vol_info - dump volume information.123 * @vol: UBI volume description object124 */125void ubi_dump_vol_info(const struct ubi_volume *vol)126{127 pr_err("Volume information dump:\n");128 pr_err("\tvol_id %d\n", vol->vol_id);129 pr_err("\treserved_pebs %d\n", vol->reserved_pebs);130 pr_err("\talignment %d\n", vol->alignment);131 pr_err("\tdata_pad %d\n", vol->data_pad);132 pr_err("\tvol_type %d\n", vol->vol_type);133 pr_err("\tname_len %d\n", vol->name_len);134 pr_err("\tusable_leb_size %d\n", vol->usable_leb_size);135 pr_err("\tused_ebs %d\n", vol->used_ebs);136 pr_err("\tused_bytes %lld\n", vol->used_bytes);137 pr_err("\tlast_eb_bytes %d\n", vol->last_eb_bytes);138 pr_err("\tcorrupted %d\n", vol->corrupted);139 pr_err("\tupd_marker %d\n", vol->upd_marker);140 pr_err("\tskip_check %d\n", vol->skip_check);141 142 if (vol->name_len <= UBI_VOL_NAME_MAX &&143 strnlen(vol->name, vol->name_len + 1) == vol->name_len) {144 pr_err("\tname %s\n", vol->name);145 } else {146 pr_err("\t1st 5 characters of name: %c%c%c%c%c\n",147 vol->name[0], vol->name[1], vol->name[2],148 vol->name[3], vol->name[4]);149 }150}151 152/**153 * ubi_dump_vtbl_record - dump a &struct ubi_vtbl_record object.154 * @r: the object to dump155 * @idx: volume table index156 */157void ubi_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx)158{159 int name_len = be16_to_cpu(r->name_len);160 161 pr_err("Volume table record %d dump:\n", idx);162 pr_err("\treserved_pebs %d\n", be32_to_cpu(r->reserved_pebs));163 pr_err("\talignment %d\n", be32_to_cpu(r->alignment));164 pr_err("\tdata_pad %d\n", be32_to_cpu(r->data_pad));165 pr_err("\tvol_type %d\n", (int)r->vol_type);166 pr_err("\tupd_marker %d\n", (int)r->upd_marker);167 pr_err("\tname_len %d\n", name_len);168 169 if (r->name[0] == '\0') {170 pr_err("\tname NULL\n");171 return;172 }173 174 if (name_len <= UBI_VOL_NAME_MAX &&175 strnlen(&r->name[0], name_len + 1) == name_len) {176 pr_err("\tname %s\n", &r->name[0]);177 } else {178 pr_err("\t1st 5 characters of name: %c%c%c%c%c\n",179 r->name[0], r->name[1], r->name[2], r->name[3],180 r->name[4]);181 }182 pr_err("\tcrc %#08x\n", be32_to_cpu(r->crc));183}184 185/**186 * ubi_dump_av - dump a &struct ubi_ainf_volume object.187 * @av: the object to dump188 */189void ubi_dump_av(const struct ubi_ainf_volume *av)190{191 pr_err("Volume attaching information dump:\n");192 pr_err("\tvol_id %d\n", av->vol_id);193 pr_err("\thighest_lnum %d\n", av->highest_lnum);194 pr_err("\tleb_count %d\n", av->leb_count);195 pr_err("\tcompat %d\n", av->compat);196 pr_err("\tvol_type %d\n", av->vol_type);197 pr_err("\tused_ebs %d\n", av->used_ebs);198 pr_err("\tlast_data_size %d\n", av->last_data_size);199 pr_err("\tdata_pad %d\n", av->data_pad);200}201 202/**203 * ubi_dump_aeb - dump a &struct ubi_ainf_peb object.204 * @aeb: the object to dump205 * @type: object type: 0 - not corrupted, 1 - corrupted206 */207void ubi_dump_aeb(const struct ubi_ainf_peb *aeb, int type)208{209 pr_err("eraseblock attaching information dump:\n");210 pr_err("\tec %d\n", aeb->ec);211 pr_err("\tpnum %d\n", aeb->pnum);212 if (type == 0) {213 pr_err("\tlnum %d\n", aeb->lnum);214 pr_err("\tscrub %d\n", aeb->scrub);215 pr_err("\tsqnum %llu\n", aeb->sqnum);216 }217}218 219/**220 * ubi_dump_mkvol_req - dump a &struct ubi_mkvol_req object.221 * @req: the object to dump222 */223void ubi_dump_mkvol_req(const struct ubi_mkvol_req *req)224{225 char nm[17];226 227 pr_err("Volume creation request dump:\n");228 pr_err("\tvol_id %d\n", req->vol_id);229 pr_err("\talignment %d\n", req->alignment);230 pr_err("\tbytes %lld\n", (long long)req->bytes);231 pr_err("\tvol_type %d\n", req->vol_type);232 pr_err("\tname_len %d\n", req->name_len);233 234 memcpy(nm, req->name, 16);235 nm[16] = 0;236 pr_err("\t1st 16 characters of name: %s\n", nm);237}238 239/*240 * Root directory for UBI stuff in debugfs. Contains sub-directories which241 * contain the stuff specific to particular UBI devices.242 */243static struct dentry *dfs_rootdir;244 245#ifdef CONFIG_MTD_UBI_FAULT_INJECTION246static void dfs_create_fault_entry(struct dentry *parent)247{248 struct dentry *dir;249 250 dir = debugfs_create_dir("fault_inject", parent);251 if (IS_ERR_OR_NULL(dir)) {252 int err = dir ? PTR_ERR(dir) : -ENODEV;253 254 pr_warn("UBI error: cannot create \"fault_inject\" debugfs directory, error %d\n",255 err);256 return;257 }258 259 fault_create_debugfs_attr("emulate_eccerr", dir,260 &fault_eccerr_attr);261 262 fault_create_debugfs_attr("emulate_read_failure", dir,263 &fault_read_failure_attr);264 265 fault_create_debugfs_attr("emulate_bitflips", dir,266 &fault_bitflips_attr);267 268 fault_create_debugfs_attr("emulate_write_failure", dir,269 &fault_write_failure_attr);270 271 fault_create_debugfs_attr("emulate_erase_failure", dir,272 &fault_erase_failure_attr);273 274 fault_create_debugfs_attr("emulate_power_cut", dir,275 &fault_power_cut_attr);276 277 fault_create_debugfs_attr("emulate_io_ff", dir,278 &fault_io_ff_attr);279 280 fault_create_debugfs_attr("emulate_io_ff_bitflips", dir,281 &fault_io_ff_bitflips_attr);282 283 fault_create_debugfs_attr("emulate_bad_hdr", dir,284 &fault_bad_hdr_attr);285 286 fault_create_debugfs_attr("emulate_bad_hdr_ebadmsg", dir,287 &fault_bad_hdr_ebadmsg_attr);288}289#endif290 291/**292 * ubi_debugfs_init - create UBI debugfs directory.293 *294 * Create UBI debugfs directory. Returns zero in case of success and a negative295 * error code in case of failure.296 */297int ubi_debugfs_init(void)298{299 if (!IS_ENABLED(CONFIG_DEBUG_FS))300 return 0;301 302 dfs_rootdir = debugfs_create_dir("ubi", NULL);303 if (IS_ERR_OR_NULL(dfs_rootdir)) {304 int err = dfs_rootdir ? PTR_ERR(dfs_rootdir) : -ENODEV;305 306 pr_err("UBI error: cannot create \"ubi\" debugfs directory, error %d\n",307 err);308 return err;309 }310 311#ifdef CONFIG_MTD_UBI_FAULT_INJECTION312 dfs_create_fault_entry(dfs_rootdir);313#endif314 315 return 0;316}317 318/**319 * ubi_debugfs_exit - remove UBI debugfs directory.320 */321void ubi_debugfs_exit(void)322{323 if (IS_ENABLED(CONFIG_DEBUG_FS))324 debugfs_remove(dfs_rootdir);325}326 327/* Read an UBI debugfs file */328static ssize_t dfs_file_read(struct file *file, char __user *user_buf,329 size_t count, loff_t *ppos)330{331 unsigned long ubi_num = (unsigned long)file->private_data;332 struct dentry *dent = file->f_path.dentry;333 struct ubi_device *ubi;334 struct ubi_debug_info *d;335 char buf[16];336 int val;337 338 ubi = ubi_get_device(ubi_num);339 if (!ubi)340 return -ENODEV;341 d = &ubi->dbg;342 343 if (dent == d->dfs_chk_gen)344 val = d->chk_gen;345 else if (dent == d->dfs_chk_io)346 val = d->chk_io;347 else if (dent == d->dfs_chk_fastmap)348 val = d->chk_fastmap;349 else if (dent == d->dfs_disable_bgt)350 val = d->disable_bgt;351 else if (dent == d->dfs_emulate_bitflips)352 val = d->emulate_bitflips;353 else if (dent == d->dfs_emulate_io_failures)354 val = d->emulate_io_failures;355 else if (dent == d->dfs_emulate_failures) {356 snprintf(buf, sizeof(buf), "0x%04x\n", d->emulate_failures);357 count = simple_read_from_buffer(user_buf, count, ppos,358 buf, strlen(buf));359 goto out;360 } else if (dent == d->dfs_emulate_power_cut) {361 snprintf(buf, sizeof(buf), "%u\n", d->emulate_power_cut);362 count = simple_read_from_buffer(user_buf, count, ppos,363 buf, strlen(buf));364 goto out;365 } else if (dent == d->dfs_power_cut_min) {366 snprintf(buf, sizeof(buf), "%u\n", d->power_cut_min);367 count = simple_read_from_buffer(user_buf, count, ppos,368 buf, strlen(buf));369 goto out;370 } else if (dent == d->dfs_power_cut_max) {371 snprintf(buf, sizeof(buf), "%u\n", d->power_cut_max);372 count = simple_read_from_buffer(user_buf, count, ppos,373 buf, strlen(buf));374 goto out;375 } else {376 count = -EINVAL;377 goto out;378 }379 380 if (val)381 buf[0] = '1';382 else383 buf[0] = '0';384 buf[1] = '\n';385 buf[2] = 0x00;386 387 count = simple_read_from_buffer(user_buf, count, ppos, buf, 2);388 389out:390 ubi_put_device(ubi);391 return count;392}393 394/* Write an UBI debugfs file */395static ssize_t dfs_file_write(struct file *file, const char __user *user_buf,396 size_t count, loff_t *ppos)397{398 unsigned long ubi_num = (unsigned long)file->private_data;399 struct dentry *dent = file->f_path.dentry;400 struct ubi_device *ubi;401 struct ubi_debug_info *d;402 size_t buf_size;403 char buf[16] = {0};404 int val;405 406 ubi = ubi_get_device(ubi_num);407 if (!ubi)408 return -ENODEV;409 d = &ubi->dbg;410 411 buf_size = min_t(size_t, count, (sizeof(buf) - 1));412 if (copy_from_user(buf, user_buf, buf_size)) {413 count = -EFAULT;414 goto out;415 }416 417 if (dent == d->dfs_emulate_failures) {418 if (kstrtouint(buf, 0, &d->emulate_failures) != 0)419 count = -EINVAL;420 goto out;421 } else if (dent == d->dfs_power_cut_min) {422 if (kstrtouint(buf, 0, &d->power_cut_min) != 0)423 count = -EINVAL;424 goto out;425 } else if (dent == d->dfs_power_cut_max) {426 if (kstrtouint(buf, 0, &d->power_cut_max) != 0)427 count = -EINVAL;428 goto out;429 } else if (dent == d->dfs_emulate_power_cut) {430 if (kstrtoint(buf, 0, &val) != 0)431 count = -EINVAL;432 else433 d->emulate_power_cut = val;434 goto out;435 }436 437 if (buf[0] == '1')438 val = 1;439 else if (buf[0] == '0')440 val = 0;441 else {442 count = -EINVAL;443 goto out;444 }445 446 if (dent == d->dfs_chk_gen)447 d->chk_gen = val;448 else if (dent == d->dfs_chk_io)449 d->chk_io = val;450 else if (dent == d->dfs_chk_fastmap)451 d->chk_fastmap = val;452 else if (dent == d->dfs_disable_bgt)453 d->disable_bgt = val;454 else if (dent == d->dfs_emulate_bitflips)455 d->emulate_bitflips = val;456 else if (dent == d->dfs_emulate_io_failures)457 d->emulate_io_failures = val;458 else459 count = -EINVAL;460 461out:462 ubi_put_device(ubi);463 return count;464}465 466/* File operations for all UBI debugfs files except467 * detailed_erase_block_info468 */469static const struct file_operations dfs_fops = {470 .read = dfs_file_read,471 .write = dfs_file_write,472 .open = simple_open,473 .owner = THIS_MODULE,474};475 476/* As long as the position is less then that total number of erase blocks,477 * we still have more to print.478 */479static void *eraseblk_count_seq_start(struct seq_file *s, loff_t *pos)480{481 struct ubi_device *ubi = s->private;482 483 if (*pos < ubi->peb_count)484 return pos;485 486 return NULL;487}488 489/* Since we are using the position as the iterator, we just need to check if we490 * are done and increment the position.491 */492static void *eraseblk_count_seq_next(struct seq_file *s, void *v, loff_t *pos)493{494 struct ubi_device *ubi = s->private;495 496 (*pos)++;497 498 if (*pos < ubi->peb_count)499 return pos;500 501 return NULL;502}503 504static void eraseblk_count_seq_stop(struct seq_file *s, void *v)505{506}507 508static int eraseblk_count_seq_show(struct seq_file *s, void *iter)509{510 struct ubi_device *ubi = s->private;511 struct ubi_wl_entry *wl;512 int *block_number = iter;513 int erase_count = -1;514 int err;515 516 /* If this is the start, print a header */517 if (*block_number == 0)518 seq_puts(s, "physical_block_number\terase_count\n");519 520 err = ubi_io_is_bad(ubi, *block_number);521 if (err)522 return err;523 524 spin_lock(&ubi->wl_lock);525 526 wl = ubi->lookuptbl[*block_number];527 if (wl)528 erase_count = wl->ec;529 530 spin_unlock(&ubi->wl_lock);531 532 if (erase_count < 0)533 return 0;534 535 seq_printf(s, "%-22d\t%-11d\n", *block_number, erase_count);536 537 return 0;538}539 540static const struct seq_operations eraseblk_count_seq_ops = {541 .start = eraseblk_count_seq_start,542 .next = eraseblk_count_seq_next,543 .stop = eraseblk_count_seq_stop,544 .show = eraseblk_count_seq_show545};546 547static int eraseblk_count_open(struct inode *inode, struct file *f)548{549 struct seq_file *s;550 int err;551 552 err = seq_open(f, &eraseblk_count_seq_ops);553 if (err)554 return err;555 556 s = f->private_data;557 s->private = ubi_get_device((unsigned long)inode->i_private);558 559 if (!s->private)560 return -ENODEV;561 else562 return 0;563}564 565static int eraseblk_count_release(struct inode *inode, struct file *f)566{567 struct seq_file *s = f->private_data;568 struct ubi_device *ubi = s->private;569 570 ubi_put_device(ubi);571 572 return seq_release(inode, f);573}574 575static const struct file_operations eraseblk_count_fops = {576 .owner = THIS_MODULE,577 .open = eraseblk_count_open,578 .read = seq_read,579 .llseek = seq_lseek,580 .release = eraseblk_count_release,581};582 583/**584 * ubi_debugfs_init_dev - initialize debugfs for an UBI device.585 * @ubi: UBI device description object586 *587 * This function creates all debugfs files for UBI device @ubi. Returns zero in588 * case of success and a negative error code in case of failure.589 */590int ubi_debugfs_init_dev(struct ubi_device *ubi)591{592 unsigned long ubi_num = ubi->ubi_num;593 struct ubi_debug_info *d = &ubi->dbg;594 umode_t mode = S_IRUSR | S_IWUSR;595 int n;596 597 if (!IS_ENABLED(CONFIG_DEBUG_FS))598 return 0;599 600 n = snprintf(d->dfs_dir_name, UBI_DFS_DIR_LEN, UBI_DFS_DIR_NAME,601 ubi->ubi_num);602 if (n >= UBI_DFS_DIR_LEN) {603 /* The array size is too small */604 return -EINVAL;605 }606 607 d->dfs_dir = debugfs_create_dir(d->dfs_dir_name, dfs_rootdir);608 609 d->dfs_chk_gen = debugfs_create_file("chk_gen", mode, d->dfs_dir,610 (void *)ubi_num, &dfs_fops);611 612 d->dfs_chk_io = debugfs_create_file("chk_io", mode, d->dfs_dir,613 (void *)ubi_num, &dfs_fops);614 615 d->dfs_chk_fastmap = debugfs_create_file("chk_fastmap", mode,616 d->dfs_dir, (void *)ubi_num,617 &dfs_fops);618 619 d->dfs_disable_bgt = debugfs_create_file("tst_disable_bgt", mode,620 d->dfs_dir, (void *)ubi_num,621 &dfs_fops);622 623 d->dfs_emulate_bitflips = debugfs_create_file("tst_emulate_bitflips",624 mode, d->dfs_dir,625 (void *)ubi_num,626 &dfs_fops);627 628 d->dfs_emulate_io_failures = debugfs_create_file("tst_emulate_io_failures",629 mode, d->dfs_dir,630 (void *)ubi_num,631 &dfs_fops);632 633 d->dfs_emulate_power_cut = debugfs_create_file("tst_emulate_power_cut",634 mode, d->dfs_dir,635 (void *)ubi_num,636 &dfs_fops);637 638 d->dfs_power_cut_min = debugfs_create_file("tst_emulate_power_cut_min",639 mode, d->dfs_dir,640 (void *)ubi_num, &dfs_fops);641 642 d->dfs_power_cut_max = debugfs_create_file("tst_emulate_power_cut_max",643 mode, d->dfs_dir,644 (void *)ubi_num, &dfs_fops);645 646 debugfs_create_file("detailed_erase_block_info", S_IRUSR, d->dfs_dir,647 (void *)ubi_num, &eraseblk_count_fops);648 649#ifdef CONFIG_MTD_UBI_FAULT_INJECTION650 d->dfs_emulate_failures = debugfs_create_file("emulate_failures",651 mode, d->dfs_dir,652 (void *)ubi_num,653 &dfs_fops);654#endif655 return 0;656}657 658/**659 * ubi_debugfs_exit_dev - free all debugfs files corresponding to device @ubi660 * @ubi: UBI device description object661 */662void ubi_debugfs_exit_dev(struct ubi_device *ubi)663{664 if (IS_ENABLED(CONFIG_DEBUG_FS))665 debugfs_remove_recursive(ubi->dbg.dfs_dir);666}667 668/**669 * ubi_dbg_power_cut - emulate a power cut if it is time to do so670 * @ubi: UBI device description object671 * @caller: Flags set to indicate from where the function is being called672 *673 * Returns non-zero if a power cut was emulated, zero if not.674 */675int ubi_dbg_power_cut(struct ubi_device *ubi, int caller)676{677 unsigned int range;678 679 if ((ubi->dbg.emulate_power_cut & caller) == 0)680 return 0;681 682 if (ubi->dbg.power_cut_counter == 0) {683 ubi->dbg.power_cut_counter = ubi->dbg.power_cut_min;684 685 if (ubi->dbg.power_cut_max > ubi->dbg.power_cut_min) {686 range = ubi->dbg.power_cut_max - ubi->dbg.power_cut_min;687 ubi->dbg.power_cut_counter += get_random_u32_below(range);688 }689 return 0;690 }691 692 ubi->dbg.power_cut_counter--;693 if (ubi->dbg.power_cut_counter)694 return 0;695 696 return 1;697}698