728* driver/systrace.c: Bug fix for /proc/dtrace/syscall - SIGSEGV

          and confusion on 32b kernel.

Author: dtrace4linux

.release

@@ -1,3 +1,3 @@
-date=Thu Jul 26 21:47:57 BST 2012
-release=dtrace-20120726d
-build=402
+date=Fri Jul 27 22:57:26 BST 2012
+release=dtrace-20120727
+build=403

Changes

@@ -1,3 +1,12 @@
+Fri Jul 27 13:27:25 2012  fox
+
+     728* driver/systrace.c: Bug fix for /proc/dtrace/syscall - SIGSEGV
+          and confusion on 32b kernel.
+
+     727* libproc/common/Pcontrol.c: Use the /dev/dtrace_ctl driver instead
+          of ptrace(). We can now use PID provider on stopped jobs or even
+	  procs being debugged in a debugger.
+
 Thu Jul 26 08:33:03 2012  fox
 
      726* archive: 1.0140

driver/ctl.c

@@ -81,7 +81,7 @@ present.
 #define PCSZONE  30L    /* set zoneid from zoneid_t argument */
 #define PCSCREDX 31L    /* as PCSCRED but with supplemental groups */
 
-void *(*fn_get_pid_task)(void *, int); 
+static void (*__put_task_struct_ptr)(struct task_struct *);
 static int (*access_process_vm_ptr)(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
 
 #if 0
@@ -215,31 +215,63 @@ ctl_linux_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsign
 
 	  	if (copyin((void *) arg, &mem, sizeof mem))
 			return -EFAULT;
+		if (mem.c_len <= 0)
+			return -EINVAL;
 
-#if 0
+		/***********************************************/
+		/*   Convert  PID to a process structure, but  */
+		/*   special locking required in case process  */
+		/*   tries         to         die.        The  */
+		/*   get_task_struct/put_task_struct modifies  */
+		/*   a lock counter.			       */
+		/***********************************************/
 		rcu_read_lock();
-//		child = find_task_by_vpid(mem.c_pid);
+		child = find_task_by_vpid(mem.c_pid);
 		if (child)
 			get_task_struct(child);
 		rcu_read_unlock();
 		if (child == NULL)
 			return -ESRCH;
-#endif
 
 		src = mem.c_src;
 		dst = mem.c_dst;
 		for (len = mem.c_len; len > 0; ) {
 			int	sz = len > sizeof buf ? sizeof buf : len;
 			int	sz1;
 
-			sz1 = access_process_vm_ptr(child, (unsigned long) src, buf, sz, 
-				cmd == CTLIOC_RDMEM ? 0 : 1);
-			if (sz1 <= 0)
-				break;
-			if (copyout(buf, dst, sz1))
-				return -EFAULT;
+			if (cmd == CTLIOC_RDMEM) {
+				sz1 = access_process_vm_ptr(child, 
+					(unsigned long) src, buf, sz, 0);
+printk("sz1=%d sz=%d\n", sz1, sz);
+				if (sz1 <= 0)
+					break;
+printk("access_process_vm_ptr %p %p returns %d\n", src, dst, sz1);
+				if (copy_to_user(dst, buf, sz1)) {
+					n = -EFAULT;
+					break;
+				}
+			} else {
+				if (copy_from_user(buf, src, sz)) {
+					n = -EFAULT;
+					break;
+				}
+				sz1 = access_process_vm_ptr(child, (unsigned long) dst, buf, sz, 1);
+				if (sz1 <= 0)
+					break;
+			}
+			src += sz1;
+			dst += sz1;
 			len -= sz1;
+			n += sz1;
 			}
+
+		/***********************************************/
+		/*   Unlock the target now we are done.	       */
+		/***********************************************/
+		// put_task_struct(child); GPL
+		if (atomic_dec_and_test(&child->usage))
+			__put_task_struct_ptr(child);
+
 	  	return n;
 		}
 
@@ -286,6 +318,8 @@ static struct miscdevice ctl_dev = {
 int ctl_init(void)
 {	int	ret;
 
+	__put_task_struct_ptr = get_proc_addr("__put_task_struct");
+
 	ret = misc_register(&ctl_dev);
 	if (ret) {
 		printk(KERN_WARNING "ctl: Unable to register misc device\n");

driver/systrace.c

@@ -131,6 +131,8 @@ static char *syscallnames32[] = {
 	};
 # define NSYSCALL32 (sizeof syscallnames32 / sizeof syscallnames32[0])
 
+int xx = NSYSCALL;
+int xx32 = NSYSCALL32;
 struct sysent {
         asmlinkage int64_t         (*sy_callc)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);  /* C-style call hander or wrapper */
 };
@@ -2176,7 +2178,10 @@ static int sys_seq_show(struct seq_file *seq, void *v)
 	n -= 2;
 	if (n >= NSYSCALL + NSYSCALL32)
 		return 0;
-
+# if defined(__i386)
+	if (n >= NSYSCALL)
+		return 0;
+# endif
 	if (n >= NSYSCALL) {
 		sysp = &systrace_sysent32[n - NSYSCALL];
 		syp = &sysent32[n - NSYSCALL];
@@ -2186,7 +2191,11 @@ static int sys_seq_show(struct seq_file *seq, void *v)
 	}
 
 	seq_printf(seq, "%s%s %p %p %3d %8llu %s\n",
+# if defined(__i386)
+		"x32",
+# else
 		n >= NSYSCALL ? "x32" : "x64",
+# endif
 		syp->sy_callc == sysp->stsy_underlying ? " " : "*",
 		syp->sy_callc, sysp->stsy_underlying,
 		(int) (n >= NSYSCALL ? n - NSYSCALL : n),

include/ctl.h

@@ -0,0 +1,24 @@
+/**********************************************************************/
+/*   Driver  for  allowing direct access to process memory - similar  */
+/*   to /proc/pid/mem, but bypassing various restrictions which mean  */
+/*   that  dtrace  can  have trouble ptrace() attaching to a process  */
+/*   which is being debugged.					      */
+/**********************************************************************/
+
+#if !defined(_CTL_H_INCLUDE)
+# define _CTL_H_INCLUDE
+
+/**********************************************************************/
+/*   ioctl values and structures for /dev/dtrace_ctl		      */
+/**********************************************************************/
+#define	CTLIOC	(('c' << 24) | ('t' << 16) | ('l' << 8))
+#define CTLIOC_RDMEM	(CTLIOC | 1)
+#define CTLIOC_WRMEM	(CTLIOC | 2)
+typedef struct ctl_mem_t {
+	int	c_pid;
+	void	*c_src;
+	void	*c_dst;
+	int	c_len;
+	} ctl_mem_t;
+
+#endif /* _CTL_H_INCLUDE */

libdtrace/dt_proc.c

@@ -737,7 +737,7 @@ dt_proc_destroy(dtrace_hdl_t *dtp, struct ps_prochandle *P)
 	 * an external debugger and we were waiting in dt_proc_waitrun().
 	 * Leave the process in this condition using PRELEASE_HANG.
 	 */
-printf("dt_proc_destroy flags=%d\n", Pstatus(dpr->dpr_proc)->pr_flags);
+/*printf("dt_proc_destroy flags=%d\n", Pstatus(dpr->dpr_proc)->pr_flags);*/
 	if (!(Pstatus(dpr->dpr_proc)->pr_flags & (PR_KLC | PR_RLC))) {
 		dt_dprintf("abandoning pid %d\n", (int)dpr->dpr_pid);
 		rflag = PRELEASE_HANG;

libproc/common/Pcontrol.c

@@ -52,6 +52,7 @@
 #include <sys/sysmacros.h>
 # if linux
 #include <sys/ptrace.h>
+#include "../../include/ctl.h"
 # endif
 
 
@@ -93,6 +94,23 @@ static ssize_t
 Pread_live(struct ps_prochandle *P, void *buf, size_t n, uintptr_t addr)
 {
 # if linux
+	static int fd = -1;
+	ctl_mem_t ctl;
+
+	if (fd < 0) {
+		if ((fd = open("/dev/dtrace_ctl", O_RDWR)) < 0) {
+			perror("/dev/dtrace_ctl");
+			printf("Either dtrace kernel module is not loaded or you are not root.\n");
+			return -1;
+		}
+	}
+
+	ctl.c_pid = P->pid;
+	ctl.c_src = addr;
+	ctl.c_dst = buf;
+	ctl.c_len = n;
+	return ioctl(fd, CTLIOC_RDMEM, &ctl);
+
 	// HACK: this is horrible from a performance perspective,
 	// and we need to be root to attach, but pread() wont
 	// work unless we own the proc. We need to move this to

libproc/common/Psymtab.c

@@ -103,6 +103,7 @@ get_saddrs(struct ps_prochandle *P, uintptr_t ehdr_start, uint_t *n)
 	uintptr_t a, addr, *addrs, last = 0;
 	uint_t i, naddrs = 0, unordered = 0;
 
+printf("model=%lx\n", P->status.pr_dmodel);
 	if (P->status.pr_dmodel == PR_MODEL_ILP32) {
 		Elf32_Ehdr ehdr;
 		Elf32_Phdr phdr;
@@ -159,6 +160,10 @@ get_saddrs(struct ps_prochandle *P, uintptr_t ehdr_start, uint_t *n)
 			addrs[naddrs++] = last = addr + phdr.p_memsz - 1;
 		}
 #endif
+	} else {
+		printf("Internal error: %s:%s pr_dmodel is incorrect\n",
+			__FILE__, __func__);
+		abort();
 	}
 
 	if (unordered)

tests/ctl.c

@@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include "../include/ctl.h"
+
+char	buf[2 * 1024 * 1024];
+
+static void
+dump_mem(char *start, char *mem, char *memend)
+{	char	*cp;
+	int	i;
+
+        for (cp = mem; cp < memend; cp += 16) {
+                printf("%04lx: ", cp - start);
+                for (i = 0; i < 16 && cp + i < memend; i++) {
+                        printf("%02x ", cp[i] & 0xff);
+                }
+                printf("\n");
+        }
+}
+
+int main(int argc, char **argv)
+{	int	arg_index = 1;
+	int	ret, cmd;
+	int	fd;
+	ctl_mem_t ctl;
+
+	if (argc < 5) {
+		printf("usage: ctl [rd | wr] pid addr len\n");
+		exit(1);
+	}
+
+	fd = open("/dev/dtrace_ctl", O_RDWR);
+	if (fd < 0) {
+		perror("/dev/dtrace_ctl");
+		exit(1);
+		}
+
+	if (strcmp(argv[arg_index++], "rd") == 0) {
+		ctl.c_pid = atoi(argv[arg_index++]);
+		cmd = CTLIOC_RDMEM;
+		ctl.c_dst = buf;
+		ctl.c_src = strtoul(argv[arg_index++], NULL, 0);
+	} else {
+		ctl.c_pid = atoi(argv[arg_index++]);
+		cmd = CTLIOC_WRMEM;
+		ctl.c_src = buf;
+		ctl.c_dst = strtoul(argv[arg_index++], NULL, 0);
+	}
+	ctl.c_len = atoi(argv[arg_index++]);
+
+	printf("pid=%d src=%p dst=%p len=%d\n",
+		ctl.c_pid, ctl.c_src, ctl.c_dst, ctl.c_len);
+	if ((ret = ioctl(fd, cmd, &ctl)) < 0) {
+		perror("ioctl");
+		exit(1);
+		}
+	printf("ret=%d\n", ret);
+	dump_mem(buf, buf, buf + ret);
+}