+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,
__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;
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;
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 */
-/* 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.
#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;
}
-/* 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.
/* 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,
if (ret == 0)
{
- iattr->cpuset = (cpu_set_t *) malloc (sizeof (cpu_set_t));
- if (iattr->cpuset == NULL)
- ret = ENOMEM;
- else
+ size_t size = 32;
+ cpu_set_t *cpuset = NULL;
+
+ do
{
- ret = pthread_getaffinity_np (thread_id, iattr->cpuset);
- if (ret == ENOSYS)
+ void *newp = realloc (cpuset, size);
+ if (newp == NULL)
{
- free (iattr->cpuset);
- iattr->cpuset = NULL;
- ret = 0;
+ 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
+ {
+ free (cpuset);
+ if (ret == ENOSYS)
+ /* There is no such functionality. */
+ ret = 0;
}
}
-/* 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
/* 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;
/* 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
-/* 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.
#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
-/* 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.
#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)
+ {
+ int res = __determine_cpumask_size (THREAD_SELF->tid);
+ if (res != 0)
+ /* Some serious problem. */
+ return res;
+ }
+
+ /* 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)
{
- iattr->cpuset = (cpu_set_t *) malloc (sizeof (cpu_set_t));
- if (iattr->cpuset == NULL)
+ void *newp = (cpu_set_t *) realloc (iattr->cpuset, cpusetsize);
+ if (newp == NULL)
return ENOMEM;
+
+ iattr->cpuset = newp;
+ iattr->cpusetsize = cpusetsize;
}
- memcpy (iattr->cpuset, cpuset, sizeof (cpu_set_t));
+ 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
-/* 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.
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
-/* 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.
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
-pthread_setaffinity_np (th, cpuset)
- pthread_t th;
- const cpu_set_t *cpuset;
+__determine_cpumask_size (pid_t tid)
{
- struct pthread *pd = (struct pthread *) th;
INTERNAL_SYSCALL_DECL (err);
- int res = INTERNAL_SYSCALL (sched_setaffinity, err, 3, pd->tid,
- sizeof (cpu_set_t), cpuset);
+ 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_new (pthread_t th, size_t cpusetsize,
+ const cpu_set_t *cpuset)
+{
+ const struct pthread *pd = (const struct pthread *) th;
+
+ INTERNAL_SYSCALL_DECL (err);
+ 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
/* 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.
}
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");
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");
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");
/* 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
/* 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
-/* 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
/* 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);
-/* 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
/* 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);
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;
-/* 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
#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
-/* 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
#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_new (pid_t pid, size_t cpusetsize, const 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
-sched_setaffinity (pid, cpuset)
- pid_t pid;
- const cpu_set_t *cpuset;
+attribute_compat_text_section
+__sched_setaffinity_old (const pthread_attr_t *attr, const cpu_set_t *cpuset)
{
- return INLINE_SYSCALL (sched_setaffinity, 3, pid, sizeof (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
projects / platform / upstream / glibc.git / commitdiff