Value *FlashOSImage(const char *name, State * state, int argc, Expr * argv[])
{
char* result = NULL;
Value *funret = NULL;
char *image_type;
int ret;
Value* partition_value;
Value* contents;
if (ReadValueArgs(state, argv, 2, &contents, &partition_value) < 0) {
return NULL;
}
char* partition = NULL;
if (partition_value->type != VAL_STRING) {
ErrorAbort(state, "partition argument to %s must be string", name);
goto exit;
}
partition = partition_value->data;
if (strlen(partition) == 0) {
ErrorAbort(state, "partition argument to %s can't be empty", name);
goto exit;
}
if (contents->type == VAL_STRING && strlen((char*) contents->data) == 0) {
ErrorAbort(state, "file argument to %s can't be empty", name);
goto exit;
}
image_type = basename(partition);
ret = flash_image(contents->data, contents->size, image_type);
if (ret != 0) {
ErrorAbort(state, "%s: Failed to flash image %s, %s.",
name, image_type, strerror(errno));
goto free;
}
funret = StringValue(strdup("t"));
free:
free(image_type);
exit:
return funret;
}
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;
}
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 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;
}