/**
* __check_vol_patt - check that volume contains certain data
*
* @libubi libubi descriptor
* @test test name
* @func function name
* @line line number
* @node volume character device node
* @byte data pattern to check
*
* This function returns %0 if the volume contains only @byte bytes, and %-1 if
* not.
*/
int __check_vol_patt(libubi_t libubi, const char *test, const char *func,
int line, const char *node, uint8_t byte)
{
int ret, fd;
long long bytes = 0;
struct ubi_vol_info vol_info;
unsigned char buf[512];
fd = open(node, O_RDONLY);
if (fd == -1) {
__failed(test, func, line, "open");
__err_msg(test, func, line, "cannot open \"%s\"\n", node);
return -1;
}
ret = ubi_get_vol_info(libubi, node, &vol_info);
if (ret) {
__failed(test, func, line, "ubi_get_vol_info");
goto close;
}
while (bytes < vol_info.data_bytes) {
int i;
memset(buf, ~byte, 512);
ret = read(fd, buf, 512);
if (ret == -1) {
__failed(test, func, line, "read");
__err_msg(test, func, line, "bytes = %lld, ret = %d",
bytes, ret);
goto close;
}
if (ret == 0 && bytes + ret < vol_info.data_bytes) {
__err_msg(test, func, line,
"EOF, but read only %lld bytes of %lld",
bytes + ret, vol_info.data_bytes);
goto close;
}
for (i = 0; i < ret; i++)
if (buf[i] != byte) {
__err_msg(test, func, line,
"byte at %lld is not %#x but %#x",
bytes + i, byte, (int)buf[i]);
goto close;
}
bytes += ret;
}
close(fd);
return 0;
close:
close(fd);
return -1;
}
/**
* __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;
}
/**
* __update_vol_patt - update volume using a certain byte pattern
*
* @libubi libubi descriptor
* @dev_info UBI device description
* @test test name
* @func function name
* @line line number
* @node volume character device node
* @byte data pattern to check
*
* This function returns %0 in case of success, and %-1 if in case of failure.
*/
int __update_vol_patt(libubi_t libubi, const char *test, const char *func,
int line, const char *node, long long bytes, uint8_t byte)
{
int ret, fd;
long long written = 0;
unsigned char buf[512];
fd = open(node, O_RDWR);
if (fd == -1) {
__failed(test, func, line, "open");
__err_msg(test, func, line, "cannot open \"%s\"\n", node);
return -1;
}
if (ubi_update_start(libubi, fd, bytes)) {
__failed(test, func, line, "ubi_update_start");
__err_msg(test, func, line, "bytes = %lld", bytes);
goto close;
}
memset(buf, byte, 512);
while (written != bytes) {
ret = write(fd, buf, 512);
if (ret == -1) {
__failed(test, func, line, "write");
__err_msg(test, func, line, "written = %lld, ret = %d",
written, ret);
goto close;
}
written += ret;
if (written > bytes) {
__err_msg(test, func, line, "update length %lld bytes, "
"but %lld bytes are already written",
bytes, written);
goto close;
}
}
close(fd);
return 0;
close:
close(fd);
return -1;
}
/**
* __check_volume - check volume information.
*
* @libubi libubi descriptor
* @dev_info UBI device description
* @test test name
* @func function name
* @line line number
* @vol_id ID of existing volume to check
* @req volume creation request to compare with
*
* This function checks if a volume created using @req request has exactly the
* requested characteristics. Returns 0 in case of success and %-1 in case of
* error.
*/
int __check_volume(libubi_t libubi, struct ubi_dev_info *dev_info,
const char *test, const char *func, int line, int vol_id,
const struct ubi_mkvol_request *req)
{
int ret;
struct ubi_vol_info vol_info;
int leb_size;
long long rsvd_bytes;
ret = ubi_get_vol_info1(libubi, dev_info->dev_num, vol_id, &vol_info);
if (ret) {
__failed(test, func, line, "ubi_get_vol_info");
return -1;
}
if (req->alignment != vol_info.alignment) {
__err_msg(test, func, line,
"bad alignment: requested %d, got %d",
req->alignment, vol_info.alignment);
return -1;
}
if (req->vol_type != vol_info.type) {
__err_msg(test, func, line, "bad type: requested %d, got %d",
req->vol_type, vol_info.type);
return -1;
}
if (strlen(req->name) != strlen(vol_info.name) ||
strcmp(req->name, vol_info.name) != 0) {
__err_msg(test, func, line,
"bad name: requested \"%s\", got \"%s\"",
req->name, vol_info.name);
return -1;
}
if (vol_info.corrupted) {
__err_msg(test, func, line, "corrupted new volume");
return -1;
}
leb_size = dev_info->leb_size - (dev_info->leb_size % req->alignment);
if (leb_size != vol_info.leb_size) {
__err_msg(test, func, line,
"bad usable LEB size %d, should be %d",
vol_info.leb_size, leb_size);
return -1;
}
rsvd_bytes = req->bytes;
if (rsvd_bytes % leb_size)
rsvd_bytes += leb_size - (rsvd_bytes % leb_size);
if (rsvd_bytes != vol_info.rsvd_bytes) {
__err_msg(test, func, line,
"bad reserved bytes %lld, should be %lld",
vol_info.rsvd_bytes, rsvd_bytes);
return -1;
}
return 0;
}
void __verify(int res, string err_text) {
verify(!__failed(res), err_text);
}
