LSF/MM/BPF 2023 IOMAP conversion status update

[Luis Chamberlain <mcgrof@kernel.org>]

One of the recurring themes that comes up at LSF is "iomap has little
to no documentation, it is hard to use". I've only recently taken a
little nose dive into it, and so I also can frankly admit to say I don't
grok it well either yet. However, the *general* motivation and value is clear:
avoiding the old ugly monster of struct buffer_head, and abstracting
the page cache for non network filesystems, and that is because for
network filesystems my understanding is that we have another side effort
for that. We could go a bit down memory lane on prior attempts to kill
the struct buffer_head evil demon from Linux, or why its evil, but I'm not
sure if recapping that is useful at this point in time, let me know, I could
do that if it helps if folks want to talk about this at LSF. For now I rather
instead focus on sharing efforts to review where we are today on the effort
towards conversion towards IOMAP for some of the major filesystems:

https://docs.google.com/presentation/d/e/2PACX-1vSN4TmhiTu1c6HNv6_gJZFqbFZpbF7GkABllSwJw5iLnSYKkkO-etQJ3AySYEbgJA/pub?start=true&loop=false&delayms=3000&slide=id.g189cfd05063_0_225

I'm hoping this *might* be useful to some, but I fear it may leave quite
a bit of folks with more questions than answers as it did for me. And
hence I figured that *this aspect of this topic* perhaps might be a good
topic for LSF.  The end goal would hopefully then be finally enabling us
to document IOMAP API properly and helping with the whole conversion
effort.

My gatherings from this quick review of API evolution and use is that,
XFS is *certainly* a first class citizen user. No surprise there if a
lot of the effort came out from XFS. And even though btrfs now avoids
the evil struct buffer_head monster, its use of the IOMAP API seems
*dramatically* different than XFS, and it probably puzzles many. Is it
that btrfs managed to just get rid of struct buffer_head use but missed
fully abstracting working with the page cache? How does one check? What
semantics do we look for?

When looking to see if one can help on the conversion front with other
filesystems it begs the question what is the correct real end goal. What
should one strive for? And it also gets me wondering, if we wanted to abstract
the page cache from scratch again, would we have done this a bit differently
now? Are there lessons from the network filesystem side of things which
can be shared? If so it gets me wondering if this instead should be
about why that's a good idea and what should that look like.

Perhaps fs/buffers.c could be converted to folios only, and be done
with it. But would we be loosing out on something? What would that be?

  Luis