1 /*- 2 * Copyright (c) 2005-2007 Joseph Koshy 3 * Copyright (c) 2007 The FreeBSD Foundation 4 * All rights reserved. 5 * 6 * Portions of this software were developed by A. Joseph Koshy under 7 * sponsorship from the FreeBSD Foundation and Google, Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 */ 31 32 /* 33 * Logging code for hwpmc(4) 34 */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 #include <sys/param.h> 40 #include <sys/capability.h> 41 #include <sys/file.h> 42 #include <sys/kernel.h> 43 #include <sys/kthread.h> 44 #include <sys/lock.h> 45 #include <sys/module.h> 46 #include <sys/mutex.h> 47 #include <sys/pmc.h> 48 #include <sys/pmckern.h> 49 #include <sys/pmclog.h> 50 #include <sys/proc.h> 51 #include <sys/signalvar.h> 52 #include <sys/sysctl.h> 53 #include <sys/systm.h> 54 #include <sys/uio.h> 55 #include <sys/unistd.h> 56 #include <sys/vnode.h> 57 58 /* 59 * Sysctl tunables 60 */ 61 62 SYSCTL_DECL(_kern_hwpmc); 63 64 /* 65 * kern.hwpmc.logbuffersize -- size of the per-cpu owner buffers. 66 */ 67 68 static int pmclog_buffer_size = PMC_LOG_BUFFER_SIZE; 69 TUNABLE_INT(PMC_SYSCTL_NAME_PREFIX "logbuffersize", &pmclog_buffer_size); 70 SYSCTL_INT(_kern_hwpmc, OID_AUTO, logbuffersize, CTLFLAG_TUN|CTLFLAG_RD, 71 &pmclog_buffer_size, 0, "size of log buffers in kilobytes"); 72 73 /* 74 * kern.hwpmc.nbuffer -- number of global log buffers 75 */ 76 77 static int pmc_nlogbuffers = PMC_NLOGBUFFERS; 78 TUNABLE_INT(PMC_SYSCTL_NAME_PREFIX "nbuffers", &pmc_nlogbuffers); 79 SYSCTL_INT(_kern_hwpmc, OID_AUTO, nbuffers, CTLFLAG_TUN|CTLFLAG_RD, 80 &pmc_nlogbuffers, 0, "number of global log buffers"); 81 82 /* 83 * Global log buffer list and associated spin lock. 84 */ 85 86 TAILQ_HEAD(, pmclog_buffer) pmc_bufferlist = 87 TAILQ_HEAD_INITIALIZER(pmc_bufferlist); 88 static struct mtx pmc_bufferlist_mtx; /* spin lock */ 89 static struct mtx pmc_kthread_mtx; /* sleep lock */ 90 91 #define PMCLOG_INIT_BUFFER_DESCRIPTOR(D) do { \ 92 const int __roundup = roundup(sizeof(*D), \ 93 sizeof(uint32_t)); \ 94 (D)->plb_fence = ((char *) (D)) + \ 95 1024*pmclog_buffer_size; \ 96 (D)->plb_base = (D)->plb_ptr = ((char *) (D)) + \ 97 __roundup; \ 98 } while (0) 99 100 101 /* 102 * Log file record constructors. 103 */ 104 #define _PMCLOG_TO_HEADER(T,L) \ 105 ((PMCLOG_HEADER_MAGIC << 24) | \ 106 (PMCLOG_TYPE_ ## T << 16) | \ 107 ((L) & 0xFFFF)) 108 109 /* reserve LEN bytes of space and initialize the entry header */ 110 #define _PMCLOG_RESERVE(PO,TYPE,LEN,ACTION) do { \ 111 uint32_t *_le; \ 112 int _len = roundup((LEN), sizeof(uint32_t)); \ 113 if ((_le = pmclog_reserve((PO), _len)) == NULL) { \ 114 ACTION; \ 115 } \ 116 *_le = _PMCLOG_TO_HEADER(TYPE,_len); \ 117 _le += 3 /* skip over timestamp */ 118 119 #define PMCLOG_RESERVE(P,T,L) _PMCLOG_RESERVE(P,T,L,return) 120 #define PMCLOG_RESERVE_WITH_ERROR(P,T,L) _PMCLOG_RESERVE(P,T,L, \ 121 error=ENOMEM;goto error) 122 123 #define PMCLOG_EMIT32(V) do { *_le++ = (V); } while (0) 124 #define PMCLOG_EMIT64(V) do { \ 125 *_le++ = (uint32_t) ((V) & 0xFFFFFFFF); \ 126 *_le++ = (uint32_t) (((V) >> 32) & 0xFFFFFFFF); \ 127 } while (0) 128 129 130 /* Emit a string. Caution: does NOT update _le, so needs to be last */ 131 #define PMCLOG_EMITSTRING(S,L) do { bcopy((S), _le, (L)); } while (0) 132 133 #define PMCLOG_DESPATCH(PO) \ 134 pmclog_release((PO)); \ 135 } while (0) 136 137 138 /* 139 * Assertions about the log file format. 140 */ 141 142 CTASSERT(sizeof(struct pmclog_callchain) == 6*4 + 143 PMC_CALLCHAIN_DEPTH_MAX*sizeof(uintfptr_t)); 144 CTASSERT(sizeof(struct pmclog_closelog) == 3*4); 145 CTASSERT(sizeof(struct pmclog_dropnotify) == 3*4); 146 CTASSERT(sizeof(struct pmclog_map_in) == PATH_MAX + 147 4*4 + sizeof(uintfptr_t)); 148 CTASSERT(offsetof(struct pmclog_map_in,pl_pathname) == 149 4*4 + sizeof(uintfptr_t)); 150 CTASSERT(sizeof(struct pmclog_map_out) == 4*4 + 2*sizeof(uintfptr_t)); 151 CTASSERT(sizeof(struct pmclog_pcsample) == 6*4 + sizeof(uintfptr_t)); 152 CTASSERT(sizeof(struct pmclog_pmcallocate) == 6*4); 153 CTASSERT(sizeof(struct pmclog_pmcattach) == 5*4 + PATH_MAX); 154 CTASSERT(offsetof(struct pmclog_pmcattach,pl_pathname) == 5*4); 155 CTASSERT(sizeof(struct pmclog_pmcdetach) == 5*4); 156 CTASSERT(sizeof(struct pmclog_proccsw) == 5*4 + 8); 157 CTASSERT(sizeof(struct pmclog_procexec) == 5*4 + PATH_MAX + 158 sizeof(uintfptr_t)); 159 CTASSERT(offsetof(struct pmclog_procexec,pl_pathname) == 5*4 + 160 sizeof(uintfptr_t)); 161 CTASSERT(sizeof(struct pmclog_procexit) == 5*4 + 8); 162 CTASSERT(sizeof(struct pmclog_procfork) == 5*4); 163 CTASSERT(sizeof(struct pmclog_sysexit) == 4*4); 164 CTASSERT(sizeof(struct pmclog_userdata) == 4*4); 165 166 /* 167 * Log buffer structure 168 */ 169 170 struct pmclog_buffer { 171 TAILQ_ENTRY(pmclog_buffer) plb_next; 172 char *plb_base; 173 char *plb_ptr; 174 char *plb_fence; 175 }; 176 177 /* 178 * Prototypes 179 */ 180 181 static int pmclog_get_buffer(struct pmc_owner *po); 182 static void pmclog_loop(void *arg); 183 static void pmclog_release(struct pmc_owner *po); 184 static uint32_t *pmclog_reserve(struct pmc_owner *po, int length); 185 static void pmclog_schedule_io(struct pmc_owner *po); 186 static void pmclog_stop_kthread(struct pmc_owner *po); 187 188 /* 189 * Helper functions 190 */ 191 192 /* 193 * Get a log buffer 194 */ 195 196 static int 197 pmclog_get_buffer(struct pmc_owner *po) 198 { 199 struct pmclog_buffer *plb; 200 201 mtx_assert(&po->po_mtx, MA_OWNED); 202 203 KASSERT(po->po_curbuf == NULL, 204 ("[pmclog,%d] po=%p current buffer still valid", __LINE__, po)); 205 206 mtx_lock_spin(&pmc_bufferlist_mtx); 207 if ((plb = TAILQ_FIRST(&pmc_bufferlist)) != NULL) 208 TAILQ_REMOVE(&pmc_bufferlist, plb, plb_next); 209 mtx_unlock_spin(&pmc_bufferlist_mtx); 210 211 PMCDBG(LOG,GTB,1, "po=%p plb=%p", po, plb); 212 213 #ifdef DEBUG 214 if (plb) 215 KASSERT(plb->plb_ptr == plb->plb_base && 216 plb->plb_base < plb->plb_fence, 217 ("[pmclog,%d] po=%p buffer invariants: ptr=%p " 218 "base=%p fence=%p", __LINE__, po, plb->plb_ptr, 219 plb->plb_base, plb->plb_fence)); 220 #endif 221 222 po->po_curbuf = plb; 223 224 /* update stats */ 225 atomic_add_int(&pmc_stats.pm_buffer_requests, 1); 226 if (plb == NULL) 227 atomic_add_int(&pmc_stats.pm_buffer_requests_failed, 1); 228 229 return (plb ? 0 : ENOMEM); 230 } 231 232 /* 233 * Log handler loop. 234 * 235 * This function is executed by each pmc owner's helper thread. 236 */ 237 238 static void 239 pmclog_loop(void *arg) 240 { 241 int error; 242 struct pmc_owner *po; 243 struct pmclog_buffer *lb; 244 struct proc *p; 245 struct ucred *ownercred; 246 struct ucred *mycred; 247 struct thread *td; 248 struct uio auio; 249 struct iovec aiov; 250 size_t nbytes; 251 252 po = (struct pmc_owner *) arg; 253 p = po->po_owner; 254 td = curthread; 255 mycred = td->td_ucred; 256 257 PROC_LOCK(p); 258 ownercred = crhold(p->p_ucred); 259 PROC_UNLOCK(p); 260 261 PMCDBG(LOG,INI,1, "po=%p kt=%p", po, po->po_kthread); 262 KASSERT(po->po_kthread == curthread->td_proc, 263 ("[pmclog,%d] proc mismatch po=%p po/kt=%p curproc=%p", __LINE__, 264 po, po->po_kthread, curthread->td_proc)); 265 266 lb = NULL; 267 268 269 /* 270 * Loop waiting for I/O requests to be added to the owner 271 * struct's queue. The loop is exited when the log file 272 * is deconfigured. 273 */ 274 275 mtx_lock(&pmc_kthread_mtx); 276 277 for (;;) { 278 279 /* check if we've been asked to exit */ 280 if ((po->po_flags & PMC_PO_OWNS_LOGFILE) == 0) 281 break; 282 283 if (lb == NULL) { /* look for a fresh buffer to write */ 284 mtx_lock_spin(&po->po_mtx); 285 if ((lb = TAILQ_FIRST(&po->po_logbuffers)) == NULL) { 286 mtx_unlock_spin(&po->po_mtx); 287 288 if (po->po_flags & PMC_PO_SHUTDOWN) { 289 mtx_unlock(&pmc_kthread_mtx); 290 /* 291 * Close the file to get PMCLOG_EOF 292 * error in pmclog(3). 293 */ 294 fo_close(po->po_file, curthread); 295 mtx_lock(&pmc_kthread_mtx); 296 } 297 298 (void) msleep(po, &pmc_kthread_mtx, PWAIT, 299 "pmcloop", 0); 300 continue; 301 } 302 303 TAILQ_REMOVE(&po->po_logbuffers, lb, plb_next); 304 mtx_unlock_spin(&po->po_mtx); 305 } 306 307 mtx_unlock(&pmc_kthread_mtx); 308 309 /* process the request */ 310 PMCDBG(LOG,WRI,2, "po=%p base=%p ptr=%p", po, 311 lb->plb_base, lb->plb_ptr); 312 /* change our thread's credentials before issuing the I/O */ 313 314 aiov.iov_base = lb->plb_base; 315 aiov.iov_len = nbytes = lb->plb_ptr - lb->plb_base; 316 317 auio.uio_iov = &aiov; 318 auio.uio_iovcnt = 1; 319 auio.uio_offset = -1; 320 auio.uio_resid = nbytes; 321 auio.uio_rw = UIO_WRITE; 322 auio.uio_segflg = UIO_SYSSPACE; 323 auio.uio_td = td; 324 325 /* switch thread credentials -- see kern_ktrace.c */ 326 td->td_ucred = ownercred; 327 error = fo_write(po->po_file, &auio, ownercred, 0, td); 328 td->td_ucred = mycred; 329 330 if (error) { 331 /* XXX some errors are recoverable */ 332 /* send a SIGIO to the owner and exit */ 333 PROC_LOCK(p); 334 kern_psignal(p, SIGIO); 335 PROC_UNLOCK(p); 336 337 mtx_lock(&pmc_kthread_mtx); 338 339 po->po_error = error; /* save for flush log */ 340 341 PMCDBG(LOG,WRI,2, "po=%p error=%d", po, error); 342 343 break; 344 } 345 346 mtx_lock(&pmc_kthread_mtx); 347 348 /* put the used buffer back into the global pool */ 349 PMCLOG_INIT_BUFFER_DESCRIPTOR(lb); 350 351 mtx_lock_spin(&pmc_bufferlist_mtx); 352 TAILQ_INSERT_HEAD(&pmc_bufferlist, lb, plb_next); 353 mtx_unlock_spin(&pmc_bufferlist_mtx); 354 355 lb = NULL; 356 } 357 358 po->po_kthread = NULL; 359 360 mtx_unlock(&pmc_kthread_mtx); 361 362 /* return the current I/O buffer to the global pool */ 363 if (lb) { 364 PMCLOG_INIT_BUFFER_DESCRIPTOR(lb); 365 366 mtx_lock_spin(&pmc_bufferlist_mtx); 367 TAILQ_INSERT_HEAD(&pmc_bufferlist, lb, plb_next); 368 mtx_unlock_spin(&pmc_bufferlist_mtx); 369 } 370 371 /* 372 * Exit this thread, signalling the waiter 373 */ 374 375 crfree(ownercred); 376 377 kproc_exit(0); 378 } 379 380 /* 381 * Release and log entry and schedule an I/O if needed. 382 */ 383 384 static void 385 pmclog_release(struct pmc_owner *po) 386 { 387 KASSERT(po->po_curbuf->plb_ptr >= po->po_curbuf->plb_base, 388 ("[pmclog,%d] buffer invariants po=%p ptr=%p base=%p", __LINE__, 389 po, po->po_curbuf->plb_ptr, po->po_curbuf->plb_base)); 390 KASSERT(po->po_curbuf->plb_ptr <= po->po_curbuf->plb_fence, 391 ("[pmclog,%d] buffer invariants po=%p ptr=%p fenc=%p", __LINE__, 392 po, po->po_curbuf->plb_ptr, po->po_curbuf->plb_fence)); 393 394 /* schedule an I/O if we've filled a buffer */ 395 if (po->po_curbuf->plb_ptr >= po->po_curbuf->plb_fence) 396 pmclog_schedule_io(po); 397 398 mtx_unlock_spin(&po->po_mtx); 399 400 PMCDBG(LOG,REL,1, "po=%p", po); 401 } 402 403 404 /* 405 * Attempt to reserve 'length' bytes of space in an owner's log 406 * buffer. The function returns a pointer to 'length' bytes of space 407 * if there was enough space or returns NULL if no space was 408 * available. Non-null returns do so with the po mutex locked. The 409 * caller must invoke pmclog_release() on the pmc owner structure 410 * when done. 411 */ 412 413 static uint32_t * 414 pmclog_reserve(struct pmc_owner *po, int length) 415 { 416 uintptr_t newptr, oldptr; 417 uint32_t *lh; 418 struct timespec ts; 419 420 PMCDBG(LOG,ALL,1, "po=%p len=%d", po, length); 421 422 KASSERT(length % sizeof(uint32_t) == 0, 423 ("[pmclog,%d] length not a multiple of word size", __LINE__)); 424 425 mtx_lock_spin(&po->po_mtx); 426 427 /* No more data when shutdown in progress. */ 428 if (po->po_flags & PMC_PO_SHUTDOWN) { 429 mtx_unlock_spin(&po->po_mtx); 430 return (NULL); 431 } 432 433 if (po->po_curbuf == NULL) 434 if (pmclog_get_buffer(po) != 0) { 435 mtx_unlock_spin(&po->po_mtx); 436 return (NULL); 437 } 438 439 KASSERT(po->po_curbuf != NULL, 440 ("[pmclog,%d] po=%p no current buffer", __LINE__, po)); 441 442 KASSERT(po->po_curbuf->plb_ptr >= po->po_curbuf->plb_base && 443 po->po_curbuf->plb_ptr <= po->po_curbuf->plb_fence, 444 ("[pmclog,%d] po=%p buffer invariants: ptr=%p base=%p fence=%p", 445 __LINE__, po, po->po_curbuf->plb_ptr, po->po_curbuf->plb_base, 446 po->po_curbuf->plb_fence)); 447 448 oldptr = (uintptr_t) po->po_curbuf->plb_ptr; 449 newptr = oldptr + length; 450 451 KASSERT(oldptr != (uintptr_t) NULL, 452 ("[pmclog,%d] po=%p Null log buffer pointer", __LINE__, po)); 453 454 /* 455 * If we have space in the current buffer, return a pointer to 456 * available space with the PO structure locked. 457 */ 458 if (newptr <= (uintptr_t) po->po_curbuf->plb_fence) { 459 po->po_curbuf->plb_ptr = (char *) newptr; 460 goto done; 461 } 462 463 /* 464 * Otherwise, schedule the current buffer for output and get a 465 * fresh buffer. 466 */ 467 pmclog_schedule_io(po); 468 469 if (pmclog_get_buffer(po) != 0) { 470 mtx_unlock_spin(&po->po_mtx); 471 return (NULL); 472 } 473 474 KASSERT(po->po_curbuf != NULL, 475 ("[pmclog,%d] po=%p no current buffer", __LINE__, po)); 476 477 KASSERT(po->po_curbuf->plb_ptr != NULL, 478 ("[pmclog,%d] null return from pmc_get_log_buffer", __LINE__)); 479 480 KASSERT(po->po_curbuf->plb_ptr == po->po_curbuf->plb_base && 481 po->po_curbuf->plb_ptr <= po->po_curbuf->plb_fence, 482 ("[pmclog,%d] po=%p buffer invariants: ptr=%p base=%p fence=%p", 483 __LINE__, po, po->po_curbuf->plb_ptr, po->po_curbuf->plb_base, 484 po->po_curbuf->plb_fence)); 485 486 oldptr = (uintptr_t) po->po_curbuf->plb_ptr; 487 488 done: 489 lh = (uint32_t *) oldptr; 490 lh++; /* skip header */ 491 getnanotime(&ts); /* fill in the timestamp */ 492 *lh++ = ts.tv_sec & 0xFFFFFFFF; 493 *lh++ = ts.tv_nsec & 0xFFFFFFF; 494 return ((uint32_t *) oldptr); 495 } 496 497 /* 498 * Schedule an I/O. 499 * 500 * Transfer the current buffer to the helper kthread. 501 */ 502 503 static void 504 pmclog_schedule_io(struct pmc_owner *po) 505 { 506 KASSERT(po->po_curbuf != NULL, 507 ("[pmclog,%d] schedule_io with null buffer po=%p", __LINE__, po)); 508 509 KASSERT(po->po_curbuf->plb_ptr >= po->po_curbuf->plb_base, 510 ("[pmclog,%d] buffer invariants po=%p ptr=%p base=%p", __LINE__, 511 po, po->po_curbuf->plb_ptr, po->po_curbuf->plb_base)); 512 KASSERT(po->po_curbuf->plb_ptr <= po->po_curbuf->plb_fence, 513 ("[pmclog,%d] buffer invariants po=%p ptr=%p fenc=%p", __LINE__, 514 po, po->po_curbuf->plb_ptr, po->po_curbuf->plb_fence)); 515 516 PMCDBG(LOG,SIO, 1, "po=%p", po); 517 518 mtx_assert(&po->po_mtx, MA_OWNED); 519 520 /* 521 * Add the current buffer to the tail of the buffer list and 522 * wakeup the helper. 523 */ 524 TAILQ_INSERT_TAIL(&po->po_logbuffers, po->po_curbuf, plb_next); 525 po->po_curbuf = NULL; 526 wakeup_one(po); 527 } 528 529 /* 530 * Stop the helper kthread. 531 */ 532 533 static void 534 pmclog_stop_kthread(struct pmc_owner *po) 535 { 536 /* 537 * Close the file to force the thread out of fo_write, 538 * unset flag, wakeup the helper thread, 539 * wait for it to exit 540 */ 541 542 if (po->po_file != NULL) 543 fo_close(po->po_file, curthread); 544 545 mtx_lock(&pmc_kthread_mtx); 546 po->po_flags &= ~PMC_PO_OWNS_LOGFILE; 547 wakeup_one(po); 548 if (po->po_kthread) 549 msleep(po->po_kthread, &pmc_kthread_mtx, PPAUSE, "pmckstp", 0); 550 mtx_unlock(&pmc_kthread_mtx); 551 } 552 553 /* 554 * Public functions 555 */ 556 557 /* 558 * Configure a log file for pmc owner 'po'. 559 * 560 * Parameter 'logfd' is a file handle referencing an open file in the 561 * owner process. This file needs to have been opened for writing. 562 */ 563 564 int 565 pmclog_configure_log(struct pmc_mdep *md, struct pmc_owner *po, int logfd) 566 { 567 int error; 568 struct proc *p; 569 570 /* 571 * As long as it is possible to get a LOR between pmc_sx lock and 572 * proctree/allproc sx locks used for adding a new process, assure 573 * the former is not held here. 574 */ 575 sx_assert(&pmc_sx, SA_UNLOCKED); 576 PMCDBG(LOG,CFG,1, "config po=%p logfd=%d", po, logfd); 577 578 p = po->po_owner; 579 580 /* return EBUSY if a log file was already present */ 581 if (po->po_flags & PMC_PO_OWNS_LOGFILE) 582 return (EBUSY); 583 584 KASSERT(po->po_kthread == NULL, 585 ("[pmclog,%d] po=%p kthread (%p) already present", __LINE__, po, 586 po->po_kthread)); 587 KASSERT(po->po_file == NULL, 588 ("[pmclog,%d] po=%p file (%p) already present", __LINE__, po, 589 po->po_file)); 590 591 /* get a reference to the file state */ 592 error = fget_write(curthread, logfd, CAP_WRITE, &po->po_file); 593 if (error) 594 goto error; 595 596 /* mark process as owning a log file */ 597 po->po_flags |= PMC_PO_OWNS_LOGFILE; 598 error = kproc_create(pmclog_loop, po, &po->po_kthread, 599 RFHIGHPID, 0, "hwpmc: proc(%d)", p->p_pid); 600 if (error) 601 goto error; 602 603 /* mark process as using HWPMCs */ 604 PROC_LOCK(p); 605 p->p_flag |= P_HWPMC; 606 PROC_UNLOCK(p); 607 608 /* create a log initialization entry */ 609 PMCLOG_RESERVE_WITH_ERROR(po, INITIALIZE, 610 sizeof(struct pmclog_initialize)); 611 PMCLOG_EMIT32(PMC_VERSION); 612 PMCLOG_EMIT32(md->pmd_cputype); 613 PMCLOG_DESPATCH(po); 614 615 return (0); 616 617 error: 618 /* shutdown the thread */ 619 if (po->po_kthread) 620 pmclog_stop_kthread(po); 621 622 KASSERT(po->po_kthread == NULL, ("[pmclog,%d] po=%p kthread not " 623 "stopped", __LINE__, po)); 624 625 if (po->po_file) 626 (void) fdrop(po->po_file, curthread); 627 po->po_file = NULL; /* clear file and error state */ 628 po->po_error = 0; 629 630 return (error); 631 } 632 633 634 /* 635 * De-configure a log file. This will throw away any buffers queued 636 * for this owner process. 637 */ 638 639 int 640 pmclog_deconfigure_log(struct pmc_owner *po) 641 { 642 int error; 643 struct pmclog_buffer *lb; 644 645 PMCDBG(LOG,CFG,1, "de-config po=%p", po); 646 647 if ((po->po_flags & PMC_PO_OWNS_LOGFILE) == 0) 648 return (EINVAL); 649 650 KASSERT(po->po_sscount == 0, 651 ("[pmclog,%d] po=%p still owning SS PMCs", __LINE__, po)); 652 KASSERT(po->po_file != NULL, 653 ("[pmclog,%d] po=%p no log file", __LINE__, po)); 654 655 /* stop the kthread, this will reset the 'OWNS_LOGFILE' flag */ 656 if (po->po_kthread) 657 pmclog_stop_kthread(po); 658 659 KASSERT(po->po_kthread == NULL, 660 ("[pmclog,%d] po=%p kthread not stopped", __LINE__, po)); 661 662 /* return all queued log buffers to the global pool */ 663 while ((lb = TAILQ_FIRST(&po->po_logbuffers)) != NULL) { 664 TAILQ_REMOVE(&po->po_logbuffers, lb, plb_next); 665 PMCLOG_INIT_BUFFER_DESCRIPTOR(lb); 666 mtx_lock_spin(&pmc_bufferlist_mtx); 667 TAILQ_INSERT_HEAD(&pmc_bufferlist, lb, plb_next); 668 mtx_unlock_spin(&pmc_bufferlist_mtx); 669 } 670 671 /* return the 'current' buffer to the global pool */ 672 if ((lb = po->po_curbuf) != NULL) { 673 PMCLOG_INIT_BUFFER_DESCRIPTOR(lb); 674 mtx_lock_spin(&pmc_bufferlist_mtx); 675 TAILQ_INSERT_HEAD(&pmc_bufferlist, lb, plb_next); 676 mtx_unlock_spin(&pmc_bufferlist_mtx); 677 } 678 679 /* drop a reference to the fd */ 680 error = fdrop(po->po_file, curthread); 681 po->po_file = NULL; 682 po->po_error = 0; 683 684 return (error); 685 } 686 687 /* 688 * Flush a process' log buffer. 689 */ 690 691 int 692 pmclog_flush(struct pmc_owner *po) 693 { 694 int error; 695 struct pmclog_buffer *lb; 696 697 PMCDBG(LOG,FLS,1, "po=%p", po); 698 699 /* 700 * If there is a pending error recorded by the logger thread, 701 * return that. 702 */ 703 if (po->po_error) 704 return (po->po_error); 705 706 error = 0; 707 708 /* 709 * Check that we do have an active log file. 710 */ 711 mtx_lock(&pmc_kthread_mtx); 712 if ((po->po_flags & PMC_PO_OWNS_LOGFILE) == 0) { 713 error = EINVAL; 714 goto error; 715 } 716 717 /* 718 * Schedule the current buffer if any and not empty. 719 */ 720 mtx_lock_spin(&po->po_mtx); 721 lb = po->po_curbuf; 722 if (lb && lb->plb_ptr != lb->plb_base) { 723 pmclog_schedule_io(po); 724 } else 725 error = ENOBUFS; 726 mtx_unlock_spin(&po->po_mtx); 727 728 error: 729 mtx_unlock(&pmc_kthread_mtx); 730 731 return (error); 732 } 733 734 int 735 pmclog_close(struct pmc_owner *po) 736 { 737 738 PMCDBG(LOG,CLO,1, "po=%p", po); 739 740 mtx_lock(&pmc_kthread_mtx); 741 742 /* 743 * Schedule the current buffer. 744 */ 745 mtx_lock_spin(&po->po_mtx); 746 if (po->po_curbuf) 747 pmclog_schedule_io(po); 748 else 749 wakeup_one(po); 750 mtx_unlock_spin(&po->po_mtx); 751 752 /* 753 * Initiate shutdown: no new data queued, 754 * thread will close file on last block. 755 */ 756 po->po_flags |= PMC_PO_SHUTDOWN; 757 758 mtx_unlock(&pmc_kthread_mtx); 759 760 return (0); 761 } 762 763 void 764 pmclog_process_callchain(struct pmc *pm, struct pmc_sample *ps) 765 { 766 int n, recordlen; 767 uint32_t flags; 768 struct pmc_owner *po; 769 770 PMCDBG(LOG,SAM,1,"pm=%p pid=%d n=%d", pm, ps->ps_pid, 771 ps->ps_nsamples); 772 773 recordlen = offsetof(struct pmclog_callchain, pl_pc) + 774 ps->ps_nsamples * sizeof(uintfptr_t); 775 po = pm->pm_owner; 776 flags = PMC_CALLCHAIN_TO_CPUFLAGS(ps->ps_cpu,ps->ps_flags); 777 PMCLOG_RESERVE(po, CALLCHAIN, recordlen); 778 PMCLOG_EMIT32(ps->ps_pid); 779 PMCLOG_EMIT32(pm->pm_id); 780 PMCLOG_EMIT32(flags); 781 for (n = 0; n < ps->ps_nsamples; n++) 782 PMCLOG_EMITADDR(ps->ps_pc[n]); 783 PMCLOG_DESPATCH(po); 784 } 785 786 void 787 pmclog_process_closelog(struct pmc_owner *po) 788 { 789 PMCLOG_RESERVE(po,CLOSELOG,sizeof(struct pmclog_closelog)); 790 PMCLOG_DESPATCH(po); 791 } 792 793 void 794 pmclog_process_dropnotify(struct pmc_owner *po) 795 { 796 PMCLOG_RESERVE(po,DROPNOTIFY,sizeof(struct pmclog_dropnotify)); 797 PMCLOG_DESPATCH(po); 798 } 799 800 void 801 pmclog_process_map_in(struct pmc_owner *po, pid_t pid, uintfptr_t start, 802 const char *path) 803 { 804 int pathlen, recordlen; 805 806 KASSERT(path != NULL, ("[pmclog,%d] map-in, null path", __LINE__)); 807 808 pathlen = strlen(path) + 1; /* #bytes for path name */ 809 recordlen = offsetof(struct pmclog_map_in, pl_pathname) + 810 pathlen; 811 812 PMCLOG_RESERVE(po, MAP_IN, recordlen); 813 PMCLOG_EMIT32(pid); 814 PMCLOG_EMITADDR(start); 815 PMCLOG_EMITSTRING(path,pathlen); 816 PMCLOG_DESPATCH(po); 817 } 818 819 void 820 pmclog_process_map_out(struct pmc_owner *po, pid_t pid, uintfptr_t start, 821 uintfptr_t end) 822 { 823 KASSERT(start <= end, ("[pmclog,%d] start > end", __LINE__)); 824 825 PMCLOG_RESERVE(po, MAP_OUT, sizeof(struct pmclog_map_out)); 826 PMCLOG_EMIT32(pid); 827 PMCLOG_EMITADDR(start); 828 PMCLOG_EMITADDR(end); 829 PMCLOG_DESPATCH(po); 830 } 831 832 void 833 pmclog_process_pmcallocate(struct pmc *pm) 834 { 835 struct pmc_owner *po; 836 837 po = pm->pm_owner; 838 839 PMCDBG(LOG,ALL,1, "pm=%p", pm); 840 841 PMCLOG_RESERVE(po, PMCALLOCATE, sizeof(struct pmclog_pmcallocate)); 842 PMCLOG_EMIT32(pm->pm_id); 843 PMCLOG_EMIT32(pm->pm_event); 844 PMCLOG_EMIT32(pm->pm_flags); 845 PMCLOG_DESPATCH(po); 846 } 847 848 void 849 pmclog_process_pmcattach(struct pmc *pm, pid_t pid, char *path) 850 { 851 int pathlen, recordlen; 852 struct pmc_owner *po; 853 854 PMCDBG(LOG,ATT,1,"pm=%p pid=%d", pm, pid); 855 856 po = pm->pm_owner; 857 858 pathlen = strlen(path) + 1; /* #bytes for the string */ 859 recordlen = offsetof(struct pmclog_pmcattach, pl_pathname) + pathlen; 860 861 PMCLOG_RESERVE(po, PMCATTACH, recordlen); 862 PMCLOG_EMIT32(pm->pm_id); 863 PMCLOG_EMIT32(pid); 864 PMCLOG_EMITSTRING(path, pathlen); 865 PMCLOG_DESPATCH(po); 866 } 867 868 void 869 pmclog_process_pmcdetach(struct pmc *pm, pid_t pid) 870 { 871 struct pmc_owner *po; 872 873 PMCDBG(LOG,ATT,1,"!pm=%p pid=%d", pm, pid); 874 875 po = pm->pm_owner; 876 877 PMCLOG_RESERVE(po, PMCDETACH, sizeof(struct pmclog_pmcdetach)); 878 PMCLOG_EMIT32(pm->pm_id); 879 PMCLOG_EMIT32(pid); 880 PMCLOG_DESPATCH(po); 881 } 882 883 /* 884 * Log a context switch event to the log file. 885 */ 886 887 void 888 pmclog_process_proccsw(struct pmc *pm, struct pmc_process *pp, pmc_value_t v) 889 { 890 struct pmc_owner *po; 891 892 KASSERT(pm->pm_flags & PMC_F_LOG_PROCCSW, 893 ("[pmclog,%d] log-process-csw called gratuitously", __LINE__)); 894 895 PMCDBG(LOG,SWO,1,"pm=%p pid=%d v=%jx", pm, pp->pp_proc->p_pid, 896 v); 897 898 po = pm->pm_owner; 899 900 PMCLOG_RESERVE(po, PROCCSW, sizeof(struct pmclog_proccsw)); 901 PMCLOG_EMIT32(pm->pm_id); 902 PMCLOG_EMIT64(v); 903 PMCLOG_EMIT32(pp->pp_proc->p_pid); 904 PMCLOG_DESPATCH(po); 905 } 906 907 void 908 pmclog_process_procexec(struct pmc_owner *po, pmc_id_t pmid, pid_t pid, 909 uintfptr_t startaddr, char *path) 910 { 911 int pathlen, recordlen; 912 913 PMCDBG(LOG,EXC,1,"po=%p pid=%d path=\"%s\"", po, pid, path); 914 915 pathlen = strlen(path) + 1; /* #bytes for the path */ 916 recordlen = offsetof(struct pmclog_procexec, pl_pathname) + pathlen; 917 918 PMCLOG_RESERVE(po, PROCEXEC, recordlen); 919 PMCLOG_EMIT32(pid); 920 PMCLOG_EMITADDR(startaddr); 921 PMCLOG_EMIT32(pmid); 922 PMCLOG_EMITSTRING(path,pathlen); 923 PMCLOG_DESPATCH(po); 924 } 925 926 /* 927 * Log a process exit event (and accumulated pmc value) to the log file. 928 */ 929 930 void 931 pmclog_process_procexit(struct pmc *pm, struct pmc_process *pp) 932 { 933 int ri; 934 struct pmc_owner *po; 935 936 ri = PMC_TO_ROWINDEX(pm); 937 PMCDBG(LOG,EXT,1,"pm=%p pid=%d v=%jx", pm, pp->pp_proc->p_pid, 938 pp->pp_pmcs[ri].pp_pmcval); 939 940 po = pm->pm_owner; 941 942 PMCLOG_RESERVE(po, PROCEXIT, sizeof(struct pmclog_procexit)); 943 PMCLOG_EMIT32(pm->pm_id); 944 PMCLOG_EMIT64(pp->pp_pmcs[ri].pp_pmcval); 945 PMCLOG_EMIT32(pp->pp_proc->p_pid); 946 PMCLOG_DESPATCH(po); 947 } 948 949 /* 950 * Log a fork event. 951 */ 952 953 void 954 pmclog_process_procfork(struct pmc_owner *po, pid_t oldpid, pid_t newpid) 955 { 956 PMCLOG_RESERVE(po, PROCFORK, sizeof(struct pmclog_procfork)); 957 PMCLOG_EMIT32(oldpid); 958 PMCLOG_EMIT32(newpid); 959 PMCLOG_DESPATCH(po); 960 } 961 962 /* 963 * Log a process exit event of the form suitable for system-wide PMCs. 964 */ 965 966 void 967 pmclog_process_sysexit(struct pmc_owner *po, pid_t pid) 968 { 969 PMCLOG_RESERVE(po, SYSEXIT, sizeof(struct pmclog_sysexit)); 970 PMCLOG_EMIT32(pid); 971 PMCLOG_DESPATCH(po); 972 } 973 974 /* 975 * Write a user log entry. 976 */ 977 978 int 979 pmclog_process_userlog(struct pmc_owner *po, struct pmc_op_writelog *wl) 980 { 981 int error; 982 983 PMCDBG(LOG,WRI,1, "writelog po=%p ud=0x%x", po, wl->pm_userdata); 984 985 error = 0; 986 987 PMCLOG_RESERVE_WITH_ERROR(po, USERDATA, 988 sizeof(struct pmclog_userdata)); 989 PMCLOG_EMIT32(wl->pm_userdata); 990 PMCLOG_DESPATCH(po); 991 992 error: 993 return (error); 994 } 995 996 /* 997 * Initialization. 998 * 999 * Create a pool of log buffers and initialize mutexes. 1000 */ 1001 1002 void 1003 pmclog_initialize() 1004 { 1005 int n; 1006 struct pmclog_buffer *plb; 1007 1008 if (pmclog_buffer_size <= 0) { 1009 (void) printf("hwpmc: tunable logbuffersize=%d must be " 1010 "greater than zero.\n", pmclog_buffer_size); 1011 pmclog_buffer_size = PMC_LOG_BUFFER_SIZE; 1012 } 1013 1014 if (pmc_nlogbuffers <= 0) { 1015 (void) printf("hwpmc: tunable nlogbuffers=%d must be greater " 1016 "than zero.\n", pmc_nlogbuffers); 1017 pmc_nlogbuffers = PMC_NLOGBUFFERS; 1018 } 1019 1020 /* create global pool of log buffers */ 1021 for (n = 0; n < pmc_nlogbuffers; n++) { 1022 plb = malloc(1024 * pmclog_buffer_size, M_PMC, 1023 M_WAITOK|M_ZERO); 1024 PMCLOG_INIT_BUFFER_DESCRIPTOR(plb); 1025 TAILQ_INSERT_HEAD(&pmc_bufferlist, plb, plb_next); 1026 } 1027 mtx_init(&pmc_bufferlist_mtx, "pmc-buffer-list", "pmc-leaf", 1028 MTX_SPIN); 1029 mtx_init(&pmc_kthread_mtx, "pmc-kthread", "pmc-sleep", MTX_DEF); 1030 } 1031 1032 /* 1033 * Shutdown logging. 1034 * 1035 * Destroy mutexes and release memory back the to free pool. 1036 */ 1037 1038 void 1039 pmclog_shutdown() 1040 { 1041 struct pmclog_buffer *plb; 1042 1043 mtx_destroy(&pmc_kthread_mtx); 1044 mtx_destroy(&pmc_bufferlist_mtx); 1045 1046 while ((plb = TAILQ_FIRST(&pmc_bufferlist)) != NULL) { 1047 TAILQ_REMOVE(&pmc_bufferlist, plb, plb_next); 1048 free(plb, M_PMC); 1049 } 1050 } 1051