Build fails on musl 1.2.4 - lfs64

[andypost]

Description

After removal of patches alpinelinux/aports@cab9b78 Alpinelinux now fails to compile with following output:

/builds/alpine/aports/testing/php83/src/php-8.3.0alpha3/main/streams/cast.c:139:2: error: incompatible function pointer types initializing 'cookie_seek_function_t *' (aka 'int (*)(void *, long *, int)') with an expression of type 'int (void *, zend_off_t, int)' (aka 'int (void *, long, int)') [-Wincompatible-function-pointer-types]
 stream_cookie_seeker, stream_cookie_closer
 ^~~~~~~~~~~~~~~~~~~~
1 error generated.
make: *** [Makefile:2600: main/streams/cast.lo] Error 1

Discussion https://gitlab.alpinelinux.org/alpine/aports/-/merge_requests/48728#note_321723

Build fixed by removing check

php-src/main/streams/cast.c

Lines 105 to 122 in 62a9408

	# ifdef COOKIE_SEEKER_USES_OFF64_T
	static int stream_cookie_seeker(void *cookie, off64_t *position, int whence)
	{
	*position = php_stream_seek((php_stream *)cookie, (zend_off_t)*position, whence);
	if (*position == -1) {
	return -1;
	}
	return 0;
	}
	# else
	static int stream_cookie_seeker(void *cookie, zend_off_t position, int whence)
	{
	return php_stream_seek((php_stream *)cookie, position, whence);
	}
	# endif

PHP Version

PHP 8.1.21

Operating System

Alpinelinux

[andypost]

Using following patch to build

diff --git a/main/streams/cast.c b/main/streams/cast.c
index 3bad65fbac..05cab34658 100644
--- a/main/streams/cast.c
+++ b/main/streams/cast.c
@@ -102,8 +102,7 @@ static ssize_t stream_cookie_writer(void *cookie, const char *buffer, size_t siz
 	return php_stream_write(((php_stream *)cookie), (char *)buffer, size);
 }
 
-# ifdef COOKIE_SEEKER_USES_OFF64_T
-static int stream_cookie_seeker(void *cookie, off64_t *position, int whence)
+static int stream_cookie_seeker(void *cookie, off_t *position, int whence)
 {
 
 	*position = php_stream_seek((php_stream *)cookie, (zend_off_t)*position, whence);
@@ -113,13 +112,6 @@ static int stream_cookie_seeker(void *cookie, off64_t *position, int whence)
 	}
 	return 0;
 }
-# else
-static int stream_cookie_seeker(void *cookie, zend_off_t position, int whence)
-{
-
-	return php_stream_seek((php_stream *)cookie, position, whence);
-}
-# endif
 
 static int stream_cookie_closer(void *cookie)
 {

[andypost]

From https://musl.libc.org/releases.html

On the API level, the legacy "LFS64" ("large file support") interfaces, which were provided by macros remapping them to their standard names (#define stat64 stat and similar) have been deprecated and are no longer provided under the _GNU_SOURCE feature profile, only under explicit _LARGEFILE64_SOURCE. The latter will also be removed in a future version. Builds broken by this change can be fixed short-term by adding -D_LARGEFILE64_SOURCE to CFLAGS, but should be fixed to use the standard interfaces.

[andypost]

The detection code needs to account musl which using 64-bit IO by default for a long time and only since 1.2.4 the compatibility was removed

Probably the place to fix is

php-src/build/php.m4

Lines 1427 to 1512 in 0b0cec5

	dnl
	dnl PHP_FOPENCOOKIE
	dnl
	AC_DEFUN([PHP_FOPENCOOKIE], [
	AC_CHECK_FUNC(fopencookie, [have_glibc_fopencookie=yes])
	if test "$have_glibc_fopencookie" = "yes"; then
	dnl This comes in two flavors: newer glibcs (since 2.1.2?) have a type called
	dnl cookie_io_functions_t.
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#define _GNU_SOURCE
	#include <stdio.h>
	]], [[cookie_io_functions_t cookie;]])],[have_cookie_io_functions_t=yes],[])
	if test "$have_cookie_io_functions_t" = "yes"; then
	cookie_io_functions_t=cookie_io_functions_t
	have_fopen_cookie=yes
	dnl Even newer glibcs have a different seeker definition.
	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	#define _GNU_SOURCE
	#include <stdio.h>
	#include <stdlib.h>
	struct cookiedata {
	off64_t pos;
	};
	ssize_t reader(void *cookie, char *buffer, size_t size)
	{ return size; }
	ssize_t writer(void *cookie, const char *buffer, size_t size)
	{ return size; }
	int closer(void *cookie)
	{ return 0; }
	int seeker(void *cookie, off64_t *position, int whence)
	{ ((struct cookiedata*)cookie)->pos = *position; return 0; }
	cookie_io_functions_t funcs = {reader, writer, seeker, closer};
	int main(void) {
	struct cookiedata g = { 0 };
	FILE *fp = fopencookie(&g, "r", funcs);
	if (fp && fseek(fp, 8192, SEEK_SET) == 0 && g.pos == 8192)
	return 0;
	return 1;
	}
	]])], [
	cookie_io_functions_use_off64_t=yes
	], [
	cookie_io_functions_use_off64_t=no
	], [
	dnl Cross compilation.
	case $host_alias in
	*linux*)
	cookie_io_functions_use_off64_t=yes
	;;
	*)
	cookie_io_functions_use_off64_t=no
	;;
	esac
	])
	else
	dnl Older glibc versions (up to 2.1.2?) call it _IO_cookie_io_functions_t.
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#define _GNU_SOURCE
	#include <stdio.h>
	]], [[_IO_cookie_io_functions_t cookie;]])], [have_IO_cookie_io_functions_t=yes], [])
	if test "$have_cookie_io_functions_t" = "yes" ; then
	cookie_io_functions_t=_IO_cookie_io_functions_t
	have_fopen_cookie=yes
	fi
	fi
	if test "$have_fopen_cookie" = "yes" ; then
	AC_DEFINE(HAVE_FOPENCOOKIE, 1, [ ])
	AC_DEFINE_UNQUOTED(COOKIE_IO_FUNCTIONS_T, $cookie_io_functions_t, [ ])
	if test "$cookie_io_functions_use_off64_t" = "yes" ; then
	AC_DEFINE(COOKIE_SEEKER_USES_OFF64_T, 1, [ ])
	fi
	fi
	fi
	])

[petk]

I've only quickly checked this issue. From what I understand is that off_t should be used today everywhere instead of off64_t type. However, I don't find anything about this written in the glibc, that this can be done on current platforms, everywhere.

Musl has quite an attitude - https://wiki.musl-libc.org/faq#Q:-Do-I-need-to-define-%3Ccode%3E_LARGEFILE64_SOURCE%3C/code%3E-to-get-64bit-%3Ccode%3Eoff_t%3C/code%3E?

Those options are for building apps, not building libc.
-D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE have nothing to do with supporting large files properly but with exposing the idiotic legacy interfaces with 64 on the end of their names (like open64, lseek64, etc.). only -D_FILE_OFFSET_BITS=64 should ever be used, anywhere, even on glibc.
under musl, off_t is always 64-bit. the -D_LARGEFILE64_SOURCE option is however honored to support compiling applications using the legacy open64, etc. nonsense, but it just #defines them away to the version without 64 on the end.

I'm always in for following latest standards but having proper portability and I guess we should consider using the off_t then everywhere in the php-src code.

We probably could do the "temporary" fix with defining #define _LARGEFILE64_SOURCE in cast.c and in the php.m4 test and it would work for Musl, but I somehow don't understand why then this will be also removed in the future MUSL versions.... It's like musl is trying to move the issue to glibc and vice versa :D

Or maybe we define the Glibc's feature #define _FILE_OFFSET_BITS 64 and use off_t safely everywhere.

I'm not sure yet how this would work everywhere and how it would affect php-src on some possible 32-bit architectures 🤔 I'll check more later about this.

[andypost]

FYI Alpine require following patch to build with musl >= 1.2.4 and Alpine edge just upgraded to 1.2.5

[orlitzky]

We have a report of this on Gentoo now: https://bugs.gentoo.org/928072

Do I understand correctly that appending -D_LARGEFILE64_SOURCE to CPPFLAGS will work around the issue, albeit temporarily? Is there any risk in doing that across the board? I don't have a musl system yet so the usual trial and error approach will be expensive in this case.

[andypost]

FYI Alpinelinux using following patch as workaround https://gitlab.alpinelinux.org/alpine/aports/-/blob/master/community/php83/fix-lfs64.patch