mtd-utils-1.3.1/ubi-utils/old-utils/src/libubi.c - nest-learning-thermostat/5.0.2/mtd-utils - Git at Google

 /*
  * Copyright (c) International Business Machines Corp., 2006
  *
  * 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.
  *
  * Author: Artem B. Bityutskiy
  *
  * UBI (Unsorted Block Images) library.
  */

 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <errno.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <limits.h>
 #include "libubi.h"
 #include "libubi_int.h"

 libubi_t libubi_open(void)
 {
 	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 error;

 	lib->sysfs_ubi = mkpath(lib->sysfs, SYSFS_UBI);
 	if (!lib->sysfs_ubi)
 		goto error;

 	/* Make sure UBI is present */
 	fd = open(lib->sysfs_ubi, O_RDONLY);
 	if (fd == -1)
 		goto error;
 	close(fd);

 	lib->ubi_dev = mkpath(lib->sysfs_ubi, UBI_DEV_NAME_PATT);
 	if (!lib->ubi_dev)
 		goto error;

 	lib->ubi_version = mkpath(lib->sysfs_ubi, UBI_VER);
 	if (!lib->ubi_version)
 		goto error;

 	lib->dev_dev = mkpath(lib->ubi_dev, DEV_DEV);
 	if (!lib->dev_dev)
 		goto error;

 	lib->dev_avail_ebs = mkpath(lib->ubi_dev, DEV_AVAIL_EBS);
 	if (!lib->dev_avail_ebs)
 		goto error;

 	lib->dev_total_ebs = mkpath(lib->ubi_dev, DEV_TOTAL_EBS);
 	if (!lib->dev_total_ebs)
 		goto error;

 	lib->dev_bad_count = mkpath(lib->ubi_dev, DEV_BAD_COUNT);
 	if (!lib->dev_bad_count)
 		goto error;

 	lib->dev_eb_size = mkpath(lib->ubi_dev, DEV_EB_SIZE);
 	if (!lib->dev_eb_size)
 		goto error;

 	lib->dev_max_ec = mkpath(lib->ubi_dev, DEV_MAX_EC);
 	if (!lib->dev_max_ec)
 		goto error;

 	lib->dev_bad_rsvd = mkpath(lib->ubi_dev, DEV_MAX_RSVD);
 	if (!lib->dev_bad_rsvd)
 		goto error;

 	lib->dev_max_vols = mkpath(lib->ubi_dev, DEV_MAX_VOLS);
 	if (!lib->dev_max_vols)
 		goto error;

 	lib->dev_min_io_size = mkpath(lib->ubi_dev, DEV_MIN_IO_SIZE);
 	if (!lib->dev_min_io_size)
 		goto error;

 	lib->ubi_vol = mkpath(lib->sysfs_ubi, UBI_VOL_NAME_PATT);
 	if (!lib->ubi_vol)
 		goto error;

 	lib->vol_type = mkpath(lib->ubi_vol, VOL_TYPE);
 	if (!lib->vol_type)
 		goto error;

 	lib->vol_dev = mkpath(lib->ubi_vol, VOL_DEV);
 	if (!lib->vol_dev)
 		goto error;

 	lib->vol_alignment = mkpath(lib->ubi_vol, VOL_ALIGNMENT);
 	if (!lib->vol_alignment)
 		goto error;

 	lib->vol_data_bytes = mkpath(lib->ubi_vol, VOL_DATA_BYTES);
 	if (!lib->vol_data_bytes)
 		goto error;

 	lib->vol_rsvd_ebs = mkpath(lib->ubi_vol, VOL_RSVD_EBS);
 	if (!lib->vol_rsvd_ebs)
 		goto error;

 	lib->vol_eb_size = mkpath(lib->ubi_vol, VOL_EB_SIZE);
 	if (!lib->vol_eb_size)
 		goto error;

 	lib->vol_corrupted = mkpath(lib->ubi_vol, VOL_CORRUPTED);
 	if (!lib->vol_corrupted)
 		goto error;

 	lib->vol_name = mkpath(lib->ubi_vol, VOL_NAME);
 	if (!lib->vol_name)
 		goto error;

 	if (read_int(lib->ubi_version, &version))
 		goto error;
 	if (version != LIBUBI_UBI_VERSION) {
 		fprintf(stderr, "LIBUBI: this library was made for UBI version "
 				"%d, but UBI version %d is detected\n",
 			LIBUBI_UBI_VERSION, version);
 		goto error;
 	}

 	return lib;

 error:
 	free(lib->vol_corrupted);
 	free(lib->vol_eb_size);
 	free(lib->vol_rsvd_ebs);
 	free(lib->vol_data_bytes);
 	free(lib->vol_alignment);
 	free(lib->vol_dev);
 	free(lib->vol_type);
 	free(lib->ubi_vol);
 	free(lib->dev_min_io_size);
 	free(lib->dev_max_vols);
 	free(lib->dev_bad_rsvd);
 	free(lib->dev_max_ec);
 	free(lib->dev_eb_size);
 	free(lib->dev_bad_count);
 	free(lib->dev_total_ebs);
 	free(lib->dev_avail_ebs);
 	free(lib->dev_dev);
 	free(lib->ubi_version);
 	free(lib->ubi_dev);
 	free(lib->sysfs_ubi);
 	free(lib->sysfs);
 	free(lib);
 	return NULL;
 }

 void libubi_close(libubi_t desc)
 {
 	struct libubi *lib = (struct libubi *)desc;

 	free(lib->vol_name);
 	free(lib->vol_corrupted);
 	free(lib->vol_eb_size);
 	free(lib->vol_rsvd_ebs);
 	free(lib->vol_data_bytes);
 	free(lib->vol_alignment);
 	free(lib->vol_dev);
 	free(lib->vol_type);
 	free(lib->ubi_vol);
 	free(lib->dev_min_io_size);
 	free(lib->dev_max_vols);
 	free(lib->dev_bad_rsvd);
 	free(lib->dev_max_ec);
 	free(lib->dev_eb_size);
 	free(lib->dev_bad_count);
 	free(lib->dev_total_ebs);
 	free(lib->dev_avail_ebs);
 	free(lib->dev_dev);
 	free(lib->ubi_version);
 	free(lib->ubi_dev);
 	free(lib->sysfs_ubi);
 	free(lib->sysfs);
 	free(lib);
 }

 int ubi_get_info(libubi_t desc, struct ubi_info *info)
 {
 	DIR *sysfs_ubi;
 	struct dirent *dirent;
 	struct libubi *lib = (struct libubi *)desc;

 	memset(info, '\0', sizeof(struct ubi_info));

 	/*
 	 * We have to scan the UBI sysfs directory to identify how many UBI
 	 * devices are present.
 	 */
 	sysfs_ubi = opendir(lib->sysfs_ubi);
 	if (!sysfs_ubi)
 		return -1;

 	info->lowest_dev_num = INT_MAX;
 	while ((dirent = readdir(sysfs_ubi))) {
 		char *name = &dirent->d_name[0];
 		int dev_num, ret;

 		ret = sscanf(name, UBI_DEV_NAME_PATT, &dev_num);
 		if (ret == 1) {
 			info->dev_count += 1;
 			if (dev_num > info->highest_dev_num)
 				info->highest_dev_num = dev_num;
 			if (dev_num < info->lowest_dev_num)
 				info->lowest_dev_num = dev_num;
 		}
 	}

 	if (info->lowest_dev_num == INT_MAX)
 		info->lowest_dev_num = 0;

 	if (read_int(lib->ubi_version, &info->version))
 		goto close;

 	return closedir(sysfs_ubi);

 close:
 	closedir(sysfs_ubi);
 	return -1;
 }

 int ubi_mkvol(libubi_t desc, const char *node, struct ubi_mkvol_request *req)
 {
 	int fd, ret;
 	struct ubi_mkvol_req r;
 	size_t n;

 	desc = desc;
 	r.vol_id = req->vol_id;
 	r.alignment = req->alignment;
 	r.bytes = req->bytes;
 	r.vol_type = req->vol_type;

 	n = strlen(req->name);
 	if (n > UBI_MAX_VOLUME_NAME)
 		return -1;

 	strncpy(r.name, req->name, UBI_MAX_VOLUME_NAME + 1);
 	r.name_len = n;

 	fd = open(node, O_RDONLY);
 	if (fd == -1)
 		return -1;

 	ret = ioctl(fd, UBI_IOCMKVOL, &r);
 	if (!ret)
 		req->vol_id = r.vol_id;

 	close(fd);
 	return ret;
 }

 int ubi_rmvol(libubi_t desc, const char *node, int vol_id)
 {
 	int fd, ret;

 	desc = desc;
 	fd = open(node, O_RDONLY);
 	if (fd == -1)
 		return -1;

 	ret = ioctl(fd, UBI_IOCRMVOL, &vol_id);
 	close(fd);
 	return ret;
 }

 int ubi_rsvol(libubi_t desc, const char *node, int vol_id, long long bytes)
 {
 	int fd, ret;
 	struct ubi_rsvol_req req;

 	desc = desc;
 	fd = open(node, O_RDONLY);
 	if (fd == -1)
 		return -1;

 	req.bytes = bytes;
 	req.vol_id = vol_id;

 	ret = ioctl(fd, UBI_IOCRSVOL, &req);
 	close(fd);
 	return ret;
 }

 int ubi_update_start(libubi_t desc, int fd, long long bytes)
 {
 	desc = desc;
 	if (ioctl(fd, UBI_IOCVOLUP, &bytes))
 		return -1;
 	return 0;
 }

 int ubi_get_dev_info(libubi_t desc, const char *node, struct ubi_dev_info *info)
 {
 	int dev_num;
 	struct libubi *lib = (struct libubi *)desc;

 	dev_num = find_dev_num(lib, node);
 	if (dev_num == -1)
 		return -1;

 	return ubi_get_dev_info1(desc, dev_num, info);
 }

 int ubi_get_dev_info1(libubi_t desc, int dev_num, struct ubi_dev_info *info)
 {
 	DIR *sysfs_ubi;
 	struct dirent *dirent;
 	struct libubi *lib = (struct libubi *)desc;

 	memset(info, '\0', sizeof(struct ubi_dev_info));
 	info->dev_num = dev_num;

 	sysfs_ubi = opendir(lib->sysfs_ubi);
 	if (!sysfs_ubi)
 		return -1;

 	info->lowest_vol_num = INT_MAX;
 	while ((dirent = readdir(sysfs_ubi))) {
 		char *name = &dirent->d_name[0];
 		int vol_id, ret, devno;

 		ret = sscanf(name, UBI_VOL_NAME_PATT, &devno, &vol_id);
 		if (ret == 2 && devno == dev_num) {
 			info->vol_count += 1;
 			if (vol_id > info->highest_vol_num)
 				info->highest_vol_num = vol_id;
 			if (vol_id < info->lowest_vol_num)
 				info->lowest_vol_num = vol_id;
 		}
 	}

 	closedir(sysfs_ubi);

 	if (info->lowest_vol_num == INT_MAX)
 		info->lowest_vol_num = 0;

 	if (dev_read_int(lib->dev_avail_ebs, dev_num, &info->avail_ebs))
 		return -1;
 	if (dev_read_int(lib->dev_total_ebs, dev_num, &info->total_ebs))
 		return -1;
 	if (dev_read_int(lib->dev_bad_count, dev_num, &info->bad_count))
 		return -1;
 	if (dev_read_int(lib->dev_eb_size, dev_num, &info->eb_size))
 		return -1;
 	if (dev_read_int(lib->dev_bad_rsvd, dev_num, &info->bad_rsvd))
 		return -1;
 	if (dev_read_ll(lib->dev_max_ec, dev_num, &info->max_ec))
 		return -1;
 	if (dev_read_int(lib->dev_max_vols, dev_num, &info->max_vol_count))
 		return -1;
 	if (dev_read_int(lib->dev_min_io_size, dev_num, &info->min_io_size))
 		return -1;

 	info->avail_bytes = info->avail_ebs * info->eb_size;
 	info->total_bytes = info->total_ebs * info->eb_size;

 	return 0;
 }

 int ubi_get_vol_info(libubi_t desc, const char *node, struct ubi_vol_info *info)
 {
 	int vol_id, dev_num;
 	struct libubi *lib = (struct libubi *)desc;

 	dev_num = find_dev_num_vol(lib, node);
 	if (dev_num == -1)
 		return -1;

 	vol_id = find_vol_num(lib, dev_num, node);
 	if (vol_id == -1)
 		return -1;

 	return ubi_get_vol_info1(desc, dev_num, vol_id, info);
 }

 int ubi_get_vol_info1(libubi_t desc, int dev_num, int vol_id,
 		      struct ubi_vol_info *info)
 {
 	int ret;
 	struct libubi *lib = (struct libubi *)desc;
 	char buf[50];

 	memset(info, '\0', sizeof(struct ubi_vol_info));
 	info->dev_num = dev_num;
 	info->vol_id = vol_id;

 	ret = vol_read_data(lib->vol_type, dev_num, vol_id, &buf[0], 50);
 	if (ret < 0)
 		return -1;

 	if (strncmp(&buf[0], "static\n", ret) == 0)
 		info->type = UBI_STATIC_VOLUME;
 	else if (strncmp(&buf[0], "dynamic\n", ret) == 0)
 		info->type = UBI_DYNAMIC_VOLUME;
 	else {
 		fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
 		errno = EINVAL;
 		return -1;
 	}

 	ret = vol_read_int(lib->vol_alignment, dev_num, vol_id,
 			   &info->alignment);
 	if (ret)
 		return -1;
 	ret = vol_read_ll(lib->vol_data_bytes, dev_num, vol_id,
 			  &info->data_bytes);
 	if (ret)
 		return -1;
 	ret = vol_read_int(lib->vol_rsvd_ebs, dev_num, vol_id, &info->rsvd_ebs);
 	if (ret)
 		return -1;
 	ret = vol_read_int(lib->vol_eb_size, dev_num, vol_id, &info->eb_size);
 	if (ret)
 		return -1;
 	ret = vol_read_int(lib->vol_corrupted, dev_num, vol_id,
 			   &info->corrupted);
 	if (ret)
 		return -1;
 	info->rsvd_bytes = info->eb_size * info->rsvd_ebs;

 	ret = vol_read_data(lib->vol_name, dev_num, vol_id, &info->name,
 			    UBI_VOL_NAME_MAX + 2);
 	if (ret < 0)
 		return -1;

 	info->name[ret - 1] = '\0';
 	return 0;
 }

 /**
  * read_int - read an 'int' value from a file.
  *
  * @file   the file to read from
  * @value  the result is stored here
  *
  * This function returns %0 in case of success and %-1 in case of failure.
  */
 static int read_int(const char *file, int *value)
 {
 	int fd, rd;
 	char buf[50];

 	fd = open(file, O_RDONLY);
 	if (fd == -1)
 		return -1;

 	rd = read(fd, &buf[0], 50);
 	if (rd == -1)
 		goto error;

 	if (sscanf(&buf[0], "%d\n", value) != 1) {
 		/* This must be a UBI bug */
 		fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
 		errno = EINVAL;
 		goto error;
 	}

 	close(fd);
 	return 0;

 error:
 	close(fd);
 	return -1;
 }

 /**
  * dev_read_int - read an 'int' value from an UBI device's sysfs file.
  *
  * @patt     the file pattern to read from
  * @dev_num  UBI device number
  * @value    the result is stored here
  *
  * This function returns %0 in case of success and %-1 in case of failure.
  */
 static int dev_read_int(const char *patt, int dev_num, int *value)
 {
 	int fd, rd;
 	char buf[50];
 	char file[strlen(patt) + 50];

 	sprintf(&file[0], patt, dev_num);
 	fd = open(&file[0], O_RDONLY);
 	if (fd == -1)
 		return -1;

 	rd = read(fd, &buf[0], 50);
 	if (rd == -1)
 		goto error;

 	if (sscanf(&buf[0], "%d\n", value) != 1) {
 		/* This must be a UBI bug */
 		fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
 		errno = EINVAL;
 		goto error;
 	}

 	close(fd);
 	return 0;

 error:
 	close(fd);
 	return -1;
 }

 /**
  * dev_read_ll - read a 'long long' value from an UBI device's sysfs file.
  *
  * @patt     the file pattern to read from
  * @dev_num  UBI device number
  * @value    the result is stored here
  *
  * This function returns %0 in case of success and %-1 in case of failure.
  */
 static int dev_read_ll(const char *patt, int dev_num, long long *value)
 {
 	int fd, rd;
 	char buf[50];
 	char file[strlen(patt) + 50];

 	sprintf(&file[0], patt, dev_num);
 	fd = open(&file[0], O_RDONLY);
 	if (fd == -1)
 		return -1;

 	rd = read(fd, &buf[0], 50);
 	if (rd == -1)
 		goto error;

 	if (sscanf(&buf[0], "%lld\n", value) != 1) {
 		/* This must be a UBI bug */
 		fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
 		errno = EINVAL;
 		goto error;
 	}

 	close(fd);
 	return 0;

 error:
 	close(fd);
 	return -1;
 }

 /**
  * dev_read_data - read data from an UBI device's sysfs file.
  *
  * @patt     the file pattern to read from
  * @dev_num  UBI device number
  * @buf      buffer to read data to
  * @buf_len  buffer length
  *
  * This function returns number of read bytes in case of success and %-1 in
  * case of failure.
  */
 static int dev_read_data(const char *patt, int dev_num, void *buf, int buf_len)
 {
 	int fd, rd;
 	char file[strlen(patt) + 50];

 	sprintf(&file[0], patt, dev_num);
 	fd = open(&file[0], O_RDONLY);
 	if (fd == -1)
 		return -1;

 	rd = read(fd, buf, buf_len);
 	if (rd == -1) {
 		close(fd);
 		return -1;
 	}

 	close(fd);
 	return rd;
 }

 /**
  * vol_read_int - read an 'int' value from an UBI volume's sysfs file.
  *
  * @patt     the file pattern to read from
  * @dev_num  UBI device number
  * @vol_id   volume identifier
  * @value    the result is stored here
  *
  * This function returns %0 in case of success and %-1 in case of failure.
  */
 static int vol_read_int(const char *patt, int dev_num, int vol_id, int *value)
 {
 	int fd, rd;
 	char buf[50];
 	char file[strlen(patt) + 100];

 	sprintf(&file[0], patt, dev_num, vol_id);
 	fd = open(&file[0], O_RDONLY);
 	if (fd == -1)
 		return -1;

 	rd = read(fd, &buf[0], 50);
 	if (rd == -1)
 		goto error;

 	if (sscanf(&buf[0], "%d\n", value) != 1) {
 		/* This must be a UBI bug */
 		fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
 		errno = EINVAL;
 		goto error;
 	}

 	close(fd);
 	return 0;

 error:
 	close(fd);
 	return -1;
 }

 /**
  * vol_read_ll - read a 'long long' value from an UBI volume's sysfs file.
  *
  * @patt     the file pattern to read from
  * @dev_num  UBI device number
  * @vol_id   volume identifier
  * @value    the result is stored here
  *
  * This function returns %0 in case of success and %-1 in case of failure.
  */
 static int vol_read_ll(const char *patt, int dev_num, int vol_id,
 		       long long *value)
 {
 	int fd, rd;
 	char buf[50];
 	char file[strlen(patt) + 100];

 	sprintf(&file[0], patt, dev_num, vol_id);
 	fd = open(&file[0], O_RDONLY);
 	if (fd == -1)
 		return -1;

 	rd = read(fd, &buf[0], 50);
 	if (rd == -1)
 		goto error;

 	if (sscanf(&buf[0], "%lld\n", value) != 1) {
 		/* This must be a UBI bug */
 		fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
 		errno = EINVAL;
 		goto error;
 	}

 	close(fd);
 	return 0;

 error:
 	close(fd);
 	return -1;
 }

 /**
  * vol_read_data - read data from an UBI volume's sysfs file.
  *
  * @patt     the file pattern to read from
  * @dev_num  UBI device number
  * @vol_id   volume identifier
  * @buf      buffer to read to
  * @buf_len  buffer length
  *
  * This function returns number of read bytes in case of success and %-1 in
  * case of failure.
  */
 static int vol_read_data(const char *patt, int dev_num, int vol_id, void *buf,
 			 int buf_len)
 {
 	int fd, rd;
 	char file[strlen(patt) + 100];

 	sprintf(&file[0], patt, dev_num, vol_id);
 	fd = open(&file[0], O_RDONLY);
 	if (fd == -1)
 		return -1;

 	rd = read(fd, buf, buf_len);
 	if (rd == -1) {
 		close(fd);
 		return -1;
 	}

 	close(fd);
 	return rd;
 }

 /**
  * mkpath - compose full path from 2 given components.
  *
  * @path  first component
  * @name  second component
  *
  * This function returns the resulting path in case of success and %NULL in
  * case of failure.
  */
 static char *mkpath(const char *path, const char *name)
 {
 	char *n;
 	int len1 = strlen(path);
 	int len2 = strlen(name);

 	n = malloc(len1 + len2 + 2);
 	if (!n)
 		return NULL;

 	memcpy(n, path, len1);
 	if (n[len1 - 1] != '/')
 		n[len1++] = '/';

 	memcpy(n + len1, name, len2 + 1);
 	return n;
 }

 /**
  * find_dev_num - find UBI device number by its character device node.
  *
  * @lib   UBI library descriptor
  * @node  UBI character device node name
  *
  * This function returns positive UBI device number in case of success and %-1
  * in case of failure.
  */
 static int find_dev_num(struct libubi *lib, const char *node)
 {
 	struct stat st;
 	struct ubi_info info;
 	int i, major, minor;

 	if (stat(node, &st))
 		return -1;

 	if (!S_ISCHR(st.st_mode)) {
 		errno = EINVAL;
 		return -1;
 	}

 	major = major(st.st_rdev);
 	minor = minor(st.st_rdev);

 	if (minor != 0) {
 		errno = -EINVAL;
 		return -1;
 	}

 	if (ubi_get_info((libubi_t *)lib, &info))
 		return -1;

 	for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
 		int major1, minor1, ret;
 		char buf[50];

 		ret = dev_read_data(lib->dev_dev, i, &buf[0], 50);
 		if (ret < 0)
 			return -1;

 		ret = sscanf(&buf[0], "%d:%d\n", &major1, &minor1);
 		if (ret != 2) {
 			fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
 			errno = EINVAL;
 			return -1;
 		}

 		if (minor1 == minor && major1 == major)
 			return i;
 	}

 	errno = ENOENT;
 	return -1;
 }

 /**
  * find_dev_num_vol - find UBI device number by volume character device node.
  *
  * @lib   UBI library descriptor
  * @node  UBI character device node name
  *
  * This function returns positive UBI device number in case of success and %-1
  * in case of failure.
  */
 static int find_dev_num_vol(struct libubi *lib, const char *node)
 {
 	struct stat st;
 	struct ubi_info info;
 	int i, major;

 	if (stat(node, &st))
 		return -1;

 	if (!S_ISCHR(st.st_mode)) {
 		errno = EINVAL;
 		return -1;
 	}

 	major = major(st.st_rdev);

 	if (minor(st.st_rdev) == 0) {
 		errno = -EINVAL;
 		return -1;
 	}

 	if (ubi_get_info((libubi_t *)lib, &info))
 		return -1;

 	for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
 		int major1, minor1, ret;
 		char buf[50];

 		ret = dev_read_data(lib->dev_dev, i, &buf[0], 50);
 		if (ret < 0)
 			return -1;

 		ret = sscanf(&buf[0], "%d:%d\n", &major1, &minor1);
 		if (ret != 2) {
 			fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
 			errno = EINVAL;
 			return -1;
 		}

 		if (major1 == major)
 			return i;
 	}

 	errno = ENOENT;
 	return -1;
 }

 /**
  * find_vol_num - find UBI volume number by its character device node.
  *
  * @lib      UBI library descriptor
  * @dev_num  UBI device number
  * @node     UBI volume character device node name
  *
  * This function returns positive UBI volume number in case of success and %-1
  * in case of failure.
  */
 static int find_vol_num(struct libubi *lib, int dev_num, const char *node)
 {
 	struct stat st;
 	struct ubi_dev_info info;
 	int i, major, minor;

 	if (stat(node, &st))
 		return -1;

 	if (!S_ISCHR(st.st_mode)) {
 		errno = EINVAL;
 		return -1;
 	}

 	major = major(st.st_rdev);
 	minor = minor(st.st_rdev);

 	if (minor == 0) {
 		errno = -EINVAL;
 		return -1;
 	}

 	if (ubi_get_dev_info1((libubi_t *)lib, dev_num, &info))
 		return -1;

 	for (i = info.lowest_vol_num; i <= info.highest_vol_num; i++) {
 		int major1, minor1, ret;
 		char buf[50];

 		ret = vol_read_data(lib->vol_dev,  dev_num, i, &buf[0], 50);
 		if (ret < 0)
 			return -1;

 		ret = sscanf(&buf[0], "%d:%d\n", &major1, &minor1);
 		if (ret != 2) {
 			fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
 			errno = EINVAL;
 			return -1;
 		}

 		if (minor1 == minor && major1 == major)
 			return i;
 	}

 	errno = ENOENT;
 	return -1;
 }
	/*
	* Copyright (c) International Business Machines Corp., 2006
	*
	* 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.
	*
	* Author: Artem B. Bityutskiy
	*
	* UBI (Unsorted Block Images) library.
	*/

	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <fcntl.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <dirent.h>
	#include <errno.h>
	#include <unistd.h>
	#include <sys/ioctl.h>
	#include <limits.h>
	#include "libubi.h"
	#include "libubi_int.h"

	libubi_t libubi_open(void)
	{
	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 error;

	lib->sysfs_ubi = mkpath(lib->sysfs, SYSFS_UBI);
	if (!lib->sysfs_ubi)
	goto error;

	/* Make sure UBI is present */
	fd = open(lib->sysfs_ubi, O_RDONLY);
	if (fd == -1)
	goto error;
	close(fd);

	lib->ubi_dev = mkpath(lib->sysfs_ubi, UBI_DEV_NAME_PATT);
	if (!lib->ubi_dev)
	goto error;

	lib->ubi_version = mkpath(lib->sysfs_ubi, UBI_VER);
	if (!lib->ubi_version)
	goto error;

	lib->dev_dev = mkpath(lib->ubi_dev, DEV_DEV);
	if (!lib->dev_dev)
	goto error;

	lib->dev_avail_ebs = mkpath(lib->ubi_dev, DEV_AVAIL_EBS);
	if (!lib->dev_avail_ebs)
	goto error;

	lib->dev_total_ebs = mkpath(lib->ubi_dev, DEV_TOTAL_EBS);
	if (!lib->dev_total_ebs)
	goto error;

	lib->dev_bad_count = mkpath(lib->ubi_dev, DEV_BAD_COUNT);
	if (!lib->dev_bad_count)
	goto error;

	lib->dev_eb_size = mkpath(lib->ubi_dev, DEV_EB_SIZE);
	if (!lib->dev_eb_size)
	goto error;

	lib->dev_max_ec = mkpath(lib->ubi_dev, DEV_MAX_EC);
	if (!lib->dev_max_ec)
	goto error;

	lib->dev_bad_rsvd = mkpath(lib->ubi_dev, DEV_MAX_RSVD);
	if (!lib->dev_bad_rsvd)
	goto error;

	lib->dev_max_vols = mkpath(lib->ubi_dev, DEV_MAX_VOLS);
	if (!lib->dev_max_vols)
	goto error;

	lib->dev_min_io_size = mkpath(lib->ubi_dev, DEV_MIN_IO_SIZE);
	if (!lib->dev_min_io_size)
	goto error;

	lib->ubi_vol = mkpath(lib->sysfs_ubi, UBI_VOL_NAME_PATT);
	if (!lib->ubi_vol)
	goto error;

	lib->vol_type = mkpath(lib->ubi_vol, VOL_TYPE);
	if (!lib->vol_type)
	goto error;

	lib->vol_dev = mkpath(lib->ubi_vol, VOL_DEV);
	if (!lib->vol_dev)
	goto error;

	lib->vol_alignment = mkpath(lib->ubi_vol, VOL_ALIGNMENT);
	if (!lib->vol_alignment)
	goto error;

	lib->vol_data_bytes = mkpath(lib->ubi_vol, VOL_DATA_BYTES);
	if (!lib->vol_data_bytes)
	goto error;

	lib->vol_rsvd_ebs = mkpath(lib->ubi_vol, VOL_RSVD_EBS);
	if (!lib->vol_rsvd_ebs)
	goto error;

	lib->vol_eb_size = mkpath(lib->ubi_vol, VOL_EB_SIZE);
	if (!lib->vol_eb_size)
	goto error;

	lib->vol_corrupted = mkpath(lib->ubi_vol, VOL_CORRUPTED);
	if (!lib->vol_corrupted)
	goto error;

	lib->vol_name = mkpath(lib->ubi_vol, VOL_NAME);
	if (!lib->vol_name)
	goto error;

	if (read_int(lib->ubi_version, &version))
	goto error;
	if (version != LIBUBI_UBI_VERSION) {
	fprintf(stderr, "LIBUBI: this library was made for UBI version "
	"%d, but UBI version %d is detected\n",
	LIBUBI_UBI_VERSION, version);
	goto error;
	}

	return lib;

	error:
	free(lib->vol_corrupted);
	free(lib->vol_eb_size);
	free(lib->vol_rsvd_ebs);
	free(lib->vol_data_bytes);
	free(lib->vol_alignment);
	free(lib->vol_dev);
	free(lib->vol_type);
	free(lib->ubi_vol);
	free(lib->dev_min_io_size);
	free(lib->dev_max_vols);
	free(lib->dev_bad_rsvd);
	free(lib->dev_max_ec);
	free(lib->dev_eb_size);
	free(lib->dev_bad_count);
	free(lib->dev_total_ebs);
	free(lib->dev_avail_ebs);
	free(lib->dev_dev);
	free(lib->ubi_version);
	free(lib->ubi_dev);
	free(lib->sysfs_ubi);
	free(lib->sysfs);
	free(lib);
	return NULL;
	}

	void libubi_close(libubi_t desc)
	{
	struct libubi lib = (struct libubi )desc;

	free(lib->vol_name);
	free(lib->vol_corrupted);
	free(lib->vol_eb_size);
	free(lib->vol_rsvd_ebs);
	free(lib->vol_data_bytes);
	free(lib->vol_alignment);
	free(lib->vol_dev);
	free(lib->vol_type);
	free(lib->ubi_vol);
	free(lib->dev_min_io_size);
	free(lib->dev_max_vols);
	free(lib->dev_bad_rsvd);
	free(lib->dev_max_ec);
	free(lib->dev_eb_size);
	free(lib->dev_bad_count);
	free(lib->dev_total_ebs);
	free(lib->dev_avail_ebs);
	free(lib->dev_dev);
	free(lib->ubi_version);
	free(lib->ubi_dev);
	free(lib->sysfs_ubi);
	free(lib->sysfs);
	free(lib);
	}

	int ubi_get_info(libubi_t desc, struct ubi_info *info)
	{
	DIR *sysfs_ubi;
	struct dirent *dirent;
	struct libubi lib = (struct libubi )desc;

	memset(info, '\0', sizeof(struct ubi_info));

	/*
	* We have to scan the UBI sysfs directory to identify how many UBI
	* devices are present.
	*/
	sysfs_ubi = opendir(lib->sysfs_ubi);
	if (!sysfs_ubi)
	return -1;

	info->lowest_dev_num = INT_MAX;
	while ((dirent = readdir(sysfs_ubi))) {
	char *name = &dirent->d_name[0];
	int dev_num, ret;

	ret = sscanf(name, UBI_DEV_NAME_PATT, &dev_num);
	if (ret == 1) {
	info->dev_count += 1;
	if (dev_num > info->highest_dev_num)
	info->highest_dev_num = dev_num;
	if (dev_num < info->lowest_dev_num)
	info->lowest_dev_num = dev_num;
	}
	}

	if (info->lowest_dev_num == INT_MAX)
	info->lowest_dev_num = 0;

	if (read_int(lib->ubi_version, &info->version))
	goto close;

	return closedir(sysfs_ubi);

	close:
	closedir(sysfs_ubi);
	return -1;
	}

	int ubi_mkvol(libubi_t desc, const char node, struct ubi_mkvol_request req)
	{
	int fd, ret;
	struct ubi_mkvol_req r;
	size_t n;

	desc = desc;
	r.vol_id = req->vol_id;
	r.alignment = req->alignment;
	r.bytes = req->bytes;
	r.vol_type = req->vol_type;

	n = strlen(req->name);
	if (n > UBI_MAX_VOLUME_NAME)
	return -1;

	strncpy(r.name, req->name, UBI_MAX_VOLUME_NAME + 1);
	r.name_len = n;

	fd = open(node, O_RDONLY);
	if (fd == -1)
	return -1;

	ret = ioctl(fd, UBI_IOCMKVOL, &r);
	if (!ret)
	req->vol_id = r.vol_id;

	close(fd);
	return ret;
	}

	int ubi_rmvol(libubi_t desc, const char *node, int vol_id)
	{
	int fd, ret;

	desc = desc;
	fd = open(node, O_RDONLY);
	if (fd == -1)
	return -1;

	ret = ioctl(fd, UBI_IOCRMVOL, &vol_id);
	close(fd);
	return ret;
	}

	int ubi_rsvol(libubi_t desc, const char *node, int vol_id, long long bytes)
	{
	int fd, ret;
	struct ubi_rsvol_req req;

	desc = desc;
	fd = open(node, O_RDONLY);
	if (fd == -1)
	return -1;

	req.bytes = bytes;
	req.vol_id = vol_id;

	ret = ioctl(fd, UBI_IOCRSVOL, &req);
	close(fd);
	return ret;
	}

	int ubi_update_start(libubi_t desc, int fd, long long bytes)
	{
	desc = desc;
	if (ioctl(fd, UBI_IOCVOLUP, &bytes))
	return -1;
	return 0;
	}

	int ubi_get_dev_info(libubi_t desc, const char node, struct ubi_dev_info info)
	{
	int dev_num;
	struct libubi lib = (struct libubi )desc;

	dev_num = find_dev_num(lib, node);
	if (dev_num == -1)
	return -1;

	return ubi_get_dev_info1(desc, dev_num, info);
	}

	int ubi_get_dev_info1(libubi_t desc, int dev_num, struct ubi_dev_info *info)
	{
	DIR *sysfs_ubi;
	struct dirent *dirent;
	struct libubi lib = (struct libubi )desc;

	memset(info, '\0', sizeof(struct ubi_dev_info));
	info->dev_num = dev_num;

	sysfs_ubi = opendir(lib->sysfs_ubi);
	if (!sysfs_ubi)
	return -1;

	info->lowest_vol_num = INT_MAX;
	while ((dirent = readdir(sysfs_ubi))) {
	char *name = &dirent->d_name[0];
	int vol_id, ret, devno;

	ret = sscanf(name, UBI_VOL_NAME_PATT, &devno, &vol_id);
	if (ret == 2 && devno == dev_num) {
	info->vol_count += 1;
	if (vol_id > info->highest_vol_num)
	info->highest_vol_num = vol_id;
	if (vol_id < info->lowest_vol_num)
	info->lowest_vol_num = vol_id;
	}
	}

	closedir(sysfs_ubi);

	if (info->lowest_vol_num == INT_MAX)
	info->lowest_vol_num = 0;

	if (dev_read_int(lib->dev_avail_ebs, dev_num, &info->avail_ebs))
	return -1;
	if (dev_read_int(lib->dev_total_ebs, dev_num, &info->total_ebs))
	return -1;
	if (dev_read_int(lib->dev_bad_count, dev_num, &info->bad_count))
	return -1;
	if (dev_read_int(lib->dev_eb_size, dev_num, &info->eb_size))
	return -1;
	if (dev_read_int(lib->dev_bad_rsvd, dev_num, &info->bad_rsvd))
	return -1;
	if (dev_read_ll(lib->dev_max_ec, dev_num, &info->max_ec))
	return -1;
	if (dev_read_int(lib->dev_max_vols, dev_num, &info->max_vol_count))
	return -1;
	if (dev_read_int(lib->dev_min_io_size, dev_num, &info->min_io_size))
	return -1;

	info->avail_bytes = info->avail_ebs * info->eb_size;
	info->total_bytes = info->total_ebs * info->eb_size;

	return 0;
	}

	int ubi_get_vol_info(libubi_t desc, const char node, struct ubi_vol_info info)
	{
	int vol_id, dev_num;
	struct libubi lib = (struct libubi )desc;

	dev_num = find_dev_num_vol(lib, node);
	if (dev_num == -1)
	return -1;

	vol_id = find_vol_num(lib, dev_num, node);
	if (vol_id == -1)
	return -1;

	return ubi_get_vol_info1(desc, dev_num, vol_id, info);
	}

	int ubi_get_vol_info1(libubi_t desc, int dev_num, int vol_id,
	struct ubi_vol_info *info)
	{
	int ret;
	struct libubi lib = (struct libubi )desc;
	char buf[50];

	memset(info, '\0', sizeof(struct ubi_vol_info));
	info->dev_num = dev_num;
	info->vol_id = vol_id;

	ret = vol_read_data(lib->vol_type, dev_num, vol_id, &buf[0], 50);
	if (ret < 0)
	return -1;

	if (strncmp(&buf[0], "static\n", ret) == 0)
	info->type = UBI_STATIC_VOLUME;
	else if (strncmp(&buf[0], "dynamic\n", ret) == 0)
	info->type = UBI_DYNAMIC_VOLUME;
	else {
	fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
	errno = EINVAL;
	return -1;
	}

	ret = vol_read_int(lib->vol_alignment, dev_num, vol_id,
	&info->alignment);
	if (ret)
	return -1;
	ret = vol_read_ll(lib->vol_data_bytes, dev_num, vol_id,
	&info->data_bytes);
	if (ret)
	return -1;
	ret = vol_read_int(lib->vol_rsvd_ebs, dev_num, vol_id, &info->rsvd_ebs);
	if (ret)
	return -1;
	ret = vol_read_int(lib->vol_eb_size, dev_num, vol_id, &info->eb_size);
	if (ret)
	return -1;
	ret = vol_read_int(lib->vol_corrupted, dev_num, vol_id,
	&info->corrupted);
	if (ret)
	return -1;
	info->rsvd_bytes = info->eb_size * info->rsvd_ebs;

	ret = vol_read_data(lib->vol_name, dev_num, vol_id, &info->name,
	UBI_VOL_NAME_MAX + 2);
	if (ret < 0)
	return -1;

	info->name[ret - 1] = '\0';
	return 0;
	}

	/**
	* read_int - read an 'int' value from a file.
	*
	* @file the file to read from
	* @value the result is stored here
	*
	* This function returns %0 in case of success and %-1 in case of failure.
	*/
	static int read_int(const char file, int value)
	{
	int fd, rd;
	char buf[50];

	fd = open(file, O_RDONLY);
	if (fd == -1)
	return -1;

	rd = read(fd, &buf[0], 50);
	if (rd == -1)
	goto error;

	if (sscanf(&buf[0], "%d\n", value) != 1) {
	/* This must be a UBI bug */
	fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
	errno = EINVAL;
	goto error;
	}

	close(fd);
	return 0;

	error:
	close(fd);
	return -1;
	}

	/**
	* dev_read_int - read an 'int' value from an UBI device's sysfs file.
	*
	* @patt the file pattern to read from
	* @dev_num UBI device number
	* @value the result is stored here
	*
	* This function returns %0 in case of success and %-1 in case of failure.
	*/
	static int dev_read_int(const char patt, int dev_num, int value)
	{
	int fd, rd;
	char buf[50];
	char file[strlen(patt) + 50];

	sprintf(&file[0], patt, dev_num);
	fd = open(&file[0], O_RDONLY);
	if (fd == -1)
	return -1;

	rd = read(fd, &buf[0], 50);
	if (rd == -1)
	goto error;

	if (sscanf(&buf[0], "%d\n", value) != 1) {
	/* This must be a UBI bug */
	fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
	errno = EINVAL;
	goto error;
	}

	close(fd);
	return 0;

	error:
	close(fd);
	return -1;
	}

	/**
	* dev_read_ll - read a 'long long' value from an UBI device's sysfs file.
	*
	* @patt the file pattern to read from
	* @dev_num UBI device number
	* @value the result is stored here
	*
	* This function returns %0 in case of success and %-1 in case of failure.
	*/
	static int dev_read_ll(const char patt, int dev_num, long long value)
	{
	int fd, rd;
	char buf[50];
	char file[strlen(patt) + 50];

	sprintf(&file[0], patt, dev_num);
	fd = open(&file[0], O_RDONLY);
	if (fd == -1)
	return -1;

	rd = read(fd, &buf[0], 50);
	if (rd == -1)
	goto error;

	if (sscanf(&buf[0], "%lld\n", value) != 1) {
	/* This must be a UBI bug */
	fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
	errno = EINVAL;
	goto error;
	}

	close(fd);
	return 0;

	error:
	close(fd);
	return -1;
	}

	/**
	* dev_read_data - read data from an UBI device's sysfs file.
	*
	* @patt the file pattern to read from
	* @dev_num UBI device number
	* @buf buffer to read data to
	* @buf_len buffer length
	*
	* This function returns number of read bytes in case of success and %-1 in
	* case of failure.
	*/
	static int dev_read_data(const char patt, int dev_num, void buf, int buf_len)
	{
	int fd, rd;
	char file[strlen(patt) + 50];

	sprintf(&file[0], patt, dev_num);
	fd = open(&file[0], O_RDONLY);
	if (fd == -1)
	return -1;

	rd = read(fd, buf, buf_len);
	if (rd == -1) {
	close(fd);
	return -1;
	}

	close(fd);
	return rd;
	}

	/**
	* vol_read_int - read an 'int' value from an UBI volume's sysfs file.
	*
	* @patt the file pattern to read from
	* @dev_num UBI device number
	* @vol_id volume identifier
	* @value the result is stored here
	*
	* This function returns %0 in case of success and %-1 in case of failure.
	*/
	static int vol_read_int(const char patt, int dev_num, int vol_id, int value)
	{
	int fd, rd;
	char buf[50];
	char file[strlen(patt) + 100];

	sprintf(&file[0], patt, dev_num, vol_id);
	fd = open(&file[0], O_RDONLY);
	if (fd == -1)
	return -1;

	rd = read(fd, &buf[0], 50);
	if (rd == -1)
	goto error;

	if (sscanf(&buf[0], "%d\n", value) != 1) {
	/* This must be a UBI bug */
	fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
	errno = EINVAL;
	goto error;
	}

	close(fd);
	return 0;

	error:
	close(fd);
	return -1;
	}

	/**
	* vol_read_ll - read a 'long long' value from an UBI volume's sysfs file.
	*
	* @patt the file pattern to read from
	* @dev_num UBI device number
	* @vol_id volume identifier
	* @value the result is stored here
	*
	* This function returns %0 in case of success and %-1 in case of failure.
	*/
	static int vol_read_ll(const char *patt, int dev_num, int vol_id,
	long long *value)
	{
	int fd, rd;
	char buf[50];
	char file[strlen(patt) + 100];

	sprintf(&file[0], patt, dev_num, vol_id);
	fd = open(&file[0], O_RDONLY);
	if (fd == -1)
	return -1;

	rd = read(fd, &buf[0], 50);
	if (rd == -1)
	goto error;

	if (sscanf(&buf[0], "%lld\n", value) != 1) {
	/* This must be a UBI bug */
	fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
	errno = EINVAL;
	goto error;
	}

	close(fd);
	return 0;

	error:
	close(fd);
	return -1;
	}

	/**
	* vol_read_data - read data from an UBI volume's sysfs file.
	*
	* @patt the file pattern to read from
	* @dev_num UBI device number
	* @vol_id volume identifier
	* @buf buffer to read to
	* @buf_len buffer length
	*
	* This function returns number of read bytes in case of success and %-1 in
	* case of failure.
	*/
	static int vol_read_data(const char patt, int dev_num, int vol_id, void buf,
	int buf_len)
	{
	int fd, rd;
	char file[strlen(patt) + 100];

	sprintf(&file[0], patt, dev_num, vol_id);
	fd = open(&file[0], O_RDONLY);
	if (fd == -1)
	return -1;

	rd = read(fd, buf, buf_len);
	if (rd == -1) {
	close(fd);
	return -1;
	}

	close(fd);
	return rd;
	}

	/**
	* mkpath - compose full path from 2 given components.
	*
	* @path first component
	* @name second component
	*
	* This function returns the resulting path in case of success and %NULL in
	* case of failure.
	*/
	static char mkpath(const char path, const char *name)
	{
	char *n;
	int len1 = strlen(path);
	int len2 = strlen(name);

	n = malloc(len1 + len2 + 2);
	if (!n)
	return NULL;

	memcpy(n, path, len1);
	if (n[len1 - 1] != '/')
	n[len1++] = '/';

	memcpy(n + len1, name, len2 + 1);
	return n;
	}

	/**
	* find_dev_num - find UBI device number by its character device node.
	*
	* @lib UBI library descriptor
	* @node UBI character device node name
	*
	* This function returns positive UBI device number in case of success and %-1
	* in case of failure.
	*/
	static int find_dev_num(struct libubi lib, const char node)
	{
	struct stat st;
	struct ubi_info info;
	int i, major, minor;

	if (stat(node, &st))
	return -1;

	if (!S_ISCHR(st.st_mode)) {
	errno = EINVAL;
	return -1;
	}

	major = major(st.st_rdev);
	minor = minor(st.st_rdev);

	if (minor != 0) {
	errno = -EINVAL;
	return -1;
	}

	if (ubi_get_info((libubi_t *)lib, &info))
	return -1;

	for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
	int major1, minor1, ret;
	char buf[50];

	ret = dev_read_data(lib->dev_dev, i, &buf[0], 50);
	if (ret < 0)
	return -1;

	ret = sscanf(&buf[0], "%d:%d\n", &major1, &minor1);
	if (ret != 2) {
	fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
	errno = EINVAL;
	return -1;
	}

	if (minor1 == minor && major1 == major)
	return i;
	}

	errno = ENOENT;
	return -1;
	}

	/**
	* find_dev_num_vol - find UBI device number by volume character device node.
	*
	* @lib UBI library descriptor
	* @node UBI character device node name
	*
	* This function returns positive UBI device number in case of success and %-1
	* in case of failure.
	*/
	static int find_dev_num_vol(struct libubi lib, const char node)
	{
	struct stat st;
	struct ubi_info info;
	int i, major;

	if (stat(node, &st))
	return -1;

	if (!S_ISCHR(st.st_mode)) {
	errno = EINVAL;
	return -1;
	}

	major = major(st.st_rdev);

	if (minor(st.st_rdev) == 0) {
	errno = -EINVAL;
	return -1;
	}

	if (ubi_get_info((libubi_t *)lib, &info))
	return -1;

	for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
	int major1, minor1, ret;
	char buf[50];

	ret = dev_read_data(lib->dev_dev, i, &buf[0], 50);
	if (ret < 0)
	return -1;

	ret = sscanf(&buf[0], "%d:%d\n", &major1, &minor1);
	if (ret != 2) {
	fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
	errno = EINVAL;
	return -1;
	}

	if (major1 == major)
	return i;
	}

	errno = ENOENT;
	return -1;
	}

	/**
	* find_vol_num - find UBI volume number by its character device node.
	*
	* @lib UBI library descriptor
	* @dev_num UBI device number
	* @node UBI volume character device node name
	*
	* This function returns positive UBI volume number in case of success and %-1
	* in case of failure.
	*/
	static int find_vol_num(struct libubi lib, int dev_num, const char node)
	{
	struct stat st;
	struct ubi_dev_info info;
	int i, major, minor;

	if (stat(node, &st))
	return -1;

	if (!S_ISCHR(st.st_mode)) {
	errno = EINVAL;
	return -1;
	}

	major = major(st.st_rdev);
	minor = minor(st.st_rdev);

	if (minor == 0) {
	errno = -EINVAL;
	return -1;
	}

	if (ubi_get_dev_info1((libubi_t *)lib, dev_num, &info))
	return -1;

	for (i = info.lowest_vol_num; i <= info.highest_vol_num; i++) {
	int major1, minor1, ret;
	char buf[50];

	ret = vol_read_data(lib->vol_dev, dev_num, i, &buf[0], 50);
	if (ret < 0)
	return -1;

	ret = sscanf(&buf[0], "%d:%d\n", &major1, &minor1);
	if (ret != 2) {
	fprintf(stderr, "LIBUBI: bad value at sysfs file\n");
	errno = EINVAL;
	return -1;
	}

	if (minor1 == minor && major1 == major)
	return i;
	}

	errno = ENOENT;
	return -1;
	}