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; }