xref: /illumos-gate/usr/src/uts/common/tnf/tnf.c (revision e2c63ca6)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 
27 /*
28  * tnf driver - provides probe control and kernel trace buffer access
29  * to the user programs prex and tnfxtract.
30  */
31 
32 #include <sys/types.h>
33 #include <sys/param.h>
34 #include <sys/sysmacros.h>
35 #include <sys/file.h>
36 #include <sys/cmn_err.h>
37 #include <sys/fcntl.h>
38 #include <sys/uio.h>
39 #include <sys/kmem.h>
40 #include <sys/cred.h>
41 #include <sys/mman.h>
42 #include <sys/errno.h>
43 #include <sys/stat.h>
44 #include <sys/conf.h>
45 #include <sys/ddi.h>
46 #include <sys/sunddi.h>
47 #include <sys/modctl.h>
48 #include <sys/tnf.h>
49 #include <sys/debug.h>
50 #include <sys/devops.h>
51 #include <vm/as.h>
52 #include <vm/seg_kp.h>
53 #include <sys/tnf_probe.h>
54 #include <sys/kobj.h>
55 
56 #include "tnf_buf.h"
57 #include "tnf_types.h"
58 #include "tnf_trace.h"
59 
60 #ifndef NPROBE
61 
62 /*
63  * Each probe is independently put in the kernel, prex uses
64  * __tnf_probe_list_head and __tnf_tag_list_head as pointers to linked list
65  * for probes and static tnf_tag_data_t, respectively.
66  * tnf used the elf relocation record to build a separate linked list for
67  * the probes and tnf_tag_data_t. We will describe how the linked list for
68  * __tnf_tag_list_head is made, the probe list is very similar.
69  * During the dynamic relocation(in uts/sparc/krtld/kobj_reloc.c),
70  * the &__tnf_tag_version_1(the first member in tnf_tag_data_t data struct)
71  * (and since it is a global variable which was never defined) will be filled
72  * with 0. The following code in kobj_reloc.c will get the address of current
73  * __tnf_tag_list_head and put it in value_p:
74  *   #define TAG_MARKER_SYMBOL       "__tnf_tag_version_1"
75  *   if (strcmp(symname, TAG_MARKER_SYMBOL) == 0) {
76  *       *addend_p = 0;
77  *       *value_p = (Addr) __tnf_tag_list_head; (value_p points to list head)
78  *       __tnf_tag_list_head = (void *)*offset_p;(list head is the next record)
79  *       return (0);
80  *   }
81  *
82  * the function do_reloc(in the kobj_reloc.c) will put vlaue_p into
83  * &__tnf_tag_version_1
84  * Now the &__tnf_tag_version_1 points to the last list head
85  * and __tnf_tag_list_head points to the new list head.
86  * This is equivalent to attatch a node at the beginning of the list.
87  *
88  */
89 extern tnf_probe_control_t *__tnf_probe_list_head;
90 extern tnf_tag_data_t *__tnf_tag_list_head;
91 extern int tnf_changed_probe_list;
92 
93 static int tnf_attach(dev_info_t *, ddi_attach_cmd_t);
94 static int tnf_detach(dev_info_t *, ddi_detach_cmd_t);
95 static int tnf_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
96 static int tnf_open(dev_t *, int, int, struct cred *);
97 static int tnf_close(dev_t, int, int, struct cred *);
98 #ifdef UNUSED
99 static int tnf_mmap(dev_t, off_t, int);
100 #endif
101 static int tnf_ioctl(dev_t, int, intptr_t, int, struct cred *, int *);
102 #ifdef UNUSED
103 static int tnf_prop_op(dev_t, dev_info_t *, ddi_prop_op_t,
104     int, char *, caddr_t, int *);
105 #endif
106 static dev_info_t *tnf_devi;
107 
108 static struct {
109 	int		tnf_probe_count;
110 	boolean_t	tnf_pidfilter_mode;
111 	boolean_t	ctldev_is_open;
112 	int		mapdev_open_count;
113 	kmutex_t	tnf_mtx;
114 } tnf_drv_state = { 0, B_FALSE, B_FALSE, 0 };
115 
116 static int tnf_getmaxprobe(caddr_t, int);
117 static int tnf_getprobevals(caddr_t, int);
118 static int tnf_getprobestring(caddr_t, int);
119 static int tnf_setprobevals(caddr_t, int);
120 static int tnf_getstate(caddr_t, int);
121 static int tnf_allocbuf(intptr_t);
122 static int tnf_deallocbuf(void);
123 static int tnf_settracing(int);
124 static int tnf_pidfilterset(int);
125 static int tnf_pidfilterget(caddr_t, int);
126 static int tnf_getpidstate(caddr_t, int);
127 static int tnf_setpidstate(int, pid_t, int);
128 static int tnf_getheader(caddr_t, int);
129 static int tnf_getblock(caddr_t, int);
130 static int tnf_getfwzone(caddr_t, int);
131 
132 static void *tnf_test_1(void *, tnf_probe_control_t *, tnf_probe_setup_t *);
133 static void *tnf_test_2(void *, tnf_probe_control_t *, tnf_probe_setup_t *);
134 
135 #define	TNFCTL_MINOR 0
136 #define	TNFMAP_MINOR 1
137 
138 struct cb_ops	tnf_cb_ops = {
139 	tnf_open,		/* open */
140 	tnf_close,		/* close */
141 	nodev,			/* strategy */
142 	nodev,			/* print */
143 	nodev,			/* dump */
144 	nodev,			/* read */
145 	nodev,			/* write */
146 	tnf_ioctl,		/* ioctl */
147 	nodev,			/* devmap */
148 	nodev,			/* mmap */
149 	nodev,			/* segmap */
150 	nochpoll,		/* poll */
151 	ddi_prop_op,		/* prop_op */
152 	0,			/* streamtab  */
153 	D_NEW | D_MP		/* Driver compatibility flag */
154 };
155 
156 struct dev_ops	tnf_ops = {
157 	DEVO_REV,		/* devo_rev, */
158 	0,			/* refcnt  */
159 	tnf_info,		/* info */
160 	nulldev,		/* identify */
161 	nulldev,		/* probe */
162 	tnf_attach,		/* attach */
163 	tnf_detach,		/* detach */
164 	nodev,			/* reset */
165 	&tnf_cb_ops,		/* driver operations */
166 	(struct bus_ops *)0,	/* no bus operations */
167 	NULL,			/* power */
168 	ddi_quiesce_not_needed,		/* quiesce */
169 };
170 
171 extern struct mod_ops mod_driverops;
172 
173 static struct modldrv modldrv = {
174 	&mod_driverops,
175 	"kernel probes driver",
176 	&tnf_ops,
177 };
178 
179 static struct modlinkage modlinkage = {
180 	MODREV_1,
181 	(void *)&modldrv,
182 	NULL
183 };
184 
185 int
_init()186 _init()
187 {
188 	register int error;
189 
190 	mutex_init(&tnf_drv_state.tnf_mtx, NULL, MUTEX_DEFAULT, NULL);
191 
192 	if ((error = mod_install(&modlinkage)) != 0) {
193 		mutex_destroy(&tnf_drv_state.tnf_mtx);
194 		return (error);
195 	}
196 
197 	/* Give t0 a tpdp */
198 	if (!t0.t_tnf_tpdp)
199 		t0.t_tnf_tpdp = kmem_zalloc(sizeof (tnf_ops_t), KM_SLEEP);
200 	/* Initialize tag system */
201 	tnf_tag_core_init();
202 	tnf_tag_trace_init();
203 	tnf_changed_probe_list = 1;
204 	return (0);
205 }
206 
207 int
_fini()208 _fini()
209 {
210 	/* Not safe to unload this module, currently */
211 	return (EBUSY);
212 }
213 
214 int
_info(struct modinfo * modinfop)215 _info(struct modinfo *modinfop)
216 {
217 	return (mod_info(&modlinkage, modinfop));
218 }
219 
220 /* ARGSUSED */
221 static int
tnf_info(dev_info_t * dip,ddi_info_cmd_t infocmd,void * arg,void ** result)222 tnf_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
223 {
224 	register int error;
225 
226 	switch (infocmd) {
227 	case DDI_INFO_DEVT2DEVINFO:
228 		*result = (void *)tnf_devi;
229 		error = DDI_SUCCESS;
230 		break;
231 	case DDI_INFO_DEVT2INSTANCE:
232 		*result = (void *)0;
233 		error = DDI_SUCCESS;
234 		break;
235 	default:
236 		error = DDI_FAILURE;
237 	}
238 	return (error);
239 }
240 
241 static int
tnf_attach(dev_info_t * devi,ddi_attach_cmd_t cmd)242 tnf_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
243 {
244 	if (cmd != DDI_ATTACH)
245 		return (DDI_FAILURE);
246 	if ((ddi_create_minor_node(devi, "tnfctl", S_IFCHR, TNFCTL_MINOR,
247 	    DDI_PSEUDO, 0) == DDI_FAILURE) ||
248 	    (ddi_create_minor_node(devi, "tnfmap", S_IFCHR, TNFMAP_MINOR,
249 	    DDI_PSEUDO, 0) == DDI_FAILURE)) {
250 		ddi_remove_minor_node(devi, NULL);
251 		return (DDI_FAILURE);
252 	}
253 	tnf_devi = devi;
254 	return (DDI_SUCCESS);
255 }
256 
257 static int
tnf_detach(dev_info_t * devi,ddi_detach_cmd_t cmd)258 tnf_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
259 {
260 	if (cmd != DDI_DETACH)
261 		return (DDI_FAILURE);
262 	ddi_remove_minor_node(devi, NULL);
263 	return (DDI_SUCCESS);
264 }
265 
266 /*
267  * property operations. Return the size of the kernel trace buffer.  We
268  * only handle size property requests.  Others are passed on.
269  */
270 #ifdef UNUSED
271 static int
tnf_prop_op(dev_t dev,dev_info_t * di,ddi_prop_op_t prop,int m,char * name,caddr_t valuep,int * lengthp)272 tnf_prop_op(dev_t dev, dev_info_t *di, ddi_prop_op_t prop,
273     int m, char *name, caddr_t valuep, int *lengthp)
274 {
275 	int length, *retbuf, size;
276 
277 	if (strcmp(name, "size") == 0) {
278 
279 		/* Don't need tnf_mtx, since mapdev_open_count > 0 */
280 		size = tnf_trace_file_size;
281 
282 		length = *lengthp;		/* get caller's length */
283 		*lengthp = sizeof (int);	/* set caller's length */
284 
285 		switch (prop) {
286 
287 		case PROP_LEN:
288 			return (DDI_PROP_SUCCESS);
289 
290 		case PROP_LEN_AND_VAL_ALLOC:
291 			retbuf = kmem_alloc(sizeof (int),
292 			    (m & DDI_PROP_CANSLEEP) ? KM_SLEEP : KM_NOSLEEP);
293 			if (retbuf == NULL)
294 				return (DDI_PROP_NO_MEMORY);
295 			*(int **)valuep = retbuf;	/* set caller's buf */
296 			*retbuf = size;
297 			return (DDI_PROP_SUCCESS);
298 
299 		case PROP_LEN_AND_VAL_BUF:
300 			if (length < sizeof (int))
301 				return (DDI_PROP_BUF_TOO_SMALL);
302 			*(int *)valuep = size;
303 			return (DDI_PROP_SUCCESS);
304 		}
305 	}
306 	return (ddi_prop_op(dev, dip, prop, m, name, valuep, lengthp));
307 }
308 #endif
309 
310 /* ARGSUSED */
311 static int
tnf_open(dev_t * devp,int flag,int otyp,struct cred * cred)312 tnf_open(dev_t *devp, int flag, int otyp, struct cred *cred)
313 {
314 	int err = 0;
315 	mutex_enter(&tnf_drv_state.tnf_mtx);
316 	if (getminor(*devp) == TNFCTL_MINOR) {
317 		if (tnf_drv_state.ctldev_is_open)
318 			err = EBUSY;
319 		else {
320 			tnf_drv_state.ctldev_is_open = B_TRUE;
321 			/* stop autounloading -- XXX temporary */
322 			modunload_disable();
323 		}
324 	} else {
325 		/* ASSERT(getminor(*devp) == TNFMAP_MINOR) */
326 		++tnf_drv_state.mapdev_open_count;
327 	}
328 	mutex_exit(&tnf_drv_state.tnf_mtx);
329 	return (err);
330 }
331 
332 /* ARGSUSED */
333 static int
tnf_close(dev_t dev,int flag,int otyp,struct cred * cred)334 tnf_close(dev_t dev, int flag, int otyp, struct cred *cred)
335 {
336 	if (getminor(dev) == TNFCTL_MINOR) {
337 		/*
338 		 * Request the reenablement of autounloading
339 		 */
340 		modunload_enable();
341 		tnf_drv_state.ctldev_is_open = B_FALSE;
342 	} else {
343 		/* ASSERT(getminor(dev) == TNFMAP_MINOR) */
344 		/*
345 		 * Unconditionally zero the open count since close()
346 		 * is called when last client closes the device.
347 		 */
348 		tnf_drv_state.mapdev_open_count = 0;
349 	}
350 	return (0);
351 }
352 
353 /*
354  * return the address of the image referenced by dev.
355  *
356  * 1191344: aliasing problem on VAC machines.  It could be made to
357  * work by ensuring that tnf_buf is allocated on a vac_size boundary.
358  */
359 #ifdef UNUSED
360 /*ARGSUSED*/
361 static int
tnf_mmap(dev_t dev,off_t off,int prot)362 tnf_mmap(dev_t dev, off_t off, int prot)
363 {
364 	register caddr_t addr;
365 	register caddr_t pg_offset;
366 
367 	if (getminor(dev) != TNFMAP_MINOR)
368 		return (-1);
369 	if (tnf_buf == 0 || off >= tnf_trace_file_size) {
370 		return (-1);
371 	}
372 
373 	addr = tnf_buf;
374 	pg_offset = (caddr_t)((ulong_t)addr + (ulong_t)off);
375 	return ((int)hat_getpfnum(kas.a_hat, pg_offset));
376 }
377 #endif
378 
379 /*ARGSUSED4*/
380 static int
tnf_ioctl(dev_t dev,int cmd,intptr_t arg,int mode,cred_t * credp,int * rvalp)381 tnf_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
382     cred_t *credp, int *rvalp)
383 {
384 	int filterval = 1;
385 
386 	if ((mode & FMODELS) != FNATIVE)
387 		return (ENOTSUP);
388 
389 	if (getminor(dev) != TNFCTL_MINOR &&
390 	    cmd != TIFIOCGSTATE &&
391 	    cmd != TIFIOCGHEADER &&
392 	    cmd != TIFIOCGBLOCK &&
393 	    cmd != TIFIOCGFWZONE)
394 		return (EINVAL);
395 
396 	switch (cmd) {
397 	case TIFIOCGMAXPROBE:
398 		return (tnf_getmaxprobe((caddr_t)arg, mode));
399 	case TIFIOCGPROBEVALS:
400 		return (tnf_getprobevals((caddr_t)arg, mode));
401 	case TIFIOCGPROBESTRING:
402 		return (tnf_getprobestring((caddr_t)arg, mode));
403 	case TIFIOCSPROBEVALS:
404 		return (tnf_setprobevals((caddr_t)arg, mode));
405 	case TIFIOCGSTATE:
406 		return (tnf_getstate((caddr_t)arg, mode));
407 	case TIFIOCALLOCBUF:
408 		return (tnf_allocbuf(arg));
409 	case TIFIOCDEALLOCBUF:
410 		return (tnf_deallocbuf());
411 	case TIFIOCSTRACING:
412 		/* LINTED cast from 64-bit integer to 32-bit integer */
413 		return (tnf_settracing((int)arg));
414 	case TIFIOCSPIDFILTER:
415 		/* LINTED cast from 64-bit integer to 32-bit integer */
416 		return (tnf_pidfilterset((int)arg));
417 	case TIFIOCGPIDSTATE:
418 		return (tnf_getpidstate((caddr_t)arg, mode));
419 	case TIFIOCSPIDOFF:
420 		filterval = 0;
421 		/*FALLTHROUGH*/
422 	case TIFIOCSPIDON:
423 		/* LINTED cast from 64-bit integer to 32-bit integer */
424 		return (tnf_setpidstate(filterval, (pid_t)arg, mode));
425 	case TIFIOCPIDFILTERGET:
426 		return (tnf_pidfilterget((caddr_t)arg, mode));
427 	case TIFIOCGHEADER:
428 		return (tnf_getheader((caddr_t)arg, mode));
429 	case TIFIOCGBLOCK:
430 		return (tnf_getblock((caddr_t)arg, mode));
431 	case TIFIOCGFWZONE:
432 		return (tnf_getfwzone((caddr_t)arg, mode));
433 	default:
434 		return (EINVAL);
435 	}
436 }
437 
438 /*
439  * ioctls
440  */
441 
442 static int
tnf_getmaxprobe(caddr_t arg,int mode)443 tnf_getmaxprobe(caddr_t arg, int mode)
444 {
445 	tnf_probe_control_t *p;
446 	/*
447 	 * XXX Still not right for module unload -- just counting
448 	 * the probes is not enough
449 	 */
450 	if (tnf_changed_probe_list) {
451 		mutex_enter(&mod_lock);
452 		tnf_changed_probe_list = 0;
453 		tnf_drv_state.tnf_probe_count = 0;
454 		for (p = (tnf_probe_control_t *)__tnf_probe_list_head;
455 		    p != 0; p = p->next)
456 			++tnf_drv_state.tnf_probe_count;
457 		mutex_exit(&mod_lock);
458 	}
459 	if (ddi_copyout((caddr_t)&tnf_drv_state.tnf_probe_count,
460 	    arg, sizeof (tnf_drv_state.tnf_probe_count), mode))
461 		return (EFAULT);
462 	return (0);
463 }
464 
465 static int
tnf_getprobevals(caddr_t arg,int mode)466 tnf_getprobevals(caddr_t arg, int mode)
467 {
468 	tnf_probevals_t probebuf;
469 	tnf_probe_control_t *p;
470 	int i, retval = 0;
471 
472 	if (ddi_copyin(arg, (caddr_t)&probebuf, sizeof (probebuf), mode))
473 		return (EFAULT);
474 
475 	mutex_enter(&mod_lock);
476 	for (i = 1, p = (tnf_probe_control_t *)__tnf_probe_list_head;
477 	    p != NULL && i != probebuf.probenum;
478 	    ++i, p = p->next)
479 		;
480 	if (p == NULL)
481 		retval = ENOENT;
482 	else {
483 		probebuf.enabled = (p->test_func != NULL);
484 		probebuf.traced = (p->probe_func == tnf_trace_commit);
485 		/* LINTED assignment of 64-bit integer to 32-bit integer */
486 		probebuf.attrsize = strlen(p->attrs) + 1;
487 		if (ddi_copyout((caddr_t)&probebuf,
488 		    arg, sizeof (probebuf), mode))
489 			retval = EFAULT;
490 	}
491 	mutex_exit(&mod_lock);
492 	return (retval);
493 }
494 
495 static int
tnf_getprobestring(caddr_t arg,int mode)496 tnf_getprobestring(caddr_t arg, int mode)
497 {
498 	tnf_probevals_t probebuf;
499 	tnf_probe_control_t *p;
500 	int i, retval = 0;
501 
502 	if (ddi_copyin(arg, (caddr_t)&probebuf, sizeof (probebuf), mode))
503 		return (EFAULT);
504 
505 	mutex_enter(&mod_lock);
506 	for (i = 1, p = (tnf_probe_control_t *)__tnf_probe_list_head;
507 	    p != NULL && i != probebuf.probenum;
508 	    ++i, p = p->next)
509 		;
510 	if (p == NULL)
511 		retval = ENOENT;
512 	else if (ddi_copyout((caddr_t)p->attrs,
513 	    arg, strlen(p->attrs) + 1, mode))
514 		retval = EFAULT;
515 	mutex_exit(&mod_lock);
516 	return (retval);
517 }
518 
519 static int
tnf_setprobevals(caddr_t arg,int mode)520 tnf_setprobevals(caddr_t arg, int mode)
521 {
522 	tnf_probevals_t probebuf;
523 	tnf_probe_control_t *p;
524 	int i, retval = 0;
525 
526 	if (ddi_copyin(arg, (caddr_t)&probebuf, sizeof (probebuf), mode))
527 		return (EFAULT);
528 
529 	mutex_enter(&mod_lock);
530 	for (i = 1, p = (tnf_probe_control_t *)__tnf_probe_list_head;
531 	    p != NULL && i != probebuf.probenum;
532 	    ++i, p = p->next)
533 		;
534 	if (p == NULL)
535 		retval = ENOENT;
536 	else {
537 		/*
538 		 * First do trace, then enable.
539 		 * Set test_func last.
540 		 */
541 		if (probebuf.traced)
542 			p->probe_func = tnf_trace_commit;
543 		else
544 			p->probe_func = tnf_trace_rollback;
545 		if (probebuf.enabled) {
546 			p->alloc_func = tnf_trace_alloc;
547 			/* this must be set last */
548 			if (tnf_drv_state.tnf_pidfilter_mode)
549 				p->test_func = tnf_test_2;
550 			else
551 				p->test_func = tnf_test_1;
552 		} else
553 			p->test_func = NULL;
554 	}
555 	mutex_exit(&mod_lock);
556 	return (retval);
557 }
558 
559 static int
tnf_getstate(caddr_t arg,int mode)560 tnf_getstate(caddr_t arg, int mode)
561 {
562 	tifiocstate_t	tstate;
563 	proc_t		*procp;
564 
565 	if (tnf_buf == NULL) {
566 		tstate.buffer_state = TIFIOCBUF_NONE;
567 		tstate.buffer_size = 0;
568 	} else {
569 		switch (tnfw_b_state & ~TNFW_B_STOPPED) {
570 		case TNFW_B_RUNNING:
571 			tstate.buffer_state = TIFIOCBUF_OK;
572 			break;
573 		case TNFW_B_NOBUFFER:
574 			tstate.buffer_state = TIFIOCBUF_UNINIT;
575 			break;
576 		case TNFW_B_BROKEN:
577 			tstate.buffer_state = TIFIOCBUF_BROKEN;
578 			break;
579 		}
580 		/* LINTED assignment of 64-bit integer to 32-bit integer */
581 		tstate.buffer_size = tnf_trace_file_size;
582 	}
583 	tstate.trace_stopped = tnfw_b_state & TNFW_B_STOPPED;
584 	tstate.pidfilter_mode = tnf_drv_state.tnf_pidfilter_mode;
585 	tstate.pidfilter_size = 0;
586 
587 	mutex_enter(&pidlock);
588 	for (procp = practive; procp != NULL; procp = procp->p_next)
589 		if (PROC_IS_FILTER(procp))
590 			tstate.pidfilter_size++;
591 	mutex_exit(&pidlock);
592 
593 	if (ddi_copyout((caddr_t)&tstate, arg, sizeof (tstate), mode))
594 		return (EFAULT);
595 	return (0);
596 }
597 
598 static int
tnf_allocbuf(intptr_t arg)599 tnf_allocbuf(intptr_t arg)
600 {
601 	size_t bufsz;
602 
603 	if (tnf_buf != NULL)
604 		return (EBUSY);
605 
606 	bufsz = roundup((size_t)arg, PAGESIZE);
607 	/*
608 	 * Validate size
609 	 * XXX Take kernel VM into consideration as well
610 	 */
611 	/* bug fix #4057599 if (bufsz > (physmem << PAGESHIFT) / 2) */
612 	if (btop(bufsz) > (physmem / 2))
613 		return (ENOMEM);
614 	if (bufsz < TNF_TRACE_FILE_MIN)
615 		bufsz = TNF_TRACE_FILE_MIN;
616 
617 #if TNF_USE_KMA
618 	tnf_buf = kmem_zalloc(bufsz, KM_SLEEP);
619 #else
620 	/* LINTED cast from 64-bit integer to 32-bit intege */
621 	tnf_buf = segkp_get(segkp, (int)bufsz,
622 	    KPD_ZERO | KPD_LOCKED | KPD_NO_ANON);
623 #endif
624 	if (tnf_buf == NULL)
625 		return (ENOMEM);
626 
627 	tnf_trace_file_size = bufsz;
628 	tnf_trace_init();
629 	return (0);
630 }
631 
632 /*
633  * Process a "deallocate buffer" ioctl request.  Tracing must be turned
634  * off.  We must clear references to the buffer from the tag sites;
635  * invalidate all threads' notions of block ownership; make sure nobody
636  * is executing a probe (they might have started before tracing was
637  * turned off); and free the buffer.
638  */
639 static int
tnf_deallocbuf(void)640 tnf_deallocbuf(void)
641 {
642 	tnf_ops_t *tpdp;
643 	kthread_t *t;
644 	tnf_probe_control_t *probep;
645 	tnf_tag_data_t *tagp;
646 
647 	if (tnf_drv_state.mapdev_open_count > 0 || tnf_tracing_active)
648 		return (EBUSY);
649 	if (tnf_buf == NULL)
650 		return (ENOMEM);
651 
652 	/*
653 	 * Make sure nobody is executing a probe.
654 	 * (They could be if they got started while
655 	 * tnf_tracing_active was still on.)  Grab
656 	 * pidlock, and check the busy flag in all
657 	 * TPDP's.
658 	 */
659 	mutex_enter(&pidlock);
660 	t = curthread;
661 	do {
662 		if (t->t_tnf_tpdp != NULL) {
663 		/* LINTED pointer cast may result in improper alignment */
664 			tpdp = (tnf_ops_t *)t->t_tnf_tpdp;
665 			if (LOCK_HELD(&tpdp->busy)) {
666 				mutex_exit(&pidlock);
667 				return (EBUSY);
668 			}
669 			tpdp->wcb.tnfw_w_pos.tnfw_w_block = NULL;
670 			tpdp->wcb.tnfw_w_tag_pos.tnfw_w_block = NULL;
671 			tpdp->schedule.record_p = NULL;
672 		}
673 		t = t->t_next;
674 	} while (t != curthread);
675 	mutex_exit(&pidlock);
676 
677 	/*
678 	 * Zap all references to the buffer we're freeing.
679 	 * Grab mod_lock while walking list to keep it
680 	 * consistent.
681 	 */
682 	mutex_enter(&mod_lock);
683 	tagp = (tnf_tag_data_t *)__tnf_tag_list_head;
684 	while (tagp != NULL) {
685 		tagp->tag_index = 0;
686 		tagp = (tnf_tag_data_t *)tagp->tag_version;
687 	}
688 	probep = (tnf_probe_control_t *)__tnf_probe_list_head;
689 	while (probep != NULL) {
690 		probep->index = 0;
691 		probep = probep->next;
692 	}
693 	mutex_exit(&mod_lock);
694 
695 	tnfw_b_state = TNFW_B_NOBUFFER | TNFW_B_STOPPED;
696 #if TNF_USE_KMA
697 	kmem_free(tnf_buf, tnf_trace_file_size);
698 #else
699 	segkp_release(segkp, tnf_buf);
700 #endif
701 	tnf_buf = NULL;
702 
703 	return (0);
704 }
705 
706 static int
tnf_settracing(int arg)707 tnf_settracing(int arg)
708 {
709 	if (arg)
710 		if (tnf_buf == NULL)
711 			return (ENOMEM);
712 		else
713 			tnf_trace_on();
714 	else
715 		tnf_trace_off();
716 
717 #ifdef _TNF_SPEED_TEST
718 #define	NITER	255
719 	{
720 		int i;
721 
722 		for (i = 0; i < NITER; i++)
723 			TNF_PROBE_0(tnf_speed_0, "tnf", /* CSTYLED */);
724 		for (i = 0; i < NITER; i++)
725 			TNF_PROBE_1(tnf_speed_1, "tnf", /* CSTYLED */,
726 			    tnf_long,	long,	i);
727 		for (i = 0; i < NITER; i++)
728 			TNF_PROBE_2(tnf_speed_2, "tnf", /* CSTYLED */,
729 			    tnf_long,	long1,	i,
730 			    tnf_long,	long2,	i);
731 	}
732 #endif /* _TNF_SPEED_TEST */
733 
734 	return (0);
735 }
736 
737 static int
tnf_getpidstate(caddr_t arg,int mode)738 tnf_getpidstate(caddr_t arg, int mode)
739 {
740 	int	err = 0;
741 	pid_t	pid;
742 	proc_t	*procp;
743 	int	result;
744 
745 	if (ddi_copyin(arg, (caddr_t)&pid, sizeof (pid), mode))
746 		return (EFAULT);
747 
748 	mutex_enter(&pidlock);
749 	if ((procp = prfind(pid)) != NULL)
750 		result = PROC_IS_FILTER(procp);
751 	else
752 		err = ESRCH;
753 	mutex_exit(&pidlock);
754 
755 	if (!err)
756 		if (ddi_copyout((caddr_t)&result, (caddr_t)arg,
757 		    sizeof (result), mode))
758 			return (EFAULT);
759 	return (err);
760 }
761 
762 /*ARGSUSED*/
763 static int
tnf_setpidstate(int filterval,pid_t pid,int mode)764 tnf_setpidstate(int filterval, pid_t pid, int mode)
765 {
766 	int	err = 0;
767 	proc_t	*procp;
768 
769 	mutex_enter(&pidlock);
770 	if ((procp = prfind(pid)) != NULL)
771 		if (filterval)
772 			PROC_FILTER_SET(procp);
773 		else
774 			PROC_FILTER_CLR(procp);
775 	else
776 		err = ESRCH;
777 	mutex_exit(&pidlock);
778 
779 	return (err);
780 }
781 
782 static int
tnf_pidfilterset(int mode)783 tnf_pidfilterset(int mode)
784 {
785 	tnf_probe_control_t	*p;
786 	tnf_probe_test_func_t	func;
787 
788 	tnf_drv_state.tnf_pidfilter_mode = mode;
789 
790 	/* Establish correct test func for each probe */
791 	if (mode)
792 		func = tnf_test_2;
793 	else
794 		func = tnf_test_1;
795 
796 	mutex_enter(&mod_lock);
797 	p = (tnf_probe_control_t *)__tnf_probe_list_head;
798 	while (p != NULL) {
799 		if (p->test_func != NULL)
800 			p->test_func = func;
801 		p = p->next;
802 	}
803 	mutex_exit(&mod_lock);
804 
805 	return (0);
806 }
807 
808 static int
tnf_pidfilterget(caddr_t dest,int mode)809 tnf_pidfilterget(caddr_t dest, int mode)
810 {
811 	int err = 0;
812 	int filtercount = 0;
813 	size_t	sz;
814 	pid_t	*filterbuf, *bufp;
815 	proc_t	*procp;
816 
817 	/* Count how many processes in filter set (upper bound) */
818 	mutex_enter(&pidlock);
819 	for (procp = practive; procp != NULL; procp = procp->p_next)
820 		if (PROC_IS_FILTER(procp))
821 			filtercount++;
822 	mutex_exit(&pidlock);
823 
824 	/* Allocate temp space to hold filter set (upper bound) */
825 	sz = sizeof (pid_t) * (filtercount + 1);
826 	filterbuf = kmem_zalloc(sz, KM_SLEEP);
827 
828 	/*
829 	 * NOTE: The filter set cannot grow between the first and
830 	 * second acquisitions of pidlock.  This is currently true
831 	 * because:
832 	 *	1. /dev/tnfctl is exclusive open, so all driver
833 	 *	   control operations, including changing the filter
834 	 *	   set and this code, are effectively single-threaded.
835 	 *	2. There is no in-kernel API to manipulate the filter
836 	 *	   set (i.e. toggle the on/off bit in a proc struct).
837 	 *	3. The proc filter bit is not inherited across a fork()
838 	 *	   operation; the child starts with the bit off.
839 	 * If any of these assumptions is invalidated, a possible
840 	 * solution is to check whether we're overflowing the allocated
841 	 * filterbuf below, and back out and restart from the beginning
842 	 * if so.
843 	 *
844 	 * The code below handles the case when the filter set shrinks
845 	 * due to processes exiting.
846 	 */
847 
848 	/* Fill in filter set */
849 	bufp = filterbuf + 1;	/* first word is for count */
850 	filtercount = 0;	/* recomputed below */
851 	mutex_enter(&pidlock);
852 	for (procp = practive; procp != NULL; procp = procp->p_next) {
853 		if (PROC_IS_FILTER(procp)) {
854 			filtercount++;
855 			*bufp++ = procp->p_pid;
856 		}
857 	}
858 	mutex_exit(&pidlock);
859 
860 	/* Set filtercount */
861 	*filterbuf = (pid_t)filtercount;
862 
863 	/* Copy out result */
864 	if (ddi_copyout((caddr_t)filterbuf, dest, sz, mode))
865 		err = EFAULT;
866 
867 	/* Free temp space */
868 	kmem_free(filterbuf, sz);
869 
870 	return (err);
871 }
872 
873 static int
tnf_getheader(caddr_t arg,int mode)874 tnf_getheader(caddr_t arg, int mode)
875 {
876 	if (tnf_buf == NULL)
877 		return (ENOMEM);
878 	if (ddi_copyout(tnf_buf, arg, TNF_BLOCK_SIZE, mode))
879 		return (EFAULT);
880 	return (0);
881 }
882 
883 static int
tnf_getblock(caddr_t arg,int mode)884 tnf_getblock(caddr_t arg, int mode)
885 {
886 	int		err = 0;
887 	tifiocgblock_t	parms;
888 	caddr_t		area;
889 	tnf_block_header_t	*blk;
890 
891 	if (tnf_buf == NULL)
892 		return (ENOMEM);
893 	if (ddi_copyin(arg, (caddr_t)&parms, sizeof (parms), mode))
894 		return (EFAULT);
895 	area = tnf_buf + TNF_DIRECTORY_SIZE +
896 	    parms.block_num * TNF_BLOCK_SIZE;
897 	if (area < tnf_buf + TNF_DIRECTORY_SIZE ||
898 	    area >= tnf_buf + tnf_trace_file_size)
899 		return (EFAULT);
900 	/* LINTED pointer cast */
901 	blk = (tnf_block_header_t *)area;
902 	/*
903 	 * B-lock the block while we're reading
904 	 */
905 	if (!lock_try(&blk->B_lock))
906 		return (EBUSY);
907 	if (ddi_copyout(area, parms.dst_addr, TNF_BLOCK_SIZE, mode))
908 		err = EFAULT;
909 	lock_clear(&blk->B_lock);
910 	return (err);
911 }
912 
913 static int
tnf_getfwzone(caddr_t arg,int mode)914 tnf_getfwzone(caddr_t arg, int mode)
915 {
916 	tifiocgfw_t parms;
917 
918 	if (tnf_buf == NULL)
919 		return (ENOMEM);
920 	if (ddi_copyin(arg, (caddr_t)&parms, sizeof (parms), mode))
921 		return (EFAULT);
922 	if (ddi_copyout(tnf_buf + TNF_BLOCK_SIZE + parms.start *
923 	    sizeof (tnf_ref32_t), (caddr_t)parms.dst_addr,
924 	    parms.slots * (int)(sizeof (tnf_ref32_t)), mode))
925 		return (EFAULT);
926 	return (0);
927 }
928 
929 /*ARGSUSED*/
930 static void *
tnf_test_1(void * tpdp,tnf_probe_control_t * probe_p,tnf_probe_setup_t * sp)931 tnf_test_1(void *tpdp, tnf_probe_control_t *probe_p, tnf_probe_setup_t *sp)
932 {
933 	tpdp = (void *)curthread->t_tnf_tpdp;
934 	if (tpdp != NULL)
935 		return (tnf_trace_alloc((tnf_ops_t *)tpdp, probe_p, sp));
936 	return (NULL);
937 }
938 
939 /*ARGSUSED*/
940 static void *
tnf_test_2(void * tpdp,tnf_probe_control_t * probe_p,tnf_probe_setup_t * sp)941 tnf_test_2(void *tpdp, tnf_probe_control_t *probe_p, tnf_probe_setup_t *sp)
942 {
943 	tpdp = (void *)curthread->t_tnf_tpdp;
944 	if (tpdp != NULL && PROC_IS_FILTER(curproc))
945 		return (tnf_trace_alloc((tnf_ops_t *)tpdp, probe_p, sp));
946 	return (NULL);
947 }
948 
949 #endif /* !NPROBE */
950