lfs_file_close() returns -28 using w25q128

[dacsson]

I am trying to use littlefs with w25q128 flash, i created a config as follows:

struct lfs_config lfs_cfg = {
    // block device operations
    .read  = lfsRead,
    .prog  = lfsProg,
    .erase = lfsErase,
    .sync  = lfsSync,

    // block device configuration
    .read_size		= LFS_BUFFERS_SIZE, // 256
    .prog_size		= LFS_BUFFERS_SIZE, // 256
    .block_size		= EXT_MEM_BLOCK_SIZE, // 4096
    .block_count	= 4096,
    .cache_size		= LFS_BUFFERS_SIZE, //256
    .lookahead_size	= LFS_BUFFERS_SIZE, // 256
    .block_cycles 	= 1500,

	.compact_thresh = -1,
	.read_buffer = lfsBufferRead,
	.prog_buffer = lfsBufferWrite,
	.lookahead_buffer = lfsBufferLookahead,

	.name_max = LFS_NAME_MAX,
	.file_max = LFS_FILE_MAX,
	.attr_max = LFS_ATTR_MAX,
	.metadata_max = EXT_MEM_BLOCK_SIZE,
//	.inline_max = -1,
};

// Read a region in a block. Negative error codes are propagated
// to the user.
int lfsRead(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, void *buffer, lfs_size_t size)
{
	W25qxx_ReadPage((uint8_t*)buffer, block*c->block_size, off, size);
	return LFS_ERR_OK;
}

// Program a region in a block. The block must have previously
// been erased. Negative error codes are propagated to the user.
// May return LFS_ERR_CORRUPT if the block should be considered bad.
int lfsProg(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size)
{
	W25qxx_WritePage((uint8_t*)buffer, block*c->block_size, off, size);
	return LFS_ERR_OK;
}

int lfsErase(const struct lfs_config *c, lfs_block_t block)
{
	W25qxx_EraseSector(block*c->block_size);
	return LFS_ERR_OK;
}

// Sync the state of the underlying block device. Negative error codes
// are propagated to the user.
int lfsSync(const struct lfs_config *c)
{
	return LFS_ERR_OK;
}

Trying to use an example:

void logTest(void)
{
	volatile int state = 0;
	char tstFilename[] = "tst.txt";
	char dataTx[] = "01234567890qwerty\n";
	char dataRx[32] = {0};

	spiFlashInit();
	spiFlashPower(1);
	delay_ms(1000);
	state = W25qxx_Init();
	state = check_write_protection();
	delay_ms(1000);

	state = lfs_mount(&lfs, &lfs_cfg);

	if(state) {
		W25qxx_EraseChip();

		state = lfs_format(&lfs, &lfs_cfg);
		state = lfs_mount(&lfs, &lfs_cfg);
	}

	uint32_t boot_count = 0;
	lfs_file_open(&lfs, &lfs_file, "boot_count", LFS_O_RDWR | LFS_O_CREAT);
	lfs_file_read(&lfs, &lfs_file, &boot_count, sizeof(boot_count));

    boot_count += 1;
    lfs_file_rewind(&lfs, &lfs_file);
    lfs_file_write(&lfs, &lfs_file, &boot_count, sizeof(boot_count));
	state = lfs_file_close(&lfs, &lfs_file);

	state = lfs_unmount(&lfs);

	spiFlashPower(0);

	return;
}

I get -28 error on lfs_file_close(&lfs, &lfs_file), when debugging the last call is lfs_dir_relocatingcommit, but i think the error comes from this:

        if (!tired) {
            LFS_DEBUG("Bad block at 0x%"PRIx32, dir->pair[1]);
        }

        // can't relocate superblock, filesystem is now frozen
        if (lfs_pair_cmp(dir->pair, (const lfs_block_t[2]){0, 1}) == 0) {
            LFS_WARN("Superblock 0x%"PRIx32" has become unwritable",
                    dir->pair[1]);
            return LFS_ERR_NOSPC;
        }

Additional detail is that if erase has happend then the programm hangs with hardfault on lfs_file_open(&lfs, &lfs_file, "boot_count", LFS_O_RDWR | LFS_O_CREAT)

[geky]

Hi @dacsson, I'm not entirely sure what the issue is, but I just wanted to point out -28 (LFS_ERR_NOSPC) is returned here if littlefs finds it can't write to blocks 0 or 1.

In normal use, this can happen near the end of a block device's life (thus LFS_ERR_NOSPC), but it can also happen if you have a bug in your block device layer that prevents writes/reads from working. I would test that you can write and read back from blocks 0 and 1 outside of littlefs, and that block addresses are being mapped correctly.