/* TODO: we should actually torture the PEB before marking it as bad */
static int mark_bad(const struct mtd_dev_info *mtd, struct ubi_scan_info *si, int eb)
{
int err;
if (!args.yes) {
normsg_cont("mark it as bad? Continue (yes/no) ");
if (!answer_is_yes())
return -1;
}
if (!args.quiet)
normsg_cont("marking block %d bad", eb);
if (!args.quiet)
printf("\n");
if (!mtd->bb_allowed) {
if (!args.quiet)
printf("\n");
return errmsg("bad blocks not supported by this flash");
}
err = mtd_mark_bad(mtd, args.node_fd, eb);
if (err)
return err;
si->bad_cnt += 1;
si->ec[eb] = EB_BAD;
return consecutive_bad_check(eb);
}
static int want_exit(void)
{
char buf[4];
while (1) {
normsg_cont("continue? (yes/no) ");
if (scanf("%3s", buf) == EOF) {
sys_errmsg("scanf returned unexpected EOF, assume \"yes\"");
return 1;
}
if (!strncmp(buf, "yes", 3) || !strncmp(buf, "y", 1))
return 0;
if (!strncmp(buf, "no", 2) || !strncmp(buf, "n", 1))
return 1;
}
}
static void print_bad_eraseblocks(const struct mtd_dev_info *mtd,
const struct ubi_scan_info *si)
{
int first = 1, eb;
if (si->bad_cnt == 0)
return;
normsg_cont("%d bad eraseblocks found, numbers: ", si->bad_cnt);
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");
}
int do_ubiformat(int argc, char *argv[])
{
int err, verbose;
struct mtd_dev_info mtd;
struct ubigen_info ui;
struct ubi_scan_info *si;
err = parse_opt(argc, argv);
if (err)
return err;
err = mtd_get_dev_info(args.node, &mtd);
if (err) {
sys_errmsg("cannot get information about \"%s\"", args.node);
goto out_close_mtd;
}
if (!is_power_of_2(mtd.min_io_size)) {
errmsg("min. I/O size is %d, but should be power of 2",
mtd.min_io_size);
goto out_close_mtd;
}
if (args.subpage_size && args.subpage_size != mtd.subpage_size) {
mtd.subpage_size = args.subpage_size;
args.manual_subpage = 1;
}
if (args.manual_subpage) {
/* Do some sanity check */
if (args.subpage_size > mtd.min_io_size) {
errmsg("sub-page cannot be larger than min. I/O unit");
goto out_close_mtd;
}
if (mtd.min_io_size % args.subpage_size) {
errmsg("min. I/O unit size should be multiple of "
"sub-page size");
goto out_close_mtd;
}
}
args.node_fd = open(args.node, O_RDWR);
if (args.node_fd < 0) {
sys_errmsg("cannot open \"%s\"", args.node);
goto out_close_mtd;
}
/* 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 + (int)UBI_VID_HDR_SIZE > mtd.eb_size) {
errmsg("bad VID header offset");
goto out_close;
}
}
if (!mtd.writable) {
errmsg("%s (%s) is a read-only device", mtd.node, args.node);
goto out_close;
}
/* Make sure this MTD device is not attached to UBI */
/* FIXME! Find a proper way to do this in barebox! */
if (!args.quiet) {
normsg_cont("%s (%s), size %lld bytes (%s)", mtd.node, mtd.type_str,
mtd.size, size_human_readable(mtd.size));
printf(", %d eraseblocks of %d bytes (%s)", mtd.eb_cnt,
mtd.eb_size, size_human_readable(mtd.eb_size));
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 = libscan_ubi_scan(&mtd, args.node_fd, &si, verbose);
if (err) {
errmsg("failed to scan %s (%s)", mtd.node, 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 %s",
si->good_cnt, mtd.node);
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.quiet)
warnmsg("%d of %d eraseblocks contain non-ubifs data",
si->alien_cnt, si->good_cnt);
if (!args.yes && !args.quiet)
warnmsg("use '-y' to force erasing");
if (!args.yes)
goto out_free;
}
if (!args.override_ec && si->empty_cnt < si->good_cnt) {
int percent = (si->ok_cnt * 100) / si->good_cnt;
/*
* Make sure the majority of eraseblocks have valid
* erase counters.
*/
if (percent < 50) {
if (!args.quiet) {
warnmsg("only %d of %d eraseblocks have valid erase counter",
si->ok_cnt, si->good_cnt);
if (args.yes) {
normsg("erase counter 0 will be used for all eraseblocks");
normsg("note, arbitrary erase counter value may be specified using -e option");
} else {
warnmsg("use '-y' to force erase counters");
}
}
if (!args.yes)
goto out_free;
args.ec = 0;
args.override_ec = 1;
} else if (percent < 95) {
if (!args.quiet) {
warnmsg("only %d of %d eraseblocks have valid erase counter",
si->ok_cnt, si->good_cnt);
if (args.yes)
normsg("mean erase counter %lld will be used for the rest of eraseblock",
si->mean_ec);
else
warnmsg("use '-y' to force erase counters");
}
if (!args.yes)
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, mtd.subpage_size,
args.vid_hdr_offs, args.ubi_ver, args.image_seq);
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.quiet) {
warnmsg("VID header and data offsets on flash are %d and %d, "
"which is different to requested offsets %d and %d",
si->vid_hdr_offs, si->data_offs, ui.vid_hdr_offs,
ui.data_offs);
normsg("using offsets %d and %d", ui.vid_hdr_offs, ui.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;
}
libscan_ubi_scan_free(si);
close(args.node_fd);
return 0;
out_free:
libscan_ubi_scan_free(si);
out_close:
close(args.node_fd);
out_close_mtd:
return 1;
}
static int format(const struct mtd_dev_info *mtd,
const struct ubigen_info *ui, 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 -- %2u %% complete ",
eb, (eb + 1 - start_eb) * 100 / (mtd->eb_cnt - start_eb));
}
if (si->ec[eb] == EB_BAD)
continue;
if (args.override_ec)
ec = args.ec;
else if (si->ec[eb] <= EC_MAX)
ec = si->ec[eb] + 1;
else
ec = si->mean_ec;
ubigen_init_ec_hdr(ui, hdr, ec);
if (args.verbose) {
normsg_cont("eraseblock %d: erase", eb);
}
err = libmtd_erase(mtd, args.node_fd, eb);
if (err) {
if (!args.quiet)
printf("\n");
sys_errmsg("failed to erase eraseblock %d", eb);
if (errno != EIO)
goto out_free;
if (mark_bad(mtd, si, eb))
goto out_free;
continue;
}
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);
}
err = libmtd_write(mtd, args.node_fd, eb, 0, hdr, write_size);
if (err) {
if (!args.quiet && !args.verbose)
printf("\n");
sys_errmsg("cannot write EC header (%d bytes buffer) to eraseblock %d",
write_size, eb);
if (errno != EIO) {
if (!args.subpage_size != mtd->min_io_size)
normsg("may be sub-page size is "
"incorrect?");
goto out_free;
}
err = mtd_torture(mtd, args.node_fd, eb);
if (err) {
if (mark_bad(mtd, si, eb))
goto out_free;
}
continue;
}
}
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,
args.node_fd);
free(vtbl);
if (err) {
errmsg("cannot write layout volume");
goto out_free;
}
}
free(hdr);
return 0;
out_free:
free(hdr);
return -1;
}
static int flash_image(const struct mtd_dev_info *mtd,
const struct ubigen_info *ui, struct ubi_scan_info *si)
{
int fd, img_ebs, eb, written_ebs = 0, divisor, ret = -1;
off_t st_size;
char *buf = NULL;
fd = open_file(&st_size);
if (fd < 0)
return fd;
buf = malloc(mtd->eb_size);
if (!buf) {
sys_errmsg("cannot allocate %d bytes of memory", mtd->eb_size);
goto out_close;
}
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) {
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;
}
if (st_size == 0) {
sys_errmsg("file \"%s\" has size 0 bytes", args.image);
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;
long long ec;
if (!args.quiet && !args.verbose) {
printf("\r" PROGRAM_NAME ": flashing eraseblock %d -- %2u %% complete ",
eb, (eb + 1) * 100 / mtd->eb_cnt);
}
if (si->ec[eb] == EB_BAD) {
divisor += 1;
continue;
}
if (args.verbose) {
normsg_cont("eraseblock %d: erase", eb);
}
err = libmtd_erase(mtd, args.node_fd, eb);
if (err) {
if (!args.quiet)
printf("\n");
sys_errmsg("failed to erase eraseblock %d", eb);
if (errno != EIO)
goto out_close;
if (mark_bad(mtd, si, eb))
goto out_close;
continue;
}
err = read_full(fd, buf, mtd->eb_size);
if (err < 0) {
sys_errmsg("failed to read eraseblock %d from \"%s\"",
written_ebs, args.image);
goto out_close;
}
if (args.override_ec)
ec = args.ec;
else if (si->ec[eb] <= EC_MAX)
ec = si->ec[eb] + 1;
else
ec = si->mean_ec;
if (args.verbose) {
printf(", change EC to %lld", ec);
}
err = change_ech((struct ubi_ec_hdr *)buf, ui->image_seq, 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");
}
new_len = drop_ffs(mtd, buf, mtd->eb_size);
err = libmtd_write(mtd, args.node_fd, eb, 0, buf, new_len);
if (err) {
sys_errmsg("cannot write eraseblock %d", eb);
if (errno != EIO)
goto out_close;
err = mtd_torture(mtd, args.node_fd, eb);
if (err) {
if (mark_bad(mtd, si, eb))
goto out_close;
}
continue;
}
if (++written_ebs >= img_ebs)
break;
}
if (!args.quiet && !args.verbose)
printf("\n");
ret = eb + 1;
out_close:
free(buf);
close(fd);
return ret;
}
int main(int argc, char * const argv[])
{
int err, verbose;
libmtd_t libmtd;
struct mtd_info mtd_info;
struct mtd_dev_info mtd;
libubi_t libubi;
struct ubigen_info ui;
struct ubi_scan_info *si;
libmtd = libmtd_open();
if (!libmtd)
return errmsg("MTD subsystem is not present");
err = parse_opt(argc, argv);
if (err)
goto out_close_mtd;
err = mtd_get_info(libmtd, &mtd_info);
if (err) {
if (errno == ENODEV)
errmsg("MTD is not present");
sys_errmsg("cannot get MTD information");
goto out_close_mtd;
}
err = mtd_get_dev_info(libmtd, args.node, &mtd);
if (err) {
sys_errmsg("cannot get information about \"%s\"", args.node);
goto out_close_mtd;
}
if (!is_power_of_2(mtd.min_io_size)) {
errmsg("min. I/O size is %d, but should be power of 2",
mtd.min_io_size);
goto out_close;
}
if (!mtd_info.sysfs_supported) {
/*
* Linux kernels older than 2.6.30 did not support sysfs
* interface, and it is impossible to find out sub-page
* size in these kernels. This is why users should
* provide -s option.
*/
if (args.subpage_size == 0) {
warnmsg("your MTD system is old and it is impossible "
"to detect sub-page size. Use -s to get rid "
"of this warning");
normsg("assume sub-page to be %d", mtd.subpage_size);
} else {
mtd.subpage_size = args.subpage_size;
args.manual_subpage = 1;
}
} else if (args.subpage_size && args.subpage_size != mtd.subpage_size) {
mtd.subpage_size = args.subpage_size;
args.manual_subpage = 1;
}
if (args.manual_subpage) {
/* Do some sanity check */
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;
}
}
args.node_fd = open(args.node, O_RDWR);
if (args.node_fd == -1) {
sys_errmsg("cannot open \"%s\"", args.node);
goto out_close_mtd;
}
/* 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 + (int)UBI_VID_HDR_SIZE > mtd.eb_size) {
errmsg("bad VID header offset");
goto out_close;
}
}
if (!mtd.writable) {
errmsg("mtd%d (%s) is a read-only device", mtd.mtd_num, args.node);
goto out_close;
}
/* Make sure this MTD device is not attached to UBI */
libubi = libubi_open();
if (libubi) {
int ubi_dev_num;
err = mtd_num2ubi_dev(libubi, mtd.mtd_num, &ubi_dev_num);
libubi_close(libubi);
if (!err) {
errmsg("please, first detach mtd%d (%s) from ubi%d",
mtd.mtd_num, args.node, ubi_dev_num);
goto out_close;
}
}
if (!args.quiet) {
normsg_cont("mtd%d (%s), size ", mtd.mtd_num, mtd.type_str);
ubiutils_print_bytes(mtd.size, 1);
printf(", %d eraseblocks of ", mtd.eb_cnt);
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, args.node_fd, &si, verbose);
if (err) {
errmsg("failed to scan mtd%d (%s)", mtd.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.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, mtd.subpage_size,
args.vid_hdr_offs, args.ubi_ver, args.image_seq);
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 requested 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) ",
ui.vid_hdr_offs, ui.data_offs);
}
if (args.yes || answer_is_yes()) {
if (args.yes && !args.quiet)
printf("yes\n");
} else
ubigen_info_init(&ui, mtd.eb_size, mtd.min_io_size, 0,
si->vid_hdr_offs, args.ubi_ver,
args.image_seq);
normsg("use offsets %d and %d", ui.vid_hdr_offs, ui.data_offs);
}
if (args.image) {
err = flash_image(libmtd, &mtd, &ui, si);
if (err < 0)
goto out_free;
err = format(libmtd, &mtd, &ui, si, err, 1);
if (err)
goto out_free;
} else {
err = format(libmtd, &mtd, &ui, si, 0, args.novtbl);
if (err)
goto out_free;
}
ubi_scan_free(si);
close(args.node_fd);
libmtd_close(libmtd);
return 0;
out_free:
ubi_scan_free(si);
out_close:
close(args.node_fd);
out_close_mtd:
libmtd_close(libmtd);
return -1;
}
int ubi_scan(struct mtd_dev_info *mtd, int fd, struct ubi_scan_info **info,
int verbose)
{
int eb, v = (verbose == 2), pr = (verbose == 1);
struct ubi_scan_info *si;
unsigned long long sum = 0;
si = calloc(1, sizeof(struct ubi_scan_info));
if (!si)
return sys_errmsg("cannot allocate %zd bytes of memory",
sizeof(struct ubi_scan_info));
si->ec = calloc(mtd->eb_cnt, sizeof(uint32_t));
if (!si->ec) {
sys_errmsg("cannot allocate %zd bytes of memory",
sizeof(struct ubi_scan_info));
goto out_si;
}
si->vid_hdr_offs = si->data_offs = -1;
verbose(v, "start scanning eraseblocks 0-%d", mtd->eb_cnt);
for (eb = 0; eb < mtd->eb_cnt; eb++) {
int ret;
uint32_t crc;
struct ubi_ec_hdr ech;
unsigned long long ec;
if (v) {
normsg_cont("scanning eraseblock %d", eb);
fflush(stdout);
}
if (pr) {
printf("\r" PROGRAM_NAME ": scanning eraseblock %d -- %2lld %% complete ",
eb, (long long)(eb + 1) * 100 / mtd->eb_cnt);
fflush(stdout);
}
ret = mtd_is_bad(mtd, fd, eb);
if (ret == -1)
goto out_ec;
if (ret) {
si->bad_cnt += 1;
si->ec[eb] = EB_BAD;
if (v)
printf(": bad\n");
continue;
}
ret = mtd_read(mtd, fd, eb, 0, &ech, sizeof(struct ubi_ec_hdr));
if (ret < 0)
goto out_ec;
if (be32_to_cpu(ech.magic) != UBI_EC_HDR_MAGIC) {
if (all_ff(&ech, sizeof(struct ubi_ec_hdr))) {
si->empty_cnt += 1;
si->ec[eb] = EB_EMPTY;
if (v)
printf(": empty\n");
} else {
si->alien_cnt += 1;
si->ec[eb] = EB_ALIEN;
if (v)
printf(": alien\n");
}
continue;
}
crc = mtd_crc32(UBI_CRC32_INIT, &ech, UBI_EC_HDR_SIZE_CRC);
if (be32_to_cpu(ech.hdr_crc) != crc) {
si->corrupted_cnt += 1;
si->ec[eb] = EB_CORRUPTED;
if (v)
printf(": bad CRC %#08x, should be %#08x\n",
crc, be32_to_cpu(ech.hdr_crc));
continue;
}
ec = be64_to_cpu(ech.ec);
if (ec > EC_MAX) {
if (pr)
printf("\n");
errmsg("erase counter in EB %d is %llu, while this "
"program expects them to be less than %u",
eb, ec, EC_MAX);
goto out_ec;
}
if (si->vid_hdr_offs == -1) {
si->vid_hdr_offs = be32_to_cpu(ech.vid_hdr_offset);
si->data_offs = be32_to_cpu(ech.data_offset);
if (si->data_offs % mtd->min_io_size) {
if (pr)
printf("\n");
if (v)
printf(": corrupted because of the below\n");
warnmsg("bad data offset %d at eraseblock %d (n"
"of multiple of min. I/O unit size %d)",
si->data_offs, eb, mtd->min_io_size);
warnmsg("treat eraseblock %d as corrupted", eb);
si->corrupted_cnt += 1;
si->ec[eb] = EB_CORRUPTED;
continue;
}
} else {
if ((int)be32_to_cpu(ech.vid_hdr_offset) != si->vid_hdr_offs) {
if (pr)
printf("\n");
if (v)
printf(": corrupted because of the below\n");
warnmsg("inconsistent VID header offset: was "
"%d, but is %d in eraseblock %d",
si->vid_hdr_offs,
be32_to_cpu(ech.vid_hdr_offset), eb);
warnmsg("treat eraseblock %d as corrupted", eb);
si->corrupted_cnt += 1;
si->ec[eb] = EB_CORRUPTED;
continue;
}
if ((int)be32_to_cpu(ech.data_offset) != si->data_offs) {
if (pr)
printf("\n");
if (v)
printf(": corrupted because of the below\n");
warnmsg("inconsistent data offset: was %d, but"
" is %d in eraseblock %d",
si->data_offs,
be32_to_cpu(ech.data_offset), eb);
warnmsg("treat eraseblock %d as corrupted", eb);
si->corrupted_cnt += 1;
si->ec[eb] = EB_CORRUPTED;
continue;
}
}
si->ok_cnt += 1;
si->ec[eb] = ec;
if (v)
printf(": OK, erase counter %u\n", si->ec[eb]);
}
if (si->ok_cnt != 0) {
/* Calculate mean erase counter */
for (eb = 0; eb < mtd->eb_cnt; eb++) {
if (si->ec[eb] > EC_MAX)
continue;
sum += si->ec[eb];
}
si->mean_ec = sum / si->ok_cnt;
}
si->good_cnt = mtd->eb_cnt - si->bad_cnt;
verbose(v, "finished, mean EC %lld, %d OK, %d corrupted, %d empty, %d "
"alien, bad %d", si->mean_ec, si->ok_cnt, si->corrupted_cnt,
si->empty_cnt, si->alien_cnt, si->bad_cnt);
*info = si;
if (pr)
printf("\n");
return 0;
out_ec:
free(si->ec);
out_si:
free(si);
*info = NULL;
return -1;
}
static int flash_image(libmtd_t libmtd, const struct mtd_dev_info *mtd,
const struct ubigen_info *ui, struct ubi_scan_info *si)
{
int fd, img_ebs, eb, written_ebs = 0, divisor, skip_data_read = 0;
off_t st_size;
fd = open_file(&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(libmtd, mtd, args.node_fd, eb);
if (err) {
if (!args.quiet)
printf("\n");
sys_errmsg("failed to erase eraseblock %d", eb);
if (errno != EIO)
goto out_close;
if (mark_bad(mtd, si, eb))
goto out_close;
continue;
}
if (!skip_data_read) {
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;
}
}
skip_data_read = 0;
if (args.override_ec)
ec = args.ec;
else if (si->ec[eb] <= EC_MAX)
ec = si->ec[eb] + 1;
else
ec = si->mean_ec;
if (args.verbose) {
printf(", change EC to %lld", ec);
fflush(stdout);
}
err = change_ech((struct ubi_ec_hdr *)buf, ui->image_seq, 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(libmtd, mtd, args.node_fd, eb, 0, buf, new_len,
NULL, 0, 0);
if (err) {
sys_errmsg("cannot write eraseblock %d", eb);
if (errno != EIO)
goto out_close;
err = mtd_torture(libmtd, mtd, args.node_fd, eb);
if (err) {
if (mark_bad(mtd, si, eb))
goto out_close;
}
/*
* We have to make sure that we do not read next block
* of data from the input image or stdin - we have to
* write buf first instead.
*/
skip_data_read = 1;
continue;
}
if (++written_ebs >= img_ebs)
break;
}
if (!args.quiet && !args.verbose)
printf("\n");
close(fd);
return eb + 1;
out_close:
close(fd);
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;
}
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;
}
