about summary refs log tree commit diff
path: root/nptl/sysdeps
diff options
context:
space:
mode:
authorUlrich Drepper <drepper@redhat.com>2004-03-19 00:14:42 +0000
committerUlrich Drepper <drepper@redhat.com>2004-03-19 00:14:42 +0000
commit439ff07be06e9354151f984c7d0d2fb05917e8be (patch)
tree2c3471a5c7e73d1f6a043b082266e7248b992c02 /nptl/sysdeps
parent701a7b234eab5615adb472b5dc5b0a9199d69f9b (diff)
downloadglibc-439ff07be06e9354151f984c7d0d2fb05917e8be.tar.gz
glibc-439ff07be06e9354151f984c7d0d2fb05917e8be.tar.xz
glibc-439ff07be06e9354151f984c7d0d2fb05917e8be.zip
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.
Diffstat (limited to 'nptl/sysdeps')
-rw-r--r--nptl/sysdeps/pthread/pthread.h12
-rw-r--r--nptl/sysdeps/unix/sysv/linux/pthread_attr_getaffinity.c43
-rw-r--r--nptl/sysdeps/unix/sysv/linux/pthread_attr_setaffinity.c58
-rw-r--r--nptl/sysdeps/unix/sysv/linux/pthread_getaffinity.c32
-rw-r--r--nptl/sysdeps/unix/sysv/linux/pthread_setaffinity.c76
5 files changed, 183 insertions, 38 deletions
diff --git a/nptl/sysdeps/pthread/pthread.h b/nptl/sysdeps/pthread/pthread.h
index 6e8da67753..8fb6cc741d 100644
--- a/nptl/sysdeps/pthread/pthread.h
+++ b/nptl/sysdeps/pthread/pthread.h
@@ -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
 
 
diff --git a/nptl/sysdeps/unix/sysv/linux/pthread_attr_getaffinity.c b/nptl/sysdeps/unix/sysv/linux/pthread_attr_getaffinity.c
index 8a3f31d078..6620172b58 100644
--- a/nptl/sysdeps/unix/sysv/linux/pthread_attr_getaffinity.c
+++ b/nptl/sysdeps/unix/sysv/linux/pthread_attr_getaffinity.c
@@ -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
diff --git a/nptl/sysdeps/unix/sysv/linux/pthread_attr_setaffinity.c b/nptl/sysdeps/unix/sysv/linux/pthread_attr_setaffinity.c
index de8f54fb97..c75bdae492 100644
--- a/nptl/sysdeps/unix/sysv/linux/pthread_attr_setaffinity.c
+++ b/nptl/sysdeps/unix/sysv/linux/pthread_attr_setaffinity.c
@@ -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)
+	{
+	  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
diff --git a/nptl/sysdeps/unix/sysv/linux/pthread_getaffinity.c b/nptl/sysdeps/unix/sysv/linux/pthread_getaffinity.c
index 41849ddadf..c6cf9d71e4 100644
--- a/nptl/sysdeps/unix/sysv/linux/pthread_getaffinity.c
+++ b/nptl/sysdeps/unix/sysv/linux/pthread_getaffinity.c
@@ -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
diff --git a/nptl/sysdeps/unix/sysv/linux/pthread_setaffinity.c b/nptl/sysdeps/unix/sysv/linux/pthread_setaffinity.c
index 7680068155..9a73d2c3cb 100644
--- a/nptl/sysdeps/unix/sysv/linux/pthread_setaffinity.c
+++ b/nptl/sysdeps/unix/sysv/linux/pthread_setaffinity.c
@@ -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
-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