jeans/motioneyeos
jeans/motioneyeos
1
0
Fork 0
mirror of https://github.com/motioneye-project/motioneyeos.git synced 2025-07-26 04:36:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Upgrade valgrind

Browse Source
This commit is contained in:
Eric Andersen 2003-10-19 07:36:18 +00:00
parent 83b95bdb42
commit 3c913b59bf
2 changed files with 38 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
make/valgrind.mk
View File

@ -5,8 +5,8 @@
############################################################# #############################################################
VALGRIND_SITE:=http://developer.kde.org/~sewardj VALGRIND_SITE:=http://developer.kde.org/~sewardj
VALGRIND_DIR:=$(BUILD_DIR)/valgrind-20030725 VALGRIND_DIR:=$(BUILD_DIR)/valgrind-20031012
VALGRIND_SOURCE:=valgrind-20030725.tar.bz2 VALGRIND_SOURCE:=valgrind-20031012.tar.bz2
VALGRIND_PATCH:=$(SOURCE_DIR)/valgrind.patch VALGRIND_PATCH:=$(SOURCE_DIR)/valgrind.patch
$(DL_DIR)/$(VALGRIND_SOURCE): $(DL_DIR)/$(VALGRIND_SOURCE):

198
sources/valgrind.patch
View File

@ -1,6 +1,6 @@
diff -urN valgrind-20030725.orig/coregrind/vg_intercept.c valgrind-20030725/coregrind/vg_intercept.c 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.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 +++ valgrind-20030725/coregrind/vg_intercept.c 2003-10-13 15:06:33.000000000 -0600
@@ -827,8 +827,10 @@ @@ -827,8 +827,10 @@
void VG_(__libc_freeres_wrapper)( void ) void VG_(__libc_freeres_wrapper)( void )
{ {
@ -14,7 +14,7 @@ diff -urN valgrind-20030725.orig/coregrind/vg_intercept.c valgrind-20030725/core
/*NOTREACHED*/ /*NOTREACHED*/
diff -urN valgrind-20030725.orig/coregrind/vg_libpthread.c valgrind-20030725/coregrind/vg_libpthread.c 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.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 +++ valgrind-20030725/coregrind/vg_libpthread.c 2003-10-13 15:06:33.000000000 -0600
@@ -3124,6 +3124,8 @@ @@ -3124,6 +3124,8 @@
/* I've no idea what these are, but they get called quite a lot. /* I've no idea what these are, but they get called quite a lot.
Anybody know? */ Anybody know? */
@ -34,28 +34,29 @@ diff -urN valgrind-20030725.orig/coregrind/vg_libpthread.c valgrind-20030725/cor
interface, but many people complain about its absence. */ interface, but many people complain about its absence. */
diff -urN valgrind-20030725.orig/coregrind/vg_syscalls.c valgrind-20030725/coregrind/vg_syscalls.c 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.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 +++ valgrind-20030725/coregrind/vg_syscalls.c 2003-10-13 16:35:33.000000000 -0600
@@ -2427,6 +2427,104 @@ @@ -2427,6 +2427,119 @@
KERNEL_DO_SYSCALL(tid,res); KERNEL_DO_SYSCALL(tid,res);
break; break;
+ /* Stuff added by Erik Andersen for general device probing/handling */ + /* Stuff added by Erik Andersen for general device probing/handling */
+#define BLKSSZGET _IO(0x12,104) +#define BLKSSZGET _IO(0x12,104)
+ case BLKSSZGET: + case BLKSSZGET:
+ SYSCALL_TRACK( pre_mem_write, tst, "ioctl(BLKSSZGET)", arg3, + SYSCALL_TRACK( pre_mem_write, tid, "ioctl(BLKSSZGET)", arg3,
+ sizeof(int)); + sizeof(int));
+ KERNEL_DO_SYSCALL(tid,res); + KERNEL_DO_SYSCALL(tid,res);
+ if (!VG_(is_kerror)(res) && res == 0) + if (!VG_(is_kerror)(res) && res == 0)
+ VG_TRACK( post_mem_write,arg3, sizeof(int)); + VG_TRACK( post_mem_write,arg3, sizeof(int));
+ break; + break;
+#define BLKGETSIZE64 _IOR(0x12,114,sizeof(unsigned long long*)) +#define BLKGETSIZE64 _IOR(0x12,114,sizeof(unsigned long long*))
+ case BLKGETSIZE64: + case BLKGETSIZE64:
+ SYSCALL_TRACK( pre_mem_write, tst, "ioctl(BLKGETSIZE64)", arg3, + SYSCALL_TRACK( pre_mem_write, tid, "ioctl(BLKGETSIZE64)", arg3,
+ sizeof(unsigned long long)); + sizeof(unsigned long long));
+ KERNEL_DO_SYSCALL(tid,res); + KERNEL_DO_SYSCALL(tid,res);
+ if (!VG_(is_kerror)(res) && res == 0) + if (!VG_(is_kerror)(res) && res == 0)
+ VG_TRACK( post_mem_write,arg3, sizeof(unsigned long long)); + VG_TRACK( post_mem_write,arg3, sizeof(unsigned long long));
+ break; + break;
+#define HDIO_GETGEO 0x0301 /* get device geometry */
+ case HDIO_GETGEO: + case HDIO_GETGEO:
+ { + {
+ struct hd_geometry { + struct hd_geometry {
@ -65,20 +66,23 @@ diff -urN valgrind-20030725.orig/coregrind/vg_syscalls.c valgrind-20030725/coreg
+ unsigned long start; + unsigned long start;
+ }; + };
+ +
+ SYSCALL_TRACK( pre_mem_write, tst, "ioctl(HDIO_GETGEO)", arg3, + SYSCALL_TRACK( pre_mem_write, tid, "ioctl(HDIO_GETGEO)", arg3,
+ sizeof(struct hd_geometry)); + sizeof(struct hd_geometry));
+ KERNEL_DO_SYSCALL(tid,res); + KERNEL_DO_SYSCALL(tid,res);
+ if (!VG_(is_kerror)(res) && res == 0) + if (!VG_(is_kerror)(res) && res == 0)
+ VG_TRACK( post_mem_write,arg3, sizeof(struct hd_geometry)); + VG_TRACK( post_mem_write,arg3, sizeof(struct hd_geometry));
+ } + }
+ break; + break;
+#define HDIO_GET_IDENTITY 0x030d /* get IDE identification info */
+#define struct_hd_driveid_size 256 /* ATA6 specifies words 0-255 */
+ case HDIO_GET_IDENTITY: + case HDIO_GET_IDENTITY:
+ SYSCALL_TRACK( pre_mem_write, tst, "ioctl(HDIO_GET_IDENTITY)", arg3, + SYSCALL_TRACK( pre_mem_write, tid, "ioctl(HDIO_GET_IDENTITY)", arg3,
+ sizeof(struct hd_driveid)); + struct_hd_driveid_size);
+ KERNEL_DO_SYSCALL(tid,res); + KERNEL_DO_SYSCALL(tid,res);
+ if (!VG_(is_kerror)(res) && res == 0) + if (!VG_(is_kerror)(res) && res == 0)
+ VG_TRACK( post_mem_write,arg3, sizeof(struct hd_driveid)); + VG_TRACK( post_mem_write,arg3, struct_hd_driveid_size);
+ break; + break;
+#define SCSI_IOCTL_GET_IDLUN 0x5382
+ case SCSI_IOCTL_GET_IDLUN: + case SCSI_IOCTL_GET_IDLUN:
+ { + {
+ struct scsi_idlun + struct scsi_idlun
@ -88,33 +92,36 @@ diff -urN valgrind-20030725.orig/coregrind/vg_syscalls.c valgrind-20030725/coreg
+ +
+ }; + };
+ +
+ SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_GET_IDLUN)", arg3, + SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SCSI_IOCTL_GET_IDLUN)", arg3,
+ sizeof(struct scsi_idlun)); + sizeof(struct scsi_idlun));
+ KERNEL_DO_SYSCALL(tid,res); + KERNEL_DO_SYSCALL(tid,res);
+ if (!VG_(is_kerror)(res) && res == 0) + if (!VG_(is_kerror)(res) && res == 0)
+ VG_TRACK( post_mem_write,arg3, sizeof(struct scsi_idlun)); + VG_TRACK( post_mem_write,arg3, sizeof(struct scsi_idlun));
+ } + }
+ break; + break;
+#define SCSI_IOCTL_SEND_COMMAND 1
+ case SCSI_IOCTL_SEND_COMMAND: + case SCSI_IOCTL_SEND_COMMAND:
+ SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_SEND_COMMAND)", arg3, + SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SCSI_IOCTL_SEND_COMMAND)", arg3,
+ ((2 * sizeof(unsigned int)) + 6 + 512)); + ((2 * sizeof(unsigned int)) + 6 + 512));
+ KERNEL_DO_SYSCALL(tid,res); + KERNEL_DO_SYSCALL(tid,res);
+ if (!VG_(is_kerror)(res) && res == 0) + if (!VG_(is_kerror)(res) && res == 0)
+ VG_TRACK( post_mem_write,arg3, ((2 * sizeof(unsigned int)) + 6 + 512)); + VG_TRACK( post_mem_write,arg3, ((2 * sizeof(unsigned int)) + 6 + 512));
+ break; + break;
+#define SCSI_IOCTL_GET_BUS_NUMBER 0x5386
+ case SCSI_IOCTL_GET_BUS_NUMBER: + case SCSI_IOCTL_GET_BUS_NUMBER:
+ SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_GET_BUS_NUMBER)", arg3, + SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SCSI_IOCTL_GET_BUS_NUMBER)", arg3,
+ sizeof(int)); + sizeof(int));
+ KERNEL_DO_SYSCALL(tid,res); + KERNEL_DO_SYSCALL(tid,res);
+ if (!VG_(is_kerror)(res) && res == 0) + if (!VG_(is_kerror)(res) && res == 0)
+ VG_TRACK( post_mem_write,arg3, sizeof(int)); + VG_TRACK( post_mem_write,arg3, sizeof(int));
+ break; + break;
+#define SCSI_IOCTL_PROBE_HOST 0x5385
+ case SCSI_IOCTL_PROBE_HOST: + case SCSI_IOCTL_PROBE_HOST:
+ { + {
+ int xxxx; + int xxxx;
+ char *array = (char*)arg3; + char *array = (char*)arg3;
+ xxxx = array[0] + (array[1]<<8) + (array[2]<<16) + (array[3]<<24); + xxxx = array[0] + (array[1]<<8) + (array[2]<<16) + (array[3]<<24);
+ SYSCALL_TRACK( pre_mem_write, tst, "ioctl(SCSI_IOCTL_PROBE_HOST)", arg3, + SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SCSI_IOCTL_PROBE_HOST)", arg3,
+ sizeof(int)); + sizeof(int));
+ KERNEL_DO_SYSCALL(tid,res); + KERNEL_DO_SYSCALL(tid,res);
+ if (!VG_(is_kerror)(res) && res == 0) + if (!VG_(is_kerror)(res) && res == 0)
@ -129,155 +136,22 @@ diff -urN valgrind-20030725.orig/coregrind/vg_syscalls.c valgrind-20030725/coreg
+ case BLKRRPART: + case BLKRRPART:
+ KERNEL_DO_SYSCALL(tid,res); + KERNEL_DO_SYSCALL(tid,res);
+ break; + break;
+#define MTIOCTOP _IO(0x6d,0x1)
+ case MTIOCTOP: + case MTIOCTOP:
+ SYSCALL_TRACK( pre_mem_write, tst, "ioctl(MTIOCTOP)", arg3, + {
+ sizeof(struct mtop)); + struct mtop
+ KERNEL_DO_SYSCALL(tid,res); + {
+ if (!VG_(is_kerror)(res) && res == 0) + short int mt_op; /* Operations defined below. */
+ VG_TRACK( post_mem_write,arg3, sizeof(struct mtop)); + int mt_count; /* How many of them. */
+ };
+ SYSCALL_TRACK( pre_mem_write, tid, "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; + break;
+ +
/* We don't have any specific information on it, so /* We don't have any specific information on it, so
try to do something reasonable based on direction and try to do something reasonable based on direction and
size bits. The encoding scheme is described in 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