# Test checksum validation things after = ['test_traversal', 'test_gc', 'test_mount'] code = ''' // naive crc32c static uint32_t test_ck_naive_crc32c( uint32_t crc, const void *buffer, size_t size) { const uint8_t *buffer_ = buffer; crc ^= 0xffffffff; for (size_t i = 0; i < size; i++) { crc = crc ^ buffer_[i]; for (size_t j = 0; j < 8; j++) { crc = (crc >> 1) ^ ((crc & 1) ? 0x82f63b78 : 0); } } crc ^= 0xffffffff; return crc; } // naive crc32c multiplication static uint32_t test_ck_naive_crc32c_mul(uint32_t a, uint32_t b) { // pmul uint64_t r = 0; for (int i = 0; i < 32; i++) { if (b & (1 << i)) { r ^= (uint64_t)a << i; } } // mod crc32c for (int i = 0; i < 31; i++) { r = (r >> 1) ^ ((r & 1) ? 0x82f63b78 : 0); } return (uint32_t)r; } ''' # let's first check that our crc32c math probably works # try some random inputs and compare with a naive implementation [cases.test_ck_crc32c] defines.SIZE = [1, 2, 4, 8, 16, 32, 64] defines.SEED = 'range(10)' defines.N = 1000 fuzz = 'SEED' code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < N; i++) { uint8_t buffer[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { buffer[j] = TEST_PRNG(&prng); } uint32_t a = test_ck_naive_crc32c(0, buffer, SIZE); uint32_t b = lfs_crc32c(0, buffer, SIZE); assert(a == b); } ''' # test incremental crc32cs [cases.test_ck_crc32c_incr] defines.SIZE = [1, 2, 4, 8, 16, 32, 64] defines.SEED = 'range(10)' defines.N = 1000 fuzz = 'SEED' code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < N; i++) { uint8_t buffer[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { buffer[j] = TEST_PRNG(&prng); } uint32_t a = lfs_crc32c(0, buffer, SIZE); uint32_t b = 0; for (lfs_size_t j = 0; j < SIZE; j++) { b = lfs_crc32c(b, &buffer[j], 1); } assert(a == b); } ''' # try some random inputs and compare with a naive implementation [cases.test_ck_crc32c_mul] defines.SEED = 'range(10)' defines.N = 1000 fuzz = 'SEED' code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < N; i++) { uint32_t x = TEST_PRNG(&prng); uint32_t y = TEST_PRNG(&prng); uint32_t a = test_ck_naive_crc32c_mul(x, y); uint32_t b = lfs_crc32c_mul(x, y); assert(a == b); } ''' # test that multiplication is distributive [cases.test_ck_crc32c_mul_dist] defines.SEED = 'range(10)' defines.N = 1000 fuzz = 'SEED' code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < N; i++) { uint32_t x = TEST_PRNG(&prng); uint32_t y = TEST_PRNG(&prng); uint32_t z = TEST_PRNG(&prng); uint32_t a = lfs_crc32c_mul(x, y ^ z); uint32_t b = lfs_crc32c_mul(x, y) ^ lfs_crc32c_mul(x, z); assert(a == b); } ''' # Test filesystem-level checksum things # test that lfsr_fs_cksum doesn't do anything weird [cases.test_ck_cksum] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] if = [ '(SIZE*N)/BLOCK_SIZE <= 32', 'LFS_IFDEF_GC(true, METHOD != 1)', ] code = ''' lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; for (lfs_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_t file; lfsr_file_open(&lfs, &file, name, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; } // get the filesystem cksum uint32_t gcksum; lfsr_fs_cksum(&lfs, &gcksum) => 0; printf("cksum: %08x\n", gcksum); // test that the cksum remains the same after a remount lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; uint32_t gcksum_; lfsr_fs_cksum(&lfs, &gcksum_) => 0; assert(gcksum_ == gcksum); lfsr_unmount(&lfs) => 0; ''' # test we can detect at least fully clobbered blocks [cases.test_ck_ckmeta_easy] # METHOD=0 => lfsr_fs_ckmeta # METHOD=1 => lfsr_fs_gc # METHOD=2 => lfsr_traversal_read # METHOD=3 => lfsr_mount defines.METHOD = [0, 1, 2, 3] defines.GC_FLAGS = 'LFS_GC_CKMETA' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] if = [ '(SIZE*N)/BLOCK_SIZE <= 32', 'LFS_IFDEF_GC(true, METHOD != 1)', ] code = ''' lfs_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; for (lfs_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_t file; lfsr_file_open(&lfs, &file, name, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; } // traverse to find blocks lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t k = 0; for (lfs_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs if (tinfo.btype == LFS_BTYPE_MDIR || tinfo.btype == LFS_BTYPE_BTREE) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; lfsr_traversal_close(&lfs, &t) => 0; goto clobbered; } } k += 1; } } clobbered:; // find clobbered blocks with lfsr_fs_ckmeta if (METHOD == 0) { lfsr_fs_ckmeta(&lfs) => LFS_ERR_CORRUPT; // find clobbered blocks with lfsr_fs_gc } else if (METHOD == 1) { #ifdef LFS_GC lfsr_fs_gc(&lfs) => LFS_ERR_CORRUPT; #else LFS_UNREACHABLE(); #endif // find clobbered blocks with lfsr_traversal_read } else if (METHOD == 2) { lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, LFS_T_CKMETA) => 0; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS_ASSERT(i < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { break; } } lfsr_traversal_close(&lfs, &t) => 0; // find clobbered blocks with lfsr_mount } else if (METHOD == 3) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKMETA, CFG) => LFS_ERR_CORRUPT; } else { assert(false); } if (METHOD != 3) { lfsr_unmount(&lfs) => 0; } } done:; ''' [cases.test_ck_ckdata_easy] # METHOD=0 => lfsr_fs_ckdata # METHOD=1 => lfsr_fs_gc # METHOD=2 => lfsr_traversal_read # METHOD=3 => lfsr_mount defines.METHOD = [0, 1, 2, 3] defines.GC_FLAGS = 'LFS_GC_CKDATA' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] if = [ '(SIZE*N)/BLOCK_SIZE <= 32', 'LFS_IFDEF_GC(true, METHOD != 1)', ] code = ''' lfs_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; for (lfs_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_t file; lfsr_file_open(&lfs, &file, name, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; } // traverse to find blocks lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t k = 0; for (lfs_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs if (tinfo.btype == LFS_BTYPE_MDIR || tinfo.btype == LFS_BTYPE_BTREE || tinfo.btype == LFS_BTYPE_DATA) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; lfsr_traversal_close(&lfs, &t) => 0; goto clobbered; } } k += 1; } } clobbered:; // find clobbered blocks with lfsr_fs_ckmeta if (METHOD == 0) { lfsr_fs_ckdata(&lfs) => LFS_ERR_CORRUPT; // find clobbered blocks with lfsr_fs_gc } else if (METHOD == 1) { #ifdef LFS_GC lfsr_fs_gc(&lfs) => LFS_ERR_CORRUPT; #else LFS_UNREACHABLE(); #endif // find clobbered blocks with lfsr_traversal_read } else if (METHOD == 2) { lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, LFS_T_CKDATA) => 0; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS_ASSERT(i < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { break; } } lfsr_traversal_close(&lfs, &t) => 0; // find clobbered blocks with lfsr_mount } else if (METHOD == 3) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKDATA, CFG) => LFS_ERR_CORRUPT; } else { assert(false); } if (METHOD != 3) { lfsr_unmount(&lfs) => 0; } } done:; ''' # test some more interesting errors [cases.test_ck_ckmeta_hard] # METHOD=0 => lfsr_fs_ckmeta # METHOD=1 => lfsr_fs_gc # METHOD=2 => lfsr_traversal_read # METHOD=3 => lfsr_mount defines.METHOD = [0, 1, 2, 3] defines.GC_FLAGS = 'LFS_GC_CKMETA' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] defines.SEED = 42 defines.M = 100 fuzz = 'SEED' if = [ '(SIZE*N)/BLOCK_SIZE <= 32', 'LFS_IFDEF_GC(true, METHOD != 1)', ] code = ''' uint32_t prng_ = SEED; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; for (lfs_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_t file; lfsr_file_open(&lfs, &file, name, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; } // traverse to find blocks lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t k = 0; lfs_block_t badblock; for (lfs_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; goto done; } if (tinfo.btype == LFS_BTYPE_MDIR || tinfo.btype == LFS_BTYPE_BTREE) { // found an interesting block? if (k == i) { badblock = tinfo.block; lfsr_traversal_close(&lfs, &t) => 0; goto clobber; } k += 1; } } clobber:; // save the current gcksum uint32_t gcksum; lfsr_fs_cksum(&lfs, &gcksum) => 0; // try flipping some bits for (lfs_size_t j = 0; j < M; j++) { // choose a bit lfs_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); // flip printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // find clobbered blocks with lfsr_fs_ckmeta if (METHOD == 0) { int err = lfsr_fs_ckmeta(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } // find clobbered blocks with lfsr_fs_gc } else if (METHOD == 1) { #ifdef LFS_GC int err = lfsr_fs_gc(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } #else LFS_UNREACHABLE(); #endif // find clobbered blocks with lfsr_traversal_read } else if (METHOD == 2) { lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, LFS_T_CKMETA) => 0; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS_ASSERT(i < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_NOENT) { break; } if (err == LFS_ERR_CORRUPT) { lfsr_traversal_close(&lfs, &t) => 0; goto detected; } } lfsr_traversal_close(&lfs, &t) => 0; // find clobbered blocks with lfsr_mount } else if (METHOD == 3) { lfsr_unmount(&lfs) => 0; int err = lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKMETA, CFG); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } } else { assert(false); } goto undetected; undetected:; // It's ok to not always find the error, since our // filesystem contains padding we don't care about, but in // that case we should be able to read all of our files. // // Well... most of our files at least... Rollback issues // mean we can end up in any of our previous filesystem // states, but our gcksum should at least prevent this from // corrupting our filesystem. This is a fundamental issue // for any filesystem with logs (AKA any powerloss-resilient // filesystem). // lfsr_dir_t dir; lfsr_dir_open(&lfs, &dir, "/") => 0; struct lfs_info info; lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfs_size_t found = 0; for (lfs_size_t i = 0;; i++) { int err = lfsr_dir_read(&lfs, &dir, &info); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { break; } found += 1; char name[256]; sprintf(name, "squid%03x", i); assert(strcmp(info.name, name) == 0); assert(info.type == LFS_TYPE_REG); assert(info.size == SIZE); } lfsr_dir_close(&lfs, &dir) => 0; // we should at least detect rollback if we don't lose // power/remount if (METHOD != 3) { assert(found == N); } // if we do lose power/remount, at least the gcksum should // end up different, this allows detecting rollback if // stored externally if (found != N) { uint32_t gcksum_; lfsr_fs_cksum(&lfs, &gcksum_) => 0; assert(gcksum_ != gcksum); } // test we can read the files that survived prng = 42; for (lfs_size_t i = 0; i < found; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_t file; uint8_t rbuf[SIZE]; lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } // unflip our bit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // clear any ck flags for gc lfsr_fs_unck(&lfs, GC_FLAGS) => 0; continue; detected:; // unflip our bit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // remount if we ended up unmounted if (METHOD == 3) { lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; } // clear any ck flags for gc lfsr_fs_unck(&lfs, GC_FLAGS) => 0; continue; } lfsr_unmount(&lfs) => 0; } done:; ''' [cases.test_ck_ckdata_hard] # METHOD=0 => lfsr_fs_ckdata # METHOD=1 => lfsr_fs_gc # METHOD=2 => lfsr_traversal_read # METHOD=3 => lfsr_mount defines.METHOD = [0, 1, 2, 3] defines.GC_FLAGS = 'LFS_GC_CKDATA' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] defines.SEED = 42 defines.M = 100 fuzz = 'SEED' if = [ '(SIZE*N)/BLOCK_SIZE <= 32', 'LFS_IFDEF_GC(true, METHOD != 1)', ] code = ''' uint32_t prng_ = SEED; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; for (lfs_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_t file; lfsr_file_open(&lfs, &file, name, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; } // traverse to find blocks lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t k = 0; lfs_block_t badblock; for (lfs_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; goto done; } if (tinfo.btype == LFS_BTYPE_MDIR || tinfo.btype == LFS_BTYPE_BTREE || tinfo.btype == LFS_BTYPE_DATA) { // found an interesting block? if (k == i) { badblock = tinfo.block; lfsr_traversal_close(&lfs, &t) => 0; goto clobber; } k += 1; } } clobber:; // save the current gcksum uint32_t gcksum = lfs.gcksum; lfsr_fs_cksum(&lfs, &gcksum) => 0; // try flipping some bits for (lfs_size_t j = 0; j < M; j++) { // choose a bit lfs_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); // flip printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // find clobbered blocks with lfsr_fs_ckdata if (METHOD == 0) { int err = lfsr_fs_ckdata(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } // find clobbered blocks with lfsr_fs_gc } else if (METHOD == 1) { #ifdef LFS_GC int err = lfsr_fs_gc(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } #else LFS_UNREACHABLE(); #endif // find clobbered blocks with lfsr_traversal_read } else if (METHOD == 2) { lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, LFS_T_CKDATA) => 0; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS_ASSERT(i < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_NOENT) { break; } if (err == LFS_ERR_CORRUPT) { lfsr_traversal_close(&lfs, &t) => 0; goto detected; } } lfsr_traversal_close(&lfs, &t) => 0; // find clobbered blocks with lfsr_mount } else if (METHOD == 3) { lfsr_unmount(&lfs) => 0; int err = lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKDATA, CFG); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } } else { assert(false); } goto undetected; undetected:; // It's ok to not always find the error, since our // filesystem contains padding we don't care about, but in // that case we should be able to read all of our files. // // Well... most of our files at least... Rollback issues // mean we can end up in any of our previous filesystem // states, but our gcksum should at least prevent this from // corrupting our filesystem. This is a fundamental issue // for any filesystem with logs (AKA any powerloss-resilient // filesystem). // lfsr_dir_t dir; lfsr_dir_open(&lfs, &dir, "/") => 0; struct lfs_info info; lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfs_size_t found = 0; for (lfs_size_t i = 0;; i++) { int err = lfsr_dir_read(&lfs, &dir, &info); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { break; } found += 1; char name[256]; sprintf(name, "squid%03x", i); assert(strcmp(info.name, name) == 0); assert(info.type == LFS_TYPE_REG); assert(info.size == SIZE); } lfsr_dir_close(&lfs, &dir) => 0; // we should at least detect rollback if we don't lose // power/remount if (METHOD != 3) { assert(found == N); } // if we do lose power/remount, at least the gcksum should // end up different, this allows detecting rollback if // stored externally if (found != N) { uint32_t gcksum_; lfsr_fs_cksum(&lfs, &gcksum_) => 0; assert(gcksum_ != gcksum); } // test we can read the files that survived prng = 42; for (lfs_size_t i = 0; i < found; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_t file; uint8_t rbuf[SIZE]; lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } // unflip our bit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // clear any ck flags for gc lfsr_fs_unck(&lfs, GC_FLAGS) => 0; continue; detected:; // unflip our bit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // remount if we ended up unmounted if (METHOD == 3) { lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; } // clear any ck flags for gc lfsr_fs_unck(&lfs, GC_FLAGS) => 0; continue; } lfsr_unmount(&lfs) => 0; } done:; ''' # Test file-level checksum things # test we can detect at least fully clobbered blocks [cases.test_ck_file_ckmeta_easy] # METHOD=0 => lfsr_file_ckmeta # METHOD=1 => lfsr_file_close+open+ckmeta # METHOD=2 => lfsr_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] code = ''' for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; // create an interesting file uint32_t prng = 42; lfsr_file_t file; lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; // traverse to find blocks lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t k = 0; for (lfs_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { lfsr_traversal_close(&lfs, &t) => 0; lfsr_file_close(&lfs, &file) => 0; lfsr_unmount(&lfs) => 0; goto done; } if (tinfo.btype == LFS_BTYPE_BTREE) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; lfsr_traversal_close(&lfs, &t) => 0; goto clobbered; } k += 1; } } clobbered:; // find clobbered blocks with lfsr_file_ckmeta if (METHOD == 0) { lfsr_file_ckmeta(&lfs, &file) => LFS_ERR_CORRUPT; // find clobbered blocks with lfsr_file_close+open+ckmeta } else if (METHOD == 1) { lfsr_file_close(&lfs, &file) => 0; lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY) => 0; lfsr_file_ckmeta(&lfs, &file) => LFS_ERR_CORRUPT; // find clobbered blocks with lfsr_file_close+open } else if (METHOD == 2) { lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY | LFS_O_CKMETA) => LFS_ERR_CORRUPT; } else { assert(false); } if (METHOD != 2) { lfsr_file_close(&lfs, &file) => 0; } lfsr_unmount(&lfs) => 0; } done:; ''' [cases.test_ck_file_ckdata_easy] # METHOD=0 => lfsr_file_ckdata # METHOD=1 => lfsr_file_close+open+ckdata # METHOD=2 => lfsr_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] code = ''' for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; // create an interesting file uint32_t prng = 42; lfsr_file_t file; lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; // traverse to find blocks lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t k = 0; for (lfs_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { lfsr_traversal_close(&lfs, &t) => 0; lfsr_file_close(&lfs, &file) => 0; lfsr_unmount(&lfs) => 0; goto done; } if (tinfo.btype == LFS_BTYPE_BTREE || tinfo.btype == LFS_BTYPE_DATA) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; lfsr_traversal_close(&lfs, &t) => 0; goto clobbered; } k += 1; } } clobbered:; // find clobbered blocks with lfsr_file_ckmeta if (METHOD == 0) { lfsr_file_ckdata(&lfs, &file) => LFS_ERR_CORRUPT; // find clobbered blocks with lfsr_file_close+open+ckmeta } else if (METHOD == 1) { lfsr_file_close(&lfs, &file) => 0; lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY) => 0; lfsr_file_ckdata(&lfs, &file) => LFS_ERR_CORRUPT; // find clobbered blocks with lfsr_file_close+open } else if (METHOD == 2) { lfsr_file_close(&lfs, &file) => 0; lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY | LFS_O_CKDATA) => LFS_ERR_CORRUPT; } else { assert(false); } if (METHOD != 2) { lfsr_file_close(&lfs, &file) => 0; } lfsr_unmount(&lfs) => 0; } done:; ''' # test some more interesting errors [cases.test_ck_file_ckmeta_hard] # METHOD=0 => lfsr_file_ckmeta # METHOD=1 => lfsr_file_close+open+ckmeta # METHOD=2 => lfsr_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] defines.SEED = 42 defines.M = 100 fuzz = 'SEED' code = ''' uint32_t prng_ = SEED; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; // create an interesting file uint32_t prng = 42; lfsr_file_t file; lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; // traverse to find blocks lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t k = 0; lfs_block_t badblock; for (lfs_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { lfsr_traversal_close(&lfs, &t) => 0; lfsr_file_close(&lfs, &file) => 0; lfsr_unmount(&lfs) => 0; goto done; } if (tinfo.btype == LFS_BTYPE_BTREE) { // found an interesting block? if (k == i) { badblock = tinfo.block; lfsr_traversal_close(&lfs, &t) => 0; goto clobber; } k += 1; } } clobber:; // try flipping some bits for (lfs_size_t j = 0; j < M; j++) { // choose a bit lfs_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); // flip printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // find clobbered blocks with lfsr_file_ckmeta if (METHOD == 0) { int err = lfsr_file_ckmeta(&lfs, &file); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } // find clobbered blocks with lfsr_file_close+open+ckmeta } else if (METHOD == 1) { lfsr_file_close(&lfs, &file) => 0; lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY) => 0; int err = lfsr_file_ckmeta(&lfs, &file); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } // find clobbered blocks with lfsr_file_close+open } else if (METHOD == 2) { lfsr_file_close(&lfs, &file) => 0; int err = lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY | LFS_O_CKMETA); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } } else { assert(false); } goto undetected; undetected:; // It's ok to not always find the error, since our // filesystem contains padding we don't care about, but in // that case we should be able to read our file. prng = 42; { uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; lfsr_file_rewind(&lfs, &file) => 0; lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } // unflip our bit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; continue; detected:; // unflip our bit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // reopen our file if we ended up closed if (METHOD == 2) { lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDWR) => 0; } } lfsr_file_close(&lfs, &file) => 0; } done:; ''' [cases.test_ck_file_ckdata_hard] # METHOD=0 => lfsr_file_ckdata # METHOD=1 => lfsr_file_close+open+ckdata # METHOD=2 => lfsr_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] defines.SEED = 42 defines.M = 100 fuzz = 'SEED' code = ''' uint32_t prng_ = SEED; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; // create an interesting file uint32_t prng = 42; lfsr_file_t file; lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; // traverse to find blocks lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t k = 0; lfs_block_t badblock; for (lfs_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { lfsr_traversal_close(&lfs, &t) => 0; lfsr_file_close(&lfs, &file) => 0; lfsr_unmount(&lfs) => 0; goto done; } if (tinfo.btype == LFS_BTYPE_BTREE || tinfo.btype == LFS_BTYPE_DATA) { // found an interesting block? if (k == i) { badblock = tinfo.block; lfsr_traversal_close(&lfs, &t) => 0; goto clobber; } k += 1; } } clobber:; // try flipping some bits for (lfs_size_t j = 0; j < M; j++) { // choose a bit lfs_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); // flip printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // find clobbered blocks with lfsr_file_ckdata if (METHOD == 0) { int err = lfsr_file_ckdata(&lfs, &file); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } // find clobbered blocks with lfsr_file_close+open+ckmeta } else if (METHOD == 1) { lfsr_file_close(&lfs, &file) => 0; lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY) => 0; int err = lfsr_file_ckdata(&lfs, &file); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } // find clobbered blocks with lfsr_file_close+open } else if (METHOD == 2) { lfsr_file_close(&lfs, &file) => 0; int err = lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY | LFS_O_CKDATA); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto detected; } } else { assert(false); } goto undetected; undetected:; // It's ok to not always find the error, since our // filesystem contains padding we don't care about, but in // that case we should be able to read our file. prng = 42; { uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; lfsr_file_rewind(&lfs, &file) => 0; lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // unflip our bit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; continue; detected:; // unflip our bit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // reopen our file if we ended up closed if (METHOD == 2) { lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDWR) => 0; } } lfsr_file_close(&lfs, &file) => 0; } done:; ''' # Some simple ckprog tests # test every single-bit error in block 0/1 [cases.test_ck_ckprogs_mroot] defines.BADBLOCK = [0, 1] defines.BADBIT = -1 defines.BADBLOCK_BEHAVIOR = 'LFS_EMUBD_BADBLOCK_PROGFLIP' # this should stay inlined defines.SIZE = 'BLOCK_SIZE/16' ifdef = 'LFS_CKPROGS' code = ''' // test all bad bits in the mroot for (lfs_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", (lfs_size_t)BADBLOCK, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad lfs_emubd_markbadbit(CFG, BADBLOCK, badbit) => 0; // formatting the filesystem may already find the bit error lfs_t lfs; int err = lfsr_format(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt; } lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; { // create a file lfsr_file_t file; err = lfsr_file_open(&lfs, &file, "physalia", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { goto corrupt_mounted; } err = lfsr_file_close(&lfs, &file); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // if we made it here without erroring we should be able to // read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; } lfsr_file_open(&lfs, &file, "physalia", LFS_O_RDONLY) => 0; uint8_t rbuf[SIZE]; lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; corrupt:; // reset badbit lfs_emubd_markgood(CFG, BADBLOCK) => 0; } ''' # test every single-bit error in a file's data block [cases.test_ck_ckprogs_data] defines.BADBIT = -1 defines.BADBLOCK_BEHAVIOR = 'LFS_EMUBD_BADBLOCK_PROGFLIP' # this should create a single block file defines.SIZE = 'BLOCK_SIZE' ifdef = 'LFS_CKPROGS' code = ''' // first we need to figure out where the data block will actually // end up, fortunately our block randomization is intentionally // consistent // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPROGS, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "physalia", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; // find the data block lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t badblock; while (true) { struct lfs_tinfo tinfo; lfsr_traversal_read(&lfs, &t, &tinfo) => 0; if (tinfo.btype == LFS_BTYPE_DATA) { badblock = tinfo.block; break; } } lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; // now test all bad bits in the data block for (lfs_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad lfs_emubd_markbadbit(CFG, badblock, badbit) => 0; // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPROGS, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; { // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "physalia", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } int err = lfsr_file_close(&lfs, &file); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // if we made it here without erroring we should be able to // read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; } lfsr_file_open(&lfs, &file, "physalia", LFS_O_RDONLY) => 0; uint8_t rbuf[SIZE]; lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; // reset badbit lfs_emubd_markgood(CFG, badblock) => 0; } ''' # test every single-bit error in a file's btree node [cases.test_ck_ckprogs_btree] defines.BADBIT = -1 defines.BADBLOCK_BEHAVIOR = 'LFS_EMUBD_BADBLOCK_PROGFLIP' # force the file to create a btree defines.INLINE_SIZE = 0 defines.CRYSTAL_THRESH = -1 defines.FRAGMENT_SIZE = 'BLOCK_SIZE/8' defines.SIZE = '2*FRAGMENT_SIZE' ifdef = 'LFS_CKPROGS' code = ''' // first we need to figure out where the btree block will actually // end up, fortunately our block randomization is intentionally // consistent // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPROGS, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "physalia", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; // find the btree block lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t badblock; while (true) { struct lfs_tinfo tinfo; lfsr_traversal_read(&lfs, &t, &tinfo) => 0; if (tinfo.btype == LFS_BTYPE_BTREE) { badblock = tinfo.block; break; } } lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; // now test all bad bits in the btree block for (lfs_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad lfs_emubd_markbadbit(CFG, badblock, badbit) => 0; // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPROGS, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; { // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "physalia", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } int err = lfsr_file_close(&lfs, &file); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // if we made it here without erroring we should be able to // read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; } lfsr_file_open(&lfs, &file, "physalia", LFS_O_RDONLY) => 0; uint8_t rbuf[SIZE]; lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; // reset badbit lfs_emubd_markgood(CFG, badblock) => 0; } ''' # Some simple ckfetches tests # test every single-bit error in block 0/1 [cases.test_ck_ckfetches_mroot] defines.BADBLOCK = [0, 1] defines.BADBIT = -1 # this should stay inlined defines.SIZE = 'BLOCK_SIZE/16' ifdef = 'LFS_CKFETCHES' code = ''' // test all bad bits in the mroot for (lfs_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", (lfs_size_t)BADBLOCK, badbit/8, badbit, badbit/8, badbit%8); // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; { // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "stygiomedusa", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; // try to read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; // flip our badbit lfs_emubd_flipbit(CFG, BADBLOCK, badbit) => 0; int err = lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt; } } // yes reads can fail here int err = lfsr_file_open(&lfs, &file, "stygiomedusa", LFS_O_RDONLY); assert(!err // bit errors can also cause our fs state to "rollback", // which is not great but we can't solve this with // ckfetches alone || err == LFS_ERR_NOENT); if (err == LFS_ERR_NOENT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; corrupt:; // reset badbit lfs_emubd_markgood(CFG, BADBLOCK) => 0; } ''' # test every single-bit error in a file's data block [cases.test_ck_ckfetches_data] defines.BADBIT = -1 # this should create a single block file defines.SIZE = 'BLOCK_SIZE' ifdef = 'LFS_CKFETCHES' code = ''' // first we need to figure out where the data block will actually // end up, fortunately our block randomization is intentionally // consistent // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "stygiomedusa", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; // find the data block lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t badblock; while (true) { struct lfs_tinfo tinfo; lfsr_traversal_read(&lfs, &t, &tinfo) => 0; if (tinfo.btype == LFS_BTYPE_DATA) { badblock = tinfo.block; break; } } lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; // now test all bad bits in the data block for (lfs_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; { // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "stygiomedusa", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; // flip our badbit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // try to read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; } // yes reads can fail here int err = lfsr_file_open(&lfs, &file, "stygiomedusa", LFS_O_RDONLY); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; // reset badbit lfs_emubd_markgood(CFG, badblock) => 0; } ''' # test every single-bit error in a file's btree node [cases.test_ck_ckfetches_btree] defines.BADBIT = -1 # force the file to create a btree defines.INLINE_SIZE = 0 defines.CRYSTAL_THRESH = -1 defines.FRAGMENT_SIZE = 'BLOCK_SIZE/8' defines.SIZE = '2*FRAGMENT_SIZE' ifdef = 'LFS_CKFETCHES' code = ''' // first we need to figure out where the btree block will actually // end up, fortunately our block randomization is intentionally // consistent // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "stygiomedusa", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; // find the btree block lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t badblock; while (true) { struct lfs_tinfo tinfo; lfsr_traversal_read(&lfs, &t, &tinfo) => 0; if (tinfo.btype == LFS_BTYPE_BTREE) { badblock = tinfo.block; break; } } lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; // now test all bad bits in the btree block for (lfs_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; { // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "stygiomedusa", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; // flip our badbit lfs_emubd_flipbit(CFG, badblock, badbit) => 0; // try to read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; } // yes reads can fail here int err = lfsr_file_open(&lfs, &file, "stygiomedusa", LFS_O_RDONLY); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; // reset badbit lfs_emubd_markgood(CFG, badblock) => 0; } ''' # Some simple ckparity tests # These tests were originally intended to test all single-bit # metastability errors with ckparity, however they quickly found that # ckparity can't actually guarantee single-bit error-detection since # the bit flip may alter the leb128 encoded size field and find a new, # erronous, parity bit. # # For example, one bit flip: # # 40 0c 00 12 80 0d ff ff # '----.----' ^--------------------. # '- altble 0xc w0 -18 parity=1 # # 40 0c 80 12 80 0d ff ff # '-------.-------' ^----------------------. # '- altble 0xc w2304 -1664 parity=1 # # This doesn't make ckparity _completely_ useless, just mostly useless. # We can still use it to check parity bits, but without a systematic # proof. # # So for now these tests are sort of in stasis, limited to testing # metastability in areas we know we can detect. Maybe future features # will make them more useful. # # test some single-bit errors in block 0/1 [cases.test_ck_ckparity_mroot] defines.BADBLOCK = [0, 1] defines.BADBIT = -1 defines.BADBLOCK_BEHAVIOR = [ 'LFS_EMUBD_BADBLOCK_PROGFLIP', 'LFS_EMUBD_BADBLOCK_READFLIP', ] # this should stay inlined defines.SIZE = 'BLOCK_SIZE/16' ifdef = 'LFS_CKPARITY' code = ''' // test all bad bits in the mroot for (lfs_size_t i = 0; // we can't detect metastable tags, so limit read-flips // to our revision count + first tag i < ((BADBIT == -1) ? 8*6 : 1); i++) { lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; // reset the bd prng every run for reproducibility lfs_emubd_seed(CFG, 42); printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", (lfs_size_t)BADBLOCK, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad lfs_emubd_markbadbit(CFG, BADBLOCK, badbit) => 0; // With metastability, basically any filesystem operation can // return LFS_ERR_CORRUPT. This is ok, what we're really testing // for is no internal/external asserts failing. // format lfs_t lfs; int err = lfsr_format(&lfs, LFS_M_RDWR | LFS_M_CKPARITY, CFG); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt; } err = lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPARITY, CFG); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt; } { // create a file lfsr_file_t file; err = lfsr_file_open(&lfs, &file, "tripedalia", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } err = lfsr_file_close(&lfs, &file); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // try to read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; err = lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPARITY, CFG); if (err == LFS_ERR_CORRUPT) { goto corrupt; } } // yes reads can fail here err = lfsr_file_open(&lfs, &file, "tripedalia", LFS_O_RDONLY); assert(!err || err == LFS_ERR_CORRUPT // bit errors can also cause our fs state to "rollback", // which is not great but we can't solve this with // ckparity alone || err == LFS_ERR_NOENT); if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOENT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; corrupt:; // reset badbit lfs_emubd_markgood(CFG, BADBLOCK) => 0; } ''' # test some single-bit errors in a file's btree node [cases.test_ck_ckparity_btree] defines.BADBIT = -1 defines.BADBLOCK_BEHAVIOR = [ 'LFS_EMUBD_BADBLOCK_PROGFLIP', 'LFS_EMUBD_BADBLOCK_READFLIP', ] # force the file to create a btree defines.INLINE_SIZE = 0 defines.CRYSTAL_THRESH = -1 defines.FRAGMENT_SIZE = 'BLOCK_SIZE/8' defines.SIZE = '2*FRAGMENT_SIZE' ifdef = 'LFS_CKPARITY' code = ''' // first we need to figure out where the btree block will actually // end up, fortunately our block randomization is intentionally // consistent // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPARITY, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPARITY, CFG) => 0; // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "tripedalia", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; // find the btree block lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t badblock; while (true) { struct lfs_tinfo tinfo; lfsr_traversal_read(&lfs, &t, &tinfo) => 0; if (tinfo.btype == LFS_BTYPE_BTREE) { badblock = tinfo.block; break; } } lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; // now test all bad bits in the btree block for (lfs_size_t i = 0; // we can't detect metastable tags, so limit read-flips // to our revision count + first tag i < ((BADBIT == -1) ? 8*6 : 1); i++) { lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; // reset the bd prng every run for reproducibility lfs_emubd_seed(CFG, 42); printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad lfs_emubd_markbadbit(CFG, badblock, badbit) => 0; // With metastability, basically any filesystem operation can // return LFS_ERR_CORRUPT. This is ok, what we're really testing // for is no internal/external asserts failing. // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPARITY, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPARITY, CFG) => 0; { // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "tripedalia", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } int err = lfsr_file_close(&lfs, &file); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // try to read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPARITY, CFG) => 0; } // yes reads can fail here err = lfsr_file_open(&lfs, &file, "tripedalia", LFS_O_RDONLY); assert(!err || err == LFS_ERR_CORRUPT // bit errors can also cause our fs state to "rollback", // which is not great but we can't solve this with // ckparity alone || err == LFS_ERR_NOENT); if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOENT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; // reset badbit lfs_emubd_markgood(CFG, badblock) => 0; } ''' # Some simple ckdatacksums tests # test every single-bit error in a file's data block [cases.test_ck_ckdatacksums_data] defines.BADBIT = -1 defines.BADBLOCK_BEHAVIOR = [ 'LFS_EMUBD_BADBLOCK_PROGFLIP', 'LFS_EMUBD_BADBLOCK_READFLIP', ] # this should create a single block file defines.SIZE = 'BLOCK_SIZE' ifdef = 'LFS_CKDATACKSUMS' code = ''' // first we need to figure out where the data block will actually // end up, fortunately our block randomization is intentionally // consistent // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKDATACKSUMS, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKDATACKSUMS, CFG) => 0; // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "bathykorus", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; lfsr_file_close(&lfs, &file) => 0; // find the data block lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, 0) => 0; lfs_block_t badblock; while (true) { struct lfs_tinfo tinfo; lfsr_traversal_read(&lfs, &t, &tinfo) => 0; if (tinfo.btype == LFS_BTYPE_DATA) { badblock = tinfo.block; break; } } lfsr_traversal_close(&lfs, &t) => 0; lfsr_unmount(&lfs) => 0; // now test all bad bits in the data block for (lfs_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; // reset the bd prng every run for reproducibility lfs_emubd_seed(CFG, 42); printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad lfs_emubd_markbadbit(CFG, badblock, badbit) => 0; // With metastability, basically any filesystem operation can // return LFS_ERR_CORRUPT. This is ok, what we're really testing // for is no internal/external asserts failing. // format lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKDATACKSUMS, CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKDATACKSUMS, CFG) => 0; { // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "bathykorus", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } int err = lfsr_file_close(&lfs, &file); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // try to read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKDATACKSUMS, CFG) => 0; } // yes reads can fail here err = lfsr_file_open(&lfs, &file, "bathykorus", LFS_O_RDONLY); assert(!err || err == LFS_ERR_CORRUPT // bit errors can also cause our fs state to "rollback", // which is not great but we can't solve this with ckreads // alone || err == LFS_ERR_NOENT); if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOENT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); assert(res == SIZE || res == LFS_ERR_CORRUPT); if (res == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; // reset badbit lfs_emubd_markgood(CFG, badblock) => 0; } ''' ## High-level error spam tests # # we basically just throw errors at filesystem operations until they # error with either LFS_ERR_CORRUPT or LFS_ERR_NOSPC # # TODO revisit these when ckredund is implemented, ckredund should # finally close the ckread hole # fuzz errors with fuzz dirs [cases.test_ck_spam_dir_fuzz] # METHOD=0 => ckprogs # METHOD=1 => ckdata # METHOD=2 => ckmeta+ckfetches # METHOD=3 => ckmeta+ckdatacksums defines.METHOD = [0, 1, 2, 3] defines.PERIOD = 10 # protecting the mrootanchor encourages more interesting failures, and # simulates storage with hardened {0,1} blocks defines.PROTECTED_MROOTANCHOR = [false, true] # we can't reliably detect bit errors in erased blocks, we rely on # future progs failing if this happens defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) ? LFS_EMUBD_BADBLOCK_PROGFLIP : LFS_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' defines.MTREEONLY = 'METHOD == 2' defines.CKPROGS = 'METHOD == 0' defines.CKFETCHES = 'METHOD == 2' defines.CKPARITY = false defines.CKDATACKSUMS = 'METHOD == 3' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.SEED = 'range(10)' fuzz = 'SEED' if = [ 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', 'LFS_IFDEF_CKPARITY(true, !CKPARITY)', 'LFS_IFDEF_CKDATACKSUMS(true, !CKDATACKSUMS)', ] code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; lfs_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // // precalculating the permutation avoids issues around running out // of blocks to randomly select uint32_t badblocks[BLOCK_COUNT]; TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test fuzz with dirs lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_F_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_F_CKDATACKSUMS, -1) : 0), CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_M_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_M_CKDATACKSUMS, -1) : 0), CFG) => 0; // set up a simulation to compare against lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); lfs_size_t sim_size = 0; // keep adding errors until we either run out of blocks or detect // corruption lfs_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { lfs_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different // types of errors, so we implement errors for each one a // bit differently // mark our badblock as bad lfs_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { lfs_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { int err = lfsr_fs_ckdata(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { int err = lfsr_fs_ckmeta(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS_ASSERT(i < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_NOENT) { break; } if (err == LFS_ERR_CORRUPT) { lfsr_traversal_close(&lfs, &t) => 0; goto corrupt_mounted; } } lfsr_traversal_close(&lfs, &t) => 0; } } // keep testing... // choose a pseudo-random op, either mkdir, remove, or rename uint8_t op = TEST_PRNG(&prng) % 3; if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals lfs_size_t x = TEST_PRNG(&prng) % N; // insert into our sim for (lfs_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { // do nothing } else { // insert memmove(&sim[j+1], &sim[j], (sim_size-j)*sizeof(lfs_size_t)); sim_size += 1; sim[j] = x; } break; } } // create a directory here char name[256]; sprintf(name, "dir%03x", x); int err = lfsr_mkdir(&lfs, name); assert(!err || err == LFS_ERR_EXIST || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } } else if (op == 1) { // choose a pseudo-random entry to delete lfs_size_t j = TEST_PRNG(&prng) % sim_size; lfs_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "dir%03x", x); int err = lfsr_remove(&lfs, name); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to lfs_size_t j = TEST_PRNG(&prng) % sim_size; lfs_size_t x = sim[j]; lfs_size_t y = TEST_PRNG(&prng) % N; for (lfs_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], (sim_size-k)*sizeof(lfs_size_t)); sim[k] = y; } break; } } // rename this directory char old_name[256]; sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); int err = lfsr_rename(&lfs, old_name, new_name); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_M_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_M_CKDATACKSUMS, -1) : 0), CFG) => 0; } // grm should be zero here assert(lfs.grm_p[0] == 0); // test that our directories match our simulation for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); struct lfs_info info; lfsr_stat(&lfs, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); } lfsr_dir_t dir; lfsr_dir_open(&lfs, &dir, "/") => 0; struct lfs_info info; lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); } lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; lfsr_dir_close(&lfs, &dir) => 0; } corrupt_mounted:; lfsr_unmount(&lfs) => 0; // clean up sim free(sim); // how many errors did we survive? printf("survived %d block errors!\n", (int)(i/PERIOD)); ''' # fuzz errors with fuzz files [cases.test_ck_spam_file_fuzz] # METHOD=0 => ckprogs # METHOD=1 => ckdata # METHOD=2 => ckmeta+ckfetches # METHOD=3 => ckmeta+ckdatacksums defines.METHOD = [0, 1, 2, 3] defines.PERIOD = 10 # protecting the mrootanchor encourages more interesting failures, and # simulates storage with hardened {0,1} blocks defines.PROTECTED_MROOTANCHOR = [false, true] # we can't reliably detect bit errors in erased blocks, we rely on # future progs failing if this happens defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) ? LFS_EMUBD_BADBLOCK_PROGFLIP : LFS_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' defines.MTREEONLY = 'METHOD == 2' defines.CKPROGS = 'METHOD == 0' defines.CKFETCHES = 'METHOD == 2' defines.CKPARITY = false defines.CKDATACKSUMS = 'METHOD == 3' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] defines.SEED = 'range(10)' fuzz = 'SEED' if = [ 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', 'LFS_IFDEF_CKPARITY(true, !CKPARITY)', 'LFS_IFDEF_CKDATACKSUMS(true, !CKDATACKSUMS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; lfs_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // // precalculating the permutation avoids issues around running out // of blocks to randomly select uint32_t badblocks[BLOCK_COUNT]; TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test fuzz with files lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_F_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_F_CKDATACKSUMS, -1) : 0), CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_M_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_M_CKDATACKSUMS, -1) : 0), CFG) => 0; // set up a simulation to compare against lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); lfs_size_t sim_size = 0; // keep adding errors until we either run out of blocks or detect // corruption lfs_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { lfs_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different // types of errors, so we implement errors for each one a // bit differently // mark our badblock as bad lfs_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { lfs_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { int err = lfsr_fs_ckdata(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { int err = lfsr_fs_ckmeta(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS_ASSERT(i < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_NOENT) { break; } if (err == LFS_ERR_CORRUPT) { lfsr_traversal_close(&lfs, &t) => 0; goto corrupt_mounted; } } lfsr_traversal_close(&lfs, &t) => 0; } } // keep testing... // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number lfs_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim for (lfs_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { // new prng sim_prngs[j] = wprng; } else { // insert memmove(&sim[j+1], &sim[j], (sim_size-j)*sizeof(lfs_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; sim[j] = x; sim_prngs[j] = wprng; } break; } } // create a file here char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } lfsr_file_t file; int err = lfsr_file_open(&lfs, &file, name, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC); assert(!err || err == LFS_ERR_NOSPC); if (err) { goto corrupt_mounted; } lfs_ssize_t d = lfsr_file_write(&lfs, &file, wbuf, SIZE); assert(d == SIZE || d == LFS_ERR_NOSPC); if (d == LFS_ERR_NOSPC) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } err = lfsr_file_close(&lfs, &file); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } // deleting a file? } else if (op == 1) { // choose a random file to delete lfs_size_t j = TEST_PRNG(&prng) % sim_size; lfs_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; // delete this file char name[256]; sprintf(name, "amethyst%03x", x); int err = lfsr_remove(&lfs, name); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } // renaming a file? } else { // choose a random file to rename, and a random number to // rename to lfs_size_t j = TEST_PRNG(&prng) % sim_size; lfs_size_t x = sim[j]; lfs_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim for (lfs_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; if (k > j) { k -= 1; } // update the prng sim_prngs[k] = wprng; // just renaming } else { // first delete memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], (sim_size-k)*sizeof(lfs_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; sim_prngs[k] = wprng; } break; } } // rename this file char old_name[256]; sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); int err = lfsr_rename(&lfs, old_name, new_name); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_M_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_M_CKDATACKSUMS, -1) : 0), CFG) => 0; } // check that our files match our simulation for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); struct lfs_info info; lfsr_stat(&lfs, name, &info) => 0; assert(strcmp(info.name, name) == 0); assert(info.type == LFS_TYPE_REG); assert(info.size == SIZE); } lfsr_dir_t dir; lfsr_dir_open(&lfs, &dir, "/") => 0; struct lfs_info info; lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); assert(info.type == LFS_TYPE_REG); assert(info.size == SIZE); } lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; lfsr_dir_close(&lfs, &dir) => 0; // check the file contents for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); lfsr_file_t file; lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; lfs_ssize_t d = lfsr_file_read(&lfs, &file, rbuf, SIZE); assert(d == SIZE || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); if (d == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } corrupt_mounted:; lfsr_unmount(&lfs) => 0; // clean up sim free(sim); free(sim_prngs); // how many errors did we survive? printf("survived %d block errors!\n", (int)(i/PERIOD)); ''' # fuzz errors with more complex file writes [cases.test_ck_spam_fwrite_fuzz] # METHOD=0 => ckprogs # METHOD=1 => ckdata # METHOD=2 => ckmeta+ckfetches # METHOD=3 => ckmeta+ckdatacksums defines.METHOD = [0, 1, 2, 3] defines.PERIOD = 10 # protecting the mrootanchor encourages more interesting failures, and # simulates storage with hardened {0,1} blocks defines.PROTECTED_MROOTANCHOR = [false, true] # we can't reliably detect bit errors in erased blocks, we rely on # future progs failing if this happens defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) ? LFS_EMUBD_BADBLOCK_PROGFLIP : LFS_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' # note we need a full ckmeta if we have open files, ckfetches does not # recheck open btrees defines.MTREEONLY = false defines.CKPROGS = 'METHOD == 0' defines.CKFETCHES = 'METHOD == 2' defines.CKPARITY = false defines.CKDATACKSUMS = 'METHOD == 3' defines.SIZE = [ 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] # chunk is more an upper limit here defines.CHUNK = 64 # INIT=0 => no init # INIT=1 => fill with data # INIT=2 => truncate to size defines.INIT = [0, 1, 2] defines.SYNC = [false, true] defines.SEED = 'range(10)' fuzz = 'SEED' if = [ 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', 'LFS_IFDEF_CKPARITY(true, !CKPARITY)', 'LFS_IFDEF_CKDATACKSUMS(true, !CKDATACKSUMS)', 'CHUNK <= SIZE', # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; lfs_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // // precalculating the permutation avoids issues around running out // of blocks to randomly select uint32_t badblocks[BLOCK_COUNT]; TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test with complex file writes lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_F_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_F_CKDATACKSUMS, -1) : 0), CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_M_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_M_CKDATACKSUMS, -1) : 0), CFG) => 0; // create a file lfsr_file_t file; lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; lfs_off_t size; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { for (lfs_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); lfsr_file_truncate(&lfs, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { lfsr_file_sync(&lfs, &file) => 0; } // keep adding errors until we either run out of blocks or detect // corruption lfs_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { lfs_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different // types of errors, so we implement errors for each one a // bit differently // mark our badblock as bad lfs_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { lfs_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { int err = lfsr_fs_ckdata(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_open; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { int err = lfsr_fs_ckmeta(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_open; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS_ASSERT(i < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_NOENT) { break; } if (err == LFS_ERR_CORRUPT) { lfsr_traversal_close(&lfs, &t) => 0; goto corrupt_open; } } lfsr_traversal_close(&lfs, &t) => 0; } } // keep testing... // choose a random location lfs_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size lfs_size_t chunk = lfs_min( TEST_PRNG(&prng) % CHUNK, SIZE - off); // update sim for (lfs_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } if (chunk != 0) { size = lfs_max(size, off+chunk); } // update file lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; lfs_ssize_t d = lfsr_file_write(&lfs, &file, &sim[off], chunk); assert(d == (lfs_ssize_t)chunk || d == LFS_ERR_NOSPC || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); if (d == LFS_ERR_NOSPC || d == LFS_ERR_CORRUPT) { goto corrupt_open; } // sync? if (SYNC) { int err = lfsr_file_sync(&lfs, &file); assert(!err || err == LFS_ERR_NOSPC || (err == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { goto corrupt_open; } } } int err = lfsr_file_close(&lfs, &file); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_M_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_M_CKDATACKSUMS, -1) : 0), CFG) => 0; } // check our file with stat struct lfs_info info; lfsr_stat(&lfs, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); assert(info.type == LFS_TYPE_REG); assert(info.size == size); // and with dir read lfsr_dir_t dir; lfsr_dir_open(&lfs, &dir, "/") => 0; lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); assert(info.type == LFS_TYPE_REG); assert(info.size == size); lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; lfsr_dir_close(&lfs, &dir) => 0; // try reading our file lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; // is size correct? lfsr_file_size(&lfs, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); lfsr_file_close(&lfs, &file) => 0; } goto corrupt_mounted; corrupt_open:; lfsr_file_desync(&lfs, &file) => 0; lfsr_file_close(&lfs, &file) => 0; corrupt_mounted:; lfsr_unmount(&lfs) => 0; // how many errors did we survive? printf("survived %d block errors! (%d)\n", (int)(i/PERIOD), i); ''' # fuzz errors with uncreats, zombies, etc [cases.test_ck_spam_uz_fuzz] # METHOD=0 => ckprogs # METHOD=1 => ckdata # METHOD=2 => ckmeta+ckfetches # METHOD=3 => ckmeta+ckdatacksums defines.METHOD = [0, 1, 2, 3] defines.PERIOD = 10 # protecting the mrootanchor encourages more interesting failures, and # simulates storage with hardened {0,1} blocks defines.PROTECTED_MROOTANCHOR = [false, true] # we can't reliably detect bit errors in erased blocks, we rely on # future progs failing if this happens defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) ? LFS_EMUBD_BADBLOCK_PROGFLIP : LFS_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' # note we need a full ckmeta if we have open files, ckfetches does not # recheck open btrees defines.MTREEONLY = false defines.CKPROGS = 'METHOD == 0' defines.CKFETCHES = 'METHOD == 2' defines.CKPARITY = false defines.CKDATACKSUMS = 'METHOD == 3' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] defines.SEED = 'range(10)' fuzz = 'SEED' if = [ 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', 'LFS_IFDEF_CKPARITY(true, !CKPARITY)', 'LFS_IFDEF_CKDATACKSUMS(true, !CKDATACKSUMS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; lfs_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // // precalculating the permutation avoids issues around running out // of blocks to randomly select uint32_t badblocks[BLOCK_COUNT]; TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test with uncreats, zombies, etc lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_F_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_F_CKDATACKSUMS, -1) : 0), CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_M_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_M_CKDATACKSUMS, -1) : 0), CFG) => 0; // set up a simulation to compare against lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); lfs_size_t sim_size = 0; typedef struct sim_file { lfs_size_t x; bool uncreat; bool zombie; uint32_t prng; lfsr_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); lfs_size_t sim_file_count = 0; // keep adding errors until we either run out of blocks or detect // corruption lfs_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { lfs_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different // types of errors, so we implement errors for each one a // bit differently // mark our badblock as bad lfs_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { lfs_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { int err = lfsr_fs_ckdata(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { int err = lfsr_fs_ckmeta(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS_ASSERT(i < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_NOENT) { break; } if (err == LFS_ERR_CORRUPT) { lfsr_traversal_close(&lfs, &t) => 0; goto corrupt_mounted; } } lfsr_traversal_close(&lfs, &t) => 0; } } // keep testing... nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 5; // open a new file? if (op == 0) { if (sim_file_count >= N) { goto nonsense; } // choose a pseudo-random number lfs_size_t x = TEST_PRNG(&prng) % N; // already exists? bool uncreat = true; uint32_t wprng = 0; for (lfs_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { uncreat = false; wprng = sim_prngs[j]; break; } } // choose a random seed if we don't exist if (uncreat) { wprng = TEST_PRNG(&prng); } // open in our sim lfs_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); sim_files[j]->x = x; sim_files[j]->uncreat = uncreat; sim_files[j]->zombie = false; sim_files[j]->prng = wprng; // open the actual file char name[256]; sprintf(name, "batman%03x", x); int err = lfsr_file_open(&lfs, &sim_files[j]->file, name, LFS_O_RDWR | LFS_O_CREAT); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } sim_file_count++; // write some initial data if we don't exist if (uncreat) { uint8_t wbuf[SIZE]; for (lfs_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng) % 26); } lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE); assert(d == SIZE || d == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } } // write/rewrite a file? } else if (op == 1) { if (sim_file_count == 0) { goto nonsense; } // choose a random file handle lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; lfs_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // insert into our sim for (lfs_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { // new prng sim_prngs[k] = wprng; } else { // insert memmove(&sim[k+1], &sim[k], (sim_size-k)*sizeof(lfs_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim_size += 1; sim[k] = x; sim_prngs[k] = wprng; } break; } } // update related sim files for (lfs_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { sim_files[k]->uncreat = false; sim_files[k]->prng = wprng; } } } // write to the file lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; for (lfs_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng) % 26); } lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE); assert(d == SIZE || d == LFS_ERR_NOSPC || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); if (d == LFS_ERR_NOSPC || d == LFS_ERR_CORRUPT) { goto corrupt_mounted; } int err = lfsr_file_sync(&lfs, &sim_files[j]->file); assert(err == ((!sim_files[j]->zombie) ? 0 : LFS_ERR_NOENT) || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } // close a file? } else if (op == 2) { if (sim_file_count == 0) { goto nonsense; } // choose a random file handle lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; lfsr_file_close(&lfs, &sim_files[j]->file) => 0; // remove from list free(sim_files[j]); sim_files[j] = sim_files[sim_file_count-1]; sim_file_count -= 1; // remove a file? } else if (op == 3) { if (sim_size == 0) { goto nonsense; } // choose a random file to delete lfs_size_t j = TEST_PRNG(&prng) % sim_size; lfs_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; // mark any related sim files as zombied for (lfs_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } } // delete this file char name[256]; sprintf(name, "batman%03x", x); int err = lfsr_remove(&lfs, name); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } // rename a file? } else if (op == 4) { if (sim_size == 0) { goto nonsense; } // choose a random file to rename, and a random number to // rename to lfs_size_t j = TEST_PRNG(&prng) % sim_size; lfs_size_t x = sim[j]; lfs_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim for (lfs_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; if (k > j) { k -= 1; } // update the prng sim_prngs[k] = wprng; // just renaming } else { // first delete memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], (sim_size-k)*sizeof(lfs_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; sim_prngs[k] = wprng; } break; } } // update any related sim files for (lfs_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; // mark target files as zombied } else if (sim_files[k]->x == y) { sim_files[k]->zombie = true; } } // rename this file char old_name[256]; sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); int err = lfsr_rename(&lfs, old_name, new_name); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } } } // check that disk matches our simulation for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); struct lfs_info info; lfsr_stat(&lfs, name, &info) => 0; assert(strcmp(info.name, name) == 0); assert(info.type == LFS_TYPE_REG); assert(info.size == SIZE); } lfsr_dir_t dir; lfsr_dir_open(&lfs, &dir, "/") => 0; struct lfs_info info; lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); assert(info.type == LFS_TYPE_REG); assert(info.size == SIZE); } lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; lfsr_dir_close(&lfs, &dir) => 0; for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); lfsr_file_t file; lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; lfs_ssize_t d = lfsr_file_read(&lfs, &file, rbuf, SIZE); assert(d == SIZE || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); if (d == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } // check that our file handles match our simulation for (lfs_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; lfs_ssize_t d = lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE); assert(d == SIZE || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); if (d == LFS_ERR_CORRUPT) { goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); } corrupt_mounted:; // clean up sim/lfs free(sim); free(sim_prngs); for (lfs_size_t j = 0; j < sim_file_count; j++) { lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; lfsr_file_close(&lfs, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); lfsr_unmount(&lfs) => 0; // how many errors did we survive? printf("survived %d block errors!\n", (int)(i/PERIOD)); ''' # fuzz errors with uncreats, zombies, dirs, etc [cases.test_ck_spam_uzd_fuzz] # METHOD=0 => ckprogs # METHOD=1 => ckdata # METHOD=2 => ckmeta+ckfetches # METHOD=3 => ckmeta+ckdatacksums defines.METHOD = [0, 1, 2, 3] defines.PERIOD = 10 # protecting the mrootanchor encourages more interesting failures, and # simulates storage with hardened {0,1} blocks defines.PROTECTED_MROOTANCHOR = [false, true] # we can't reliably detect bit errors in erased blocks, we rely on # future progs failing if this happens defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) ? LFS_EMUBD_BADBLOCK_PROGFLIP : LFS_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' # note we need a full ckmeta if we have open files, ckfetches does not # recheck open btrees defines.MTREEONLY = false defines.CKPROGS = 'METHOD == 0' defines.CKFETCHES = 'METHOD == 2' defines.CKPARITY = false defines.CKDATACKSUMS = 'METHOD == 3' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', 'BLOCK_SIZE/2', 'BLOCK_SIZE', '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] defines.SEED = 'range(10)' fuzz = 'SEED' if = [ 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', 'LFS_IFDEF_CKPARITY(true, !CKPARITY)', 'LFS_IFDEF_CKDATACKSUMS(true, !CKDATACKSUMS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; lfs_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // // precalculating the permutation avoids issues around running out // of blocks to randomly select uint32_t badblocks[BLOCK_COUNT]; TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test with uncreats, zombies, dirs, etc lfs_t lfs; lfsr_format(&lfs, LFS_F_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_F_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_F_CKDATACKSUMS, -1) : 0), CFG) => 0; lfsr_mount(&lfs, LFS_M_RDWR | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) | ((CKPARITY) ? LFS_IFDEF_CKPARITY(LFS_M_CKPARITY, -1) : 0) | ((CKDATACKSUMS) ? LFS_IFDEF_CKDATACKSUMS(LFS_M_CKDATACKSUMS, -1) : 0), CFG) => 0; // set up a simulation to compare against lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isdirs = malloc(N*sizeof(bool)); lfs_size_t sim_size = 0; typedef struct sim_file { lfs_size_t x; bool uncreat; bool zombie; uint32_t prng; lfsr_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); lfs_size_t sim_file_count = 0; // keep adding errors until we either run out of blocks or detect // corruption lfs_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { lfs_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different // types of errors, so we implement errors for each one a // bit differently // mark our badblock as bad lfs_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { lfs_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { int err = lfsr_fs_ckdata(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { int err = lfsr_fs_ckmeta(&lfs); assert(!err || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this lfsr_traversal_t t; lfsr_traversal_open(&lfs, &t, LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; for (lfs_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS_ASSERT(i < 2*BLOCK_COUNT); struct lfs_tinfo tinfo; int err = lfsr_traversal_read(&lfs, &t, &tinfo); assert(!err || err == LFS_ERR_NOENT || err == LFS_ERR_CORRUPT); if (err == LFS_ERR_NOENT) { break; } if (err == LFS_ERR_CORRUPT) { lfsr_traversal_close(&lfs, &t) => 0; goto corrupt_mounted; } } lfsr_traversal_close(&lfs, &t) => 0; } } // keep testing... nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 8; // open a new file? if (op == 0) { if (sim_file_count >= N) { goto nonsense; } // choose a pseudo-random number lfs_size_t x = TEST_PRNG(&prng) % N; // already exists? bool uncreat = true; uint32_t wprng = 0; for (lfs_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; } uncreat = false; wprng = sim_prngs[j]; break; } } // choose a random seed if we don't exist if (uncreat) { wprng = TEST_PRNG(&prng); } // open in our sim lfs_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); sim_files[j]->x = x; sim_files[j]->uncreat = uncreat; sim_files[j]->zombie = false; sim_files[j]->prng = wprng; // open the actual file char name[256]; sprintf(name, "batman%03x", x); int err = lfsr_file_open(&lfs, &sim_files[j]->file, name, LFS_O_RDWR | LFS_O_CREAT); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } sim_file_count++; // write some initial data if we don't exist if (uncreat) { uint8_t wbuf[SIZE]; for (lfs_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng) % 26); } lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE); assert(d == SIZE || d == LFS_ERR_NOSPC); if (d == LFS_ERR_NOSPC) { goto corrupt_mounted; } } // write/rewrite a file? } else if (op == 1) { if (sim_file_count == 0) { goto nonsense; } // choose a random file handle lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; lfs_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // insert into our sim for (lfs_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { // new prng sim_prngs[k] = wprng; } else { // insert memmove(&sim[k+1], &sim[k], (sim_size-k)*sizeof(lfs_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isdirs[k+1], &sim_isdirs[k], (sim_size-k)*sizeof(bool)); sim_size += 1; sim[k] = x; sim_prngs[k] = wprng; sim_isdirs[k] = false; } break; } } // update related sim files for (lfs_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { sim_files[k]->uncreat = false; sim_files[k]->prng = wprng; } } } // write to the file lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; for (lfs_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng) % 26); } lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE); assert(d == SIZE || d == LFS_ERR_NOSPC || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); if (d == LFS_ERR_NOSPC || d == LFS_ERR_CORRUPT) { goto corrupt_mounted; } int err = lfsr_file_sync(&lfs, &sim_files[j]->file); assert(err == ((!sim_files[j]->zombie) ? 0 : LFS_ERR_NOENT) || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } // close a file? } else if (op == 2) { if (sim_file_count == 0) { goto nonsense; } // choose a random file handle lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; lfsr_file_close(&lfs, &sim_files[j]->file) => 0; // remove from list free(sim_files[j]); sim_files[j] = sim_files[sim_file_count-1]; sim_file_count -= 1; // remove a file? } else if (op == 3) { if (sim_size == 0) { goto nonsense; } // choose a random file to delete lfs_size_t j = TEST_PRNG(&prng) % sim_size; lfs_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isdirs[j], &sim_isdirs[j+1], (sim_size-(j+1))*sizeof(bool)); sim_size -= 1; // mark any related sim files as zombied for (lfs_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } } // delete this file char name[256]; sprintf(name, "batman%03x", x); int err = lfsr_remove(&lfs, name); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } // rename a file? } else if (op == 4) { if (sim_size == 0) { goto nonsense; } // choose a random file to rename, and a random number to // rename to lfs_size_t j = TEST_PRNG(&prng) % sim_size; lfs_size_t x = sim[j]; lfs_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool isdir = sim_isdirs[j]; // update our sim for (lfs_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // type mismatch? if (sim_isdirs[k] != isdir) { goto nonsense; } // delete the original entry memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isdirs[j], &sim_isdirs[j+1], (sim_size-(j+1))*sizeof(bool)); sim_size -= 1; if (k > j) { k -= 1; } // update the prng sim_prngs[k] = wprng; // just renaming } else { // first delete memmove(&sim[j], &sim[j+1], (sim_size-(j+1))*sizeof(lfs_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isdirs[j], &sim_isdirs[j+1], (sim_size-(j+1))*sizeof(bool)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], (sim_size-k)*sizeof(lfs_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isdirs[k+1], &sim_isdirs[k], (sim_size-k)*sizeof(bool)); sim[k] = y; sim_prngs[k] = wprng; sim_isdirs[k] = isdir; } break; } } // update any related sim files for (lfs_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; // mark target files as zombied } else if (sim_files[k]->x == y) { sim_files[k]->zombie = true; } } // rename this file char old_name[256]; sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); int err = lfsr_rename(&lfs, old_name, new_name); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number lfs_size_t x = TEST_PRNG(&prng) % N; // insert into our sim, use negative numbers for dirs for (lfs_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { goto nonsense; } else { // insert memmove(&sim[k+1], &sim[k], (sim_size-k)*sizeof(lfs_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isdirs[k+1], &sim_isdirs[k], (sim_size-k)*sizeof(bool)); sim_size += 1; sim[k] = x; sim_prngs[k] = 0; sim_isdirs[k] = true; } break; } } // mark any related sim files as zombied for (lfs_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } } // make the directory char name[256]; sprintf(name, "batman%03x", x); int err = lfsr_mkdir(&lfs, name); assert(!err || err == LFS_ERR_NOSPC); if (err == LFS_ERR_NOSPC) { goto corrupt_mounted; } } } // check that disk matches our simulation for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); struct lfs_info info; lfsr_stat(&lfs, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { assert(info.type == LFS_TYPE_DIR); } else { assert(info.type == LFS_TYPE_REG); assert(info.size == SIZE); } } lfsr_dir_t dir; lfsr_dir_open(&lfs, &dir, "/") => 0; struct lfs_info info; lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); assert(info.type == LFS_TYPE_DIR); assert(info.size == 0); for (lfs_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { assert(info.type == LFS_TYPE_DIR); } else { assert(info.type == LFS_TYPE_REG); assert(info.size == SIZE); } } lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; lfsr_dir_close(&lfs, &dir) => 0; for (lfs_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); lfsr_file_t file; lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => LFS_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); lfsr_file_t file; lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; lfs_ssize_t d = lfsr_file_read(&lfs, &file, rbuf, SIZE); assert(d == SIZE || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); if (d == LFS_ERR_CORRUPT) { lfsr_file_close(&lfs, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); lfsr_file_close(&lfs, &file) => 0; } } // check that our file handles match our simulation for (lfs_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; for (lfs_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; lfs_ssize_t d = lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE); assert(d == SIZE || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); if (d == LFS_ERR_CORRUPT) { goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); } corrupt_mounted:; // clean up sim/lfs free(sim); free(sim_prngs); for (lfs_size_t j = 0; j < sim_file_count; j++) { lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; lfsr_file_close(&lfs, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); lfsr_unmount(&lfs) => 0; // how many errors did we survive? printf("survived %d block errors!\n", (int)(i/PERIOD)); '''