usr/src/uts/common/tnf/tnf.c

   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
 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
 208 _fini()
 209 {
 210         /* Not safe to unload this module, currently */
 211         return (EBUSY);
 212 }
 213
 214 int
 215 _info(struct modinfo *modinfop)
 216 {
 217         return (mod_info(&modlinkage, modinfop));
 218 }
 219
 220 /* ARGSUSED */
 221 static int
 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
 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, NULL) == DDI_FAILURE) ||
 248             (ddi_create_minor_node(devi, "tnfmap", S_IFCHR, TNFMAP_MINOR,
 249             DDI_PSEUDO, NULL) == 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 *
 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 *
 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 */