static int nfs_read_reply(unsigned char *pkt, unsigned len)
{
int rlen;
uint32_t *data;
int ret;
debug("%s\n", __func__);
ret = rpc_check_reply(pkt, 1);
if (ret)
return ret;
data = (uint32_t *)(pkt + sizeof(struct rpc_reply));
if (!nfs_offset) {
uint32_t filesize = ntohl(net_read_uint32(data + 6));
init_progression_bar(filesize);
}
rlen = ntohl(net_read_uint32(data + 18));
ret = write(net_store_fd, (char *)(data + 19), rlen);
if (ret < 0) {
perror("write");
return ret;
}
return rlen;
}
/*
* Implementation of pwrite with lseek and write.
*/
static ssize_t __pwrite(int fd, const void *buf,
size_t count, loff_t offset, loff_t length)
{
ssize_t ret;
/* Write buf to flash */
ret = pwrite(fd, buf, count, offset);
if (ret < 0) {
perror("pwrite");
if (markbad) {
printf("\nMark block bad at 0x%08llx\n",
offset + memregion.offset);
ioctl(fd, MEMSETBADBLOCK, &offset);
init_progression_bar(length);
show_progress(offset);
}
}
flush(fd);
return ret;
}
/*
* Perform a memory test. The complete test
* loops until interrupted by ctrl-c.
*
* Prameters:
* start: start address for memory test.
* end: end address of memory test.
* bus_only: skip integrity check and do only a address/data bus
* testing.
*
* Return value can be -EINVAL for invalid parameter or -EINTR
* if memory test was interrupted.
*/
int mem_test(resource_size_t _start,
resource_size_t _end, int bus_only)
{
volatile resource_size_t *start, *dummy, val, readback, offset,
offset2, pattern, temp, anti_pattern, num_words;
int i;
_start = ALIGN(_start, sizeof(resource_size_t));
_end = ALIGN_DOWN(_end, sizeof(resource_size_t)) - 1;
if (_end <= _start)
return -EINVAL;
start = (resource_size_t *)_start;
/*
* Point the dummy to start[1]
*/
dummy = start + 1;
num_words = (_end - _start + 1)/sizeof(resource_size_t);
printf("Starting data line test.\n");
/*
* Data line test: write a pattern to the first
* location, write the 1's complement to a 'parking'
* address (changes the state of the data bus so a
* floating bus doen't give a false OK), and then
* read the value back. Note that we read it back
* into a variable because the next time we read it,
* it might be right (been there, tough to explain to
* the quality guys why it prints a failure when the
* "is" and "should be" are obviously the same in the
* error message).
*
* Rather than exhaustively testing, we test some
* patterns by shifting '1' bits through a field of
* '0's and '0' bits through a field of '1's (i.e.
* pattern and ~pattern).
*/
for (i = 0; i < ARRAY_SIZE(bitpattern)/
sizeof(resource_size_t); i++) {
val = bitpattern[i];
for (; val != 0; val <<= 1) {
*start = val;
/* clear the test data off of the bus */
*dummy = ~val;
readback = *start;
if (readback != val) {
printf("FAILURE (data line): "
"expected 0x%08x, actual 0x%08x at address 0x%08x.\n",
val, readback, (resource_size_t)start);
return -EIO;
}
*start = ~val;
*dummy = val;
readback = *start;
if (readback != ~val) {
printf("FAILURE (data line): "
"Is 0x%08x, should be 0x%08x at address 0x%08x.\n",
readback,
~val, (resource_size_t)start);
return -EIO;
}
}
}
/*
* Based on code whose Original Author and Copyright
* information follows: Copyright (c) 1998 by Michael
* Barr. This software is placed into the public
* domain and may be used for any purpose. However,
* this notice must not be changed or removed and no
* warranty is either expressed or implied by its
* publication or distribution.
*/
/*
* Address line test
*
* Description: Test the address bus wiring in a
* memory region by performing a walking
* 1's test on the relevant bits of the
* address and checking for aliasing.
* This test will find single-bit
* address failures such as stuck -high,
* stuck-low, and shorted pins. The base
* address and size of the region are
* selected by the caller.
*
* Notes: For best results, the selected base
* address should have enough LSB 0's to
* guarantee single address bit changes.
* For example, to test a 64-Kbyte
* region, select a base address on a
* 64-Kbyte boundary. Also, select the
* region size as a power-of-two if at
* all possible.
*
* ## NOTE ## Be sure to specify start and end
* addresses such that num_words has
* lots of bits set. For example an
* address range of 01000000 02000000 is
* bad while a range of 01000000
* 01ffffff is perfect.
*/
pattern = 0xAAAAAAAA;
anti_pattern = 0x55555555;
/*
* Write the default pattern at each of the
* power-of-two offsets.
*/
for (offset = 1; offset <= num_words; offset <<= 1)
start[offset] = pattern;
printf("Check for address bits stuck high.\n");
/*
* Check for address bits stuck high.
*/
for (offset = 1; offset <= num_words; offset <<= 1) {
temp = start[offset];
if (temp != pattern) {
printf("FAILURE: Address bit "
"stuck high @ 0x%08x:"
" expected 0x%08x, actual 0x%08x.\n",
(resource_size_t)&start[offset],
pattern, temp);
return -EIO;
}
}
printf("Check for address bits stuck "
"low or shorted.\n");
/*
* Check for address bits stuck low or shorted.
*/
for (offset2 = 1; offset2 <= num_words; offset2 <<= 1) {
start[offset2] = anti_pattern;
for (offset = 1; offset <= num_words; offset <<= 1) {
temp = start[offset];
if ((temp != pattern) &&
(offset != offset2)) {
printf("FAILURE: Address bit stuck"
" low or shorted @"
" 0x%08x: expected 0x%08x, actual 0x%08x.\n",
(resource_size_t)&start[offset],
pattern, temp);
return -EIO;
}
}
start[offset2] = pattern;
}
/*
* We tested only the bus if != 0
* leaving here
*/
if (bus_only)
return 0;
printf("Starting integrity check of physicaly ram.\n"
"Filling ram with patterns...\n");
/*
* Description: Test the integrity of a physical
* memory device by performing an
* increment/decrement test over the
* entire region. In the process every
* storage bit in the device is tested
* as a zero and a one. The base address
* and the size of the region are
* selected by the caller.
*/
/*
* Fill memory with a known pattern.
*/
init_progression_bar(num_words);
for (offset = 0; offset < num_words; offset++) {
/*
* Every 4K we update the progressbar.
*/
if (!(offset & (SZ_4K - 1))) {
if (ctrlc())
return -EINTR;
show_progress(offset);
}
start[offset] = offset + 1;
}
show_progress(offset);
printf("\nCompare written patterns...\n");
/*
* Check each location and invert it for the second pass.
*/
init_progression_bar(num_words - 1);
for (offset = 0; offset < num_words; offset++) {
if (!(offset & (SZ_4K - 1))) {
if (ctrlc())
return -EINTR;
show_progress(offset);
}
temp = start[offset];
if (temp != (offset + 1)) {
printf("\nFAILURE (read/write) @ 0x%08x:"
" expected 0x%08x, actual 0x%08x.\n",
(resource_size_t)&start[offset],
(offset + 1), temp);
return -EIO;
}
anti_pattern = ~(offset + 1);
start[offset] = anti_pattern;
}
show_progress(offset);
printf("\nFilling ram with inverted pattern and compare it...\n");
/*
* Check each location for the inverted pattern and zero it.
*/
init_progression_bar(num_words - 1);
for (offset = 0; offset < num_words; offset++) {
if (!(offset & (SZ_4K - 1))) {
if (ctrlc())
return -EINTR;
show_progress(offset);
}
anti_pattern = ~(offset + 1);
temp = start[offset];
if (temp != anti_pattern) {
printf("\nFAILURE (read/write): @ 0x%08x:"
" expected 0x%08x, actual 0x%08x.\n",
(resource_size_t)&start[offset],
anti_pattern, temp);
return -EIO;
}
start[offset] = 0;
}
show_progress(offset);
/*
* end of progressbar
*/
printf("\n");
return 0;
}
/*
* Erase and write function.
* Param ofs: offset on flash_device.
* Param data: data to write on flash.
* Param rbuf: pointer to allocated buffer to copy readed data.
* Param length: length of testing area
*/
static int erase_and_write(loff_t ofs, unsigned char *data,
unsigned char *rbuf, loff_t length)
{
struct erase_info_user er;
unsigned int i;
int ret;
er.start = ofs;
er.length = meminfo.erasesize;
ret = erase(fd, er.length, er.start);
if (ret < 0) {
perror("\nerase");
printf("Could't not erase flash at 0x%08x length 0x%08x.\n",
er.start, er.length);
return ret;
}
for (i = 0; i < meminfo.erasesize;
i += meminfo.writesize) {
/* Write data to given offset */
__pwrite(fd, data + i, meminfo.writesize,
ofs + i, length);
/* Read data from offset */
pread(fd, rbuf + i, meminfo.writesize, ofs + i);
ret = ioctl(fd, ECCGETSTATS, &newstats);
if (ret < 0) {
perror("\nECCGETSTATS");
return ret;
}
if (newstats.corrected > oldstats.corrected) {
printf("\n %d bit(s) ECC corrected at page 0x%08llx\n",
newstats.corrected - oldstats.corrected,
ofs + memregion.offset + i);
init_progression_bar(length);
show_progress(ofs + i);
if ((newstats.corrected-oldstats.corrected) >=
MAX_ECC_BITS) {
/* Increment ECC stats that
* are over MAX_ECC_BITS */
ecc_stats_over++;
} else {
/* Increment ECC stat value */
ecc_stats[(newstats.corrected -
oldstats.corrected) - 1]++;
}
/* Set oldstats to newstats */
oldstats.corrected = newstats.corrected;
}
if (newstats.failed > oldstats.failed) {
printf("\nECC failed at page 0x%08llx\n",
ofs + memregion.offset + i);
init_progression_bar(length);
show_progress(ofs + i);
oldstats.failed = newstats.failed;
ecc_failed_cnt++;
}
}
/* Compared written data with read data.
* If data is not identical, display a detailed
* debugging information. */
ret = memcmp(data, rbuf, meminfo.erasesize);
if (ret < 0) {
printf("\ncompare failed. seed %d\n", seed);
for (i = 0; i < meminfo.erasesize; i++) {
if (data[i] != rbuf[i])
printf("Byte 0x%x is %02x should be %02x\n",
i, rbuf[i], data[i]);
}
return ret;
}
return 0;
}
/* Main program. */
static int do_nandtest(int argc, char *argv[])
{
int opt, do_nandtest_dev = -1, ret = -1;
loff_t flash_offset = 0, test_ofs, length = 0;
unsigned int nr_iterations = 1, iter;
unsigned char *wbuf, *rbuf;
ecc_failed_cnt = 0;
ecc_stats_over = 0;
markbad = 0;
fd = -1;
memset(ecc_stats, 0, sizeof(*ecc_stats));
while ((opt = getopt(argc, argv, "ms:i:o:l:t")) > 0) {
switch (opt) {
case 'm':
markbad = 1;
break;
case 's':
seed = simple_strtoul(optarg, NULL, 0);
break;
case 'i':
nr_iterations = simple_strtoul(optarg, NULL, 0);
break;
case 'o':
flash_offset = simple_strtoul(optarg, NULL, 0);
break;
case 'l':
length = simple_strtoul(optarg, NULL, 0);
break;
case 't':
do_nandtest_dev = 1;
break;
default:
return COMMAND_ERROR_USAGE;
}
}
/* Check if no device is given */
if (optind >= argc)
return COMMAND_ERROR_USAGE;
if (do_nandtest_dev == -1) {
printf("Please add -t parameter to start nandtest.\n");
return 0;
}
printf("Open device %s\n", argv[optind]);
fd = open(argv[optind], O_RDWR);
if (fd < 0) {
perror("open");
return COMMAND_ERROR_USAGE;
}
/* Getting flash information. */
ret = ioctl(fd, MEMGETINFO, &meminfo);
if (ret < 0) {
perror("MEMGETINFO");
goto err;
}
ret = ioctl(fd, MEMGETREGIONINFO, &memregion);
if (ret < 0) {
perror("MEMGETREGIONINFO");
goto err;
}
ret = ioctl(fd, ECCGETSTATS, &oldstats);
if (ret < 0) {
perror("ECCGETSTATS");
goto err;
}
if (!length) {
length = meminfo.size;
length -= flash_offset;
}
printf("Flash offset: 0x%08llx\n",
flash_offset + memregion.offset);
printf("Length: 0x%08llx\n", length);
printf("End address: 0x%08llx\n",
flash_offset + length + memregion.offset);
printf("Erasesize: 0x%08x\n", meminfo.erasesize);
printf("Starting nandtest...\n");
if (!IS_ALIGNED(meminfo.erasesize, meminfo.writesize)) {
printf("Erasesize 0x%08x is not a multiple "
"of writesize 0x%08x.\n"
"Please check driver implementation\n",
meminfo.erasesize, meminfo.writesize);
goto err;
}
if (!IS_ALIGNED(flash_offset, meminfo.erasesize)) {
printf("Offset 0x%08llx not multiple of erase size 0x%08x\n",
flash_offset, meminfo.erasesize);
goto err;
}
if (!IS_ALIGNED(length, meminfo.erasesize)) {
printf("Length 0x%08llx not multiple of erase size 0x%08x\n",
length, meminfo.erasesize);
goto err;
}
if (length + flash_offset > meminfo.size) {
printf("Length 0x%08llx + offset 0x%08llx exceeds "
"device size 0x%08llx\n", length,
flash_offset, meminfo.size);
goto err;
}
wbuf = malloc(meminfo.erasesize * 2);
if (!wbuf) {
printf("Could not allocate %d bytes for buffer\n",
meminfo.erasesize * 2);
goto err;
}
rbuf = wbuf + meminfo.erasesize;
for (iter = 0; iter < nr_iterations; iter++) {
init_progression_bar(length);
for (test_ofs = 0;
test_ofs < length;
test_ofs += meminfo.erasesize) {
show_progress(test_ofs);
srand(seed);
seed = rand();
if (ioctl(fd, MEMGETBADBLOCK, &test_ofs)) {
printf("\nBad block at 0x%08llx\n",
test_ofs + memregion.offset);
init_progression_bar(length);
show_progress(test_ofs);
continue;
}
get_random_bytes(wbuf, meminfo.erasesize);
ret = erase_and_write(test_ofs, wbuf,
rbuf, length);
if (ret < 0)
goto err2;
}
show_progress(test_ofs);
printf("\nFinished pass %d successfully\n", iter + 1);
}
print_stats(nr_iterations, length);
ret = close(fd);
if (ret < 0) {
perror("close");
goto err2;
}
free(wbuf);
return 0;
err2:
free(wbuf);
err:
printf("Error occurred.\n");
close(fd);
return 1;
}
/**
* @param[in] src FIXME
* @param[out] dst FIXME
* @param[in] verbose FIXME
*/
int copy_file(const char *src, const char *dst, int verbose)
{
char *rw_buf = NULL;
int srcfd = 0, dstfd = 0;
int r, w;
int ret = 1;
void *buf;
int total = 0;
struct stat statbuf;
rw_buf = xmalloc(RW_BUF_SIZE);
srcfd = open(src, O_RDONLY);
if (srcfd < 0) {
printf("could not open %s: %s\n", src, errno_str());
goto out;
}
dstfd = open(dst, O_WRONLY | O_CREAT);
if (dstfd < 0) {
printf("could not open %s: %s\n", dst, errno_str());
goto out;
}
if (verbose) {
if (stat(src, &statbuf) < 0)
statbuf.st_size = 0;
init_progression_bar(statbuf.st_size);
}
while(1) {
r = read(srcfd, rw_buf, RW_BUF_SIZE);
if (r < 0) {
perror("read");
goto out;
}
if (!r)
break;
buf = rw_buf;
while (r) {
w = write(dstfd, buf, r);
if (w < 0) {
perror("write");
goto out;
}
buf += w;
r -= w;
total += w;
}
if (verbose)
show_progress(statbuf.st_size ? total : total / 16384);
}
ret = 0;
out:
if (verbose)
putchar('\n');
free(rw_buf);
if (srcfd > 0)
close(srcfd);
if (dstfd > 0)
close(dstfd);
return ret;
}
/**
* copy_file - Copy a file
* @src: The source filename
* @dst: The destination filename
* @verbose: if true, show a progression bar
*
* Return: 0 for success or negative error code
*/
int copy_file(const char *src, const char *dst, int verbose)
{
char *rw_buf = NULL;
int srcfd = 0, dstfd = 0;
int r, w;
int ret = 1, err1 = 0;
int mode;
void *buf;
int total = 0;
struct stat srcstat, dststat;
rw_buf = xmalloc(RW_BUF_SIZE);
srcfd = open(src, O_RDONLY);
if (srcfd < 0) {
printf("could not open %s: %s\n", src, errno_str());
goto out;
}
mode = O_WRONLY | O_CREAT;
ret = stat(dst, &dststat);
if (ret && ret != -ENOENT)
goto out;
/* Set O_TRUNC only if file exist and is a regular file */
if (!ret && S_ISREG(dststat.st_mode))
mode |= O_TRUNC;
dstfd = open(dst, mode);
if (dstfd < 0) {
printf("could not open %s: %s\n", dst, errno_str());
goto out;
}
if (verbose) {
if (stat(src, &srcstat) < 0)
srcstat.st_size = 0;
init_progression_bar(srcstat.st_size);
}
while (1) {
r = read(srcfd, rw_buf, RW_BUF_SIZE);
if (r < 0) {
perror("read");
goto out;
}
if (!r)
break;
buf = rw_buf;
while (r) {
w = write(dstfd, buf, r);
if (w < 0) {
perror("write");
goto out;
}
buf += w;
r -= w;
total += w;
}
if (verbose) {
if (srcstat.st_size && srcstat.st_size != FILESIZE_MAX)
show_progress(total);
else
show_progress(total / 16384);
}
}
ret = 0;
out:
if (verbose)
putchar('\n');
free(rw_buf);
if (srcfd > 0)
close(srcfd);
if (dstfd > 0)
err1 = close(dstfd);
return ret ?: err1;
}
