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 = ubi->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_sv - dump a &struct ubi_ainf_volume object.
 175  * @sv: the object to dump
 176  */
 177 void ubi_dump_sv(const struct ubi_ainf_volume *sv)
 178 {
 179         printk(KERN_DEBUG "Volume scanning information dump:\n");
 180         printk(KERN_DEBUG "\tvol_id         %d\n", sv->vol_id);
 181         printk(KERN_DEBUG "\thighest_lnum   %d\n", sv->highest_lnum);
 182         printk(KERN_DEBUG "\tleb_count      %d\n", sv->leb_count);
 183         printk(KERN_DEBUG "\tcompat         %d\n", sv->compat);
 184         printk(KERN_DEBUG "\tvol_type       %d\n", sv->vol_type);
 185         printk(KERN_DEBUG "\tused_ebs       %d\n", sv->used_ebs);
 186         printk(KERN_DEBUG "\tlast_data_size %d\n", sv->last_data_size);
 187         printk(KERN_DEBUG "\tdata_pad       %d\n", sv->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 scanning 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         dfs_rootdir = debugfs_create_dir("ubi", NULL);
 268         if (IS_ERR_OR_NULL(dfs_rootdir)) {
 269                 int err = dfs_rootdir ? -ENODEV : PTR_ERR(dfs_rootdir);
 270
 271                 ubi_err("cannot create \"ubi\" debugfs directory, error %d\n",
 272                         err);
 273                 return err;
 274         }
 275
 276         return 0;
 277 }
 278
 279 /**
 280  * ubi_debugfs_exit - remove UBI debugfs directory.
 281  */
 282 void ubi_debugfs_exit(void)
 283 {
 284         debugfs_remove(dfs_rootdir);
 285 }
 286
 287 /* Read an UBI debugfs file */
 288 static ssize_t dfs_file_read(struct file *file, char __user *user_buf,
 289                              size_t count, loff_t *ppos)
 290 {
 291         unsigned long ubi_num = (unsigned long)file->private_data;
 292         struct dentry *dent = file->f_path.dentry;
 293         struct ubi_device *ubi;
 294         struct ubi_debug_info *d;
 295         char buf[3];
 296         int val;
 297
 298         ubi = ubi_get_device(ubi_num);
 299         if (!ubi)
 300                 return -ENODEV;
 301         d = ubi->dbg;
 302
 303         if (dent == d->dfs_chk_gen)
 304                 val = d->chk_gen;
 305         else if (dent == d->dfs_chk_io)
 306                 val = d->chk_io;
 307         else if (dent == d->dfs_disable_bgt)
 308                 val = d->disable_bgt;
 309         else if (dent == d->dfs_emulate_bitflips)
 310                 val = d->emulate_bitflips;
 311         else if (dent == d->dfs_emulate_io_failures)
 312                 val = d->emulate_io_failures;
 313         else {
 314                 count = -EINVAL;
 315                 goto out;
 316         }
 317
 318         if (val)
 319                 buf[0] = '1';
 320         else
 321                 buf[0] = '0';
 322         buf[1] = '\n';
 323         buf[2] = 0x00;
 324
 325         count = simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 326
 327 out:
 328         ubi_put_device(ubi);
 329         return count;
 330 }
 331
 332 /* Write an UBI debugfs file */
 333 static ssize_t dfs_file_write(struct file *file, const char __user *user_buf,
 334                               size_t count, loff_t *ppos)
 335 {
 336         unsigned long ubi_num = (unsigned long)file->private_data;
 337         struct dentry *dent = file->f_path.dentry;
 338         struct ubi_device *ubi;
 339         struct ubi_debug_info *d;
 340         size_t buf_size;
 341         char buf[8];
 342         int val;
 343
 344         ubi = ubi_get_device(ubi_num);
 345         if (!ubi)
 346                 return -ENODEV;
 347         d = ubi->dbg;
 348
 349         buf_size = min_t(size_t, count, (sizeof(buf) - 1));
 350         if (copy_from_user(buf, user_buf, buf_size)) {
 351                 count = -EFAULT;
 352                 goto out;
 353         }
 354
 355         if (buf[0] == '1')
 356                 val = 1;
 357         else if (buf[0] == '0')
 358                 val = 0;
 359         else {
 360                 count = -EINVAL;
 361                 goto out;
 362         }
 363
 364         if (dent == d->dfs_chk_gen)
 365                 d->chk_gen = val;
 366         else if (dent == d->dfs_chk_io)
 367                 d->chk_io = val;
 368         else if (dent == d->dfs_disable_bgt)
 369                 d->disable_bgt = val;
 370         else if (dent == d->dfs_emulate_bitflips)
 371                 d->emulate_bitflips = val;
 372         else if (dent == d->dfs_emulate_io_failures)
 373                 d->emulate_io_failures = val;
 374         else
 375                 count = -EINVAL;
 376
 377 out:
 378         ubi_put_device(ubi);
 379         return count;
 380 }
 381
 382 static int default_open(struct inode *inode, struct file *file)
 383 {
 384         if (inode->i_private)
 385                 file->private_data = inode->i_private;
 386
 387         return 0;
 388 }
 389
 390 /* File operations for all UBI debugfs files */
 391 static const struct file_operations dfs_fops = {
 392         .read   = dfs_file_read,
 393         .write  = dfs_file_write,
 394         .open   = default_open,
 395         .llseek = no_llseek,
 396         .owner  = THIS_MODULE,
 397 };
 398
 399 /**
 400  * ubi_debugfs_init_dev - initialize debugfs for an UBI device.
 401  * @ubi: UBI device description object
 402  *
 403  * This function creates all debugfs files for UBI device @ubi. Returns zero in
 404  * case of success and a negative error code in case of failure.
 405  */
 406 int ubi_debugfs_init_dev(struct ubi_device *ubi)
 407 {
 408         int err, n;
 409         unsigned long ubi_num = ubi->ubi_num;
 410         const char *fname;
 411         struct dentry *dent;
 412         struct ubi_debug_info *d = ubi->dbg;
 413
 414         n = snprintf(d->dfs_dir_name, UBI_DFS_DIR_LEN + 1, UBI_DFS_DIR_NAME,
 415                      ubi->ubi_num);
 416         if (n == UBI_DFS_DIR_LEN) {
 417                 /* The array size is too small */
 418                 fname = UBI_DFS_DIR_NAME;
 419                 dent = ERR_PTR(-EINVAL);
 420                 goto out;
 421         }
 422
 423         fname = d->dfs_dir_name;
 424         dent = debugfs_create_dir(fname, dfs_rootdir);
 425         if (IS_ERR_OR_NULL(dent))
 426                 goto out;
 427         d->dfs_dir = dent;
 428
 429         fname = "chk_gen";
 430         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 431                                    &dfs_fops);
 432         if (IS_ERR_OR_NULL(dent))
 433                 goto out_remove;
 434         d->dfs_chk_gen = dent;
 435
 436         fname = "chk_io";
 437         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 438                                    &dfs_fops);
 439         if (IS_ERR_OR_NULL(dent))
 440                 goto out_remove;
 441         d->dfs_chk_io = dent;
 442
 443         fname = "tst_disable_bgt";
 444         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 445                                    &dfs_fops);
 446         if (IS_ERR_OR_NULL(dent))
 447                 goto out_remove;
 448         d->dfs_disable_bgt = dent;
 449
 450         fname = "tst_emulate_bitflips";
 451         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 452                                    &dfs_fops);
 453         if (IS_ERR_OR_NULL(dent))
 454                 goto out_remove;
 455         d->dfs_emulate_bitflips = dent;
 456
 457         fname = "tst_emulate_io_failures";
 458         dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,
 459                                    &dfs_fops);
 460         if (IS_ERR_OR_NULL(dent))
 461                 goto out_remove;
 462         d->dfs_emulate_io_failures = dent;
 463
 464         return 0;
 465
 466 out_remove:
 467         debugfs_remove_recursive(d->dfs_dir);
 468 out:
 469         err = dent ? PTR_ERR(dent) : -ENODEV;
 470         ubi_err("cannot create \"%s\" debugfs file or directory, error %d\n",
 471                 fname, err);
 472         return err;
 473 }
 474
 475 /**
 476  * dbg_debug_exit_dev - free all debugfs files corresponding to device @ubi
 477  * @ubi: UBI device description object
 478  */
 479 void ubi_debugfs_exit_dev(struct ubi_device *ubi)
 480 {
 481         debugfs_remove_recursive(ubi->dbg->dfs_dir);
 482 }