OpenE2K
/
glibc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Consolidate posix_fadvise implementations 

This patch consolidates mostly of the Linux posix_fadvise{64} implementations
on sysdeps/unix/sysv/linux/posix_fadvise{64}.c.  It still keeps arch-specific
files for:

  * S390-32: it uses a packed structure to pass all the arguments on syscall.
    It is the only supported port that implements __NR_fadvise64_64 in this
    way.

  * ARM: it does not implement __NR_fadvise64 (as other 32-bits ports), so
    posix_fadvise calls internal posix_fadvise64 symbol.

  * MIPS64 n64: it requires a different version number that other ports.

The new macro SYSCALL_LL{64} is used to handle the offset argument and
INTERNAL_SYSCALL_CALL to handle passing the correct number of expect
arguments.

The default Linux adds two new defines a port can use to control how
__NR_fadvise64_64 passes the kernel arguments:

  * __ASSUME_FADVISE64_64_6ARG: the 'advise' argument is moved on second
    position.  This is the case of powerpc32 and arm to avoid implement
    7 argument syscall.

  * __ASSUME_FADVISE64_64_NO_ALIGN: for ABIs that defines
    __ASSUME_ALIGNED_REGISTER_PAIRS packs the offset without the leading
    '0'.  This is the case of tile 32 bits.

ARM also defines __NR_fadvise64_64 as __NR_arm_fadvise64_64 (which is also
handled on arch kernel-feature.h).

Tested on x86_64, x32, i686, armhf, and aarch64.

	* posix/Makefile (tests): Add tst-posix_fadvise and tst-posix_fadvise64.
	* posix/tst-posix_fadvise.c: New file.
	* posix/tst-posix_fadvise64.c: Likewise.
	* posix/tst-posix_fadvise-common.c: Likewise.
	* sysdeps/unix/sysv/linux/arm/kernel-features.h
	(__ASSUME_FADVISE64_64_6ARG): Define.
	* sysdeps/unix/sysv/linux/powerpc/kernel-features.h
	[!__powerpc64__] (__ASSUME_FADVISE64_64_6ARG): Add define.
	* sysdeps/unix/sysv/linux/arm/posix_fadvise64.c: Remove file.
	* sysdeps/unix/sysv/linux/generic/wordsize-32/posix_fadvise.c: Likewise.
	* sysdeps/unix/sysv/linux/i386/posix_fadvise64.S: Likewise.
	* sysdeps/unix/sysv/linux/mips/mips32/posix_fadvise.c: Likewise.
	* sysdeps/unix/sysv/linux/mips/mips32/posix_fadvise64.c: Likewise.
	* sysdeps/unix/sysv/linux/mips/mips64/n32/posix_fadvise.c: Likewise.
	* sysdeps/unix/sysv/linux/mips/mips64/n32/posix_fadvise64.c: Likewise.
	* sysdeps/unix/sysv/linux/mips/mips64/n64/posix_fadvise.c: Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc32/posix_fadvise.c: Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc32/posix_fadvise64.c:
	Likewise.
	* sysdeps/unix/sysv/linux/wordsize-64/posix_fadvise.c: Likewise.
	* sysdeps/unix/sysv/linux/wordsize-64/posix_fadvise64.c: Likewise.
	* sysdeps/unix/sysv/linux/mips/mips64/n64/posix_fadvise64.c
	(SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3) [__posix_fadvise64_l64]:
	Alias to __posix_fadvise64_l32.
	(SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3) [__posix_fadvise64_l32]:
	Add compat definition to posix_fadvise64.
	(SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3) [__posix_fadvise64_l64]:
	Add versioned definition to posix_fadvise64.
	* sysdeps/unix/sysv/linux/posix_fadvise.c (posix_fadvise): Build iff
	__OFF_T_MATCHES_OFF64_T is defined, use INTERNAL_SYSCALL_CALL, add
	__ASSUME_FADVISE64_64_6ARG/__ASSUME_FADVISE64_64_NO_ALIGN support.
	* sysdeps/unix/sysv/linux/posix_fadvise64.c (posix_fadvise64): Add
	__ASSUME_FADVISE64_64_NO_ALIGN support and use INTERNAL_SYSCALL_CALL.
This commit is contained in:
Adhemerval Zanella 2016-07-06 08:52:11 -03:00
parent 45ff2bfcb3
commit 96b7fe4243
23 changed files with 306 additions and 554 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
ChangeLog
View File

@ -1,5 +1,41 @@
2016-10-07 Adhemerval Zanella <adhemerval.zanella@linaro.org>
* posix/Makefile (tests): Add tst-posix_fadvise and tst-posix_fadvise64.
* posix/tst-posix_fadvise.c: New file.
* posix/tst-posix_fadvise64.c: Likewise.
* posix/tst-posix_fadvise-common.c: Likewise.
* sysdeps/unix/sysv/linux/arm/kernel-features.h
(__ASSUME_FADVISE64_64_6ARG): Define.
* sysdeps/unix/sysv/linux/powerpc/kernel-features.h
[!__powerpc64__] (__ASSUME_FADVISE64_64_6ARG): Define.
* sysdeps/unix/sysv/linux/tile/kernel-features.h
[!LP64] (__ASSUME_FADVISE64_64_NO_ALIGN): Define.
* sysdeps/unix/sysv/linux/arm/posix_fadvise64.c: Remove file.
* sysdeps/unix/sysv/linux/generic/wordsize-32/posix_fadvise.c: Likewise.
* sysdeps/unix/sysv/linux/i386/posix_fadvise64.S: Likewise.
* sysdeps/unix/sysv/linux/mips/mips32/posix_fadvise.c: Likewise.
* sysdeps/unix/sysv/linux/mips/mips32/posix_fadvise64.c: Likewise.
* sysdeps/unix/sysv/linux/mips/mips64/n32/posix_fadvise.c: Likewise.
* sysdeps/unix/sysv/linux/mips/mips64/n32/posix_fadvise64.c: Likewise.
* sysdeps/unix/sysv/linux/mips/mips64/n64/posix_fadvise.c: Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc32/posix_fadvise.c: Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc32/posix_fadvise64.c:
Likewise.
* sysdeps/unix/sysv/linux/wordsize-64/posix_fadvise.c: Likewise.
* sysdeps/unix/sysv/linux/wordsize-64/posix_fadvise64.c: Likewise.
* sysdeps/unix/sysv/linux/mips/mips64/n64/posix_fadvise64.c
(SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3) [__posix_fadvise64_l64]:
Alias to __posix_fadvise64_l32.
(SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3) [__posix_fadvise64_l32]:
Add compat definition to posix_fadvise64.
(SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3) [__posix_fadvise64_l64]:
Add versioned definition to posix_fadvise64.
* sysdeps/unix/sysv/linux/posix_fadvise.c (posix_fadvise): Build iff
__OFF_T_MATCHES_OFF64_T is defined, use INTERNAL_SYSCALL_CALL, add
__ASSUME_FADVISE64_64_6ARG/__ASSUME_FADVISE64_64_NO_ALIGN support.
* sysdeps/unix/sysv/linux/posix_fadvise64.c (posix_fadvise64): Add
__ASSUME_FADVISE64_64_NO_ALIGN support and use INTERNAL_SYSCALL_CALL.
* io/Makefile (tests): Add tst-posix_fallocate and
tst-posix_fallocate64.
* io/tst-posix_fallocate-common.c: New file.

3
posix/Makefile
View File

@ -90,7 +90,8 @@ tests := tstgetopt testfnm runtests runptests \
bug-getopt5 tst-getopt_long1 bug-regex34 bug-regex35 \
tst-pathconf tst-getaddrinfo4 tst-rxspencer-no-utf8 \
tst-fnmatch3 bug-regex36 tst-getaddrinfo5 \
tst-posix_spawn-fd
tst-posix_spawn-fd \
tst-posix_fadvise tst-posix_fadvise64
xtests := bug-ga2
ifeq (yes,$(build-shared))
test-srcs := globtest

103
posix/tst-posix_fadvise-common.c Normal file
View File

@ -0,0 +1,103 @@
/* Common posix_fadvise tests definitions.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
static void do_prepare (void);
#define PREPARE(argc, argv) do_prepare ()
static int do_test (void);
#define TEST_FUNCTION do_test ()
#include <test-skeleton.c>
static char *temp_filename;
static int temp_fd;
static char fifoname[] = "/tmp/tst-posix_fadvise-fifo-XXXXXX";
static int fifofd;
static void
do_prepare (void)
{
temp_fd = create_temp_file ("tst-posix_fadvise.", &temp_filename);
if (temp_fd == -1)
FAIL_EXIT1 ("cannot create temporary file: %m");
if (mktemp (fifoname) == NULL)
FAIL_EXIT1 ("cannot generate temp file name: %m");
add_temp_file (fifoname);
if (mkfifo (fifoname, S_IWUSR | S_IRUSR) != 0)
FAIL_EXIT1 ("cannot create fifo: %m");
fifofd = open (fifoname, O_RDONLY | O_NONBLOCK);
if (fifofd == -1)
FAIL_EXIT1 ("cannot open fifo: %m");
}
/* Effectivelly testing posix_fadvise is hard because side effects are not
observed without checking either performance or any kernel specific
supplied information. Also, the syscall is meant to be an advisory,
so the kernel is free to use this information in any way it deems fit,
including ignoring it.
This test check for some invalid returned operation to check argument
passing and if implementation follows POSIX error definition. */
static int
do_test_common (void)
{
/* Add some data to file and ensure it is written to disk. */
#define BLK_SIZE 2048
char buffer[BLK_SIZE] = { 0xcd };
ssize_t ret;
if ((ret = write (temp_fd, buffer, BLK_SIZE)) != BLK_SIZE)
FAIL_EXIT1 ("write returned %zd different than expected %d",
ret, BLK_SIZE);
if (fsync (temp_fd) != 0)
FAIL_EXIT1 ("fsync failed");
/* Test passing an invalid fd. */
if (posix_fadvise (-1, 0, 0, POSIX_FADV_NORMAL) != EBADF)
FAIL_EXIT1 ("posix_fadvise with invalid fd did not return EBADF");
/* Test passing an invalid operation. */
if (posix_fadvise (temp_fd, 0, 0, -1) != EINVAL)
FAIL_EXIT1 ("posix_fadvise with invalid advise did not return EINVAL");
/* Test passing a FIFO fd. */
if (posix_fadvise (fifofd, 0, 0, POSIX_FADV_NORMAL) != ESPIPE)
FAIL_EXIT1 ("posix_advise with PIPE fd did not return ESPIPE");
/* Default fadvise on all file starting at initial position. */
if (posix_fadvise (temp_fd, 0, 0, POSIX_FADV_NORMAL) != 0)
FAIL_EXIT1 ("default posix_fadvise failed");
if (posix_fadvise (temp_fd, 0, 2 * BLK_SIZE, POSIX_FADV_NORMAL) != 0)
FAIL_EXIT1 ("posix_fadvise failed (offset = 0, len = %d) failed",
BLK_SIZE);
if (posix_fadvise (temp_fd, 2 * BLK_SIZE, 0, POSIX_FADV_NORMAL) != 0)
FAIL_EXIT1 ("posix_fadvise failed (offset = %d, len = 0) failed",
BLK_SIZE);
return 0;
}

26
sysdeps/unix/sysv/linux/powerpc/powerpc32/posix_fadvise.c → posix/tst-posix_fadvise.c
View File

@ -1,4 +1,5 @@
/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
/* Basic posix_fadvise tests.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@ -15,25 +16,10 @@
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
#include "tst-posix_fadvise-common.c"
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
posix_fadvise (int fd, off_t offset, off_t len, int advise)
static int
do_test (void)
{
#ifdef __NR_fadvise64
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64, err, 6, fd, 0,
__LONG_LONG_PAIR (offset >> 31, offset), len,
advise);
if (INTERNAL_SYSCALL_ERROR_P (ret, err))
return INTERNAL_SYSCALL_ERRNO (ret, err);
return 0;
#else
return ENOSYS;
#endif
return do_test_common ();
}

46
posix/tst-posix_fadvise64.c Normal file
View File

@ -0,0 +1,46 @@
/* Basic posix_fadvise64 tests.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#define _FILE_OFFSET_BITS 64
#include "tst-posix_fadvise-common.c"
static int
do_test (void)
{
int ret = do_test_common ();
if (ret == 1)
return 1;
/* Test passing a negative length. The compat fadvise64 might use
off64_t for size argument passing, so using -1 for len without
_FILE_OFFSET_BITS might not trigger the length issue. */
if (posix_fadvise (temp_fd, 0, -1, POSIX_FADV_NORMAL) != EINVAL)
FAIL_EXIT1 ("posix_fadvise with negative length did not return EINVAL");
/* Check with some offset values larger than 32-bits. */
off_t offset = UINT32_MAX + 2048LL;
if (posix_fadvise (temp_fd, 0, offset, POSIX_FADV_NORMAL) != 0)
FAIL_EXIT1 ("posix_fadvise failed (offset = 0, len = %zd) failed",
(ssize_t)offset);
if (posix_fadvise (temp_fd, offset, 0, POSIX_FADV_NORMAL) != 0)
FAIL_EXIT1 ("posix_fadvise failed (offset = %zd, len = 0) failed",
(ssize_t)offset);
return 0;
}

7
sysdeps/unix/sysv/linux/arm/kernel-features.h
View File

@ -27,6 +27,13 @@
# undef __ASSUME_SET_ROBUST_LIST
#endif
/* ARM fadvise64_64 reorganize the syscall arguments. */
#define __ASSUME_FADVISE64_64_6ARG 1
/* Define this if your 32-bit syscall API requires 64-bit register
pairs to start with an even-number register. */
#define __ASSUME_ALIGNED_REGISTER_PAIRS 1
/* ARM only has a syscall for fadvise64{_64} and it is defined with a
non-standard name. */
#define __NR_fadvise64_64 __NR_arm_fadvise64_64

38
sysdeps/unix/sysv/linux/arm/posix_fadvise64.c
View File

@ -1,38 +0,0 @@
/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
int __posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise);
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
__posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise)
{
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (arm_fadvise64_64, err, 6, fd, advise,
__LONG_LONG_PAIR ((long)(offset >> 32), (long)offset),
__LONG_LONG_PAIR ((long)(len >> 32), (long)len));
if (!INTERNAL_SYSCALL_ERROR_P (ret, err))
return 0;
return INTERNAL_SYSCALL_ERRNO (ret, err);
}
weak_alias (__posix_fadvise64_l64, posix_fadvise64);

37
sysdeps/unix/sysv/linux/generic/wordsize-32/posix_fadvise.c
View File

@ -1,37 +0,0 @@
/* Copyright (C) 2011-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Chris Metcalf <cmetcalf@tilera.com>, 2011.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
posix_fadvise (int fd, off_t offset, off_t len, int advise)
{
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64_64, err, 6, fd,
__LONG_LONG_PAIR (offset >> 31, offset),
__LONG_LONG_PAIR (len >> 31, len),
advise);
if (INTERNAL_SYSCALL_ERROR_P (ret, err))
return INTERNAL_SYSCALL_ERRNO (ret, err);
return 0;
}

92
sysdeps/unix/sysv/linux/i386/posix_fadvise64.S
View File

@ -1,92 +0,0 @@
/* Copyright (C) 1995-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <sysdep.h>
#define EINVAL 22
#define ENOSYS 38
#define EOVERFLOW 75
#define SVRSP 16 /* saved register space */
#define PARMS 4+SVRSP /* space for 4 saved regs */
#define FD PARMS
#define OFFLO FD+4
#define OFFHI OFFLO+4
#define LENLO OFFHI+4
#define LENHI LENLO+4
#define FLAGS LENHI+4
.text
ENTRY (__posix_fadvise64_l64)
/* Save registers. */
pushl %ebp
cfi_adjust_cfa_offset (4)
pushl %ebx
cfi_adjust_cfa_offset (4)
pushl %esi
cfi_adjust_cfa_offset (4)
pushl %edi
cfi_adjust_cfa_offset (4)
movl FD(%esp), %ebx
cfi_rel_offset (ebx, 8)
movl OFFLO(%esp), %ecx
movl OFFHI(%esp), %edx
movl LENLO(%esp), %esi
cfi_rel_offset (esi, 4)
movl LENHI(%esp), %edi
cfi_rel_offset (edi, 0)
movl FLAGS(%esp), %ebp
cfi_rel_offset (ebp, 12)
movl $SYS_ify(fadvise64_64), %eax
ENTER_KERNEL
/* Restore registers. */
popl %edi
cfi_adjust_cfa_offset (-4)
cfi_restore (edi)
popl %esi
cfi_adjust_cfa_offset (-4)
cfi_restore (esi)
popl %ebx
cfi_adjust_cfa_offset (-4)
cfi_restore (ebx)
popl %ebp
cfi_adjust_cfa_offset (-4)
cfi_restore (ebp)
/* The function returns zero, or the error number. So all we
have to do is negate the value passed back from the kernel. */
/* If 0 > %eax > -4096 there was an error. */
negl %eax
/* Successful; return the syscall's value. */
ret
END (__posix_fadvise64_l64)
.section .text.compat, "ax"
ENTRY (__posix_fadvise64_l32)
DO_CALL (fadvise64, 5)
negl %eax
ret
PSEUDO_END_ERRVAL (__posix_fadvise64_l32)
default_symbol_version (__posix_fadvise64_l64, posix_fadvise64, GLIBC_2.3.3)
symbol_version (__posix_fadvise64_l32, posix_fadvise64, GLIBC_2.2)

41
sysdeps/unix/sysv/linux/mips/mips32/posix_fadvise.c
View File

@ -1,41 +0,0 @@
/* Copyright (C) 2007-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
posix_fadvise (int fd, off_t offset, off_t len, int advise)
{
/* MIPS kernel only has NR_fadvise64 which acts as NR_fadvise64_64 */
#ifdef __NR_fadvise64
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64, err, 7, fd, 0,
__LONG_LONG_PAIR (offset >> 31, offset),
__LONG_LONG_PAIR (len >> 31, len),
advise);
if (INTERNAL_SYSCALL_ERROR_P (ret, err))
return INTERNAL_SYSCALL_ERRNO (ret, err);
return 0;
#else
return ENOSYS;
#endif
}

60
sysdeps/unix/sysv/linux/mips/mips32/posix_fadvise64.c
View File

@ -1,60 +0,0 @@
/* Copyright (C) 2007-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
__posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise)
{
/* MIPS kernel only has NR_fadvise64 which acts as NR_fadvise64_64 */
#ifdef __NR_fadvise64
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64, err, 7, fd, 0,
__LONG_LONG_PAIR ((long) (offset >> 32),
(long) offset),
__LONG_LONG_PAIR ((long) (len >> 32),
(long) len),
advise);
if (INTERNAL_SYSCALL_ERROR_P (ret, err))
return INTERNAL_SYSCALL_ERRNO (ret, err);
return 0;
#else
return ENOSYS;
#endif
}
#include <shlib-compat.h>
#if SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3)
int
attribute_compat_text_section
__posix_fadvise64_l32 (int fd, off64_t offset, size_t len, int advise)
{
return __posix_fadvise64_l64 (fd, offset, len, advise);
}
versioned_symbol (libc, __posix_fadvise64_l64, posix_fadvise64, GLIBC_2_3_3);
compat_symbol (libc, __posix_fadvise64_l32, posix_fadvise64, GLIBC_2_2);
#else
strong_alias (__posix_fadvise64_l64, posix_fadvise64);
#endif

37
sysdeps/unix/sysv/linux/mips/mips64/n32/posix_fadvise.c
View File

@ -1,37 +0,0 @@
/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
posix_fadvise (int fd, off_t offset, off_t len, int advise)
{
#ifdef __NR_fadvise64
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64, err, 4, fd, offset, len, advise);
if (INTERNAL_SYSCALL_ERROR_P (ret, err))
return INTERNAL_SYSCALL_ERRNO (ret, err);
return 0;
#else
return ENOSYS;
#endif
}

55
sysdeps/unix/sysv/linux/mips/mips64/n32/posix_fadvise64.c
View File

@ -1,55 +0,0 @@
/* Copyright (C) 2007-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
__posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise)
{
/* MIPS kernel only has NR_fadvise64 which acts as NR_fadvise64_64 */
#ifdef __NR_fadvise64
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64, err, 4, fd, offset, len, advise);
if (INTERNAL_SYSCALL_ERROR_P (ret, err))
return INTERNAL_SYSCALL_ERRNO (ret, err);
return 0;
#else
return ENOSYS;
#endif
}
#include <shlib-compat.h>
#if SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3)
int
attribute_compat_text_section
__posix_fadvise64_l32 (int fd, off64_t offset, size_t len, int advise)
{
return __posix_fadvise64_l64 (fd, offset, len, advise);
}
versioned_symbol (libc, __posix_fadvise64_l64, posix_fadvise64, GLIBC_2_3_3);
compat_symbol (libc, __posix_fadvise64_l32, posix_fadvise64, GLIBC_2_2);
#else
strong_alias (__posix_fadvise64_l64, posix_fadvise64);
#endif

50
sysdeps/unix/sysv/linux/mips/mips64/n64/posix_fadvise.c
View File

@ -1,50 +0,0 @@
/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#define posix_fadvise64 __no_posix_fadvise64
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
#undef posix_fadvise64
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
posix_fadvise (int fd, off_t offset, off_t len, int advise)
{
#ifdef __NR_fadvise64
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64, err, 4, fd, offset, len, advise);
if (INTERNAL_SYSCALL_ERROR_P (ret, err))
return INTERNAL_SYSCALL_ERRNO (ret, err);
return 0;
#else
return ENOSYS;
#endif
}
#include <shlib-compat.h>
#if SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3)
strong_alias (posix_fadvise, __posix_fadvise64_l32);
compat_symbol (libc, __posix_fadvise64_l32, posix_fadvise64, GLIBC_2_2);
strong_alias (posix_fadvise, __posix_fadvise64_l64);
versioned_symbol (libc, __posix_fadvise64_l64, posix_fadvise64, GLIBC_2_3_3);
#else
weak_alias (posix_fadvise, posix_fadvise64);
#endif

29
sysdeps/unix/sysv/linux/mips/mips64/n64/posix_fadvise64.c
View File

@ -1 +1,28 @@
/* posix_fadvise64 is in posix_fadvise.c */
/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#undef strong_alias
#define strong_alias(a, b)
#include <sysdeps/unix/sysv/linux/posix_fadvise64.c>
#if SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3)
_strong_alias (__posix_fadvise64_l64, __posix_fadvise64_l32);
compat_symbol (libc, __posix_fadvise64_l32, posix_fadvise64, GLIBC_2_2);
versioned_symbol (libc, __posix_fadvise64_l64, posix_fadvise64, GLIBC_2_3_3);
#endif
_strong_alias (__posix_fadvise64_l64, posix_fadvise);

45
sysdeps/unix/sysv/linux/posix_fadvise.c
View File

@ -22,27 +22,46 @@
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
#ifndef __OFF_T_MATCHES_OFF64_T
/* Both arm and powerpc implements fadvise64_64 with last 'advise' argument
just after 'fd' to avoid the requirement of implementing 7-arg syscalls.
ARM also defines __NR_fadvise64_64 as __NR_arm_fadvise64_64.
tile requires __ASSUME_ALIGNED_REGISTER_PAIRS but implements the 32-bit
fadvise64_64 without the padding 0 after fd.
s390 implements fadvice64_64 using a specific struct with arguments
packed inside. This is the only implementation handled in arch-specific
code. */
int
posix_fadvise (int fd, off_t offset, off_t len, int advise)
{
#if defined(__NR_fadvise64) || defined(__NR_fadvise64_64)
INTERNAL_SYSCALL_DECL (err);
# ifdef __NR_fadvise64
int ret = INTERNAL_SYSCALL (fadvise64, err, 5, fd,
__LONG_LONG_PAIR (offset >> 31, offset), len,
advise);
int ret = INTERNAL_SYSCALL_CALL (fadvise64, err, fd,
__ALIGNMENT_ARG SYSCALL_LL (offset),
len, advise);
# else
int ret = INTERNAL_SYSCALL (fadvise64_64, err, 6, fd,
__LONG_LONG_PAIR ((long) (offset >> 31),
(long) offset),
__LONG_LONG_PAIR ((long) (len >> 31),
(long) len),
advise);
# ifdef __ASSUME_FADVISE64_64_6ARG
int ret = INTERNAL_SYSCALL_CALL (fadvise64_64, err, fd, advise,
__ALIGNMENT_ARG SYSCALL_LL (offset),
SYSCALL_LL (len));
# else
# ifdef __ASSUME_FADVISE64_64_NO_ALIGN
# undef __ALIGNMENT_ARG
# define __ALIGNMENT_ARG
# endif
int ret = INTERNAL_SYSCALL_CALL (fadvise64_64, err, fd,
__ALIGNMENT_ARG SYSCALL_LL (offset),
SYSCALL_LL (len), advise);
# endif
# endif
if (INTERNAL_SYSCALL_ERROR_P (ret, err))
return INTERNAL_SYSCALL_ERRNO (ret, err);
return 0;
#else
return ENOSYS;
#endif
}
#endif /* __OFF_T_MATCHES_OFF64_T */

51
sysdeps/unix/sysv/linux/posix_fadvise64.c
View File

@ -17,10 +17,29 @@
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
#include <shlib-compat.h>
int __posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise);
int __posix_fadvise64_l32 (int fd, off64_t offset, size_t len, int advise);
/* Both arm and powerpc implements fadvise64_64 with last 'advise' argument
just after 'fd' to avoid the requirement of implementing 7-arg syscalls.
ARM also defines __NR_fadvise64_64 as __NR_arm_fadvise64_64.
tile requires __ASSUME_ALIGNED_REGISTER_PAIRS but implements the 32-bit
fadvise64_64 without the padding 0 after fd.
s390 implements fadvice64_64 using a specific struct with arguments
packed inside. This is the only implementation handled in arch-specific
code. */
#ifdef __ASSUME_FADVISE64_64_NO_ALIGN
# undef __ALIGNMENT_ARG
# define __ALIGNMENT_ARG
#endif
#ifndef __NR_fadvise64_64
# define __NR_fadvise64_64 __NR_fadvise64
#endif
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
@ -29,20 +48,24 @@ int
__posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise)
{
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64_64, err, 6, fd,
__LONG_LONG_PAIR ((long) (offset >> 32),
(long) offset),
__LONG_LONG_PAIR ((long) (len >> 32),
(long) len),
advise);
#ifdef __ASSUME_FADVISE64_64_6ARG
int ret = INTERNAL_SYSCALL_CALL (fadvise64_64, err, fd, advise,
SYSCALL_LL64 (offset), SYSCALL_LL64 (len));
#else
int ret = INTERNAL_SYSCALL_CALL (fadvise64_64, err, fd,
__ALIGNMENT_ARG SYSCALL_LL64 (offset),
SYSCALL_LL64 (len), advise);
#endif
if (!INTERNAL_SYSCALL_ERROR_P (ret, err))
return 0;
return INTERNAL_SYSCALL_ERRNO (ret, err);
}
#include <shlib-compat.h>
#if SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3)
/* The type of the len argument was changed from size_t to off_t in
POSIX.1-2003 TC1. */
#ifndef __OFF_T_MATCHES_OFF64_T
# if SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3)
int __posix_fadvise64_l32 (int fd, off64_t offset, size_t len, int advise);
int
attribute_compat_text_section
@ -53,6 +76,10 @@ __posix_fadvise64_l32 (int fd, off64_t offset, size_t len, int advise)
versioned_symbol (libc, __posix_fadvise64_l64, posix_fadvise64, GLIBC_2_3_3);
compat_symbol (libc, __posix_fadvise64_l32, posix_fadvise64, GLIBC_2_2);
# else
weak_alias (__posix_fadvise64_l64, posix_fadvise64);
# endif
#else
strong_alias (__posix_fadvise64_l64, posix_fadvise64);
weak_alias (__posix_fadvise64_l64, posix_fadvise64);
strong_alias (__posix_fadvise64_l64, posix_fadvise);
#endif

5
sysdeps/unix/sysv/linux/powerpc/kernel-features.h
View File

@ -46,4 +46,9 @@
# define __ASSUME_ALIGNED_REGISTER_PAIRS 1
#endif
/* powerpc compat fadvise64_64 reorganize the syscall argument. */
#ifndef __powerpc64__
# define __ASSUME_FADVISE64_64_6ARG 1
#endif
#include_next <kernel-features.h>

55
sysdeps/unix/sysv/linux/powerpc/powerpc32/posix_fadvise64.c
View File

@ -1,55 +0,0 @@
/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
int __posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise);
int __posix_fadvise64_l32 (int fd, off64_t offset, size_t len, int advise);
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
__posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise)
{
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64_64, err, 6, fd, advise,
__LONG_LONG_PAIR ((long)(offset >> 32), (long)offset),
__LONG_LONG_PAIR ((long)(len >> 32), (long)len));
if (!INTERNAL_SYSCALL_ERROR_P (ret, err))
return 0;
return INTERNAL_SYSCALL_ERRNO (ret, err);
}
#include <shlib-compat.h>
#if SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3)
int
attribute_compat_text_section
__posix_fadvise64_l32 (int fd, off64_t offset, size_t len, int advise)
{
return __posix_fadvise64_l64 (fd, offset, len, advise);
}
versioned_symbol (libc, __posix_fadvise64_l64, posix_fadvise64, GLIBC_2_3_3);
compat_symbol (libc, __posix_fadvise64_l32, posix_fadvise64, GLIBC_2_2);
#else
strong_alias (__posix_fadvise64_l64, posix_fadvise64);
#endif

1
sysdeps/unix/sysv/linux/tile/kernel-features.h
View File

@ -23,4 +23,5 @@
pairs to start with an even-number register. */
#ifndef _LP64
# define __ASSUME_ALIGNED_REGISTER_PAIRS 1
# define __ASSUME_FADVISE64_64_NO_ALIGN 1
#endif

40
sysdeps/unix/sysv/linux/wordsize-64/posix_fadvise.c
View File

@ -1,40 +0,0 @@
/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#define posix_fadvise64 __no_posix_fadvise64
#include <errno.h>
#include <fcntl.h>
#include <sysdep.h>
#undef posix_fadvise64
/* Advice the system about the expected behaviour of the application with
respect to the file associated with FD. */
int
posix_fadvise (int fd, off_t offset, off_t len, int advise)
{
#ifdef __NR_fadvise64
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (fadvise64, err, 4, fd, offset, len, advise);
if (INTERNAL_SYSCALL_ERROR_P (ret, err))
return INTERNAL_SYSCALL_ERRNO (ret, err);
return 0;
#else
return ENOSYS;
#endif
}
weak_alias (posix_fadvise, posix_fadvise64)

1
sysdeps/unix/sysv/linux/wordsize-64/posix_fadvise64.c
View File

@ -1 +0,0 @@
/* posix_fadvise64 is in posix_fadvise.c */

2
sysdeps/unix/sysv/linux/x86_64/x32/syscalls.list
View File

@ -3,5 +3,5 @@
fallocate - fallocate Ci:iiii fallocate fallocate64
gettimeofday - gettimeofday:__vdso_gettimeofday@LINUX_2.6 i:pP __gettimeofday gettimeofday
personality EXTRA personality Ei:i __personality personality
posix_fadvise - fadvise64 Vi:iiii posix_fadvise posix_fadvise64
posix_fadvise64 - fadvise64 Vi:iiii posix_fadvise posix_fadvise64
time - time:__vdso_time@LINUX_2.6 Ei:P time