Add support for SDT probes.

Author: dtrace4linux

Changes

@@ -1,3 +1,18 @@
+Sat Oct 19 17:47:23 2013  fox
+
+     844* driver/dtrace_linux.c: Fix for /proc/dtrace/trace on 3.11 kernel
+          which doesnt like big blobs of output.
+
+Fri Oct 18 22:51:33 2013  fox
+
+     843* driver/systrace.c: Dont GPF on an amd64 kernel with no
+          32-bit syscalls support when catting /proc/dtrace/syscall.
+
+Thu Oct 17 23:20:00 2013  fox
+
+     842* sdt_linux.c, prov_common.c, dtrace_linux.c: Support for
+          dynamic/private SDT probes in loadable modules.
+
 Sat Oct 12 08:07:40 2013  fox
 
      841* intr.c: Fix for 3.11 kernel (store_gdt)

Packages

@@ -1,6 +1,6 @@
 Linux port of DTrace
 
-Aug 2013
+Oct 2013
 Paul D. Fox
 [email protected]
 http://www.twitter.com/crispeditor
@@ -162,6 +162,16 @@ make unl
 make test
 	To run the userland cmd/dtrace regression test
 
-For AS4/Centos
-==============
-	yum install elfutils-libelf-devel
+Dependencies
+============
+To build dtrace for linux requires a number of tools - mostly
+the basic Unix development tools, plus you will need the kernel
+source/build tree. dtrace does not affect or touch your kernel
+sources, but it needs the normal header files for creating a 
+loadable module.
+
+Examine the following scripts to help identify missing packages:
+
+	tools/get-deps-arch.sh
+	tools/get-deps-fedora.sh
+	tools/get-deps.pl

README

@@ -35,6 +35,8 @@ Working Features
   o ARMv6/RaspberryPi on 3.4.6 kernel (USDT is not tested or likely to work)
     - the instr provider isnt supported (yet)
     - no SMP support
+  o driver-2/hworld.c - example SDT loadable driver, demonstrating dynamic
+    SDT probes. See doc/sdt-probes.txt for more details.
 
 Partially Working / Not yet quality controlled:
 

Status.txt

@@ -1,6 +1,6 @@
 NAME=dtrace
 MAJ_VERSION=1
-MIN_VERSION=0149
+MIN_VERSION=0150
 EXCLUDE="*.ko *.o .git"
 EXCLUDE_DIRS="build-"
-#date Sat Jul 13 17:15:26 BST 2013
+#date Sat Oct 12 09:35:02 BST 2013

archive.sh

@@ -54,7 +54,7 @@ all:
 	@. ../../build/port.sh ; \
 	if [ ! -f /usr/lib/libdwarf.a -a ! -f /usr/lib64/libdwarf.a ]; then \
 		echo "=================================================================" ; \
-		echo "=== You need /usr/lib/libdwarf.a or /ur/lib64/libdwarf.a " ; \
+		echo "=== You need /usr/lib/libdwarf.a or /usr/lib64/libdwarf.a " ; \
 		echo "=== (libdw is not yet supported) to build." ; \
 		echo "=== " ; \
 		echo "=== apt-get install binutils-dev" ; \

cmd/ctfconvert/makefile

@@ -0,0 +1,40 @@
+SDT Probes
+Date: 20 Oct 2013
+
+SDT probes on Solaris are probes which are actual calls to DTrace,
+compiled when the kernel or module is compiled. Calls to variations
+of the DTRACE_PROBE macros insert appropriate markers so
+that these probe points are exposed and can be seen in "dtrace -l".
+
+DTrace for Linux assumes we are not going to change the kernel.
+Changes to the boot-loaded kernel require code to parse out these
+probes and make them a part of DTrace. This is not presently implemented.
+
+However DTrace does provide for SDT probes in dynamically loaded
+modules. The code in driver-2 provides a simple hello-world
+driver which exposes /proc/hello-world. The open() and read()
+code shows the use of SDT probes.
+
+The probes work by calling a dummy function - the dummy function
+is a dtrace mangled name encoding the provider/probename/function,
+and as the driver is loaded, you can see the probes in "dtrace -l"
+and use them as any other probe.
+
+If the driver is unloaded, the probes are removed, as expected, allowing
+debugging of a driver and reloading without causing harm.
+
+These probes are invoked as :
+
+<pre>
+	DTRACE_SDT_PROBE1(hworld, open_module, open1, entry, num_opens);
+</pre>
+
+The first four arguments correspond to the provider,
+module, probename, and function name. These are mostly arbitrary,
+although the module name is *ignored*. The actual driver module
+name is inserted at this point, to ensure the corresponding driver
+unload does the right thing.
+
+The remaining arguments are available as probe arguments. Presently,
+they are typeless (integer), so you would need to cast them to an
+appropriate type if you want to access internal structures.

doc/sdt-probes.txt

@@ -1169,6 +1169,28 @@ static int count;
 	}
 	return NULL;
 }
+/**********************************************************************/
+/*   Convert an address to a function name (if possible).	      */
+/**********************************************************************/
+int
+get_proc_name(unsigned long addr, char *buf)
+{
+	unsigned long symsize = 0;
+	unsigned long offset;
+	char	*modname = NULL;
+static	const char *(*my_kallsyms_lookup)(unsigned long addr,
+                        unsigned long *symbolsize,
+                        unsigned long *offset,
+                        char **modname, char *namebuf);
+
+	*buf = '\0';
+	if (my_kallsyms_lookup == NULL)
+		my_kallsyms_lookup = get_proc_addr("kallsyms_lookup");
+	if (my_kallsyms_lookup == NULL)
+		return 0;
+	my_kallsyms_lookup(addr, &symsize, &offset, &modname, buf);
+	return symsize;
+}
 int
 sulword(const void *addr, ulong_t value)
 {
@@ -2861,12 +2883,6 @@ static struct file_operations proc_dtrace_stats = {
 	.release = single_release
 };
 
-/** "proc/dtrace/trace" */
-static int proc_dtrace_trace_show(struct seq_file *seq, void *v)
-{
-	// TODO: or we can use dtracedrv_read() instead
-	return seq_printf(seq, "%s\n", dtrace_buf);
-}
 /**********************************************************************/
 /*   Special hack for debugging.				      */
 /**********************************************************************/
@@ -2881,9 +2897,74 @@ static ssize_t proc_dtrace_trace_write_proc(struct file *fp, const char __user *
 	return count;
 }
 
+/**********************************************************************/
+/*   Code for /proc/dtrace/trace				      */
+/**********************************************************************/
+
+static void *proc_dtrace_trace_seq_start(struct seq_file *seq, loff_t *pos)
+{
+	if (*pos < log_bufsiz)
+		return pos;
+	return NULL;
+}
+static void *proc_dtrace_trace_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+	(*pos)++;
+	if (*pos >= log_bufsiz / 1024)
+		return NULL;
+
+	return pos;
+}
+static void proc_dtrace_trace_seq_stop(struct seq_file *seq, void *v)
+{
+}
+static int proc_dtrace_trace_seq_show(struct seq_file *seq, void *v)
+{	char	*cp;
+	extern int dbuf_i;
+	loff_t	*pos = v;
+	int	n = (int) (long) *pos;
+	int	n1 = 0;
+
+	if (n >= log_bufsiz)
+		return 0;
+
+	/***********************************************/
+	/*   Skip  any  nulls  since  we may not have  */
+	/*   filled the buffer yet.		       */
+	/***********************************************/
+	cp = dtrace_buf + dbuf_i;
+	for (n1 = 0; n1 < log_bufsiz && *cp == '\0'; n1++) {
+		if (++cp >= &dtrace_buf[log_bufsiz])
+			cp = dtrace_buf;
+	}
+
+	n = (cp - dtrace_buf + n * 1024) % log_bufsiz;
+	cp = dtrace_buf + n;
+
+	/***********************************************/
+	/*   Now  return  the  next  block of text up  */
+	/*   until the circular index.		       */
+	/***********************************************/
+	for (n1 = 0; cp != &dtrace_buf[dbuf_i] && n1 < 1024; ) {
+		if (cp >= &dtrace_buf[log_bufsiz])
+			cp = dtrace_buf;
+		if (*cp && seq_write(seq, cp, 1))
+			break;
+		cp++;
+		//(*pos)++;
+		n1++;
+	}
+	return 0;
+}
+struct seq_operations proc_dtrace_trace_show_ops = {
+	.start = proc_dtrace_trace_seq_start,
+	.next = proc_dtrace_trace_seq_next,
+	.stop = proc_dtrace_trace_seq_stop,
+	.show = proc_dtrace_trace_seq_show,
+	};
 static int proc_dtrace_trace_single_open(struct inode *inode, struct file *file)
 {
-	return single_open(file, &proc_dtrace_trace_show, NULL);
+	return seq_open(file, &proc_dtrace_trace_show_ops);
 }
 static struct file_operations proc_dtrace_trace = {
 	.owner   = THIS_MODULE,
@@ -2894,7 +2975,7 @@ static struct file_operations proc_dtrace_trace = {
 	.write   = proc_dtrace_trace_write_proc
 };
 
-/** \proc */
+/** /proc */
 
 static int dtracedrv_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {	int	ret;

driver/dtrace_linux.c

@@ -368,6 +368,7 @@ typedef struct pf_info_t {
 	uint8_t		*st_value;
 	int		(*func_entry)(struct pf_info_t *, uint8_t *, int, int);
 	int		(*func_return)(struct pf_info_t *, uint8_t *, int);
+	int		(*func_sdt)(struct pf_info_t *, uint8_t *, int, int);
 	void		*retptr;
 	int		flags;
 	} pf_info_t;
@@ -421,6 +422,7 @@ timeout_id_t timeout(void (*func)(void *), void *arg, unsigned long ticks);
 void untimeout(timeout_id_t id);
 void *prcom_get_arg(int n, int size);
 void *par_setup_thread1(struct task_struct *tp);
+int	get_proc_name(unsigned long, char *buf);
 
 /**********************************************************************/
 /*   Some  kernels  dont  define if not SMP, but we define anyway so  */

driver/dtrace_linux.h

@@ -765,7 +765,9 @@ fbt_provide_function(struct modctl *mp, par_module_t *pmp,
 	uint8_t *instr, uint8_t *limit, int symndx)
 {
 	pf_info_t	inf;
+int io_prov_sdt(pf_info_t *infp, uint8_t *instr, int size, int modrm);
 
+	memset(&inf, 0, sizeof inf);
 	inf.mp = mp;
 	inf.pmp = pmp;
 	inf.modname = modname;
@@ -776,6 +778,7 @@ fbt_provide_function(struct modctl *mp, par_module_t *pmp,
 
 	inf.func_entry = fbt_prov_entry;
 	inf.func_return = fbt_prov_return;
+	inf.func_sdt = io_prov_sdt;
 
 	dtrace_parse_function(&inf, instr, limit);
 }