drivers/mtd/ubi/debug.c

   1 /*
   2  * Copyright (c) International Business Machines Corp., 2006
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  12  * the GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  17  *
  18  * Author: Artem Bityutskiy (Битюцкий Артём)
  19  */
  20
  21 #include "ubi.h"
  22 #include <linux/debugfs.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/module.h>
  25
  26
  27 /**
  28  * ubi_dump_flash - dump a region of flash.
  29  * @ubi: UBI device description object
  30  * @pnum: the physical eraseblock number to dump
  31  * @offset: the starting offset within the physical eraseblock to dump
  32  * @len: the length of the region to dump
  33  */
  34 void ubi_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len)
  35 {
  36         int err;
  37         size_t read;
  38         void *buf;
  39         loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
  40
  41         buf = vmalloc(len);
  42         if (!buf)
  43                 return;
  44         err = mtd_read(ubi->mtd, addr, len, &read, buf);
  45         if (err && err != -EUCLEAN) {
  46                 ubi_err("error %d while reading %d bytes from PEB %d:%d, "
  47                         "read %zd bytes", err, len, pnum, offset, read);
  48                 goto out;
  49         }
  50
  51         ubi_msg("dumping %d bytes of data from PEB %d, offset %d",
  52                 len, pnum, offset);
  53         print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
  54 out:
  55         vfree(buf);
  56         return;
  57 }
  58
  59 /**
  60  * ubi_dump_ec_hdr - dump an erase counter header.
  61  * @ec_hdr: the erase counter header to dump
  62  */
  63 void ubi_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr)
  64 {
  65         printk(KERN_DEBUG "Erase counter header dump:\n");
  66         printk(KERN_DEBUG "\tmagic          %#08x\n",
  67                be32_to_cpu(ec_hdr->magic));
  68         printk(KERN_DEBUG "\tversion        %d\n", (int)ec_hdr->version);
  69         printk(KERN_DEBUG "\tec             %llu\n",
  70                (long long)be64_to_cpu(ec_hdr->ec));
  71         printk(KERN_DEBUG "\tvid_hdr_offset %d\n",
  72                be32_to_cpu(ec_hdr->vid_hdr_offset));
  73         printk(KERN_DEBUG "\tdata_offset    %d\n",
  74                be32_to_cpu(ec_hdr->data_offset));
  75         printk(KERN_DEBUG "\timage_seq      %d\n",
  76                be32_to_cpu(ec_hdr->image_seq));
  77         printk(KERN_DEBUG "\thdr_crc        %#08x\n",
  78                be32_to_cpu(ec_hdr->hdr_crc));
  79         printk(KERN_DEBUG "erase counter header hexdump:\n");
  80         print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
  81                        ec_hdr, UBI_EC_HDR_SIZE, 1);
  82 }
  83
  84 /**
  85  * ubi_dump_vid_hdr - dump a volume identifier header.
  86  * @vid_hdr: the volume identifier header to dump
  87  */
  88 void ubi_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr)
  89 {
  90         printk(KERN_DEBUG "Volume identifier header dump:\n");
  91         printk(KERN_DEBUG "\tmagic     %08x\n", be32_to_cpu(vid_hdr->magic));
  92         printk(KERN_DEBUG "\tversion   %d\n",  (int)vid_hdr->version);
  93         printk(KERN_DEBUG "\tvol_type  %d\n",  (int)vid_hdr->vol_type);
  94         printk(KERN_DEBUG "\tcopy_flag %d\n",  (int)vid_hdr->copy_flag);
  95         printk(KERN_DEBUG "\tcompat    %d\n",  (int)vid_hdr->compat);
  96         printk(KERN_DEBUG "\tvol_id    %d\n",  be32_to_cpu(vid_hdr->vol_id));
  97         printk(KERN_DEBUG "\tlnum      %d\n",  be32_to_cpu(vid_hdr->lnum));
  98         printk(KERN_DEBUG "\tdata_size %d\n",  be32_to_cpu(vid_hdr->data_size));
  99         printk(KERN_DEBUG "\tused_ebs  %d\n",  be32_to_cpu(vid_hdr->used_ebs));
 100         printk(KERN_DEBUG "\tdata_pad  %d\n",  be32_to_cpu(vid_hdr->data_pad));
 101         printk(KERN_DEBUG "\tsqnum     %llu\n",
 102                 (unsigned long long)be64_to_cpu(vid_hdr->sqnum));
 103         printk(KERN_DEBUG "\thdr_crc   %08x\n", be32_to_cpu(vid_hdr->hdr_crc));
 104         printk(KERN_DEBUG "Volume identifier header hexdump:\n");
 105         print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
 106                        vid_hdr, UBI_VID_HDR_SIZE, 1);
 107 }
 108
 109 /**
 110  * ubi_dump_vol_info - dump volume information.
 111  * @vol: UBI volume description object
 112  */
 113 void ubi_dump_vol_info(const struct ubi_volume *vol)
 114 {
 115         printk(KERN_DEBUG "Volume information dump:\n");
 116         printk(KERN_DEBUG "\tvol_id          %d\n", vol->vol_id);
 117         printk(KERN_DEBUG "\treserved_pebs   %d\n", vol->reserved_pebs);
 118         printk(KERN_DEBUG "\talignment       %d\n", vol->alignment);
 119         printk(KERN_DEBUG "\tdata_pad        %d\n", vol->data_pad);
 120         printk(KERN_DEBUG "\tvol_type        %d\n", vol->vol_type);
 121         printk(KERN_DEBUG "\tname_len        %d\n", vol->name_len);
 122         printk(KERN_DEBUG "\tusable_leb_size %d\n", vol->usable_leb_size);
 123         printk(KERN_DEBUG "\tused_ebs        %d\n", vol->used_ebs);
 124         printk(KERN_DEBUG "\tused_bytes      %lld\n", vol->used_bytes);
 125         printk(KERN_DEBUG "\tlast_eb_bytes   %d\n", vol->last_eb_bytes);
 126         printk(KERN_DEBUG "\tcorrupted       %d\n", vol->corrupted);
 127         printk(KERN_DEBUG "\tupd_marker      %d\n", vol->upd_marker);
 128
 129         if (vol->name_len <= UBI_VOL_NAME_MAX &&
 130             strnlen(vol->name, vol->name_len + 1) == vol->name_len) {
 131                 printk(KERN_DEBUG "\tname            %s\n", vol->name);
 132         } else {
 133                 printk(KERN_DEBUG "\t1st 5 characters of name: %c%c%c%c%c\n",
 134                        vol->name[0], vol->name[1], vol->name[2],
 135                        vol->name[3], vol->name[4]);
 136         }
 137 }
 138
 139 /**
 140  * ubi_dump_vtbl_record - dump a &struct ubi_vtbl_record object.
 141  * @r: the object to dump
 142  * @idx: volume table index
 143  */
 144 void ubi_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx)
 145 {
 146         int name_len = be16_to_cpu(r->name_len);
 147
 148         printk(KERN_DEBUG "Volume table record %d dump:\n", idx);
 149         printk(KERN_DEBUG "\treserved_pebs   %d\n",
 150                be32_to_cpu(r->reserved_pebs));
 151         printk(KERN_DEBUG "\talignment       %d\n", be32_to_cpu(r->alignment));
 152         printk(KERN_DEBUG "\tdata_pad        %d\n", be32_to_cpu(r->data_pad));
 153         printk(KERN_DEBUG "\tvol_type        %d\n", (int)r->vol_type);
 154         printk(KERN_DEBUG "\tupd_marker      %d\n", (int)r->upd_marker);
 155         printk(KERN_DEBUG "\tname_len        %d\n", name_len);
 156
 157         if (r->name[0] == '\0') {
 158                 printk(KERN_DEBUG "\tname            NULL\n");
 159                 return;
 160         }
 161
 162         if (name_len <= UBI_VOL_NAME_MAX &&
 163             strnlen(&r->name[0], name_len + 1) == name_len) {
 164                 printk(KERN_DEBUG "\tname            %s\n", &r->name[0]);
 165         } else {
 166                 printk(KERN_DEBUG "\t1st 5 characters of name: %c%c%c%c%c\n",
 167                         r->name[0], r->name[1], r->name[2], r->name[3],
 168                         r->name[4]);
 169         }
 170         printk(KERN_DEBUG "\tcrc             %#08x\n", be32_to_cpu(r->crc));
 171 }
 172
 173 /**
 174  * ubi_dump_av - dump a &struct ubi_ainf_volume object.
 175  * @av: the object to dump
 176  */
 177 void ubi_dump_av(const struct ubi_ainf_volume *av)
 178 {
 179         printk(KERN_DEBUG "Volume attaching information dump:\n");
 180         printk(KERN_DEBUG "\tvol_id         %d\n", av->vol_id);
 181         printk(KERN_DEBUG "\thighest_lnum   %d\n", av->highest_lnum);
 182         printk(KERN_DEBUG "\tleb_count      %d\n", av->leb_count);
 183         printk(KERN_DEBUG "\tcompat         %d\n", av->compat);
 184         printk(KERN_DEBUG "\tvol_type       %d\n", av->vol_type);
 185         printk(KERN_DEBUG "\tused_ebs       %d\n", av->used_ebs);
 186         printk(KERN_DEBUG "\tlast_data_size %d\n", av->last_data_size);
 187         printk(KERN_DEBUG "\tdata_pad       %d\n", av->data_pad);
 188 }
 189
 190 /**
 191  * ubi_dump_aeb - dump a &struct ubi_ainf_peb object.
 192  * @aeb: the object to dump
 193  * @type: object type: 0 - not corrupted, 1 - corrupted
 194  */
 195 void ubi_dump_aeb(const struct ubi_ainf_peb *aeb, int type)
 196 {
 197         printk(KERN_DEBUG "eraseblock attaching information dump:\n");
 198         printk(KERN_DEBUG "\tec       %d\n", aeb->ec);
 199         printk(KERN_DEBUG "\tpnum     %d\n", aeb->pnum);
 200         if (type == 0) {
 201                 printk(KERN_DEBUG "\tlnum     %d\n", aeb->lnum);
 202                 printk(KERN_DEBUG "\tscrub    %d\n", aeb->scrub);
 203                 printk(KERN_DEBUG "\tsqnum    %llu\n", aeb->sqnum);
 204         }
 205 }
 206
 207 /**
 208  * ubi_dump_mkvol_req - dump a &struct ubi_mkvol_req object.
 209  * @req: the object to dump
 210  */
 211 void ubi_dump_mkvol_req(const struct ubi_mkvol_req *req)
 212 {
 213         char nm[17];
 214
 215         printk(KERN_DEBUG "Volume creation request dump:\n");
 216         printk(KERN_DEBUG "\tvol_id    %d\n",   req->vol_id);
 217         printk(KERN_DEBUG "\talignment %d\n",   req->alignment);
 218         printk(KERN_DEBUG "\tbytes     %lld\n", (long long)req->bytes);
 219         printk(KERN_DEBUG "\tvol_type  %d\n",   req->vol_type);
 220         printk(KERN_DEBUG "\tname_len  %d\n",   req->name_len);
 221
 222         memcpy(nm, req->name, 16);
 223         nm[16] = 0;
 224         printk(KERN_DEBUG "\t1st 16 characters of name: %s\n", nm);
 225 }
 226
 227 /**
 228  * ubi_debugging_init_dev - initialize debugging for an UBI device.
 229  * @ubi: UBI device description object
 230  *
 231  * This function initializes debugging-related data for UBI device @ubi.
 232  * Returns zero in case of success and a negative error code in case of
 233  * failure.
 234  */
 235 int ubi_debugging_init_dev(struct ubi_device *ubi)
 236 {
 237         ubi->dbg = kzalloc(sizeof(struct ubi_debug_info), GFP_KERNEL);
 238         if (!ubi->dbg)
 239                 return -ENOMEM;
 240
 241         return 0;
 242 }
 243
 244 /**
 245  * ubi_debugging_exit_dev - free debugging data for an UBI device.
 246  * @ubi: UBI device description object
 247  */
 248 void ubi_debugging_exit_dev(struct ubi_device *ubi)
 249 {
 250         kfree(ubi->dbg);
 251 }
 252
 253 /*
 254  * Root directory for UBI stuff in debugfs. Contains sub-directories which
 255  * contain the stuff specific to particular UBI devices.
 256  */
 257 static struct dentry *dfs_rootdir;
 258
 259 /**
 260  * ubi_debugfs_init - create UBI debugfs directory.
 261  *
 262  * Create UBI debugfs directory. Returns zero in case of success and a negative
 263  * error code in case of failure.
 264  */
 265 int ubi_debugfs_init(void)
 266 {
 267         if (!IS_ENABLED(CONFIG_DEBUG_FS))
 268                 return 0;
 269
 270         dfs_rootdir = debugfs_create_dir("ubi", NULL);
 271         if (IS_ERR_OR_NULL(dfs_rootdir)) {
 272                 int err = dfs_rootdir ? -ENODEV : PTR_ERR(dfs_rootdir);
 273
 274                 ubi_err("cannot create \"ubi\" debugfs directory, error %d\n",
 275                         err);
 276                 return err;
 277         }
 278
 279         return 0;
 280 }
 281
 282 /**
 283  * ubi_debugfs_exit - remove UBI debugfs directory.
 284  */
 285 void ubi_debugfs_exit(void)
 286 {
 287         if (IS_ENABLED(CONFIG_DEBUG_FS))
 288                 debugfs_remove(dfs_rootdir);
 289 }
 290
 291 /* Read an UBI debugfs file */
 292 static ssize_t dfs_file_read(struct file *file, char __user *user_buf,
 293                              size_t count, loff_t *ppos)
 294 {
 295         unsigned long ubi_num = (unsigned long)file->private_data;
 296         struct dentry *dent = file->f_path.dentry;
 297         struct ubi_device *ubi;
 298         struct ubi_debug_info *d;
 299         char buf[3];
 300         int val;
 301
 302         ubi = ubi_get_device(ubi_num);
 303         if (!ubi)
 304                 return -ENODEV;
 305         d = ubi->dbg;
 306
 307         if (dent == d->dfs_chk_gen)
 308                 val = d->chk_gen;
 309         else if (dent == d->dfs_chk_io)
 310                 val = d->chk_io;
 311         else if (dent == d->dfs_disable_bgt)
 312                 val = d->disable_bgt;
 313         else if (dent == d->dfs_emulate_bitflips)
 314                 val = d->emulate_bitflips;
 315         else if (dent == d->dfs_emulate_io_failures)
 316                 val = d->emulate_io_failures;
 317         else {
 318                 count = -EINVAL;
 319                 goto out;
 320         }
 321
 322         if (val)
 323                 buf[0] = '1';
 324         else
 325                 buf[0] = '0';
 326         buf[1] = '\n';
 327         buf[2] = 0x00;
 328
 329         count = simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 330
 331 out:
 332         ubi_put_device(ubi);
 333         return count;
 334 }
 335
 336 /* Write an UBI debugfs file */
 337 static ssize_t dfs_file_write(struct file *file, const char __user *user_buf,
 338                               size_t count, loff_t *ppos)
 339 {
 340         unsigned long ubi_num = (unsigned long)file->private_data;
 341         struct dentry *dent = file->f_path.dentry;
 342         struct ubi_device *ubi;
 343         struct ubi_debug_info *d;
 344         size_t buf_size;
 345         char buf[8];
 346         int val;
 347
 348         ubi = ubi_get_device(ubi_num);
 349         if (!ubi)
 350                 return -ENODEV;
 351         d = ubi->dbg;
 352
 353         buf_size = min_t(size_t, count, (sizeof(buf) - 1));
 354         if (copy_from_user(buf, user_buf, buf_size)) {
 355                 count = -EFAULT;
 356                 goto out;
 357         }
 358
 359         if (buf[0] == '1')
 360                 val = 1;
 361         else if (buf[0] == '0')
 362                 val = 0;
 363         else {
 364                 count = -EINVAL;
 365                 goto out;
 366         }
 367
 368         if (dent == d->dfs_chk_gen)
 369                 d->chk_gen = val;
 370         else if (dent == d->dfs_chk_io)
 371                 d->chk_io = val;
 372         else if (dent == d->dfs_disable_bgt)
 373                 d->disable_bgt = val;
 374         else if (dent == d->dfs_emulate_bitflips)
 375                 d->emulate_bitflips = val;
 376         else if (dent == d->dfs_emulate_io_failures)
 377                 d->emulate_io_failures = val;
 378         else
 379                 count = -EINVAL;
 380
 381 out:
 382         ubi_put_device(ubi);
 383         return count;
 384 }
 385
 386 /* File operations for all UBI debugfs files */
 387 static const struct file_operations dfs_fops = {
 388         .read   = dfs_file_read,
 389         .write  = dfs_file_write,
 390         .open   = simple_open,
 391         .llseek = no_llseek,
 392         .owner  = THIS_MODULE,
 393 };
 394
 395 /**
 396  * ubi_debugfs_init_dev - initialize debugfs for an UBI device.
 397  * @ubi: UBI device description object
 398  *
 399  * This function creates all debugfs files for UBI device @ubi. Returns zero in
 400  * case of success and a negative error code in case of failure.
 401  */
 402 int ubi_debugfs_init_dev(struct ubi_device *ubi)
 403 {
 404         int err, n;
 405         unsigned long ubi_num = ubi->ubi_num;
 406         const char *fname;
 407         struct dentry *dent;
 408         struct ubi_debug_info *d = ubi->dbg;
 409
 410         if (!IS_ENABLED(CONFIG_DEBUG_FS))
 411                 return 0;
 412
 413         n = snprintf(d->dfs_dir_name, UBI_DFS_DIR_LEN + 1, UBI_DFS_DIR_NAME,
 414                      ubi->ubi_num);
 415         if (n == UBI_DFS_DIR_LEN) {
 416                 /* The array size is too small */
 417                 fname = UBI_DFS_DIR_NAME;
 418                 dent = ERR_PTR(-EINVAL);
 419                 goto out;
 420         }
 421
 422         fname = d->dfs_dir_name;
 423         dent = debugfs_create_dir(fname, dfs_rootdir);
 424         if (IS_ERR_OR_NULL(dent))
 425                 goto out;
 426         d->dfs_dir = dent;
 427
 428         fname = "chk_gen";
 429         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 430                                    &dfs_fops);
 431         if (IS_ERR_OR_NULL(dent))
 432                 goto out_remove;
 433         d->dfs_chk_gen = dent;
 434
 435         fname = "chk_io";
 436         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 437                                    &dfs_fops);
 438         if (IS_ERR_OR_NULL(dent))
 439                 goto out_remove;
 440         d->dfs_chk_io = dent;
 441
 442         fname = "tst_disable_bgt";
 443         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 444                                    &dfs_fops);
 445         if (IS_ERR_OR_NULL(dent))
 446                 goto out_remove;
 447         d->dfs_disable_bgt = dent;
 448
 449         fname = "tst_emulate_bitflips";
 450         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 451                                    &dfs_fops);
 452         if (IS_ERR_OR_NULL(dent))
 453                 goto out_remove;
 454         d->dfs_emulate_bitflips = dent;
 455
 456         fname = "tst_emulate_io_failures";
 457         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 458                                    &dfs_fops);
 459         if (IS_ERR_OR_NULL(dent))
 460                 goto out_remove;
 461         d->dfs_emulate_io_failures = dent;
 462
 463         return 0;
 464
 465 out_remove:
 466         debugfs_remove_recursive(d->dfs_dir);
 467 out:
 468         err = dent ? PTR_ERR(dent) : -ENODEV;
 469         ubi_err("cannot create \"%s\" debugfs file or directory, error %d\n",
 470                 fname, err);
 471         return err;
 472 }
 473
 474 /**
 475  * dbg_debug_exit_dev - free all debugfs files corresponding to device @ubi
 476  * @ubi: UBI device description object
 477  */
 478 void ubi_debugfs_exit_dev(struct ubi_device *ubi)
 479 {
 480         if (IS_ENABLED(CONFIG_DEBUG_FS))
 481                 debugfs_remove_recursive(ubi->dbg->dfs_dir);
 482 }