ubifs write buffer

UBIFS write-buffer

UBIFS write-buffer

UBIFS is asynchronous file-system (readthis section for more information). Asother Linux file-system, it utilizes the page cache. The page cache isa generic Linux memory-management mechanism. It may be very large and cache alot of data. When you write to a file, the data are written to the page cache,marked as dirty, and the write returns (unless the file is synchronous). Laterthe data are written-back.

Write-buffer is an additional UBIFS buffer, which is implemented insideUBIFS, and it sits between the page cache and the flash. This means thatwrite-back actually writes to the write-buffer, not directly to the flash.

The write-buffer is designated to speed-up UBIFS on NAND flashes. NANDflashes consist of NAND pages, which are usually 512, 2KiB or 4KiB in size.NAND page is the minimal read/write unit of NAND flash (seethis section).

Write-buffer size is equivalent to NAND page size (so it is tiny comparingto the page cache). It's purpose is to accumulate small writes, and write fullNAND pages instead of partially filled. Indeed, imagine we have to write 4512-byte nodes with half a second interval, and NAND page size is 2KiB. Withoutwrite-buffer we would have to write 4 NAND pages and waste 6KiB of flash space,while write-buffer allows us to write only once and waste nothing. This meanswe write less, we create less dirty space so UBIFS garbage collector will haveto do less work, we save power.

Well, the example shows an ideal situation, and even with the write-bufferwe may waste space, for example in case of synchronous I/O, or if the dataarrives with long time intervals. This is because the write-buffer has anassociated timer, which flushes it every 3-5 seconds, even if it isn't full.We do this for data integrity reasons.

Of course, when UBIFS has to write a lot of data, it does not use writebuffer. Only the last part of the data which is smaller than the NAND page endsup in the write-buffer and waits more for data, until it is flushed by thetimer.

The write-buffer implementation is a little more complex, and we actuallyhave several of them - one for each journal head. But this does not change thebasic idea behind the write-buffer.

Few notes with regards to synchronization:

• "sync()" also synchronizes all write-buffers;
• "fsync(fd)" also synchronizes all write-buffers whichcontain pieces of "fd";
• synchronous files, as well as files opened with"O_SYNC", bypass write-buffers, so the I/O is indeedsynchronous for this files;
• write-buffers are also bypassed if the file-system is mounted withthe "-o sync" mount option.

Take into account that write-buffers delay the data synchronization timeoutdefined by "dirty_expire_centisecs" (seehere) by 3-5 seconds. However, sincewrite-buffers are small, only few data are delayed.