int main(int argc, char * const argv[])
{
if (initial_check(argc, argv))
return 1;
node = argv[1];
libubi = libubi_open();
if (libubi == NULL) {
failed("libubi_open");
return 1;
}
if (ubi_get_dev_info(libubi, node, &dev_info)) {
failed("ubi_get_dev_info");
goto close;
}
if (test_basic(UBI_DYNAMIC_VOLUME))
goto close;
if (test_basic(UBI_STATIC_VOLUME))
goto close;
if (test_rsvol(UBI_DYNAMIC_VOLUME))
goto close;
if (test_rsvol(UBI_STATIC_VOLUME))
goto close;
libubi_close(libubi);
return 0;
close:
libubi_close(libubi);
return 1;
}
int main(int argc, char * const argv[])
{
if (initial_check(argc, argv))
return 1;
node = argv[1];
libubi = libubi_open();
if (libubi == NULL) {
failed("libubi_open");
return 1;
}
if (ubi_get_dev_info(libubi, node, &dev_info)) {
failed("ubi_get_dev_info");
goto close;
}
if (mkvol_basic())
goto close;
if (mkvol_alignment())
goto close;
if (mkvol_multiple())
goto close;
libubi_close(libubi);
return 0;
close:
libubi_close(libubi);
return 1;
}
/*
* Read bootenv from ubi volume
*/
static int
ubi_read_bootenv(uint32_t devno, uint32_t id, bootenv_t env)
{
libubi_t ulib;
int rc = 0;
char path[PATH_MAX];
FILE* fp_in = NULL;
ulib = libubi_open();
if (ulib == NULL) {
err_msg("Cannot allocate ubi structure\n");
return -1;
}
snprintf(path, PATH_MAX, DEFAULT_VOL_PATTERN, devno, id);
fp_in = fopen(path, "r");
if (fp_in == NULL) {
err_msg("Cannot open volume:%d number:%d\n", devno, id);
goto err;
}
rc = bootenv_read(fp_in, env, BOOTENV_MAXSIZE);
if (rc != 0) {
err_msg("Cannot read volume:%d number:%d\n", devno, id);
goto err;
}
err:
if (fp_in)
fclose(fp_in);
libubi_close(ulib);
return rc;
}
/**
* __initial_check - check that common prerequisites which are required to run
* tests.
*
* @test test name
* @argc count of command-line arguments
* @argv command-line arguments
*
* This function returns %0 if all is fine and test may be run and %-1 if not.
*/
int __initial_check(const char *test, int argc, char * const argv[])
{
libubi_t libubi;
struct ubi_dev_info dev_info;
/*
* All tests require UBI character device name as the first parameter,
* check this.
*/
if (argc < 2) {
__err_msg(test, __FUNCTION__, __LINE__,
"UBI character device node is not specified");
return -1;
}
libubi = libubi_open();
if (libubi == NULL) {
__failed(test, __FUNCTION__, __LINE__, "libubi_open");
return -1;
}
if (ubi_get_dev_info(libubi, argv[1], &dev_info)) {
__failed(test, __FUNCTION__, __LINE__, "ubi_get_dev_info");
goto close;
}
if (dev_info.avail_lebs < MIN_AVAIL_EBS) {
__err_msg(test, __FUNCTION__, __LINE__,
"insufficient available eraseblocks %d on UBI "
"device, required %d",
dev_info.avail_lebs, MIN_AVAIL_EBS);
goto close;
}
if (dev_info.vol_count != 0) {
__err_msg(test, __FUNCTION__, __LINE__,
"device %s is not empty", argv[1]);
goto close;
}
libubi_close(libubi);
return 0;
close:
libubi_close(libubi);
return -1;
}
int main(int argc, char * const argv[])
{
int i, ret;
pthread_t threads[THREADS_NUM];
if (initial_check(argc, argv))
return 1;
node = argv[1];
libubi = libubi_open();
if (libubi == NULL) {
failed("libubi_open");
return 1;
}
if (ubi_get_dev_info(libubi, node, &dev_info)) {
failed("ubi_get_dev_info");
goto close;
}
for (i = 0; i < THREADS_NUM; i++) {
ret = pthread_create(&threads[i], NULL, &the_thread, (void*)(long)i);
if (ret) {
failed("pthread_create");
goto close;
}
}
for (i = 0; i < THREADS_NUM; i++)
pthread_join(threads[i], NULL);
libubi_close(libubi);
return 0;
close:
libubi_close(libubi);
return 1;
}
/*
* Read bootenv from ubi volume
*/
static int
ubi_write_bootenv(uint32_t devno, uint32_t id, bootenv_t env)
{
libubi_t ulib;
int rc = 0;
char path[PATH_MAX];
FILE* fp_out = NULL;
size_t nbytes;
rc = bootenv_size(env, &nbytes);
if (rc) {
err_msg("Cannot determine size of bootenv structure\n");
return rc;
}
ulib = libubi_open();
if (ulib == NULL) {
err_msg("Cannot allocate ubi structure\n");
return rc;
}
snprintf(path, PATH_MAX, DEFAULT_VOL_PATTERN, devno, id);
fp_out = fopen(path, "r+");
if (fp_out == NULL) {
err_msg("Cannot fopen volume:%d number:%d\n", devno, id);
rc = -EBADF;
goto err;
}
rc = ubi_update_start(ulib, fileno(fp_out), nbytes);
if (rc != 0) {
err_msg("Cannot start update for %s\n", path);
goto err;
}
rc = bootenv_write(fp_out, env);
if (rc != 0) {
err_msg("Cannot write bootenv to volume %d number:%d\n",
devno, id);
goto err;
}
err:
if( fp_out )
fclose(fp_out);
libubi_close(ulib);
return rc;
}
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 i, ret;
pthread_t threads[THREADS_NUM];
struct ubi_mkvol_request req;
long long mem_limit;
if (initial_check(argc, argv))
return 1;
node = argv[1];
libubi = libubi_open();
if (libubi == NULL) {
failed("libubi_open");
return 1;
}
if (ubi_get_dev_info(libubi, node, &dev_info)) {
failed("ubi_get_dev_info");
goto close;
}
req.alignment = 1;
mem_limit = memory_limit();
if (mem_limit && mem_limit < dev_info.avail_bytes)
total_bytes = req.bytes =
(mem_limit / dev_info.eb_size / THREADS_NUM)
* dev_info.eb_size;
else
total_bytes = req.bytes =
((dev_info.avail_ebs - 3) / THREADS_NUM)
* dev_info.eb_size;
for (i = 0; i < THREADS_NUM; i++) {
char name[100];
req.vol_id = i;
sprintf(&name[0], TESTNAME":%d", i);
req.name = &name[0];
req.vol_type = (i & 1) ? UBI_STATIC_VOLUME : UBI_DYNAMIC_VOLUME;
if (ubi_mkvol(libubi, node, &req)) {
failed("ubi_mkvol");
goto remove;
}
}
/* Create one volume with static data to make WL work more */
req.vol_id = THREADS_NUM;
req.name = TESTNAME ":static";
req.vol_type = UBI_DYNAMIC_VOLUME;
req.bytes = 3*dev_info.eb_size;
if (ubi_mkvol(libubi, node, &req)) {
failed("ubi_mkvol");
goto remove;
}
for (i = 0; i < THREADS_NUM; i++) {
ret = pthread_create(&threads[i], NULL, &the_thread, (void*)i);
if (ret) {
failed("pthread_create");
goto remove;
}
}
for (i = 0; i < THREADS_NUM; i++)
pthread_join(threads[i], NULL);
for (i = 0; i <= THREADS_NUM; i++) {
if (ubi_rmvol(libubi, node, i)) {
failed("ubi_rmvol");
goto remove;
}
}
libubi_close(libubi);
return 0;
remove:
for (i = 0; i <= THREADS_NUM; i++)
ubi_rmvol(libubi, node, i);
close:
libubi_close(libubi);
return 1;
}
libubi_t libubi_open(int required)
{
int fd, version;
struct libubi *lib;
lib = calloc(1, sizeof(struct libubi));
if (!lib)
return NULL;
/* TODO: this must be discovered instead */
lib->sysfs = strdup("/sys");
if (!lib->sysfs)
goto out_error;
lib->sysfs_ctrl = mkpath(lib->sysfs, SYSFS_CTRL);
if (!lib->sysfs_ctrl)
goto out_error;
lib->ctrl_dev = mkpath(lib->sysfs_ctrl, CTRL_DEV);
if (!lib->ctrl_dev)
goto out_error;
lib->sysfs_ubi = mkpath(lib->sysfs, SYSFS_UBI);
if (!lib->sysfs_ubi)
goto out_error;
/* Make sure UBI is present */
fd = open(lib->sysfs_ubi, O_RDONLY);
if (fd == -1) {
if (required)
errmsg("cannot open \"%s\", UBI does not seem to "
"exist in system", lib->sysfs_ubi);
goto out_error;
}
if (close(fd)) {
sys_errmsg("close failed on \"%s\"", lib->sysfs_ubi);
goto out_error;
}
lib->ubi_dev = mkpath(lib->sysfs_ubi, UBI_DEV_NAME_PATT);
if (!lib->ubi_dev)
goto out_error;
lib->ubi_version = mkpath(lib->sysfs_ubi, UBI_VER);
if (!lib->ubi_version)
goto out_error;
lib->dev_dev = mkpath(lib->ubi_dev, DEV_DEV);
if (!lib->dev_dev)
goto out_error;
lib->dev_avail_ebs = mkpath(lib->ubi_dev, DEV_AVAIL_EBS);
if (!lib->dev_avail_ebs)
goto out_error;
lib->dev_total_ebs = mkpath(lib->ubi_dev, DEV_TOTAL_EBS);
if (!lib->dev_total_ebs)
goto out_error;
lib->dev_bad_count = mkpath(lib->ubi_dev, DEV_BAD_COUNT);
if (!lib->dev_bad_count)
goto out_error;
lib->dev_eb_size = mkpath(lib->ubi_dev, DEV_EB_SIZE);
if (!lib->dev_eb_size)
goto out_error;
lib->dev_max_ec = mkpath(lib->ubi_dev, DEV_MAX_EC);
if (!lib->dev_max_ec)
goto out_error;
lib->dev_bad_rsvd = mkpath(lib->ubi_dev, DEV_MAX_RSVD);
if (!lib->dev_bad_rsvd)
goto out_error;
lib->dev_max_vols = mkpath(lib->ubi_dev, DEV_MAX_VOLS);
if (!lib->dev_max_vols)
goto out_error;
lib->dev_min_io_size = mkpath(lib->ubi_dev, DEV_MIN_IO_SIZE);
if (!lib->dev_min_io_size)
goto out_error;
lib->dev_mtd_num = mkpath(lib->ubi_dev, DEV_MTD_NUM);
if (!lib->dev_mtd_num)
goto out_error;
lib->ubi_vol = mkpath(lib->sysfs_ubi, UBI_VOL_NAME_PATT);
if (!lib->ubi_vol)
goto out_error;
lib->vol_type = mkpath(lib->ubi_vol, VOL_TYPE);
if (!lib->vol_type)
goto out_error;
lib->vol_dev = mkpath(lib->ubi_vol, VOL_DEV);
if (!lib->vol_dev)
goto out_error;
lib->vol_alignment = mkpath(lib->ubi_vol, VOL_ALIGNMENT);
if (!lib->vol_alignment)
goto out_error;
lib->vol_data_bytes = mkpath(lib->ubi_vol, VOL_DATA_BYTES);
if (!lib->vol_data_bytes)
goto out_error;
lib->vol_rsvd_ebs = mkpath(lib->ubi_vol, VOL_RSVD_EBS);
if (!lib->vol_rsvd_ebs)
goto out_error;
lib->vol_eb_size = mkpath(lib->ubi_vol, VOL_EB_SIZE);
if (!lib->vol_eb_size)
goto out_error;
lib->vol_corrupted = mkpath(lib->ubi_vol, VOL_CORRUPTED);
if (!lib->vol_corrupted)
goto out_error;
lib->vol_name = mkpath(lib->ubi_vol, VOL_NAME);
if (!lib->vol_name)
goto out_error;
if (read_positive_int(lib->ubi_version, &version))
goto out_error;
if (version != LIBUBI_UBI_VERSION) {
errmsg("this library was made for UBI version %d, but UBI "
"version %d is detected\n", LIBUBI_UBI_VERSION, version);
goto out_error;
}
return lib;
out_error:
libubi_close((libubi_t)lib);
return NULL;
}
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;
}
int main(int argc, char * const argv[])
{
int i, err;
int count = 0;
libubi_t libubi;
struct ubi_dev_info dev_info;
struct ubi_rnvol_req rnvol;
const char *node;
if (argc < 3 || (argc & 1) == 1) {
errmsg("too few arguments");
fprintf(stderr, "%s\n", usage);
return -1;
}
if (argc > UBI_MAX_RNVOL + 2) {
errmsg("too many volumes to re-name, max. is %d",
UBI_MAX_RNVOL);
return -1;
}
node = argv[1];
libubi = libubi_open();
if (!libubi) {
if (errno == 0)
return errmsg("UBI is not present in the system");
return sys_errmsg("cannot open libubi");
}
err = ubi_probe_node(libubi, node);
if (err == 2) {
errmsg("\"%s\" is an UBI volume node, not an UBI device node",
node);
goto out_libubi;
} else if (err < 0) {
if (errno == ENODEV)
errmsg("\"%s\" is not an UBI device node", node);
else
sys_errmsg("error while probing \"%s\"", node);
goto out_libubi;
}
err = ubi_get_dev_info(libubi, node, &dev_info);
if (err == -1) {
sys_errmsg("cannot get information about UBI device \"%s\"", node);
goto out_libubi;
}
for (i = 2; i < argc; i += 2) {
err = get_vol_id(libubi, &dev_info, argv[i]);
if (err == -1) {
errmsg("\"%s\" volume not found", argv[i]);
goto out_libubi;
}
rnvol.ents[count].vol_id = err;
rnvol.ents[count].name_len = strlen(argv[i + 1]);
strcpy(rnvol.ents[count++].name, argv[i + 1]);
}
rnvol.count = count;
err = ubi_rnvols(libubi, node, &rnvol);
if (err == -1) {
sys_errmsg("cannot rename volumes");
goto out_libubi;
}
libubi_close(libubi);
return 0;
out_libubi:
libubi_close(libubi);
return -1;
}