Attachment #4780 for bug #11588

(-)a/Versions.def (+1 lines)

Lines 92-97 libpthread {	Link Here

  GLIBC_2.6

  GLIBC_2.6

  GLIBC_2.11

  GLIBC_2.11

  GLIBC_2.12

  GLIBC_2.12

  GLIBC_2.13

  GLIBC_PRIVATE

  GLIBC_PRIVATE

libresolv {

libresolv {

(-)a/nptl/Makefile (+1 lines)

Lines 75-80 libpthread-routines = nptl-init vars events version \	Link Here

		      old_pthread_cond_signal old_pthread_cond_broadcast \

		      old_pthread_cond_signal old_pthread_cond_broadcast \

		      pthread_condattr_init pthread_condattr_destroy \

		      pthread_condattr_init pthread_condattr_destroy \

		      pthread_condattr_getpshared pthread_condattr_setpshared \

		      pthread_condattr_getpshared pthread_condattr_setpshared \

		      pthread_condattr_getprotocol_np pthread_condattr_setprotocol_np \

		      pthread_condattr_getclock pthread_condattr_setclock \

		      pthread_condattr_getclock pthread_condattr_setclock \

		      pthread_spin_init pthread_spin_destroy \

		      pthread_spin_init pthread_spin_destroy \

		      pthread_spin_lock pthread_spin_trylock \

		      pthread_spin_lock pthread_spin_trylock \

(-)a/nptl/Versions (+4 lines)

Lines 251-256 libpthread {	Link Here

251

    pthread_setname_np; pthread_getname_np;

251

    pthread_setname_np; pthread_getname_np;

252

};

252

};

253

254

  GLIBC_2.13 {

255

    pthread_condattr_getprotocol_np; pthread_condattr_setprotocol_np;

256

257

254

  GLIBC_PRIVATE {

258

  GLIBC_PRIVATE {

255

    __pthread_initialize_minimal;

259

    __pthread_initialize_minimal;

256

    __pthread_clock_gettime; __pthread_clock_settime;

260

    __pthread_clock_gettime; __pthread_clock_settime;

(-)a/nptl/pthread_cond_broadcast.c (-22 / +37 lines)

Lines 1-4	Link Here

/* Copyright (C) 2003, 2004, 2006, 2007 Free Software Foundation, Inc.

/* Copyright (C) 2003, 2004, 2006, 2007, 2010 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   This file is part of the GNU C Library.

   Contributed by Martin Schwidefsky <schwidefsky@de.ibm.com>, 2003.

   Contributed by Martin Schwidefsky <schwidefsky@de.ibm.com>, 2003.

Lines 27-32	Link Here

#include <shlib-compat.h>

#include <shlib-compat.h>

#include <kernel-features.h>

#include <kernel-features.h>

#include "cond-lock.h"

int

int

__pthread_cond_broadcast (cond)

__pthread_cond_broadcast (cond)

Lines 34-41 __pthread_cond_broadcast (cond)	Link Here

  int pshared = (cond->__data.__mutex == (void *) ~0l)

  int pshared = (cond->__data.__mutex == (void *) ~0l)

		? LLL_SHARED : LLL_PRIVATE;

		? LLL_SHARED : LLL_PRIVATE;

  /* Make sure we are alone.  */

  /* Make sure we are alone.  */

  lll_lock (cond->__data.__lock, pshared);

  cond_lock(cond, pshared);

  /* Are there any waiters to be woken?  */

  /* Are there any waiters to be woken?  */

  if (cond->__data.__total_seq > cond->__data.__wakeup_seq)

  if (cond->__data.__total_seq > cond->__data.__wakeup_seq)

Lines 45-80 __pthread_cond_broadcast (cond)	Link Here

      cond->__data.__woken_seq = cond->__data.__total_seq;

      cond->__data.__woken_seq = cond->__data.__total_seq;

      cond->__data.__futex = (unsigned int) cond->__data.__total_seq * 2;

      cond->__data.__futex = (unsigned int) cond->__data.__total_seq * 2;

      int futex_val = cond->__data.__futex;

      int futex_val = cond->__data.__futex;

      pthread_mutex_t *mut = (pthread_mutex_t *) cond->__data.__mutex;

      int err;

      /* Signal that a broadcast happened.  */

      /* Signal that a broadcast happened.  */

      ++cond->__data.__broadcast_seq;

      ++cond->__data.__broadcast_seq;

      /* We are done.  */

      /* We are done.  */

      lll_unlock (cond->__data.__lock, pshared);

      cond_unlock(cond, pshared);

      /* Do not use requeue for pshared condvars.  */

      /* Do not use requeue for pshared condvars.  */

      if (cond->__data.__mutex == (void *) ~0l)

      if (cond->__data.__mutex == (void *) ~0l)

	goto wake_all;

	goto wake_all;

      /* Wake everybody.  */

      /* We don't requeue for pshared condvars  */

      pthread_mutex_t *mut = (pthread_mutex_t *) cond->__data.__mutex;

      /* XXX: Kernel so far doesn't support requeue to PI futex.  */

      /* XXX: Kernel so far can only requeue to the same type of futex,

	 in this case private (we don't requeue for pshared condvars).  */

      if (__builtin_expect (mut->__data.__kind

      if (__builtin_expect (mut->__data.__kind

			    & (PTHREAD_MUTEX_PRIO_INHERIT_NP

			    & PTHREAD_MUTEX_PSHARED_BIT, 0))

			       | PTHREAD_MUTEX_PSHARED_BIT), 0))

 	goto wake_all;

	goto wake_all;

      if (__builtin_expect (mut->__data.__kind

      /* lll_futex_requeue returns 0 for success and non-zero

 			    & PTHREAD_MUTEX_PRIO_INHERIT_NP, 0))

	 for errors.  */

      if (__builtin_expect (lll_futex_requeue (&cond->__data.__futex, 1,

	 /* lll_futex_requeue_pi returns the number of tasks requeue'd on

					       INT_MAX, &mut->__data.__lock,

	    success and negative for errors.  */

					       futex_val, LLL_PRIVATE), 0))

         err = lll_futex_requeue_pi (&cond->__data.__futex, 1, INT_MAX,

				     &mut->__data.__lock, futex_val,

				     LLL_PRIVATE);

	 /* The requeue_pi functionality is not available.  */

	 if (__builtin_expect (err == -ENOSYS, 0))

	   goto wake_all;

      else

	  /* The requeue functionality is not available.  */

	 /* lll_futex_requeue_pi returns the number of tasks requeue'd on

	wake_all:

	    success and negative for errors.  */

	  lll_futex_wake (&cond->__data.__futex, INT_MAX, pshared);

	 err = lll_futex_requeue (&cond->__data.__futex, 1, INT_MAX,

				  &mut->__data.__lock, futex_val,

				  LLL_PRIVATE);

	 if (__builtin_expect (err == -ENOSYS, 0))

	    /* The requeue functionality is not available.  */

	   wake_all:

	    lll_futex_wake (&cond->__data.__futex, INT_MAX, pshared);

      /* That's all.  */

      /* That's all.  */

Lines 82-88 __pthread_cond_broadcast (cond)	Link Here

  /* We are done.  */

  /* We are done.  */

  lll_unlock (cond->__data.__lock, pshared);

100

  cond_unlock(cond, pshared);

101

  return 0;

102

  return 0;

103




/* Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2010
   Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.

  cond->__data.__lock = LLL_LOCK_INITIALIZER;
  cond->__data.__futex = 0;
  cond->__data.__nwaiters = (icond_attr != NULL
			     ? ((icond_attr->value >> CONDATTR_CLOCKID_SHIFT)
				& ((1 << COND_PROTOCOL_SHIFT) - 1))
			     : CLOCK_REALTIME);
  if (icond_attr != NULL)
   {
    switch (icond_attr->value & CONDATTR_PROTOCOL_MASK)
     {
     case PTHREAD_PRIO_INHERIT << CONDATTR_PROTOCOL_SHIFT:
       cond->__data.__nwaiters |= COND_PRIO_INHERIT;
       break;

     case PTHREAD_PRIO_PROTECT << CONDATTR_PROTOCOL_SHIFT:
       cond->__data.__nwaiters |= COND_PRIO_PROTECT;
       break;

     default:
       break;
     }
   }

  cond->__data.__total_seq = 0;
  cond->__data.__wakeup_seq = 0;
  cond->__data.__woken_seq = 0;

(-)a/nptl/pthread_cond_signal.c (-7 / +30 lines)

Lines 27-42	Link Here

#include <shlib-compat.h>

#include <shlib-compat.h>

#include <kernel-features.h>

#include <kernel-features.h>

#include "cond-lock.h"

int

int

__pthread_cond_signal (cond)

__pthread_cond_signal (cond)

     pthread_cond_t *cond;

     pthread_cond_t *cond;

  int pshared = (cond->__data.__mutex == (void *) ~0l)

  int err, futex_val;

		? LLL_SHARED : LLL_PRIVATE;

  pthread_mutex_t *mutex = (pthread_mutex_t *) cond->__data.__mutex;

  int pshared = (mutex == (void *) ~0l) ? LLL_SHARED : LLL_PRIVATE;

  /* Make sure we are alone.  */

  /* Make sure we are alone.  */

  lll_lock (cond->__data.__lock, pshared);

  cond_lock(cond, pshared);

  /* Are there any waiters to be woken?  */

  /* Are there any waiters to be woken?  */

  if (cond->__data.__total_seq > cond->__data.__wakeup_seq)

  if (cond->__data.__total_seq > cond->__data.__wakeup_seq)

Lines 44-61 __pthread_cond_signal (cond)	Link Here

      /* Yes.  Mark one of them as woken.  */

      /* Yes.  Mark one of them as woken.  */

      ++cond->__data.__wakeup_seq;

      ++cond->__data.__wakeup_seq;

      ++cond->__data.__futex;

      ++cond->__data.__futex;

      futex_val = cond->__data.__futex;

      pthread_mutex_t *mut = (pthread_mutex_t *) cond->__data.__mutex;

      /* We dont do requeue-pi for pshared mutexes */

      if (pshared == LLL_PRIVATE &&

	  mut->__data.__kind & PTHREAD_MUTEX_PRIO_INHERIT_NP)

	 /* lll_futex_requeue_pi returns the number of tasks requeue'd on

	    success and negative for errors.  */

         err = lll_futex_requeue_pi (&cond->__data.__futex, 1, 0,

				     &mut->__data.__lock, futex_val,

				     pshared);

	 /* The requeue_pi functionality is not available.  */

	 if (__builtin_expect (err != -ENOSYS, 0))

           goto done;

#if 0

      /* This is not needed for the x86_64 or i686 arches */

      /* Wake one.  */

      /* Wake one.  */

      if (! __builtin_expect (lll_futex_wake_unlock (&cond->__data.__futex, 1,

      else if (! __builtin_expect (lll_futex_wake_unlock (&cond->__data.__futex,

						     1, &cond->__data.__lock,

							  1, 1,

						     pshared), 0))

							  &cond->__data.__lock,

						          pshared), 0))

	return 0;

	return 0;

#endif

      lll_futex_wake (&cond->__data.__futex, 1, pshared);

      lll_futex_wake (&cond->__data.__futex, 1, pshared);

done:

  /* We are done.  */

  /* We are done.  */

  lll_unlock (cond->__data.__lock, pshared);

  cond_unlock(cond, pshared);

  return 0;

  return 0;

(-)a/nptl/pthread_cond_timedwait.c (-9 / +31 lines)

Lines 27-32	Link Here

#include <shlib-compat.h>

#include <shlib-compat.h>

#include "cond-lock.h"

#ifndef HAVE_CLOCK_GETTIME_VSYSCALL

#ifndef HAVE_CLOCK_GETTIME_VSYSCALL

# undef INTERNAL_VSYSCALL

# undef INTERNAL_VSYSCALL

# define INTERNAL_VSYSCALL INTERNAL_SYSCALL

# define INTERNAL_VSYSCALL INTERNAL_SYSCALL

Lines 57-62 __pthread_cond_timedwait (cond, mutex, abstime)	Link Here

  struct _pthread_cleanup_buffer buffer;

  struct _pthread_cleanup_buffer buffer;

  struct _condvar_cleanup_buffer cbuffer;

  struct _condvar_cleanup_buffer cbuffer;

  int result = 0;

  int result = 0;

  int pi_requeued;

  /* Catch invalid parameters.  */

  /* Catch invalid parameters.  */

  if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)

  if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)

Lines 65-78 __pthread_cond_timedwait (cond, mutex, abstime)	Link Here

  int pshared = (cond->__data.__mutex == (void *) ~0l)

  int pshared = (cond->__data.__mutex == (void *) ~0l)

		? LLL_SHARED : LLL_PRIVATE;

		? LLL_SHARED : LLL_PRIVATE;

  /* Make sure we are along.  */

  /* Make sure we are alone.  */

  lll_lock (cond->__data.__lock, pshared);

  cond_lock(cond, pshared);

  /* Now we can release the mutex.  */

  /* Now we can release the mutex.  */

  int err = __pthread_mutex_unlock_usercnt (mutex, 0);

  int err = __pthread_mutex_unlock_usercnt (mutex, 0);

  if (err)

  if (err)

      lll_unlock (cond->__data.__lock, pshared);

      cond_unlock(cond, pshared);

      return err;

      return err;

Lines 105-110 __pthread_cond_timedwait (cond, mutex, abstime)	Link Here

105

108

106

  while (1)

109

  while (1)

107

110

111

      pi_requeued = 0;

108

      struct timespec rt;

112

      struct timespec rt;

109

113

110

#ifdef __NR_clock_gettime

114

#ifdef __NR_clock_gettime

Lines 112-118 __pthread_cond_timedwait (cond, mutex, abstime)	Link Here

112

	int ret;

116

	int ret;

113

	ret = INTERNAL_VSYSCALL (clock_gettime, err, 2,

117

	ret = INTERNAL_VSYSCALL (clock_gettime, err, 2,

114

				(cond->__data.__nwaiters

118

				(cond->__data.__nwaiters

115

				 & ((1 << COND_NWAITERS_SHIFT) - 1)),

119

				 & ((1 << COND_PROTOCOL_SHIFT) - 1)),

116

				&rt);

120

				&rt);

117

# ifndef __ASSUME_POSIX_TIMERS

121

# ifndef __ASSUME_POSIX_TIMERS

118

	if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (ret, err), 0))

122

	if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (ret, err), 0))

Lines 158-177 __pthread_cond_timedwait (cond, mutex, abstime)	Link Here

158

      unsigned int futex_val = cond->__data.__futex;

162

      unsigned int futex_val = cond->__data.__futex;

159

163

160

      /* Prepare to wait.  Release the condvar futex.  */

164

      /* Prepare to wait.  Release the condvar futex.  */

161

      lll_unlock (cond->__data.__lock, pshared);

165

      cond_unlock(cond, pshared);

162

166

163

      /* Enable asynchronous cancellation.  Required by the standard.  */

167

      /* Enable asynchronous cancellation.  Required by the standard.  */

164

      cbuffer.oldtype = __pthread_enable_asynccancel ();

168

      cbuffer.oldtype = __pthread_enable_asynccancel ();

165

169

170

      if (mutex->__data.__kind & PTHREAD_MUTEX_PRIO_INHERIT_NP)

171

172

	  /* Try requeueing to the PI mutex, if no support in the kernel

173

	     try the non-requeue syscall.  */

174

          err = lll_futex_timed_wait_requeue_pi (cond, futex_val, abstime,

175

						 &mutex->__data.__lock,

176

						 pshared);

177

          if (__builtin_expect (!err, 1))

178

	       pi_requeued = 1;

179

          if (__builtin_expect (err != -ENOSYS, 0))

180

	       goto woken;

181

182

166

      /* Wait until woken by signal or broadcast.  */

183

      /* Wait until woken by signal or broadcast.  */

167

      err = lll_futex_timed_wait (&cond->__data.__futex,

184

      err = lll_futex_timed_wait (&cond->__data.__futex,

168

				  futex_val, &rt, pshared);

185

				  futex_val, &rt, pshared);

169

186

187

woken:

170

      /* Disable asynchronous cancellation.  */

188

      /* Disable asynchronous cancellation.  */

171

      __pthread_disable_asynccancel (cbuffer.oldtype);

189

      __pthread_disable_asynccancel (cbuffer.oldtype);

172

190

173

      /* We are going to look at shared data again, so get the lock.  */

191

      /* We are going to look at shared data again, so get the lock.  */

174

      lll_lock (cond->__data.__lock, pshared);

192

      cond_lock(cond, pshared);

175

193

176

      /* If a broadcast happened, we are done.  */

194

      /* If a broadcast happened, we are done.  */

177

      if (cbuffer.bc_seq != cond->__data.__broadcast_seq)

195

      if (cbuffer.bc_seq != cond->__data.__broadcast_seq)

Lines 211-223 __pthread_cond_timedwait (cond, mutex, abstime)	Link Here

211

    lll_futex_wake (&cond->__data.__nwaiters, 1, pshared);

229

    lll_futex_wake (&cond->__data.__nwaiters, 1, pshared);

212

230

213

  /* We are done with the condvar.  */

231

  /* We are done with the condvar.  */

214

  lll_unlock (cond->__data.__lock, pshared);

232

  cond_unlock(cond, pshared);

215

233

216

  /* The cancellation handling is back to normal, remove the handler.  */

234

  /* The cancellation handling is back to normal, remove the handler.  */

217

  __pthread_cleanup_pop (&buffer, 0);

235

  __pthread_cleanup_pop (&buffer, 0);

218

236

219

  /* Get the mutex before returning.  */

237

  /* Get the mutex before returning. If the requeue_pi call above was successful,

220

  err = __pthread_mutex_cond_lock (mutex);

238

     the lock is already held in the kernel, so just return to the application.  */

239

  if (pi_requeued)

240

    __pthread_mutex_cond_lock_adjust (mutex);

241

  else

242

    err = __pthread_mutex_cond_lock (mutex);

221

243

222

  return err ?: result;

244

  return err ?: result;

223

245

(-)a/nptl/pthread_cond_wait.c (-12 / +77 lines)

Lines 17-31	Link Here

   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

   02111-1307 USA.  */

   02111-1307 USA.  */

#include <assert.h>

#include <endian.h>

#include <endian.h>

#include <errno.h>

#include <errno.h>

#include <sysdep.h>

#include <sysdep.h>

#include <lowlevellock.h>

#include <lowlevellock.h>

#include <not-cancel.h>

#include <pthread.h>

#include <pthread.h>

#include <pthreadP.h>

#include <pthreadP.h>

#include <shlib-compat.h>

#include <shlib-compat.h>

#include "cond-lock.h"

struct _condvar_cleanup_buffer

struct _condvar_cleanup_buffer

Lines 38-53 struct _condvar_cleanup_buffer	Link Here

void

void

__attribute__ ((visibility ("hidden")))

__attribute__ ((visibility ("hidden")))

lll_pi_lock(int *futexp, int private)

  pid_t id = THREAD_GETMEM (THREAD_SELF, tid);

  int newval = id;

  int ret;

  newval |= FUTEX_WAITERS;

  ret = atomic_compare_and_exchange_val_acq (futexp, newval, 0);

  if (ret != 0)

      /* The mutex is locked.  The kernel will now take care of

	 everything.  */

      INTERNAL_SYSCALL_DECL (__err);

      int e = INTERNAL_SYSCALL (futex, __err, 4, futexp,

				__lll_private_flag (FUTEX_LOCK_PI, private),

				1, 0);

void

__attribute__ ((visibility ("hidden")))

lll_pi_unlock(int *futexp, int private)

  if ((*futexp & FUTEX_WAITERS) != 0

      || atomic_compare_and_exchange_bool_acq (futexp, 0,

					       THREAD_GETMEM (THREAD_SELF,

							      tid)))

      INTERNAL_SYSCALL_DECL (__err);

      INTERNAL_SYSCALL (futex, __err, 2, futexp,

			__lll_private_flag (FUTEX_UNLOCK_PI, private));

void

__attribute__ ((visibility ("hidden")))

__condvar_cleanup (void *arg)

__condvar_cleanup (void *arg)

  struct _condvar_cleanup_buffer *cbuffer =

  struct _condvar_cleanup_buffer *cbuffer =

    (struct _condvar_cleanup_buffer *) arg;

    (struct _condvar_cleanup_buffer *) arg;

  unsigned int destroying;

  unsigned int destroying;

  int pshared = (cbuffer->cond->__data.__mutex == (void *) ~0l)

  int pshared = (cbuffer->mutex == (void *) ~0l) ? LLL_SHARED : LLL_PRIVATE;

  		? LLL_SHARED : LLL_PRIVATE;

  /* We are going to modify shared data.  */

  /* We are going to modify shared data.  */

  lll_lock (cbuffer->cond->__data.__lock, pshared);

  cond_lock(cbuffer->cond, pshared);

  if (cbuffer->bc_seq == cbuffer->cond->__data.__broadcast_seq)

  if (cbuffer->bc_seq == cbuffer->cond->__data.__broadcast_seq)

Lines 78-84 __condvar_cleanup (void *arg)	Link Here

121

122

  /* We are done.  */

123

  /* We are done.  */

  lll_unlock (cbuffer->cond->__data.__lock, pshared);

124

  cond_unlock(cbuffer->cond, pshared);

125

  /* Wake everybody to make sure no condvar signal gets lost.  */

126

  /* Wake everybody to make sure no condvar signal gets lost.  */

  if (! destroying)

127

  if (! destroying)

Lines 97-114 __pthread_cond_wait (cond, mutex)	Link Here

140

  struct _pthread_cleanup_buffer buffer;

141

  struct _pthread_cleanup_buffer buffer;

  struct _condvar_cleanup_buffer cbuffer;

142

  struct _condvar_cleanup_buffer cbuffer;

100

  int err;

101

  int pshared = (cond->__data.__mutex == (void *) ~0l)

143

  int pshared = (cond->__data.__mutex == (void *) ~0l)

102

  		? LLL_SHARED : LLL_PRIVATE;

144

  		? LLL_SHARED : LLL_PRIVATE;

145

  int pi_requeued;

146

  int err;

103

147

104

  /* Make sure we are along.  */

148

  /* Make sure we are along.  */

105

  lll_lock (cond->__data.__lock, pshared);

149

  cond_lock(cond, pshared);

106

150

107

  /* Now we can release the mutex.  */

151

  /* Now we can release the mutex.  */

108

  err = __pthread_mutex_unlock_usercnt (mutex, 0);

152

  err = __pthread_mutex_unlock_usercnt (mutex, 0);

109

  if (__builtin_expect (err, 0))

153

  if (__builtin_expect (err, 0))

110

154

111

      lll_unlock (cond->__data.__lock, pshared);

155

      cond_unlock(cond, pshared);

112

      return err;

156

      return err;

113

157

114

158

Lines 142-162 __pthread_cond_wait (cond, mutex)	Link Here

142

do

186

do

143

187

144

      unsigned int futex_val = cond->__data.__futex;

188

      unsigned int futex_val = cond->__data.__futex;

189

      pi_requeued = 0;

145

190

146

      /* Prepare to wait.  Release the condvar futex.  */

191

      /* Prepare to wait.  Release the condvar futex.  */

147

      lll_unlock (cond->__data.__lock, pshared);

192

      cond_unlock(cond, pshared);

148

193

149

      /* Enable asynchronous cancellation.  Required by the standard.  */

194

      /* Enable asynchronous cancellation.  Required by the standard.  */

150

      cbuffer.oldtype = __pthread_enable_asynccancel ();

195

      cbuffer.oldtype = __pthread_enable_asynccancel ();

151

196

197

      if (mutex->__data.__kind & PTHREAD_MUTEX_PRIO_INHERIT_NP)

198

199

	  /* Try requeueing to the PI mutex, if no support in the kernel

200

             try the non-requeue syscall.  */

201

          err = lll_futex_wait_requeue_pi (cond, futex_val,

202

					   &mutex->__data.__lock, pshared);

203

          if (__builtin_expect (!err, 1))

204

	       pi_requeued = 1;

205

          if (__builtin_expect (err != -ENOSYS, 0))

206

	       goto woken;

207

208

152

      /* Wait until woken by signal or broadcast.  */

209

      /* Wait until woken by signal or broadcast.  */

153

      lll_futex_wait (&cond->__data.__futex, futex_val, pshared);

210

      lll_futex_wait (&cond->__data.__futex, futex_val, pshared);

154

211

212

woken:

155

      /* Disable asynchronous cancellation.  */

213

      /* Disable asynchronous cancellation.  */

156

      __pthread_disable_asynccancel (cbuffer.oldtype);

214

      __pthread_disable_asynccancel (cbuffer.oldtype);

157

215

158

      /* We are going to look at shared data again, so get the lock.  */

216

      /* We are going to look at shared data again, so get the lock.  */

159

      lll_lock (cond->__data.__lock, pshared);

217

      cond_lock(cond, pshared);

160

218

161

      /* If a broadcast happened, we are done.  */

219

      /* If a broadcast happened, we are done.  */

162

      if (cbuffer.bc_seq != cond->__data.__broadcast_seq)

220

      if (cbuffer.bc_seq != cond->__data.__broadcast_seq)

Lines 182-194 __pthread_cond_wait (cond, mutex)	Link Here

182

    lll_futex_wake (&cond->__data.__nwaiters, 1, pshared);

240

    lll_futex_wake (&cond->__data.__nwaiters, 1, pshared);

183

241

184

  /* We are done with the condvar.  */

242

  /* We are done with the condvar.  */

185

  lll_unlock (cond->__data.__lock, pshared);

243

  cond_unlock(cond, pshared);

186

244

187

  /* The cancellation handling is back to normal, remove the handler.  */

245

  /* The cancellation handling is back to normal, remove the handler.  */

188

  __pthread_cleanup_pop (&buffer, 0);

246

  __pthread_cleanup_pop (&buffer, 0);

189

247

190

  /* Get the mutex before returning.  */

248

  /* Get the mutex before returning. If the requeue_pi call above was successful,

191

  return __pthread_mutex_cond_lock (mutex);

249

     the lock is already held in the kernel, so just return 0 to application.  */

250

  if (pi_requeued)

251

252

      __pthread_mutex_cond_lock_adjust (mutex);

253

      return 0;

254

255

  else

256

    return __pthread_mutex_cond_lock (mutex);

192

257

193

258

194

versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,

259

versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,

(-)a/nptl/pthread_condattr_getclock.c (-3 / +4 lines)

Lines 1-4	Link Here

/* Copyright (C) 2003, 2004, 2007 Free Software Foundation, Inc.

/* Copyright (C) 2003,2004,2007,2010 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   This file is part of the GNU C Library.

   Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.

   Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.

Lines 25-31 pthread_condattr_getclock (attr, clock_id)	Link Here

     const pthread_condattr_t *attr;

     const pthread_condattr_t *attr;

     clockid_t *clock_id;

     clockid_t *clock_id;

  *clock_id = (((((const struct pthread_condattr *) attr)->value) >> 1)

  *clock_id = (((((const struct pthread_condattr *) attr)->value)

	       & ((1 << COND_NWAITERS_SHIFT) - 1));

	       >> CONDATTR_CLOCKID_SHIFT)

	       & ((1 << COND_PROTOCOL_SHIFT) - 1));

  return 0;

  return 0;




/* Copyright (C) 2010 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Dinakar Guniguntala <dino@in.ibm.com>, 2010.

   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; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include "pthreadP.h"


int
pthread_condattr_getprotocol_np (attr, protocol)
     const pthread_condattr_t *attr;
     int *protocol;
{
  *protocol = ((const struct pthread_condattr *) attr)->value;

  *protocol = ((*protocol & CONDATTR_PROTOCOL_MASK)
	       >> CONDATTR_PROTOCOL_SHIFT);

  return 0;
}

(-)a/nptl/pthread_condattr_setclock.c (-3 / +3 lines)

Lines 1-4	Link Here

/* Copyright (C) 2003, 2004, 2007, 2008 Free Software Foundation, Inc.

/* Copyright (C) 2003,2004,2007,2008,2010 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   This file is part of the GNU C Library.

   Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.

   Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.

Lines 62-72 pthread_condattr_setclock (attr, clock_id)	Link Here

    return EINVAL;

    return EINVAL;

  /* Make sure the value fits in the bits we reserved.  */

  /* Make sure the value fits in the bits we reserved.  */

  assert (clock_id < (1 << COND_NWAITERS_SHIFT));

  assert (clock_id < (1 << COND_PROTOCOL_SHIFT));

  int *valuep = &((struct pthread_condattr *) attr)->value;

  int *valuep = &((struct pthread_condattr *) attr)->value;

  *valuep = ((*valuep & ~(((1 << COND_NWAITERS_SHIFT) - 1) << 1))

  *valuep = ((*valuep & ~(((1 << COND_PROTOCOL_SHIFT) - 1) << 1))

	     | (clock_id << 1));

	     | (clock_id << 1));

  return 0;

  return 0;




/* Copyright (C) 2010 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Dinakar Guniguntala <dino@in.ibm.com>, 2010.

   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; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include <errno.h>
#include <pthreadP.h>

int
pthread_condattr_setprotocol_np (attr, protocol)
     pthread_condattr_t *attr;
     int protocol;
{
  if (protocol != PTHREAD_PRIO_NONE
      && protocol != PTHREAD_PRIO_INHERIT
      && __builtin_expect (protocol != PTHREAD_PRIO_PROTECT, 0))
    return EINVAL;

  int *valuep = &((struct pthread_condattr *) attr)->value;

  *valuep = ((*valuep & ~CONDATTR_PROTOCOL_MASK)
	     | (protocol << CONDATTR_PROTOCOL_SHIFT));

  return 0;
}




/* Copyright (C) 2010 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
   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; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#ifndef _COND_LOCK_H
#define _COND_LOCK_H 1


extern void lll_pi_lock (int *futex, int pshared)
     __attribute__ ((visibility ("hidden")));
extern void lll_pi_unlock (int *futex, int pshared)
     __attribute__ ((visibility ("hidden")));

static inline void cond_lock(pthread_cond_t *cond,
			     int pshared);

static inline void cond_unlock(pthread_cond_t *cond,
			       int pshared);

static inline void cond_lock(cond, pshared)
     pthread_cond_t *cond;
     int pshared;
{
  if (pshared == LLL_PRIVATE
      && ((cond->__data.__nwaiters & COND_PROTOCOL_MASK)
	  == COND_PRIO_INHERIT))
    lll_pi_lock (&cond->__data.__lock, pshared);
  else
    lll_lock (cond->__data.__lock, pshared);
}

static inline void cond_unlock(cond, pshared)
     pthread_cond_t *cond;
     int pshared;
{
  if (pshared == LLL_PRIVATE
      && ((cond->__data.__nwaiters & COND_PROTOCOL_MASK)
	  == COND_PRIO_INHERIT))
    lll_pi_unlock (&cond->__data.__lock, pshared);
  else
    lll_unlock (cond->__data.__lock, pshared);
}
 
#endif




extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
					int __pshared) __THROW __nonnull ((1));

/* Get the protocol flag of the condition variable attribute ATTR.  */
extern int pthread_condattr_getprotocol_np (__const pthread_condattr_t *
                                            __restrict __attr,
                                            int *__restrict __protocol)
     __THROW __nonnull ((1, 2));

/* Set the cond protocol attribute in ATTR to protocol (one of
   PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT or PTHREAD_PRIO_PROTECT).  */
extern int pthread_condattr_setprotocol_np (pthread_condattr_t *__attr,
                                            int __protocol)
     __THROW __nonnull ((1));

#ifdef __USE_XOPEN2K
/* Get the clock selected for the conditon variable attribute ATTR.  */
extern int pthread_condattr_getclock (__const pthread_condattr_t *




/* Copyright (C) 2002,2003,2004,2006,2007,2008,2010
   Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.


  } while (0)


#define lll_futex_wait_requeue_pi(cond, val, mutex, private) \
  lll_futex_timed_wait_requeue_pi (cond, val, NULL, mutex, private)


#define lll_futex_timed_wait_requeue_pi(cond, val, time, mutex, private) \
  ({									      \
    INTERNAL_SYSCALL_DECL (__err);					      \
    long int __ret;							      \
    unsigned int *__futexp = &cond->__data.__futex;			      \
    int __flag = FUTEX_WAIT_REQUEUE_PI;					      \
    __flag = (cond->__data.__nwaiters & COND_CLOCK_MASK) ?		      \
	      __flag  : __flag | FUTEX_CLOCK_REALTIME;			      \
    __ret = INTERNAL_SYSCALL (futex, __err, 5,				      \
			      (__futexp),				      \
			      __lll_private_flag (__flag, private),	      \
			      (val), time,				      \
			      (mutex));					      \
    INTERNAL_SYSCALL_ERROR_P (__ret, __err)? -__ret : __ret;		      \
  })


#define lll_futex_requeue(futex, nr_wake, nr_move, mutex, val, private) \
  ({									      \
    int __status;							      \
    int __save_ebx;							      \
    int __dummy;							      \
    int __flag = FUTEX_CMP_REQUEUE;					      \
    register __typeof (nr_move) _nr_move asm ("esi") = (nr_move);	      \
    __asm __volatile ("mov %%ebx, %0\n\t"				      \
		      "mov %1, %%ebx\n\t"				      \
		      LLL_EBX_LOAD					      \
		      "pushl %%ebp\n\t"					      \
		      "mov %3, %%ebp\n\t"				      \
		      : "=m" (__save_ebx)				      \
		      : "c" (mutex), LLL_EBX_REG (futex),		      \
		        "a" (val));					      \
    __asm __volatile (LLL_ENTER_KERNEL					      \
		      "popl %%ebp\n\t"					      \
		      : "=a" (__status)					      \
		      : "0" (SYS_futex), 				      \
			"c" (__lll_private_flag (__flag, private)),	      \
			"d" (nr_wake), "S" (_nr_move),			      \
			"i" (0) /* phony, to align next arg's number */,      \
			"i" (offsetof (tcbhead_t, sysinfo))		      \
		      : "memory");					      \
    __asm __volatile (LLL_EBX_LOAD					      \
		      "mov %1, %%ebx\n\t"				      \
		      : "=m" (__dummy)					      \
		      : "m" (__save_ebx), LLL_EBX_REG (futex));		      \
    __status;								      \
  })


#define lll_futex_requeue_pi(futex, nr_wake, nr_move, mutex, val, private) \
  ({									      \
    int __status;							      \
    int __save_ebx;							      \
    int __dummy;							      \
    int __flag = FUTEX_CMP_REQUEUE_PI;					      \
    register __typeof (nr_move) _nr_move asm ("esi") = (nr_move);	      \
    __asm __volatile ("mov %%ebx, %0\n\t"				      \
		      "mov %1, %%ebx\n\t"				      \
		      LLL_EBX_LOAD					      \
		      "pushl %%ebp\n\t"					      \
		      "mov %3, %%ebp\n\t"				      \
		      : "=m" (__save_ebx)				      \
		      : "c" (mutex), LLL_EBX_REG (futex),		      \
		        "a" (val));					      \
    __asm __volatile (LLL_ENTER_KERNEL					      \
		      "popl %%ebp\n\t"					      \
		      : "=a" (__status)					      \
		      : "0" (SYS_futex), 				      \
			"c" (__lll_private_flag (__flag, private)),	      \
			"d" (nr_wake), "S" (_nr_move),			      \
			"i" (0) /* phony, to align next arg's number */,      \
			"i" (offsetof (tcbhead_t, sysinfo))		      \
		      : "memory");					      \
    __asm __volatile (LLL_EBX_LOAD					      \
		      "mov %1, %%ebx\n\t"				      \
		      : "=m" (__dummy)					      \
		      : "m" (__save_ebx), LLL_EBX_REG (futex));		      \
    __status;								      \
  })


/* NB: in the lll_trylock macro we simply return the value in %eax
   after the cmpxchg instruction.  In case the operation succeded this
   value is zero.  In case the operation failed, the cmpxchg instruction




{
  /* Combination of values:

     Bit 0  : flag whether conditional variable will be shareable between
	      processes.

     Bit 1-7: clock ID.
     Bit 8-9: protocol. One of PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT
              or PTHREAD_PRIO_PROTECT.  */
  int value;
};


#define CONDATTR_PSHARED_MASK	0x00000001
#define CONDATTR_CLOCKID_MASK	0x000000FE
#define CONDATTR_CLOCKID_SHIFT	1
#define CONDATTR_PROTOCOL_MASK	0x00000300
#define CONDATTR_PROTOCOL_SHIFT	8


enum {
  COND_PRIO_INHERIT = 2,
  COND_PRIO_PROTECT
};


/* The __NWAITERS field is used as a counter and to house the number
   of bits for other purposes.  COND_CLOCK_MASK defines the bits used
   to represent the ID of the clock.  COND_PROTOCOL_MASK defines the
   bits used to represent cond protocol attrbutes. COND_NWAITERS_SHIFT
   is the number of bits reserved for other purposes like the clock.  */
#define COND_CLOCK_MASK		0x00000001
#define COND_PROTOCOL_SHIFT	1
#define COND_PROTOCOL_MASK	0x00000006
#define COND_NWAITERS_SHIFT	3


/* Read-write lock variable attribute data structure.  */




  })


#define lll_futex_wait_requeue_pi(cond, val, mutex, private) \
  lll_futex_timed_wait_requeue_pi(cond, val, NULL, mutex, private)


#define lll_futex_timed_wait_requeue_pi(cond, val, timeout, mutex, private) \
  ({									      \
    register const struct timespec *__to __asm ("r10") = timeout;	      \
    register void *__mutex __asm  ("r8") = mutex;			      \
    unsigned int *__futexp = &cond->__data.__futex;			      \
    int __flag = FUTEX_WAIT_REQUEUE_PI;					      \
    __flag = (cond->__data.__nwaiters & COND_CLOCK_MASK) ?		      \
		      __flag  : __flag | FUTEX_CLOCK_REALTIME;		      \
    int __status;							      \
    register __typeof (val) _val __asm ("edx") = (val);			      \
    __asm __volatile ("syscall"						      \
		      : "=a" (__status)					      \
		      : "0" (SYS_futex), "D" (__futexp),		      \
			"S" (__lll_private_flag (__flag, private)),	      \
			"d" (_val), "r" (__to),				      \
			"r" (__mutex)					      \
		      : "memory", "cc", "r11", "cx");			      \
    __status;								      \
  })


#define lll_futex_wake(futex, nr, private) \
  do {									      \
    int __ignore;							      \

		       : "cx", "r11", "cc", "memory");			      \
     __res < 0; })

/* Returns non-zero if error happened, zero if success.  */
#define lll_futex_requeue_pi(ftx, nr_wake, nr_move, mutex, val, private) \
  ({ int __res;								      \
     register int __nr_move __asm ("r10") = nr_move;			      \
     register void *__mutex __asm ("r8") = mutex;			      \
     register int __val __asm ("r9") = val;				      \
     __asm __volatile ("syscall"					      \
		       : "=a" (__res)					      \
		       : "0" (__NR_futex), "D" ((void *) ftx),		      \
			 "S" (__lll_private_flag (FUTEX_CMP_REQUEUE_PI,	      \
						  private)), "d" (nr_wake),   \
			 "r" (__nr_move), "r" (__mutex), "r" (__val)	      \
		       : "cx", "r11", "cc", "memory");			      \
     __res < 0; })

#define lll_islocked(futex) \
  (futex != LLL_LOCK_INITIALIZER)

- 

Return to bug 11588