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.

11 files changed, 228 insertions, 105 deletions

diff --git a/nptl/Versions b/nptl/Versions
index 611ed9b..b96a1d8 100644
--- a/nptl/Versions
+++ b/nptl/Versions
@@ -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;
diff --git a/nptl/pthreadP.h b/nptl/pthreadP.h
index b051e3b..5604579 100644
--- a/nptl/pthreadP.h
+++ b/nptl/pthreadP.h
@@ -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 */
diff --git a/nptl/pthread_attr_destroy.c b/nptl/pthread_attr_destroy.c
index 73cba1d..b8d9a20 100644
--- a/nptl/pthread_attr_destroy.c
+++ b/nptl/pthread_attr_destroy.c
@@ -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;
 }
diff --git a/nptl/pthread_attr_init.c b/nptl/pthread_attr_init.c
index b1242d3..c84b33f 100644
--- a/nptl/pthread_attr_init.c
+++ b/nptl/pthread_attr_init.c
@@ -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,
diff --git a/nptl/pthread_getattr_np.c b/nptl/pthread_getattr_np.c
index 0925ced..df11b1f 100644
--- a/nptl/pthread_getattr_np.c
+++ b/nptl/pthread_getattr_np.c
@@ -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;
-      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;
 	}
     }
 
diff --git a/nptl/sysdeps/pthread/pthread.h b/nptl/sysdeps/pthread/pthread.h
index 6e8da67..8fb6cc7 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 8a3f31d..6620172 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 de8f54f..c75bdae 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 41849dd..c6cf9d7 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 7680068..9a73d2c 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
diff --git a/nptl/tst-attr3.c b/nptl/tst-attr3.c
index eb7754d..733e851 100644
--- a/nptl/tst-attr3.c
+++ b/nptl/tst-attr3.c
@@ -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");