lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-07-29 11:41:21 +03:00
Code Activity

Update.

Browse Source 
2003-03-25  Ulrich Drepper  <drepper@redhat.com>

	* csu/tst-atomic.c: Adjust tests to what atomic_add_negative and
	atomic_add_zero were supposed to do.
	* include/atomic.h: Adjust atomic_add_negative and atomic_add_zero
	to x86 behavior.

	* sysdeps/generic/bits/typesizes.h (__TIMER_T_TYPE): Define as void*.
	This matches the new timer implementation.
	* sysdeps/unix/sysv/linux/bits/siginfo.h (struct siginfo): Adjust
	timer info for what the kernel provides these days.
	(struct sigevent): Add _tid field.
	Define SIGEV_THREAD_ID.

	* Versions.def (librt): Add GLIBC_2.3.3.

	* abilist/libpthread.abilist: Update for nptl.
This commit is contained in:
Ulrich Drepper
2003-03-25 20:41:26 +00:00
parent 2a9ae45c3f
commit 09402f5bc1
58 changed files with 1272 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

235
nptl/sysdeps/unix/sysv/linux/timer_create.c Normal file
View File

@ -0,0 +1,235 @@
/* Copyright (C) 2003 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <errno.h>
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sysdep.h>
#include <kernel-features.h>
#include <internaltypes.h>
#include "kernel-posix-timers.h"
#ifdef __NR_timer_create
# ifndef __ASSUME_POSIX_TIMERS
# define timer_create static compat_timer_create
# include <nptl/sysdeps/pthread/timer_create.c>
# undef timer_create
/* Nonzero if the system calls are not available. */
int __no_posix_timers attribute_hidden;
# endif
# ifdef timer_create_alias
# define timer_create timer_create_alias
# endif
int
timer_create (clock_id, evp, timerid)
clockid_t clock_id;
struct sigevent *evp;
timer_t *timerid;
{
# undef timer_create
# ifndef __ASSUME_POSIX_TIMERS
if (__no_posix_timers >= 0)
# endif
{
/* If the user wants notification via a thread we need to handle
this special. */
if (evp == NULL
|| __builtin_expect (evp->sigev_notify != SIGEV_THREAD, 1))
{
kernel_timer_t ktimerid;
int retval = INLINE_SYSCALL (timer_create, 3, clock_id, evp,
&ktimerid);
# ifndef __ASSUME_POSIX_TIMERS
if (retval != -1 || errno != ENOSYS)
# endif
{
# ifndef __ASSUME_POSIX_TIMERS
__no_posix_timers = 1;
#endif
if (retval != -1)
{
struct timer *newp;
/* We avoid allocating too much memory by basically
using struct timer as a derived class with the
first two elements being in the superclass. We only
need these two elements here. */
newp = (struct timer *) malloc (offsetof (struct timer,
thrfunc));
if (newp != NULL)
{
newp->sigev_notify = (evp != NULL
? evp->sigev_notify
: SIGEV_SIGNAL);
newp->ktimerid = ktimerid;
*timerid = (timer_t) newp;
}
else
{
/* No memory. Free the kernel timer. */
INTERNAL_SYSCALL_DECL (err);
(void) INTERNAL_SYSCALL (timer_delete, err, 1, ktimerid);
retval = -1;
}
}
return retval;
}
}
else
{
#ifndef __ASSUME_POSIX_TIMERS
/* Make sure we have the necessary kernel support. */
if (__no_posix_timers == 0)
{
INTERNAL_SYSCALL_DECL (err);
struct timespec ts;
int res = INTERNAL_SYSCALL (clock_getres, err, 1, &ts);
__no_posix_timers = (INTERNAL_SYSCALL_ERROR_P (res, err)
? -1 : 1);
}
if (__no_posix_timers > 0)
#endif
{
sigset_t ss;
sigemptyset (&ss);
sigaddset (&ss, TIMER_SIG);
pthread_sigmask (SIG_BLOCK, &ss, NULL);
struct timer *newp;
newp = (struct timer *) malloc (sizeof (struct timer));
if (newp == NULL)
return -1;
/* Copy the thread parameters the user provided. */
newp->sival = evp->sigev_value;
newp->thrfunc = evp->sigev_notify_function;
/* We cannot simply copy the thread attributes since the
implementation might keep internal information for
each instance. */
(void) pthread_attr_init (&newp->attr);
if (evp->sigev_notify_attributes != NULL)
{
struct pthread_attr *nattr;
struct pthread_attr *oattr;
nattr = (struct pthread_attr *) &newp->attr;
oattr = (struct pthread_attr *) evp->sigev_notify_attributes;
nattr->schedparam = oattr->schedparam;
nattr->schedpolicy = oattr->schedpolicy;
nattr->flags = oattr->flags;
nattr->guardsize = oattr->guardsize;
nattr->stackaddr = oattr->stackaddr;
nattr->stacksize = oattr->stacksize;
}
/* In any case set the detach flag. */
(void) pthread_attr_setdetachstate (&newp->attr,
PTHREAD_CREATE_DETACHED);
/* Set up the barrier for sychronization. */
(void) pthread_barrier_init (&newp->bar, NULL, 2);
/* The helper thread needs only very little resources
and should go away automatically when canceled. */
pthread_attr_t attr;
(void) pthread_attr_init (&attr);
(void) pthread_attr_setdetachstate (&attr,
PTHREAD_CREATE_DETACHED);
(void) pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN);
/* Create the helper thread for this timer. */
int res = pthread_create (&newp->th, &attr,
__timer_helper_thread, newp);
if (res != 0)
goto err_out;
/* No need for the attribute anymore. */
(void) pthread_attr_destroy (&attr);
/* Create the event structure for the kernel timer. */
struct sigevent sev;
sev.sigev_value.sival_ptr = newp;
sev.sigev_signo = TIMER_SIG;
sev.sigev_notify = SIGEV_SIGNAL | SIGEV_THREAD_ID;
/* This is the thread ID of the helper thread. */
sev._sigev_un._pad[0] = ((struct pthread *) newp->th)->tid;
/* Wait until the helper thread is set up. */
(void) pthread_barrier_wait (&newp->bar);
/* No need for the barrier anymore. */
(void) pthread_barrier_destroy (&newp->bar);
/* Create the timer. */
INTERNAL_SYSCALL_DECL (err);
res = INTERNAL_SYSCALL (timer_create, err, 3, clock_id, &sev,
&newp->ktimerid);
if (! INTERNAL_SYSCALL_ERROR_P (res, err))
{
*timerid = (timer_t) newp;
return 0;
}
/* Something went wrong. Kill the thread. */
pthread_cancel (newp->th);
/* Free the resources. */
res = INTERNAL_SYSCALL_ERRNO (res, err);
err_out:
free (newp);
__set_errno (res);
return -1;
}
}
# ifndef __ASSUME_POSIX_TIMERS
/* When we come here the syscall does not exist. Make sure we
do not try to use it again. */
__no_posix_timers = -1;
# endif
}
# ifndef __ASSUME_POSIX_TIMERS
/* Compatibility code. */
return compat_timer_create (clock_id, evp, timerid);
# endif
}
#else
# ifdef timer_create_alias
# define timer_create timer_create_alias
# endif
/* The new system calls are not available. Use the userlevel
implementation. */
# include <nptl/sysdeps/pthread/timer_create.c>
#endif