RepoMirrors
/
haproxy
mirror of http://git.haproxy.org/git/haproxy.git/
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
haproxy/include/common/syscall.h

154 lines
4.4 KiB
C
Raw Normal View History

[REORG] build: move syscall redefinition to specific places Some older libc don't define splice() and and don't define _syscall*() either, which causes build errors if splicing is enabled. To solve this, we now split the syscall redefinition into two layers : - one file per syscall (epoll, splice) - one common file to declare the _syscall*() macros The code is cleaner because files using the syscalls just have to include their respective file. It's not adviced to merge multiple syscall families into a same file if all are not intended to be used simultaneously, because defining unused static functions causes warnings to be emitted during build. As a result, the new USE_MY_SPLICE parameter was added in order to be able to define the splice() syscall separately.
2011-08-22 15:12:02 +00:00
/*
* include/common/syscall.h
* Redefinition of some missing OS-specific system calls.
*
MEDIUM: listener: add support for linux's accept4() syscall On Linux, accept4() does the same as accept() except that it allows the caller to specify some flags to set on the resulting socket. We use this to set the O_NONBLOCK flag and thus to save one fcntl() call in each connection. The effect is a small performance gain of around 1%. The option is automatically enabled when target linux2628 is set, or when the USE_ACCEPT4 Makefile variable is set. If the libc is too old to provide the equivalent function, this is automatically detected and our own function is used instead. In any case it is possible to force the use of our implementation with USE_MY_ACCEPT4.
2012-10-08 18:11:03 +00:00
* Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
[REORG] build: move syscall redefinition to specific places Some older libc don't define splice() and and don't define _syscall*() either, which causes build errors if splicing is enabled. To solve this, we now split the syscall redefinition into two layers : - one file per syscall (epoll, splice) - one common file to declare the _syscall*() macros The code is cleaner because files using the syscalls just have to include their respective file. It's not adviced to merge multiple syscall families into a same file if all are not intended to be used simultaneously, because defining unused static functions causes warnings to be emitted during build. As a result, the new USE_MY_SPLICE parameter was added in order to be able to define the splice() syscall separately.
2011-08-22 15:12:02 +00:00
*
* This 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, version 2.1
* exclusively.
*
* This 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 this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifndef _COMMON_SYSCALL_H
#define _COMMON_SYSCALL_H
#ifdef __linux__
#include <errno.h>
#include <unistd.h>
#include <sys/syscall.h>
/* On Linux, _syscall macros were removed after 2.6.18, but we still prefer
* them because syscall() is buggy on old libcs. If _syscall is not defined,
* we're on a recent kernel with a recent libc and we should be safe, so we
* emulate is using syscall().
*/
#ifndef _syscall1
#define _syscall1(tr, nr, t1, n1) \
BUILD: syscalls: remove improper inline statement in front of syscalls Trying to build with an old gcc and glibc revealed that we must not state "inline" in our _syscall* definitions since it's already present in the declaration making use of the _syscall* macros.
2014-05-08 20:36:29 +00:00
tr nr(t1 n1) { \
[REORG] build: move syscall redefinition to specific places Some older libc don't define splice() and and don't define _syscall*() either, which causes build errors if splicing is enabled. To solve this, we now split the syscall redefinition into two layers : - one file per syscall (epoll, splice) - one common file to declare the _syscall*() macros The code is cleaner because files using the syscalls just have to include their respective file. It's not adviced to merge multiple syscall families into a same file if all are not intended to be used simultaneously, because defining unused static functions causes warnings to be emitted during build. As a result, the new USE_MY_SPLICE parameter was added in order to be able to define the splice() syscall separately.
2011-08-22 15:12:02 +00:00
return syscall(__NR_##nr, n1); \
}
#endif
#ifndef _syscall2
#define _syscall2(tr, nr, t1, n1, t2, n2) \
BUILD: syscalls: remove improper inline statement in front of syscalls Trying to build with an old gcc and glibc revealed that we must not state "inline" in our _syscall* definitions since it's already present in the declaration making use of the _syscall* macros.
2014-05-08 20:36:29 +00:00
tr nr(t1 n1, t2 n2) { \
[REORG] build: move syscall redefinition to specific places Some older libc don't define splice() and and don't define _syscall*() either, which causes build errors if splicing is enabled. To solve this, we now split the syscall redefinition into two layers : - one file per syscall (epoll, splice) - one common file to declare the _syscall*() macros The code is cleaner because files using the syscalls just have to include their respective file. It's not adviced to merge multiple syscall families into a same file if all are not intended to be used simultaneously, because defining unused static functions causes warnings to be emitted during build. As a result, the new USE_MY_SPLICE parameter was added in order to be able to define the splice() syscall separately.
2011-08-22 15:12:02 +00:00
return syscall(__NR_##nr, n1, n2); \
}
#endif
#ifndef _syscall3
#define _syscall3(tr, nr, t1, n1, t2, n2, t3, n3) \
BUILD: syscalls: remove improper inline statement in front of syscalls Trying to build with an old gcc and glibc revealed that we must not state "inline" in our _syscall* definitions since it's already present in the declaration making use of the _syscall* macros.
2014-05-08 20:36:29 +00:00
tr nr(t1 n1, t2 n2, t3 n3) { \
[REORG] build: move syscall redefinition to specific places Some older libc don't define splice() and and don't define _syscall*() either, which causes build errors if splicing is enabled. To solve this, we now split the syscall redefinition into two layers : - one file per syscall (epoll, splice) - one common file to declare the _syscall*() macros The code is cleaner because files using the syscalls just have to include their respective file. It's not adviced to merge multiple syscall families into a same file if all are not intended to be used simultaneously, because defining unused static functions causes warnings to be emitted during build. As a result, the new USE_MY_SPLICE parameter was added in order to be able to define the splice() syscall separately.
2011-08-22 15:12:02 +00:00
return syscall(__NR_##nr, n1, n2, n3); \
}
#endif
#ifndef _syscall4
#define _syscall4(tr, nr, t1, n1, t2, n2, t3, n3, t4, n4) \
BUILD: syscalls: remove improper inline statement in front of syscalls Trying to build with an old gcc and glibc revealed that we must not state "inline" in our _syscall* definitions since it's already present in the declaration making use of the _syscall* macros.
2014-05-08 20:36:29 +00:00
tr nr(t1 n1, t2 n2, t3 n3, t4 n4) { \
[REORG] build: move syscall redefinition to specific places Some older libc don't define splice() and and don't define _syscall*() either, which causes build errors if splicing is enabled. To solve this, we now split the syscall redefinition into two layers : - one file per syscall (epoll, splice) - one common file to declare the _syscall*() macros The code is cleaner because files using the syscalls just have to include their respective file. It's not adviced to merge multiple syscall families into a same file if all are not intended to be used simultaneously, because defining unused static functions causes warnings to be emitted during build. As a result, the new USE_MY_SPLICE parameter was added in order to be able to define the splice() syscall separately.
2011-08-22 15:12:02 +00:00
return syscall(__NR_##nr, n1, n2, n3, n4); \
}
#endif
#ifndef _syscall5
#define _syscall5(tr, nr, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5) \
BUILD: syscalls: remove improper inline statement in front of syscalls Trying to build with an old gcc and glibc revealed that we must not state "inline" in our _syscall* definitions since it's already present in the declaration making use of the _syscall* macros.
2014-05-08 20:36:29 +00:00
tr nr(t1 n1, t2 n2, t3 n3, t4 n4, t5 n5) { \
[REORG] build: move syscall redefinition to specific places Some older libc don't define splice() and and don't define _syscall*() either, which causes build errors if splicing is enabled. To solve this, we now split the syscall redefinition into two layers : - one file per syscall (epoll, splice) - one common file to declare the _syscall*() macros The code is cleaner because files using the syscalls just have to include their respective file. It's not adviced to merge multiple syscall families into a same file if all are not intended to be used simultaneously, because defining unused static functions causes warnings to be emitted during build. As a result, the new USE_MY_SPLICE parameter was added in order to be able to define the splice() syscall separately.
2011-08-22 15:12:02 +00:00
return syscall(__NR_##nr, n1, n2, n3, n4, n5); \
}
#endif
#ifndef _syscall6
#define _syscall6(tr, nr, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6) \
BUILD: syscalls: remove improper inline statement in front of syscalls Trying to build with an old gcc and glibc revealed that we must not state "inline" in our _syscall* definitions since it's already present in the declaration making use of the _syscall* macros.
2014-05-08 20:36:29 +00:00
tr nr(t1 n1, t2 n2, t3 n3, t4 n4, t5 n5, t6 n6) { \
[REORG] build: move syscall redefinition to specific places Some older libc don't define splice() and and don't define _syscall*() either, which causes build errors if splicing is enabled. To solve this, we now split the syscall redefinition into two layers : - one file per syscall (epoll, splice) - one common file to declare the _syscall*() macros The code is cleaner because files using the syscalls just have to include their respective file. It's not adviced to merge multiple syscall families into a same file if all are not intended to be used simultaneously, because defining unused static functions causes warnings to be emitted during build. As a result, the new USE_MY_SPLICE parameter was added in order to be able to define the splice() syscall separately.
2011-08-22 15:12:02 +00:00
return syscall(__NR_##nr, n1, n2, n3, n4, n5, n6); \
}
#endif
/* Define some syscall numbers that are sometimes needed */
/* Epoll was provided as a patch for 2.4 for a long time and was not always
* exported as a known sysctl number by libc.
*/
#if !defined(__NR_epoll_ctl)
#if defined(__powerpc__) || defined(__powerpc64__)
#define __NR_epoll_create 236
#define __NR_epoll_ctl 237
#define __NR_epoll_wait 238
#elif defined(__sparc__) || defined(__sparc64__)
#define __NR_epoll_create 193
#define __NR_epoll_ctl 194
#define __NR_epoll_wait 195
#elif defined(__x86_64__)
#define __NR_epoll_create 213
#define __NR_epoll_ctl 214
#define __NR_epoll_wait 215
#elif defined(__alpha__)
#define __NR_epoll_create 407
#define __NR_epoll_ctl 408
#define __NR_epoll_wait 409
#elif defined (__i386__)
#define __NR_epoll_create 254
#define __NR_epoll_ctl 255
#define __NR_epoll_wait 256
#endif /* $arch */
#endif /* __NR_epoll_ctl */
/* splice is even more recent than epoll. It appeared around 2.6.18 but was
* not in libc for a while.
*/
#ifndef __NR_splice
#if defined(__powerpc__) || defined(__powerpc64__)
#define __NR_splice 283
#elif defined(__sparc__) || defined(__sparc64__)
#define __NR_splice 232
#elif defined(__x86_64__)
#define __NR_splice 275
#elif defined(__alpha__)
#define __NR_splice 468
#elif defined (__i386__)
#define __NR_splice 313
#endif /* $arch */
#endif /* __NR_splice */
MEDIUM: listener: add support for linux's accept4() syscall On Linux, accept4() does the same as accept() except that it allows the caller to specify some flags to set on the resulting socket. We use this to set the O_NONBLOCK flag and thus to save one fcntl() call in each connection. The effect is a small performance gain of around 1%. The option is automatically enabled when target linux2628 is set, or when the USE_ACCEPT4 Makefile variable is set. If the libc is too old to provide the equivalent function, this is automatically detected and our own function is used instead. In any case it is possible to force the use of our implementation with USE_MY_ACCEPT4.
2012-10-08 18:11:03 +00:00
/* accept4() appeared in Linux 2.6.28, but it might not be in all libcs. Some
* archs have it as a native syscall, other ones use the socketcall instead.
*/
#ifndef __NR_accept4
#if defined(__x86_64__)
#define __NR_accept4 288
#elif defined(__sparc__) || defined(__sparc64__)
BUG/MINOR: syscall: fix NR_accept4 system call on sparc/linux An invalid copy-paste called it NR_splice instead of NR_accept4. This does not lead to real issues because if this define is used, then the code cannot compile since NR_accept4 is still missing.
2013-03-04 06:31:08 +00:00
#define __NR_accept4 323
BUILD/MINOR: syscall: add definition of NR_accept4 for ARM This platform was not covered and older libc do not provide accept4().
2013-03-04 06:38:08 +00:00
#elif defined(__arm__) || defined(__thumb__)
#define __NR_accept4 (__NR_SYSCALL_BASE+366)
MEDIUM: listener: add support for linux's accept4() syscall On Linux, accept4() does the same as accept() except that it allows the caller to specify some flags to set on the resulting socket. We use this to set the O_NONBLOCK flag and thus to save one fcntl() call in each connection. The effect is a small performance gain of around 1%. The option is automatically enabled when target linux2628 is set, or when the USE_ACCEPT4 Makefile variable is set. If the libc is too old to provide the equivalent function, this is automatically detected and our own function is used instead. In any case it is possible to force the use of our implementation with USE_MY_ACCEPT4.
2012-10-08 18:11:03 +00:00
#else
#define ACCEPT4_USE_SOCKETCALL 1
#ifndef SYS_ACCEPT4
#define SYS_ACCEPT4 18
#endif /* SYS_ACCEPT4 */
#endif /* $arch */
#endif /* __NR_accept4 */
[REORG] build: move syscall redefinition to specific places Some older libc don't define splice() and and don't define _syscall*() either, which causes build errors if splicing is enabled. To solve this, we now split the syscall redefinition into two layers : - one file per syscall (epoll, splice) - one common file to declare the _syscall*() macros The code is cleaner because files using the syscalls just have to include their respective file. It's not adviced to merge multiple syscall families into a same file if all are not intended to be used simultaneously, because defining unused static functions causes warnings to be emitted during build. As a result, the new USE_MY_SPLICE parameter was added in order to be able to define the splice() syscall separately.
2011-08-22 15:12:02 +00:00
#endif /* __linux__ */
#endif /* _COMMON_SYSCALL_H */
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/