From 188cfe5f4f35dab27b2500283e8d449af8e42daa Mon Sep 17 00:00:00 2001
From: Eric Andersen <andersen@codepoet.org>
Date: Sun, 17 Aug 2003 10:20:48 +0000
Subject: [PATCH] Update valgrind

---
 make/valgrind.mk           |   8 +-
 sources/valgrind.patch     | 283 +++++++++++++++++++++++++++++++++++++
 sources/valgrind.patch.bz2 | Bin 1868 -> 0 bytes
 3 files changed, 287 insertions(+), 4 deletions(-)
 create mode 100644 sources/valgrind.patch
 delete mode 100644 sources/valgrind.patch.bz2

diff --git a/make/valgrind.mk b/make/valgrind.mk
index eb69663140..bd92ec4e5d 100644
--- a/make/valgrind.mk
+++ b/make/valgrind.mk
@@ -5,9 +5,9 @@
 #############################################################
 
 VALGRIND_SITE:=http://developer.kde.org/~sewardj
-VALGRIND_DIR:=$(BUILD_DIR)/valgrind-1.9.6
-VALGRIND_SOURCE:=valgrind-1.9.6.tar.bz2
-VALGRIND_PATCH:=$(SOURCE_DIR)/valgrind.patch.bz2
+VALGRIND_DIR:=$(BUILD_DIR)/valgrind-20030725
+VALGRIND_SOURCE:=valgrind-20030725.tar.bz2
+VALGRIND_PATCH:=$(SOURCE_DIR)/valgrind.patch
 
 $(DL_DIR)/$(VALGRIND_SOURCE):
 	$(WGET) -P $(DL_DIR) $(VALGRIND_SITE)/$(VALGRIND_SOURCE)
@@ -17,7 +17,7 @@ $(VALGRIND_DIR)/.unpacked: $(DL_DIR)/$(VALGRIND_SOURCE)
 	touch  $(VALGRIND_DIR)/.unpacked
 
 $(VALGRIND_DIR)/.patched: $(VALGRIND_DIR)/.unpacked
-	bzcat $(VALGRIND_PATCH) | patch -d $(VALGRIND_DIR) -p1
+	cat $(VALGRIND_PATCH) | patch -d $(VALGRIND_DIR) -p1
 	touch $(VALGRIND_DIR)/.patched
 
 $(VALGRIND_DIR)/.configured: $(VALGRIND_DIR)/.patched
diff --git a/sources/valgrind.patch b/sources/valgrind.patch
new file mode 100644
index 0000000000..d4e9d7d0aa
--- /dev/null
+++ b/sources/valgrind.patch
@@ -0,0 +1,283 @@
+diff -urN valgrind-20030725.orig/coregrind/vg_intercept.c valgrind-20030725/coregrind/vg_intercept.c
+--- valgrind-20030725.orig/coregrind/vg_intercept.c	2003-07-13 13:20:57.000000000 -0600
++++ valgrind-20030725/coregrind/vg_intercept.c	2003-08-10 03:22:01.000000000 -0600
+@@ -827,8 +827,10 @@
+ void VG_(__libc_freeres_wrapper)( void )
+ {
+    int res;
++#ifndef __UCLIBC__
+    extern void __libc_freeres(void);
+    __libc_freeres();
++#endif
+    VALGRIND_MAGIC_SEQUENCE(res, 0 /* default */,
+                            VG_USERREQ__LIBC_FREERES_DONE, 0, 0, 0, 0);
+    /*NOTREACHED*/
+diff -urN valgrind-20030725.orig/coregrind/vg_libpthread.c valgrind-20030725/coregrind/vg_libpthread.c
+--- valgrind-20030725.orig/coregrind/vg_libpthread.c	2003-07-10 18:02:07.000000000 -0600
++++ valgrind-20030725/coregrind/vg_libpthread.c	2003-08-10 03:24:31.000000000 -0600
+@@ -3124,6 +3124,8 @@
+ /* I've no idea what these are, but they get called quite a lot.
+    Anybody know? */
+ 
++#ifndef __UCLIBC__
++
+ #undef _IO_flockfile
+ void _IO_flockfile ( _IO_FILE * file )
+ {
+@@ -3139,6 +3141,7 @@
+ }
+ weak_alias(_IO_funlockfile, funlockfile);
+ 
++#endif
+ 
+ /* This doesn't seem to be needed to simulate libpthread.so's external
+    interface, but many people complain about its absence. */
+diff -urN valgrind-20030725.orig/coregrind/vg_syscalls.c valgrind-20030725/coregrind/vg_syscalls.c
+--- valgrind-20030725.orig/coregrind/vg_syscalls.c	2003-07-24 15:00:03.000000000 -0600
++++ valgrind-20030725/coregrind/vg_syscalls.c	2003-08-10 03:25:33.000000000 -0600
+@@ -2427,6 +2427,104 @@
+                KERNEL_DO_SYSCALL(tid,res);
+                break;
+ 
++	    /* Stuff added by Erik Andersen for general device probing/handling */
++#define BLKSSZGET  _IO(0x12,104)
++	    case BLKSSZGET:
++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(BLKSSZGET)", arg3, 
++                    sizeof(int));
++		 KERNEL_DO_SYSCALL(tid,res);
++		 if (!VG_(is_kerror)(res) && res == 0)
++		     VG_TRACK( post_mem_write,arg3, sizeof(int));
++		 break;
++#define BLKGETSIZE64 _IOR(0x12,114,sizeof(unsigned long long*))
++	    case BLKGETSIZE64:
++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(BLKGETSIZE64)", arg3, 
++                    sizeof(unsigned long long));
++		 KERNEL_DO_SYSCALL(tid,res);
++		 if (!VG_(is_kerror)(res) && res == 0)
++		     VG_TRACK( post_mem_write,arg3, sizeof(unsigned long long));
++		 break;
++	    case HDIO_GETGEO:
++		 {
++		     struct hd_geometry {
++			 unsigned char heads;
++			 unsigned char sectors;
++			 unsigned short cylinders;
++			 unsigned long start;
++		     };
++
++		     SYSCALL_TRACK( pre_mem_write, tst, "ioctl(HDIO_GETGEO)", arg3, 
++			     sizeof(struct hd_geometry));
++		     KERNEL_DO_SYSCALL(tid,res);
++		     if (!VG_(is_kerror)(res) && res == 0)
++			 VG_TRACK( post_mem_write,arg3, sizeof(struct hd_geometry));
++		 }
++		 break;
++	    case HDIO_GET_IDENTITY:
++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(HDIO_GET_IDENTITY)", arg3, 
++                    sizeof(struct hd_driveid));
++		 KERNEL_DO_SYSCALL(tid,res);
++		 if (!VG_(is_kerror)(res) && res == 0)
++		     VG_TRACK( post_mem_write,arg3, sizeof(struct hd_driveid));
++		 break;
++	    case SCSI_IOCTL_GET_IDLUN:
++		 {
++		     struct scsi_idlun
++		     {
++			 int mux4;
++			 int host_unique_id;
++
++		     };
++
++		     SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_GET_IDLUN)", arg3, 
++			     sizeof(struct scsi_idlun));
++		     KERNEL_DO_SYSCALL(tid,res);
++		     if (!VG_(is_kerror)(res) && res == 0)
++			 VG_TRACK( post_mem_write,arg3, sizeof(struct scsi_idlun));
++		 }
++		 break;
++	    case SCSI_IOCTL_SEND_COMMAND:
++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_SEND_COMMAND)", arg3, 
++                    ((2 * sizeof(unsigned int)) + 6 + 512));
++		 KERNEL_DO_SYSCALL(tid,res);
++		 if (!VG_(is_kerror)(res) && res == 0)
++		     VG_TRACK( post_mem_write,arg3, ((2 * sizeof(unsigned int)) + 6 + 512));
++		 break;
++	    case SCSI_IOCTL_GET_BUS_NUMBER:
++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_GET_BUS_NUMBER)", arg3, 
++                    sizeof(int));
++		 KERNEL_DO_SYSCALL(tid,res);
++		 if (!VG_(is_kerror)(res) && res == 0)
++		     VG_TRACK( post_mem_write,arg3, sizeof(int));
++		 break;
++	    case SCSI_IOCTL_PROBE_HOST:
++		 {
++		     int xxxx;
++		     char *array = (char*)arg3;
++		     xxxx = array[0] + (array[1]<<8) + (array[2]<<16) + (array[3]<<24);
++		     SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_PROBE_HOST)", arg3, 
++			     sizeof(int));
++		     KERNEL_DO_SYSCALL(tid,res);
++		     if (!VG_(is_kerror)(res) && res == 0)
++			 VG_TRACK( post_mem_write,arg3, sizeof(int));
++		 }
++		 break;
++#define BLKFLSBUF  _IO(0x12,97)
++	    case BLKFLSBUF:
++		 KERNEL_DO_SYSCALL(tid,res);
++		 break;
++#define BLKRRPART  _IO(0x12,95)
++	    case BLKRRPART:
++		 KERNEL_DO_SYSCALL(tid,res);
++		 break;
++	    case MTIOCTOP:
++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(MTIOCTOP)", arg3, 
++                    sizeof(struct mtop));
++		 KERNEL_DO_SYSCALL(tid,res);
++		 if (!VG_(is_kerror)(res) && res == 0)
++		     VG_TRACK( post_mem_write,arg3, sizeof(struct mtop));
++		 break;
++
+             /* We don't have any specific information on it, so
+                try to do something reasonable based on direction and
+                size bits.  The encoding scheme is described in
+diff -urN valgrind-20030725.orig/coregrind/vg_unsafe.h valgrind-20030725/coregrind/vg_unsafe.h
+--- valgrind-20030725.orig/coregrind/vg_unsafe.h	2003-06-14 02:50:27.000000000 -0600
++++ valgrind-20030725/coregrind/vg_unsafe.h	2003-08-10 03:25:33.000000000 -0600
+@@ -58,6 +58,11 @@
+ #include <sys/user.h>     /* for struct user_regs_struct et al */
+ #include <signal.h>       /* for siginfo_t */
+ 
++#include <scsi/scsi.h>    /* for a few SCSI ioctls */
++#include <scsi/scsi_ioctl.h>/* for even more SCSI ioctls */
++#include <linux/hdreg.h>  /* for ide ioctls */
++#include <sys/mtio.h>     /* for tape drive junk */
++
+ #define __USE_LARGEFILE64
+ #include <sys/stat.h>     /* for struct stat */
+ #undef __USE_LARGEFILE64
+diff -urN valgrind-20030725.orig/valgrind.patch valgrind-20030725/valgrind.patch
+--- valgrind-20030725.orig/valgrind.patch	1969-12-31 17:00:00.000000000 -0700
++++ valgrind-20030725/valgrind.patch	2003-08-10 03:25:25.000000000 -0600
+@@ -0,0 +1,122 @@
++diff -urN valgrind-1.9.4.orig/coregrind/vg_unsafe.h valgrind-1.9.4/coregrind/vg_unsafe.h
++--- valgrind-1.9.4.orig/coregrind/vg_unsafe.h	2002-10-05 09:18:27.000000000 -0600
+++++ valgrind-1.9.4/coregrind/vg_unsafe.h	2003-03-02 03:06:22.000000000 -0700
++@@ -56,6 +56,11 @@
++ #include <linux/cdrom.h>  /* for cd-rom ioctls */
++ #include <sys/user.h>     /* for struct user_regs_struct et al */
++ 
+++#include <scsi/scsi.h>    /* for a few SCSI ioctls */
+++#include <scsi/scsi_ioctl.h>/* for even more SCSI ioctls */
+++#include <linux/hdreg.h>  /* for ide ioctls */
+++#include <sys/mtio.h>     /* for tape drive junk */
+++
++ #define __USE_LARGEFILE64
++ #include <sys/stat.h>     /* for struct stat */
++ #undef __USE_LARGEFILE64
++--- valgrind-1.9.6/coregrind/vg_syscalls.c.orig	2003-05-04 18:15:41.000000000 -0600
+++++ valgrind-1.9.6/coregrind/vg_syscalls.c	2003-07-02 01:59:16.000000000 -0600
++@@ -2389,6 +2389,104 @@
++                KERNEL_DO_SYSCALL(tid,res);
++                break;
++ 
+++	    /* Stuff added by Erik Andersen for general device probing/handling */
+++#define BLKSSZGET  _IO(0x12,104)
+++	    case BLKSSZGET:
+++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(BLKSSZGET)", arg3, 
+++                    sizeof(int));
+++		 KERNEL_DO_SYSCALL(tid,res);
+++		 if (!VG_(is_kerror)(res) && res == 0)
+++		     VG_TRACK( post_mem_write,arg3, sizeof(int));
+++		 break;
+++#define BLKGETSIZE64 _IOR(0x12,114,sizeof(unsigned long long*))
+++	    case BLKGETSIZE64:
+++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(BLKGETSIZE64)", arg3, 
+++                    sizeof(unsigned long long));
+++		 KERNEL_DO_SYSCALL(tid,res);
+++		 if (!VG_(is_kerror)(res) && res == 0)
+++		     VG_TRACK( post_mem_write,arg3, sizeof(unsigned long long));
+++		 break;
+++	    case HDIO_GETGEO:
+++		 {
+++		     struct hd_geometry {
+++			 unsigned char heads;
+++			 unsigned char sectors;
+++			 unsigned short cylinders;
+++			 unsigned long start;
+++		     };
+++
+++		     SYSCALL_TRACK( pre_mem_write, tst, "ioctl(HDIO_GETGEO)", arg3, 
+++			     sizeof(struct hd_geometry));
+++		     KERNEL_DO_SYSCALL(tid,res);
+++		     if (!VG_(is_kerror)(res) && res == 0)
+++			 VG_TRACK( post_mem_write,arg3, sizeof(struct hd_geometry));
+++		 }
+++		 break;
+++	    case HDIO_GET_IDENTITY:
+++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(HDIO_GET_IDENTITY)", arg3, 
+++                    sizeof(struct hd_driveid));
+++		 KERNEL_DO_SYSCALL(tid,res);
+++		 if (!VG_(is_kerror)(res) && res == 0)
+++		     VG_TRACK( post_mem_write,arg3, sizeof(struct hd_driveid));
+++		 break;
+++	    case SCSI_IOCTL_GET_IDLUN:
+++		 {
+++		     struct scsi_idlun
+++		     {
+++			 int mux4;
+++			 int host_unique_id;
+++
+++		     };
+++
+++		     SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_GET_IDLUN)", arg3, 
+++			     sizeof(struct scsi_idlun));
+++		     KERNEL_DO_SYSCALL(tid,res);
+++		     if (!VG_(is_kerror)(res) && res == 0)
+++			 VG_TRACK( post_mem_write,arg3, sizeof(struct scsi_idlun));
+++		 }
+++		 break;
+++	    case SCSI_IOCTL_SEND_COMMAND:
+++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_SEND_COMMAND)", arg3, 
+++                    ((2 * sizeof(unsigned int)) + 6 + 512));
+++		 KERNEL_DO_SYSCALL(tid,res);
+++		 if (!VG_(is_kerror)(res) && res == 0)
+++		     VG_TRACK( post_mem_write,arg3, ((2 * sizeof(unsigned int)) + 6 + 512));
+++		 break;
+++	    case SCSI_IOCTL_GET_BUS_NUMBER:
+++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_GET_BUS_NUMBER)", arg3, 
+++                    sizeof(int));
+++		 KERNEL_DO_SYSCALL(tid,res);
+++		 if (!VG_(is_kerror)(res) && res == 0)
+++		     VG_TRACK( post_mem_write,arg3, sizeof(int));
+++		 break;
+++	    case SCSI_IOCTL_PROBE_HOST:
+++		 {
+++		     int xxxx;
+++		     char *array = (char*)arg3;
+++		     xxxx = array[0] + (array[1]<<8) + (array[2]<<16) + (array[3]<<24);
+++		     SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_PROBE_HOST)", arg3, 
+++			     sizeof(int));
+++		     KERNEL_DO_SYSCALL(tid,res);
+++		     if (!VG_(is_kerror)(res) && res == 0)
+++			 VG_TRACK( post_mem_write,arg3, sizeof(int));
+++		 }
+++		 break;
+++#define BLKFLSBUF  _IO(0x12,97)
+++	    case BLKFLSBUF:
+++		 KERNEL_DO_SYSCALL(tid,res);
+++		 break;
+++#define BLKRRPART  _IO(0x12,95)
+++	    case BLKRRPART:
+++		 KERNEL_DO_SYSCALL(tid,res);
+++		 break;
+++	    case MTIOCTOP:
+++                 SYSCALL_TRACK( pre_mem_write, tst, "ioctl(MTIOCTOP)", arg3, 
+++                    sizeof(struct mtop));
+++		 KERNEL_DO_SYSCALL(tid,res);
+++		 if (!VG_(is_kerror)(res) && res == 0)
+++		     VG_TRACK( post_mem_write,arg3, sizeof(struct mtop));
+++		 break;
+++
++             /* We don't have any specific information on it, so
++                try to do something reasonable based on direction and
++                size bits.  The encoding scheme is described in
diff --git a/sources/valgrind.patch.bz2 b/sources/valgrind.patch.bz2
deleted file mode 100644
index 81d23609cec39c8a43da2aa5d9549c0063776397..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1868
zcmV-S2ebG>T4*^jL0KkKS@p)ph5!dg|A2BfKtOr_|NsB*|GK~b|N3AE9=zM`le%{9
z;We6zRcvizMzYfkkR?4$rlTfmJw`)n0kt$VWB>y|XlOJZpwQsRG-v}Rn1-4RgAl?7
zfYFJF&;S9!kZ8~bO)(8L83rMQ4FRJQ5ugA8B1E32qGBq4p)jYE^*{p<3?OI#8UXZ7
z03wJ&Q}IShAEQcnN2%#ENcA+tVGT4kMw)}vXaE`nkpeU{O$m^u(ULSYG}CDVOpO2l
z00T$&ix8@D?}4osLjuDH5HKME0bfPb2$xd_X19c*N7W(+VDxk^yT<;5TV3c80`FpI
z;<2S>2tyU4keEq7;m_J3DzI&^AvH<_0drFn#R^dn+%u>(n{knymr{%n9K%v<O+pGA
z-TDNn0W65hZG#jyx=)`3EIA;GA_E^gakqxZsr5I#ZU!1Ho7RBe2oMR<fHTOXX^Oc=
z4nzzW2Z-#yC`*c7Z&P{?7moL5=AaZ~#nc0z>j`OnEKwz2gJxz?#~FH9*~(KkpvpUM
z1c{c?*d+^L)rDa-JE8kr6kx2ipq-lhMUQpIKd+#%jqg^NcNL{JQY8uP5JoieAfvLg
zM%ksH!`73cV+rS?3_{Nj;M;uiZTk*-yz?inv3<%0vmo@)b`V+(gJ8pA27_J4RKDQ_
zAqT?vc)vDjyyS(xOT&m|4zeBE0n`j7*K(oBe=la&A<^8pwL-UjCSSb<m?FMGlC71E
zPrXpZv54m?#CeZn(=e#0ltLk4=GyV5{45%EPPh`W?<%A(Xe1a233y<y*oNW}o~Mtc
z4_&YqN*vobqQyAov#!O+a0L$V8v=JFvcv2KV7N-D(Co6)8DH&NIHUxu66eAcL`Q&`
z_^euvU8sSbP?1M<Hc?5)mkQf*>WpLBI2kOw!I}iOfLtZ8fGfGCpbw-CfL+2BARuL%
z$X<35g}<Iao3z{k<4)1ADGAj3TL#A(6M$mkb&MAfF6p&Z-N<7cc?2D1>maq)+1<<J
zuD;?14(&FE&{Q_r7?7UZ&fK42V==D8iMSsTvMvkzfXwP<5h0rf+sz8askDv)RU%_`
z*mwR$@c3g6zP}Hzn$WSzo$Om*FM$^7WIGV!+m%az=sOb9{rAl51Ii>R<z8-aD4qo4
z*dh7;|B@u1QSBIO^ENu=UgQKv>~oNb+5J)v88TuhBloqG)Z}%8D1{}Cn1lIQQTWRN
z&okdDO|vumL9J{piW;ysurMbBwr0?)0@pqOjo345Ga?gN#5>C;NXTPgGIHdL#2=TD
zU<Lw34n>>L+#(1@Mkdf%0eTC#o6W{peClO%491xP_~u+#pqT<S7~)HT!Vxe`s!+VV
zgBK(k${3s+7o0?XVn*}8gl;#pHru^xSr{e-RwaPHV|z?|RuwIbXAuy$n@s{O5M5%}
zF;to4;%71@q;_+4pwywZ-&|`np%<pSLGFA0-@Ad#MNWlv0@<~YF`G=mio^yFIwlpV
za8{tOK?D;Wh@2`L+YbMg9s>i;#J^vhJLqQK6+^^_EvixidPFlW>XY!IJ4imKLX>aw
z31OO#w}a(Kgamv@JbiH9sjX5!y}a#=Y1-Vb+GUFo)jy{sRXkNvkn}BK+iALRDL$Fg
zm(`KUcKZhKpcAN+;0%|U3X~FQ%K(6sD<baXk}W-CrVB%c`-2bZB$5xI#+1F5*MXx&
zH?0X*2HR{pm`4tB&Hq31uN!&iuL#Dj_^?3^fZ-$;vMRv7HpR1+hD<18@#68Ch=u^M
zEW{X2Ex(D|;v3QjS(7rsZeD^6$!3rbZWhBpd2i^2G)Rib8uWs&<qA!3YY<{c<|0H5
zRCNU=wGz@Zp+neK>zJ|{#l2r`PFzEc1uo=H^)1tqAu5IK8DWrKIs(R{R1IenQI|dg
zCCv!UChc}x0_eFdJGwY(Y|2g{LWX~;4JHsdYYZ<y{Pqw&PPPIecQ&Y4pxP3G$VWyL
zSV7GulD#Xh4&I+RHN3GvEEO$OuUt5@2q~-BK@f{`xuag>NwYN@Y=?wolbB;5N--RG
zY%G#I)E3S~Qy4k~`a%?tqzq8I4Ti0xCv8E*wd9@&2VoR0f}JxOlD#UF)C<sb)Jvr(
z&!3qCU!I%Iw%K-4f(bB+BV)oK%*?c84*QcGI-*jl3nHMeu8VELc3BLL1Uo>*C}g3o
z_3ry1x`Z)nd8gA|#43phn=?NY2M~e>)c;{7NfEI&8?>uZbwPx1492N;dJ<83MCA^<
zxE+b&mB=I2^gM)<aN)yH_~?#~_Vys^5hG77Ma&x}WTt1`aj#bPM!Sa`Wd@{PGGI3#
z<E14L88VbuK|jo3v5x|22i(g<3v)tx$nRj{T!+V+I+y<4jB={#4@~6$pg3S`Lmf+<
z_;yYPQ4-5uW;b_gB=Zbk2pJ?C$2so<On`JxEhXpdIYL1Fj>0trUsgcR{9VZu;X*^#
G8y*;#lutbX

-- 
2.30.2