Re: On time64 and Large File Support

This is a multi-part message in MIME format.
--------------07XikgMB1zrNCn7ZANRzxuYn
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: quoted-printable

On 12/28/22 20:02, Zack Weinberg wrote:

> Please revert that part of your follow-up patch.
OK, I reverted all that patch, except for the further changes you=20
requested, plus some minor quoting and version-number fixes in comments.

> Is there any
> chance you could send a wdiff to the list, after restoring the text
> you took out because you took out the _REQUIRED variants?

Sure, I'm attaching a proposed patch to Autoconf master documentation in=20
two forms. The first is a simple "git format-patch" file; the second is=20
the output of "git diff --color=3Dalways --word-diff=3Dcolor".

> I want it to be
> crystal clear from the text of configure.ac that it bombed out because
> package X considers 64-bit time_t and/or off_t a requirement.

Although I don't think this feature is useful, I don't have to use it so=20
we can leave it in.

Here's why I'm not planning to use it. I help maintain (for example) GNU=20
Tar, where file sizes and timestamps are crucial. But if I change GNU=20
Tar to use AC_SYS_LARGEFILE_REQUIRED, people won't be able to build GNU=20
Tar on ancient platforms that support file sizes only up to 2 GiB.=20
Nobody will benefit from this: the very few users who'd care (computer=20
museum curators, say) already know their systems are limited, and will=20
simply build older versions of GNU Tar that don't use=20
AC_SYS_LARGEFILE_REQUIRED, or will edit away the "_REQUIRED" before=20
building. So adding the _REQUIRED will harm a very small set of users,=20
will increase my maintenance burden a bit, and will benefit essentially=20
nobody.

To put it another way: we've all gotten by without needing=20
AC_SYS_LARGEFILE_REQUIRED for 25 years, and there's no reason for us to=20
start needing it now even though it's imperative for any serious=20
application that deals with files.

The situation for AC_SYS_YEAR2038_REQUIRED will likely be similar.

As things currently stand, I plan to use AC_SYS_YEAR2038 instead of=20
AC_SYS_LARGEFILE in GNU Tar and similar applications. (They'll use=20
Gnulib so they'll get Autoconf 2.72-compatible AC_SYS_YEAR2038 even with=20
older Autoconf.) Perhaps other maintainers will want to use the=20
*_REQUIRED macros, but as far as I can see my advice will be to avoid=20
them as being more trouble than they're worth.


> I *intended* to make it clear that they are not orthogonal in
> practice, but it is not logically necessary for them to be coupled,
> and it is, I think, easier to understand what
> AC_SYS_{LARGEFILE,YEAR2038} do if we document them as abstractly

Unfortunately the documenation currently on Autoconf master makes for a=20
lot of confusion and misimpression. It's more important for=20
documentation to agree with what the code actually does, than for it to=20
present an abstract picture of what we'd like the code to do eventually.=20
The abovementioned patches fix this.


> In the new year, I can look into the possibility of decoupling the
> macros=E2=80=99 implementations.

I don't see how that would be possible. On the only platforms where=20
--enable-year2038 matters, you cannot have year-2038 support without=20
also having large-file support.

The platforms in question are glibc 2.34+ on 32-bit ARM and x86. The=20
glibc community considered making the two things orthogonal but rejected=20
that alternative as being considerably more trouble than it was worth. I=20
think it unlikely for other 32-bit OS suppliers to decide differently.


> I think you=E2=80=99re still writing documentation with application-col=
ored
> glasses on, making it sound like --enable-year2038 has no negative
> implications whatsoever.

That's a bit unfair. The proposed documentation does mention the=20
compatibility implications; it merely uses the same level of caution for=20
both --enable-largefile and --enable-year2038, and it doesn't overhype=20
the time_t issue with an undeserved big "Caution:" inbold.

Although I plead guilty in being close to users (many who need year 2038=20
support now for obvious reasons) I'm well aware of the implication for=20
libraries. When I implemented AC_SYS_LARGEFILE back in the 1990s, there=20
were similar compatibility concerns with off_t that I also took=20
seriously. In the end, the need for large-file support outweighed the=20
backward-compatibility hassles and AC_SYS_LARGEFILE has been a success=20
in that people have used AC_SYS_LARGEFILE for years and sure there are=20
occasionally glitches but the benefits far outweigh the costs.

AC_SYS_YEAR2038 will be similar. Not identical of course, but similar.=20
We've done this sort of thing before and have experience.


> I do not believe we have consensus
> for AC_SYS_LARGEFILE to become a synonym for AC_SYS_YEAR2038, not even
> =E2=80=9Cin a future Autoconf version.=E2=80=9D

The proposed documentation patches contain a simple plan for how=20
Autoconf can plausibly survive through the year 2038. Is there a better=20
plan? If so, I'd like to hear it. If not, then let's use this plan.=20
Given the long delay between Autoconf versions and end uses of=20
downstream software, we need a plan now, not years from now. The plan=20
doesn't have to be perfect, nor does it need to be cast in stone. But=20
there needs to be a plan.

--------------07XikgMB1zrNCn7ZANRzxuYn
Content-Type: text/x-patch; charset=UTF-8;
 name="0001-Improve-year-2038-documentation.patch"
Content-Disposition: attachment;
 filename="0001-Improve-year-2038-documentation.patch"
Content-Transfer-Encoding: base64
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--------------07XikgMB1zrNCn7ZANRzxuYn
Content-Type: text/plain; charset=UTF-8;
 name="Improve-year-2038-doc-wdiff-color.txt"
Content-Disposition: attachment;
 filename="Improve-year-2038-doc-wdiff-color.txt"
Content-Transfer-Encoding: base64
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--------------07XikgMB1zrNCn7ZANRzxuYn--