Re: [PATCH 10/21] block: Add fops atomic write support

[John Garry]

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