/* * Copyright (C) 2008 Nokia Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See * the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* * An utility to format MTD devices into UBI and flash UBI images. * * Author: Artem Bityutskiy */ #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> #include <stdint.h> #include <stdlib.h> #include <getopt.h> #include <fcntl.h> #include <libubi.h> #include <libmtd.h> #include <libscan.h> #include <libubigen.h> #include <mtd_swab.h> #include "crc32.h" #include "common.h" #define PROGRAM_VERSION "1.0" #define PROGRAM_NAME "ubiformat" /* The variables below are set by command line arguments */ struct args { unsigned int yes:1; unsigned int quiet:1; unsigned int verbose:1; unsigned int override_ec:1; unsigned int novtbl:1; int subpage_size; int vid_hdr_offs; int ubi_ver; off_t image_sz; long long ec; const char *image; const char *node; }; static struct args args = { .ubi_ver = 1, }; static const char *doc = PROGRAM_NAME " version " PROGRAM_VERSION " - a tool to format MTD devices and flash UBI images"; static const char *optionsstr = "-s, --sub-page-size=<bytes> minimum input/output unit used for UBI\n" " headers, e.g. sub-page size in case of NAND\n" " flash (equivalent to the minimum input/output\n" " unit size by default)\n" "-O, --vid-hdr-offset=<offs> offset if the VID header from start of the\n" " physical eraseblock (default is the next\n" " minimum I/O unit or sub-page after the EC\n" " header)\n" "-n, --no-volume-table only erase all eraseblock and preserve erase\n" " counters, do not write empty volume table\n" "-f, --flash-image=<file> flash image file, or '-' for stdin\n" "-S, --image-size=<bytes> bytes in input, if not reading from file\n" "-e, --erase-counter=<value> use <value> as the erase counter value for all\n" " eraseblocks\n" "-y, --yes assume the answer is \"yes\" for all question\n" " this program would otherwise ask\n" "-q, --quiet suppress progress percentage information\n" "-v, --verbose be verbose\n" "-x, --ubi-ver=<num> UBI version number to put to EC headers\n" " (default is 1)\n" "-h, -?, --help print help message\n" "-V, --version print program version\n"; static const char *usage = "Usage: " PROGRAM_NAME " <MTD device node file name> [-h] [-V] [-y] [-q] [-v]\n" "\t\t\t[-x <num>] [-E <value>] [-s <bytes>] [-O <offs>] [-n]\n" "\t\t\t[--help] [--version] [--yes] [--verbose] [--quiet]\n" "\t\t\t[--ec=<value>] [--vid-hdr-offset=<offs>]\n" "\t\t\t[--ubi-ver=<num>] [--no-volume-table]\n" "\t\t\t[--flash-image=<file>] [--image-size=<bytes>]\n\n" "Example 1: " PROGRAM_NAME " /dev/mtd0 -y - format MTD device number 0 and do\n" " not ask questions.\n" "Example 2: " PROGRAM_NAME " /dev/mtd0 -q -e 0 - format MTD device number 0,\n" " be quiet and force erase counter value 0."; static const struct option long_options[] = { { .name = "sub-page-size", .has_arg = 1, .flag = NULL, .val = 's' }, { .name = "vid-hdr-offset", .has_arg = 1, .flag = NULL, .val = 'O' }, { .name = "no-volume-table", .has_arg = 0, .flag = NULL, .val = 'n' }, { .name = "flash-image", .has_arg = 1, .flag = NULL, .val = 'f' }, { .name = "image-size", .has_arg = 1, .flag = NULL, .val = 'S' }, { .name = "yes", .has_arg = 0, .flag = NULL, .val = 'y' }, { .name = "erase-counter", .has_arg = 1, .flag = NULL, .val = 'e' }, { .name = "quiet", .has_arg = 0, .flag = NULL, .val = 'q' }, { .name = "verbose", .has_arg = 0, .flag = NULL, .val = 'v' }, { .name = "ubi-ver", .has_arg = 1, .flag = NULL, .val = 'x' }, { .name = "help", .has_arg = 0, .flag = NULL, .val = 'h' }, { .name = "version", .has_arg = 0, .flag = NULL, .val = 'V' }, { NULL, 0, NULL, 0}, }; static int parse_opt(int argc, char * const argv[]) { while (1) { int key; char *endp; key = getopt_long(argc, argv, "nh?Vyqve:x:s:O:f:S:", long_options, NULL); if (key == -1) break; switch (key) { case 's': args.subpage_size = ubiutils_get_bytes(optarg); if (args.subpage_size <= 0) return errmsg("bad sub-page size: \"%s\"", optarg); if (!is_power_of_2(args.subpage_size)) return errmsg("sub-page size should be power of 2"); break; case 'O': args.vid_hdr_offs = strtoul(optarg, &endp, 0); if (args.vid_hdr_offs <= 0 || *endp != '\0' || endp == optarg) return errmsg("bad VID header offset: \"%s\"", optarg); break; case 'e': args.ec = strtoull(optarg, &endp, 0); if (args.ec <= 0 || *endp != '\0' || endp == optarg) return errmsg("bad erase counter value: \"%s\"", optarg); if (args.ec >= EC_MAX) return errmsg("too high erase %llu, counter, max is %u", args.ec, EC_MAX); args.override_ec = 1; break; case 'f': args.image = optarg; break; case 'S': args.image_sz = ubiutils_get_bytes(optarg); if (args.image_sz <= 0) return errmsg("bad image-size: \"%s\"", optarg); break; case 'n': args.novtbl = 1; break; case 'y': args.yes = 1; break; case 'q': args.quiet = 1; break; case 'x': args.ubi_ver = strtoul(optarg, &endp, 0); if (args.ubi_ver < 0 || *endp != '\0' || endp == optarg) return errmsg("bad UBI version: \"%s\"", optarg); break; case 'v': args.verbose = 1; break; case 'V': fprintf(stderr, "%s\n", PROGRAM_VERSION); exit(EXIT_SUCCESS); case 'h': case '?': fprintf(stderr, "%s\n\n", doc); fprintf(stderr, "%s\n\n", usage); fprintf(stderr, "%s\n", optionsstr); exit(EXIT_SUCCESS); case ':': return errmsg("parameter is missing"); default: fprintf(stderr, "Use -h for help\n"); return -1; } } if (args.quiet && args.verbose) return errmsg("using \"-q\" and \"-v\" at the same time does not make sense"); if (optind == argc) return errmsg("MTD device name was not specified (use -h for help)"); else if (optind != argc - 1) return errmsg("more then one MTD device specified (use -h for help)"); if (args.image && args.novtbl) return errmsg("-n cannot be used together with -f"); args.node = argv[optind]; return 0; } static int want_exit(void) { char buf[4]; while (1) { normsg_cont("continue? (yes/no) "); scanf("%3s", buf); if (!strncmp(buf, "yes", 3) || !strncmp(buf, "y", 1)) return 0; if (!strncmp(buf, "no", 2) || !strncmp(buf, "n", 1)) return 1; } } static int answer_is_yes(void) { char buf[4]; while (1) { scanf("%3s", buf); if (!strncmp(buf, "yes", 3) || !strncmp(buf, "y", 1)) return 1; if (!strncmp(buf, "no", 2) || !strncmp(buf, "n", 1)) return 0; } } static void print_bad_eraseblocks(const struct mtd_info *mtd, const struct ubi_scan_info *si) { int first = 1, eb; if (si->bad_cnt == 0) return; normsg_cont("bad eraseblocks: "); for (eb = 0; eb < mtd->eb_cnt; eb++) { if (si->ec[eb] != EB_BAD) continue; if (first) { printf("%d", eb); first = 0; } else printf(", %d", eb); } printf("\n"); } static int change_ec(struct ubi_ec_hdr *hdr, long long ec) { uint32_t crc; /* Check the EC header */ if (be32_to_cpu(hdr->magic) != UBI_EC_HDR_MAGIC) return errmsg("bad UBI magic %#08x, should be %#08x", be32_to_cpu(hdr->magic), UBI_EC_HDR_MAGIC); crc = crc32(UBI_CRC32_INIT, hdr, UBI_EC_HDR_SIZE_CRC); if (be32_to_cpu(hdr->hdr_crc) != crc) return errmsg("bad CRC %#08x, should be %#08x\n", crc, be32_to_cpu(hdr->hdr_crc)); hdr->ec = cpu_to_be64(ec); crc = crc32(UBI_CRC32_INIT, hdr, UBI_EC_HDR_SIZE_CRC); hdr->hdr_crc = cpu_to_be32(crc); return 0; } static int drop_ffs(const struct mtd_info *mtd, const void *buf, int len) { int i; for (i = len - 1; i >= 0; i--) if (((const uint8_t *)buf)[i] != 0xFF) break; /* The resulting length must be aligned to the minimum flash I/O size */ len = i + 1; len = (len + mtd->min_io_size - 1) / mtd->min_io_size; len *= mtd->min_io_size; return len; } static int open_file(const struct mtd_info *mtd, struct ubi_scan_info *si, off_t *sz) { int fd; if (!strcmp(args.image, "-")) { if (args.image_sz == 0) return errmsg("must use '-S' with non-zero value when reading from stdin"); *sz = args.image_sz; fd = dup(STDIN_FILENO); if (fd < 0) return sys_errmsg("failed to dup stdin"); } else { struct stat st; if (stat(args.image, &st)) return sys_errmsg("cannot open \"%s\"", args.image); *sz = st.st_size; fd = open(args.image, O_RDONLY); if (fd == -1) return sys_errmsg("cannot open \"%s\"", args.image); } return fd; } static int read_all(int fd, void *buf, size_t len) { while (len > 0) { ssize_t l = read(fd, buf, len); if (l == 0) return errmsg("eof reached; %d bytes remaining", len); else if (l > 0) { buf += l; len -= l; } else if (errno == EINTR || errno == EAGAIN) continue; else return sys_errmsg("reading failed; %d bytes remaining", len); } return 0; } static int flash_image(const struct mtd_info *mtd, const struct ubigen_info *ui, struct ubi_scan_info *si) { int fd, img_ebs, eb, written_ebs = 0, divisor; off_t st_size; fd = open_file(mtd, si, &st_size); if (fd < 0) return fd; img_ebs = st_size / mtd->eb_size; if (img_ebs > si->good_cnt) { sys_errmsg("file \"%s\" is too large (%lld bytes)", args.image, (long long)st_size); goto out_close; } if (st_size % mtd->eb_size) { return sys_errmsg("file \"%s\" (size %lld bytes) is not multiple of eraseblock size (%d bytes)", args.image, (long long)st_size, mtd->eb_size); goto out_close; } verbose(args.verbose, "will write %d eraseblocks", img_ebs); divisor = img_ebs; for (eb = 0; eb < mtd->eb_cnt; eb++) { int err, new_len; char buf[mtd->eb_size]; long long ec; if (!args.quiet && !args.verbose) { printf("\r" PROGRAM_NAME ": flashing eraseblock %d -- %2lld %% complete ", eb, (long long)(eb + 1) * 100 / divisor); fflush(stdout); } if (si->ec[eb] == EB_BAD) { divisor += 1; continue; } if (args.verbose) { normsg_cont("eraseblock %d: erase", eb); fflush(stdout); } err = mtd_erase(mtd, eb); if (err) { sys_errmsg("failed to erase eraseblock %d", eb); goto out_close; } err = read_all(fd, buf, mtd->eb_size); if (err) { sys_errmsg("failed to read eraseblock %d from \"%s\"", written_ebs, args.image); goto out_close; } if (si->ec[eb] <= EC_MAX) ec = si->ec[eb] + 1; else if (!args.override_ec) ec = si->mean_ec; else ec = args.ec; if (args.verbose) { printf(", change EC to %lld", ec); fflush(stdout); } err = change_ec((struct ubi_ec_hdr *)buf, ec); if (err) { errmsg("bad EC header at eraseblock %d of \"%s\"", written_ebs, args.image); goto out_close; } if (args.verbose) { printf(", write data\n"); fflush(stdout); } new_len = drop_ffs(mtd, buf, mtd->eb_size); err = mtd_write(mtd, eb, 0, buf, new_len); if (err) { sys_errmsg("cannot write eraseblock %d", eb); goto out_close; } if (++written_ebs >= img_ebs) break; } if (!args.quiet && !args.verbose) printf("\n"); close(fd); return eb + 1; out_close: close(fd); return -1; } static int format(const struct mtd_info *mtd, const struct ubigen_info *ui, const struct ubi_scan_info *si, int start_eb, int novtbl) { int eb, err, write_size; struct ubi_ec_hdr *hdr; struct ubi_vtbl_record *vtbl; int eb1 = -1, eb2 = -1; long long ec1 = -1, ec2 = -1; write_size = UBI_EC_HDR_SIZE + mtd->subpage_size - 1; write_size /= mtd->subpage_size; write_size *= mtd->subpage_size; hdr = malloc(write_size); if (!hdr) return sys_errmsg("cannot allocate %d bytes of memory", write_size); memset(hdr, 0xFF, write_size); for (eb = start_eb; eb < mtd->eb_cnt; eb++) { long long ec; if (!args.quiet && !args.verbose) { printf("\r" PROGRAM_NAME ": formatting eraseblock %d -- %2lld %% complete ", eb, (long long)(eb + 1 - start_eb) * 100 / (mtd->eb_cnt - start_eb)); fflush(stdout); } if (si->ec[eb] == EB_BAD) continue; if (si->ec[eb] <= EC_MAX) ec = si->ec[eb] + 1; else if (!args.override_ec) ec = si->mean_ec; else ec = args.ec; ubigen_init_ec_hdr(ui, hdr, ec); if (args.verbose) { normsg_cont("eraseblock %d: erase", eb); fflush(stdout); } err = mtd_erase(mtd, eb); if (err) { sys_errmsg("failed to erase eraseblock %d", eb); goto out_free; } if ((eb1 == -1 || eb2 == -1) && !novtbl) { if (eb1 == -1) { eb1 = eb; ec1 = ec; } else if (eb2 == -1) { eb2 = eb; ec2 = ec; } if (args.verbose) printf(", do not write EC, leave for vtbl\n"); continue; } if (args.verbose) { printf(", write EC %lld\n", ec); fflush(stdout); } err = mtd_write(mtd, eb, 0, hdr, write_size); if (err) { sys_errmsg("cannot write EC header (%d bytes buffer) to eraseblock %d", write_size, eb); if (args.subpage_size != mtd->min_io_size) normsg("may be %d is incorrect?", args.subpage_size); goto out_free; } } if (!args.quiet && !args.verbose) printf("\n"); if (!novtbl) { if (eb1 == -1 || eb2 == -1) { errmsg("no eraseblocks for volume table"); goto out_free; } verbose(args.verbose, "write volume table to eraseblocks %d and %d", eb1, eb2); vtbl = ubigen_create_empty_vtbl(ui); if (!vtbl) goto out_free; err = ubigen_write_layout_vol(ui, eb1, eb2, ec1, ec2, vtbl, mtd->fd); free(vtbl); if (err) { errmsg("cannot write layout volume"); goto out_free; } } free(hdr); return 0; out_free: free(hdr); return -1; } int main(int argc, char * const argv[]) { int err, verbose; struct mtd_info mtd; libubi_t libubi; struct ubigen_info ui; struct ubi_scan_info *si; err = parse_opt(argc, argv); if (err) return -1; err = mtd_get_info(args.node, &mtd); if (err) return errmsg("cannot get information about \"%s\"", args.node); if (args.subpage_size == 0) args.subpage_size = mtd.min_io_size; else { if (args.subpage_size > mtd.min_io_size) { errmsg("sub-page cannot be larger than min. I/O unit"); goto out_close; } if (mtd.min_io_size % args.subpage_size) { errmsg("min. I/O unit size should be multiple of sub-page size"); goto out_close; } } /* Validate VID header offset if it was specified */ if (args.vid_hdr_offs != 0) { if (args.vid_hdr_offs % 8) { errmsg("VID header offset has to be multiple of min. I/O unit size"); goto out_close; } if (args.vid_hdr_offs + UBI_VID_HDR_SIZE > mtd.eb_size) { errmsg("bad VID header offset"); goto out_close; } } /* * Because of MTD interface limitations 'mtd_get_info()' cannot get * sub-page so we force the user to pass it via the command line. Let's * hope the user passed us something sane. */ mtd.subpage_size = args.subpage_size; if (mtd.rdonly) { errmsg("mtd%d (%s) is a read-only device", mtd.num, args.node); goto out_close; } /* Make sure this MTD device is not attached to UBI */ libubi = libubi_open(0); if (libubi) { int ubi_dev_num; err = mtd_num2ubi_dev(libubi, mtd.num, &ubi_dev_num); libubi_close(libubi); if (!err) { errmsg("please, first detach mtd%d (%s) from ubi%d", mtd.num, args.node, ubi_dev_num); goto out_close; } } if (!args.quiet) { normsg_cont("mtd%d (%s), size ", mtd.num, mtd.type_str); ubiutils_print_bytes(mtd.size, 1); printf(", %d eraseblocks of ", mtd.eb_size); ubiutils_print_bytes(mtd.eb_size, 1); printf(", min. I/O size %d bytes\n", mtd.min_io_size); } if (args.quiet) verbose = 0; else if (args.verbose) verbose = 2; else verbose = 1; err = ubi_scan(&mtd, &si, verbose); if (err) { errmsg("failed to scan mtd%d (%s)", mtd.num, args.node); goto out_close; } if (si->good_cnt == 0) { errmsg("all %d eraseblocks are bad", si->bad_cnt); goto out_free; } if (si->good_cnt < 2 && (!args.novtbl || args.image)) { errmsg("too few non-bad eraseblocks (%d) on mtd%d", si->good_cnt, mtd.num); goto out_free; } if (!args.quiet) { if (si->ok_cnt) normsg("%d eraseblocks have valid erase counter, mean value is %lld", si->ok_cnt, si->mean_ec); if (si->empty_cnt) normsg("%d eraseblocks are supposedly empty", si->empty_cnt); if (si->corrupted_cnt) normsg("%d corrupted erase counters", si->corrupted_cnt); print_bad_eraseblocks(&mtd, si); } if (si->alien_cnt) { if (!args.yes || !args.quiet) warnmsg("%d of %d eraseblocks contain non-ubifs data", si->alien_cnt, si->good_cnt); if (!args.yes && want_exit()) { if (args.yes && !args.quiet) printf("yes\n"); goto out_free; } } if (!args.override_ec && si->empty_cnt < si->good_cnt) { int percent = ((double)si->ok_cnt)/si->good_cnt * 100; /* * Make sure the majority of eraseblocks have valid * erase counters. */ if (percent < 50) { if (!args.yes || !args.quiet) warnmsg("only %d of %d eraseblocks have valid erase counter", si->ok_cnt, si->good_cnt); normsg("erase counter 0 will be used for all eraseblocks"); normsg("note, arbitrary erase counter value may be specified using -e option"); if (!args.yes && want_exit()) { if (args.yes && !args.quiet) printf("yes\n"); goto out_free; } args.ec = 0; args.override_ec = 1; } else if (percent < 95) { if (!args.yes || !args.quiet) warnmsg("only %d of %d eraseblocks have valid erase counter", si->ok_cnt, si->good_cnt); normsg("mean erase counter %lld will be used for the rest of eraseblock", si->mean_ec); if (!args.yes && want_exit()) { if (args.yes && !args.quiet) printf("yes\n"); goto out_free; } args.ec = si->mean_ec; args.override_ec = 1; } } if (!args.quiet && args.override_ec) normsg("use erase counter %lld for all eraseblocks", args.ec); ubigen_info_init(&ui, mtd.eb_size, mtd.min_io_size, args.subpage_size, args.vid_hdr_offs, args.ubi_ver); if (si->vid_hdr_offs != -1 && ui.vid_hdr_offs != si->vid_hdr_offs) { /* * Hmm, what we read from flash and what we calculated using * min. I/O unit size and sub-page size differs. */ if (!args.yes || !args.quiet) { warnmsg("VID header and data offsets on flash are %d and %d, " "which is different to calculated offsets %d and %d", si->vid_hdr_offs, si->data_offs, ui.vid_hdr_offs, ui.data_offs); normsg_cont("use new offsets %d and %d? (yes/no) ", si->vid_hdr_offs, si->data_offs); } if (args.yes || answer_is_yes()) { if (args.yes && !args.quiet) printf("yes\n"); } else { ui.vid_hdr_offs = si->vid_hdr_offs; ui.data_offs = si->data_offs; } } if (args.image) { err = flash_image(&mtd, &ui, si); if (err < 0) goto out_free; err = format(&mtd, &ui, si, err, 1); if (err) goto out_free; } else { err = format(&mtd, &ui, si, 0, args.novtbl); if (err) goto out_free; } ubi_scan_free(si); close(mtd.fd); return 0; out_free: ubi_scan_free(si); out_close: close(mtd.fd); return -1; }