Index: head/sys/cddl/dev/dtrace/dtrace_sysctl.c =================================================================== --- head/sys/cddl/dev/dtrace/dtrace_sysctl.c (revision 356651) +++ head/sys/cddl/dev/dtrace/dtrace_sysctl.c (revision 356652) @@ -1,97 +1,98 @@ /* * 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 * * $FreeBSD$ * */ /* Report registered DTrace providers. */ static int sysctl_dtrace_providers(SYSCTL_HANDLER_ARGS) { char *p_name = NULL; dtrace_provider_t *prov = dtrace_provider; int error = 0; size_t len = 0; mutex_enter(&dtrace_provider_lock); mutex_enter(&dtrace_lock); /* Compute the length of the space-separated provider name string. */ while (prov != NULL) { len += strlen(prov->dtpv_name) + 1; prov = prov->dtpv_next; } if ((p_name = kmem_alloc(len, KM_SLEEP)) == NULL) error = ENOMEM; else { /* Start with an empty string. */ *p_name = '\0'; /* Point to the first provider again. */ prov = dtrace_provider; /* Loop through the providers, appending the names. */ while (prov != NULL) { if (prov != dtrace_provider) (void) strlcat(p_name, " ", len); (void) strlcat(p_name, prov->dtpv_name, len); prov = prov->dtpv_next; } } mutex_exit(&dtrace_lock); mutex_exit(&dtrace_provider_lock); if (p_name != NULL) { error = sysctl_handle_string(oidp, p_name, len, req); kmem_free(p_name, 0); } return (error); } SYSCTL_NODE(_debug, OID_AUTO, dtrace, CTLFLAG_RD, 0, "DTrace debug parameters"); -SYSCTL_PROC(_debug_dtrace, OID_AUTO, providers, CTLTYPE_STRING | CTLFLAG_RD, - 0, 0, sysctl_dtrace_providers, "A", "available DTrace providers"); +SYSCTL_PROC(_debug_dtrace, OID_AUTO, providers, + CTLTYPE_STRING | CTLFLAG_MPSAFE | CTLFLAG_RD, 0, 0, sysctl_dtrace_providers, + "A", "available DTrace providers"); SYSCTL_NODE(_kern, OID_AUTO, dtrace, CTLFLAG_RD, 0, "DTrace parameters"); SYSCTL_INT(_kern_dtrace, OID_AUTO, err_verbose, CTLFLAG_RW, &dtrace_err_verbose, 0, "print DIF and DOF validation errors to the message buffer"); SYSCTL_INT(_kern_dtrace, OID_AUTO, memstr_max, CTLFLAG_RW, &dtrace_memstr_max, 0, "largest allowed argument to memstr(), 0 indicates no limit"); SYSCTL_QUAD(_kern_dtrace, OID_AUTO, dof_maxsize, CTLFLAG_RW, &dtrace_dof_maxsize, 0, "largest allowed DOF table"); SYSCTL_QUAD(_kern_dtrace, OID_AUTO, helper_actions_max, CTLFLAG_RW, &dtrace_helper_actions_max, 0, "maximum number of allowed helper actions"); SYSCTL_INT(_security_bsd, OID_AUTO, allow_destructive_dtrace, CTLFLAG_RDTUN, &dtrace_allow_destructive, 1, "Allow destructive mode DTrace scripts"); Index: head/sys/cddl/dev/dtrace/dtrace_test.c =================================================================== --- head/sys/cddl/dev/dtrace/dtrace_test.c (revision 356651) +++ head/sys/cddl/dev/dtrace/dtrace_test.c (revision 356652) @@ -1,108 +1,109 @@ /*- * Copyright 2008 John Birrell * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ * */ #include #include #include #include #include #include #include #include #include #include SDT_PROVIDER_DEFINE(test); SDT_PROBE_DEFINE7(test, , , sdttest, "int", "int", "int", "int", "int", "int", "int"); /* * These are variables that the DTrace test suite references in the * Solaris kernel. We define them here so that the tests function * unaltered. */ int kmem_flags; typedef struct vnode vnode_t; vnode_t dummy; vnode_t *rootvp = &dummy; /* * Test SDT probes with more than 5 arguments. On amd64, such probes require * special handling since only the first 5 arguments will be passed to * dtrace_probe() in registers; the rest must be fetched off the stack. */ static int dtrace_test_sdttest(SYSCTL_HANDLER_ARGS) { int val, error; val = 0; error = sysctl_handle_int(oidp, &val, 0, req); if (error || req->newptr == NULL) return (error); else if (val == 0) return (0); SDT_PROBE7(test, , , sdttest, 1, 2, 3, 4, 5, 6, 7); return (error); } static SYSCTL_NODE(_debug, OID_AUTO, dtracetest, CTLFLAG_RD, 0, ""); -SYSCTL_PROC(_debug_dtracetest, OID_AUTO, sdttest, CTLTYPE_INT | CTLFLAG_RW, - NULL, 0, dtrace_test_sdttest, "I", "Trigger the SDT test probe"); +SYSCTL_PROC(_debug_dtracetest, OID_AUTO, sdttest, + CTLTYPE_INT | CTLFLAG_MPSAFE | CTLFLAG_RW, NULL, 0, dtrace_test_sdttest, + "I", "Trigger the SDT test probe"); static int dtrace_test_modevent(module_t mod, int type, void *data) { int error = 0; switch (type) { case MOD_LOAD: break; case MOD_UNLOAD: break; case MOD_SHUTDOWN: break; default: error = EOPNOTSUPP; break; } return (error); } DEV_MODULE(dtrace_test, dtrace_test_modevent, NULL); MODULE_VERSION(dtrace_test, 1); MODULE_DEPEND(dtrace_test, dtraceall, 1, 1, 1);