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

Update. 

2004-03-18  Ulrich Drepper  <drepper@redhat.com>

	* posix/sched.h: Change sched_getaffinity and sched_setaffinity
	interfaces: add new second parameter.
	* sysdeps/generic/sched_getaffinity.c: Implement interface change.
	* sysdeps/generic/sched_setaffinity.c: Likewise.
	* sysdeps/unix/sysv/linux/sched_getaffinity.c: Likewise.  Add
	compatibility interface.
	* sysdeps/unix/sysv/linux/sched_setaffinity.c: Likewise.
	* sysdeps/unix/sysv/linux/Versions: Add versions for changed
	interfaces.
This commit is contained in:
Ulrich Drepper 2004-03-19 00:14:42 +00:00
parent 701a7b234e
commit 439ff07be0
18 changed files with 326 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
ChangeLog
View File

@ -1,3 +1,15 @@
2004-03-18 Ulrich Drepper <drepper@redhat.com>
* posix/sched.h: Change sched_getaffinity and sched_setaffinity
interfaces: add new second parameter.
* sysdeps/generic/sched_getaffinity.c: Implement interface change.
* sysdeps/generic/sched_setaffinity.c: Likewise.
* sysdeps/unix/sysv/linux/sched_getaffinity.c: Likewise. Add
compatibility interface.
* sysdeps/unix/sysv/linux/sched_setaffinity.c: Likewise.
* sysdeps/unix/sysv/linux/Versions: Add versions for changed
interfaces.
2004-03-18 Roland McGrath <roland@redhat.com>
* manual/Makefile (stamp-summary): Use -k option to sort,

6
nptl/Versions
View File

@ -219,6 +219,12 @@ libpthread {
__pthread_unwind_next;
__pthread_cleanup_routine;
# affinity interfaces without size parameter
pthread_getaffinity_np; pthread_setaffinity_np;
pthread_attr_getaffinity_np; pthread_attr_setaffinity_np;
}
GLIBC_2.3.4 {
# New affinity interfaces.
pthread_getaffinity_np; pthread_setaffinity_np;
pthread_attr_getaffinity_np; pthread_attr_setaffinity_np;

6
nptl/pthreadP.h
View File

@ -384,6 +384,8 @@ extern int __pthread_cond_timedwait_2_0 (pthread_cond_2_0_t *cond,
extern int __pthread_cond_wait_2_0 (pthread_cond_2_0_t *cond,
pthread_mutex_t *mutex);
extern int __pthread_getaffinity_np (pthread_t th, size_t cpusetsize,
cpu_set_t *cpuset);
/* The two functions are in libc.so and not exported. */
extern int __libc_enable_asynccancel (void) attribute_hidden;
@ -428,8 +430,4 @@ extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer,
extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer,
int execute);
#if defined NOT_IN_libc && defined IS_IN_libpthread
hidden_proto (pthread_getaffinity_np)
#endif
#endif /* pthreadP.h */

40
nptl/pthread_attr_destroy.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
@ -36,42 +36,10 @@ __pthread_attr_destroy (attr)
#if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
/* In old struct pthread_attr, neither next nor cpuset are
present. */
if (__builtin_expect ((iattr->flags & ATTR_FLAG_OLDATTR), 0))
return 0;
if (__builtin_expect ((iattr->flags & ATTR_FLAG_OLDATTR), 0) == 0)
#endif
/* Enqueue the attributes to the list of all known variables. */
if (DEBUGGING_P)
{
struct pthread_attr *prevp = NULL;
struct pthread_attr *runp;
lll_lock (__attr_list_lock);
runp = __attr_list;
while (runp != NULL && runp != iattr)
{
prevp = runp;
runp = runp->next;
}
if (runp != NULL)
{
if (prevp == NULL)
__attr_list = iattr->next;
else
prevp->next = iattr->next;
}
lll_unlock (__attr_list_lock);
if (runp == NULL)
/* Not a valid attribute. */
return EINVAL;
}
/* The affinity CPU set might be allocated dynamically. */
free (iattr->cpuset);
/* The affinity CPU set might be allocated dynamically. */
free (iattr->cpuset);
return 0;
}

13
nptl/pthread_attr_init.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
@ -47,17 +47,6 @@ __pthread_attr_init_2_1 (attr)
/* Default guard size specified by the standard. */
iattr->guardsize = __getpagesize ();
/* Enqueue the attributes to the list of all known variables. */
if (DEBUGGING_P)
{
lll_lock (__attr_list_lock);
iattr->next = __attr_list;
__attr_list = iattr;
lll_unlock (__attr_list_lock);
}
return 0;
}
versioned_symbol (libpthread, __pthread_attr_init_2_1, pthread_attr_init,

35
nptl/pthread_getattr_np.c
View File

@ -135,18 +135,35 @@ pthread_getattr_np (thread_id, attr)
if (ret == 0)
{
iattr->cpuset = (cpu_set_t *) malloc (sizeof (cpu_set_t));
if (iattr->cpuset == NULL)
ret = ENOMEM;
size_t size = 32;
cpu_set_t *cpuset = NULL;
do
{
void *newp = realloc (cpuset, size);
if (newp == NULL)
{
free (cpuset);
ret = ENOMEM;
}
cpuset = (cpu_set_t *) newp;
ret = __pthread_getaffinity_np (thread_id, size, cpuset);
}
/* Pick some ridiculous upper limit. Is 8 million CPUs enough? */
while (ret == EINVAL && size < 1024 * 1024);
if (ret == 0)
{
iattr->cpuset = cpuset;
iattr->cpusetsize = size;
}
else
{
ret = pthread_getaffinity_np (thread_id, iattr->cpuset);
free (cpuset);
if (ret == ENOSYS)
{
free (iattr->cpuset);
iattr->cpuset = NULL;
ret = 0;
}
/* There is no such functionality. */
ret = 0;
}
}

12
nptl/sysdeps/pthread/pthread.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@ -326,11 +326,13 @@ extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
/* Thread created with attribute ATTR will be limited to run only on
the processors represented in CPUSET. */
extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
size_t __cpusetsize,
__const cpu_set_t *__cpuset) __THROW;
/* Get bit set in CPUSET representing the processors threads created with
ATTR can run on. */
extern int pthread_attr_getaffinity_np (__const pthread_attr_t *__attr,
size_t __cpusetsize,
cpu_set_t *__cpuset) __THROW;
@ -374,12 +376,12 @@ extern int pthread_yield (void) __THROW;
/* Limit specified thread TH to run only on the processors represented
in CPUSET. */
extern int pthread_setaffinity_np (pthread_t __th, __const cpu_set_t *__cpuset)
__THROW;
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
__const cpu_set_t *__cpuset) __THROW;
/* Get bit set in CPUSET representing the processors TH can run on. */
extern int pthread_getaffinity_np (pthread_t __th, cpu_set_t *__cpuset)
__THROW;
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
cpu_set_t *__cpuset) __THROW;
#endif

43
nptl/sysdeps/unix/sysv/linux/pthread_attr_getaffinity.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2003 Free Software Foundation, Inc.
/* Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
@ -23,22 +23,47 @@
#include <string.h>
#include <sysdep.h>
#include <sys/types.h>
#include <shlib-compat.h>
int
pthread_attr_getaffinity_np (attr, cpuset)
const pthread_attr_t *attr;
cpu_set_t *cpuset;
__pthread_attr_getaffinity_new (const pthread_attr_t *attr, size_t cpusetsize,
cpu_set_t *cpuset)
{
struct pthread_attr *iattr;
const struct pthread_attr *iattr;
assert (sizeof (*attr) >= sizeof (struct pthread_attr));
iattr = (struct pthread_attr *) attr;
iattr = (const struct pthread_attr *) attr;
if (iattr->cpuset)
memcpy (cpuset, iattr->cpuset, sizeof (cpu_set_t));
if (iattr->cpuset != NULL)
{
/* Check whether there are any bits set beyond the limits
the user requested. */
for (size_t cnt = cpusetsize; cnt < iattr->cpusetsize; ++cnt)
if (((char *) iattr->cpuset)[cnt] != 0)
return EINVAL;
void *p = mempcpy (cpuset, iattr->cpuset, iattr->cpusetsize);
if (cpusetsize > iattr->cpusetsize)
memset (p, '\0', cpusetsize - iattr->cpusetsize);
}
else
memset (cpuset, -1, sizeof (cpu_set_t));
/* We have no information. */
memset (cpuset, -1, cpusetsize);
return 0;
}
versioned_symbol (libpthread, __pthread_attr_getaffinity_new,
pthread_attr_getaffinity_np, GLIBC_2_3_4);
#if SHLIB_COMPAT(libpthread, 2_3_3, 2_3_4)
int
__pthread_attr_getaffinity_old (const pthread_attr_t *attr, cpu_set_t *cpuset)
{
/* The old interface by default assumed a 1024 processor bitmap. */
return __pthread_attr_getaffinity_new (attr, 128, cpuset);
}
compat_symbol (libpthread, __pthread_attr_getaffinity_old,
pthread_attr_getaffinity_np, GLIBC_2_3_3);
#endif

60
nptl/sysdeps/unix/sysv/linux/pthread_attr_setaffinity.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2003 Free Software Foundation, Inc.
/* Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
@ -19,37 +19,77 @@
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <pthreadP.h>
#include <shlib-compat.h>
/* Defined in pthread_setaffinity.c. */
extern size_t __kernel_cpumask_size;
extern int __determine_cpumask_size (pid_t tid);
int
pthread_attr_setaffinity_np (attr, cpuset)
pthread_attr_t *attr;
const cpu_set_t *cpuset;
__pthread_attr_setaffinity_new (pthread_attr_t *attr, size_t cpusetsize,
const cpu_set_t *cpuset)
{
struct pthread_attr *iattr;
assert (sizeof (*attr) >= sizeof (struct pthread_attr));
iattr = (struct pthread_attr *) attr;
if (cpuset == NULL)
if (cpuset == NULL || cpusetsize == 0)
{
free (iattr->cpuset);
iattr->cpuset = NULL;
iattr->cpusetsize = 0;
}
else
{
if (iattr->cpuset == NULL)
if (__kernel_cpumask_size == 0)
{
iattr->cpuset = (cpu_set_t *) malloc (sizeof (cpu_set_t));
if (iattr->cpuset == NULL)
return ENOMEM;
int res = __determine_cpumask_size (THREAD_SELF->tid);
if (res != 0)
/* Some serious problem. */
return res;
}
memcpy (iattr->cpuset, cpuset, sizeof (cpu_set_t));
/* Check whether the new bitmask has any bit set beyond the
last one the kernel accepts. */
for (size_t cnt = __kernel_cpumask_size; cnt < cpusetsize; ++cnt)
if (((char *) cpuset)[cnt] != '\0')
/* Found a nonzero byte. This means the user request cannot be
fulfilled. */
return EINVAL;
if (iattr->cpusetsize != cpusetsize)
{
void *newp = (cpu_set_t *) realloc (iattr->cpuset, cpusetsize);
if (newp == NULL)
return ENOMEM;
iattr->cpuset = newp;
iattr->cpusetsize = cpusetsize;
}
memcpy (iattr->cpuset, cpuset, cpusetsize);
}
return 0;
}
versioned_symbol (libpthread, __pthread_attr_setaffinity_new,
pthread_attr_setaffinity_np, GLIBC_2_3_4);
#if SHLIB_COMPAT(libpthread, 2_3_3, 2_3_4)
int
__pthread_attr_setaffinity_old (const pthread_attr_t *attr, cpu_set_t *cpuset)
{
/* The old interface by default assumed a 1024 processor bitmap. */
return __pthread_attr_setaffinity_new (attr, 128, cpuset);
}
compat_symbol (libpthread, __pthread_attr_setaffinity_old,
pthread_attr_setaffinity_np, GLIBC_2_3_3);
#endif

32
nptl/sysdeps/unix/sysv/linux/pthread_getaffinity.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2003 Free Software Foundation, Inc.
/* Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
@ -18,27 +18,43 @@
02111-1307 USA. */
#include <errno.h>
#include <limits.h>
#include <pthreadP.h>
#include <string.h>
#include <sysdep.h>
#include <sys/param.h>
#include <sys/types.h>
#include <shlib-compat.h>
int
pthread_getaffinity_np (th, cpuset)
pthread_t th;
cpu_set_t *cpuset;
__pthread_getaffinity_new (pthread_t th, size_t cpusetsize, cpu_set_t *cpuset)
{
struct pthread *pd = (struct pthread *) th;
const struct pthread *pd = (const struct pthread *) th;
INTERNAL_SYSCALL_DECL (err);
int res = INTERNAL_SYSCALL (sched_getaffinity, err, 3, pd->tid,
sizeof (cpu_set_t), cpuset);
MIN (UINT_MAX, cpusetsize), cpuset);
if (INTERNAL_SYSCALL_ERROR_P (res, err))
return INTERNAL_SYSCALL_ERRNO (res, err);
/* Clean the rest of the memory the kernel didn't do. */
memset ((char *) cpuset + res, '\0', sizeof (cpu_set_t) - res);
memset ((char *) cpuset + res, '\0', cpusetsize - res);
return 0;
}
hidden_def (pthread_getaffinity_np)
strong_alias (__pthread_getaffinity_new, __pthread_getaffinity_np)
versioned_symbol (libpthread, __pthread_getaffinity_new,
pthread_getaffinity_np, GLIBC_2_3_4);
#if SHLIB_COMPAT(libpthread, 2_3_3, 2_3_4)
int
__pthread_getaffinity_old (const pthread_attr_t *attr, cpu_set_t *cpuset)
{
/* The old interface by default assumed a 1024 processor bitmap. */
return __pthread_getaffinity_new (attr, 128, cpuset);
}
compat_symbol (libpthread, __pthread_getaffinity_old, pthread_getaffinity_np,
GLIBC_2_3_3);
#endif

76
nptl/sysdeps/unix/sysv/linux/pthread_setaffinity.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2003 Free Software Foundation, Inc.
/* Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
@ -17,22 +17,84 @@
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
#include <alloca.h>
#include <errno.h>
#include <pthreadP.h>
#include <sysdep.h>
#include <sys/types.h>
#include <shlib-compat.h>
size_t __kernel_cpumask_size;
/* Determine the current affinity. As a side affect we learn
about the size of the cpumask_t in the kernel. */
int
__determine_cpumask_size (pid_t tid)
{
INTERNAL_SYSCALL_DECL (err);
int res;
size_t psize = 128;
void *p = alloca (psize);
while (res = INTERNAL_SYSCALL (sched_getaffinity, err, 3, tid, psize, p),
INTERNAL_SYSCALL_ERROR_P (res, err)
&& INTERNAL_SYSCALL_ERRNO (res, err) == EINVAL)
p = extend_alloca (p, psize, 2 * psize);
if (res == 0 || INTERNAL_SYSCALL_ERROR_P (res, err))
return INTERNAL_SYSCALL_ERRNO (res, err);
__kernel_cpumask_size = res;
return 0;
}
int
pthread_setaffinity_np (th, cpuset)
pthread_t th;
const cpu_set_t *cpuset;
__pthread_setaffinity_new (pthread_t th, size_t cpusetsize,
const cpu_set_t *cpuset)
{
struct pthread *pd = (struct pthread *) th;
const struct pthread *pd = (const struct pthread *) th;
INTERNAL_SYSCALL_DECL (err);
int res = INTERNAL_SYSCALL (sched_setaffinity, err, 3, pd->tid,
sizeof (cpu_set_t), cpuset);
int res;
if (__builtin_expect (__kernel_cpumask_size == 0, 0))
{
res = __determine_cpumask_size (pd->tid);
if (res != 0)
return res;
}
/* We now know the size of the kernel cpumask_t. Make sure the user
does not request to set a bit beyond that. */
for (size_t cnt = __kernel_cpumask_size; cnt < cpusetsize; ++cnt)
if (((char *) cpuset)[cnt] != '\0')
/* Found a nonzero byte. This means the user request cannot be
fulfilled. */
return EINVAL;
INTERNAL_SYSCALL_DECL (err);
res = INTERNAL_SYSCALL (sched_setaffinity, err, 3, pd->tid, cpusetsize,
cpuset);
return (INTERNAL_SYSCALL_ERROR_P (res, err)
? INTERNAL_SYSCALL_ERRNO (res, err)
: 0);
}
versioned_symbol (libpthread, __pthread_setaffinity_new,
pthread_setaffinity_np, GLIBC_2_3_4);
#if SHLIB_COMPAT(libpthread, 2_3_3, 2_3_4)
int
__pthread_setaffinity_old (const pthread_attr_t *attr, cpu_set_t *cpuset)
{
/* The old interface by default assumed a 1024 processor bitmap. */
return __pthread_setaffinity_new (attr, 128, cpuset);
}
compat_symbol (libpthread, __pthread_setaffinity_old, pthread_setaffinity_np,
GLIBC_2_3_3);
#endif

12
nptl/tst-attr3.c
View File

@ -1,5 +1,5 @@
/* pthread_getattr_np test.
Copyright (C) 2003 Free Software Foundation, Inc.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.
@ -168,10 +168,10 @@ tf (void *arg)
}
cpu_set_t c1, c2;
err = pthread_getaffinity_np (pthread_self (), &c1);
err = pthread_getaffinity_np (pthread_self (), sizeof (c1), &c1);
if (err == 0)
{
err = pthread_attr_getaffinity_np (&a, &c2);
err = pthread_attr_getaffinity_np (&a, sizeof (c2), &c2);
if (err)
{
error (0, err, "pthread_attr_getaffinity_np failed");
@ -219,7 +219,7 @@ do_test (void)
result = 1;
}
err = pthread_attr_getaffinity_np (&a, &c1);
err = pthread_attr_getaffinity_np (&a, sizeof (c1), &c1);
if (err && err != ENOSYS)
{
error (0, err, "pthread_attr_getaffinity_np failed");
@ -313,10 +313,10 @@ do_test (void)
result = 1;
}
err = pthread_getaffinity_np (pthread_self (), &c1);
err = pthread_getaffinity_np (pthread_self (), sizeof (c1), &c1);
if (err == 0)
{
err = pthread_attr_getaffinity_np (&a, &c2);
err = pthread_attr_getaffinity_np (&a, sizeof (c2), &c2);
if (err)
{
error (0, err, "pthread_attr_getaffinity_np failed");

9
posix/sched.h
View File

@ -1,5 +1,5 @@
/* Definitions for POSIX 1003.1b-1993 (aka POSIX.4) scheduling interface.
Copyright (C) 1996,1997,1999,2001,2002,2003 Free Software Foundation, Inc.
Copyright (C) 1996,1997,1999,2001-2003,2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@ -73,11 +73,12 @@ extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) __THROW;
/* Set the CPU affinity for a task */
extern int sched_setaffinity (__pid_t __pid, __const cpu_set_t *__mask)
__THROW;
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
__const cpu_set_t *__cpuset) __THROW;
/* Get the CPU affinity for a task */
extern int sched_getaffinity (__pid_t __pid, cpu_set_t *__mask) __THROW;
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
cpu_set_t *__cpuset) __THROW;
#endif
__END_DECLS

5
sysdeps/generic/sched_getaffinity.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@ -23,8 +23,9 @@
/* Retrieve the CPU affinity mask for a particular process. */
int
sched_getaffinity (pid, cpuset)
sched_getaffinity (pid, cpusetsize, cpuset)
pid_t pid;
size_t cpusetsize;
cpu_set_t *cpuset;
{
__set_errno (ENOSYS);

5
sysdeps/generic/sched_setaffinity.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@ -23,8 +23,9 @@
/* Retrieve the CPU affinity mask for a particular process. */
int
sched_setaffinity (pid, cpuset)
sched_setaffinity (pid, cpusetsize, cpuset)
pid_t pid;
size_t cpusetsize;
const cpu_set_t *cpuset;
{
__set_errno (ENOSYS);

3
sysdeps/unix/sysv/linux/Versions
View File

@ -112,6 +112,9 @@ libc {
GLIBC_2.3.3 {
gnu_dev_major; gnu_dev_minor; gnu_dev_makedev;
}
GLIBC_2.3.4 {
sched_getaffinity; sched_setaffinity;
}
GLIBC_PRIVATE {
# needed by libpthread.
__libc_sigaction;

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

@ -1,4 +1,4 @@
/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@ -21,25 +21,38 @@
#include <string.h>
#include <sysdep.h>
#include <sys/types.h>
#include <shlib-compat.h>
#ifdef __NR_sched_getaffinity
int
sched_getaffinity (pid, cpuset)
pid_t pid;
cpu_set_t *cpuset;
__sched_getaffinity_new (pid_t pid, size_t cpusetsize, cpu_set_t *cpuset)
{
int res = INLINE_SYSCALL (sched_getaffinity, 3, pid, sizeof (cpu_set_t),
cpuset);
if (res != -1)
{
/* Clean the rest of the memory the kernel didn't do. */
memset ((char *) cpuset + res, '\0', sizeof (cpu_set_t) - res);
memset ((char *) cpuset + res, '\0', cpusetsize - res);
res = 0;
}
return res;
}
versioned_symbol (libc, __sched_getaffinity_new, sched_getaffinity,
GLIBC_2_3_4);
# if SHLIB_COMPAT(libc, 2_3_3, 2_3_4)
int
attribute_compat_text_section
__sched_getaffinity_old (const pthread_attr_t *attr, cpu_set_t *cpuset)
{
/* The old interface by default assumed a 1024 processor bitmap. */
return __sched_getaffinity_new (attr, 128, cpuset);
}
compat_symbol (libc, __sched_getaffinity_old, sched_getaffinity, GLIBC_2_3_3);
# endif
#else
# include <sysdeps/generic/sched_getaffinity.c>
#endif

59
sysdeps/unix/sysv/linux/sched_setaffinity.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@ -20,18 +20,65 @@
#include <sched.h>
#include <string.h>
#include <sysdep.h>
#include <unistd.h>
#include <sys/types.h>
#include <shlib-compat.h>
#ifdef __NR_sched_setaffinity
static size_t __kernel_cpumask_size;
int
sched_setaffinity (pid, cpuset)
pid_t pid;
const cpu_set_t *cpuset;
__sched_setaffinity_new (pid_t pid, size_t cpusetsize, const cpu_set_t *cpuset)
{
return INLINE_SYSCALL (sched_setaffinity, 3, pid, sizeof (cpu_set_t),
cpuset);
if (__builtin_expect (__kernel_cpumask_size == 0, 0))
{
INTERNAL_SYSCALL_DECL (err);
int res;
size_t psize = 128;
void *p = alloca (psize);
while (res = INTERNAL_SYSCALL (sched_getaffinity, err, 3, getpid (),
psize, p),
INTERNAL_SYSCALL_ERROR_P (res, err)
&& INTERNAL_SYSCALL_ERRNO (res, err) == EINVAL)
p = extend_alloca (p, psize, 2 * psize);
if (res == 0 || INTERNAL_SYSCALL_ERROR_P (res, err))
{
__set_errno (INTERNAL_SYSCALL_ERRNO (res, err));
return -1;
}
__kernel_cpumask_size = res;
}
/* We now know the size of the kernel cpumask_t. Make sure the user
does not request to set a bit beyond that. */
for (size_t cnt = __kernel_cpumask_size; cnt < cpusetsize; ++cnt)
if (((char *) cpuset)[cnt] != '\0')
/* Found a nonzero byte. This means the user request cannot be
fulfilled. */
return EINVAL;
return INLINE_SYSCALL (sched_setaffinity, 3, pid, cpusetsize, cpuset);
}
versioned_symbol (libc, __sched_setaffinity_new, sched_setaffinity,
GLIBC_2_3_4);
# if SHLIB_COMPAT(libc, 2_3_3, 2_3_4)
int
attribute_compat_text_section
__sched_setaffinity_old (const pthread_attr_t *attr, const cpu_set_t *cpuset)
{
/* The old interface by default assumed a 1024 processor bitmap. */
return __sched_setaffinity_new (attr, 128, cpuset);
}
compat_symbol (libc, __sched_setaffinity_old, sched_setaffinity, GLIBC_2_3_3);
# endif
#else
# include <sysdeps/generic/sched_setaffinity.c>
#endif