53  *   - ECB functions
255 static dtrace_ecb_t	*dtrace_ecb_create_cache; /* cached created ECB */
1486  * invoking ECB match the target credentials
1513  * verify that the zone of the process that enabled the invoking ECB
1628  * Determine if the dte_cond of the specified ECB allows for processing of
1635     dtrace_ecb_t *ecb)  in dtrace_priv_probe()  argument
1637 	dtrace_probe_t *probe = ecb->dte_probe;  in dtrace_priv_probe()
1642 	ASSERT(ecb->dte_cond);  in dtrace_priv_probe()
1663 	if (ecb->dte_cond & DTRACE_COND_USERMODE) {  in dtrace_priv_probe()
1684 	if (ecb->dte_cond & DTRACE_COND_OWNER) {  in dtrace_priv_probe()
1716 	if (ecb->dte_cond & DTRACE_COND_ZONEOWNER) {  in dtrace_priv_probe()
5784 			 * If we've done a getf() as a part of this ECB and we
6909 dtrace_action_breakpoint(dtrace_ecb_t *ecb)  argument
6911 	dtrace_probe_t *probe = ecb->dte_probe;
6915 	char *ecbmsg = " (ecb ";
6916 	uintptr_t val = (uintptr_t)ecb;
6930 	 * the probe, along with the hex address of the ECB with the breakpoint
6974 dtrace_action_panic(dtrace_ecb_t *ecb)  argument
6976 	dtrace_probe_t *probe = ecb->dte_probe;
6997 	dtrace_panic("dtrace: panic action at probe %s:%s:%s:%s (ecb %p)",
6999 	    probe->dtpr_func, probe->dtpr_name, (void *)ecb);
7093 	 * not change within an ECB.  The presence of chill() represents an
7328 	dtrace_ecb_t *ecb;  local
7394 	for (ecb = probe->dtpr_ecb; ecb != NULL; ecb = ecb->dte_next) {
7395 		dtrace_predicate_t *pred = ecb->dte_predicate;
7396 		dtrace_state_t *state = ecb->dte_state;
7425 			 * we're only going to continue processing the ECB if
7426 			 * arg0 (the dtrace_state_t) is equal to the ECB's
7457 		if (ecb->dte_cond) {
7463 			 * while in a user context. Skip this ECB if that's
7466 			if ((ecb->dte_cond & DTRACE_COND_USERMODE) &&
7484 			if (ecb->dte_cond & DTRACE_COND_OWNER) {
7487 				    ecb->dte_state->dts_cred.dcr_cred;
7504 			if (ecb->dte_cond & DTRACE_COND_ZONEOWNER) {
7507 				    ecb->dte_state->dts_cred.dcr_cred;
7543 		if ((offs = dtrace_buffer_reserve(buf, ecb->dte_needed,
7544 		    ecb->dte_alignment, state, &mstate)) < 0)
7550 		if (ecb->dte_size != 0) {
7556 			ASSERT3U(ecb->dte_size, >=, sizeof (dtrace_rechdr_t));
7557 			dtrh.dtrh_epid = ecb->dte_epid;
7563 		mstate.dtms_epid = ecb->dte_epid;
7592 		for (act = ecb->dte_action; !(*flags & CPU_DTRACE_ERROR) &&
7635 					dtrace_action_breakpoint(ecb);
7640 					dtrace_action_panic(ecb);
7721 				    ecb->dte_needed, ecb->dte_alignment,
7732 				if (ecb->dte_size == 0)
7735 				ASSERT3U(ecb->dte_size, >=,
7738 				dtrh->dtrh_epid = ecb->dte_epid;
7818 				if (ecb->dte_size)
7819 					buf->dtb_offset = offs + ecb->dte_size;
7990 			 * act is ecb->dte_action, the fault was in the
7991 			 * predicate, if it's ecb->dte_action->dta_next it's
7994 			for (err = ecb->dte_action, ndx = 0;
7998 			dtrace_probe_error(state, ecb->dte_epid, ndx,
8007 			buf->dtb_offset = offs + ecb->dte_size;
9431 		 * create an ECB with a NULL probe.
11089  * DTrace ECB Functions
11094 	dtrace_ecb_t *ecb;  local
11099 	ecb = kmem_zalloc(sizeof (dtrace_ecb_t), KM_SLEEP);
11100 	ecb->dte_predicate = NULL;
11101 	ecb->dte_probe = probe;
11107 	ecb->dte_size = ecb->dte_needed = sizeof (dtrace_rechdr_t);
11108 	ecb->dte_alignment = sizeof (dtrace_epid_t);
11149 	ecb->dte_state = state;
11153 	state->dts_ecbs[(ecb->dte_epid = epid) - 1] = ecb;
11155 	return (ecb);
11159 dtrace_ecb_enable(dtrace_ecb_t *ecb)  argument
11161 	dtrace_probe_t *probe = ecb->dte_probe;
11165 	ASSERT(ecb->dte_next == NULL);
11178 		 * We're the first ECB on this probe.
11180 		probe->dtpr_ecb = probe->dtpr_ecb_last = ecb;
11182 		if (ecb->dte_predicate != NULL)
11183 			probe->dtpr_predcache = ecb->dte_predicate->dtp_cacheid;
11190 		 * point to the new ECB, and issue a dtrace_sync() to assure
11194 		probe->dtpr_ecb_last->dte_next = ecb;
11195 		probe->dtpr_ecb_last = ecb;
11203 dtrace_ecb_resize(dtrace_ecb_t *ecb)  argument
11213 	ecb->dte_size = sizeof (dtrace_rechdr_t);
11214 	ecb->dte_alignment = sizeof (dtrace_epid_t);
11216 	for (act = ecb->dte_action; act != NULL; act = act->dta_next) {
11220 		ecb->dte_alignment = MAX(ecb->dte_alignment,
11239 			ecb->dte_needed = MAX(ecb->dte_needed, curneeded);
11253 				curneeded = P2PHASEUP(ecb->dte_size,
11270 			ecb->dte_size = P2ROUNDUP(ecb->dte_size,
11272 			rec->dtrd_offset = ecb->dte_size;
11273 			if (ecb->dte_size + rec->dtrd_size < ecb->dte_size)
11275 			ecb->dte_size += rec->dtrd_size;
11276 			ecb->dte_needed = MAX(ecb->dte_needed, ecb->dte_size);
11280 	if ((act = ecb->dte_action) != NULL &&
11282 	    ecb->dte_size == sizeof (dtrace_rechdr_t)) {
11287 		ecb->dte_size = 0;
11290 	ecb->dte_size = P2ROUNDUP(ecb->dte_size, sizeof (dtrace_epid_t));
11291 	ecb->dte_needed = P2ROUNDUP(ecb->dte_needed, (sizeof (dtrace_epid_t)));
11292 	ecb->dte_state->dts_needed = MAX(ecb->dte_state->dts_needed,
11293 	    ecb->dte_needed);
11298 dtrace_ecb_aggregation_create(dtrace_ecb_t *ecb, dtrace_actdesc_t *desc)  argument
11306 	dtrace_state_t *state = ecb->dte_state;
11309 	agg->dtag_ecb = ecb;
11403 	for (act = ecb->dte_action_last; act != NULL; act = act->dta_prev) {
11429 	ASSERT(ecb->dte_action_last != NULL);
11430 	act = ecb->dte_action_last;
11489 dtrace_ecb_aggregation_destroy(dtrace_ecb_t *ecb, dtrace_action_t *act)  argument
11492 	dtrace_state_t *state = ecb->dte_state;
11509 dtrace_ecb_action_add(dtrace_ecb_t *ecb, dtrace_actdesc_t *desc)  argument
11516 	dtrace_state_t *state = ecb->dte_state;
11521 	ASSERT(ecb->dte_action == NULL || ecb->dte_action->dta_refcnt == 1);
11530 		for (act = ecb->dte_action; act != NULL; act = act->dta_next) {
11538 		action = dtrace_ecb_aggregation_create(ecb, desc);
11674 			if (ecb->dte_size > sizeof (dtrace_rechdr_t))
11688 			dtrace_action_t *act = ecb->dte_action;
11710 			dtrace_action_t *act = ecb->dte_action;
11744 	if ((last = ecb->dte_action_last) != NULL) {
11745 		ASSERT(ecb->dte_action != NULL);
11749 		ASSERT(ecb->dte_action == NULL);
11750 		ecb->dte_action = action;
11753 	ecb->dte_action_last = action;
11759 dtrace_ecb_action_remove(dtrace_ecb_t *ecb)  argument
11761 	dtrace_action_t *act = ecb->dte_action, *next;
11762 	dtrace_vstate_t *vstate = &ecb->dte_state->dts_vstate;
11772 			ASSERT(next != NULL || act == ecb->dte_action_last);
11776 				dtrace_format_remove(ecb->dte_state, format);
11782 				dtrace_ecb_aggregation_destroy(ecb, act);
11789 	ecb->dte_action = NULL;
11790 	ecb->dte_action_last = NULL;
11791 	ecb->dte_size = 0;
11795 dtrace_ecb_disable(dtrace_ecb_t *ecb)  argument
11798 	 * We disable the ECB by removing it from its probe.
11801 	dtrace_probe_t *probe = ecb->dte_probe;
11813 		if (pecb == ecb)
11821 		probe->dtpr_ecb = ecb->dte_next;
11823 		prev->dte_next = ecb->dte_next;
11826 	if (ecb == probe->dtpr_ecb_last) {
11827 		ASSERT(ecb->dte_next == NULL);
11832 	 * The ECB has been disconnected from the probe; now sync to assure
11839 		 * That was the last ECB on the probe; clear the predicate
11845 		ASSERT(ecb->dte_next == NULL);
11853 		 * There is at least one ECB remaining on the probe.  If there
11855 		 * the predicate cache ID of the remaining ECB.
11869 		ecb->dte_next = NULL;
11874 dtrace_ecb_destroy(dtrace_ecb_t *ecb)  argument
11876 	dtrace_state_t *state = ecb->dte_state;
11879 	dtrace_epid_t epid = ecb->dte_epid;
11882 	ASSERT(ecb->dte_next == NULL);
11883 	ASSERT(ecb->dte_probe == NULL || ecb->dte_probe->dtpr_ecb != ecb);
11885 	if ((pred = ecb->dte_predicate) != NULL)
11888 	dtrace_ecb_action_remove(ecb);
11890 	ASSERT(state->dts_ecbs[epid - 1] == ecb);
11893 	kmem_free(ecb, sizeof (dtrace_ecb_t));
11900 	dtrace_ecb_t *ecb;  local
11909 	ecb = dtrace_ecb_add(state, probe);
11910 	ecb->dte_uarg = desc->dted_uarg;
11914 		ecb->dte_predicate = pred;
11921 		 * predicate bits to prevent the ecb from activating at
11932 			ecb->dte_cond |= DTRACE_COND_OWNER;
11936 			ecb->dte_cond |= DTRACE_COND_ZONEOWNER;
11945 			ecb->dte_cond |= DTRACE_COND_USERMODE;
11950 		 * If we have a cached ecb, we'll use its action list instead
11959 			ecb->dte_action = act;
11960 			ecb->dte_action_last = cached->dte_action_last;
11961 			ecb->dte_needed = cached->dte_needed;
11962 			ecb->dte_size = cached->dte_size;
11963 			ecb->dte_alignment = cached->dte_alignment;
11966 		return (ecb);
11970 		if ((enab->dten_error = dtrace_ecb_action_add(ecb, act)) != 0) {
11971 			dtrace_ecb_destroy(ecb);
11976 	if ((enab->dten_error = dtrace_ecb_resize(ecb)) != 0) {
11977 		dtrace_ecb_destroy(ecb);
11981 	return (dtrace_ecb_create_cache = ecb);
11987 	dtrace_ecb_t *ecb;  local
12002 	if ((ecb = dtrace_ecb_create(state, probe, enab)) == NULL)
12005 	dtrace_ecb_enable(ecb);
12012 	dtrace_ecb_t *ecb;  local
12020 	ASSERT((ecb = state->dts_ecbs[id - 1]) == NULL || ecb->dte_epid == id);
12428 			 * down to the space required by the ECB -- we know
12603  * if an ECB on a defunct probe (but for an active enabling) can be safely
12671 dtrace_enabling_add(dtrace_enabling_t *enab, dtrace_ecbdesc_t *ecb)  argument
12684 		enab->dten_desc[enab->dten_ndesc++] = ecb;
12705 	enab->dten_desc[enab->dten_ndesc++] = ecb;
12709 dtrace_enabling_addlike(dtrace_enabling_t *enab, dtrace_ecbdesc_t *ecb,  argument
12717 	 * We're going to create a new ECB description that matches the
12718 	 * specified ECB in every way, but has the specified probe description.
12722 	if ((pred = ecb->dted_pred.dtpdd_predicate) != NULL)
12725 	for (act = ecb->dted_action; act != NULL; act = act->dtad_next)
12728 	new->dted_action = ecb->dted_action;
12729 	new->dted_pred = ecb->dted_pred;
12731 	new->dted_uarg = ecb->dted_uarg;
13038  * enabling must be _primed_ by creating an ECB for every ECB description.
13042  * enabling any probes, we create ECBs for every ECB decription, but with a
13134 	dtrace_ecb_t *ecb;  local
13156 		 * of these ECBs must be done carefully:  if we destroy the ECB
13158 		 * corresponds to the destroyed ECB (and if the EPID metadata
13162 		 * ECB for a defunct provider if, for the state that
13163 		 * corresponds to the ECB:
13181 		while ((ecb = probe->dtpr_ecb) != NULL) {
13182 			dtrace_state_t *state = ecb->dte_state;
13195 			dtrace_ecb_disable(ecb);
13196 			ASSERT(probe->dtpr_ecb != ecb);
13197 			dtrace_ecb_destroy(ecb);
13964 	dof_ecbdesc_t *ecb;  local
13969 		dtrace_dof_error(dof, "truncated ECB description");
13974 		dtrace_dof_error(dof, "bad alignment in ECB description");
13978 	ecb = (dof_ecbdesc_t *)((uintptr_t)dof + (uintptr_t)sec->dofs_offset);
13979 	sec = dtrace_dof_sect(dof, DOF_SECT_PROBEDESC, ecb->dofe_probes);
13985 	ep->dted_uarg = ecb->dofe_uarg;
13991 	if (ecb->dofe_pred != DOF_SECIDX_NONE) {
13993 		    DOF_SECT_DIFOHDR, ecb->dofe_pred)) == NULL)
14002 	if (ecb->dofe_actions != DOF_SECIDX_NONE) {
14004 		    DOF_SECT_ACTDESC, ecb->dofe_actions)) == NULL)
14942 	dtrace_ecb_t *ecb;  local
14957 	for (ecb = probe->dtpr_ecb; ecb != NULL; ecb = ecb->dte_next) {
14958 		if (ecb->dte_state != state)
14961 		state->dts_reserve += ecb->dte_needed + ecb->dte_alignment;
15240 	 * processing an ECB halfway down a probe's ECB chain; all CPUs will
15410 	dtrace_ecb_t *ecb;  local
15459 			if ((ecb = state->dts_ecbs[i]) == NULL)
15462 			if (match && ecb->dte_probe != NULL) {
15463 				dtrace_probe_t *probe = ecb->dte_probe;
15470 			dtrace_ecb_disable(ecb);
15471 			dtrace_ecb_destroy(ecb);
16426 	 * Now we need to walk through the ECB descriptions in the enabling.
17501 		dtrace_ecb_t *ecb;  local
17513 		if ((ecb = dtrace_epid2ecb(state, epdesc.dtepd_epid)) == NULL) {
17518 		if (ecb->dte_probe == NULL) {
17523 		epdesc.dtepd_probeid = ecb->dte_probe->dtpr_id;
17524 		epdesc.dtepd_uarg = ecb->dte_uarg;
17525 		epdesc.dtepd_size = ecb->dte_size;
17529 		for (act = ecb->dte_action; act != NULL; act = act->dta_next) {
17551 		for (act = ecb->dte_action; act != NULL; act = act->dta_next) {