##--------------------------------------------------------------------##

##--- Support for doing system calls.                              ---##

##---                                                 vg_syscall.S ---##

##--------------------------------------------------------------------##

/*

  This file is part of Valgrind, an extensible x86 protected-mode

  emulator for monitoring program execution on x86-Unixes.

  Copyright (C) 2000-2004 Julian Seward 

     jseward@acm.org

  This program is free software; you can redistribute it and/or

  modify it under the terms of the GNU General Public License as

  published by the Free Software Foundation; either version 2 of the

  License, or (at your option) any later version.

  This program 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

  General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with this program; if not, write to the Free Software

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

  02111-1307, USA.

  The GNU General Public License is contained in the file COPYING.

*/

#include "vg_constants.h"

#include "vg_unistd.h"

.globl	VG_(do_syscall)

/*

	Perform a Linux syscall with int 0x80

	Syscall args are passed on the stack

	Int VG_(do_syscall)(Int syscall_no, ...)

	This has no effect on the virtual machine; the expectation is

	that the syscall mechanism makes no useful changes to any

	register except %eax, which is returned.

 */

VG_(do_syscall):

	pop	%ecx

	pop	%eax

	push	%ecx

	int	$0x80

	push	%ecx

	jae	1f

	movl	$-1,%eax

1:

	ret

/*

	Perform a FreeBSD syscall with int 0x80, returning error flag

	Syscall args are passed on the stack

	Int VG_(do_syscall_err)(Int syscall_no, UInt edx, UInt* eflags, ...)

	This has no effect on the virtual machine; the expectation is

	that the syscall mechanism makes no useful changes to any

	register except %eax and %edx, which are returned.

 */

.globl	VG_(do_syscall_err)

VG_(do_syscall_err):

	movl	12(%esp),%ecx

	andb	$254,(%ecx)

	movl	(%esp),%eax

	movl	%eax,12(%esp)

	movl	4(%esp),%eax

	movl	8(%esp),%edx

	addl	$12,%esp

	int	$0x80

	jae	1f

	orb	$1,(%ecx)

1:

	movl	(%esp),%ecx

	push	%ecx

	push	%ecx

	push	%ecx

	ret

/*

	Perform a clone system call.  clone is strange because it has

	fork()-like return-twice semantics, so it needs special

	handling here.

	int VG_(clone)(int (*fn)(void *), void *child_stack, int flags, void *arg, 

	               0                  4                  8          12

		       pid_t *child_tid, pid_t *parent_tid)

		       16                20

 */

.globl VG_(clone)

VG_(clone):

	ret

/*

 *                8      12          16         20

 * rfork_thread(flags, stack_addr, start_fnc, start_arg);

 *

 * flags:		Flags to rfork system call.  See rfork(2).

 * stack_addr:		Top of stack for thread.

 * start_fnc:		Address of thread function to call in child.

 * start_arg:		Argument to pass to the thread function in child.

 */

.globl VG_(rfork_thread)

VG_(rfork_thread):

	pushl	%ebp

	movl	%esp, %ebp

	pushl	%esi

	/*

	 * Push thread info onto the new thread's stack

	 */

	movl	12(%ebp), %esi	# get stack addr

	subl	$4, %esi

	movl	20(%ebp), %eax	# get start argument

	movl	%eax, (%esi)

	subl	$4, %esi

	movl	16(%ebp), %eax	# get start thread address

	movl	%eax, (%esi)

	/*

	 * Prepare and execute the thread creation syscall

	 */

	pushl	8(%ebp)

	pushl	$0

	movl	$__NR_rfork, %eax

	int	$0x80

	jb 	2f

	/*

	 * Check to see if we are in the parent or child

	 */

	cmpl	$0, %edx

	jnz	1f

	addl	$8, %esp

	popl	%esi

	movl	%ebp, %esp

	popl	%ebp

	ret

	.p2align 2

	/*

	 * If we are in the child (new thread), then

	 * set-up the call to the internal subroutine.  If it

	 * returns, then call __exit.

	 */

1:

	movl	%esi,%esp

	popl	%eax

	call	*%eax

	addl	$4, %esp

	/*

	 * Exit system call

	 */

	pushl	%eax

	pushl	$0

	movl	$__NR_exit, %eax

	int	$0x80

	/*

	 * Branch here if the thread creation fails:

	 */

2:

	movl	$-1,%eax

	ret

.globl VG_(pipe)

VG_(pipe):

	mov	$__NR_pipe,%eax

	int	$0x80

	jb	1f

	movl	4(%esp),%ecx

	movl	%eax,(%ecx)

	movl	%edx,4(%ecx)

	movl	$0,%eax

	ret

1:

	negl	%eax

	ret

##--------------------------------------------------------------------##

##--- end                                             vg_syscall.S ---##

##--------------------------------------------------------------------##

Makefile.in

Makefile

/.cvsignore/1.1/Sat Jan  3 15:21:14 2004//

/Makefile.am/1.1/Sat Jan  3 15:21:14 2004//

/vg_libpthread.c/1.143/Sun Jan  4 16:43:21 2004//

/vg_libpthread_unimp.c/1.43/Sun Jan  4 16:43:21 2004//

/vg_syscall.S/1.11/Sun Jan  4 16:43:21 2004//

D

valgrind/coregrind/arch/x86-linux

:pserver:anonymous@anoncvs.kde.org:/home/kde

# Makefile.in generated by automake 1.8.2 from Makefile.am.

# @configure_input@

# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,

# 2003, 2004  Free Software Foundation, Inc.

# This Makefile.in is free software; the Free Software Foundation

# gives unlimited permission to copy and/or distribute it,

# with or without modifications, as long as this notice is preserved.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY, to the extent permitted by law; without

# even the implied warranty of MERCHANTABILITY or FITNESS FOR A

# PARTICULAR PURPOSE.

@SET_MAKE@

srcdir = @srcdir@

top_srcdir = @top_srcdir@

VPATH = @srcdir@

pkgdatadir = $(datadir)/@PACKAGE@

pkglibdir = $(libdir)/@PACKAGE@

pkgincludedir = $(includedir)/@PACKAGE@

top_builddir = ../../..

am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd

INSTALL = @INSTALL@

install_sh_DATA = $(install_sh) -c -m 644

install_sh_PROGRAM = $(install_sh) -c

install_sh_SCRIPT = $(install_sh) -c

INSTALL_HEADER = $(INSTALL_DATA)

transform = $(program_transform_name)

NORMAL_INSTALL = :

PRE_INSTALL = :

POST_INSTALL = :

NORMAL_UNINSTALL = :

PRE_UNINSTALL = :

POST_UNINSTALL = :

host_triplet = @host@

subdir = coregrind/arch/x86-linux

DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in

ACLOCAL_M4 = $(top_srcdir)/aclocal.m4

am__aclocal_m4_deps = $(top_srcdir)/configure.in

am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

	$(ACLOCAL_M4)

mkinstalldirs = $(mkdir_p)

CONFIG_HEADER = $(top_builddir)/config.h

CONFIG_CLEAN_FILES =

SOURCES =

DIST_SOURCES =

DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

ACLOCAL = @ACLOCAL@

AMDEP_FALSE = @AMDEP_FALSE@

AMDEP_TRUE = @AMDEP_TRUE@

AMTAR = @AMTAR@

AUTOCONF = @AUTOCONF@

AUTOHEADER = @AUTOHEADER@

AUTOMAKE = @AUTOMAKE@

AWK = @AWK@

CC = @CC@

CCAS = @CCAS@

CCASFLAGS = @CCASFLAGS@

CCDEPMODE = @CCDEPMODE@

CFLAGS = @CFLAGS@

CPP = @CPP@

CPPFLAGS = @CPPFLAGS@

CXX = @CXX@

CXXDEPMODE = @CXXDEPMODE@

CXXFLAGS = @CXXFLAGS@

CYGPATH_W = @CYGPATH_W@

DEFAULT_SUPP = @DEFAULT_SUPP@

DEFS = @DEFS@

DEPDIR = @DEPDIR@

ECHO_C = @ECHO_C@

ECHO_N = @ECHO_N@

ECHO_T = @ECHO_T@

EGREP = @EGREP@

EXEEXT = @EXEEXT@

GDB = @GDB@

INSTALL_DATA = @INSTALL_DATA@

INSTALL_PROGRAM = @INSTALL_PROGRAM@

INSTALL_SCRIPT = @INSTALL_SCRIPT@

INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@

LDFLAGS = @LDFLAGS@

LIBOBJS = @LIBOBJS@

LIBS = @LIBS@

LN_S = @LN_S@

LTLIBOBJS = @LTLIBOBJS@

MAINT = @MAINT@

MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@

MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@

MAKEINFO = @MAKEINFO@

OBJEXT = @OBJEXT@

PACKAGE = @PACKAGE@

PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@

PACKAGE_NAME = @PACKAGE_NAME@

PACKAGE_STRING = @PACKAGE_STRING@

PACKAGE_TARNAME = @PACKAGE_TARNAME@

PACKAGE_VERSION = @PACKAGE_VERSION@

PATH_SEPARATOR = @PATH_SEPARATOR@

PERL = @PERL@

PREFERRED_STACK_BOUNDARY = @PREFERRED_STACK_BOUNDARY@

RANLIB = @RANLIB@

SET_MAKE = @SET_MAKE@

SHELL = @SHELL@

STRIP = @STRIP@

VERSION = @VERSION@

VG_PLATFORM = @VG_PLATFORM@

ac_ct_CC = @ac_ct_CC@

ac_ct_CXX = @ac_ct_CXX@

ac_ct_RANLIB = @ac_ct_RANLIB@

ac_ct_STRIP = @ac_ct_STRIP@

am__fastdepCC_FALSE = @am__fastdepCC_FALSE@

am__fastdepCC_TRUE = @am__fastdepCC_TRUE@

am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@

am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@

am__include = @am__include@

am__leading_dot = @am__leading_dot@

am__quote = @am__quote@

bindir = @bindir@

build = @build@

build_alias = @build_alias@

build_cpu = @build_cpu@

build_os = @build_os@

build_vendor = @build_vendor@

datadir = @datadir@

exec_prefix = @exec_prefix@

host = @host@

host_alias = @host_alias@

host_cpu = @host_cpu@

host_os = @host_os@

host_vendor = @host_vendor@

includedir = @includedir@

infodir = @infodir@

install_sh = @install_sh@

libdir = @libdir@

libexecdir = @libexecdir@

localstatedir = @localstatedir@

mandir = @mandir@

mkdir_p = @mkdir_p@

oldincludedir = @oldincludedir@

prefix = @prefix@

program_transform_name = @program_transform_name@

sbindir = @sbindir@

sharedstatedir = @sharedstatedir@

sysconfdir = @sysconfdir@

target_alias = @target_alias@

all: all-am

.SUFFIXES:

$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)

	@for dep in $?; do \

	  case '$(am__configure_deps)' in \

	    *$$dep*) \

	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \

		&& exit 0; \

	      exit 1;; \

	  esac; \

	done; \

	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  coregrind/arch/x86-linux/Makefile'; \

	cd $(top_srcdir) && \

	  $(AUTOMAKE) --gnu  coregrind/arch/x86-linux/Makefile

.PRECIOUS: Makefile

Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status

	@case '$?' in \

	  *config.status*) \

	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \

	  *) \

	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \

	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \

	esac;

$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)

	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh

$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)

	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh

$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)

	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh

uninstall-info-am:

tags: TAGS

TAGS:

ctags: CTAGS

CTAGS:

distdir: $(DISTFILES)

	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \

	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \

	list='$(DISTFILES)'; for file in $$list; do \

	  case $$file in \

	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \

	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \

	  esac; \

	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \

	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \

	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \

	    dir="/$$dir"; \

	    $(mkdir_p) "$(distdir)$$dir"; \

	  else \

	    dir=''; \

	  fi; \

	  if test -d $$d/$$file; then \

	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \

	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \

	    fi; \

	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \

	  else \

	    test -f $(distdir)/$$file \

	    || cp -p $$d/$$file $(distdir)/$$file \

	    || exit 1; \

	  fi; \

	done

check-am: all-am

check: check-am

all-am: Makefile

installdirs:

install: install-am

install-exec: install-exec-am

install-data: install-data-am

uninstall: uninstall-am

install-am: all-am

	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am

installcheck: installcheck-am

install-strip:

	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \

	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \

	  `test -z '$(STRIP)' || \

	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install

mostlyclean-generic:

clean-generic:

distclean-generic:

	-rm -f $(CONFIG_CLEAN_FILES)

maintainer-clean-generic:

	@echo "This command is intended for maintainers to use"

	@echo "it deletes files that may require special tools to rebuild."

clean: clean-am

clean-am: clean-generic mostlyclean-am

distclean: distclean-am

	-rm -f Makefile

distclean-am: clean-am distclean-generic

dvi: dvi-am

dvi-am:

html: html-am

info: info-am

info-am:

install-data-am:

install-exec-am:

install-info: install-info-am

install-man:

installcheck-am:

maintainer-clean: maintainer-clean-am

	-rm -f Makefile

maintainer-clean-am: distclean-am maintainer-clean-generic

mostlyclean: mostlyclean-am

mostlyclean-am: mostlyclean-generic

pdf: pdf-am

pdf-am:

ps: ps-am

ps-am:

uninstall-am: uninstall-info-am

.PHONY: all all-am check check-am clean clean-generic distclean \

	distclean-generic distdir dvi dvi-am html html-am info info-am \

	install install-am install-data install-data-am install-exec \

	install-exec-am install-info install-info-am install-man \

	install-strip installcheck installcheck-am installdirs \

	maintainer-clean maintainer-clean-generic mostlyclean \

	mostlyclean-generic pdf pdf-am ps ps-am uninstall uninstall-am \

	uninstall-info-am

# Tell versions [3.59,3.63) of GNU make to not export all variables.

# Otherwise a system limit (for SysV at least) may be exceeded.

.NOEXPORT:

/*--------------------------------------------------------------------*/

/*--- A replacement for the standard libpthread.so.                ---*/

/*---                                              vg_libpthread.c ---*/

/*--------------------------------------------------------------------*/

/*

   This file is part of Valgrind, an extensible x86 protected-mode

   emulator for monitoring program execution on x86-Unixes.

   Copyright (C) 2000-2004 Julian Seward 

      jseward@acm.org

   This program is free software; you can redistribute it and/or

   modify it under the terms of the GNU General Public License as

   published by the Free Software Foundation; either version 2 of the

   License, or (at your option) any later version.

   This program 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

   General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

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

   02111-1307, USA.

   The GNU General Public License is contained in the file COPYING.

*/

/* ALL THIS CODE RUNS ON THE SIMULATED CPU.

   This is a replacement for the standard libpthread.so.  It is loaded

   as part of the client's image (if required) and directs pthread

   calls through to Valgrind's request mechanism. 

   A couple of caveats.

   1.  Since it's a binary-compatible replacement for an existing library, 

       we must take care to used exactly the same data layouts, etc, as 

       the standard pthread.so does.  

   2.  Since this runs as part of the client, there are no specific

       restrictions on what headers etc we can include, so long as

       this libpthread.so does not end up having dependencies on .so's

       which the real one doesn't.

   Later ... it appears we cannot call file-related stuff in libc here,

   perhaps fair enough.  Be careful what you call from here.  Even exit()

   doesn't work (gives infinite recursion and then stack overflow); hence

   myexit().  Also fprintf doesn't seem safe.

*/

#include "valgrind.h"    /* For the request-passing mechanism */

#include "vg_include.h"  /* For the VG_USERREQ__* constants */

#define __USE_UNIX98

#include <sys/types.h>

#include <pthread.h>

#undef __USE_UNIX98

#include <unistd.h>

#include <string.h>

#include <sys/time.h>

#include <sys/stat.h>

#include <sys/poll.h>

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

# define strong_alias(name, aliasname) \

  extern __typeof (name) aliasname __attribute__ ((alias (#name)));

# define weak_alias(name, aliasname) \

  extern __typeof (name) aliasname __attribute__ ((weak, alias (#name)));

/* ---------------------------------------------------------------------

   Forwardses.

   ------------------------------------------------------------------ */

#define WEAK	__attribute__((weak))

static

__inline__

int is_kerror ( int res )

{

   if (res >= -4095 && res <= -1)

      return 1;

   else

      return 0;

}

#ifdef GLIBC_2_3

   /* kludge by JRS (not from glibc) ... */

   typedef void* __locale_t;

   /* Copied from locale/locale.h in glibc-2.2.93 sources */

   /* This value can be passed to `uselocale' and may be returned by

      it.  Passing this value to any other function has undefined

      behavior.  */

#  define LC_GLOBAL_LOCALE       ((__locale_t) -1L)

   extern __locale_t __uselocale ( __locale_t );

#endif

static

void init_libc_tsd_keys ( void );

/* ---------------------------------------------------------------------

   Helpers.  We have to be pretty self-sufficient.

   ------------------------------------------------------------------ */

/* Number of times any given error message is printed. */

#define N_MOANS 3

/* Extract from Valgrind the value of VG_(clo_trace_pthread_level).

   Returns 0 (none) if not running on Valgrind. */

static

int get_pt_trace_level ( void )

{

   int res;

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__GET_PTHREAD_TRACE_LEVEL,

                           0, 0, 0, 0);

   return res;

}

/* Don't do anything if we're not under Valgrind */

static __inline__

void ensure_valgrind ( char* caller )

{

   if (!RUNNING_ON_VALGRIND) {

      const char msg[] = "Warning: this libpthread.so should only be run with Valgrind\n";

      VG_(do_syscall)(__NR_write, 2, msg, sizeof(msg)-1);

      VG_(do_syscall)(__NR_exit, 1);

   }

}

/* While we're at it ... hook our own startup function into this

   game. */

static

__attribute__((noreturn))

void barf ( const char* str )

{

   char buf[1000];

   strcpy(buf, "\nvalgrind's libpthread.so: ");

   strcat(buf, str);

   strcat(buf, "\nPlease report this bug at: ");

   strcat(buf, VG_BUGS_TO);

   strcat(buf, "\n\n");

   VALGRIND_INTERNAL_PRINTF(buf);

   _exit(1);

   /* We have to persuade gcc into believing this doesn't return. */

   while (1) { };

}

static void cat_n_send ( char* s1, char* s2, char* s3 )

{

   char  buf[1000];

   if (get_pt_trace_level() >= 0) {

      snprintf(buf, sizeof(buf), "%s%s%s", s1, s2, s3);

      buf[sizeof(buf)-1] = '\0';

      VALGRIND_INTERNAL_PRINTF(buf);

   }

}

static void oh_dear ( char* fn, char* aux, char* s )

{

   cat_n_send    ( "warning: Valgrind's ", fn, s );

   if (NULL != aux)

      cat_n_send ( "         ", aux, "" );

   cat_n_send    ( "         your program may misbehave as a result", "", "" );

}

static void ignored ( char* fn, char* aux )

{

   oh_dear ( fn, aux, " does nothing" );

}

static void kludged ( char* fn, char* aux )

{

   oh_dear ( fn, aux, " is incomplete" );

}

__attribute__((noreturn))

void vgPlain_unimp ( char* fn )

{

   cat_n_send ( "valgrind's libpthread.so: UNIMPLEMENTED FUNCTION: ", fn, "" );

   barf("unimplemented function");

}

static

void my_assert_fail ( const Char* expr, const Char* file, Int line, const Char* fn )

{

   char buf[1000];

   static Bool entered = False;

   if (entered) 

      _exit(2);

   entered = True;

   sprintf(buf, "\n%s: %s:%d (%s): Assertion `%s' failed.\n",

                "valgrind", file, line, fn, expr );

   cat_n_send ( "", buf, "" );

   sprintf(buf, "Please report this bug at: %s\n\n", VG_BUGS_TO);

   cat_n_send ( "", buf, "" );

   _exit(1);

}

#define MY__STRING(__str)  #__str

#define my_assert(expr)                                               \

  ((void) ((expr) ? 0 :						      \

	   (my_assert_fail  (MY__STRING(expr),			      \

			      __FILE__, __LINE__,                     \

                              __PRETTY_FUNCTION__), 0)))

static

void my_free ( void* ptr )

{

#if 0

   int res;

   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,

                           VG_USERREQ__FREE, ptr, 0, 0, 0);

   my_assert(res == 0);

#else

   free(ptr);

#endif

}

static

void* my_malloc ( int nbytes )

{

   void* res;

#if 0

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__MALLOC, nbytes, 0, 0, 0);

#else

   res = malloc(nbytes);

#endif

   my_assert(res != (void*)0);

   return res;

}

/* ---------------------------------------------------------------------

   Pass pthread_ calls to Valgrind's request mechanism.

   ------------------------------------------------------------------ */

/* ---------------------------------------------------

   Ummm ..

   ------------------------------------------------ */

static

void pthread_error ( const char* msg )

{

   int res;

   VALGRIND_MAGIC_SEQUENCE(res, 0,

                           VG_USERREQ__PTHREAD_ERROR, 

                           msg, 0, 0, 0);

}

/* ---------------------------------------------------

   Here so it can be inlined without complaint.

   ------------------------------------------------ */

__inline__

pthread_t pthread_self(void)

{

   int tid;

   ensure_valgrind("pthread_self");

   VALGRIND_MAGIC_SEQUENCE(tid, 0 /* default */,

                           VG_USERREQ__PTHREAD_GET_THREADID,

                           0, 0, 0, 0);

   if (tid < 1 || tid >= VG_N_THREADS)

      barf("pthread_self: invalid ThreadId");

   return tid;

}

/* ---------------------------------------------------

   THREAD ATTRIBUTES

   ------------------------------------------------ */

int pthread_attr_init(pthread_attr_t *attr)

{

   /* Just initialise the fields which we might look at. */

   attr->__detachstate = PTHREAD_CREATE_JOINABLE;

   /* Linuxthreads sets this field to the value __getpagesize(), so I

      guess the following is OK. */

   attr->__guardsize = VKI_BYTES_PER_PAGE;   return 0;

}

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)

{

   if (detachstate != PTHREAD_CREATE_JOINABLE 

       && detachstate != PTHREAD_CREATE_DETACHED) {

      pthread_error("pthread_attr_setdetachstate: "

                    "detachstate is invalid");

      return EINVAL;

   }

   attr->__detachstate = detachstate;

   return 0;

}

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)

{

   *detachstate = attr->__detachstate;

   return 0;

}

int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)

{

   static int moans = N_MOANS;

   if (moans-- > 0) 

      ignored("pthread_attr_setinheritsched", NULL);

   return 0;

}

WEAK

int pthread_attr_setstacksize (pthread_attr_t *__attr,

                               size_t __stacksize)

{

   size_t limit;

   char buf[1024];

   ensure_valgrind("pthread_attr_setstacksize");

   limit = VG_PTHREAD_STACK_SIZE - VG_AR_CLIENT_STACKBASE_REDZONE_SZB 

                                 - 1000; /* paranoia */

   if (__stacksize < limit)

      return 0;

   snprintf(buf, sizeof(buf), "pthread_attr_setstacksize: "

            "requested size %d >= VG_PTHREAD_STACK_SIZE\n   "

            "edit vg_include.h and rebuild.", __stacksize);

   buf[sizeof(buf)-1] = '\0'; /* Make sure it is zero terminated */

   barf(buf);

}

/* This is completely bogus. */

int  pthread_attr_getschedparam(const  pthread_attr_t  *attr,  

                                struct sched_param *param)

{

   static int moans = N_MOANS;

   if (moans-- > 0) 

      kludged("pthread_attr_getschedparam", NULL);

#  ifdef HAVE_SCHED_PRIORITY

   if (param) param->sched_priority = 0; /* who knows */

#  else

   if (param) param->__sched_priority = 0; /* who knows */

#  endif

   return 0;

}

int  pthread_attr_setschedparam(pthread_attr_t  *attr,

                                const  struct sched_param *param)

{

   static int moans = N_MOANS;

   if (moans-- > 0) 

      ignored("pthread_attr_setschedparam", "(scheduling not changeable)");

   return 0;

}

int pthread_attr_destroy(pthread_attr_t *attr)

{

   static int moans = N_MOANS;

   if (moans-- > 0) 

      ignored("pthread_attr_destroy", NULL);

   return 0;

}

/* These are no-ops, as with LinuxThreads. */

int pthread_attr_setscope ( pthread_attr_t *attr, int scope )

{

   ensure_valgrind("pthread_attr_setscope");

   if (scope == PTHREAD_SCOPE_SYSTEM)

      return 0;

   pthread_error("pthread_attr_setscope: "

                 "invalid or unsupported scope");

   if (scope == PTHREAD_SCOPE_PROCESS)

      return ENOTSUP;

   return EINVAL;

}

int pthread_attr_getscope ( const pthread_attr_t *attr, int *scope )

{

   ensure_valgrind("pthread_attr_setscope");

   if (scope)

      *scope = PTHREAD_SCOPE_SYSTEM;

   return 0;

}

/* Pretty bogus.  Avoid if possible. */

int pthread_getattr_np (pthread_t thread, pthread_attr_t *attr)

{

   int    detached;

   size_t limit;

   ensure_valgrind("pthread_getattr_np");

   kludged("pthread_getattr_np", NULL);

   limit = VG_PTHREAD_STACK_SIZE - VG_AR_CLIENT_STACKBASE_REDZONE_SZB 

                                 - 1000; /* paranoia */

   attr->__detachstate = PTHREAD_CREATE_JOINABLE;

   attr->__schedpolicy = SCHED_OTHER;

   attr->__schedparam.sched_priority = 0;

   attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;

   attr->__scope = PTHREAD_SCOPE_SYSTEM;

   attr->__guardsize = VKI_BYTES_PER_PAGE;

   attr->__stackaddr = NULL;

   attr->__stackaddr_set = 0;

   attr->__stacksize = limit;

   VALGRIND_MAGIC_SEQUENCE(detached, (-1) /* default */,

                           VG_USERREQ__SET_OR_GET_DETACH, 

                           2 /* get */, thread, 0, 0);

   my_assert(detached == 0 || detached == 1);

   if (detached)

      attr->__detachstate = PTHREAD_CREATE_DETACHED;

   return 0;

}

/* Bogus ... */

WEAK

int pthread_attr_getstackaddr ( const pthread_attr_t * attr,

                                void ** stackaddr )

{

   ensure_valgrind("pthread_attr_getstackaddr");

   kludged("pthread_attr_getstackaddr", "(it always sets stackaddr to zero)");

   if (stackaddr)

      *stackaddr = NULL;

   return 0;

}

/* Not bogus (!) */

WEAK

int pthread_attr_getstacksize ( const pthread_attr_t * _attr, 

                                size_t * __stacksize )

{

   size_t limit;

   ensure_valgrind("pthread_attr_getstacksize");

   limit = VG_PTHREAD_STACK_SIZE - VG_AR_CLIENT_STACKBASE_REDZONE_SZB 

                                 - 1000; /* paranoia */

   if (__stacksize)

      *__stacksize = limit;

   return 0;

}

int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)

{

  if (policy != SCHED_OTHER && policy != SCHED_FIFO && policy != SCHED_RR)

    return EINVAL;

  attr->__schedpolicy = policy;

  return 0;

}

int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)

{

  *policy = attr->__schedpolicy;

  return 0;

}

/* This is completely bogus.  We reject all attempts to change it from

   VKI_BYTES_PER_PAGE.  I don't have a clue what it's for so it seems

   safest to be paranoid. */

WEAK 

int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)

{

   static int moans = N_MOANS;

   if (guardsize == VKI_BYTES_PER_PAGE)

      return 0;

   if (moans-- > 0) 

       ignored("pthread_attr_setguardsize",

               "(it ignores any guardsize != 4096)");

   return 0;

}

/* A straight copy of the LinuxThreads code. */

WEAK 

int pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize)

{

   *guardsize = attr->__guardsize;

   return 0;

}  

/* Again, like LinuxThreads. */

static int concurrency_current_level = 0;

WEAK 

int pthread_setconcurrency(int new_level)

{

   if (new_level < 0)

      return EINVAL;

   else {

      concurrency_current_level = new_level;

      return 0;

   }

}

WEAK 

int pthread_getconcurrency(void)

{

   return concurrency_current_level;

}

/* --------------------------------------------------- 

   Helper functions for running a thread 

   and for clearing up afterwards.

   ------------------------------------------------ */

/* All exiting threads eventually pass through here, bearing the

   return value, or PTHREAD_CANCELED, in ret_val. */

static

__attribute__((noreturn))

void thread_exit_wrapper ( void* ret_val )

{

   int           detached, res;

   CleanupEntry  cu;

   pthread_key_t key;

   void**        specifics_ptr;

   /* Run this thread's cleanup handlers. */

   while (1) {

      VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,

                              VG_USERREQ__CLEANUP_POP,

                              &cu, 0, 0, 0);

      if (res == -1) break; /* stack empty */

      my_assert(res == 0);

      if (0) printf("running exit cleanup handler");

      cu.fn ( cu.arg );

   }

   /* Run this thread's key finalizers.  Really this should be run

      PTHREAD_DESTRUCTOR_ITERATIONS times. */

   for (key = 0; key < VG_N_THREAD_KEYS; key++) {

      VALGRIND_MAGIC_SEQUENCE(res, (-2) /* default */,

                              VG_USERREQ__GET_KEY_D_AND_S,

                              key, &cu, 0, 0 );

      if (res == 0) {

         /* valid key */

         if (cu.fn && cu.arg)

            cu.fn /* destructor for key */ 

                  ( cu.arg /* specific for key for this thread */ );

         continue;

      }

      my_assert(res == -1);

   }

   /* Free up my specifics space, if any. */

   VALGRIND_MAGIC_SEQUENCE(specifics_ptr, 3 /* default */,

                           VG_USERREQ__PTHREAD_GETSPECIFIC_PTR,

                           pthread_self(), 0, 0, 0);

   my_assert(specifics_ptr != (void**)3);

   my_assert(specifics_ptr != (void**)1); /* 1 means invalid thread */

   if (specifics_ptr != NULL)

      my_free(specifics_ptr);

   /* Decide on my final disposition. */

   VALGRIND_MAGIC_SEQUENCE(detached, (-1) /* default */,

                           VG_USERREQ__SET_OR_GET_DETACH, 

                           2 /* get */, pthread_self(), 0, 0);

   my_assert(detached == 0 || detached == 1);

   if (detached) {

      /* Detached; I just quit right now. */

      VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                              VG_USERREQ__QUIT, 0, 0, 0, 0);

   } else {

      /* Not detached; so I wait for a joiner. */

      VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                              VG_USERREQ__WAIT_JOINER, ret_val, 0, 0, 0);

   }

   /* NOTREACHED */

   barf("thread_exit_wrapper: still alive?!");

}

/* This function is a wrapper function for running a thread.  It runs

   the root function specified in pthread_create, and then, should the

   root function return a value, it arranges to run the thread's

   cleanup handlers and exit correctly. */

/* Struct used to convey info from pthread_create to thread_wrapper.

   Must be careful not to pass to the child thread any pointers to

   objects which might be on the parent's stack.  */

typedef

   struct {

      int   attr__detachstate;

      void* (*root_fn) ( void* );

      void* arg;

   }

   NewThreadInfo;

/* This is passed to the VG_USERREQ__APPLY_IN_NEW_THREAD and so must

   not return.  Note that this runs in the new thread, not the

   parent. */

static

__attribute__((noreturn))

void thread_wrapper ( NewThreadInfo* info )

{

   int   attr__detachstate;

   void* (*root_fn) ( void* );

   void* arg;

   void* ret_val;

   attr__detachstate = info->attr__detachstate;

   root_fn           = info->root_fn;

   arg               = info->arg;

   /* Free up the arg block that pthread_create malloced. */

   my_free(info);

   /* Minimally observe the attributes supplied. */

   if (attr__detachstate != PTHREAD_CREATE_DETACHED

       && attr__detachstate != PTHREAD_CREATE_JOINABLE)

      pthread_error("thread_wrapper: invalid attr->__detachstate");

   if (attr__detachstate == PTHREAD_CREATE_DETACHED)

      pthread_detach(pthread_self());

#  ifdef GLIBC_2_3

   /* Set this thread's locale to the global (default) locale.  A hack

      in support of glibc-2.3.  This does the biz for the all new

      threads; the root thread is done with a horrible hack in

      init_libc_tsd_keys() below.

   */

   __uselocale(LC_GLOBAL_LOCALE);

#  endif

   /* The root function might not return.  But if it does we simply

      move along to thread_exit_wrapper.  All other ways out for the

      thread (cancellation, or calling pthread_exit) lead there

      too. */

   ret_val = root_fn(arg);

   thread_exit_wrapper(ret_val);

   /* NOTREACHED */

}

/* ---------------------------------------------------

   THREADs

   ------------------------------------------------ */

static void __valgrind_pthread_yield ( void )

{

   int res;

   ensure_valgrind("pthread_yield");

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__PTHREAD_YIELD, 0, 0, 0, 0);

}

WEAK

int pthread_yield ( void )

{

   __valgrind_pthread_yield();

   return 0;

}

int pthread_equal(pthread_t thread1, pthread_t thread2)

{

   return thread1 == thread2 ? 1 : 0;

}

/* Bundle up the args into a malloc'd block and create a new thread

   consisting of thread_wrapper() applied to said malloc'd block. */

int

pthread_create (pthread_t *__restrict __thredd,

                __const pthread_attr_t *__restrict __attr,

                void *(*__start_routine) (void *),

                void *__restrict __arg)

{

   int            tid_child;

   NewThreadInfo* info;

   ensure_valgrind("pthread_create");

   /* make sure the tsd keys, and hence locale info, are initialised

      before we get into complications making new threads. */

   init_libc_tsd_keys();

   /* Allocate space for the arg block.  thread_wrapper will free

      it. */

   info = my_malloc(sizeof(NewThreadInfo));

   my_assert(info != NULL);

   if (__attr)

      info->attr__detachstate = __attr->__detachstate;

   else 

      info->attr__detachstate = PTHREAD_CREATE_JOINABLE;

   info->root_fn = __start_routine;

   info->arg     = __arg;

   VALGRIND_MAGIC_SEQUENCE(tid_child, VG_INVALID_THREADID /* default */,

                           VG_USERREQ__APPLY_IN_NEW_THREAD,

                           &thread_wrapper, info, 0, 0);

   my_assert(tid_child != VG_INVALID_THREADID);

   if (__thredd)

      *__thredd = tid_child;

   return 0; /* success */

}

int 

pthread_join (pthread_t __th, void **__thread_return)

{

   int res;

   ensure_valgrind("pthread_join");

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__PTHREAD_JOIN,

                           __th, __thread_return, 0, 0);

   return res;

}

void pthread_exit(void *retval)

{

   ensure_valgrind("pthread_exit");

   /* Simple! */

   thread_exit_wrapper(retval);

}

int pthread_detach(pthread_t th)

{

   int res;

   ensure_valgrind("pthread_detach");

   /* First we enquire as to the current detach state. */

   VALGRIND_MAGIC_SEQUENCE(res, (-2) /* default */,

                           VG_USERREQ__SET_OR_GET_DETACH,

                           2 /* get */, th, 0, 0);

   if (res == -1) {

      /* not found */ 

      pthread_error("pthread_detach: "

                    "invalid target thread");

      return ESRCH;

   }

   if (res == 1) { 

      /* already detached */

      pthread_error("pthread_detach: "

                    "target thread is already detached");

      return EINVAL;

   }

   if (res == 0) {

      VALGRIND_MAGIC_SEQUENCE(res, (-2) /* default */,

                              VG_USERREQ__SET_OR_GET_DETACH,

                              1 /* set */, th, 0, 0);

      my_assert(res == 0);

      return 0;

   }

   barf("pthread_detach");

}

/* ---------------------------------------------------

   CLEANUP STACKS

   ------------------------------------------------ */

void _pthread_cleanup_push (struct _pthread_cleanup_buffer *__buffer,

                            void (*__routine) (void *),

                            void *__arg)

{

   int          res;

   CleanupEntry cu;

   ensure_valgrind("_pthread_cleanup_push");

   cu.fn  = __routine;

   cu.arg = __arg;

   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,

                           VG_USERREQ__CLEANUP_PUSH,

                           &cu, 0, 0, 0);

   my_assert(res == 0);

}

void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer,

                                  void (*__routine) (void *),

                                  void *__arg)

{

   /* As _pthread_cleanup_push, but first save the thread's original

      cancellation type in __buffer and set it to Deferred. */

   int orig_ctype;

   ensure_valgrind("_pthread_cleanup_push_defer");

   /* Set to Deferred, and put the old cancellation type in res. */

   my_assert(-1 != PTHREAD_CANCEL_DEFERRED);

   my_assert(-1 != PTHREAD_CANCEL_ASYNCHRONOUS);

   my_assert(sizeof(struct _pthread_cleanup_buffer) >= sizeof(int));

   VALGRIND_MAGIC_SEQUENCE(orig_ctype, (-1) /* default */,

                           VG_USERREQ__SET_CANCELTYPE,

                           PTHREAD_CANCEL_DEFERRED, 0, 0, 0);   

   my_assert(orig_ctype != -1);

   *((int*)(__buffer)) = orig_ctype;

   /* Now push the cleanup. */

   _pthread_cleanup_push(NULL, __routine, __arg);

}

void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *__buffer,

                           int __execute)

{

   int          res;

   CleanupEntry cu;

   ensure_valgrind("_pthread_cleanup_push");

   cu.fn = cu.arg = NULL; /* paranoia */

   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,

                           VG_USERREQ__CLEANUP_POP,

                           &cu, 0, 0, 0);

   if (res == 0) {

      /* pop succeeded */

     if (__execute) {

        cu.fn ( cu.arg );

     }

     return;

   }   

   if (res == -1) {

      /* stack underflow */

      return;

   }

   barf("_pthread_cleanup_pop");

}

void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer,

                                   int __execute)

{

   int orig_ctype, fake_ctype;

   /* As _pthread_cleanup_pop, but after popping/running the handler,

      restore the thread's original cancellation type from the first

      word of __buffer. */

   _pthread_cleanup_pop(NULL, __execute);

   orig_ctype = *((int*)(__buffer));

   my_assert(orig_ctype == PTHREAD_CANCEL_DEFERRED

          || orig_ctype == PTHREAD_CANCEL_ASYNCHRONOUS);

   my_assert(-1 != PTHREAD_CANCEL_DEFERRED);

   my_assert(-1 != PTHREAD_CANCEL_ASYNCHRONOUS);

   my_assert(sizeof(struct _pthread_cleanup_buffer) >= sizeof(int));

   VALGRIND_MAGIC_SEQUENCE(fake_ctype, (-1) /* default */,

                           VG_USERREQ__SET_CANCELTYPE,

                           orig_ctype, 0, 0, 0); 

   my_assert(fake_ctype == PTHREAD_CANCEL_DEFERRED);

}

/* ---------------------------------------------------

   MUTEX ATTRIBUTES

   ------------------------------------------------ */

int __pthread_mutexattr_init(pthread_mutexattr_t *attr)

{

   attr->__mutexkind = PTHREAD_MUTEX_ERRORCHECK_NP;

   return 0;

}

int __pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type)

{

   switch (type) {

#     ifndef GLIBC_2_1    

      case PTHREAD_MUTEX_TIMED_NP:

      case PTHREAD_MUTEX_ADAPTIVE_NP:

#     endif

#     ifdef GLIBC_2_1    

      case PTHREAD_MUTEX_FAST_NP:

#     endif

      case PTHREAD_MUTEX_RECURSIVE_NP:

      case PTHREAD_MUTEX_ERRORCHECK_NP:

         attr->__mutexkind = type;

         return 0;

      default:

         pthread_error("pthread_mutexattr_settype: "

                       "invalid type");

         return EINVAL;

   }

}

int __pthread_mutexattr_destroy(pthread_mutexattr_t *attr)

{

   return 0;

}

int __pthread_mutexattr_setpshared ( pthread_mutexattr_t* attr, int pshared)

{

  if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)

    return EINVAL;

  /* For now it is not possible to shared a conditional variable.  */

  if (pshared != PTHREAD_PROCESS_PRIVATE)

    return ENOSYS;

  return 0;

}

/* ---------------------------------------------------

   MUTEXes

   ------------------------------------------------ */

int __pthread_mutex_init(pthread_mutex_t *mutex, 

                         const  pthread_mutexattr_t *mutexattr)

{

   mutex->__m_count = 0;

   mutex->__m_owner = (_pthread_descr)VG_INVALID_THREADID;

   mutex->__m_kind  = PTHREAD_MUTEX_ERRORCHECK_NP;

   if (mutexattr)

      mutex->__m_kind = mutexattr->__mutexkind;

   return 0;

}

int __pthread_mutex_lock(pthread_mutex_t *mutex)

{

   int res;

   if (RUNNING_ON_VALGRIND) {

      VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                              VG_USERREQ__PTHREAD_MUTEX_LOCK,

                              mutex, 0, 0, 0);

      return res;

   } else {

      /* Play at locking */

      if (0)

	 kludged("prehistoric lock", NULL);

      mutex->__m_owner = (_pthread_descr)1;

      mutex->__m_count = 1;

      mutex->__m_kind |= VG_PTHREAD_PREHISTORY;

      return 0; /* success */

   }

}

int __pthread_mutex_trylock(pthread_mutex_t *mutex)

{

   int res;

   if (RUNNING_ON_VALGRIND) {

      VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                              VG_USERREQ__PTHREAD_MUTEX_TRYLOCK,

                              mutex, 0, 0, 0);

      return res;

   } else {

      /* Play at locking */

      if (0)

	 kludged("prehistoric trylock", NULL);

      mutex->__m_owner = (_pthread_descr)1;

      mutex->__m_count = 1;

      mutex->__m_kind |= VG_PTHREAD_PREHISTORY;

      return 0; /* success */

   }

}

int __pthread_mutex_unlock(pthread_mutex_t *mutex)

{

   int res;

   if (RUNNING_ON_VALGRIND) {

      VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                              VG_USERREQ__PTHREAD_MUTEX_UNLOCK,

                              mutex, 0, 0, 0);

      return res;

   } else {

      /* Play at locking */

      if (0)

	 kludged("prehistoric unlock", NULL);

      mutex->__m_owner = 0;

      mutex->__m_count = 0;

      mutex->__m_kind &= ~VG_PTHREAD_PREHISTORY;

      return 0; /* success */

   }

}

int __pthread_mutex_destroy(pthread_mutex_t *mutex)

{

   /* Valgrind doesn't hold any resources on behalf of the mutex, so no

      need to involve it. */

   if (mutex->__m_count > 0) {

      /* Oh, the horror.  glibc's internal use of pthreads "knows"

	 that destroying a lock does an implicit unlock.  Make it

	 explicit. */

      __pthread_mutex_unlock(mutex);

      pthread_error("pthread_mutex_destroy: "

		    "mutex is still in use");

      return EBUSY;

   }

   mutex->__m_count = 0;

   mutex->__m_owner = (_pthread_descr)VG_INVALID_THREADID;

   mutex->__m_kind  = PTHREAD_MUTEX_ERRORCHECK_NP;

   return 0;

}

/* ---------------------------------------------------

   CONDITION VARIABLES

   ------------------------------------------------ */

/* LinuxThreads supports no attributes for conditions.  Hence ... */

int pthread_condattr_init(pthread_condattr_t *attr)

{

   return 0;

}

int pthread_condattr_destroy(pthread_condattr_t *attr)

{

   return 0;

}

int pthread_cond_init( pthread_cond_t *cond,

		       const pthread_condattr_t *cond_attr)

{

   cond->__c_waiting = (_pthread_descr)VG_INVALID_THREADID;

   return 0;

}

int pthread_cond_destroy(pthread_cond_t *cond)

{

   /* should check that no threads are waiting on this CV */

   static int moans = N_MOANS;

   if (moans-- > 0) 

      kludged("pthread_cond_destroy", 

              "(it doesn't check if the cond is waited on)" );

   return 0;

}

/* ---------------------------------------------------

   SCHEDULING

   ------------------------------------------------ */

/* This is completely bogus. */

int   pthread_getschedparam(pthread_t  target_thread,  

                            int  *policy,

                            struct sched_param *param)

{

   static int moans = N_MOANS;

   if (moans-- > 0) 

      kludged("pthread_getschedparam", NULL);

   if (policy) *policy = SCHED_OTHER;

#  ifdef HAVE_SCHED_PRIORITY

   if (param) param->sched_priority = 0; /* who knows */

#  else

   if (param) param->__sched_priority = 0; /* who knows */

#  endif

   return 0;

}

int pthread_setschedparam(pthread_t target_thread, 

                          int policy, 

                          const struct sched_param *param)

{

   static int moans = N_MOANS;

   if (moans-- > 0) 

      ignored("pthread_setschedparam", "(scheduling not changeable)");

   return 0;

}

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)

{

   int res;

   ensure_valgrind("pthread_cond_wait");

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__PTHREAD_COND_WAIT,

			   cond, mutex, 0, 0);

   return res;

}

int pthread_cond_timedwait ( pthread_cond_t *cond, 

                             pthread_mutex_t *mutex, 

                             const struct  timespec *abstime )

{

   int res;

   unsigned int ms_now, ms_end;

   struct  timeval timeval_now;

   unsigned long long int ull_ms_now_after_1970;

   unsigned long long int ull_ms_end_after_1970;

   ensure_valgrind("pthread_cond_timedwait");

   VALGRIND_MAGIC_SEQUENCE(ms_now, 0xFFFFFFFF /* default */,

                           VG_USERREQ__READ_MILLISECOND_TIMER,

                           0, 0, 0, 0);

   my_assert(ms_now != 0xFFFFFFFF);

   res = gettimeofday(&timeval_now, NULL);

   my_assert(res == 0);

   ull_ms_now_after_1970 

      = 1000ULL * ((unsigned long long int)(timeval_now.tv_sec))

        + ((unsigned long long int)(timeval_now.tv_usec / 1000000));

   ull_ms_end_after_1970

      = 1000ULL * ((unsigned long long int)(abstime->tv_sec))

        + ((unsigned long long int)(abstime->tv_nsec / 1000000));

   if (ull_ms_end_after_1970 < ull_ms_now_after_1970)

      ull_ms_end_after_1970 = ull_ms_now_after_1970;

   ms_end 

      = ms_now + (unsigned int)(ull_ms_end_after_1970 - ull_ms_now_after_1970);

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__PTHREAD_COND_TIMEDWAIT,

			   cond, mutex, ms_end, 0);

   return res;

}

int pthread_cond_signal(pthread_cond_t *cond)

{

   int res;

   ensure_valgrind("pthread_cond_signal");

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__PTHREAD_COND_SIGNAL,

			   cond, 0, 0, 0);

   return res;

}

int pthread_cond_broadcast(pthread_cond_t *cond)

{

   int res;

   ensure_valgrind("pthread_cond_broadcast");

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__PTHREAD_COND_BROADCAST,

			   cond, 0, 0, 0);

   return res;

}

/* ---------------------------------------------------

   CANCELLATION

   ------------------------------------------------ */

int pthread_setcancelstate(int state, int *oldstate)

{

   int res;

   ensure_valgrind("pthread_setcancelstate");

   if (state != PTHREAD_CANCEL_ENABLE

       && state != PTHREAD_CANCEL_DISABLE) {

      pthread_error("pthread_setcancelstate: "

                    "invalid state");

      return EINVAL;

   }

   my_assert(-1 != PTHREAD_CANCEL_ENABLE);

   my_assert(-1 != PTHREAD_CANCEL_DISABLE);

   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,

                           VG_USERREQ__SET_CANCELSTATE,

                           state, 0, 0, 0);

   my_assert(res != -1);

   if (oldstate) 

      *oldstate = res;

   return 0;

}

int pthread_setcanceltype(int type, int *oldtype)

{

   int res;

   ensure_valgrind("pthread_setcanceltype");

   if (type != PTHREAD_CANCEL_DEFERRED

       && type != PTHREAD_CANCEL_ASYNCHRONOUS) {

      pthread_error("pthread_setcanceltype: "

                    "invalid type");

      return EINVAL;

   }

   my_assert(-1 != PTHREAD_CANCEL_DEFERRED);

   my_assert(-1 != PTHREAD_CANCEL_ASYNCHRONOUS);

   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,

                           VG_USERREQ__SET_CANCELTYPE,

                           type, 0, 0, 0);

   my_assert(res != -1);

   if (oldtype) 

      *oldtype = res;

   return 0;

}

int pthread_cancel(pthread_t thread)

{

   int res;

   ensure_valgrind("pthread_cancel");

   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,

                           VG_USERREQ__SET_CANCELPEND,

                           thread, &thread_exit_wrapper, 0, 0);

   my_assert(res != -1);

   return res;

}

static

void __my_pthread_testcancel(void)

{

   int res;

   ensure_valgrind("__my_pthread_testcancel");

   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,

                           VG_USERREQ__TESTCANCEL,

                           0, 0, 0, 0);

   my_assert(res == 0);

}

void pthread_testcancel ( void )

{

   __my_pthread_testcancel();

}

/* Not really sure what this is for.  I suspect for doing the POSIX

   requirements for fork() and exec().  We do this internally anyway

   whenever those syscalls are observed, so this could be superfluous,

   but hey ... 

*/

void __pthread_kill_other_threads_np ( void )

{

   int res;

   ensure_valgrind("__pthread_kill_other_threads_np");

   VALGRIND_MAGIC_SEQUENCE(res, (-1) /* default */,

                           VG_USERREQ__NUKE_OTHER_THREADS,

                           0, 0, 0, 0);

   my_assert(res == 0);

}

/* ---------------------------------------------------

   SIGNALS

   ------------------------------------------------ */

#include <signal.h>

int pthread_sigmask(int how, const sigset_t *newmask, 

                             sigset_t *oldmask)

{

   int res;

   /* A bit subtle, because the scheduler expects newmask and oldmask

      to be vki_sigset_t* rather than sigset_t*, and the two are

      different.  Fortunately the first 64 bits of a sigset_t are

      exactly a vki_sigset_t, so we just pass the pointers through

      unmodified.  Haaaack! 

      Also mash the how value so that the SIG_ constants from glibc

      constants to VKI_ constants, so that the former do not have to

      be included into vg_scheduler.c. */

   ensure_valgrind("pthread_sigmask");

   switch (how) {

      case SIG_SETMASK: how = VKI_SIG_SETMASK; break;

      case SIG_BLOCK:   how = VKI_SIG_BLOCK; break;

      case SIG_UNBLOCK: how = VKI_SIG_UNBLOCK; break;

      default: pthread_error("pthread_sigmask: invalid how");

               return EINVAL;

   }

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__PTHREAD_SIGMASK,

                           how, newmask, oldmask, 0);

   /* The scheduler tells us of any memory violations. */

   return res == 0 ? 0 : EFAULT;

}

int sigwait ( const sigset_t* set, int* sig )

{

   int res;

   siginfo_t si;

   __my_pthread_testcancel();

   si.si_signo = 0;

   res = sigtimedwait(set, &si, NULL);

   *sig = si.si_signo;

   return 0;			/* always returns 0 */

}

int pthread_kill(pthread_t thread, int signo)

{

   int res;

   ensure_valgrind("pthread_kill");

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__PTHREAD_KILL, 

                           thread, signo, 0, 0);

   return res;

}

/* Copied verbatim from Linuxthreads */

/* Redefine raise() to send signal to calling thread only,

   as per POSIX 1003.1c */

int raise (int sig)

{

  int retcode = pthread_kill(pthread_self(), sig);

  if (retcode == 0) {

    return 0;

  } else {

    *(__errno_location()) = retcode;

    return -1;

  }

}

/* ---------------------------------------------------

   THREAD-SPECIFICs

   ------------------------------------------------ */

static

int key_is_valid (pthread_key_t key)

{

   int res;

   VALGRIND_MAGIC_SEQUENCE(res, 2 /* default */,

                           VG_USERREQ__PTHREAD_KEY_VALIDATE,

                           key, 0, 0, 0);

   my_assert(res != 2);

   return res;

}

/* Returns NULL if thread is invalid.  Otherwise, if the thread

   already has a specifics area, return that.  Otherwise allocate it

   one. */

static

void** get_or_allocate_specifics_ptr ( pthread_t thread )

{

   int    res, i;

   void** specifics_ptr;

   ensure_valgrind("get_or_allocate_specifics_ptr");

   /* Returns zero if the thread has no specific_ptr.  One if thread

      is invalid.  Otherwise, the specific_ptr value.  This is

      allocated with my_malloc and so is aligned and cannot be

      confused with 1 or 3. */

   VALGRIND_MAGIC_SEQUENCE(specifics_ptr, 3 /* default */,

                           VG_USERREQ__PTHREAD_GETSPECIFIC_PTR,

                           thread, 0, 0, 0);

   my_assert(specifics_ptr != (void**)3);

   if (specifics_ptr == (void**)1) 

      return NULL; /* invalid thread */

   if (specifics_ptr != NULL)

      return specifics_ptr; /* already has a specifics ptr. */

   /* None yet ... allocate a new one.  Should never fail. */

   specifics_ptr = my_malloc( VG_N_THREAD_KEYS * sizeof(void*) );

   my_assert(specifics_ptr != NULL);

   VALGRIND_MAGIC_SEQUENCE(res, -1 /* default */,

                           VG_USERREQ__PTHREAD_SETSPECIFIC_PTR,

                           specifics_ptr, 0, 0, 0);

   my_assert(res == 0);

   /* POSIX sez: "Upon thread creation, the value NULL shall be

      associated with all defined keys in the new thread."  This

      allocation is in effect a delayed allocation of the specific

      data for a thread, at its first-use.  Hence we initialise it

      here. */

   for (i = 0; i < VG_N_THREAD_KEYS; i++) {

      specifics_ptr[i] = NULL;

   }

   return specifics_ptr;   

}

int __pthread_key_create(pthread_key_t *key,  

                         void  (*destr_function)  (void *))

{

   void** specifics_ptr;

   int    res, i;

   ensure_valgrind("pthread_key_create");

   /* This writes *key if successful.  It should never fail. */

   VALGRIND_MAGIC_SEQUENCE(res, 1 /* default */,

                           VG_USERREQ__PTHREAD_KEY_CREATE,

                           key, destr_function, 0, 0);

   if (res == 0) {

      /* POSIX sez: "Upon key creation, the value NULL shall be

	 associated with the new key in all active threads." */

      for (i = 0; i < VG_N_THREADS; i++) {

	 specifics_ptr = get_or_allocate_specifics_ptr(i);

	 /* we get NULL if i is an invalid thread. */

	 if (specifics_ptr != NULL)

	    specifics_ptr[*key] = NULL;

      }

   }

   return res;

}

int pthread_key_delete(pthread_key_t key)

{

   int res;

   ensure_valgrind("pthread_key_delete");

   if (!key_is_valid(key))

      return EINVAL;

   VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,

                           VG_USERREQ__PTHREAD_KEY_DELETE,

                           key, 0, 0, 0);

   my_assert(res == 0);

   return 0;

}

int __pthread_setspecific(pthread_key_t key, const void *pointer)

{

   void** specifics_ptr;

   ensure_valgrind("pthread_setspecific");

   if (!key_is_valid(key))

      return EINVAL;

   specifics_ptr = get_or_allocate_specifics_ptr(pthread_self());

   specifics_ptr[key] = (void*)pointer;

   return 0;

}

void * __pthread_getspecific(pthread_key_t key)

{

   void** specifics_ptr;

   ensure_valgrind("pthread_getspecific");

   if (!key_is_valid(key))

      return NULL;

   specifics_ptr = get_or_allocate_specifics_ptr(pthread_self());

   return specifics_ptr[key];

}