Custom DTrace kernel module files plus FreeBSD-specific DTrace providers.

1 files changed, 220 insertions, 0 deletions

diff --git a/sys/cddl/dev/dtmalloc/dtmalloc.c b/sys/cddl/dev/dtmalloc/dtmalloc.c
new file mode 100644
index 0000000..ca822f9
--- /dev/null
+++ b/sys/cddl/dev/dtmalloc/dtmalloc.c
@@ -0,0 +1,220 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ *
+ * Portions Copyright 2006-2008 John Birrell jb@freebsd.org
+ *
+ * $FreeBSD$
+ *
+ */
+
+#include <sys/cdefs.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+
+#include <sys/dtrace.h>
+#include <sys/dtrace_bsd.h>
+
+static d_open_t	dtmalloc_open;
+static int	dtmalloc_unload(void);
+static void	dtmalloc_getargdesc(void *, dtrace_id_t, void *, dtrace_argdesc_t *);
+static void	dtmalloc_provide(void *, dtrace_probedesc_t *);
+static void	dtmalloc_destroy(void *, dtrace_id_t, void *);
+static void	dtmalloc_enable(void *, dtrace_id_t, void *);
+static void	dtmalloc_disable(void *, dtrace_id_t, void *);
+static void	dtmalloc_load(void *);
+
+static struct cdevsw dtmalloc_cdevsw = {
+	.d_version	= D_VERSION,
+	.d_open		= dtmalloc_open,
+	.d_name		= "dtmalloc",
+};
+
+static dtrace_pattr_t dtmalloc_attr = {
+{ DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON },
+{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
+{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
+{ DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON },
+{ DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON },
+};
+
+static dtrace_pops_t dtmalloc_pops = {
+	dtmalloc_provide,
+	NULL,
+	dtmalloc_enable,
+	dtmalloc_disable,
+	NULL,
+	NULL,
+	dtmalloc_getargdesc,
+	NULL,
+	NULL,
+	dtmalloc_destroy
+};
+
+static struct cdev		*dtmalloc_cdev;
+static dtrace_provider_id_t	dtmalloc_id;
+
+static void
+dtmalloc_getargdesc(void *arg, dtrace_id_t id, void *parg, dtrace_argdesc_t *desc)
+{
+	const char *p = NULL;
+
+	switch (desc->dtargd_ndx) {
+	case 0:
+		p = "struct malloc_type *";
+		break;
+	case 1:
+		p = "struct malloc_type_internal *";
+		break;
+	case 2:
+		p = "struct malloc_type_stats *";
+		break;
+	case 3:
+		p = "unsigned long";
+		break;
+	case 4:
+		p = "int";
+		break;
+	default:
+		desc->dtargd_ndx = DTRACE_ARGNONE;
+		break;
+	}
+
+	if (p != NULL)
+		strlcpy(desc->dtargd_native, p, sizeof(desc->dtargd_native));
+
+	return;
+}
+
+static void
+dtmalloc_type_cb(struct malloc_type *mtp, void *arg __unused)
+{
+	char name[DTRACE_FUNCNAMELEN];
+	struct malloc_type_internal *mtip = mtp->ks_handle;
+
+	strlcpy(name, mtp->ks_shortdesc, sizeof(name));
+
+	if (dtrace_probe_lookup(dtmalloc_id, NULL, name, "malloc") != 0)
+		return;
+
+	(void) dtrace_probe_create(dtmalloc_id, NULL, name, "malloc", 0,
+	    &mtip->mti_probes[DTMALLOC_PROBE_MALLOC]);
+	(void) dtrace_probe_create(dtmalloc_id, NULL, name, "free", 0,
+	    &mtip->mti_probes[DTMALLOC_PROBE_FREE]);
+}
+
+static void
+dtmalloc_provide(void *arg, dtrace_probedesc_t *desc)
+{
+	if (desc != NULL)
+		return;
+
+	malloc_type_list(dtmalloc_type_cb, desc);
+}
+
+static void
+dtmalloc_destroy(void *arg, dtrace_id_t id, void *parg)
+{
+}
+
+static void
+dtmalloc_enable(void *arg, dtrace_id_t id, void *parg)
+{
+	uint32_t *p = parg;
+	*p = id;
+}
+
+static void
+dtmalloc_disable(void *arg, dtrace_id_t id, void *parg)
+{
+	uint32_t *p = parg;
+	*p = 0;
+}
+
+static void
+dtmalloc_load(void *dummy)
+{
+	/* Create the /dev/dtrace/dtmalloc entry. */
+	dtmalloc_cdev = make_dev(&dtmalloc_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
+	    "dtrace/dtmalloc");
+
+	if (dtrace_register("dtmalloc", &dtmalloc_attr, DTRACE_PRIV_USER,
+	    NULL, &dtmalloc_pops, NULL, &dtmalloc_id) != 0)
+		return;
+
+	dtrace_malloc_probe = dtrace_probe;
+}
+
+
+static int
+dtmalloc_unload()
+{
+	int error = 0;
+
+	dtrace_malloc_probe = NULL;
+
+	if ((error = dtrace_unregister(dtmalloc_id)) != 0)
+		return (error);
+
+	destroy_dev(dtmalloc_cdev);
+
+	return (error);
+}
+
+static int
+dtmalloc_modevent(module_t mod __unused, int type, void *data __unused)
+{
+	int error = 0;
+
+	switch (type) {
+	case MOD_LOAD:
+		break;
+
+	case MOD_UNLOAD:
+		break;
+
+	case MOD_SHUTDOWN:
+		break;
+
+	default:
+		error = EOPNOTSUPP;
+		break;
+
+	}
+
+	return (error);
+}
+
+static int
+dtmalloc_open(struct cdev *dev __unused, int oflags __unused, int devtype __unused, struct thread *td __unused)
+{
+	return (0);
+}
+
+SYSINIT(dtmalloc_load, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, dtmalloc_load, NULL);
+SYSUNINIT(dtmalloc_unload, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, dtmalloc_unload, NULL);
+
+DEV_MODULE(dtmalloc, dtmalloc_modevent, NULL);
+MODULE_VERSION(dtmalloc, 1);
+MODULE_DEPEND(dtmalloc, dtrace, 1, 1, 1);
+MODULE_DEPEND(dtmalloc, opensolaris, 1, 1, 1);