usr/src/uts/common/io/cpc.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 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*
  27  * CPU Performance Counter system calls and device driver.
  28  *
  29  * This module uses a combination of thread context operators, and
  30  * thread-specific data to export CPU performance counters
  31  * via both a system call and a driver interface.
  32  *
  33  * There are three access methods exported - the 'shared' device
  34  * and the 'private' and 'agent' variants of the system call.
  35  *
  36  * The shared device treats the performance counter registers as
  37  * a processor metric, regardless of the work scheduled on them.
  38  * The private system call treats the performance counter registers
  39  * as a property of a single lwp.  This is achieved by using the
  40  * thread context operators to virtualize the contents of the
  41  * performance counter registers between lwps.
  42  *
  43  * The agent method is like the private method, except that it must
  44  * be accessed via /proc's agent lwp to allow the counter context of
  45  * other threads to be examined safely.
  46  *
  47  * The shared usage fundamentally conflicts with the agent and private usage;
  48  * almost all of the complexity of the module is needed to allow these two
  49  * models to co-exist in a reasonable way.
  50  */
  51
  52 #include <sys/types.h>
  53 #include <sys/file.h>
  54 #include <sys/errno.h>
  55 #include <sys/open.h>
  56 #include <sys/cred.h>
  57 #include <sys/conf.h>
  58 #include <sys/stat.h>
  59 #include <sys/processor.h>
  60 #include <sys/cpuvar.h>
  61 #include <sys/disp.h>
  62 #include <sys/kmem.h>
  63 #include <sys/modctl.h>
  64 #include <sys/ddi.h>
  65 #include <sys/sunddi.h>
  66 #include <sys/nvpair.h>
  67 #include <sys/policy.h>
  68 #include <sys/machsystm.h>
  69 #include <sys/cpc_impl.h>
  70 #include <sys/cpc_pcbe.h>
  71 #include <sys/kcpc.h>
  72
  73 static int kcpc_copyin_set(kcpc_set_t **set, void *ubuf, size_t len);
  74 static int kcpc_verify_set(kcpc_set_t *set);
  75 static uint32_t kcpc_nvlist_npairs(nvlist_t *list);
  76
  77 /*
  78  * Generic attributes supported regardless of processor.
  79  */
  80
  81 #define ATTRLIST "picnum"
  82 #define SEPARATOR ","
  83
  84 /*
  85  * System call to access CPU performance counters.
  86  */
  87 static int
  88 cpc(int cmd, id_t lwpid, void *udata1, void *udata2, void *udata3)
  89 {
  90         kthread_t       *t;
  91         int             error;
  92         int             size;
  93         const char      *str;
  94         int             code;
  95
  96         /*
  97          * This CPC syscall should only be loaded if it found a PCBE to use.
  98          */
  99         ASSERT(pcbe_ops != NULL);
 100
 101         if (curproc->p_agenttp == curthread) {
 102                 /*
 103                  * Only if /proc is invoking this system call from
 104                  * the agent thread do we allow the caller to examine
 105                  * the contexts of other lwps in the process.  And
 106                  * because we know we're the agent, we know we don't
 107                  * have to grab p_lock because no-one else can change
 108                  * the state of the process.
 109                  */
 110                 if ((t = idtot(curproc, lwpid)) == NULL || t == curthread)
 111                         return (set_errno(ESRCH));
 112                 ASSERT(t->t_tid == lwpid && ttolwp(t) != NULL);
 113         } else
 114                 t = curthread;
 115
 116         if (t->t_cpc_set == NULL && (cmd == CPC_SAMPLE || cmd == CPC_RELE))
 117                 return (set_errno(EINVAL));
 118
 119         switch (cmd) {
 120         case CPC_BIND:
 121                 /*
 122                  * udata1 = pointer to packed nvlist buffer
 123                  * udata2 = size of packed nvlist buffer
 124                  * udata3 = User addr to return error subcode in.
 125                  */
 126
 127                 rw_enter(&kcpc_cpuctx_lock, RW_READER);
 128                 if (kcpc_cpuctx || dtrace_cpc_in_use) {
 129                         rw_exit(&kcpc_cpuctx_lock);
 130                         return (set_errno(EAGAIN));
 131                 }
 132
 133                 if (kcpc_hw_lwp_hook() != 0) {
 134                         rw_exit(&kcpc_cpuctx_lock);
 135                         return (set_errno(EACCES));
 136                 }
 137
 138                 /*
 139                  * An LWP may only have one set bound to it at a time; if there
 140                  * is a set bound to this LWP already, we unbind it here.
 141                  */
 142                 if (t->t_cpc_set != NULL)
 143                         (void) kcpc_unbind(t->t_cpc_set);
 144                 ASSERT(t->t_cpc_set == NULL);
 145
 146                 if ((error = kcpc_copyin_set(&t->t_cpc_set, udata1,
 147                     (size_t)udata2)) != 0) {
 148                         rw_exit(&kcpc_cpuctx_lock);
 149                         return (set_errno(error));
 150                 }
 151
 152                 if ((error = kcpc_verify_set(t->t_cpc_set)) != 0) {
 153                         rw_exit(&kcpc_cpuctx_lock);
 154                         kcpc_free_set(t->t_cpc_set);
 155                         t->t_cpc_set = NULL;
 156                         if (copyout(&error, udata3, sizeof (error)) == -1)
 157                                 return (set_errno(EFAULT));
 158                         return (set_errno(EINVAL));
 159                 }
 160
 161                 if ((error = kcpc_bind_thread(t->t_cpc_set, t, &code)) != 0) {
 162                         rw_exit(&kcpc_cpuctx_lock);
 163                         kcpc_free_set(t->t_cpc_set);
 164                         t->t_cpc_set = NULL;
 165                         /*
 166                          * EINVAL and EACCES are the only errors with more
 167                          * specific subcodes.
 168                          */
 169                         if ((error == EINVAL || error == EACCES) &&
 170                             copyout(&code, udata3, sizeof (code)) == -1)
 171                                 return (set_errno(EFAULT));
 172                         return (set_errno(error));
 173                 }
 174
 175                 rw_exit(&kcpc_cpuctx_lock);
 176                 return (0);
 177         case CPC_SAMPLE:
 178                 /*
 179                  * udata1 = pointer to user's buffer
 180                  * udata2 = pointer to user's hrtime
 181                  * udata3 = pointer to user's tick
 182                  */
 183                 /*
 184                  * We only allow thread-bound sets to be sampled via the
 185                  * syscall, so if this set has a CPU-bound context, return an
 186                  * error.
 187                  */
 188                 if (t->t_cpc_set->ks_ctx->kc_cpuid != -1)
 189                         return (set_errno(EINVAL));
 190                 if ((error = kcpc_sample(t->t_cpc_set, udata1, udata2,
 191                     udata3)) != 0)
 192                         return (set_errno(error));
 193
 194                 return (0);
 195         case CPC_PRESET:
 196         case CPC_RESTART:
 197                 /*
 198                  * These are valid only if this lwp has a bound set.
 199                  */
 200                 if (t->t_cpc_set == NULL)
 201                         return (set_errno(EINVAL));
 202                 if (cmd == CPC_PRESET) {
 203                         /*
 204                          * The preset is shipped up to us from userland in two
 205                          * parts. This lets us handle 64-bit values from 32-bit
 206                          * and 64-bit applications in the same manner.
 207                          *
 208                          * udata1 = index of request to preset
 209                          * udata2 = new 64-bit preset (most sig. 32 bits)
 210                          * udata3 = new 64-bit preset (least sig. 32 bits)
 211                          */
 212                         if ((error = kcpc_preset(t->t_cpc_set, (intptr_t)udata1,
 213                             ((uint64_t)(uintptr_t)udata2 << 32ULL) |
 214                             (uint64_t)(uintptr_t)udata3)) != 0)
 215                                 return (set_errno(error));
 216                 } else {
 217                         /*
 218                          * udata[1-3] = unused
 219                          */
 220                         if ((error = kcpc_restart(t->t_cpc_set)) != 0)
 221                                 return (set_errno(error));
 222                 }
 223                 return (0);
 224         case CPC_ENABLE:
 225         case CPC_DISABLE:
 226                 udata1 = 0;
 227                 /*FALLTHROUGH*/
 228         case CPC_USR_EVENTS:
 229         case CPC_SYS_EVENTS:
 230                 if (t != curthread || t->t_cpc_set == NULL)
 231                         return (set_errno(EINVAL));
 232                 /*
 233                  * Provided for backwards compatibility with CPCv1.
 234                  *
 235                  * Stop the counters and record the current counts. Use the
 236                  * counts as the preset to rebind a new set with the requests
 237                  * reconfigured as requested.
 238                  *
 239                  * udata1: 1 == enable; 0 == disable
 240                  * udata{2,3}: unused
 241                  */
 242                 rw_enter(&kcpc_cpuctx_lock, RW_READER);
 243                 if ((error = kcpc_enable(t,
 244                     cmd, (int)(uintptr_t)udata1)) != 0) {
 245                         rw_exit(&kcpc_cpuctx_lock);
 246                         return (set_errno(error));
 247                 }
 248                 rw_exit(&kcpc_cpuctx_lock);
 249                 return (0);
 250         case CPC_NPIC:
 251                 return (cpc_ncounters);
 252         case CPC_CAPS:
 253                 return (pcbe_ops->pcbe_caps);
 254         case CPC_EVLIST_SIZE:
 255         case CPC_LIST_EVENTS:
 256                 /*
 257                  * udata1 = pointer to user's int or buffer
 258                  * udata2 = picnum
 259                  * udata3 = unused
 260                  */
 261                 if ((uintptr_t)udata2 >= cpc_ncounters)
 262                         return (set_errno(EINVAL));
 263
 264                 size = strlen(
 265                     pcbe_ops->pcbe_list_events((uintptr_t)udata2)) + 1;
 266
 267                 if (cmd == CPC_EVLIST_SIZE) {
 268                         if (suword32(udata1, size) == -1)
 269                                 return (set_errno(EFAULT));
 270                 } else {
 271                         if (copyout(
 272                             pcbe_ops->pcbe_list_events((uintptr_t)udata2),
 273                             udata1, size) == -1)
 274                                 return (set_errno(EFAULT));
 275                 }
 276                 return (0);
 277         case CPC_ATTRLIST_SIZE:
 278         case CPC_LIST_ATTRS:
 279                 /*
 280                  * udata1 = pointer to user's int or buffer
 281                  * udata2 = unused
 282                  * udata3 = unused
 283                  *
 284                  * attrlist size is length of PCBE-supported attributes, plus
 285                  * room for "picnum\0" plus an optional ',' separator char.
 286                  */
 287                 str = pcbe_ops->pcbe_list_attrs();
 288                 size = strlen(str) + sizeof (SEPARATOR ATTRLIST) + 1;
 289                 if (str[0] != '\0')
 290                         /*
 291                          * A ',' separator character is necessary.
 292                          */
 293                         size += 1;
 294
 295                 if (cmd == CPC_ATTRLIST_SIZE) {
 296                         if (suword32(udata1, size) == -1)
 297                                 return (set_errno(EFAULT));
 298                 } else {
 299                         /*
 300                          * Copyout the PCBE attributes, and then append the
 301                          * generic attribute list (with separator if necessary).
 302                          */
 303                         if (copyout(str, udata1, strlen(str)) == -1)
 304                                 return (set_errno(EFAULT));
 305                         if (str[0] != '\0') {
 306                                 if (copyout(SEPARATOR ATTRLIST,
 307                                     ((char *)udata1) + strlen(str),
 308                                     strlen(SEPARATOR ATTRLIST) + 1)
 309                                     == -1)
 310                                         return (set_errno(EFAULT));
 311                         } else
 312                                 if (copyout(ATTRLIST,
 313                                     (char *)udata1 + strlen(str),
 314                                     strlen(ATTRLIST) + 1) == -1)
 315                                         return (set_errno(EFAULT));
 316                 }
 317                 return (0);
 318         case CPC_IMPL_NAME:
 319         case CPC_CPUREF:
 320                 /*
 321                  * udata1 = pointer to user's buffer
 322                  * udata2 = unused
 323                  * udata3 = unused
 324                  */
 325                 if (cmd == CPC_IMPL_NAME) {
 326                         str = pcbe_ops->pcbe_impl_name();
 327                         ASSERT(strlen(str) < CPC_MAX_IMPL_NAME);
 328                 } else {
 329                         str = pcbe_ops->pcbe_cpuref();
 330                         ASSERT(strlen(str) < CPC_MAX_CPUREF);
 331                 }
 332
 333                 if (copyout(str, udata1, strlen(str) + 1) != 0)
 334                         return (set_errno(EFAULT));
 335                 return (0);
 336         case CPC_INVALIDATE:
 337                 kcpc_invalidate(t);
 338                 return (0);
 339         case CPC_RELE:
 340                 if ((error = kcpc_unbind(t->t_cpc_set)) != 0)
 341                         return (set_errno(error));
 342                 return (0);
 343         default:
 344                 return (set_errno(EINVAL));
 345         }
 346 }
 347
 348 /*
 349  * The 'shared' device allows direct access to the
 350  * performance counter control register of the current CPU.
 351  * The major difference between the contexts created here and those
 352  * above is that the context handlers are -not- installed, thus
 353  * no context switching behaviour occurs.
 354  *
 355  * Because they manipulate per-cpu state, these ioctls can
 356  * only be invoked from a bound lwp, by a caller with the cpc_cpu privilege
 357  * who can open the relevant entry in /devices (the act of holding it open
 358  * causes other uses of the counters to be suspended).
 359  *
 360  * Note that for correct results, the caller -must- ensure that
 361  * all existing per-lwp contexts are either inactive or marked invalid;
 362  * that's what the open routine does.
 363  */
 364 /*ARGSUSED*/
 365 static int
 366 kcpc_ioctl(dev_t dev, int cmd, intptr_t data, int flags, cred_t *cr, int *rvp)
 367 {
 368         kthread_t       *t = curthread;
 369         processorid_t   cpuid;
 370         void            *udata1 = NULL;
 371         void            *udata2 = NULL;
 372         void            *udata3 = NULL;
 373         int             error;
 374         int             code;
 375
 376         STRUCT_DECL(__cpc_args, args);
 377
 378         STRUCT_INIT(args, flags);
 379
 380         if (curthread->t_bind_cpu != getminor(dev))
 381                 return (EAGAIN);  /* someone unbound it? */
 382
 383         cpuid = getminor(dev);
 384
 385         if (cmd == CPCIO_BIND || cmd == CPCIO_SAMPLE) {
 386                 if (copyin((void *)data, STRUCT_BUF(args),
 387                     STRUCT_SIZE(args)) == -1)
 388                         return (EFAULT);
 389
 390                 udata1 = STRUCT_FGETP(args, udata1);
 391                 udata2 = STRUCT_FGETP(args, udata2);
 392                 udata3 = STRUCT_FGETP(args, udata3);
 393         }
 394
 395         switch (cmd) {
 396         case CPCIO_BIND:
 397                 /*
 398                  * udata1 = pointer to packed nvlist buffer
 399                  * udata2 = size of packed nvlist buffer
 400                  * udata3 = User addr to return error subcode in.
 401                  */
 402                 if (t->t_cpc_set != NULL) {
 403                         (void) kcpc_unbind(t->t_cpc_set);
 404                         ASSERT(t->t_cpc_set == NULL);
 405                 }
 406
 407                 if ((error = kcpc_copyin_set(&t->t_cpc_set, udata1,
 408                     (size_t)udata2)) != 0) {
 409                         return (error);
 410                 }
 411
 412                 if ((error = kcpc_verify_set(t->t_cpc_set)) != 0) {
 413                         kcpc_free_set(t->t_cpc_set);
 414                         t->t_cpc_set = NULL;
 415                         if (copyout(&error, udata3, sizeof (error)) == -1)
 416                                 return (EFAULT);
 417                         return (EINVAL);
 418                 }
 419
 420                 if ((error = kcpc_bind_cpu(t->t_cpc_set, cpuid, &code)) != 0) {
 421                         kcpc_free_set(t->t_cpc_set);
 422                         t->t_cpc_set = NULL;
 423                         /*
 424                          * Subcodes are only returned for EINVAL and EACCESS.
 425                          */
 426                         if ((error == EINVAL || error == EACCES) &&
 427                             copyout(&code, udata3, sizeof (code)) == -1)
 428                                 return (EFAULT);
 429                         return (error);
 430                 }
 431
 432                 return (0);
 433         case CPCIO_SAMPLE:
 434                 /*
 435                  * udata1 = pointer to user's buffer
 436                  * udata2 = pointer to user's hrtime
 437                  * udata3 = pointer to user's tick
 438                  */
 439                 /*
 440                  * Only CPU-bound sets may be sampled via the ioctl(). If this
 441                  * set has no CPU-bound context, return an error.
 442                  */
 443                 if (t->t_cpc_set == NULL)
 444                         return (EINVAL);
 445                 if ((error = kcpc_sample(t->t_cpc_set, udata1, udata2,
 446                     udata3)) != 0)
 447                         return (error);
 448                 return (0);
 449         case CPCIO_RELE:
 450                 if (t->t_cpc_set == NULL)
 451                         return (EINVAL);
 452                 return (kcpc_unbind(t->t_cpc_set));
 453         default:
 454                 return (EINVAL);
 455         }
 456 }
 457
 458 /*
 459  * The device supports multiple opens, but only one open
 460  * is allowed per processor.  This is to enable multiple
 461  * instances of tools looking at different processors.
 462  */
 463 #define KCPC_MINOR_SHARED               ((minor_t)0x3fffful)
 464
 465 static ulong_t *kcpc_cpumap;            /* bitmap of cpus */
 466
 467 /*ARGSUSED1*/
 468 static int
 469 kcpc_open(dev_t *dev, int flags, int otyp, cred_t *cr)
 470 {
 471         processorid_t   cpuid;
 472         int             error;
 473
 474         ASSERT(pcbe_ops != NULL);
 475
 476         if ((error = secpolicy_cpc_cpu(cr)) != 0)
 477                 return (error);
 478         if (getminor(*dev) != KCPC_MINOR_SHARED)
 479                 return (ENXIO);
 480         if ((cpuid = curthread->t_bind_cpu) == PBIND_NONE)
 481                 return (EINVAL);
 482         if (cpuid > max_cpuid)
 483                 return (EINVAL);
 484
 485         rw_enter(&kcpc_cpuctx_lock, RW_WRITER);
 486         if (++kcpc_cpuctx == 1) {
 487                 ASSERT(kcpc_cpumap == NULL);
 488
 489                 /*
 490                  * Bail out if DTrace is already using the counters.
 491                  */
 492                 if (dtrace_cpc_in_use) {
 493                         kcpc_cpuctx--;
 494                         rw_exit(&kcpc_cpuctx_lock);
 495                         return (EAGAIN);
 496                 }
 497                 kcpc_cpumap = kmem_zalloc(BT_SIZEOFMAP(max_cpuid + 1),
 498                     KM_SLEEP);
 499                 /*
 500                  * When this device is open for processor-based contexts,
 501                  * no further lwp-based contexts can be created.
 502                  *
 503                  * Since this is the first open, ensure that all existing
 504                  * contexts are invalidated.
 505                  */
 506                 kcpc_invalidate_all();
 507         } else if (BT_TEST(kcpc_cpumap, cpuid)) {
 508                 kcpc_cpuctx--;
 509                 rw_exit(&kcpc_cpuctx_lock);
 510                 return (EAGAIN);
 511         } else if (kcpc_hw_cpu_hook(cpuid, kcpc_cpumap) != 0) {
 512                 kcpc_cpuctx--;
 513                 rw_exit(&kcpc_cpuctx_lock);
 514                 return (EACCES);
 515         }
 516         BT_SET(kcpc_cpumap, cpuid);
 517         rw_exit(&kcpc_cpuctx_lock);
 518
 519         *dev = makedevice(getmajor(*dev), (minor_t)cpuid);
 520
 521         return (0);
 522 }
 523
 524 /*ARGSUSED1*/
 525 static int
 526 kcpc_close(dev_t dev, int flags, int otyp, cred_t *cr)
 527 {
 528         rw_enter(&kcpc_cpuctx_lock, RW_WRITER);
 529         BT_CLEAR(kcpc_cpumap, getminor(dev));
 530         if (--kcpc_cpuctx == 0) {
 531                 kmem_free(kcpc_cpumap, BT_SIZEOFMAP(max_cpuid + 1));
 532                 kcpc_cpumap = NULL;
 533         }
 534         ASSERT(kcpc_cpuctx >= 0);
 535         rw_exit(&kcpc_cpuctx_lock);
 536
 537         return (0);
 538 }
 539
 540 /*
 541  * Sane boundaries on the size of packed lists. In bytes.
 542  */
 543 #define CPC_MIN_PACKSIZE 4
 544 #define CPC_MAX_PACKSIZE 10000
 545
 546 /*
 547  * Sane boundary on the number of requests a set can contain.
 548  */
 549 #define CPC_MAX_NREQS 100
 550
 551 /*
 552  * Sane boundary on the number of attributes a request can contain.
 553  */
 554 #define CPC_MAX_ATTRS 50
 555
 556 /*
 557  * Copy in a packed nvlist from the user and create a request set out of it.
 558  * If successful, return 0 and store a pointer to the set we've created. Returns
 559  * error code on error.
 560  */
 561 int
 562 kcpc_copyin_set(kcpc_set_t **inset, void *ubuf, size_t len)
 563 {
 564         kcpc_set_t      *set;
 565         int             i;
 566         int             j;
 567         char            *packbuf;
 568
 569         nvlist_t        *nvl;
 570         nvpair_t        *nvp = NULL;
 571
 572         nvlist_t        *attrs;
 573         nvpair_t        *nvp_attr;
 574         kcpc_attr_t     *attrp;
 575
 576         nvlist_t        **reqlist;
 577         uint_t          nreqs;
 578         uint64_t        uint64;
 579         uint32_t        uint32;
 580         uint32_t        setflags = (uint32_t)-1;
 581         char            *string;
 582         char            *name;
 583
 584         if (len < CPC_MIN_PACKSIZE || len > CPC_MAX_PACKSIZE)
 585                 return (EINVAL);
 586
 587         packbuf = kmem_alloc(len, KM_SLEEP);
 588
 589         if (copyin(ubuf, packbuf, len) == -1) {
 590                 kmem_free(packbuf, len);
 591                 return (EFAULT);
 592         }
 593
 594         if (nvlist_unpack(packbuf, len, &nvl, KM_SLEEP) != 0) {
 595                 kmem_free(packbuf, len);
 596                 return (EINVAL);
 597         }
 598
 599         /*
 600          * The nvlist has been unpacked so there is no need for the packed
 601          * representation from this point on.
 602          */
 603         kmem_free(packbuf, len);
 604
 605         i = 0;
 606         while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
 607                 switch (nvpair_type(nvp)) {
 608                 case DATA_TYPE_UINT32:
 609                         if (strcmp(nvpair_name(nvp), "flags") != 0 ||
 610                             nvpair_value_uint32(nvp, &setflags) != 0) {
 611                                 nvlist_free(nvl);
 612                                 return (EINVAL);
 613                         }
 614                         break;
 615                 case DATA_TYPE_NVLIST_ARRAY:
 616                         if (strcmp(nvpair_name(nvp), "reqs") != 0 ||
 617                             nvpair_value_nvlist_array(nvp, &reqlist,
 618                             &nreqs) != 0) {
 619                                 nvlist_free(nvl);
 620                                 return (EINVAL);
 621                         }
 622                         break;
 623                 default:
 624                         nvlist_free(nvl);
 625                         return (EINVAL);
 626                 }
 627                 i++;
 628         }
 629
 630         /*
 631          * There should be two members in the top-level nvlist:
 632          * an array of nvlists consisting of the requests, and flags.
 633          * Anything else is an invalid set.
 634          */
 635         if (i != 2) {
 636                 nvlist_free(nvl);
 637                 return (EINVAL);
 638         }
 639
 640         if (nreqs > CPC_MAX_NREQS) {
 641                 nvlist_free(nvl);
 642                 return (EINVAL);
 643         }
 644
 645         /*
 646          * The requests are now stored in the nvlist array at reqlist.
 647          * Note that the use of kmem_zalloc() to alloc the kcpc_set_t means
 648          * we don't need to call the init routines for ks_lock and ks_condv.
 649          */
 650         set = kmem_zalloc(sizeof (kcpc_set_t), KM_SLEEP);
 651         set->ks_req = (kcpc_request_t *)kmem_zalloc(sizeof (kcpc_request_t) *
 652             nreqs, KM_SLEEP);
 653         set->ks_nreqs = nreqs;
 654         /*
 655          * If the nvlist didn't contain a flags member, setflags was initialized
 656          * with an illegal value and this set will fail sanity checks later on.
 657          */
 658         set->ks_flags = setflags;
 659         /*
 660          * Initialize bind/unbind set synchronization.
 661          */
 662         set->ks_state &= ~KCPC_SET_BOUND;
 663
 664         /*
 665          * Build the set up one request at a time, always keeping it self-
 666          * consistent so we can give it to kcpc_free_set() if we need to back
 667          * out and return and error.
 668          */
 669         for (i = 0; i < nreqs; i++) {
 670                 nvp = NULL;
 671                 set->ks_req[i].kr_picnum = -1;
 672                 while ((nvp = nvlist_next_nvpair(reqlist[i], nvp)) != NULL) {
 673                         name = nvpair_name(nvp);
 674                         switch (nvpair_type(nvp)) {
 675                         case DATA_TYPE_UINT32:
 676                                 if (nvpair_value_uint32(nvp, &uint32) == EINVAL)
 677                                         goto inval;
 678                                 if (strcmp(name, "cr_flags") == 0)
 679                                         set->ks_req[i].kr_flags = uint32;
 680                                 if (strcmp(name, "cr_index") == 0)
 681                                         set->ks_req[i].kr_index = uint32;
 682                                 break;
 683                         case DATA_TYPE_UINT64:
 684                                 if (nvpair_value_uint64(nvp, &uint64) == EINVAL)
 685                                         goto inval;
 686                                 if (strcmp(name, "cr_preset") == 0)
 687                                         set->ks_req[i].kr_preset = uint64;
 688                                 break;
 689                         case DATA_TYPE_STRING:
 690                                 if (nvpair_value_string(nvp, &string) == EINVAL)
 691                                         goto inval;
 692                                 if (strcmp(name, "cr_event") == 0)
 693                                         (void) strncpy(set->ks_req[i].kr_event,
 694                                             string, CPC_MAX_EVENT_LEN);
 695                                 break;
 696                         case DATA_TYPE_NVLIST:
 697                                 if (strcmp(name, "cr_attr") != 0)
 698                                         goto inval;
 699                                 if (nvpair_value_nvlist(nvp, &attrs) == EINVAL)
 700                                         goto inval;
 701                                 nvp_attr = NULL;
 702                                 /*
 703                                  * If the picnum has been specified as an
 704                                  * attribute, consume that attribute here and
 705                                  * remove it from the list of attributes.
 706                                  */
 707                                 if (nvlist_lookup_uint64(attrs, "picnum",
 708                                     &uint64) == 0) {
 709                                         if (nvlist_remove(attrs, "picnum",
 710                                             DATA_TYPE_UINT64) != 0)
 711                                                 panic("nvlist %p faulty",
 712                                                     (void *)attrs);
 713                                         set->ks_req[i].kr_picnum = uint64;
 714                                 }
 715
 716                                 if ((set->ks_req[i].kr_nattrs =
 717                                     kcpc_nvlist_npairs(attrs)) == 0)
 718                                         break;
 719
 720                                 if (set->ks_req[i].kr_nattrs > CPC_MAX_ATTRS)
 721                                         goto inval;
 722
 723                                 set->ks_req[i].kr_attr =
 724                                     kmem_alloc(set->ks_req[i].kr_nattrs *
 725                                     sizeof (kcpc_attr_t), KM_SLEEP);
 726                                 j = 0;
 727
 728                                 while ((nvp_attr = nvlist_next_nvpair(attrs,
 729                                     nvp_attr)) != NULL) {
 730                                         attrp = &set->ks_req[i].kr_attr[j];
 731
 732                                         if (nvpair_type(nvp_attr) !=
 733                                             DATA_TYPE_UINT64)
 734                                                 goto inval;
 735
 736                                         (void) strncpy(attrp->ka_name,
 737                                             nvpair_name(nvp_attr),
 738                                             CPC_MAX_ATTR_LEN);
 739
 740                                         if (nvpair_value_uint64(nvp_attr,
 741                                             &(attrp->ka_val)) == EINVAL)
 742                                                 goto inval;
 743                                         j++;
 744                                 }
 745                                 ASSERT(j == set->ks_req[i].kr_nattrs);
 746                         default:
 747                                 break;
 748                         }
 749                 }
 750         }
 751
 752         nvlist_free(nvl);
 753         *inset = set;
 754         return (0);
 755
 756 inval:
 757         nvlist_free(nvl);
 758         kcpc_free_set(set);
 759         return (EINVAL);
 760 }
 761
 762 /*
 763  * Count the number of nvpairs in the supplied nvlist.
 764  */
 765 static uint32_t
 766 kcpc_nvlist_npairs(nvlist_t *list)
 767 {
 768         nvpair_t *nvp = NULL;
 769         uint32_t n = 0;
 770
 771         while ((nvp = nvlist_next_nvpair(list, nvp)) != NULL)
 772                 n++;
 773
 774         return (n);
 775 }
 776
 777 /*
 778  * Performs sanity checks on the given set.
 779  * Returns 0 if the set checks out OK.
 780  * Returns a detailed error subcode, or -1 if there is no applicable subcode.
 781  */
 782 static int
 783 kcpc_verify_set(kcpc_set_t *set)
 784 {
 785         kcpc_request_t  *rp;
 786         int             i;
 787         uint64_t        bitmap = 0;
 788         int             n;
 789
 790         if (set->ks_nreqs > cpc_ncounters)
 791                 return (-1);
 792
 793         if (CPC_SET_VALID_FLAGS(set->ks_flags) == 0)
 794                 return (-1);
 795
 796         for (i = 0; i < set->ks_nreqs; i++) {
 797                 rp = &set->ks_req[i];
 798
 799                 /*
 800                  * The following comparison must cast cpc_ncounters to an int,
 801                  * because kr_picnum will be -1 if the request didn't explicitly
 802                  * choose a PIC.
 803                  */
 804                 if (rp->kr_picnum >= (int)cpc_ncounters)
 805                         return (CPC_INVALID_PICNUM);
 806
 807                 /*
 808                  * Of the pics whose physical picnum has been specified, make
 809                  * sure each PIC appears only once in set.
 810                  */
 811                 if ((n = set->ks_req[i].kr_picnum) != -1) {
 812                         if ((bitmap & (1 << n)) != 0)
 813                                 return (-1);
 814                         bitmap |= (1 << n);
 815                 }
 816
 817                 /*
 818                  * Make sure the requested index falls within the range of all
 819                  * requests.
 820                  */
 821                 if (rp->kr_index < 0 || rp->kr_index >= set->ks_nreqs)
 822                         return (-1);
 823
 824                 /*
 825                  * Make sure there are no unknown flags.
 826                  */
 827                 if (KCPC_REQ_VALID_FLAGS(rp->kr_flags) == 0)
 828                         return (CPC_REQ_INVALID_FLAGS);
 829         }
 830
 831         return (0);
 832 }
 833
 834 static struct cb_ops cb_ops = {
 835         kcpc_open,
 836         kcpc_close,
 837         nodev,          /* strategy */
 838         nodev,          /* print */
 839         nodev,          /* dump */
 840         nodev,          /* read */
 841         nodev,          /* write */
 842         kcpc_ioctl,
 843         nodev,          /* devmap */
 844         nodev,          /* mmap */
 845         nodev,          /* segmap */
 846         nochpoll,       /* poll */
 847         ddi_prop_op,
 848         NULL,
 849         D_NEW | D_MP
 850 };
 851
 852 /*ARGSUSED*/
 853 static int
 854 kcpc_probe(dev_info_t *devi)
 855 {
 856         return (DDI_PROBE_SUCCESS);
 857 }
 858
 859 static dev_info_t *kcpc_devi;
 860
 861 static int
 862 kcpc_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
 863 {
 864         if (cmd != DDI_ATTACH)
 865                 return (DDI_FAILURE);
 866         kcpc_devi = devi;
 867         return (ddi_create_minor_node(devi, "shared", S_IFCHR,
 868             KCPC_MINOR_SHARED, DDI_PSEUDO, 0));
 869 }
 870
 871 /*ARGSUSED*/
 872 static int
 873 kcpc_getinfo(dev_info_t *devi, ddi_info_cmd_t cmd, void *arg, void **result)
 874 {
 875         switch (cmd) {
 876         case DDI_INFO_DEVT2DEVINFO:
 877                 switch (getminor((dev_t)arg)) {
 878                 case KCPC_MINOR_SHARED:
 879                         *result = kcpc_devi;
 880                         return (DDI_SUCCESS);
 881                 default:
 882                         break;
 883                 }
 884                 break;
 885         case DDI_INFO_DEVT2INSTANCE:
 886                 *result = 0;
 887                 return (DDI_SUCCESS);
 888         default:
 889                 break;
 890         }
 891
 892         return (DDI_FAILURE);
 893 }
 894
 895 static struct dev_ops dev_ops = {
 896         DEVO_REV,
 897         0,
 898         kcpc_getinfo,
 899         nulldev,                /* identify */
 900         kcpc_probe,
 901         kcpc_attach,
 902         nodev,                  /* detach */
 903         nodev,                  /* reset */
 904         &cb_ops,
 905         (struct bus_ops *)0,
 906         NULL,
 907         ddi_quiesce_not_needed,         /* quiesce */
 908 };
 909
 910 static struct modldrv modldrv = {
 911         &mod_driverops,
 912         "cpc sampling driver",
 913         &dev_ops
 914 };
 915
 916 static struct sysent cpc_sysent = {
 917         5,
 918         SE_NOUNLOAD | SE_ARGC | SE_32RVAL1,
 919         cpc
 920 };
 921
 922 static struct modlsys modlsys = {
 923         &mod_syscallops,
 924         "cpc sampling system call",
 925         &cpc_sysent
 926 };
 927
 928 #ifdef _SYSCALL32_IMPL
 929 static struct modlsys modlsys32 = {
 930         &mod_syscallops32,
 931         "32-bit cpc sampling system call",
 932         &cpc_sysent
 933 };
 934 #endif
 935
 936 static struct modlinkage modl = {
 937         MODREV_1,
 938         &modldrv,
 939         &modlsys,
 940 #ifdef _SYSCALL32_IMPL
 941         &modlsys32,
 942 #endif
 943 };
 944
 945 int
 946 _init(void)
 947 {
 948         if (kcpc_init() != 0)
 949                 return (ENOTSUP);
 950
 951         return (mod_install(&modl));
 952 }
 953
 954 int
 955 _fini(void)
 956 {
 957         return (mod_remove(&modl));
 958 }
 959
 960 int
 961 _info(struct modinfo *mi)
 962 {
 963         return (mod_info(&modl, mi));
 964 }