/home/fox/release/dtrace/2009/dtrace-20090510.tar.bz2

dtrace4linux · dtrace4linux · commit 920f76bac126 · 2012-02-08T21:19:44.000Z
diff --git a/.release b/.release
@@ -1,3 +1,3 @@
-date=Sat May 9 16:19:18 BST 2009
-release=dtrace-20090509
-build=83
+date=Sun May 10 22:31:59 BST 2009
+release=dtrace-20090510
+build=84
diff --git a/Changes b/Changes
@@ -1,3 +1,8 @@
+Sun May 10 21:47:15 2009  fox
+
+     263* linux_types.h, driver/*: Use semaphores instead of mutexes
+          since mutexes arent available in interrupt context.
+
 Sat May  9 09:57:35 2009  fox
 
      262* libdtrace/makefile: Put dt_lex.c in the build dir since it 
diff --git a/driver/dtrace.c b/driver/dtrace.c
@@ -248,9 +248,9 @@ static dtrace_dynvar_t  dtrace_dynhash_sink;    /* end of dynamic hash chains */
  * mod_lock is similar with respect to dtrace_provider_lock in that it must be
  * acquired _between_ dtrace_provider_lock and dtrace_lock.
  */
-DEFINE_MUTEX(dtrace_lock);			/* probe state lock */
-DEFINE_MUTEX(dtrace_provider_lock);		/* provider state lock */
-DEFINE_MUTEX(dtrace_meta_lock);			/* meta-provider state lock */
+MUTEX_DEFINE(dtrace_lock);			/* probe state lock */
+MUTEX_DEFINE(dtrace_provider_lock);		/* provider state lock */
+MUTEX_DEFINE(dtrace_meta_lock);			/* meta-provider state lock */
 
 /*
  * DTrace Provider Variables
@@ -314,7 +314,7 @@ int	dtrace_helptrace_enabled = 0;
 static dtrace_errhash_t	dtrace_errhash[DTRACE_ERRHASHSZ];
 static const char *dtrace_errlast;
 static kthread_t *dtrace_errthread;
-static DEFINE_MUTEX(dtrace_errlock);
+static MUTEX_DEFINE(dtrace_errlock);
 #endif
 
 /*
@@ -5822,7 +5822,6 @@ dcnt++;
 		dtrace_interrupt_enable(cookie);
 		return;
 	}
-
 	now = dtrace_gethrtime();
 	vtime = dtrace_vtime_references != 0;
 
@@ -5844,6 +5843,9 @@ dcnt++;
 
 	flags = (volatile uint16_t *)&cpu_core[cpuid].cpuc_dtrace_flags;
 
+//dtrace_interrupt_enable(cookie);
+//return;
+
 	for (ecb = probe->dtpr_ecb; ecb != NULL; ecb = ecb->dte_next) {
 		dtrace_predicate_t *pred = ecb->dte_predicate;
 		dtrace_state_t *state = ecb->dte_state;
@@ -12594,7 +12596,7 @@ dtrace_state_create(struct file *fp, cred_t *cr)
 # else
         /*state->dts_aggid_arena = new_unrhdr(1, INT_MAX, &dtrace_unr_mtx);*/
 
-        state->dts_dev = (dev_t) (long long) fp;
+        state->dts_dev = (dev_t) (uintptr_t *) fp;
 # endif
 
 	/*
diff --git a/driver/dtrace_isa.c b/driver/dtrace_isa.c
@@ -62,7 +62,7 @@ extern size_t _allsyscalls_size;
 /*   We  use  the  kernels  stack  dumper  to  avoid issues with cpu  */
 /*   architecture and frame pointer.				      */
 /**********************************************************************/
-DEFINE_MUTEX(dtrace_stack_mutex);
+MUTEX_DEFINE(dtrace_stack_mutex);
 static pc_t	*g_pcstack;
 static int	g_pcstack_limit;
 static int	g_depth;
diff --git a/driver/dtrace_linux.c b/driver/dtrace_linux.c
@@ -145,10 +145,10 @@ cpu_t	*cpu_list;
 cpu_core_t *cpu_core;
 cpu_t *cpu_table;
 int	nr_cpus = 1;
-DEFINE_MUTEX(mod_lock);
+MUTEX_DEFINE(mod_lock);
 
-static DEFINE_MUTEX(dtrace_provider_lock);	/* provider state lock */
-DEFINE_MUTEX(cpu_lock);
+static MUTEX_DEFINE(dtrace_provider_lock);	/* provider state lock */
+MUTEX_DEFINE(cpu_lock);
 int	panic_quiesce;
 sol_proc_t	*curthread;
 
@@ -537,9 +537,9 @@ typedef struct gate32 gate_t;
 #   error "Dont know how to handle GATEs on this cpu"
 # endif
 
-/*
+# if 0
 void
-xset_idt_entry(int intr, unsigned long func)
+set_idt_entry(int intr, unsigned long func)
 {
 gate_desc *idt_table = get_proc_addr("idt_table");
 gate_desc s;
@@ -550,7 +550,7 @@ memory_set_rw(idt_table, 1, TRUE);
 write_idt_entry(idt_table, intr, &s);
 return;
 }
-*/
+# else
 void
 set_idt_entry(int intr, unsigned long func)
 {
@@ -561,7 +561,7 @@ set_idt_entry(int intr, unsigned long func)
 	int	ist = GATE_DEBUG_STACK;
 	int	seg = __KERNEL_CS;
 
-printk("patch idt %p vec %d func %p\n", idt_table, intr, func);
+printk("patch idt %p vec %d func %lx\n", idt_table, intr, func);
 
 	memset(&s, 0, sizeof s);
 
@@ -592,6 +592,7 @@ printk("patch idt %p vec %d func %p\n", idt_table, intr, func);
 	idt_table[intr] = s;
 
 }
+#endif
 
 /**********************************************************************/
 /*   Saved copies of idt_table[n] for when we get unloaded.	      */
@@ -1376,7 +1377,8 @@ static pte_t *(*lookup_address)(void *, int *);
 int
 mutex_count(mutex_t *mp)
 {
-	return atomic_read(&mp->count);
+//	return atomic_read(&mp->count);
+	return mp->count;
 }
 /**********************************************************************/
 /*   Called from fbt_linux.c. Dont let us register a probe point for  */
@@ -1625,7 +1627,7 @@ dtrace_double_fault_handler(int type, struct pt_regs *regs)
 	struct die_args die;
 
 	die.regs = regs;
-	die.str = "hello";
+	die.str = "double-fault";
 	return proc_notifier_int3(&n, DIE_DEBUG, &die);
 }
 int 
@@ -1634,7 +1636,7 @@ dtrace_int1_handler(int type, struct pt_regs *regs)
 	struct die_args die;
 
 	die.regs = regs;
-	die.str = "hello";
+	die.str = "single-step";
 	return proc_notifier_int3(&n, DIE_DEBUG, &die);
 }
 /**********************************************************************/
@@ -1654,7 +1656,7 @@ dtrace_dump_mem64(regs, 50);
 */
 //int i; for (i = 0; i < 10000000; i++);
 	die.regs = regs;
-	die.str = "hello";
+	die.str = "bkpt";
 	return proc_notifier_int3(&n, DIE_INT3, &die);
 }
 /**********************************************************************/
@@ -1727,7 +1729,7 @@ static int noisy;
 	/*   we  can grep /proc/kallsyms to find what  */
 	/*   we forgot to do.			       */
 	/***********************************************/
-	if (cnt_reentrancy && cnt_reentrancy_msgcnt < 5) {
+	if (cnt_reentrancy && cnt_reentrancy_msgcnt < 20) {
 		cnt_reentrancy_msgcnt++;
 		printk("dtrace:cnt_reentrancy=%d PC:%p\n", cnt_reentrancy, (void *) pc_reentrancy);
 	}
@@ -1782,12 +1784,19 @@ static int noisy;
 
 	/***********************************************/
 	/*   Check  with  fbt/sdt  and anyone else if  */
-	/*   this is one of our INT3 type traps.       */
-	/***********************************************/
+	/*   this  is  one of our INT3 type traps. In  */
+	/*   case   we   are   calling   printk()  in  */
+	/*   dtrace_probe,  we  need  to flag that we  */
+	/*   dont  want  any  more  INT3's  until  we  */
+	/*   finish,   so   temporarily   enable  the  */
+	/*   auto-remove code above.		       */
+	/***********************************************/
+	this_cpu->cpuc_stepping++;
 	ret = dtrace_invop(regs->r_pc - 1, 
 		(uintptr_t *) regs, 
 		regs->r_rax,
 		&this_cpu->cpuc_tinfo);
+	this_cpu->cpuc_stepping--;
 
 	if (dtrace_here && ret && noisy < 100) {
 		printk("ret=%d %s\n", ret, ret == 0 ? "nothing" :
@@ -2127,9 +2136,9 @@ vmem_alloc(vmem_t *hdr, size_t s, int flags)
 	if (TRACE_ALLOC || dtrace_mem_alloc)
 		printk("vmem_alloc(size=%d)\n", (int) s);
 
-	mutex_lock(&seqp->seq_mutex);
+	mutex_enter(&seqp->seq_mutex);
 	ret = (void *) (long) ++seqp->seq_id;
-	mutex_unlock(&seqp->seq_mutex);
+	mutex_exit(&seqp->seq_mutex);
 	return ret;
 }
 
@@ -2281,6 +2290,7 @@ dtracedrv_read(struct file *fp, char __user *buf, size_t len, loff_t *off)
 		dtrace_here,
 		cpu_get_id(),
 		dcnt);
+	*off += n;
 	return n;
 }
 /**********************************************************************/
diff --git a/driver/dtrace_linux.h b/driver/dtrace_linux.h
@@ -47,8 +47,6 @@
 #  include <linux/hrtimer.h>
 #endif
 
-//# include <linux/uaccess.h>
-
 # define MUTEX_HELD mutex_is_locked
 
 #define PRIV_EFFECTIVE          (1 << 0)
@@ -65,9 +63,6 @@
 #define	uprintf		printk
 #define	vuprintf	vprintk
 
-#define	mutex_enter(x)	mutex_lock(x)
-#define	mutex_exit(x)	mutex_unlock(x)
-
 # define PRINT_CASE(x) do { if (dtrace_here) printk("%s(%d):%s: %s\n", __FILE__, __LINE__, __func__, #x); } while (0)
 
 # define crhold(x)
diff --git a/driver/fasttrap.c b/driver/fasttrap.c
@@ -87,7 +87,7 @@ static void swap_func(void *p1, void *p2, int size)
 }
 # define qsort(base, num, size, cmp) sort(base, num, size, cmp, swap_func)
 
-DEFINE_MUTEX(pidlock);
+MUTEX_DEFINE(pidlock);
 
 timeout_id_t
 timeout(void (*func)(void *), void *arg, unsigned long ticks)
@@ -235,7 +235,7 @@ static dev_info_t *fasttrap_devi;
 static dtrace_meta_provider_id_t fasttrap_meta_id;
 
 static timeout_id_t fasttrap_timeout;
-static DEFINE_MUTEX(fasttrap_cleanup_mtx);
+static MUTEX_DEFINE(fasttrap_cleanup_mtx);
 static uint_t fasttrap_cleanup_work;
 
 /*
@@ -271,7 +271,7 @@ static fasttrap_hash_t		fasttrap_provs;
 static fasttrap_hash_t		fasttrap_procs;
 
 static uint64_t			fasttrap_pid_count;	/* pid ref count */
-static DEFINE_MUTEX(fasttrap_count_mtx);		/* lock on ref count */
+static MUTEX_DEFINE(fasttrap_count_mtx);		/* lock on ref count */
 
 #define	FASTTRAP_ENABLE_FAIL	1
 #define	FASTTRAP_ENABLE_PARTIAL	2
diff --git a/driver/systrace.c b/driver/systrace.c
@@ -115,7 +115,7 @@ dtrace_systrace_syscall2(int syscall, systrace_sysent_t *sy,
 
 # define linux_get_syscall() get_current()->thread.trap_no
 
-DEFINE_MUTEX(slock);
+MUTEX_DEFINE(slock);
 static int do_slock;
 
 /**********************************************************************/
diff --git a/linux/linux_types.h b/linux/linux_types.h
diff --git a/tools/make_kernels.pl b/tools/make_kernels.pl
diff --git a/utils/mon b/utils/mon
