On 02/10/2023 20:12, Bart Van Assche wrote:
> + if (!is_power_of_2(iov_iter_count(iter)))
> + return false;
This rule comes from FS block alignment and NVMe atomic boundary.
FSes (XFS) have discontiguous extents. We need to ensure that an
atomic write does not cross discontiguous extents. To do this we
ensure extent length and alignment and limit
atomic_write_unit_max_bytes to that.
For NVMe, an atomic write boundary is a boundary in LBA space which an
atomic write should not cross. We limit atomic_write_unit_max_bytes
such that it is evenly divisible into this atomic write boundary.
To ensure that the write does not cross these alignment boundaries we
say that it must be naturally aligned and a power-of-2 in length.
We may be able to relax this rule but I am not sure it buys us
anything - typically we want to be writing a 64KB block aligned to
64KB, for example.
It seems to me that the requirement is_power_of_2(iov_iter_count(iter))
is necessary for some filesystems but not for all filesystems.
Restrictions that are specific to a single filesystem (XFS) should not
occur in code that is intended to be used by all filesystems
(blkdev_atomic_write_valid()).
I don't think that is_power_of_2(write length) is specific to XFS. It is
just a simple mathematical method to ensure we obey length and alignment
requirement always.
Furthermore, if ext4 wants to support atomic writes, for example, then
it will probably base that on bigalloc. And bigalloc is power-of-2 based.
As for the rules, current proposal is:
- atomic_write_unit_min and atomic_write_unit_max are power-of-2
- write needs to be at a naturally aligned file offset
- write length needs to be a power-of-2 between atomic_write_unit_min
and atomic_write_unit_max, inclusive
Those could be relaxed to:
- atomic_write_unit_min and atomic_write_unit_max are power-of-2
- write length needs to be a multiple of atomic_write_unit_min and a max
of atomic_write_unit_max
- write needs to be at an offset aligned to atomic_write_unit_min
- write cannot cross atomic_write_unit_max boundary within the file
Are the relaxed rules better? I don't think so, and I don't like "write
cannot cross atomic_write_unit_max boundary" in terms of wording.
Thanks,
John
