AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-22 02:40:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Add INLINE_SYSCALL_RETURN/INLINE_SYSCALL_ERROR_RETURN"

Browse Source 
This reverts commit 0c5b8b5941.
This commit is contained in:
H.J. Lu 2015-08-21 09:57:15 -07:00
parent 8c7c251746
commit e5dee2c896
64 changed files with 292 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
ChangeLog
View File

@ -1,80 +1,3 @@
2015-08-21 H.J. Lu <hongjiu.lu@intel.com>
* sysdeps/unix/sysdep.h (INLINE_SYSCALL_RETURN): New.
(INLINE_SYSCALL_ERROR_RETURN): Likewise.
* sysdeps/unix/sysv/linux/adjtime.c (ADJTIME): Use
INLINE_SYSCALL_RETURN and INLINE_SYSCALL_ERROR_RETURN.
* sysdeps/unix/sysv/linux/aio_sigqueue.c (__aio_sigqueue):
Likewise.
* sysdeps/unix/sysv/linux/dl-openat64.c (openat64): Likewise.
* sysdeps/unix/sysv/linux/eventfd.c (eventfd): Likewise.
* sysdeps/unix/sysv/linux/faccessat.c (faccessat): Likewise.
* sysdeps/unix/sysv/linux/fchmodat.c (fchmodat): Likewise.
* sysdeps/unix/sysv/linux/fcntl.c (do_fcntl): Likewise.
* sysdeps/unix/sysv/linux/fstatfs64.c (__fstatfs64): Likewise.
* sysdeps/unix/sysv/linux/ftruncate64.c (__ftruncate64): Likewise.
* sysdeps/unix/sysv/linux/futimens.c (futimens): Likewise.
* sysdeps/unix/sysv/linux/futimes.c (__futimes): Likewise.
* sysdeps/unix/sysv/linux/futimesat.c (futimesat): Likewise.
* sysdeps/unix/sysv/linux/fxstat.c (__fxstat): Likewise.
* sysdeps/unix/sysv/linux/fxstat64.c (___fxstat64): Likewise.
* sysdeps/unix/sysv/linux/fxstatat.c (__fxstatat): Likewise.
* sysdeps/unix/sysv/linux/fxstatat64.c (__fxstatat64): Likewise.
* sysdeps/unix/sysv/linux/gai_sigqueue.c (__gai_sigqueue):
Likewise.
* sysdeps/unix/sysv/linux/getpriority.c (__getpriority): Likewise.
* sysdeps/unix/sysv/linux/getrlimit64.c (__getrlimit64): Likewise.
* sysdeps/unix/sysv/linux/llseek.c (__llseek): Likewise.
* sysdeps/unix/sysv/linux/lutimes.c (lutimes): Likewise.
* sysdeps/unix/sysv/linux/lxstat.c (__lxstat): Likewise.
* sysdeps/unix/sysv/linux/lxstat64.c (___lxstat64): Likewise.
* sysdeps/unix/sysv/linux/mmap64.c (__mmap64): Likewise.
* sysdeps/unix/sysv/linux/mq_close.c (mq_close): Likewise.
* sysdeps/unix/sysv/linux/mq_open.c (__mq_open): Likewise.
* sysdeps/unix/sysv/linux/mq_unlink.c (mq_unlink): Likewise.
* sysdeps/unix/sysv/linux/msgget.c (msgget): Likewise.
* sysdeps/unix/sysv/linux/prlimit.c (prlimit): Likewise.
* sysdeps/unix/sysv/linux/pt-raise.c (raise): Likewise.
* sysdeps/unix/sysv/linux/raise.c (raise): Likewise.
* sysdeps/unix/sysv/linux/readahead.c (__readahead): Likewise.
* sysdeps/unix/sysv/linux/reboot.c (reboot): Likewise.
* sysdeps/unix/sysv/linux/semget.c (semget): Likewise.
* sysdeps/unix/sysv/linux/semop.c (semop): Likewise.
* sysdeps/unix/sysv/linux/semtimedop.c (semtimedop): Likewise.
* sysdeps/unix/sysv/linux/setrlimit64.c (setrlimit64): Likewise.
* sysdeps/unix/sysv/linux/shmat.c (shmat): Likewise.
* sysdeps/unix/sysv/linux/shmdt.c (shmdt): Likewise.
* sysdeps/unix/sysv/linux/shmget.c (shmget): Likewise.
* sysdeps/unix/sysv/linux/signalfd.c (signalfd): Likewise.
* sysdeps/unix/sysv/linux/sigpending.c (sigpending): Likewise.
* sysdeps/unix/sysv/linux/sigprocmask.c ( __sigprocmask): Likewise.
* sysdeps/unix/sysv/linux/sigqueue.c (__sigqueue): Likewise.
* sysdeps/unix/sysv/linux/speed.c (cfsetospeed): Likewise.
* sysdeps/unix/sysv/linux/statfs64.c (__statfs64): Likewise.
* sysdeps/unix/sysv/linux/sysctl.c (__sysctl): Likewise.
* sysdeps/unix/sysv/linux/tcsendbrk.c (tcsendbreak): Likewise.
* sysdeps/unix/sysv/linux/tcsetattr.c (tcsetattr): Likewise.
* sysdeps/unix/sysv/linux/timer_getoverr.c (timer_getoverrun):
Likewise.
* sysdeps/unix/sysv/linux/timer_gettime.c (timer_gettime):
Likewise.
* sysdeps/unix/sysv/linux/timer_settime.c (timer_settime):
Likewise.
* sysdeps/unix/sysv/linux/truncate64.c (truncate64): Likewise.
* sysdeps/unix/sysv/linux/ustat.c (ustat): Likewise.
* sysdeps/unix/sysv/linux/utimensat.c (utimensat): Likewise.
* sysdeps/unix/sysv/linux/utimes.c (__utimes): Likewise.
* sysdeps/unix/sysv/linux/xmknod.c (__xmknod): Likewise.
* sysdeps/unix/sysv/linux/xmknodat.c (__xmknodat): Likewise.
* sysdeps/unix/sysv/linux/xstat.c (__xstat): Likewise.
* sysdeps/unix/sysv/linux/xstat64.c (___xstat64): Likewise.
* sysdeps/unix/sysv/linux/xstatconv.c (__xstat_conv): Likewise.
(__xstat64_conv): Likewise.
(__xstat32_conv): Likewise.
* sysdeps/unix/sysv/linux/sched_getaffinity.c
(__sched_getaffinity_new): Add libc_hidden_proto and
libc_hidden_def. Use INLINE_SYSCALL_ERROR_RETURN.
2015-08-20 Joseph Myers <joseph@codesourcery.com>
* timezone/Makefile (CFLAGS-zdump.c): Remove

19
sysdeps/unix/sysdep.h
View File

@ -73,22 +73,3 @@
#ifndef INLINE_SYSCALL
#define INLINE_SYSCALL(name, nr, args...) __syscall_##name (args)
#endif
/* Similar to INLINE_SYSCALL, but with return type. It should only be
used with function return. */
#ifndef INLINE_SYSCALL_RETURN
#define INLINE_SYSCALL_RETURN(name, nr, type, args...) \
INLINE_SYSCALL (name, nr, args)
#endif
/* Set error number and return value. It should only be used with
function return. ERR is the negative error number returned from
the majority of Linux kernels for which -ERR is no-op
with INTERNAL_SYSCALL_ERRNO. */
#ifndef INLINE_SYSCALL_ERROR_RETURN
#define INLINE_SYSCALL_ERROR_RETURN(err, type, value) \
({ \
__set_errno (-err); \
(type) (value); \
})
#endif

5
sysdeps/unix/sysv/linux/adjtime.c
View File

@ -61,7 +61,10 @@ ADJTIME (const struct TIMEVAL *itv, struct TIMEVAL *otv)
tmp.tv_sec = itv->tv_sec + itv->tv_usec / 1000000L;
tmp.tv_usec = itv->tv_usec % 1000000L;
if (tmp.tv_sec > MAX_SEC || tmp.tv_sec < MIN_SEC)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
tntx.offset = tmp.tv_usec + tmp.tv_sec * 1000000L;
tntx.modes = ADJ_OFFSET_SINGLESHOT;
}

3
sysdeps/unix/sysv/linux/aio_sigqueue.c
View File

@ -47,8 +47,7 @@ __aio_sigqueue (sig, val, caller_pid)
info.si_uid = getuid ();
info.si_value = val;
return INLINE_SYSCALL_RETURN (rt_sigqueueinfo, 3, int, info.si_pid,
sig, &info);
return INLINE_SYSCALL (rt_sigqueueinfo, 3, info.si_pid, sig, &info);
}
#else
# include <rt/aio_sigqueue.c>

6
sysdeps/unix/sysv/linux/dl-openat64.c
View File

@ -31,9 +31,9 @@ openat64 (dfd, file, oflag)
assert (!__OPEN_NEEDS_MODE (oflag));
#ifdef __NR_openat
return INLINE_SYSCALL_RETURN (openat, 3, int, dfd, file,
oflag | O_LARGEFILE);
return INLINE_SYSCALL (openat, 3, dfd, file, oflag | O_LARGEFILE);
#else
return INLINE_SYSCALL_ERROR_RETURN (-ENOSYS, int, -1);
__set_errno (ENOSYS);
return -1;
#endif
}

19
sysdeps/unix/sysv/linux/eventfd.c
View File

@ -25,14 +25,11 @@ int
eventfd (unsigned int count, int flags)
{
#ifdef __NR_eventfd2
int res = INLINE_SYSCALL (eventfd2, 2, count, flags);
# ifndef __ASSUME_EVENTFD2
INTERNAL_SYSCALL_DECL (err);
int res = INTERNAL_SYSCALL (eventfd2, err, 2, count, flags);
if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err))
|| INTERNAL_SYSCALL_ERRNO (res, err) != ENOSYS)
return res;
if (res != -1 || errno != ENOSYS)
# endif
return INLINE_SYSCALL_RETURN (eventfd2, 2, int, count, flags);
return res;
#endif
#ifndef __ASSUME_EVENTFD2
@ -41,12 +38,16 @@ eventfd (unsigned int count, int flags)
kernel (sys_indirect) before implementing setting flags like
O_NONBLOCK etc. */
if (flags != 0)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1)
{
__set_errno (EINVAL);
return -1;
}
# ifdef __NR_eventfd
return INLINE_SYSCALL_RETURN (eventfd, 1, int, count)
return INLINE_SYSCALL (eventfd, 1, count);
# else
return INLINE_SYSCALL_ERROR_RETURN (-ENOSYS, int, -1)
__set_errno (ENOSYS);
return -1;
# endif
#elif !defined __NR_eventfd2
# error "__ASSUME_EVENTFD2 defined but not __NR_eventfd2"

10
sysdeps/unix/sysv/linux/faccessat.c
View File

@ -35,10 +35,13 @@ faccessat (fd, file, mode, flag)
int flag;
{
if (flag & ~(AT_SYMLINK_NOFOLLOW | AT_EACCESS))
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
if ((flag == 0 || ((flag & ~AT_EACCESS) == 0 && ! __libc_enable_secure)))
return INLINE_SYSCALL_RETURN (faccessat, 3, int, fd, file, mode);
return INLINE_SYSCALL (faccessat, 3, fd, file, mode);
struct stat64 stats;
if (__fxstatat64 (_STAT_VER, fd, file, &stats, flag & AT_SYMLINK_NOFOLLOW))
@ -71,5 +74,6 @@ faccessat (fd, file, mode, flag)
if (granted == mode)
return 0;
return INLINE_SYSCALL_ERROR_RETURN (-EACCES, int, -1);
__set_errno (EACCES);
return -1;
}

12
sysdeps/unix/sysv/linux/fchmodat.c
View File

@ -34,11 +34,17 @@ fchmodat (fd, file, mode, flag)
int flag;
{
if (flag & ~AT_SYMLINK_NOFOLLOW)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
#ifndef __NR_lchmod /* Linux so far has no lchmod syscall. */
if (flag & AT_SYMLINK_NOFOLLOW)
return INLINE_SYSCALL_ERROR_RETURN (-ENOTSUP, int, -1);
{
__set_errno (ENOTSUP);
return -1;
}
#endif
return INLINE_SYSCALL_RETURN (fchmodat, 3, int, fd, file, mode);
return INLINE_SYSCALL (fchmodat, 3, fd, file, mode);
}

6
sysdeps/unix/sysv/linux/fcntl.c
View File

@ -28,7 +28,7 @@ static int
do_fcntl (int fd, int cmd, void *arg)
{
if (cmd != F_GETOWN)
return INLINE_SYSCALL_RETURN (fcntl, 3, int, fd, cmd, arg);
return INLINE_SYSCALL (fcntl, 3, fd, cmd, arg);
INTERNAL_SYSCALL_DECL (err);
struct f_owner_ex fex;
@ -36,8 +36,8 @@ do_fcntl (int fd, int cmd, void *arg)
if (!INTERNAL_SYSCALL_ERROR_P (res, err))
return fex.type == F_OWNER_GID ? -fex.pid : fex.pid;
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (res, err),
int, -1);
__set_errno (INTERNAL_SYSCALL_ERRNO (res, err));
return -1;
}

13
sysdeps/unix/sysv/linux/fstatfs64.c
View File

@ -35,17 +35,12 @@ __fstatfs64 (int fd, struct statfs64 *buf)
if (! __no_statfs64)
# endif
{
int result = INLINE_SYSCALL (fstatfs64, 3, fd, sizeof (*buf), buf);
# if __ASSUME_STATFS64 == 0
INTERNAL_SYSCALL_DECL (err);
int result = INTERNAL_SYSCALL (fstatfs64, err, 3, fd,
sizeof (*buf), buf);
if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err))
|| INTERNAL_SYSCALL_ERRNO (result, err) != ENOSYS)
return result;
# else
return INLINE_SYSCALL_RETURN (fstatfs64, 3, int, fd,
sizeof (*buf), buf);
if (result == 0 || errno != ENOSYS)
# endif
return result;
# if __ASSUME_STATFS64 == 0
__no_statfs64 = 1;

5
sysdeps/unix/sysv/linux/ftruncate64.c
View File

@ -29,7 +29,8 @@ __ftruncate64 (int fd, off64_t length)
{
unsigned int low = length & 0xffffffff;
unsigned int high = length >> 32;
return INLINE_SYSCALL_RETURN (ftruncate64, 3, int, fd,
__LONG_LONG_PAIR (high, low));
int result = INLINE_SYSCALL (ftruncate64, 3, fd,
__LONG_LONG_PAIR (high, low));
return result;
}
weak_alias (__ftruncate64, ftruncate64)

10
sysdeps/unix/sysv/linux/futimens.c
View File

@ -33,11 +33,15 @@ futimens (int fd, const struct timespec tsp[2])
{
#ifdef __NR_utimensat
if (fd < 0)
return INLINE_SYSCALL_ERROR_RETURN (-EBADF, int, -1);
{
__set_errno (EBADF);
return -1;
}
/* Avoid implicit array coercion in syscall macros. */
return INLINE_SYSCALL_RETURN (utimensat, 4, int, fd, NULL, &tsp[0], 0);
return INLINE_SYSCALL (utimensat, 4, fd, NULL, &tsp[0], 0);
#else
return INLINE_SYSCALL_ERROR_RETURN (-ENOSYS, int, -1);
__set_errno (ENOSYS);
return -1;
#endif
}
#ifndef __NR_utimensat

8
sysdeps/unix/sysv/linux/futimes.c
View File

@ -40,13 +40,15 @@ __futimes (int fd, const struct timeval tvp[2])
{
if (tvp[0].tv_usec < 0 || tvp[0].tv_usec >= 1000000
|| tvp[1].tv_usec < 0 || tvp[1].tv_usec >= 1000000)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
TIMEVAL_TO_TIMESPEC (&tvp[0], &ts[0]);
TIMEVAL_TO_TIMESPEC (&tvp[1], &ts[1]);
}
return INLINE_SYSCALL_RETURN (utimensat, 4, int, fd, NULL,
tvp ? &ts : NULL, 0);
return INLINE_SYSCALL (utimensat, 4, fd, NULL, tvp ? &ts : NULL, 0);
}
weak_alias (__futimes, futimes)

2
sysdeps/unix/sysv/linux/futimesat.c
View File

@ -34,5 +34,5 @@ futimesat (int fd, const char *file, const struct timeval tvp[2])
return __futimes (fd, tvp);
/* Avoid implicit array coercion in syscall macros. */
return INLINE_SYSCALL_RETURN (futimesat, 3, int, fd, file, &tvp[0]);
return INLINE_SYSCALL (futimesat, 3, fd, file, &tvp[0]);
}

21
sysdeps/unix/sysv/linux/fxstat.c
View File

@ -36,21 +36,20 @@ int
__fxstat (int vers, int fd, struct stat *buf)
{
if (vers == _STAT_VER_KERNEL)
return INLINE_SYSCALL_RETURN (fstat, 2, fd,
(struct kernel_stat *) buf);
return INLINE_SYSCALL (fstat, 2, fd, (struct kernel_stat *) buf);
#ifdef STAT_IS_KERNEL_STAT
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
errno = EINVAL;
return -1;
#else
struct kernel_stat kbuf;
INTERNAL_SYSCALL_DECL (err);
int result = INTERNAL_SYSCALL (fstat, err, 2, fd, &kbuf);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (result,
err),
int, -1);
else
return __xstat_conv (vers, &kbuf, buf);
int result;
result = INLINE_SYSCALL (fstat, 2, fd, &kbuf);
if (result == 0)
result = __xstat_conv (vers, &kbuf, buf);
return result;
#endif
}

8
sysdeps/unix/sysv/linux/fxstat64.c
View File

@ -31,12 +31,8 @@
int
___fxstat64 (int vers, int fd, struct stat64 *buf)
{
INTERNAL_SYSCALL_DECL (err);
int result = INTERNAL_SYSCALL (fstat64, err, 2, fd, buf);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (result,
err),
int, -1);
int result;
result = INLINE_SYSCALL (fstat64, 2, fd, buf);
#if defined _HAVE_STAT64___ST_INO && __ASSUME_ST_INO_64_BIT == 0
if (__builtin_expect (!result, 1) && buf->__st_ino != (__ino_t) buf->st_ino)
buf->st_ino = buf->__st_ino;

11
sysdeps/unix/sysv/linux/fxstatat.c
View File

@ -45,11 +45,7 @@ __fxstatat (int vers, int fd, const char *file, struct stat *st, int flag)
#endif
result = INTERNAL_SYSCALL (newfstatat, err, 4, fd, file, &kst, flag);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (result,
err),
int, -1);
else
if (!__builtin_expect (INTERNAL_SYSCALL_ERROR_P (result, err), 1))
{
#ifdef STAT_IS_KERNEL_STAT
return 0;
@ -57,6 +53,11 @@ __fxstatat (int vers, int fd, const char *file, struct stat *st, int flag)
return __xstat_conv (vers, &kst, st);
#endif
}
else
{
__set_errno (INTERNAL_SYSCALL_ERRNO (result, err));
return -1;
}
}
libc_hidden_def (__fxstatat)
#ifdef XSTAT_IS_XSTAT64

16
sysdeps/unix/sysv/linux/fxstatat64.c
View File

@ -32,17 +32,21 @@ int
__fxstatat64 (int vers, int fd, const char *file, struct stat64 *st, int flag)
{
if (__glibc_unlikely (vers != _STAT_VER_LINUX))
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
int result;
INTERNAL_SYSCALL_DECL (err);
result = INTERNAL_SYSCALL (fstatat64, err, 4, fd, file, st, flag);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (result,
err),
int, -1);
else
if (!__builtin_expect (INTERNAL_SYSCALL_ERROR_P (result, err), 1))
return 0;
else
{
__set_errno (INTERNAL_SYSCALL_ERRNO (result, err));
return -1;
}
}
libc_hidden_def (__fxstatat64)

3
sysdeps/unix/sysv/linux/gai_sigqueue.c
View File

@ -47,8 +47,7 @@ __gai_sigqueue (sig, val, caller_pid)
info.si_uid = __getuid ();
info.si_value = val;
return INLINE_SYSCALL_RETURN (rt_sigqueueinfo, 3, int, info.si_pid,
sig, &info);
return INLINE_SYSCALL (rt_sigqueueinfo, 3, info.si_pid, sig, &info);
}
#else
# include <resolv/gai_sigqueue.c>

14
sysdeps/unix/sysv/linux/getpriority.c
View File

@ -34,14 +34,12 @@
int
__getpriority (enum __priority_which which, id_t who)
{
INTERNAL_SYSCALL_DECL (err);
int res = INTERNAL_SYSCALL (getpriority, err, 2, (int) which, who);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (res,
err),
int, -1);
else
return PZERO - res;
int res;
res = INLINE_SYSCALL (getpriority, 2, (int) which, who);
if (res >= 0)
res = PZERO - res;
return res;
}
libc_hidden_def (__getpriority)
weak_alias (__getpriority, getpriority)

10
sysdeps/unix/sysv/linux/getrlimit64.c
View File

@ -27,15 +27,11 @@ int
__getrlimit64 (enum __rlimit_resource resource, struct rlimit64 *rlimits)
{
#ifdef __ASSUME_PRLIMIT64
return INLINE_SYSCALL_RETURN (prlimit64, 4, int, 0, resource,
NULL, rlimits);
return INLINE_SYSCALL (prlimit64, 4, 0, resource, NULL, rlimits);
#else
# ifdef __NR_prlimit64
INTERNAL_SYSCALL_DECL (err);
int res = INTERNAL_SYSCALL (prlimit64, err, 4, 0, resource, NULL,
rlimits);
if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err))
|| INTERNAL_SYSCALL_ERRNO (res, err) != ENOSYS)
int res = INLINE_SYSCALL (prlimit64, 4, 0, resource, NULL, rlimits);
if (res == 0 || errno != ENOSYS)
return res;
# endif
struct rlimit rlimits32;

15
sysdeps/unix/sysv/linux/llseek.c
View File

@ -29,17 +29,10 @@ loff_t
__llseek (int fd, loff_t offset, int whence)
{
loff_t retval;
INTERNAL_SYSCALL_DECL (err);
int result = INTERNAL_SYSCALL (_llseek, err, 5, fd,
(off_t) (offset >> 32),
(off_t) (offset & 0xffffffff),
&retval, whence);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (result,
err),
loff_t, -1);
else
return retval;
return (loff_t) (INLINE_SYSCALL (_llseek, 5, fd, (off_t) (offset >> 32),
(off_t) (offset & 0xffffffff),
&retval, whence) ?: retval);
}
weak_alias (__llseek, llseek)
strong_alias (__llseek, __libc_lseek64)

12
sysdeps/unix/sysv/linux/lutimes.c
View File

@ -34,16 +34,20 @@ lutimes (const char *file, const struct timeval tvp[2])
{
if (tvp[0].tv_usec < 0 || tvp[0].tv_usec >= 1000000
|| tvp[1].tv_usec < 0 || tvp[1].tv_usec >= 1000000)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
TIMEVAL_TO_TIMESPEC (&tvp[0], &ts[0]);
TIMEVAL_TO_TIMESPEC (&tvp[1], &ts[1]);
}
return INLINE_SYSCALL_RETURN (utimensat, 4, int, AT_FDCWD, file,
tvp ? ts : NULL, AT_SYMLINK_NOFOLLOW);
return INLINE_SYSCALL (utimensat, 4, AT_FDCWD, file, tvp ? ts : NULL,
AT_SYMLINK_NOFOLLOW);
#else
return INLINE_SYSCALL_ERROR_RETURN (-ENOSYS, int, -1);
__set_errno (ENOSYS);
return -1;
#endif
}

21
sysdeps/unix/sysv/linux/lxstat.c
View File

@ -35,21 +35,20 @@ int
__lxstat (int vers, const char *name, struct stat *buf)
{
if (vers == _STAT_VER_KERNEL)
return INLINE_SYSCALL_ERROR_RETURN (lstat, 2, int, name,
(struct kernel_stat *) buf);
return INLINE_SYSCALL (lstat, 2, name, (struct kernel_stat *) buf);
#ifdef STAT_IS_KERNEL_STAT
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1)
errno = EINVAL;
return -1;
#else
struct kernel_stat kbuf;
INTERNAL_SYSCALL_DECL (err);
int result = INTERNAL_SYSCALL (lstat, err, 2, name, &kbuf);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (result,
err),
int, -1)
else
return __xstat_conv (vers, &kbuf, buf);
int result;
result = INLINE_SYSCALL (lstat, 2, name, &kbuf);
if (result == 0)
result = __xstat_conv (vers, &kbuf, buf);
return result;
#endif
}

8
sysdeps/unix/sysv/linux/lxstat64.c
View File

@ -30,12 +30,8 @@
int
___lxstat64 (int vers, const char *name, struct stat64 *buf)
{
INTERNAL_SYSCALL_DECL (err);
int result = INTERNAL_SYSCALL (lstat64, err, 2, name, buf);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (result,
err),
int, -1);
int result;
result = INLINE_SYSCALL (lstat64, 2, name, buf);
#if defined _HAVE_STAT64___ST_INO && __ASSUME_ST_INO_64_BIT == 0
if (__builtin_expect (!result, 1) && buf->__st_ino != (__ino_t) buf->st_ino)
buf->st_ino = buf->__st_ino;

14
sysdeps/unix/sysv/linux/mmap64.c
View File

@ -46,9 +46,15 @@ __mmap64 (void *addr, size_t len, int prot, int flags, int fd, off64_t offset)
}
#endif
if (offset & ((1 << page_shift) - 1))
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, void *, MAP_FAILED);
return INLINE_SYSCALL_RETURN (mmap2, 6, void *, addr,
len, prot, flags, fd,
(off_t) (offset >> page_shift));
{
__set_errno (EINVAL);
return MAP_FAILED;
}
void *result;
result = (void *)
INLINE_SYSCALL (mmap2, 6, addr,
len, prot, flags, fd,
(off_t) (offset >> page_shift));
return result;
}
weak_alias (__mmap64, mmap64)

2
sysdeps/unix/sysv/linux/mq_close.c
View File

@ -26,7 +26,7 @@
int
mq_close (mqd_t mqdes)
{
return INLINE_SYSCALL_RETURN (close, 1, int, mqdes);
return INLINE_SYSCALL (close, 1, mqdes);
}
#else

8
sysdeps/unix/sysv/linux/mq_open.c
View File

@ -35,7 +35,10 @@ mqd_t
__mq_open (const char *name, int oflag, ...)
{
if (name[0] != '/')
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
mode_t mode = 0;
struct mq_attr *attr = NULL;
@ -49,8 +52,7 @@ __mq_open (const char *name, int oflag, ...)
va_end (ap);
}
return INLINE_SYSCALL_RETURN (mq_open, 4, int, name + 1, oflag, mode,
attr);
return INLINE_SYSCALL (mq_open, 4, name + 1, oflag, mode, attr);
}
strong_alias (__mq_open, mq_open);

8
sysdeps/unix/sysv/linux/mq_unlink.c
View File

@ -26,7 +26,10 @@ int
mq_unlink (const char *name)
{
if (name[0] != '/')
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
INTERNAL_SYSCALL_DECL (err);
int ret = INTERNAL_SYSCALL (mq_unlink, err, 1, name + 1);
@ -38,7 +41,8 @@ mq_unlink (const char *name)
ret = INTERNAL_SYSCALL_ERRNO (ret, err);
if (ret == EPERM)
ret = EACCES;
return INLINE_SYSCALL_ERROR_RETURN (-ret, int, -1);
__set_errno (ret);
ret = -1;
}
return ret;

3
sysdeps/unix/sysv/linux/msgget.c
View File

@ -32,6 +32,5 @@ msgget (key, msgflg)
key_t key;
int msgflg;
{
return INLINE_SYSCALL_RETURN (ipc, 5, int, IPCOP_msgget, key, msgflg,
0, NULL);
return INLINE_SYSCALL (ipc, 5, IPCOP_msgget, key, msgflg, 0, NULL);
}

24
sysdeps/unix/sysv/linux/prlimit.c
View File

@ -44,15 +44,10 @@ prlimit (__pid_t pid, enum __rlimit_resource resource,
new_rlimit64 = &new_rlimit64_mem;
}
INTERNAL_SYSCALL_DECL (err);
int res = INTERNAL_SYSCALL (prlimit64, err, 4, pid, resource,
new_rlimit64, old_rlimit64);
int res = INLINE_SYSCALL (prlimit64, 4, pid, resource, new_rlimit64,
old_rlimit64);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (res,
err),
int, -1);
else if (old_rlimit != NULL)
if (res == 0 && old_rlimit != NULL)
{
/* The prlimit64 syscall is ill-designed for 32-bit machines.
We have to provide a 32-bit variant since otherwise the LFS
@ -64,14 +59,20 @@ prlimit (__pid_t pid, enum __rlimit_resource resource,
if (old_rlimit->rlim_cur != old_rlimit64_mem.rlim_cur)
{
if (new_rlimit == NULL)
return INLINE_SYSCALL_ERROR_RETURN (-EOVERFLOW, int, -1);
{
__set_errno (EOVERFLOW);
return -1;
}
old_rlimit->rlim_cur = RLIM_INFINITY;
}
old_rlimit->rlim_max = old_rlimit64_mem.rlim_max;
if (old_rlimit->rlim_max != old_rlimit64_mem.rlim_max)
{
if (new_rlimit == NULL)
return INLINE_SYSCALL_ERROR_RETURN (-EOVERFLOW, int, -1);
{
__set_errno (EOVERFLOW);
return -1;
}
old_rlimit->rlim_max = RLIM_INFINITY;
}
}
@ -83,7 +84,8 @@ int
prlimit (__pid_t pid, enum __rlimit_resource resource,
const struct rlimit *new_rlimit, struct rlimit *old_rlimit)
{
return INLINE_SYSCALL_ERROR_RETURN (-ENOSYS, int, -1);
__set_errno (ENOSYS);
return -1;
}
stub_warning (prlimit)
#endif

4
sysdeps/unix/sysv/linux/pt-raise.c
View File

@ -33,6 +33,6 @@ raise (sig)
if (__glibc_unlikely (pid < 0))
pid = -pid;
return INLINE_SYSCALL_RETURN (tgkill, 3, int, pid,
THREAD_GETMEM (THREAD_SELF, tid), sig);
return INLINE_SYSCALL (tgkill, 3, pid, THREAD_GETMEM (THREAD_SELF, tid),
sig);
}

2
sysdeps/unix/sysv/linux/raise.c
View File

@ -52,7 +52,7 @@ raise (sig)
if (__glibc_unlikely (pid <= 0))
pid = (pid & INT_MAX) == 0 ? selftid : -pid;
return INLINE_SYSCALL_RETURN (tgkill, 3, int, pid, selftid, sig);
return INLINE_SYSCALL (tgkill, 3, pid, selftid, sig);
}
libc_hidden_def (raise)
weak_alias (raise, gsignal)

11
sysdeps/unix/sysv/linux/readahead.c
View File

@ -29,16 +29,17 @@
ssize_t
__readahead (int fd, off64_t offset, size_t count)
{
return INLINE_SYSCALL_RETURN (readahead, 4, int, fd,
__LONG_LONG_PAIR ((off_t) (offset >> 32),
(off_t) (offset & 0xffffffff)),
count);
return INLINE_SYSCALL (readahead, 4, fd,
__LONG_LONG_PAIR ((off_t) (offset >> 32),
(off_t) (offset & 0xffffffff)),
count);
}
#else
ssize_t
__readahead (int fd, off64_t offset, size_t count)
{
return INLINE_SYSCALL_ERROR_RETURN (-ENOSYS, int, -1);
__set_errno (ENOSYS);
return -1;
}
stub_warning (readahead)
#endif

3
sysdeps/unix/sysv/linux/reboot.c
View File

@ -25,6 +25,5 @@
int
reboot (int howto)
{
return INLINE_SYSCALL_RETURN (reboot, 3, int, (int) 0xfee1dead,
672274793, howto);
return INLINE_SYSCALL (reboot, 3, (int) 0xfee1dead, 672274793, howto);
}

18
sysdeps/unix/sysv/linux/sched_getaffinity.c
View File

@ -25,22 +25,12 @@
#ifdef __NR_sched_getaffinity
# if SHLIB_COMPAT (libc, GLIBC_2_3_3, GLIBC_2_3_4)
extern int __sched_getaffinity_new (pid_t, size_t, cpu_set_t *);
libc_hidden_proto (__sched_getaffinity_new)
# endif
int
__sched_getaffinity_new (pid_t pid, size_t cpusetsize, cpu_set_t *cpuset)
{
INTERNAL_SYSCALL_DECL (err);
int res = INTERNAL_SYSCALL (sched_getaffinity, err, 3, pid,
MIN (INT_MAX, cpusetsize), cpuset);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (res,
err),
int, -1);
else
int res = INLINE_SYSCALL (sched_getaffinity, 3, pid,
MIN (INT_MAX, cpusetsize), cpuset);
if (res != -1)
{
/* Clean the rest of the memory the kernel didn't do. */
memset ((char *) cpuset + res, '\0', cpusetsize - res);
@ -54,8 +44,6 @@ versioned_symbol (libc, __sched_getaffinity_new, sched_getaffinity,
# if SHLIB_COMPAT (libc, GLIBC_2_3_3, GLIBC_2_3_4)
libc_hidden_def (__sched_getaffinity_new)
int
attribute_compat_text_section
__sched_getaffinity_old (pid_t pid, cpu_set_t *cpuset)

3
sysdeps/unix/sysv/linux/semget.c
View File

@ -33,6 +33,5 @@ semget (key, nsems, semflg)
int nsems;
int semflg;
{
return INLINE_SYSCALL_RETURN (ipc, 5, int, IPCOP_semget, key, nsems,
semflg, NULL);
return INLINE_SYSCALL (ipc, 5, IPCOP_semget, key, nsems, semflg, NULL);
}

3
sysdeps/unix/sysv/linux/semop.c
View File

@ -31,6 +31,5 @@ semop (semid, sops, nsops)
struct sembuf *sops;
size_t nsops;
{
return INLINE_SYSCALL_RETURN (ipc, 5, int, IPCOP_semop, semid,
(int) nsops, 0, sops);
return INLINE_SYSCALL (ipc, 5, IPCOP_semop, semid, (int) nsops, 0, sops);
}

5
sysdeps/unix/sysv/linux/semtimedop.c
View File

@ -32,6 +32,7 @@ semtimedop (semid, sops, nsops, timeout)
size_t nsops;
const struct timespec *timeout;
{
return INLINE_SYSCALL_RETURN (ipc, 6, int, IPCOP_semtimedop, semid,
(int) nsops, 0, sops, timeout);
return INLINE_SYSCALL (ipc, 6, IPCOP_semtimedop,
semid, (int) nsops, 0, sops,
timeout);
}

10
sysdeps/unix/sysv/linux/setrlimit64.c
View File

@ -30,15 +30,11 @@ setrlimit64 (resource, rlimits)
const struct rlimit64 *rlimits;
{
#ifdef __ASSUME_PRLIMIT64
return INLINE_SYSCALL_RETURN (prlimit64, 4, int, 0, resource,
rlimits, NULL);
return INLINE_SYSCALL (prlimit64, 4, 0, resource, rlimits, NULL);
#else
# ifdef __NR_prlimit64
INTERNAL_SYSCALL_DECL (err);
int res = INTERNAL_SYSCALL (prlimit64, err, 4, 0, resource, rlimits,
NULL);
if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err))
|| INTERNAL_SYSCALL_ERRNO (res, err) != ENOSYS)
int res = INLINE_SYSCALL (prlimit64, 4, 0, resource, rlimits, NULL);
if (res == 0 || errno != ENOSYS)
return res;
# endif
struct rlimit rlimits32;

13
sysdeps/unix/sysv/linux/shmat.c
View File

@ -42,10 +42,11 @@ shmat (shmid, shmaddr, shmflg)
shmid, shmflg,
(long int) &raddr,
(void *) shmaddr);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (resultvar,
err),
void *, -1l);
else
return raddr;
if (INTERNAL_SYSCALL_ERROR_P (resultvar, err))
{
__set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, err));
return (void *) -1l;
}
return raddr;
}

3
sysdeps/unix/sysv/linux/shmdt.c
View File

@ -30,6 +30,5 @@ int
shmdt (shmaddr)
const void *shmaddr;
{
return INLINE_SYSCALL_RETURN (ipc, 5, int, IPCOP_shmdt, 0, 0, 0,
(void *) shmaddr);
return INLINE_SYSCALL (ipc, 5, IPCOP_shmdt, 0, 0, 0, (void *) shmaddr);
}

3
sysdeps/unix/sysv/linux/shmget.c
View File

@ -33,6 +33,5 @@ shmget (key, size, shmflg)
size_t size;
int shmflg;
{
return INLINE_SYSCALL_RETURN (ipc, 5, int, IPCOP_shmget, key, size,
shmflg, NULL);
return INLINE_SYSCALL (ipc, 5, IPCOP_shmget, key, size, shmflg, NULL);
}

22
sysdeps/unix/sysv/linux/signalfd.c
View File

@ -26,17 +26,11 @@ int
signalfd (int fd, const sigset_t *mask, int flags)
{
#ifdef __NR_signalfd4
int res = INLINE_SYSCALL (signalfd4, 4, fd, mask, _NSIG / 8, flags);
# ifndef __ASSUME_SIGNALFD4
INTERNAL_SYSCALL_DECL (err);
int res = INTERNAL_SYSCALL (signalfd4, err, 4, fd, mask, _NSIG / 8,
flags);
if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err))
|| INTERNAL_SYSCALL_ERRNO (res, err) != ENOSYS)
return res;
# else
return INLINE_SYSCALL_RETURN (signalfd4, 4, int, fd, mask, _NSIG / 8,
flags);
if (res != -1 || errno != ENOSYS)
# endif
return res;
#endif
#ifndef __ASSUME_SIGNALFD4
@ -45,12 +39,16 @@ signalfd (int fd, const sigset_t *mask, int flags)
kernel (sys_indirect) before implementing setting flags like
O_NONBLOCK etc. */
if (flags != 0)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
# ifdef __NR_signalfd
return INLINE_SYSCALL_RETURN (signalfd, 3, int, fd, mask, _NSIG / 8);
return INLINE_SYSCALL (signalfd, 3, fd, mask, _NSIG / 8);
# else
return INLINE_SYSCALL_ERROR_RETURN (-ENOSYS, int, -1);
__set_errno (ENOSYS);
return -1;
# endif
#elif !defined __NR_signalfd4
# error "__ASSUME_SIGNALFD4 defined but not __NR_signalfd4"

2
sysdeps/unix/sysv/linux/sigpending.c
View File

@ -29,5 +29,5 @@ int
sigpending (set)
sigset_t *set;
{
return INLINE_SYSCALL_RETURN (rt_sigpending, 2, int, set, _NSIG / 8);
return INLINE_SYSCALL (rt_sigpending, 2, set, _NSIG / 8);
}

3
sysdeps/unix/sysv/linux/sigprocmask.c
View File

@ -54,7 +54,6 @@ __sigprocmask (how, set, oset)
}
#endif
return INLINE_SYSCALL_RETURN (rt_sigprocmask, 4, int, how, set, oset,
_NSIG / 8);
return INLINE_SYSCALL (rt_sigprocmask, 4, how, set, oset, _NSIG / 8);
}
weak_alias (__sigprocmask, sigprocmask)

2
sysdeps/unix/sysv/linux/sigqueue.c
View File

@ -43,7 +43,7 @@ __sigqueue (pid, sig, val)
info.si_uid = __getuid ();
info.si_value = val;
return INLINE_SYSCALL_RETURN (rt_sigqueueinfo, 3, int, pid, sig, &info);
return INLINE_SYSCALL (rt_sigqueueinfo, 3, pid, sig, &info);
}
weak_alias (__sigqueue, sigqueue)
#else

10
sysdeps/unix/sysv/linux/speed.c
View File

@ -60,7 +60,10 @@ cfsetospeed (termios_p, speed)
{
if ((speed & ~CBAUD) != 0
&& (speed < B57600 || speed > __MAX_BAUD))
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
#ifdef _HAVE_STRUCT_TERMIOS_C_OSPEED
termios_p->c_ospeed = speed;
@ -84,7 +87,10 @@ cfsetispeed (termios_p, speed)
{
if ((speed & ~CBAUD) != 0
&& (speed < B57600 || speed > __MAX_BAUD))
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
#ifdef _HAVE_STRUCT_TERMIOS_C_ISPEED
termios_p->c_ispeed = speed;

14
sysdeps/unix/sysv/linux/statfs64.c
View File

@ -37,18 +37,12 @@ __statfs64 (const char *file, struct statfs64 *buf)
if (! __no_statfs64)
# endif
{
# if __ASSUME_STATFS64 == 0
INTERNAL_SYSCALL_DECL (err);
int result = INTERNAL_SYSCALL (statfs64, err, 3, file,
sizeof (*buf), buf);
int result = INLINE_SYSCALL (statfs64, 3, file, sizeof (*buf), buf);
if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err))
|| INTERNAL_SYSCALL_ERRNO (result, err) != ENOSYS)
return result;
# else
return INLINE_SYSCALL_RETURN (statfs64, 3, int, file,
sizeof (*buf), buf);
# if __ASSUME_STATFS64 == 0
if (result == 0 || errno != ENOSYS)
# endif
return result;
# if __ASSUME_STATFS64 == 0
__no_statfs64 = 1;

2
sysdeps/unix/sysv/linux/sysctl.c
View File

@ -37,7 +37,7 @@ __sysctl (int *name, int nlen, void *oldval, size_t *oldlenp,
.newlen = newlen
};
return INLINE_SYSCALL_RETURN (_sysctl, 1, int, &args);
return INLINE_SYSCALL (_sysctl, 1, &args);
}
libc_hidden_def (__sysctl)
weak_alias (__sysctl, sysctl)

3
sysdeps/unix/sysv/linux/tcsendbrk.c
View File

@ -39,6 +39,7 @@ tcsendbreak (int fd, int duration)
/* ioctl can't send a break of any other duration for us.
This could be changed to use trickery (e.g. lower speed and
send a '\0') to send the break, but for now just return an error. */
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
__set_errno (EINVAL);
return -1;
#endif
}

5
sysdeps/unix/sysv/linux/tcsetattr.c
View File

@ -61,7 +61,8 @@ tcsetattr (fd, optional_actions, termios_p)
cmd = TCSETSF;
break;
default:
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
__set_errno (EINVAL);
return -1;
}
k_termios.c_iflag = termios_p->c_iflag & ~IBAUD0;
@ -78,6 +79,6 @@ tcsetattr (fd, optional_actions, termios_p)
memcpy (&k_termios.c_cc[0], &termios_p->c_cc[0],
__KERNEL_NCCS * sizeof (cc_t));
return INLINE_SYSCALL_RETURN (ioctl, 3, int, fd, cmd, &k_termios);
return INLINE_SYSCALL (ioctl, 3, fd, cmd, &k_termios);
}
libc_hidden_def (tcsetattr)

4
sysdeps/unix/sysv/linux/timer_getoverr.c
View File

@ -35,5 +35,7 @@ timer_getoverrun (timerid)
struct timer *kt = (struct timer *) timerid;
/* Get the information from the kernel. */
return INLINE_SYSCALL_RETURN (timer_getoverrun, 1, int, kt->ktimerid);
int res = INLINE_SYSCALL (timer_getoverrun, 1, kt->ktimerid);
return res;
}

5
sysdeps/unix/sysv/linux/timer_gettime.c
View File

@ -37,6 +37,7 @@ timer_gettime (timerid, value)
struct timer *kt = (struct timer *) timerid;
/* Delete the kernel timer object. */
return INLINE_SYSCALL_RETURN (timer_gettime, 2, int, kt->ktimerid,
value);
int res = INLINE_SYSCALL (timer_gettime, 2, kt->ktimerid, value);
return res;
}

6
sysdeps/unix/sysv/linux/timer_settime.c
View File

@ -39,6 +39,8 @@ timer_settime (timerid, flags, value, ovalue)
struct timer *kt = (struct timer *) timerid;
/* Delete the kernel timer object. */
return INLINE_SYSCALL_RETURN (timer_settime, 4, int, kt->ktimerid,
flags, value, ovalue);
int res = INLINE_SYSCALL (timer_settime, 4, kt->ktimerid, flags,
value, ovalue);
return res;
}

5
sysdeps/unix/sysv/linux/truncate64.c
View File

@ -29,6 +29,7 @@ truncate64 (const char *path, off64_t length)
{
unsigned int low = length & 0xffffffff;
unsigned int high = length >> 32;
return INLINE_SYSCALL_RETURN (truncate64, 3, int, path,
__LONG_LONG_PAIR (high, low));
int result = INLINE_SYSCALL (truncate64, 3, path,
__LONG_LONG_PAIR (high, low));
return result;
}

8
sysdeps/unix/sysv/linux/ustat.c
View File

@ -31,8 +31,10 @@ ustat (dev_t dev, struct ustat *ubuf)
/* We must convert the value to dev_t type used by the kernel. */
k_dev = dev & ((1ULL << 32) - 1);
if (k_dev != dev)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
return INLINE_SYSCALL_RETURN (ustat, 2, int, (unsigned int) k_dev,
ubuf);
return INLINE_SYSCALL (ustat, 2, (unsigned int) k_dev, ubuf);
}

11
sysdeps/unix/sysv/linux/utimensat.c
View File

@ -30,13 +30,16 @@ utimensat (int fd, const char *file, const struct timespec tsp[2],
int flags)
{
if (file == NULL)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
#ifdef __NR_utimensat
/* Avoid implicit array coercion in syscall macros. */
return INLINE_SYSCALL_RETURN (utimensat, 4, int, fd, file, &tsp[0],
flags);
return INLINE_SYSCALL (utimensat, 4, fd, file, &tsp[0], flags);
#else
return INLINE_SYSCALL_ERROR_RETURN (-ENOSYS, int, -1);
__set_errno (ENOSYS);
return -1;
#endif
}
#ifndef __NR_utimensat

2
sysdeps/unix/sysv/linux/utimes.c
View File

@ -30,7 +30,7 @@ int
__utimes (const char *file, const struct timeval tvp[2])
{
/* Avoid implicit array coercion in syscall macros. */
return INLINE_SYSCALL_RETURN (utimes, 2, int, file, &tvp[0]);
return INLINE_SYSCALL (utimes, 2, file, &tvp[0]);
}
weak_alias (__utimes, utimes)

13
sysdeps/unix/sysv/linux/xmknod.c
View File

@ -33,15 +33,20 @@ __xmknod (int vers, const char *path, mode_t mode, dev_t *dev)
unsigned long long int k_dev;
if (vers != _MKNOD_VER)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
/* We must convert the value to dev_t type used by the kernel. */
k_dev = (*dev) & ((1ULL << 32) - 1);
if (k_dev != *dev)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
return INLINE_SYSCALL_RETURN (mknod, 3, int, path, mode,
(unsigned int) k_dev);
return INLINE_SYSCALL (mknod, 3, path, mode, (unsigned int) k_dev);
}
weak_alias (__xmknod, _xmknod)

13
sysdeps/unix/sysv/linux/xmknodat.c
View File

@ -34,15 +34,20 @@ int
__xmknodat (int vers, int fd, const char *file, mode_t mode, dev_t *dev)
{
if (vers != _MKNOD_VER)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
/* We must convert the value to dev_t type used by the kernel. */
unsigned long long int k_dev = (*dev) & ((1ULL << 32) - 1);
if (k_dev != *dev)
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
{
__set_errno (EINVAL);
return -1;
}
return INLINE_SYSCALL_RETURN (mknodat, 4, int, fd, file, mode,
(unsigned int) k_dev);
return INLINE_SYSCALL (mknodat, 4, fd, file, mode, (unsigned int) k_dev);
}
libc_hidden_def (__xmknodat)

18
sysdeps/unix/sysv/linux/xstat.c
View File

@ -35,22 +35,20 @@ int
__xstat (int vers, const char *name, struct stat *buf)
{
if (vers == _STAT_VER_KERNEL)
return INLINE_SYSCALL_RETURN (stat, 2, int, name,
(struct kernel_stat *) buf);
return INLINE_SYSCALL (stat, 2, name, (struct kernel_stat *) buf);
#ifdef STAT_IS_KERNEL_STAT
errno = EINVAL;
return -1;
#else
struct kernel_stat kbuf;
INTERNAL_SYSCALL_DECL (err);
int result = INTERNAL_SYSCALL (stat, err, 2, name, &kbuf);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (result,
err),
int, -1);
else
return __xstat_conv (vers, &kbuf, buf);
int result;
result = INLINE_SYSCALL (stat, 2, name, &kbuf);
if (result == 0)
result = __xstat_conv (vers, &kbuf, buf);
return result;
#endif
}
hidden_def (__xstat)

8
sysdeps/unix/sysv/linux/xstat64.c
View File

@ -31,12 +31,8 @@
int
___xstat64 (int vers, const char *name, struct stat64 *buf)
{
INTERNAL_SYSCALL_DECL (err);
int result = INTERNAL_SYSCALL (stat64, err, 2, name, buf);
if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
return INLINE_SYSCALL_ERROR_RETURN (-INTERNAL_SYSCALL_ERRNO (result,
err),
int, -1);
int result;
result = INLINE_SYSCALL (stat64, 2, name, buf);
#if defined _HAVE_STAT64___ST_INO && __ASSUME_ST_INO_64_BIT == 0
if (__builtin_expect (!result, 1) && buf->__st_ino != (__ino_t) buf->st_ino)
buf->st_ino = buf->__st_ino;

29
sysdeps/unix/sysv/linux/xstatconv.c
View File

@ -96,7 +96,8 @@ __xstat_conv (int vers, struct kernel_stat *kbuf, void *ubuf)
break;
default:
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
__set_errno (EINVAL);
return -1;
}
return 0;
@ -169,7 +170,8 @@ __xstat64_conv (int vers, struct kernel_stat *kbuf, void *ubuf)
_STAT_VER_KERNEL does not make sense. */
case _STAT_VER_KERNEL:
default:
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
__set_errno (EINVAL);
return -1;
}
return 0;
@ -199,13 +201,19 @@ __xstat32_conv (int vers, struct stat64 *kbuf, struct stat *buf)
buf->st_ino = kbuf->st_ino;
if (sizeof (buf->st_ino) != sizeof (kbuf->st_ino)
&& buf->st_ino != kbuf->st_ino)
return INLINE_SYSCALL_ERROR_RETURN (-EOVERFLOW, int, -1);
{
__set_errno (EOVERFLOW);
return -1;
}
}
#else
buf->st_ino = kbuf->st_ino;
if (sizeof (buf->st_ino) != sizeof (kbuf->st_ino)
&& buf->st_ino != kbuf->st_ino)
return INLINE_SYSCALL_ERROR_RETURN (-EOVERFLOW, int, -1);
{
__set_errno (EOVERFLOW);
return -1;
}
#endif
buf->st_mode = kbuf->st_mode;
buf->st_nlink = kbuf->st_nlink;
@ -219,13 +227,19 @@ __xstat32_conv (int vers, struct stat64 *kbuf, struct stat *buf)
/* Check for overflow. */
if (sizeof (buf->st_size) != sizeof (kbuf->st_size)
&& buf->st_size != kbuf->st_size)
return INLINE_SYSCALL_ERROR_RETURN (-EOVERFLOW, int, -1);
{
__set_errno (EOVERFLOW);
return -1;
}
buf->st_blksize = kbuf->st_blksize;
buf->st_blocks = kbuf->st_blocks;
/* Check for overflow. */
if (sizeof (buf->st_blocks) != sizeof (kbuf->st_blocks)
&& buf->st_blocks != kbuf->st_blocks)
return INLINE_SYSCALL_ERROR_RETURN (-EOVERFLOW, int, -1);
{
__set_errno (EOVERFLOW);
return -1;
}
#ifdef _HAVE_STAT_NSEC
buf->st_atim.tv_sec = kbuf->st_atim.tv_sec;
buf->st_atim.tv_nsec = kbuf->st_atim.tv_nsec;
@ -261,7 +275,8 @@ __xstat32_conv (int vers, struct stat64 *kbuf, struct stat *buf)
_STAT_VER_KERNEL does not make sense. */
case _STAT_VER_KERNEL:
default:
return INLINE_SYSCALL_ERROR_RETURN (-EINVAL, int, -1);
__set_errno (EINVAL);
return -1;
}
return 0;