Large block sizes (LBS)

Storage block sizes are increasing over time. This page documents some of the rationale behind why that is the case in different storage technologies and explains how the Linux kernel is adapting to help support these changes.

Increasing block sizes over time

The increase in larger block sizes has happened before and is happening with more modern storage technologies. This section provides a brief overview of these advancements.

Increase in block sizes on older storage technologies

As storage capacity demands increase it becomes more important to also reduce the amount of space required to store data to also help reduce cost. Old storage devices used a physical block size of 512 bytes. To help with theoretical boundaries on areal density with 512 byte sectors storage devices have advanced to with "long data sectors". 1k became a reality and soon after that 4k physical drives followed.

Increase in block sizes on flash storage

With Flash storage technologies the increase in storage capacities is reflected in NAND through multi-level cells reducing the number of MOSFETs required to store the same amount of data as single level cells. And so we have SLC, MLC, TLC, QLC and PLC. So for example QLC provides 4 bits per cell, holding 33% more capacity than TLC cells.

Indirection Unit size increases

In modern SSDs, an indirection map in the Flash Translation Layer (FTL) enables the device to map writes in its virtual address space to any underlying physical location. Users use LBAs to interact with drives the FTL will use its indirection map for logical to physical (L2P) mapping arranged in a specific configuration to help map specific Logical Page Number (LPN) to Physical Page Number (PPN). This mapping construct is referred to as Indirection Unit (IU). The entire mapping table is kept in storage controller DRAM, the smaller the mapping table the less amount of DRAM needed and therefore the smaller the cost to end users. A 4k IU has sufficed for many years but as storage drive capacities increase it becomes increasingly necessary to embrace larger IUs to reduce SSD cost. An example is the Solidigm D5-P5336 which is clearly marketed with a 16k IU.

It is already well known that using a 16KiB IU provides benefits for large sequential IOs. However, it is important to review what a single 4k write implicates on larger IUs as well. A 4k write on 16k IU implicates a 16k read followed by a 16k write. A Write Amplification Factor (WAF) is defined by what you write over what you actually need to write, so in the worst case for a 16k IU on a 4k IO workload you have can have 16k/4k = 4. In the worst case a 4k write on a 16k IU drive means we're increasing WAF by a factor of 4. Research published by the team at Micron presented by Luca Bert at this year's 2023 Flash Memory Summit suggests that real workloads end up aligning most writes to the IU though, and in practice the WAF is actually much smaller. Luca's summarizes that:

• Using a 16k IU provides 75% DRAM savings
• Using a 16k IU on a series of real workloads, although expectations is a WAF to be around 4, the WAF observed less than 2, and sometimes close to 1
• The data shows that the larger the writes are the lower WAF

• If you are using a 16k IU and you were to count number of IOs for each workload at random points in time and compute WAF, you'd expect that the worst WAF would occur in cases where large IO count would happen at 4k but empirical observations reveals that it is not the IO count that matters, it is the IO volume contribution each IO contributes to a workload.

IU size increase implications on Linux

Although more works should be done to independently verify Micron's finding the adoption of larger IUs for QLC seems inevitable given products are already shipping with them. Storage vendors serious about large capacity QLC drives are embracing either 16k UI already or are looking towards larger IUs. How Linux can also adapt to support and take advantage of 16k and larger IUs is part of the purpose of this page.

===== Alignment to the IU =====

As documented in Intel's large Indirection Unit white paper one of the options to enhance optimal performance and endurance is to align writes to the IU. This can be done with:

• Align partition and its sizes to the IU
• Use direct IO and use posix_memalign() to the IU

At the point this white paper was written the possibility to support buffered IO support larger than 4k was not possible as Linux lacked support for pages in the page cache greater than 4k.

Supporting buffered IO for larger IUs

Direct IO writes means your software will be in charge of doing proper software alignment. This can be done transparently for you by supporting larger block sizes in the page cache aligned to the IU. Although Linux used to not support larger page sizes greater than 4k on x86_64 on the page cache the conversion of the page cache from using a custom radix tree to xarray allows the page cache now to use larger page sizes greater than 4k through folios. This also paves the way to support block sizes greater than the page size (bs > ps), and so block sizes greater than 4k.

By leveraging the use of xarray to support bs > ps we can leverage support for block sizes aligned to the larger IUs and therefore allow the page cache to deal with our read modify writes for IO smaller than the IU.

Linux support for larger block sizes

Linux has supported larger block sizes on both filesystems and bock devices when the PAGE_SIZE is also large for years. Supporting a blocksize > PAGE_SIZE, or bs > ps for short, has required much more work and is the main focus of this page.

This page focuses on the bs > ps world when considering large block sizes for filesystems and storage devices. This page tries to itemize and keep track of progress, outstanding issues, and the ongoing efforts to support bs > ps (LBS) on Linux.

Addressing this is a large endeavor requiring coordination with different subsystems: filesystems, memory & IO.

Filesystem and storage LBS support

Linux filesystems have historically supported limiting their own supported max data blocksize size through the CPU's and operating system PAGE_SIZE. The page size for x86 has been 4k since the i386 days. But Linux also has supported architectures whith page sizes greater than 4k for years. Examples are Power PC with CONFIG_PPC_64K_PAGE, ARM64 with CONFIG_ARM64_64K_PAGES. In fact, some architectures such as ARM64 can support different page sizes.

The XFS filesystem, for example, has supported a up to 64k blocksize for data for years on ppc64 systems with CONFIG_PPC_64K_PAGE. Some RAID systems are known to have existed and sold. To can create a 64k blocksize filesystem you can use:

mkfs.xfs -f -b size=65536

The above will work today even on x86 with 4k PAGE_SIZE, however mount will only work on a system with at least a 64k PAGE_SIZE.

Linux XFS was ported from IRIX's version of XFS, and IRIX had support for larger block sizes than what the CPU supported for its PAGE_SIZE. We refer to this for short as bs > ps. Linux has therefore lacked bs > ps support and adding support for bs > ps should bring XFS up to parity with the features that IRIX XFS used to support.

Supporting bs > ps requires proper operating system support and today we strive to make this easier on Linux through the adoption of folios and iomap. The rest of this document focuses on the bs > ps world when considering LBS for filesystems.

Using a large block size on a filesystem does not necessarily mean you need to use a storage device with a large or matching physical block size. The storage device's actual unit of placement of data is referred to a sector sizes. Although XFS has support for 64 block sizes in the filesystem, the XFS sector size today is limited to 32k.

Most storage devices today work with a max sector size of 4k. Work to support storage devices with larger sector sizes is also part of this endeavor.

Work required

Support for LBS on filesystems and block devices require different types of efforts.

Most work required to get filesystem support with bs > ps consists of the page cache. Testing to ensure this works properly is ongoing. Supporting LBS for filesystems should be done first. A second step would be to support devices which support a larger sector sizes without incurring a larger LBA format. The last step is to work on supporting devices which require a larger LBA format greater than 4k.

Filesystems which already support folios and use iomap will require less work. The main focus on this endeavor then is to work on XFS first.

Device which can support a larger physical size greater than 4k but do not require larger LBA format are possible with device specific parameters. For example NVMe drives which support npwg of 16k and awupf of 16k will be able to leverage support for a 16k physical block size while still supporting a 4k LBA format. A 4k LBA format means your drive will still support backward compatibility with 4k IOs.

However, if a drive only supports a larger LBA format it means the minimum IO always has to be greater than 4k more work is required to support this. The amount of work depends on the type of block device, but there are also shared block layer changes required. Storage device which requires all IO to be larger than 4k will also have further alignment requires for userspace tools.

The page cache assists filesystems by enabling writeback at lower granularity than a block device sector size requires by dealing with changes in memory. This also implicates that if bypassing the page cache, using direct IO, userspace will have to take care to ensure proper alignment considerations when dealing with LBS devices to be larger than what most applications are use to today, that is larger than 4k.

And so there may also be changes required to userspace tools to ensure they always query for the minimum IO and optimal IO.

Block device cache LBS support

Block based storage devices also have an implied block device page cache bdev cache. The Linux bdev cache is used to query the storage device's capacity, and provide the block layer access to information about a drive's partitions. A device which has a capacity, or size, greater than 0 by default gets scanned for partitions on device initialization through the respective device_add_disk(). The bdev cache by default today uses the old buffer-heads to talk to the block device for block data given the block device page cache is implemented as a simple filesystem where each block device gets its own super_block with just one inode representing the entire disk.

CONFIG_BUFFER_HEAD

In Linux you can now avoid using buffer-heads on the block device cache if you only enable filesystems which use iomap. Today that effectively means only enabling xfs and btrfs, and disabling most other filesystems such as ext4. That effectively means you disable CONFIG_BUFFER_HEAD.

Using iomap for the block device cache however is only needed if your device supports a minimum sector size greater than 4k. You can still benefit from LBS and not need CONFIG_BUFFER_HEAD to be disabled if your drive has supports 4k IOs. In reality the need is for the storage drive to support IOs to match at least the system PAGE_SIZE.

block device cache buffer-head and iomap co-existence

Today we have the block device cache either use buffer-heads if CONFIG_BUFFER_HEAD=y. Only if CONFIG_BUFFER_HEAD is disabled will the block device cache use iomap. There is no alternative.

Support for co-existence, to allow a block device to support LBS devices which only support IOs larger than your system PAGE_SIZE but optionally to also block devices which may want to use filesystems which require buffer-heads is underway.

block device cache uses by filesystems

The block device cache is used implicitly to scan partitions. Optionally, it also enables filesystems mounted on block devices to query for metadata by using the backing block device super_block. This takes advantage of the fact that the page cache could have basic information about its backing device already in memory through the initial block partition scanning. Filesystems can query a backing block device super_block through buffer-head calls such as:

• sb_bread()

• sb_bread_unmovable()

• sb_breadahead()

• sb_getblk()

• sb_getblk_gfp()

• sb_find_get_block()

Not all filesystems use the block device cache for metadata though. XFS for example has it's own metadata address space for caching. The xfs_buf buffer cache does not use the page cache either. It does it's own thing, has it's own indexing, locking, shrinkers, etc. It also does not use iomap at all either - iomap is used by XFS exclusively for data IO. This means XFS relies on an uncached buffer for its backing device super_block. XFS does this mostly for historic reasons.

Block driver support

Not all block drivers are yet equipped to support LBS drives. Each one would need to be modified to ensure they work with LBS.

NVMe

NVMe disables LBS drives today if the LBA format is greater than the system PAGE_SIZE. Work to fix this is underway.

Requirements for LBS

A world with a 4 KiB PAGE_SIZE and bs, ie bs = 4k = bs is rather simple due to writeback considerations with memory pressure. If your storage device has a bs > PAGE_SIZE, the kernel can only send a write once it has in memory all the data required. In this situation reading data means you also would have to wait for all the data to be read from the drive, you could use something like a bit bucket, however that would mean that data would somehow have to be invalidated should a write come through during say a second PAGE_SIZE read on data on a storage block of twice the PAGE_SIZE.

How folios help LBS

To address the complexity of writeback when the storage supports bs > PAGE_SIZE folios should be used as a long term solution for the page cache, to opportunistically cache files in larger chunks, however there are some problems that need to be considered and measured to prove / disprove its value for storage. Folios can be used to address the writeback problem by ensuring that the block size for the storage is treated as a single unit in the page cache. A problem with this is the assumption that the kernel can provide the target block IO size for new allocations over time in light of possible memory fragmentation.

A hypothesis to consider here is that if a filesystem is regularly creating allocations in the block size required for the IO storage device the kernel will also then be able to reclaim memory in these block sizes. In the worst case some workloads may end up spiraling down with no allocations being available for the target IO block size. Testing this hypothesis is something which we all in the community could work on. The more memory gets cached using folios the easier it becomes to address problems and contentions with memory using bs > ps.

Folio order count recap

Folio sizes are more easily kept track of with the folio order size, this is the power of 2 of the respective PAGE_SIZE. So order 0 is one 2^{0 so one PAGE_SIZE folio. Order 2 is 2}2 so 4 * PAGE_SIZE so 16k.

No order 1 folio or 8k support

Folios currently have a deffered_list on the third page for large folios, due to this requirement large folios must be at least 16k, so order 2.

Filesystem LBS support

In order to provide support for a larger block size a filesystem needs to provide the correct offset-in-file to block-on-disk mapping. Supporting LBS with reflinks / CoW can be more complicated. For example, on memory pressure on write, the kernel would need all the corresponding 64 KiB pages in memory. Low memory pressure could easily create problems synchronization issues.

Filesystems provide offset-in-file to block-on-disk mapping through the old buffer-head or newer IOMAP. Synchronization and dealing with LBS atomically is enabled by using folios.

LBS with buffer-heads

Linux buffer-heads, implemented in fs/buffer.c, provides filesystems a 512 byte buffer array based block mapping abstraction for dealing with block devices and the page cache. Filesystems supply a filesystem callback get_block_t when issuing calls to buffer-heads when they want to request an IO to a block device, the get_block_t callback is in charge of providing the filesystem block which buffer-heads will submit_bio() for. Filesystems would use the get_block_t callback in buffer-heads calls such as:

  * block_write_full_page(..., get_block_t *get_block, ...)
  * __block_write_full_page(..., get_block_t *get_block, ...)
  * block_read_full_folio(struct folio *, get_block_t *)
  * block_write_begin(..., get_block_t *get_block, ...)
  * __block_write_begin(..., get_block_t *get_block, ...)
  * cont_write_begin(..., get_block_t *, ...)
  * block_page_mkwrite(..., get_block_t *, ...)
  * generic_block_bmap(..., get_block_t *);

Filesystems or the bdev cache can request higher order folios through buffer-heads when the bs > ps.

LBS with IOMAP

The newer IOMAP allows filesystems to provide callbacks in a similar way but it was designed instead allow filesystems to simplify the filesystem block-mapping callbacks for each type of need within the filesystem. This allows the filesystem callbacks to be easier to read and dedicated towards each specific need.

LBS with storage devices

Storage devices announce their physical block sizes to Linux by setting the physical block size with call blk_queue_physical_block_size(). To help with stacking IO devices and to ensure backward compatibility with older userspace it can announce a smaller logical block size with blk_queue_logical_block_size().

LBS with NVMe

NVMe sets the logical and physical block size on nvme_update_disk_info(). The logical block size is set to the NVMe blocksize. The physical block size is set as the minimum between NVMe blocksize and the NVMe's announced atomic block size (nawupf or awupf).

Today NVMe drives with an LBA format with a blocksize greater than the PAGE_SIZE are effectively disabled by assigning a disk capacity of 0 using set_capacity_and_notify(disk, 0).

Enabling support for NVMe drives where the storage bs > ps requires some effort which is currently being worked on.

NVMe LBA format

NVMe drives support different data block sizes through the different LBA formats it supports. To query what LBA format your drive supports you can use something like the following with nvme-cli.

nvme id-ns -H /dev/nvme4n1 | grep ^LBA
LBA Format  0 : Metadata Size: 0   bytes - Data Size: 512 bytes - Relative Performance: 0 Best 
LBA Format  1 : Metadata Size: 0   bytes - Data Size: 4096 bytes - Relative Performance: 0 Best (in use)

This is an example NVMe drive which supports two different LBA formats, one where the physical data block size is 512 bytes and another where the data physical block size is 4096 bytes. To format a drive to a format one can use the nvme-cli format. For example to use the above LBA format for 4k we'd use:

nvme format --lbaf=1 --force /dev/nvme4n1 

LBS Storage alignment considerations

Reads and writes to storage drives need to be aligned to the storage medium's physical block size to enhance performance and correctness. To help with this Linux started exporting to userspace block device and partition IO topologies after Linux commit c72758f33784 ("block: Export I/O topology for block devices and partitions") in May 2009. This enables Linux tools (parted, lvm, mkfs.*, etc) to optimize placement of and access to data. Proper alignment is especially important for Direct IO since the page cache is not aligned to assist with lower granularity reads or writes or writeback, and so all direct IO should be aligned to the logical block size otherwise IO will fail.

The logical block size then is a Linux software construct to help ensure backward compatibility with older userspace and to also support stacking IO devices together (RAID).

Checking physical and logical block sizes

Below is an example of how to check for the physical and logical block sizes of an NVMe drive.

cat /sys/block/nvme0n1/queue/logical_block_size                             
512                                                                                                  
cat /sys/block/nvme0n1/queue/physical_block_size                            
4096

4kn alignment example

Drives which support only 4k block sizes are referred to as using an Advanced Format 4kn, these are devices where the physical block size and logical block size are 4k. For these devices it important that applications perform direct IO that is multiple of 4k, this ensures it is aligned to 4k. Applications that perform 512 byte aligned IO on 4kn drives will break

Alignment considerations beyond 4kn

In light of prior experience in dealing with increasing physical block sizes on storage devices, since modern userspace *should* be reading the physical and logical block sizes prior to doing IO, *in theory* increasing storage device physical block sizes should not be an issue and not require much, if any changes.

Relevant block layer historic Linux commits

• e1defc4ff0cf ("block:

Do away with the notion of hardsect_size"). So the sysfs hw_sector_size is just the old name.

• ae03bf639a50 (block: Use accessor functions for queue limits)

• cd43e26f0715 (block: Expose stacked device queues in sysfs)

• 025146e13b63 (block: Move queue limits to an embedded struct)

• c72758f33784 (block: Export I/O topology for block devices and partitions)

It is worth quoting in full the commit which added the logical block size to userspace:

block: Export I/O topology for block devices and partitions
To support devices with physical block sizes bigger than 512 bytes we
need to ensure proper alignment.  This patch adds support for exposing
I/O topology characteristics as devices are stacked.

  logical_block_size is the smallest unit the device can address.

  physical_block_size indicates the smallest I/O the device can write
  without incurring a read-modify-write penalty.

  The io_min parameter is the smallest preferred I/O size reported by
  the device.  In many cases this is the same as the physical block
  size.  However, the io_min parameter can be scaled up when stacking
  (RAID5 chunk size > physical block size).

  The io_opt characteristic indicates the optimal I/O size reported by
  the device.  This is usually the stripe width for arrays.

  The alignment_offset parameter indicates the number of bytes the start
  of the device/partition is offset from the device's natural alignment.
  Partition tools and MD/DM utilities can use this to pad their offsets
  so filesystems start on proper boundaries.

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

Experimenting with LBS

As of April 28, 2023, experimenting with LBS support requires out-of-tree patches to Linux. A few block drivers and filesystems have been modified to help experiment and enable the community to work with LBS.

large-block-next

Since a lot of this is still work in progress a lot of this code is not yet merged upstream into Linux. Some of this is not yet even upstream on linux-next. And so a git tree has been put together to help developers wishing to test the latest and greatest changes to help support and test LBS.

This tree will rebase sporadically:

• large-block-next

These branches will not be changed and are intended to remain static:

• large-block-20230426

LBS on qemu

Qemu has been used with the NVMe driver to experiment with LBS. You can experiment with LBS by just using a large physical and logical block size than your PAGE_SIZE. Qemu does not allow for different physical and logical block sizes.

LBS on brd

To create a 64k LBS RAM block device use:

modprobe brd rd_nr=1 rd_size=1024000 rd_blksize=65536 rd_logical_blksize=65536

LBS on shmem

To create a 64k LBS tmpfs filesystem:

mkdir /data-tmpfs/
mount -t tmpfs            -o size=10M,bsize=$((4096*16)) -o noswap tmpfs /data-tmpfs/

LBS on kdevops

See the kdevops LBS R&D page for how to use kdevops to quickly get started on experimenting with any of the mentioned components above.

Testing with LBS

kdevops has been extended to support LBS filesystem profiles on XFS. We need to run tests for XFS for LBS and also run tests on blktests.

LBS resources

• Mel Gorman's book on the page cache

• 2007 work by Christoph Lameter to support large block sizes than PAGE_SIZE in the page cache with compound pages

• 2007 initial work of fsblock by Nick Piggin to replace buffer head to support large block sizes announced

• 2009 version of fsblock work posted

• 2009 lwn coverage of fsblock

• 2017 LSFMM discussion over prior large block size efforts and worthiness of talking about it at the summit

  • This is a summary mostly by Chinner's on why Nick and Christoph Lameter's strategy had failed

    • it used high order compound pages in the page cache so that nothing needed to
      • change on the filesystem level in order to support this
    • Chinner supported revisiting this strategy as we use and support compound pages all over
      • now and also support compaction, and compaction helps with ensuring we can get higher order pages
      • There is still concern for fragmentation if you start doing a lot of only high order page
        • allocations
      • Chinner still wondered, if Lameter's approach to modifying only the page cache is used
        • and a page fault means tracking a page to its own pte, why do we need contigous pages?
        • Can't se use discontiguous pages?
  • Nick Piggin's fsblock strategy rewrites buffer head logic to support filesystem blocks larger
    • than a page size, while leaving the page cache untouched.
  • Downsides to Nick's strategy is all filesystems would need to be rewritten to use fsblock
    • instead of buffer head

• Dave Chinner 2018's effort to support block size > PAGE_SIZE

• 2021 iomap description as a page cache abstraction], fs/iomap

  • already provides filesystems with a complete, efficient page cache abstraction that only requires filesytems to provide block mapping services. Filesystems using iomap do not interact with the page cache at all. And David Howells is working with Willy and all the network fs devs to build an equivalent generic netfs page cache abstraction based on folios that is supported by the major netfs client implementations in the kernel.

• 2021 description of fs/xfs/xfs_buf.c while clarifying while supporting folio design vs an opaque object straegy, fs/xfs/xfs_buf.c is

  • an example of a high performance handle based, variable object size cache that abstracts away the details of the data store being allocated from slab, discontiguous pages, contiguous pages or vmapped memory. It is basically two decade old re-implementation of the Irix low layer global disk-addressed buffer cache, modernised and tailored directly to the needs of XFS metadata caching.

• 2021 Folio-enabling the page cache - enables filesystems to be

  • converted to folios

• 2022 LSFMM coverage on A memory folio update

  • buffer-head --> iomap, why? Because it was designed for larger block size support in mind

  • only readahead uses folios today
  • all current filesystem's write path uses base pages, and it has not been clear when large
    • folios should be used
  • some filesystems want features like range-locking but this gets complex as you need to lock
    • a page's lock before a filesystem lock
  • page reclaim can be problematic for filesystems
    • Wilcox suggested most filesystems already do a good job with writeback and so the kernel's
      • reclaim mechanism may not be needed anymore
    • afs already removed the writepage() callback
    • XFS hasn't had a writepage() callback since last summer
    • hnaz suggests that writepage() call is still there on paper, but it's been neutered by
      • conditionals that rarely trigger in practice. It's also only there for the global case, never called for cgroup reclaim. Cgroup-aware flushers are conceivable, but in practice
  • folios could increase write amplification as when a page is dirty the entire folio needs to be
    • written the global flushers and per-cgroup dirty throttling have been working well.

• April 2023 Christoph's patches on enabling Linux without buffer-heads

Divide & Conquer work - OKRs for LBS

Here are a set of OKRs to help with folio work & LBS OKRs, OKRs are used to help divide & conquer tasks into concrete tangible components we need to complete proper LBS support upstream. Since a lot of this is editing tables, this is maintained on an Google sheet.

OKRs for LBS

CategoryDocs