+2015-10-19 Joseph Myers <joseph@codesourcery.com>
+
+ * sysdeps/arm/backtrace.c (__backtrace): Convert to
+ prototype-style function definition.
+ * sysdeps/i386/backtrace.c (__backtrace): Likewise.
+ * sysdeps/i386/ffs.c (__ffs): Likewise.
+ * sysdeps/i386/i686/ffs.c (__ffs): Likewise.
+ * sysdeps/ia64/nptl/pthread_spin_lock.c (pthread_spin_lock):
+ Likewise.
+ * sysdeps/ia64/nptl/pthread_spin_trylock.c (pthread_spin_trylock):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128/e_log2l.c (__ieee754_log2l): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/e_log2l.c (__ieee754_log2l):
+ Likewise.
+ * sysdeps/m68k/ffs.c (__ffs): Likewise.
+ * sysdeps/m68k/m680x0/fpu/e_acos.c (FUNC): Likewise.
+ * sysdeps/m68k/m680x0/fpu/e_fmod.c (FUNC): Likewise.
+ * sysdeps/mach/adjtime.c (__adjtime): Likewise.
+ * sysdeps/mach/gettimeofday.c (__gettimeofday): Likewise.
+ * sysdeps/mach/hurd/_exit.c (_exit): Likewise.
+ * sysdeps/mach/hurd/access.c (__access): Likewise.
+ * sysdeps/mach/hurd/adjtime.c (__adjtime): Likewise.
+ * sysdeps/mach/hurd/chdir.c (__chdir): Likewise.
+ * sysdeps/mach/hurd/chmod.c (__chmod): Likewise.
+ * sysdeps/mach/hurd/chown.c (__chown): Likewise.
+ * sysdeps/mach/hurd/cthreads.c (cthread_keycreate): Likewise.
+ (cthread_getspecific): Likewise.
+ (cthread_setspecific): Likewise.
+ (__libc_getspecific): Likewise.
+ * sysdeps/mach/hurd/euidaccess.c (__euidaccess): Likewise.
+ * sysdeps/mach/hurd/faccessat.c (faccessat): Likewise.
+ * sysdeps/mach/hurd/fchdir.c (__fchdir): Likewise.
+ * sysdeps/mach/hurd/fchmod.c (__fchmod): Likewise.
+ * sysdeps/mach/hurd/fchmodat.c (fchmodat): Likewise.
+ * sysdeps/mach/hurd/fchown.c (__fchown): Likewise.
+ * sysdeps/mach/hurd/fchownat.c (fchownat): Likewise.
+ * sysdeps/mach/hurd/flock.c (__flock): Likewise.
+ * sysdeps/mach/hurd/fsync.c (fsync): Likewise.
+ * sysdeps/mach/hurd/ftruncate.c (__ftruncate): Likewise.
+ * sysdeps/mach/hurd/getgroups.c (__getgroups): Likewise.
+ * sysdeps/mach/hurd/gethostname.c (__gethostname): Likewise.
+ * sysdeps/mach/hurd/getitimer.c (__getitimer): Likewise.
+ * sysdeps/mach/hurd/getlogin_r.c (__getlogin_r): Likewise.
+ * sysdeps/mach/hurd/getpgid.c (__getpgid): Likewise.
+ * sysdeps/mach/hurd/getrusage.c (__getrusage): Likewise.
+ * sysdeps/mach/hurd/getsockname.c (__getsockname): Likewise.
+ * sysdeps/mach/hurd/group_member.c (__group_member): Likewise.
+ * sysdeps/mach/hurd/isatty.c (__isatty): Likewise.
+ * sysdeps/mach/hurd/lchown.c (__lchown): Likewise.
+ * sysdeps/mach/hurd/link.c (__link): Likewise.
+ * sysdeps/mach/hurd/linkat.c (linkat): Likewise.
+ * sysdeps/mach/hurd/listen.c (__listen): Likewise.
+ * sysdeps/mach/hurd/mkdir.c (__mkdir): Likewise.
+ * sysdeps/mach/hurd/mkdirat.c (mkdirat): Likewise.
+ * sysdeps/mach/hurd/openat.c (__openat): Likewise.
+ * sysdeps/mach/hurd/poll.c (__poll): Likewise.
+ * sysdeps/mach/hurd/readlink.c (__readlink): Likewise.
+ * sysdeps/mach/hurd/readlinkat.c (readlinkat): Likewise.
+ * sysdeps/mach/hurd/recv.c (__recv): Likewise.
+ * sysdeps/mach/hurd/rename.c (rename): Likewise.
+ * sysdeps/mach/hurd/renameat.c (renameat): Likewise.
+ * sysdeps/mach/hurd/revoke.c (revoke): Likewise.
+ * sysdeps/mach/hurd/rewinddir.c (__rewinddir): Likewise.
+ * sysdeps/mach/hurd/rmdir.c (__rmdir): Likewise.
+ * sysdeps/mach/hurd/seekdir.c (seekdir): Likewise.
+ * sysdeps/mach/hurd/send.c (__send): Likewise.
+ * sysdeps/mach/hurd/setdomain.c (setdomainname): Likewise.
+ * sysdeps/mach/hurd/setegid.c (setegid): Likewise.
+ * sysdeps/mach/hurd/seteuid.c (seteuid): Likewise.
+ * sysdeps/mach/hurd/setgid.c (__setgid): Likewise.
+ * sysdeps/mach/hurd/setgroups.c (setgroups): Likewise.
+ * sysdeps/mach/hurd/sethostid.c (sethostid): Likewise.
+ * sysdeps/mach/hurd/sethostname.c (sethostname): Likewise.
+ * sysdeps/mach/hurd/setlogin.c (setlogin): Likewise.
+ * sysdeps/mach/hurd/setpgid.c (__setpgid): Likewise.
+ * sysdeps/mach/hurd/setregid.c (__setregid): Likewise.
+ * sysdeps/mach/hurd/setreuid.c (__setreuid): Likewise.
+ * sysdeps/mach/hurd/settimeofday.c (__settimeofday): Likewise.
+ * sysdeps/mach/hurd/setuid.c (__setuid): Likewise.
+ * sysdeps/mach/hurd/shutdown.c (shutdown): Likewise.
+ * sysdeps/mach/hurd/sigaction.c (__sigaction): Likewise.
+ * sysdeps/mach/hurd/sigaltstack.c (__sigaltstack): Likewise.
+ * sysdeps/mach/hurd/sigpending.c (sigpending): Likewise.
+ * sysdeps/mach/hurd/sigprocmask.c (__sigprocmask): Likewise.
+ * sysdeps/mach/hurd/sigsuspend.c (__sigsuspend): Likewise.
+ * sysdeps/mach/hurd/socket.c (__socket): Likewise.
+ * sysdeps/mach/hurd/symlink.c (__symlink): Likewise.
+ * sysdeps/mach/hurd/symlinkat.c (symlinkat): Likewise.
+ * sysdeps/mach/hurd/telldir.c (telldir): Likewise.
+ * sysdeps/mach/hurd/truncate.c (__truncate): Likewise.
+ * sysdeps/mach/hurd/umask.c (__umask): Likewise.
+ * sysdeps/mach/hurd/unlink.c (__unlink): Likewise.
+ * sysdeps/mach/hurd/unlinkat.c (unlinkat): Likewise.
+ * sysdeps/mips/mips64/__longjmp.c (__longjmp): Likewise.
+ * sysdeps/posix/alarm.c (alarm): Likewise.
+ * sysdeps/posix/cuserid.c (cuserid): Likewise.
+ * sysdeps/posix/dirfd.c (dirfd): Likewise.
+ * sysdeps/posix/dup.c (__dup): Likewise.
+ * sysdeps/posix/dup2.c (__dup2): Likewise.
+ * sysdeps/posix/euidaccess.c (euidaccess): Likewise.
+ (main): Likewise.
+ * sysdeps/posix/flock.c (__flock): Likewise.
+ * sysdeps/posix/fpathconf.c (__fpathconf): Likewise.
+ * sysdeps/posix/getcwd.c (__getcwd): Likewise.
+ * sysdeps/posix/gethostname.c (__gethostname): Likewise.
+ * sysdeps/posix/gettimeofday.c (__gettimeofday): Likewise.
+ * sysdeps/posix/isatty.c (__isatty): Likewise.
+ * sysdeps/posix/killpg.c (killpg): Likewise.
+ * sysdeps/posix/libc_fatal.c (__libc_fatal): Likewise.
+ * sysdeps/posix/mkfifoat.c (mkfifoat): Likewise.
+ * sysdeps/posix/raise.c (raise): Likewise.
+ * sysdeps/posix/remove.c (remove): Likewise.
+ * sysdeps/posix/rename.c (rename): Likewise.
+ * sysdeps/posix/rewinddir.c (__rewinddir): Likewise.
+ * sysdeps/posix/seekdir.c (seekdir): Likewise.
+ * sysdeps/posix/sigblock.c (__sigblock): Likewise.
+ * sysdeps/posix/sigignore.c (sigignore): Likewise.
+ * sysdeps/posix/sigintr.c (siginterrupt): Likewise.
+ * sysdeps/posix/signal.c (__bsd_signal): Likewise.
+ * sysdeps/posix/sigset.c (sigset): Likewise.
+ * sysdeps/posix/sigsuspend.c (__sigsuspend): Likewise.
+ * sysdeps/posix/sysconf.c (__sysconf): Likewise.
+ * sysdeps/posix/sysv_signal.c (__sysv_signal): Likewise.
+ * sysdeps/posix/time.c (time): Likewise.
+ * sysdeps/posix/ttyname.c (getttyname): Likewise.
+ (ttyname): Likewise.
+ * sysdeps/posix/ttyname_r.c (__ttyname_r): Likewise.
+ * sysdeps/posix/utime.c (utime): Likewise.
+ * sysdeps/powerpc/fpu/s_isnan.c (__isnan): Likewise.
+ * sysdeps/powerpc/nptl/pthread_spin_lock.c (pthread_spin_lock):
+ Likewise.
+ * sysdeps/powerpc/nptl/pthread_spin_trylock.c
+ (pthread_spin_trylock): Likewise.
+ * sysdeps/pthread/aio_error.c (aio_error): Likewise.
+ * sysdeps/pthread/aio_read.c (aio_read): Likewise.
+ * sysdeps/pthread/aio_read64.c (aio_read64): Likewise.
+ * sysdeps/pthread/aio_write.c (aio_write): Likewise.
+ * sysdeps/pthread/aio_write64.c (aio_write64): Likewise.
+ * sysdeps/pthread/flockfile.c (__flockfile): Likewise.
+ * sysdeps/pthread/ftrylockfile.c (__ftrylockfile): Likewise.
+ * sysdeps/pthread/funlockfile.c (__funlockfile): Likewise.
+ * sysdeps/pthread/timer_create.c (timer_create): Likewise.
+ * sysdeps/pthread/timer_getoverr.c (timer_getoverrun): Likewise.
+ * sysdeps/pthread/timer_gettime.c (timer_gettime): Likewise.
+ * sysdeps/s390/ffs.c (__ffs): Likewise.
+ * sysdeps/s390/nptl/pthread_spin_lock.c (pthread_spin_lock):
+ Likewise.
+ * sysdeps/s390/nptl/pthread_spin_trylock.c (pthread_spin_trylock):
+ Likewise.
+ * sysdeps/sh/nptl/pthread_spin_lock.c (pthread_spin_lock):
+ Likewise.
+ * sysdeps/sparc/nptl/pthread_barrier_destroy.c
+ (pthread_barrier_destroy): Likewise.
+ * sysdeps/sparc/nptl/pthread_barrier_wait.c
+ (__pthread_barrier_wait): Likewise.
+ * sysdeps/sparc/sparc32/e_sqrt.c (__ieee754_sqrt): Likewise.
+ * sysdeps/sparc/sparc32/pthread_barrier_wait.c
+ (__pthread_barrier_wait): Likewise.
+ * sysdeps/sparc/sparc32/sem_init.c (__old_sem_init): Likewise.
+ * sysdeps/tile/memcmp.c (memcmp_common_alignment): Likewise.
+ (memcmp_not_common_alignment): Likewise.
+ (MEMCMP): Likewise.
+ * sysdeps/tile/wordcopy.c (_wordcopy_fwd_aligned): Likewise.
+ (_wordcopy_fwd_dest_aligned): Likewise.
+ (_wordcopy_bwd_aligned): Likewise.
+ (_wordcopy_bwd_dest_aligned): Likewise.
+ * sysdeps/unix/bsd/ftime.c (ftime): Likewise.
+ * sysdeps/unix/bsd/gtty.c (gtty): Likewise.
+ * sysdeps/unix/bsd/stty.c (stty): Likewise.
+ * sysdeps/unix/bsd/tcflow.c (tcflow): Likewise.
+ * sysdeps/unix/bsd/tcflush.c (tcflush): Likewise.
+ * sysdeps/unix/bsd/tcgetattr.c (__tcgetattr): Likewise.
+ * sysdeps/unix/bsd/tcgetpgrp.c (tcgetpgrp): Likewise.
+ * sysdeps/unix/bsd/tcsendbrk.c (tcsendbreak): Likewise.
+ * sysdeps/unix/bsd/tcsetattr.c (tcsetattr): Likewise.
+ * sysdeps/unix/bsd/tcsetpgrp.c (tcsetpgrp): Likewise.
+ * sysdeps/unix/bsd/ualarm.c (ualarm): Likewise.
+ * sysdeps/unix/bsd/wait3.c (__wait3): Likewise.
+ * sysdeps/unix/getlogin_r.c (__getlogin_r): Likewise.
+ * sysdeps/unix/sockatmark.c (sockatmark): Likewise.
+ * sysdeps/unix/stime.c (stime): Likewise.
+ * sysdeps/unix/sysv/linux/_exit.c (_exit): Likewise.
+ * sysdeps/unix/sysv/linux/aio_sigqueue.c (__aio_sigqueue):
+ Likewise. Use internal_function.
+ * sysdeps/unix/sysv/linux/arm/sigaction.c (__libc_sigaction):
+ Convert to prototype-style function definition.
+ * sysdeps/unix/sysv/linux/faccessat.c (faccessat): Likewise.
+ * sysdeps/unix/sysv/linux/fchmodat.c (fchmodat): Likewise.
+ * sysdeps/unix/sysv/linux/fpathconf.c (__fpathconf): Likewise.
+ * sysdeps/unix/sysv/linux/gai_sigqueue.c (__gai_sigqueue):
+ Likewise. Use internal_function.
+ * sysdeps/unix/sysv/linux/gethostid.c (sethostid): Convert to
+ prototype-style function definition
+ * sysdeps/unix/sysv/linux/getlogin_r.c (__getlogin_r_loginuid):
+ Likewise.
+ (__getlogin_r): Likewise.
+ * sysdeps/unix/sysv/linux/getpt.c (__posix_openpt): Likewise.
+ * sysdeps/unix/sysv/linux/hppa/pthread_cond_broadcast.c
+ (__pthread_cond_broadcast): Likewise.
+ * sysdeps/unix/sysv/linux/hppa/pthread_cond_destroy.c
+ (__pthread_cond_destroy): Likewise.
+ * sysdeps/unix/sysv/linux/hppa/pthread_cond_init.c
+ (__pthread_cond_init): Likewise.
+ * sysdeps/unix/sysv/linux/hppa/pthread_cond_signal.c
+ (__pthread_cond_signal): Likewise.
+ * sysdeps/unix/sysv/linux/hppa/pthread_cond_wait.c
+ (__pthread_cond_wait): Likewise.
+ * sysdeps/unix/sysv/linux/i386/getmsg.c (getmsg): Likewise.
+ * sysdeps/unix/sysv/linux/i386/setegid.c (setegid): Likewise.
+ * sysdeps/unix/sysv/linux/ia64/sigaction.c (__libc_sigaction):
+ Likewise.
+ * sysdeps/unix/sysv/linux/ia64/sigpending.c (sigpending):
+ Likewise.
+ * sysdeps/unix/sysv/linux/ia64/sigprocmask.c (__sigprocmask):
+ Likewise.
+ * sysdeps/unix/sysv/linux/mips/sigaction.c (__libc_sigaction):
+ Likewise.
+ * sysdeps/unix/sysv/linux/msgget.c (msgget): Likewise.
+ * sysdeps/unix/sysv/linux/powerpc/powerpc32/ftruncate64.c
+ (__ftruncate64): Likewise.
+ * sysdeps/unix/sysv/linux/powerpc/powerpc32/truncate64.c
+ (truncate64): Likewise.
+ * sysdeps/unix/sysv/linux/pt-raise.c (raise): Likewise.
+ * sysdeps/unix/sysv/linux/pthread_getcpuclockid.c
+ (pthread_getcpuclockid): Likewise.
+ * sysdeps/unix/sysv/linux/pthread_getname.c (pthread_getname_np):
+ Likewise.
+ * sysdeps/unix/sysv/linux/pthread_setname.c (pthread_setname_np):
+ Likewise.
+ * sysdeps/unix/sysv/linux/pthread_sigmask.c (pthread_sigmask):
+ Likewise.
+ * sysdeps/unix/sysv/linux/pthread_sigqueue.c (pthread_sigqueue):
+ Likewise.
+ * sysdeps/unix/sysv/linux/raise.c (raise): Likewise.
+ * sysdeps/unix/sysv/linux/s390/s390-64/sigaction.c
+ (__libc_sigaction): Likewise.
+ * sysdeps/unix/sysv/linux/s390/s390-64/sigpending.c (sigpending):
+ Likewise.
+ * sysdeps/unix/sysv/linux/s390/s390-64/sigprocmask.c
+ (__sigprocmask): Likewise.
+ * sysdeps/unix/sysv/linux/semget.c (semget): Likewise.
+ * sysdeps/unix/sysv/linux/semop.c (semop): 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/sigaction.c (__libc_sigaction):
+ 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/sigstack.c (sigstack): Likewise.
+ * sysdeps/unix/sysv/linux/sparc/sparc64/sigpending.c (sigpending):
+ Likewise.
+ * sysdeps/unix/sysv/linux/sparc/sparc64/sigprocmask.c
+ (__sigprocmask): Likewise.
+ * sysdeps/unix/sysv/linux/speed.c (cfgetospeed): Likewise.
+ (cfgetispeed): Likewise.
+ (cfsetospeed): Likewise.
+ (cfsetispeed): Likewise.
+ * sysdeps/unix/sysv/linux/tcflow.c (tcflow): Likewise.
+ * sysdeps/unix/sysv/linux/tcflush.c (tcflush): Likewise.
+ * sysdeps/unix/sysv/linux/tcgetattr.c (__tcgetattr): Likewise.
+ * sysdeps/unix/sysv/linux/tcsetattr.c (tcsetattr): Likewise.
+ * sysdeps/unix/sysv/linux/time.c (time): Likewise.
+ * sysdeps/unix/sysv/linux/timer_create.c (timer_create): Likewise.
+ * sysdeps/unix/sysv/linux/timer_delete.c (timer_delete): 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/x86_64/sigpending.c (sigpending):
+ Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/sigprocmask.c (__sigprocmask):
+ Likewise.
+ * sysdeps/x86_64/backtrace.c (__backtrace): Likewise.
+
2015-10-17 Florian Weimer <fweimer@redhat.com>
sunrpc: Rewrite with explicit TLS access using __thread.
}
int
-__backtrace (array, size)
- void **array;
- int size;
+__backtrace (void **array, int size)
{
struct trace_arg arg = { .array = array, .size = size, .cnt = -1 };
int
-__backtrace (array, size)
- void **array;
- int size;
+__backtrace (void **array, int size)
{
struct trace_arg arg = { .array = array, .size = size, .cnt = -1 };
#ifdef __GNUC__
int
-__ffs (x)
- int x;
+__ffs (int x)
{
int cnt;
int tmp;
#ifdef __GNUC__
int
-__ffs (x)
- int x;
+__ffs (int x)
{
int cnt;
int tmp;
#include "pthreadP.h"
int
-pthread_spin_lock (lock)
- pthread_spinlock_t *lock;
+pthread_spin_lock (pthread_spinlock_t *lock)
{
int *p = (int *) lock;
#include "pthreadP.h"
int
-pthread_spin_trylock (lock)
- pthread_spinlock_t *lock;
+pthread_spin_trylock (pthread_spinlock_t *lock)
{
return __sync_val_compare_and_swap ((int *) lock, 0, 1) == 0 ? 0 : EBUSY;
}
long double
-__ieee754_log2l (x)
- long double x;
+__ieee754_log2l (long double x)
{
long double z;
long double y;
long double
-__ieee754_log2l (x)
- long double x;
+__ieee754_log2l (long double x)
{
long double z;
long double y;
#if defined (__GNUC__) && defined (__mc68020__)
int
-__ffs (x)
- int x;
+__ffs (int x)
{
int cnt;
#endif
float_type
-FUNC (x)
- float_type x;
+FUNC (float_type x)
{
return __m81_u(FUNC)(x);
}
#endif
float_type
-FUNC (x, y)
- float_type x;
- float_type y;
+FUNC (float_type x, float_type y)
{
return __m81_u(FUNC)(x, y);
}
of time adjustment remaining to be done from the last `__adjtime' call.
This call is restricted to the super-user. */
int
-__adjtime (delta, olddelta)
- const struct timeval *delta;
- struct timeval *olddelta;
+__adjtime (const struct timeval *delta, struct timeval *olddelta)
{
error_t err;
mach_port_t hostpriv;
putting it into *TV and *TZ. If TZ is NULL, *TZ is not filled.
Returns 0 on success, -1 on errors. */
int
-__gettimeofday (tv, tz)
- struct timeval *tv;
- struct timezone *tz;
+__gettimeofday (struct timeval *tv, struct timezone *tz)
{
kern_return_t err;
}
void
-_exit (status)
- int status;
+_exit (int status)
{
_hurd_exit (W_EXITCODE (status, 0));
}
/* Test for access to FILE by our real user and group IDs. */
int
-__access (file, type)
- const char *file;
- int type;
+__access (const char *file, int type)
{
error_t err;
file_t rcrdir, rcwdir, io;
of time adjustment remaining to be done from the last `__adjtime' call.
This call is restricted to the super-user. */
int
-__adjtime (delta, olddelta)
- const struct timeval *delta;
- struct timeval *olddelta;
+__adjtime (const struct timeval *delta, struct timeval *olddelta)
{
error_t err;
mach_port_t hostpriv;
/* Change the current directory to FILE_NAME. */
int
-__chdir (file_name)
- const char *file_name;
+__chdir (const char *file_name)
{
return _hurd_change_directory_port_from_name (&_hurd_ports[INIT_PORT_CWDIR],
file_name);
/* Change the protections of FILE to MODE. */
int
-__chmod (file, mode)
- const char *file;
- mode_t mode;
+__chmod (const char *file, mode_t mode)
{
error_t err;
file_t port = __file_name_lookup (file, 0, 0);
/* Change the owner and group of FILE. */
int
-__chown (file, owner, group)
- const char *file;
- uid_t owner;
- gid_t group;
+__chown (const char *file, uid_t owner, gid_t group)
{
error_t err;
file_t port = __file_name_lookup (file, 0, 0);
/* Placeholder for key creation routine from Hurd cthreads library. */
int
weak_function
-cthread_keycreate (key)
- cthread_key_t *key;
+cthread_keycreate (cthread_key_t *key)
{
__set_errno (ENOSYS);
*key = -1;
/* Placeholder for key retrieval routine from Hurd cthreads library. */
int
weak_function
-cthread_getspecific (key, pval)
- cthread_key_t key;
- void **pval;
+cthread_getspecific (cthread_key_t key, void **pval)
{
*pval = NULL;
__set_errno (ENOSYS);
/* Placeholder for key setting routine from Hurd cthreads library. */
int
weak_function
-cthread_setspecific (key, val)
- cthread_key_t key;
- void *val;
+cthread_setspecific (cthread_key_t key, void *val)
{
__set_errno (ENOSYS);
return -1;
/* Call cthread_getspecific which gets a pointer to the return value instead
of just returning it. */
void *
-__libc_getspecific (key)
- cthread_key_t key;
+__libc_getspecific (cthread_key_t key)
{
void *val;
cthread_getspecific (key, &val);
#include <hurd.h>
int
-__euidaccess (file, type)
- const char *file;
- int type;
+__euidaccess (const char *file, int type)
{
error_t err;
file_t port;
#include <hurd/fd.h>
int
-faccessat (fd, file, type, flag)
- int fd;
- const char *file;
- int type;
- int flag;
+faccessat (int fd, const char *file, int type, int flag)
{
error_t err;
file_t port;
/* Change the current directory to FD. */
int
-__fchdir (fd)
- int fd;
+__fchdir (int fd)
{
return _hurd_change_directory_port_from_fd (&_hurd_ports[INIT_PORT_CWDIR],
fd);
/* Change the permissions of the file referenced by FD to MODE. */
int
-__fchmod (fd, mode)
- int fd;
- mode_t mode;
+__fchmod (int fd, mode_t mode)
{
error_t err;
#include <hurd/fd.h>
int
-fchmodat (fd, file, mode, flag)
- int fd;
- const char *file;
- mode_t mode;
- int flag;
+fchmodat (int fd, const char *file, mode_t mode, int flag)
{
error_t err;
file_t port = __file_name_lookup_at (fd, flag, file, 0, 0);
/* Change the owner and group of the file referred to by FD. */
int
-__fchown (fd, owner, group)
- int fd;
- uid_t owner;
- gid_t group;
+__fchown (int fd, uid_t owner, gid_t group)
{
error_t err;
/* Change the owner and group of FILE. */
int
-fchownat (fd, file, owner, group, flag)
- int fd;
- const char *file;
- uid_t owner;
- gid_t group;
- int flag;
+fchownat (int fd, const char *file, uid_t owner, gid_t group, int flag)
{
error_t err;
file_t port = __file_name_lookup_at (fd, flag, file, 0, 0);
/* Apply or remove an advisory lock, according to OPERATION,
on the file FD refers to. */
int
-__flock (fd, operation)
- int fd;
- int operation;
+__flock (int fd, int operation)
{
error_t err;
/* Make all changes done to FD actually appear on disk. */
int
-fsync (fd)
- int fd;
+fsync (int fd)
{
error_t err = HURD_DPORT_USE (fd, __file_sync (port, 1, 0));
if (err)
/* Truncate the file referenced by FD to LENGTH bytes. */
int
-__ftruncate (fd, length)
- int fd;
- __off_t length;
+__ftruncate (int fd, __off_t length)
{
error_t err;
if (err = HURD_DPORT_USE (fd, __file_set_size (port, length)))
#include <string.h>
int
-__getgroups (n, gidset)
- int n;
- gid_t *gidset;
+__getgroups (int n, gid_t *gidset)
{
error_t err;
int ngids;
The result is null-terminated if LEN is large enough for the full
name and the terminator. */
int
-__gethostname (name, len)
- char *name;
- size_t len;
+__gethostname (char *name, size_t len)
{
/* The host name is just the contents of the file /etc/hostname. */
ssize_t n = _hurd_get_host_config ("/etc/hostname", name, len);
/* Set *VALUE to the current setting of timer WHICH.
Return 0 on success, -1 on errors. */
int
-__getitimer (which, value)
- enum __itimer_which which;
- struct itimerval *value;
+__getitimer (enum __itimer_which which, struct itimerval *value)
{
struct itimerval val;
struct timeval elapsed;
If it cannot be determined or some other error occurred, return the error
code. Otherwise return 0. */
int
-__getlogin_r (name, name_len)
- char *name;
- size_t name_len;
+__getlogin_r (char *name, size_t name_len)
{
string_t login;
error_t err;
/* Get the process group ID of process PID. */
int
-__getpgid (pid)
- pid_t pid;
+__getpgid (pid_t pid)
{
error_t err;
pid_t pgrp;
/* Return resource usage information on process indicated by WHO
and put it in *USAGE. Returns 0 for success, -1 for failure. */
int
-__getrusage (who, usage)
- enum __rusage_who who;
- struct rusage *usage;
+__getrusage (enum __rusage_who who, struct rusage *usage)
{
struct task_basic_info bi;
struct task_events_info ei;
/* Put the local address of FD into *ADDR and its length in *LEN. */
int
-__getsockname (fd, addrarg, len)
- int fd;
- __SOCKADDR_ARG addrarg;
- socklen_t *len;
+__getsockname (int fd, __SOCKADDR_ARG addrarg, socklen_t *len)
{
error_t err;
struct sockaddr *addr = addrarg.__sockaddr__;
#include <hurd/id.h>
int
-__group_member (gid)
- gid_t gid;
+__group_member (gid_t gid)
{
int member = 0;
error_t err;
/* Return 1 if FD is a terminal, 0 if not. */
int
-__isatty (fd)
- int fd;
+__isatty (int fd)
{
error_t err;
mach_port_t id;
/* Change the owner and group of FILE; if it's a link, do the link and
not the target. */
int
-__lchown (file, owner, group)
- const char *file;
- uid_t owner;
- gid_t group;
+__lchown (const char *file, uid_t owner, gid_t group)
{
error_t err;
file_t port = __file_name_lookup (file, O_NOLINK, 0);
/* Make a link to FROM called TO. */
int
-__link (from, to)
- const char *from;
- const char *to;
+__link (const char *from, const char *to)
{
error_t err;
file_t oldfile, linknode, todir;
/* Make a link to FROM relative to FROMFD called TO relative to TOFD. */
int
-linkat (fromfd, from, tofd, to, flags)
- int fromfd;
- const char *from;
- int tofd;
- const char *to;
- int flags;
+linkat (int fromfd, const char *from, int tofd, const char *to, int flags)
{
error_t err;
file_t oldfile, linknode, todir;
Returns 0 on success, -1 for errors. */
int
-__listen (fd, n)
- int fd;
- int n;
+__listen (int fd, int n)
{
error_t err = HURD_DPORT_USE (fd, __socket_listen (port, n));
if (err)
/* Create a directory named FILE_NAME with protections MODE. */
int
-__mkdir (file_name, mode)
- const char *file_name;
- mode_t mode;
+__mkdir (const char *file_name, mode_t mode)
{
error_t err;
const char *name;
#include <string.h>
int
-mkdirat (fd, path, mode)
- int fd;
- const char *path;
- mode_t mode;
+mkdirat (int fd, const char *path, mode_t mode)
{
error_t err;
const char *name;
the directory associated with FD. If O_CREAT or O_TMPFILE is in OFLAG, a
third argument is the file protection. */
int
-__openat (fd, file, oflag)
- int fd;
- const char *file;
- int oflag;
+__openat (int fd, const char *file, int oflag)
{
mode_t mode;
io_t port;
or -1 for errors. */
int
-__poll (fds, nfds, timeout)
- struct pollfd *fds;
- nfds_t nfds;
- int timeout;
+__poll (struct pollfd *fds, nfds_t nfds, int timeout)
{
struct timespec ts, *to;
LEN bytes of BUF. The contents are not null-terminated.
Returns the number of characters read, or -1 for errors. */
ssize_t
-__readlink (file_name, buf, len)
- const char *file_name;
- char *buf;
- size_t len;
+__readlink (const char *file_name, char *buf, size_t len)
{
error_t err;
file_t file;
than LEN bytes of BUF. The contents are not null-terminated.
Returns the number of characters read, or -1 for errors. */
ssize_t
-readlinkat (fd, file_name, buf, len)
- int fd;
- const char *file_name;
- char *buf;
- size_t len;
+readlinkat (int fd, const char *file_name, char *buf, size_t len)
{
error_t err;
file_t file;
Returns the number read or -1 for errors. */
ssize_t
-__recv (fd, buf, n, flags)
- int fd;
- void *buf;
- size_t n;
- int flags;
+__recv (int fd, void *buf, size_t n, int flags)
{
error_t err;
mach_port_t addrport;
/* Rename the file OLD to NEW. */
int
-rename (old, new)
- const char *old;
- const char *new;
+rename (const char *old, const char *new)
{
error_t err;
file_t olddir, newdir;
/* Rename the file OLD relative to OLDFD to NEW relative to NEWFD. */
int
-renameat (oldfd, old, newfd, new)
- int oldfd;
- const char *old;
- int newfd;
- const char *new;
+renameat (int oldfd, const char *old, int newfd, const char *new)
{
error_t err;
file_t olddir, newdir;
#include <hurd.h>
int
-revoke (file_name)
- const char *file_name;
+revoke (const char *file_name)
{
error_t err;
file_t file = __file_name_lookup (file_name, 0, 0);
/* Rewind DIRP to the beginning of the directory. */
void
-__rewinddir (dirp)
- DIR *dirp;
+__rewinddir (DIR *dirp)
{
seekdir (dirp, (off_t) 0L);
}
/* Remove the directory FILE_NAME. */
int
-__rmdir (file_name)
- const char *file_name;
+__rmdir (const char *file_name)
{
error_t err;
const char *name;
/* Seek to position POS in DIRP. */
/* XXX should be __seekdir ? */
void
-seekdir (dirp, pos)
- DIR *dirp;
- long int pos;
+seekdir (DIR *dirp, long int pos)
{
__libc_lock_lock (dirp->__lock);
/* Change our entry index pointer to POS and discard any data already
/* Send N bytes of BUF to socket FD. Returns the number sent or -1. */
ssize_t
-__send (fd, buf, n, flags)
- int fd;
- const void *buf;
- size_t n;
- int flags;
+__send (int fd, const void *buf, size_t n, int flags)
{
error_t err;
size_t wrote;
/* Set the name of the current YP domain to NAME, which is LEN bytes long.
This call is restricted to the super-user. */
int
-setdomainname (name, len)
- const char *name;
- size_t len;
+setdomainname (const char *name, size_t len)
{
/* The NIS domain name is just the contents of the file /etc/nisdomain. */
ssize_t n = _hurd_set_host_config ("/etc/nisdomain", name, len);
/* Set the effective user ID of the calling process to GID. */
int
-setegid (gid)
- gid_t gid;
+setegid (gid_t gid)
{
auth_t newauth;
error_t err;
/* Set the effective user ID of the calling process to UID. */
int
-seteuid (uid)
- uid_t uid;
+seteuid (uid_t uid)
{
auth_t newauth;
error_t err;
and effective group IDs, and the saved set-group-ID to UID;
if not, the effective group ID is set to GID. */
int
-__setgid (gid)
- gid_t gid;
+__setgid (gid_t gid)
{
auth_t newauth;
error_t err;
/* Set the group set for the current user to GROUPS (N of them). */
int
-setgroups (n, groups)
- size_t n;
- const gid_t *groups;
+setgroups (size_t n, const gid_t *groups)
{
error_t err;
auth_t newauth;
/* XXX should be __sethostid?
isn't hostid supposed to be hardwired and unchangeable? */
int
-sethostid (id)
- long int id;
+sethostid (long int id)
{
char buf[8], *bp;
ssize_t n;
This call is restricted to the super-user. */
/* XXX should be __sethostname ? */
int
-sethostname (name, len)
- const char *name;
- size_t len;
+sethostname (const char *name, size_t len)
{
/* The host name is just the contents of the file /etc/hostname. */
ssize_t n = _hurd_set_host_config ("/etc/hostname", name, len);
/* Set the login name returned by `getlogin'. */
int
-setlogin (name)
- const char *name;
+setlogin (const char *name)
{
error_t err;
if (err = __USEPORT (PROC, __proc_setlogin (port, name)))
If PID is zero, the current process's process group ID is set.
If PGID is zero, the process ID of the process is used. */
int
-__setpgid (pid, pgid)
- pid_t pid;
- pid_t pgid;
+__setpgid (pid_t pid, pid_t pgid)
{
error_t err;
unsigned int stamp;
#include <string.h>
int
-__setregid (rgid, egid)
- gid_t rgid;
- gid_t egid;
+__setregid (gid_t rgid, gid_t egid)
{
auth_t newauth;
error_t err;
#include <string.h>
int
-__setreuid (ruid, euid)
- uid_t ruid;
- uid_t euid;
+__setreuid (uid_t ruid, uid_t euid)
{
auth_t newauth;
error_t err;
/* Set the current time of day and timezone information.
This call is restricted to the super-user. */
int
-__settimeofday (tv, tz)
- const struct timeval *tv;
- const struct timezone *tz;
+__settimeofday (const struct timeval *tv, const struct timezone *tz)
{
error_t err;
mach_port_t hostpriv;
and effective user IDs, and the saved set-user-ID to UID;
if not, the effective user ID is set to UID. */
int
-__setuid (uid)
- uid_t uid;
+__setuid (uid_t uid)
{
auth_t newauth;
error_t err;
Returns 0 on success, -1 for errors. */
/* XXX should be __shutdown ? */
int
-shutdown (fd, how)
- int fd;
- int how;
+shutdown (int fd, int how)
{
error_t err = HURD_DPORT_USE (fd, __socket_shutdown (port, how));
if (err)
/* If ACT is not NULL, change the action for SIG to *ACT.
If OACT is not NULL, put the old action for SIG in *OACT. */
int
-__sigaction (sig, act, oact)
- int sig;
- const struct sigaction *act;
- struct sigaction *oact;
+__sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
{
struct hurd_sigstate *ss;
struct sigaction a, old;
/* Run signals handlers on the stack specified by SS (if not NULL).
If OSS is not NULL, it is filled in with the old signal stack status. */
int
-__sigaltstack (argss, oss)
- const struct sigaltstack *argss;
- struct sigaltstack *oss;
+__sigaltstack (const struct sigaltstack *argss, struct sigaltstack *oss)
{
struct hurd_sigstate *s;
struct sigaltstack ss, old;
/* Store in SET all signals that are blocked and pending. */
/* XXX should be __sigpending ? */
int
-sigpending (set)
- sigset_t *set;
+sigpending (sigset_t *set)
{
struct hurd_sigstate *ss;
sigset_t pending;
according to HOW, which may be SIG_BLOCK, SIG_UNBLOCK or SIG_SETMASK.
If OSET is not NULL, store the old set of blocked signals in *OSET. */
int
-__sigprocmask (how, set, oset)
- int how;
- const sigset_t *set;
- sigset_t *oset;
+__sigprocmask (int how, const sigset_t *set, sigset_t *oset)
{
struct hurd_sigstate *ss;
sigset_t old, new;
/* Change the set of blocked signals to SET,
wait until a signal arrives, and restore the set of blocked signals. */
int
-__sigsuspend (set)
- const sigset_t *set;
+__sigsuspend (const sigset_t *set)
{
struct hurd_sigstate *ss;
sigset_t newmask, oldmask, pending;
protocol PROTOCOL. If PROTOCOL is zero, one is chosen automatically.
Returns a file descriptor for the new socket, or -1 for errors. */
int
-__socket (domain, type, protocol)
- int domain;
- int type;
- int protocol;
+__socket (int domain, int type, int protocol)
{
error_t err;
socket_t sock, server;
/* Make a link to FROM called TO. */
int
-__symlink (from, to)
- const char *from;
- const char *to;
+__symlink (const char *from, const char *to)
{
error_t err;
file_t dir, node;
/* Make a link to FROM called TO relative to FD. */
int
-symlinkat (from, fd, to)
- const char *from;
- int fd;
- const char *to;
+symlinkat (const char *from, int fd, const char *to)
{
error_t err;
file_t dir, node;
/* Return the current position of DIRP. */
/* XXX should be __telldir ? */
long int
-telldir (dirp)
- DIR *dirp;
+telldir (DIR *dirp)
{
return dirp->__entry_ptr;
}
/* Truncate FILE_NAME to LENGTH bytes. */
int
-__truncate (file_name, length)
- const char *file_name;
- off_t length;
+__truncate (const char *file_name, off_t length)
{
error_t err;
file_t file = __file_name_lookup (file_name, O_WRITE, 0);
/* Set the file creation mask to MASK, returning the old mask. */
mode_t
-__umask (mask)
- mode_t mask;
+__umask (mode_t mask)
{
mode_t omask;
mask &= 0777;
/* Remove the link named NAME. */
int
-__unlink (name)
- const char *name;
+__unlink (const char *name)
{
error_t err;
file_t dir;
/* Remove the link named NAME. */
int
-unlinkat (fd, name, flag)
- int fd;
- const char *name;
- int flag;
+unlinkat (int fd, const char *name, int flag)
{
error_t err;
file_t dir;
#endif
void
-__longjmp (env_arg, val_arg)
- __jmp_buf env_arg;
- int val_arg;
+__longjmp (__jmp_buf env_arg, int val_arg)
{
/* gcc 1.39.19 miscompiled the longjmp routine (as it did setjmp before
the hack around it); force it to use $a1 for the longjmp value.
to 0 and check its value after calling `alarm', and this might tell you.
The signal may come late due to processor scheduling. */
unsigned int
-alarm (seconds)
- unsigned int seconds;
+alarm (unsigned int seconds)
{
struct itimerval old, new;
unsigned int retval;
If S is not NULL, it points to a buffer of at least L_cuserid bytes
into which the name is copied; otherwise, a static buffer is used. */
char *
-cuserid (s)
- char *s;
+cuserid (char *s)
{
static char name[L_cuserid];
char buf[NSS_BUFLEN_PASSWD];
#undef dirfd
int
-dirfd (dirp)
- DIR *dirp;
+dirfd (DIR *dirp)
{
return dirp->fd;
}
/* Duplicate FD, returning a new file descriptor open on the same file. */
int
-__dup (fd)
- int fd;
+__dup (int fd)
{
return fcntl (fd, F_DUPFD, 0);
}
/* Duplicate FD to FD2, closing the old FD2 and making FD2 be
open the same file as FD is. Return FD2 or -1. */
int
-__dup2 (fd, fd2)
- int fd;
- int fd2;
+__dup2 (int fd, int fd2)
{
int save;
filesystem, text busy, etc. */
int
-euidaccess (path, mode)
- const char *path;
- int mode;
+euidaccess (const char *path, int mode)
{
struct stat64 stats;
int granted;
char *program_name;
int
-main (argc, argv)
- int argc;
- char **argv;
+main (int argc, char **argv)
{
char *file;
int mode;
/* Apply or remove an advisory lock, according to OPERATION,
on the file FD refers to. */
int
-__flock (fd, operation)
- int fd;
- int operation;
+__flock (int fd, int operation)
{
struct flock lbuf;
/* Get file-specific information about descriptor FD. */
long int
-__fpathconf (fd, name)
- int fd;
- int name;
+__fpathconf (int fd, int name)
{
if (fd < 0)
{
unless SIZE == 0, in which case it is as big as necessary. */
GETCWD_RETURN_TYPE
-__getcwd (buf, size)
- char *buf;
- size_t size;
+__getcwd (char *buf, size_t size)
{
#ifndef __ASSUME_ATFCTS
static const char dots[]
The result is null-terminated if LEN is large enough for the full
name and the terminator. */
int
-__gethostname (name, len)
- char *name;
- size_t len;
+__gethostname (char *name, size_t len)
{
struct utsname buf;
size_t node_len;
putting it into *TV and *TZ. If TZ is NULL, *TZ is not filled.
Returns 0 on success, -1 on errors. */
int
-__gettimeofday (tv, tz)
- struct timeval *tv;
- struct timezone *tz;
+__gettimeofday (struct timeval *tv, struct timezone *tz)
{
if (tv == NULL)
{
/* Return 1 if FD is a terminal, 0 if not. */
int
-__isatty (fd)
- int fd;
+__isatty (int fd)
{
struct termios term;
If PGRP is zero, send SIG to all processes in
the current process's process group. */
int
-killpg (pgrp, sig)
- __pid_t pgrp;
- int sig;
+killpg (__pid_t pgrp, int sig)
{
if (pgrp < 0)
{
void
-__libc_fatal (message)
- const char *message;
+__libc_fatal (const char *message)
{
/* The loop is added only to keep gcc happy. */
while (1)
/* Create a new FIFO with permission bits MODE. But interpret
relative PATH names relative to the directory associated with FD. */
int
-mkfifoat (fd, file, mode)
- int fd;
- const char *file;
- mode_t mode;
+mkfifoat (int fd, const char *file, mode_t mode)
{
dev_t dev = 0;
return __xmknodat (_MKNOD_VER, fd, file, mode | S_IFIFO, &dev);
/* Raise the signal SIG. */
int
-raise (sig)
- int sig;
+raise (int sig)
{
return __kill (__getpid (), sig);
}
int
-remove (file)
- const char *file;
+remove (const char *file)
{
/* First try to unlink since this is more frequently the necessary action. */
if (__unlink (file) != 0
/* Rename the file OLD to NEW. */
int
-rename (old, new)
- const char *old;
- const char *new;
+rename (const char *old, const char *new)
{
int save = errno;
if (__link (old, new) < 0)
/* Rewind DIRP to the beginning of the directory. */
void
-__rewinddir (dirp)
- DIR *dirp;
+__rewinddir (DIR *dirp)
{
#if IS_IN (libc)
__libc_lock_lock (dirp->lock);
/* Seek to position POS in DIRP. */
/* XXX should be __seekdir ? */
void
-seekdir (dirp, pos)
- DIR *dirp;
- long int pos;
+seekdir (DIR *dirp, long int pos)
{
__libc_lock_lock (dirp->lock);
(void) __lseek (dirp->fd, pos, SEEK_SET);
/* Block signals in MASK, returning the old mask. */
int
-__sigblock (mask)
- int mask;
+__sigblock (int mask)
{
sigset_t set, oset;
int
-sigignore (sig)
- int sig;
+sigignore (int sig)
{
struct sigaction act;
(causing them to fail with EINTR); if INTERRUPT is zero, make system
calls be restarted after signal SIG. */
int
-siginterrupt (sig, interrupt)
- int sig;
- int interrupt;
+siginterrupt (int sig, int interrupt)
{
#ifdef SA_RESTART
extern sigset_t _sigintr attribute_hidden; /* Defined in signal.c. */
/* Set the handler for the signal SIG to HANDLER,
returning the old handler, or SIG_ERR on error. */
__sighandler_t
-__bsd_signal (sig, handler)
- int sig;
- __sighandler_t handler;
+__bsd_signal (int sig, __sighandler_t handler)
{
struct sigaction act, oact;
/* Set the disposition for SIG. */
__sighandler_t
-sigset (sig, disp)
- int sig;
- __sighandler_t disp;
+sigset (int sig, __sighandler_t disp)
{
struct sigaction act;
struct sigaction oact;
/* Change the set of blocked signals to SET,
wait until a signal arrives, and restore the set of blocked signals. */
int
-__sigsuspend (set)
- const sigset_t *set;
+__sigsuspend (const sigset_t *set)
{
sigset_t oset;
int save;
/* Get the value of the system variable NAME. */
long int
-__sysconf (name)
- int name;
+__sysconf (int name)
{
switch (name)
{
/* Set the handler for the signal SIG to HANDLER,
returning the old handler, or SIG_ERR on error. */
__sighandler_t
-__sysv_signal (sig, handler)
- int sig;
- __sighandler_t handler;
+__sysv_signal (int sig, __sighandler_t handler)
{
struct sigaction act, oact;
/* Return the current time as a `time_t' and also put it in *T if T is
not NULL. Time is represented as seconds from Jan 1 00:00:00 1970. */
time_t
-time (t)
- time_t *t;
+time (time_t *t)
{
struct timeval tv;
time_t result;
static char *
internal_function
-getttyname (fd, mydev, myino, save, dostat)
- int fd;
- dev_t mydev;
- ino_t myino;
- int save;
- int *dostat;
+getttyname (int fd, dev_t mydev, ino_t myino, int save, int *dostat)
{
static const char dev[] = "/dev";
static size_t namelen;
/* Return the pathname of the terminal FD is open on, or NULL on errors.
The returned storage is good only until the next call to this function. */
char *
-ttyname (fd)
- int fd;
+ttyname (int fd)
{
struct stat st;
int dostat = 0;
/* Store at most BUFLEN character of the pathname of the terminal FD is
open on in BUF. Return 0 on success, otherwise an error number. */
int
-__ttyname_r (fd, buf, buflen)
- int fd;
- char *buf;
- size_t buflen;
+__ttyname_r (int fd, char *buf, size_t buflen)
{
struct stat st;
int dostat = 0;
/* Set the access and modification times of FILE to those given in TIMES.
If TIMES is NULL, set them to the current time. */
int
-utime (file, times)
- const char *file;
- const struct utimbuf *times;
+utime (const char *file, const struct utimbuf *times)
{
struct timeval timevals[2];
struct timeval *tvp;
int
-__isnan (x)
- double x;
+__isnan (double x)
{
fenv_t savedstate;
int result;
#include "pthreadP.h"
int
-pthread_spin_lock (lock)
- pthread_spinlock_t *lock;
+pthread_spin_lock (pthread_spinlock_t *lock)
{
unsigned int __tmp;
#include "pthreadP.h"
int
-pthread_spin_trylock (lock)
- pthread_spinlock_t *lock;
+pthread_spin_trylock (pthread_spinlock_t *lock)
{
unsigned int old;
int err = EBUSY;
int
-aio_error (aiocbp)
- const struct aiocb *aiocbp;
+aio_error (const struct aiocb *aiocbp)
{
int ret;
int
-aio_read (aiocbp)
- struct aiocb *aiocbp;
+aio_read (struct aiocb *aiocbp)
{
return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_READ) == NULL
? -1 : 0);
int
-aio_read64 (aiocbp)
- struct aiocb64 *aiocbp;
+aio_read64 (struct aiocb64 *aiocbp)
{
return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_READ64) == NULL
? -1 : 0);
int
-aio_write (aiocbp)
- struct aiocb *aiocbp;
+aio_write (struct aiocb *aiocbp)
{
return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_WRITE) == NULL
? -1 : 0);
int
-aio_write64 (aiocbp)
- struct aiocb64 *aiocbp;
+aio_write64 (struct aiocb64 *aiocbp)
{
return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_WRITE64) == NULL
? -1 : 0);
void
-__flockfile (stream)
- FILE *stream;
+__flockfile (FILE *stream)
{
_IO_lock_lock (*stream->_lock);
}
int
-__ftrylockfile (stream)
- FILE *stream;
+__ftrylockfile (FILE *stream)
{
return _IO_lock_trylock (*stream->_lock);
}
void
-__funlockfile (stream)
- FILE *stream;
+__funlockfile (FILE *stream)
{
_IO_lock_unlock (*stream->_lock);
}
/* Create new per-process timer using CLOCK. */
int
-timer_create (clock_id, evp, timerid)
- clockid_t clock_id;
- struct sigevent *evp;
- timer_t *timerid;
+timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid)
{
int retval = -1;
struct timer_node *newtimer = NULL;
/* Get expiration overrun for timer TIMERID. */
int
-timer_getoverrun (timerid)
- timer_t timerid;
+timer_getoverrun (timer_t timerid)
{
struct timer_node *timer;
int retval = -1;
/* Get current value of timer TIMERID and store it in VLAUE. */
int
-timer_gettime (timerid, value)
- timer_t timerid;
- struct itimerspec *value;
+timer_gettime (timer_t timerid, struct itimerspec *value)
{
struct timer_node *timer;
struct timespec now, expiry;
differs in spirit from the above ffz (man ffs). */
int
-__ffs (x)
- int x;
+__ffs (int x)
{
int r;
#include "pthreadP.h"
int
-pthread_spin_lock (lock)
- pthread_spinlock_t *lock;
+pthread_spin_lock (pthread_spinlock_t *lock)
{
int oldval;
#include "pthreadP.h"
int
-pthread_spin_trylock (lock)
- pthread_spinlock_t *lock;
+pthread_spin_trylock (pthread_spinlock_t *lock)
{
int old;
#include "pthreadP.h"
int
-pthread_spin_lock (lock)
- pthread_spinlock_t *lock;
+pthread_spin_lock (pthread_spinlock_t *lock)
{
unsigned int val;
#include <sparc-nptl.h>
int
-pthread_barrier_destroy (barrier)
- pthread_barrier_t *barrier;
+pthread_barrier_destroy (pthread_barrier_t *barrier)
{
union sparc_pthread_barrier *ibarrier;
int result = EBUSY;
/* Wait on barrier. */
int
-__pthread_barrier_wait (barrier)
- pthread_barrier_t *barrier;
+__pthread_barrier_wait (pthread_barrier_t *barrier)
{
union sparc_pthread_barrier *ibarrier
= (union sparc_pthread_barrier *) barrier;
/* Return the square root of X. */
double
-__ieee754_sqrt (x)
- double x;
+__ieee754_sqrt (double x)
{
register double result;
asm ("fsqrtd %1, %0" : "=f" (result) : "f" (x));
/* Wait on barrier. */
int
-__pthread_barrier_wait (barrier)
- pthread_barrier_t *barrier;
+__pthread_barrier_wait (pthread_barrier_t *barrier)
{
union sparc_pthread_barrier *ibarrier
= (union sparc_pthread_barrier *) barrier;
#if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
int
attribute_compat_text_section
-__old_sem_init (sem, pshared, value)
- sem_t *sem;
- int pshared;
- unsigned int value;
+__old_sem_init (sem_t *sem, int pshared, unsigned int value)
{
/* Parameter sanity check. */
if (__glibc_unlikely (value > SEM_VALUE_MAX))
objects (not LEN bytes!). Both SRCP1 and SRCP2 should be aligned for
memory operations on `op_t's. */
static int
-memcmp_common_alignment (srcp1, srcp2, len)
- long int srcp1;
- long int srcp2;
- size_t len;
+memcmp_common_alignment (long int srcp1, long int srcp2, size_t len)
{
op_t a0, a1;
op_t b0, b1;
`op_t' objects (not LEN bytes!). SRCP2 should be aligned for memory
operations on `op_t', but SRCP1 *should be unaligned*. */
static int
-memcmp_not_common_alignment (srcp1, srcp2, len)
- long int srcp1;
- long int srcp2;
- size_t len;
+memcmp_not_common_alignment (long int srcp1, long int srcp2, size_t len)
{
void * srcp1i;
op_t a0, a1, a2, a3;
}
int
-MEMCMP (s1, s2, len)
- const __ptr_t s1;
- const __ptr_t s2;
- size_t len;
+MEMCMP (const __ptr_t s1, const __ptr_t s2, size_t len)
{
op_t a0;
op_t b0;
Both SRCP and DSTP should be aligned for memory operations on `op_t's. */
void
-_wordcopy_fwd_aligned (dstp, srcp, len)
- long int dstp;
- long int srcp;
- size_t len;
+_wordcopy_fwd_aligned (long int dstp, long int srcp, size_t len)
{
op_t a0, a1;
*not* be aligned. */
void
-_wordcopy_fwd_dest_aligned (dstp, srcp, len)
- long int dstp;
- long int srcp;
- size_t len;
+_wordcopy_fwd_dest_aligned (long int dstp, long int srcp, size_t len)
{
void * srci;
op_t a0, a1, a2, a3;
operations on `op_t's. */
void
-_wordcopy_bwd_aligned (dstp, srcp, len)
- long int dstp;
- long int srcp;
- size_t len;
+_wordcopy_bwd_aligned (long int dstp, long int srcp, size_t len)
{
op_t a0, a1;
long int srcp1;
operations on `op_t', but SRCP must *not* be aligned. */
void
-_wordcopy_bwd_dest_aligned (dstp, srcp, len)
- long int dstp;
- long int srcp;
- size_t len;
+_wordcopy_bwd_dest_aligned (long int dstp, long int srcp, size_t len)
{
void * srci;
op_t a0, a1, a2, a3;
#include <sys/time.h>
int
-ftime (timebuf)
- struct timeb *timebuf;
+ftime (struct timeb *timebuf)
{
struct timeval tv;
struct timezone tz;
/* Fill in *PARAMS with terminal parameters associated with FD. */
int
-gtty (fd, params)
- int fd;
- struct sgttyb *params;
+gtty (int fd, struct sgttyb *params)
{
return ioctl (fd, TIOCGETP, (void *) params);
}
/* Set the terminal parameters associated with FD to *PARAMS. */
int
-stty (fd, params)
- int fd;
- const struct sgttyb *params;
+stty (int fd, const struct sgttyb *params)
{
return ioctl (fd, TIOCSETP, (void *) params);
}
/* Suspend or restart transmission on FD. */
int
-tcflow (fd, action)
- int fd;
- int action;
+tcflow (int fd, int action)
{
switch (action)
{
/* Flush pending data on FD. */
int
-tcflush (fd, queue_selector)
- int fd;
- int queue_selector;
+tcflush (int fd, int queue_selector)
{
int arg;
/* Put the state of FD into *TERMIOS_P. */
int
-__tcgetattr (fd, termios_p)
- int fd;
- struct termios *termios_p;
+__tcgetattr (int fd, struct termios *termios_p)
{
return __ioctl (fd, TIOCGETA, termios_p);
}
/* Return the foreground process group ID of FD. */
pid_t
-tcgetpgrp (fd)
- int fd;
+tcgetpgrp (int fd)
{
int pgrp;
/* Send zero bits on FD. */
int
-tcsendbreak (fd, duration)
- int fd;
- int duration;
+tcsendbreak (int fd, int duration)
{
struct timeval delay;
/* Set the state of FD to *TERMIOS_P. */
int
-tcsetattr (fd, optional_actions, termios_p)
- int fd;
- int optional_actions;
- const struct termios *termios_p;
+tcsetattr (int fd, int optional_actions, const struct termios *termios_p)
{
struct termios myt;
/* Set the foreground process group ID of FD set PGRP_ID. */
int
-tcsetpgrp (fd, pgrp_id)
- int fd;
- pid_t pgrp_id;
+tcsetpgrp (int fd, pid_t pgrp_id)
{
return __ioctl (fd, TIOCSPGRP, &pgrp_id);
}
Returns the number of microseconds remaining before the alarm. */
useconds_t
-ualarm (value, interval)
- useconds_t value;
- useconds_t interval;
+ualarm (useconds_t value, useconds_t interval)
{
struct itimerval timer, otimer;
there. If the WUNTRACED bit is set in OPTIONS, return status for stopped
children; otherwise don't. */
pid_t
-__wait3 (stat_loc, options, usage)
- __WAIT_STATUS stat_loc;
- int options;
- struct rusage *usage;
+__wait3 (__WAIT_STATUS stat_loc, int options, struct rusage *usage)
{
return __wait4 (WAIT_ANY, stat_loc, options, usage);
}
STATIC
#endif
int
-__getlogin_r (name, name_len)
- char *name;
- size_t name_len;
+__getlogin_r (char *name, size_t name_len)
{
char tty_pathname[2 + 2 * NAME_MAX];
char *real_tty_path = tty_pathname;
/* Determine wheter socket is at a out-of-band mark. */
int
-sockatmark (fd)
- int fd;
+sockatmark (int fd)
{
int answ;
/* Set the system clock to *WHEN. */
int
-stime (when)
- const time_t *when;
+stime (const time_t *when)
{
struct timeval tv;
void
-_exit (status)
- int status;
+_exit (int status)
{
while (1)
{
/* Return any pending signal or wait for one for the given time. */
int
-__aio_sigqueue (sig, val, caller_pid)
- int sig;
- const union sigval val;
- pid_t caller_pid;
+internal_function
+__aio_sigqueue (int sig, const union sigval val, pid_t caller_pid)
{
siginfo_t info;
/* If ACT is not NULL, change the action for SIG to *ACT.
If OACT is not NULL, put the old action for SIG in *OACT. */
int
-__libc_sigaction (sig, act, oact)
- int sig;
- const struct sigaction *act;
- struct sigaction *oact;
+__libc_sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
{
int result;
int
-faccessat (fd, file, mode, flag)
- int fd;
- const char *file;
- int mode;
- int flag;
+faccessat (int fd, const char *file, int mode, int flag)
{
if (flag & ~(AT_SYMLINK_NOFOLLOW | AT_EACCESS))
return INLINE_SYSCALL_ERROR_RETURN_VALUE (EINVAL);
#include <sysdep.h>
int
-fchmodat (fd, file, mode, flag)
- int fd;
- const char *file;
- mode_t mode;
- int flag;
+fchmodat (int fd, const char *file, mode_t mode, int flag)
{
if (flag & ~AT_SYMLINK_NOFOLLOW)
return INLINE_SYSCALL_ERROR_RETURN_VALUE (EINVAL);
/* Get file-specific information about descriptor FD. */
long int
-__fpathconf (fd, name)
- int fd;
- int name;
+__fpathconf (int fd, int name)
{
struct statfs fsbuf;
/* Return any pending signal or wait for one for the given time. */
int
-__gai_sigqueue (sig, val, caller_pid)
- int sig;
- const union sigval val;
- pid_t caller_pid;
+internal_function
+__gai_sigqueue (int sig, const union sigval val, pid_t caller_pid)
{
siginfo_t info;
#ifdef SET_PROCEDURE
int
-sethostid (id)
- long int id;
+sethostid (long int id)
{
int fd;
ssize_t written;
int
attribute_hidden
-__getlogin_r_loginuid (name, namesize)
- char *name;
- size_t namesize;
+__getlogin_r_loginuid (char *name, size_t namesize)
{
int fd = open_not_cancel_2 ("/proc/self/loginuid", O_RDONLY);
if (fd == -1)
code. Otherwise return 0. */
int
-__getlogin_r (name, namesize)
- char *name;
- size_t namesize;
+__getlogin_r (char *name, size_t namesize)
{
int res = __getlogin_r_loginuid (name, namesize);
if (res >= 0)
/* Open a master pseudo terminal and return its file descriptor. */
int
-__posix_openpt (oflag)
- int oflag;
+__posix_openpt (int oflag)
{
static int have_no_dev_ptmx;
int fd;
# include <internaltypes.h>
# include <shlib-compat.h>
int
-__pthread_cond_broadcast (cond)
- pthread_cond_t *cond;
+__pthread_cond_broadcast (pthread_cond_t *cond)
{
cond_compat_check_and_clear (cond);
return __pthread_cond_broadcast_internal (cond);
# include <internaltypes.h>
# include <shlib-compat.h>
int
-__pthread_cond_destroy (cond)
- pthread_cond_t *cond;
+__pthread_cond_destroy (pthread_cond_t *cond)
{
cond_compat_check_and_clear (cond);
return __pthread_cond_destroy_internal (cond);
# include <internaltypes.h>
# include <shlib-compat.h>
int
-__pthread_cond_init (cond, cond_attr)
- pthread_cond_t *cond;
- const pthread_condattr_t *cond_attr;
+__pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
{
cond_compat_clear (cond);
return __pthread_cond_init_internal (cond, cond_attr);
# include <internaltypes.h>
# include <shlib-compat.h>
int
-__pthread_cond_signal (cond)
- pthread_cond_t *cond;
+__pthread_cond_signal (pthread_cond_t *cond)
{
cond_compat_check_and_clear (cond);
return __pthread_cond_signal_internal (cond);
# include <internaltypes.h>
# include <shlib-compat.h>
int
-__pthread_cond_wait (cond, mutex)
- pthread_cond_t *cond;
- pthread_mutex_t *mutex;
+__pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)
{
cond_compat_check_and_clear (cond);
return __pthread_cond_wait_internal (cond, mutex);
#ifdef __NR_getpmsg
int
-getmsg (fildes, ctlptr, dataptr, flagsp)
- int fildes;
- struct strbuf *ctlptr;
- struct strbuf *dataptr;
- int *flagsp;
+getmsg (int fildes, struct strbuf *ctlptr, struct strbuf *dataptr, int *flagsp)
{
return INLINE_SYSCALL (getpmsg, 5, fildes, ctlptr, dataptr, NULL, flagsp);
}
int
-setegid (gid)
- gid_t gid;
+setegid (gid_t gid)
{
int result;
/* If ACT is not NULL, change the action for SIG to *ACT.
If OACT is not NULL, put the old action for SIG in *OACT. */
int
-__libc_sigaction (sig, act, oact)
- int sig;
- const struct sigaction *act;
- struct sigaction *oact;
+__libc_sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
{
/* XXX The size argument hopefully will have to be changed to the
real size of the user-level sigset_t. */
/* Change the set of blocked signals to SET,
wait until a signal arrives, and restore the set of blocked signals. */
int
-sigpending (set)
- sigset_t *set;
+sigpending (sigset_t *set)
{
/* XXX The size argument hopefully will have to be changed to the
real size of the user-level sigset_t. */
/* Get and/or change the set of blocked signals. */
int
-__sigprocmask (how, set, oset)
- int how;
- const sigset_t *set;
- sigset_t *oset;
+__sigprocmask (int how, const sigset_t *set, sigset_t *oset)
{
/* XXX The size argument hopefully will have to be changed to the
/* If ACT is not NULL, change the action for SIG to *ACT.
If OACT is not NULL, put the old action for SIG in *OACT. */
int
-__libc_sigaction (sig, act, oact)
- int sig;
- const struct sigaction *act;
- struct sigaction *oact;
+__libc_sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
{
int result;
parameter describes how to proceed with clashing of key values. */
int
-msgget (key, msgflg)
- key_t key;
- int msgflg;
+msgget (key_t key, int msgflg)
{
return INLINE_SYSCALL (ipc, 5, IPCOP_msgget, key, msgflg, 0, NULL);
}
/* Truncate the file referenced by FD to LENGTH bytes. */
int
-__ftruncate64 (fd, length)
- int fd;
- off64_t length;
+__ftruncate64 (int fd, off64_t length)
{
/* On PPC32 64bit values are aligned in odd/even register pairs. */
int result = INLINE_SYSCALL (ftruncate64, 4, fd, 0,
/* Truncate the file referenced by FD to LENGTH bytes. */
int
-truncate64 (path, length)
- const char *path;
- off64_t length;
+truncate64 (const char *path, off64_t length)
{
/* On PPC32 64bit values are aligned in odd/even register pairs. */
int result = INLINE_SYSCALL (truncate64, 4, path, 0,
int
-raise (sig)
- int sig;
+raise (int sig)
{
/* raise is an async-safe function. It could be called while the
fork function temporarily invalidated the PID field. Adjust for
int
-pthread_getcpuclockid (threadid, clockid)
- pthread_t threadid;
- clockid_t *clockid;
+pthread_getcpuclockid (pthread_t threadid, clockid_t *clockid)
{
struct pthread *pd = (struct pthread *) threadid;
int
-pthread_getname_np (th, buf, len)
- pthread_t th;
- char *buf;
- size_t len;
+pthread_getname_np (pthread_t th, char *buf, size_t len)
{
const struct pthread *pd = (const struct pthread *) th;
int
-pthread_setname_np (th, name)
- pthread_t th;
- const char *name;
+pthread_setname_np (pthread_t th, const char *name)
{
const struct pthread *pd = (const struct pthread *) th;
int
-pthread_sigmask (how, newmask, oldmask)
- int how;
- const sigset_t *newmask;
- sigset_t *oldmask;
+pthread_sigmask (int how, const sigset_t *newmask, sigset_t *oldmask)
{
sigset_t local_newmask;
int
-pthread_sigqueue (threadid, signo, value)
- pthread_t threadid;
- int signo;
- const union sigval value;
+pthread_sigqueue (pthread_t threadid, int signo, const union sigval value)
{
#ifdef __NR_rt_tgsigqueueinfo
struct pthread *pd = (struct pthread *) threadid;
int
-raise (sig)
- int sig;
+raise (int sig)
{
struct pthread *pd = THREAD_SELF;
pid_t pid = THREAD_GETMEM (pd, pid);
/* If ACT is not NULL, change the action for SIG to *ACT.
If OACT is not NULL, put the old action for SIG in *OACT. */
int
-__libc_sigaction (sig, act, oact)
- int sig;
- const struct sigaction *act;
- struct sigaction *oact;
+__libc_sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
{
/* XXX The size argument hopefully will have to be changed to the
real size of the user-level sigset_t. */
/* Change the set of blocked signals to SET,
wait until a signal arrives, and restore the set of blocked signals. */
int
-sigpending (set)
- sigset_t *set;
+sigpending (sigset_t *set)
{
/* XXX The size argument hopefully will have to be changed to the
real size of the user-level sigset_t. */
/* Get and/or change the set of blocked signals. */
int
-__sigprocmask (how, set, oset)
- int how;
- const sigset_t *set;
- sigset_t *oset;
+__sigprocmask (int how, const sigset_t *set, sigset_t *oset)
{
/* XXX The size argument hopefully will have to be changed to the
KEY. */
int
-semget (key, nsems, semflg)
- key_t key;
- int nsems;
- int semflg;
+semget (key_t key, int nsems, int semflg)
{
return INLINE_SYSCALL (ipc, 5, IPCOP_semget, key, nsems, semflg, NULL);
}
/* Perform user-defined atomical operation of array of semaphores. */
int
-semop (semid, sops, nsops)
- int semid;
- struct sembuf *sops;
- size_t nsops;
+semop (int semid, struct sembuf *sops, size_t nsops)
{
return INLINE_SYSCALL (ipc, 5, IPCOP_semop, semid, (int) nsops, 0, sops);
}
Only the super-user can increase hard limits.
Return 0 if successful, -1 if not (and sets errno). */
int
-setrlimit64 (resource, rlimits)
- enum __rlimit_resource resource;
- const struct rlimit64 *rlimits;
+setrlimit64 (enum __rlimit_resource resource, const struct rlimit64 *rlimits)
{
#ifdef __ASSUME_PRLIMIT64
return INLINE_SYSCALL (prlimit64, 4, 0, resource, rlimits, NULL);
and where the segment is attached. */
void *
-shmat (shmid, shmaddr, shmflg)
- int shmid;
- const void *shmaddr;
- int shmflg;
+shmat (int shmid, const void *shmaddr, int shmflg)
{
INTERNAL_SYSCALL_DECL(err);
unsigned long resultvar;
from the caller's data segment. */
int
-shmdt (shmaddr)
- const void *shmaddr;
+shmdt (const void *shmaddr)
{
return INLINE_SYSCALL (ipc, 5, IPCOP_shmdt, 0, 0, 0, (void *) shmaddr);
}
which is associated with KEY. */
int
-shmget (key, size, shmflg)
- key_t key;
- size_t size;
- int shmflg;
+shmget (key_t key, size_t size, int shmflg)
{
return INLINE_SYSCALL (ipc, 5, IPCOP_shmget, key, size, shmflg, NULL);
}
/* If ACT is not NULL, change the action for SIG to *ACT.
If OACT is not NULL, put the old action for SIG in *OACT. */
int
-__libc_sigaction (sig, act, oact)
- int sig;
- const struct sigaction *act;
- struct sigaction *oact;
+__libc_sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
{
int result;
/* Change the set of blocked signals to SET,
wait until a signal arrives, and restore the set of blocked signals. */
int
-sigpending (set)
- sigset_t *set;
+sigpending (sigset_t *set)
{
return INLINE_SYSCALL (rt_sigpending, 2, set, _NSIG / 8);
}
/* Get and/or change the set of blocked signals. */
int
-__sigprocmask (how, set, oset)
- int how;
- const sigset_t *set;
- sigset_t *oset;
+__sigprocmask (int how, const sigset_t *set, sigset_t *oset)
{
#ifdef SIGCANCEL
sigset_t local_newmask;
#ifdef __NR_rt_sigqueueinfo
/* Return any pending signal or wait for one for the given time. */
int
-__sigqueue (pid, sig, val)
- pid_t pid;
- int sig;
- const union sigval val;
+__sigqueue (pid_t pid, int sig, const union sigval val)
{
siginfo_t info;
#ifdef __NR_sigaltstack
int
-sigstack (ss, oss)
- struct sigstack *ss;
- struct sigstack *oss;
+sigstack (struct sigstack *ss, struct sigstack *oss)
{
stack_t sas;
stack_t *sasp = NULL;
/* Change the set of blocked signals to SET,
wait until a signal arrives, and restore the set of blocked signals. */
int
-sigpending (set)
- sigset_t *set;
+sigpending (sigset_t *set)
{
/* XXX The size argument hopefully will have to be changed to the
real size of the user-level sigset_t. */
/* Get and/or change the set of blocked signals. */
int
-__sigprocmask (how, set, oset)
- int how;
- const sigset_t *set;
- sigset_t *oset;
+__sigprocmask (int how, const sigset_t *set, sigset_t *oset)
{
/* XXX The size argument hopefully will have to be changed to the
real size of the user-level sigset_t. */
/* Return the output baud rate stored in *TERMIOS_P. */
speed_t
-cfgetospeed (termios_p)
- const struct termios *termios_p;
+cfgetospeed (const struct termios *termios_p)
{
return termios_p->c_cflag & (CBAUD | CBAUDEX);
}
speed, the numerical 0 is a special case for the input baud rate. It
should set the input baud rate to the output baud rate. */
speed_t
-cfgetispeed (termios_p)
- const struct termios *termios_p;
+cfgetispeed (const struct termios *termios_p)
{
return ((termios_p->c_iflag & IBAUD0)
? 0 : termios_p->c_cflag & (CBAUD | CBAUDEX));
/* Set the output baud rate stored in *TERMIOS_P to SPEED. */
int
-cfsetospeed (termios_p, speed)
- struct termios *termios_p;
- speed_t speed;
+cfsetospeed (struct termios *termios_p, speed_t speed)
{
if ((speed & ~CBAUD) != 0
&& (speed < B57600 || speed > __MAX_BAUD))
speed, the numerical 0 is a special case for the input baud rate. It
should set the input baud rate to the output baud rate. */
int
-cfsetispeed (termios_p, speed)
- struct termios *termios_p;
- speed_t speed;
+cfsetispeed (struct termios *termios_p, speed_t speed)
{
if ((speed & ~CBAUD) != 0
&& (speed < B57600 || speed > __MAX_BAUD))
/* Suspend or restart transmission on FD. */
int
-tcflow (fd, action)
- int fd;
- int action;
+tcflow (int fd, int action)
{
return __ioctl (fd, TCXONC, action);
}
/* Flush pending data on FD. */
int
-tcflush (fd, queue_selector)
- int fd;
- int queue_selector;
+tcflush (int fd, int queue_selector)
{
return __ioctl (fd, TCFLSH, queue_selector);
}
/* Put the state of FD into *TERMIOS_P. */
int
-__tcgetattr (fd, termios_p)
- int fd;
- struct termios *termios_p;
+__tcgetattr (int fd, struct termios *termios_p)
{
struct __kernel_termios k_termios;
int retval;
/* Set the state of FD to *TERMIOS_P. */
int
-tcsetattr (fd, optional_actions, termios_p)
- int fd;
- int optional_actions;
- const struct termios *termios_p;
+tcsetattr (int fd, int optional_actions, const struct termios *termios_p)
{
struct __kernel_termios k_termios;
unsigned long int cmd;
#ifdef __NR_time
time_t
-time (t)
- time_t *t;
+time (time_t *t)
{
INTERNAL_SYSCALL_DECL (err);
time_t res = INTERNAL_SYSCALL (time, err, 1, NULL);
int
-timer_create (clock_id, evp, timerid)
- clockid_t clock_id;
- struct sigevent *evp;
- timer_t *timerid;
+timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid)
{
#undef timer_create
{
int
-timer_delete (timerid)
- timer_t timerid;
+timer_delete (timer_t timerid)
{
#undef timer_delete
struct timer *kt = (struct timer *) timerid;
int
-timer_getoverrun (timerid)
- timer_t timerid;
+timer_getoverrun (timer_t timerid)
{
#undef timer_getoverrun
struct timer *kt = (struct timer *) timerid;
int
-timer_gettime (timerid, value)
- timer_t timerid;
- struct itimerspec *value;
+timer_gettime (timer_t timerid, struct itimerspec *value)
{
#undef timer_gettime
struct timer *kt = (struct timer *) timerid;
/* Change the set of blocked signals to SET,
wait until a signal arrives, and restore the set of blocked signals. */
int
-sigpending (set)
- sigset_t *set;
+sigpending (sigset_t *set)
{
/* XXX The size argument hopefully will have to be changed to the
real size of the user-level sigset_t. */
/* Get and/or change the set of blocked signals. */
int
-__sigprocmask (how, set, oset)
- int how;
- const sigset_t *set;
- sigset_t *oset;
+__sigprocmask (int how, const sigset_t *set, sigset_t *oset)
{
/* XXX The size argument hopefully will have to be changed to the
}
int
-__backtrace (array, size)
- void **array;
- int size;
+__backtrace (void **array, int size)
{
struct trace_arg arg = { .array = array, .cfa = 0, .size = size, .cnt = -1 };
projects / thirdparty / glibc.git / commitdiff
