1 /* 2 * Copyright 2009-2011, Ingo Weinhold, ingo_weinhold@gmx.de. 3 * Distributed under the terms of the MIT License. 4 */ 5 6 7 #include <system_profiler.h> 8 9 #include <AutoDeleter.h> 10 #include <Referenceable.h> 11 12 #include <util/AutoLock.h> 13 14 #include <system_profiler_defs.h> 15 16 #include <cpu.h> 17 #include <kernel.h> 18 #include <kimage.h> 19 #include <kscheduler.h> 20 #include <listeners.h> 21 #include <Notifications.h> 22 #include <sem.h> 23 #include <team.h> 24 #include <thread.h> 25 #include <user_debugger.h> 26 #include <vm/vm.h> 27 28 #include <arch/debug.h> 29 30 #include "IOSchedulerRoster.h" 31 32 33 // This is the kernel-side implementation of the system profiling support. 34 // A userland team can register as system profiler, providing an area as buffer 35 // for events. Those events are team, thread, and image changes (added/removed), 36 // periodic sampling of the return address stack for each CPU, as well as 37 // scheduling and I/O scheduling events. 38 39 40 class SystemProfiler; 41 42 43 // minimum/maximum size of the table used for wait object caching 44 #define MIN_WAIT_OBJECT_COUNT 128 45 #define MAX_WAIT_OBJECT_COUNT 1024 46 47 48 static spinlock sProfilerLock = B_SPINLOCK_INITIALIZER; 49 static SystemProfiler* sProfiler = NULL; 50 static struct system_profiler_parameters* sRecordedParameters = NULL; 51 52 53 class SystemProfiler : public BReferenceable, private NotificationListener, 54 private SchedulerListener, private WaitObjectListener { 55 public: 56 SystemProfiler(team_id team, 57 const area_info& userAreaInfo, 58 const system_profiler_parameters& 59 parameters); 60 ~SystemProfiler(); 61 62 team_id TeamID() const { return fTeam; } 63 64 status_t Init(); 65 status_t NextBuffer(size_t bytesRead, 66 uint64* _droppedEvents); 67 68 private: 69 virtual void EventOccurred(NotificationService& service, 70 const KMessage* event); 71 72 virtual void ThreadEnqueuedInRunQueue(Thread* thread); 73 virtual void ThreadRemovedFromRunQueue(Thread* thread); 74 virtual void ThreadScheduled(Thread* oldThread, 75 Thread* newThread); 76 77 virtual void SemaphoreCreated(sem_id id, 78 const char* name); 79 virtual void ConditionVariableInitialized( 80 ConditionVariable* variable); 81 virtual void MutexInitialized(mutex* lock); 82 virtual void RWLockInitialized(rw_lock* lock); 83 84 bool _TeamAdded(Team* team); 85 bool _TeamRemoved(Team* team); 86 bool _TeamExec(Team* team); 87 88 bool _ThreadAdded(Thread* thread); 89 bool _ThreadRemoved(Thread* thread); 90 91 bool _ImageAdded(struct image* image); 92 bool _ImageRemoved(struct image* image); 93 94 bool _IOSchedulerAdded(IOScheduler* scheduler); 95 bool _IOSchedulerRemoved(IOScheduler* scheduler); 96 bool _IORequestScheduled(IOScheduler* scheduler, 97 IORequest* request); 98 bool _IORequestFinished(IOScheduler* scheduler, 99 IORequest* request); 100 bool _IOOperationStarted(IOScheduler* scheduler, 101 IORequest* request, IOOperation* operation); 102 bool _IOOperationFinished(IOScheduler* scheduler, 103 IORequest* request, IOOperation* operation); 104 105 void _WaitObjectCreated(addr_t object, uint32 type); 106 void _WaitObjectUsed(addr_t object, uint32 type); 107 108 inline void _MaybeNotifyProfilerThreadLocked(); 109 inline void _MaybeNotifyProfilerThread(); 110 111 static bool _InitialImageIterator(struct image* image, 112 void* cookie); 113 114 void* _AllocateBuffer(size_t size, int event, int cpu, 115 int count); 116 117 static void _InitTimers(void* cookie, int cpu); 118 static void _UninitTimers(void* cookie, int cpu); 119 void _ScheduleTimer(int cpu); 120 121 void _DoSample(); 122 123 static int32 _ProfilingEvent(struct timer* timer); 124 125 private: 126 struct CPUProfileData { 127 struct timer timer; 128 bigtime_t timerEnd; 129 bool timerScheduled; 130 addr_t buffer[B_DEBUG_STACK_TRACE_DEPTH]; 131 }; 132 133 struct WaitObjectKey { 134 addr_t object; 135 uint32 type; 136 }; 137 138 struct WaitObject : DoublyLinkedListLinkImpl<WaitObject>, 139 WaitObjectKey { 140 struct WaitObject* hash_link; 141 }; 142 143 struct WaitObjectTableDefinition { 144 typedef WaitObjectKey KeyType; 145 typedef WaitObject ValueType; 146 147 size_t HashKey(const WaitObjectKey& key) const 148 { 149 return (size_t)key.object ^ (size_t)key.type; 150 } 151 152 size_t Hash(const WaitObject* value) const 153 { 154 return HashKey(*value); 155 } 156 157 bool Compare(const WaitObjectKey& key, 158 const WaitObject* value) const 159 { 160 return value->type == key.type 161 && value->object == key.object; 162 } 163 164 WaitObject*& GetLink(WaitObject* value) const 165 { 166 return value->hash_link; 167 } 168 }; 169 170 typedef DoublyLinkedList<WaitObject> WaitObjectList; 171 typedef BOpenHashTable<WaitObjectTableDefinition> WaitObjectTable; 172 173 private: 174 spinlock fLock; 175 team_id fTeam; 176 area_id fUserArea; 177 area_id fKernelArea; 178 size_t fAreaSize; 179 uint32 fFlags; 180 uint32 fStackDepth; 181 bigtime_t fInterval; 182 system_profiler_buffer_header* fHeader; 183 uint8* fBufferBase; 184 size_t fBufferCapacity; 185 size_t fBufferStart; 186 size_t fBufferSize; 187 uint64 fDroppedEvents; 188 int64 fLastTeamAddedSerialNumber; 189 int64 fLastThreadAddedSerialNumber; 190 bool fTeamNotificationsRequested; 191 bool fTeamNotificationsEnabled; 192 bool fThreadNotificationsRequested; 193 bool fThreadNotificationsEnabled; 194 bool fImageNotificationsRequested; 195 bool fImageNotificationsEnabled; 196 bool fIONotificationsRequested; 197 bool fIONotificationsEnabled; 198 bool fSchedulerNotificationsRequested; 199 bool fWaitObjectNotificationsRequested; 200 Thread* volatile fWaitingProfilerThread; 201 bool fProfilingActive; 202 bool fReentered[SMP_MAX_CPUS]; 203 CPUProfileData fCPUData[SMP_MAX_CPUS]; 204 WaitObject* fWaitObjectBuffer; 205 int32 fWaitObjectCount; 206 WaitObjectList fUsedWaitObjects; 207 WaitObjectList fFreeWaitObjects; 208 WaitObjectTable fWaitObjectTable; 209 }; 210 211 212 /*! Notifies the profiler thread when the profiling buffer is full enough. 213 The caller must hold fLock. 214 */ 215 inline void 216 SystemProfiler::_MaybeNotifyProfilerThreadLocked() 217 { 218 // If the buffer is full enough, notify the profiler. 219 if (fWaitingProfilerThread != NULL && fBufferSize > fBufferCapacity / 2) { 220 int cpu = smp_get_current_cpu(); 221 fReentered[cpu] = true; 222 223 Thread* profilerThread = fWaitingProfilerThread; 224 fWaitingProfilerThread = NULL; 225 226 SpinLocker _(profilerThread->scheduler_lock); 227 thread_unblock_locked(profilerThread, B_OK); 228 229 fReentered[cpu] = false; 230 } 231 } 232 233 234 inline void 235 SystemProfiler::_MaybeNotifyProfilerThread() 236 { 237 if (fWaitingProfilerThread == NULL) 238 return; 239 240 InterruptsSpinLocker locker(fLock); 241 242 _MaybeNotifyProfilerThreadLocked(); 243 } 244 245 246 // #pragma mark - SystemProfiler public 247 248 249 SystemProfiler::SystemProfiler(team_id team, const area_info& userAreaInfo, 250 const system_profiler_parameters& parameters) 251 : 252 fTeam(team), 253 fUserArea(userAreaInfo.area), 254 fKernelArea(-1), 255 fAreaSize(userAreaInfo.size), 256 fFlags(parameters.flags), 257 fStackDepth(parameters.stack_depth), 258 fInterval(parameters.interval), 259 fHeader(NULL), 260 fBufferBase(NULL), 261 fBufferCapacity(0), 262 fBufferStart(0), 263 fBufferSize(0), 264 fDroppedEvents(0), 265 fLastTeamAddedSerialNumber(0), 266 fLastThreadAddedSerialNumber(0), 267 fTeamNotificationsRequested(false), 268 fTeamNotificationsEnabled(false), 269 fThreadNotificationsRequested(false), 270 fThreadNotificationsEnabled(false), 271 fImageNotificationsRequested(false), 272 fImageNotificationsEnabled(false), 273 fIONotificationsRequested(false), 274 fIONotificationsEnabled(false), 275 fSchedulerNotificationsRequested(false), 276 fWaitObjectNotificationsRequested(false), 277 fWaitingProfilerThread(NULL), 278 fWaitObjectBuffer(NULL), 279 fWaitObjectCount(0), 280 fUsedWaitObjects(), 281 fFreeWaitObjects(), 282 fWaitObjectTable() 283 { 284 B_INITIALIZE_SPINLOCK(&fLock); 285 286 memset(fReentered, 0, sizeof(fReentered)); 287 288 // compute the number wait objects we want to cache 289 if ((fFlags & B_SYSTEM_PROFILER_SCHEDULING_EVENTS) != 0) { 290 fWaitObjectCount = parameters.locking_lookup_size 291 / (sizeof(WaitObject) + (sizeof(void*) * 3 / 2)); 292 if (fWaitObjectCount < MIN_WAIT_OBJECT_COUNT) 293 fWaitObjectCount = MIN_WAIT_OBJECT_COUNT; 294 if (fWaitObjectCount > MAX_WAIT_OBJECT_COUNT) 295 fWaitObjectCount = MAX_WAIT_OBJECT_COUNT; 296 } 297 } 298 299 300 SystemProfiler::~SystemProfiler() 301 { 302 // Wake up the user thread, if it is waiting, and mark profiling 303 // inactive. 304 InterruptsSpinLocker locker(fLock); 305 if (fWaitingProfilerThread != NULL) { 306 thread_unblock(fWaitingProfilerThread, B_OK); 307 fWaitingProfilerThread = NULL; 308 } 309 fProfilingActive = false; 310 locker.Unlock(); 311 312 // stop scheduler listening 313 if (fSchedulerNotificationsRequested) 314 scheduler_remove_listener(this); 315 316 // stop wait object listening 317 if (fWaitObjectNotificationsRequested) { 318 InterruptsSpinLocker locker(gWaitObjectListenerLock); 319 remove_wait_object_listener(this); 320 } 321 322 // deactivate the profiling timers on all CPUs 323 if ((fFlags & B_SYSTEM_PROFILER_SAMPLING_EVENTS) != 0) 324 call_all_cpus(_UninitTimers, this); 325 326 // cancel notifications 327 NotificationManager& notificationManager 328 = NotificationManager::Manager(); 329 330 // images 331 if (fImageNotificationsRequested) { 332 fImageNotificationsRequested = false; 333 notificationManager.RemoveListener("images", NULL, *this); 334 } 335 336 // threads 337 if (fThreadNotificationsRequested) { 338 fThreadNotificationsRequested = false; 339 notificationManager.RemoveListener("threads", NULL, *this); 340 } 341 342 // teams 343 if (fTeamNotificationsRequested) { 344 fTeamNotificationsRequested = false; 345 notificationManager.RemoveListener("teams", NULL, *this); 346 } 347 348 // I/O 349 if (fIONotificationsRequested) { 350 fIONotificationsRequested = false; 351 notificationManager.RemoveListener("I/O", NULL, *this); 352 } 353 354 // delete wait object related allocations 355 fWaitObjectTable.Clear(); 356 delete[] fWaitObjectBuffer; 357 358 // unlock the memory and delete the area 359 if (fKernelArea >= 0) { 360 unlock_memory(fHeader, fAreaSize, B_READ_DEVICE); 361 delete_area(fKernelArea); 362 fKernelArea = -1; 363 } 364 } 365 366 367 status_t 368 SystemProfiler::Init() 369 { 370 // clone the user area 371 void* areaBase; 372 fKernelArea = clone_area("profiling samples", &areaBase, 373 B_ANY_KERNEL_ADDRESS, B_READ_AREA | B_WRITE_AREA, 374 fUserArea); 375 if (fKernelArea < 0) 376 return fKernelArea; 377 378 // we need the memory locked 379 status_t error = lock_memory(areaBase, fAreaSize, B_READ_DEVICE); 380 if (error != B_OK) { 381 delete_area(fKernelArea); 382 fKernelArea = -1; 383 return error; 384 } 385 386 // the buffer is ready for use 387 fHeader = (system_profiler_buffer_header*)areaBase; 388 fBufferBase = (uint8*)(fHeader + 1); 389 fBufferCapacity = fAreaSize - (fBufferBase - (uint8*)areaBase); 390 fHeader->start = 0; 391 fHeader->size = 0; 392 393 // allocate the wait object buffer and init the hash table 394 if (fWaitObjectCount > 0) { 395 fWaitObjectBuffer = new(std::nothrow) WaitObject[fWaitObjectCount]; 396 if (fWaitObjectBuffer == NULL) 397 return B_NO_MEMORY; 398 399 for (int32 i = 0; i < fWaitObjectCount; i++) 400 fFreeWaitObjects.Add(fWaitObjectBuffer + i); 401 402 error = fWaitObjectTable.Init(fWaitObjectCount * 3 / 2); 403 if (error != B_OK) 404 return error; 405 } 406 407 // start listening for notifications 408 409 // teams 410 NotificationManager& notificationManager 411 = NotificationManager::Manager(); 412 if ((fFlags & B_SYSTEM_PROFILER_TEAM_EVENTS) != 0) { 413 error = notificationManager.AddListener("teams", 414 TEAM_ADDED | TEAM_REMOVED | TEAM_EXEC, *this); 415 if (error != B_OK) 416 return error; 417 fTeamNotificationsRequested = true; 418 } 419 420 // threads 421 if ((fFlags & B_SYSTEM_PROFILER_THREAD_EVENTS) != 0) { 422 error = notificationManager.AddListener("threads", 423 THREAD_ADDED | THREAD_REMOVED, *this); 424 if (error != B_OK) 425 return error; 426 fThreadNotificationsRequested = true; 427 } 428 429 // images 430 if ((fFlags & B_SYSTEM_PROFILER_IMAGE_EVENTS) != 0) { 431 error = notificationManager.AddListener("images", 432 IMAGE_ADDED | IMAGE_REMOVED, *this); 433 if (error != B_OK) 434 return error; 435 fImageNotificationsRequested = true; 436 } 437 438 // I/O events 439 if ((fFlags & B_SYSTEM_PROFILER_IO_SCHEDULING_EVENTS) != 0) { 440 error = notificationManager.AddListener("I/O", 441 IO_SCHEDULER_ADDED | IO_SCHEDULER_REMOVED 442 | IO_SCHEDULER_REQUEST_SCHEDULED | IO_SCHEDULER_REQUEST_FINISHED 443 | IO_SCHEDULER_OPERATION_STARTED 444 | IO_SCHEDULER_OPERATION_FINISHED, 445 *this); 446 if (error != B_OK) 447 return error; 448 fIONotificationsRequested = true; 449 } 450 451 // We need to fill the buffer with the initial state of teams, threads, 452 // and images. 453 454 // teams 455 if ((fFlags & B_SYSTEM_PROFILER_TEAM_EVENTS) != 0) { 456 InterruptsSpinLocker locker(fLock); 457 458 TeamListIterator iterator; 459 while (Team* team = iterator.Next()) { 460 locker.Unlock(); 461 462 bool added = _TeamAdded(team); 463 464 // release the reference returned by the iterator 465 team->ReleaseReference(); 466 467 if (!added) 468 return B_BUFFER_OVERFLOW; 469 470 locker.Lock(); 471 } 472 473 fTeamNotificationsEnabled = true; 474 } 475 476 // images 477 if ((fFlags & B_SYSTEM_PROFILER_IMAGE_EVENTS) != 0) { 478 if (image_iterate_through_images(&_InitialImageIterator, this) != NULL) 479 return B_BUFFER_OVERFLOW; 480 } 481 482 // threads 483 if ((fFlags & B_SYSTEM_PROFILER_THREAD_EVENTS) != 0) { 484 InterruptsSpinLocker locker(fLock); 485 486 ThreadListIterator iterator; 487 while (Thread* thread = iterator.Next()) { 488 locker.Unlock(); 489 490 bool added = _ThreadAdded(thread); 491 492 // release the reference returned by the iterator 493 thread->ReleaseReference(); 494 495 if (!added) 496 return B_BUFFER_OVERFLOW; 497 498 locker.Lock(); 499 } 500 501 fThreadNotificationsEnabled = true; 502 } 503 504 fProfilingActive = true; 505 506 // start scheduler and wait object listening 507 if ((fFlags & B_SYSTEM_PROFILER_SCHEDULING_EVENTS) != 0) { 508 scheduler_add_listener(this); 509 fSchedulerNotificationsRequested = true; 510 511 InterruptsSpinLocker waitObjectLocker(gWaitObjectListenerLock); 512 add_wait_object_listener(this); 513 fWaitObjectNotificationsRequested = true; 514 waitObjectLocker.Unlock(); 515 516 // fake schedule events for the initially running threads 517 int32 cpuCount = smp_get_num_cpus(); 518 for (int32 i = 0; i < cpuCount; i++) { 519 Thread* thread = gCPU[i].running_thread; 520 if (thread != NULL) 521 ThreadScheduled(thread, thread); 522 } 523 } 524 525 // I/O scheduling 526 if ((fFlags & B_SYSTEM_PROFILER_IO_SCHEDULING_EVENTS) != 0) { 527 IOSchedulerRoster* roster = IOSchedulerRoster::Default(); 528 AutoLocker<IOSchedulerRoster> rosterLocker(roster); 529 530 for (IOSchedulerList::ConstIterator it 531 = roster->SchedulerList().GetIterator(); 532 IOScheduler* scheduler = it.Next();) { 533 _IOSchedulerAdded(scheduler); 534 } 535 536 fIONotificationsEnabled = true; 537 } 538 539 // activate the profiling timers on all CPUs 540 if ((fFlags & B_SYSTEM_PROFILER_SAMPLING_EVENTS) != 0) 541 call_all_cpus(_InitTimers, this); 542 543 return B_OK; 544 } 545 546 547 status_t 548 SystemProfiler::NextBuffer(size_t bytesRead, uint64* _droppedEvents) 549 { 550 InterruptsSpinLocker locker(fLock); 551 552 if (fWaitingProfilerThread != NULL || !fProfilingActive 553 || bytesRead > fBufferSize) { 554 return B_BAD_VALUE; 555 } 556 557 fBufferSize -= bytesRead; 558 fBufferStart += bytesRead; 559 if (fBufferStart > fBufferCapacity) 560 fBufferStart -= fBufferCapacity; 561 fHeader->size = fBufferSize; 562 fHeader->start = fBufferStart; 563 564 // already enough data in the buffer to return? 565 if (fBufferSize > fBufferCapacity / 2) 566 return B_OK; 567 568 // Wait until the buffer gets too full or an error or a timeout occurs. 569 while (true) { 570 Thread* thread = thread_get_current_thread(); 571 fWaitingProfilerThread = thread; 572 573 thread_prepare_to_block(thread, B_CAN_INTERRUPT, 574 THREAD_BLOCK_TYPE_OTHER, "system profiler buffer"); 575 576 locker.Unlock(); 577 578 status_t error = thread_block_with_timeout(B_RELATIVE_TIMEOUT, 1000000); 579 580 locker.Lock(); 581 582 if (error == B_OK) { 583 // the caller has unset fWaitingProfilerThread for us 584 break; 585 } 586 587 fWaitingProfilerThread = NULL; 588 589 if (error != B_TIMED_OUT) 590 return error; 591 592 // just the timeout -- return, if the buffer is not empty 593 if (fBufferSize > 0) 594 break; 595 } 596 597 if (_droppedEvents != NULL) { 598 *_droppedEvents = fDroppedEvents; 599 fDroppedEvents = 0; 600 } 601 602 return B_OK; 603 } 604 605 606 // #pragma mark - NotificationListener interface 607 608 609 void 610 SystemProfiler::EventOccurred(NotificationService& service, 611 const KMessage* event) 612 { 613 int32 eventCode; 614 if (event->FindInt32("event", &eventCode) != B_OK) 615 return; 616 617 if (strcmp(service.Name(), "teams") == 0) { 618 Team* team = (Team*)event->GetPointer("teamStruct", NULL); 619 if (team == NULL) 620 return; 621 622 switch (eventCode) { 623 case TEAM_ADDED: 624 if (fTeamNotificationsEnabled) 625 _TeamAdded(team); 626 break; 627 628 case TEAM_REMOVED: 629 if (team->id == fTeam) { 630 // The profiling team is gone -- uninstall the profiler! 631 InterruptsSpinLocker locker(sProfilerLock); 632 if (sProfiler != this) 633 return; 634 635 sProfiler = NULL; 636 locker.Unlock(); 637 638 ReleaseReference(); 639 return; 640 } 641 642 // When we're still doing the initial team list scan, we are 643 // also interested in removals that happened to teams we have 644 // already seen. 645 if (fTeamNotificationsEnabled 646 || team->serial_number <= fLastTeamAddedSerialNumber) { 647 _TeamRemoved(team); 648 } 649 break; 650 651 case TEAM_EXEC: 652 if (fTeamNotificationsEnabled) 653 _TeamExec(team); 654 break; 655 } 656 } else if (strcmp(service.Name(), "threads") == 0) { 657 Thread* thread = (Thread*)event->GetPointer("threadStruct", NULL); 658 if (thread == NULL) 659 return; 660 661 switch (eventCode) { 662 case THREAD_ADDED: 663 if (fThreadNotificationsEnabled) 664 _ThreadAdded(thread); 665 break; 666 667 case THREAD_REMOVED: 668 // When we're still doing the initial thread list scan, we are 669 // also interested in removals that happened to threads we have 670 // already seen. 671 if (fThreadNotificationsEnabled 672 || thread->serial_number <= fLastThreadAddedSerialNumber) { 673 _ThreadRemoved(thread); 674 } 675 break; 676 } 677 } else if (strcmp(service.Name(), "images") == 0) { 678 if (!fImageNotificationsEnabled) 679 return; 680 681 struct image* image = (struct image*)event->GetPointer( 682 "imageStruct", NULL); 683 if (image == NULL) 684 return; 685 686 switch (eventCode) { 687 case IMAGE_ADDED: 688 _ImageAdded(image); 689 break; 690 691 case IMAGE_REMOVED: 692 _ImageRemoved(image); 693 break; 694 } 695 } else if (strcmp(service.Name(), "I/O") == 0) { 696 if (!fIONotificationsEnabled) 697 return; 698 699 IOScheduler* scheduler = (IOScheduler*)event->GetPointer("scheduler", 700 NULL); 701 if (scheduler == NULL) 702 return; 703 704 IORequest* request = (IORequest*)event->GetPointer("request", NULL); 705 IOOperation* operation = (IOOperation*)event->GetPointer("operation", 706 NULL); 707 708 switch (eventCode) { 709 case IO_SCHEDULER_ADDED: 710 _IOSchedulerAdded(scheduler); 711 break; 712 713 case IO_SCHEDULER_REMOVED: 714 _IOSchedulerRemoved(scheduler); 715 break; 716 717 case IO_SCHEDULER_REQUEST_SCHEDULED: 718 _IORequestScheduled(scheduler, request); 719 break; 720 721 case IO_SCHEDULER_REQUEST_FINISHED: 722 _IORequestFinished(scheduler, request); 723 break; 724 725 case IO_SCHEDULER_OPERATION_STARTED: 726 _IOOperationStarted(scheduler, request, operation); 727 break; 728 729 case IO_SCHEDULER_OPERATION_FINISHED: 730 _IOOperationFinished(scheduler, request, operation); 731 break; 732 } 733 } 734 735 _MaybeNotifyProfilerThread(); 736 } 737 738 739 // #pragma mark - SchedulerListener interface 740 741 742 void 743 SystemProfiler::ThreadEnqueuedInRunQueue(Thread* thread) 744 { 745 int cpu = smp_get_current_cpu(); 746 747 InterruptsSpinLocker locker(fLock, false, !fReentered[cpu]); 748 // When re-entering, we already hold the lock. 749 750 system_profiler_thread_enqueued_in_run_queue* event 751 = (system_profiler_thread_enqueued_in_run_queue*) 752 _AllocateBuffer( 753 sizeof(system_profiler_thread_enqueued_in_run_queue), 754 B_SYSTEM_PROFILER_THREAD_ENQUEUED_IN_RUN_QUEUE, cpu, 0); 755 if (event == NULL) 756 return; 757 758 event->time = system_time_nsecs(); 759 event->thread = thread->id; 760 event->priority = thread->priority; 761 762 fHeader->size = fBufferSize; 763 764 // Unblock the profiler thread, if necessary, but don't unblock the thread, 765 // if it had been waiting on a condition variable, since then we'd likely 766 // deadlock in ConditionVariable::NotifyOne(), as it acquires a static 767 // spinlock. 768 if (thread->wait.type != THREAD_BLOCK_TYPE_CONDITION_VARIABLE) 769 _MaybeNotifyProfilerThreadLocked(); 770 } 771 772 773 void 774 SystemProfiler::ThreadRemovedFromRunQueue(Thread* thread) 775 { 776 int cpu = smp_get_current_cpu(); 777 778 InterruptsSpinLocker locker(fLock, false, !fReentered[cpu]); 779 // When re-entering, we already hold the lock. 780 781 system_profiler_thread_removed_from_run_queue* event 782 = (system_profiler_thread_removed_from_run_queue*) 783 _AllocateBuffer( 784 sizeof(system_profiler_thread_removed_from_run_queue), 785 B_SYSTEM_PROFILER_THREAD_REMOVED_FROM_RUN_QUEUE, cpu, 0); 786 if (event == NULL) 787 return; 788 789 event->time = system_time_nsecs(); 790 event->thread = thread->id; 791 792 fHeader->size = fBufferSize; 793 794 // unblock the profiler thread, if necessary 795 _MaybeNotifyProfilerThreadLocked(); 796 } 797 798 799 void 800 SystemProfiler::ThreadScheduled(Thread* oldThread, Thread* newThread) 801 { 802 int cpu = smp_get_current_cpu(); 803 804 InterruptsSpinLocker locker(fLock, false, !fReentered[cpu]); 805 // When re-entering, we already hold the lock. 806 807 // If the old thread starts waiting, handle the wait object. 808 if (oldThread->state == B_THREAD_WAITING) 809 _WaitObjectUsed((addr_t)oldThread->wait.object, oldThread->wait.type); 810 811 system_profiler_thread_scheduled* event 812 = (system_profiler_thread_scheduled*) 813 _AllocateBuffer(sizeof(system_profiler_thread_scheduled), 814 B_SYSTEM_PROFILER_THREAD_SCHEDULED, cpu, 0); 815 if (event == NULL) 816 return; 817 818 event->time = system_time_nsecs(); 819 event->thread = newThread->id; 820 event->previous_thread = oldThread->id; 821 event->previous_thread_state = oldThread->state; 822 event->previous_thread_wait_object_type = oldThread->wait.type; 823 event->previous_thread_wait_object = (addr_t)oldThread->wait.object; 824 825 fHeader->size = fBufferSize; 826 827 // unblock the profiler thread, if necessary 828 _MaybeNotifyProfilerThreadLocked(); 829 } 830 831 832 // #pragma mark - WaitObjectListener interface 833 834 835 void 836 SystemProfiler::SemaphoreCreated(sem_id id, const char* name) 837 { 838 _WaitObjectCreated((addr_t)id, THREAD_BLOCK_TYPE_SEMAPHORE); 839 } 840 841 842 void 843 SystemProfiler::ConditionVariableInitialized(ConditionVariable* variable) 844 { 845 _WaitObjectCreated((addr_t)variable, THREAD_BLOCK_TYPE_CONDITION_VARIABLE); 846 } 847 848 849 void 850 SystemProfiler::MutexInitialized(mutex* lock) 851 { 852 _WaitObjectCreated((addr_t)lock, THREAD_BLOCK_TYPE_MUTEX); 853 } 854 855 856 void 857 SystemProfiler::RWLockInitialized(rw_lock* lock) 858 { 859 _WaitObjectCreated((addr_t)lock, THREAD_BLOCK_TYPE_RW_LOCK); 860 } 861 862 863 // #pragma mark - SystemProfiler private 864 865 866 bool 867 SystemProfiler::_TeamAdded(Team* team) 868 { 869 TeamLocker teamLocker(team); 870 871 size_t nameLen = strlen(team->Name()); 872 size_t argsLen = strlen(team->Args()); 873 874 InterruptsSpinLocker locker(fLock); 875 876 // During the initial scan check whether the team is already gone again. 877 // Later this cannot happen, since the team creator notifies us before 878 // actually starting the team. 879 if (!fTeamNotificationsEnabled && team->state >= TEAM_STATE_DEATH) 880 return true; 881 882 if (team->serial_number > fLastTeamAddedSerialNumber) 883 fLastTeamAddedSerialNumber = team->serial_number; 884 885 system_profiler_team_added* event = (system_profiler_team_added*) 886 _AllocateBuffer( 887 sizeof(system_profiler_team_added) + nameLen + 1 + argsLen, 888 B_SYSTEM_PROFILER_TEAM_ADDED, 0, 0); 889 if (event == NULL) 890 return false; 891 892 event->team = team->id; 893 strcpy(event->name, team->Name()); 894 event->args_offset = nameLen + 1; 895 strcpy(event->name + nameLen + 1, team->Args()); 896 897 fHeader->size = fBufferSize; 898 899 return true; 900 } 901 902 903 bool 904 SystemProfiler::_TeamRemoved(Team* team) 905 { 906 // TODO: It is possible that we get remove notifications for teams that 907 // had already been removed from the global team list when we did the 908 // initial scan, but were still in the process of dying. ATM it is not 909 // really possible to identify such a case. 910 911 TeamLocker teamLocker(team); 912 InterruptsSpinLocker locker(fLock); 913 914 system_profiler_team_removed* event = (system_profiler_team_removed*) 915 _AllocateBuffer(sizeof(system_profiler_team_removed), 916 B_SYSTEM_PROFILER_TEAM_REMOVED, 0, 0); 917 if (event == NULL) 918 return false; 919 920 event->team = team->id; 921 922 fHeader->size = fBufferSize; 923 924 return true; 925 } 926 927 928 bool 929 SystemProfiler::_TeamExec(Team* team) 930 { 931 TeamLocker teamLocker(team); 932 933 size_t argsLen = strlen(team->Args()); 934 935 InterruptsSpinLocker locker(fLock); 936 937 system_profiler_team_exec* event = (system_profiler_team_exec*) 938 _AllocateBuffer(sizeof(system_profiler_team_exec) + argsLen, 939 B_SYSTEM_PROFILER_TEAM_EXEC, 0, 0); 940 if (event == NULL) 941 return false; 942 943 event->team = team->id; 944 strlcpy(event->thread_name, team->main_thread->name, 945 sizeof(event->thread_name)); 946 strcpy(event->args, team->Args()); 947 948 fHeader->size = fBufferSize; 949 950 return true; 951 } 952 953 954 bool 955 SystemProfiler::_ThreadAdded(Thread* thread) 956 { 957 ThreadLocker threadLocker(thread); 958 InterruptsSpinLocker locker(fLock); 959 960 // During the initial scan check whether the team is already gone again. 961 // Later this cannot happen, since the team creator notifies us before 962 // actually starting the thread. 963 if (!fThreadNotificationsEnabled && !thread->IsAlive()) 964 return true; 965 966 if (thread->serial_number > fLastThreadAddedSerialNumber) 967 fLastThreadAddedSerialNumber = thread->serial_number; 968 969 system_profiler_thread_added* event = (system_profiler_thread_added*) 970 _AllocateBuffer(sizeof(system_profiler_thread_added), 971 B_SYSTEM_PROFILER_THREAD_ADDED, 0, 0); 972 if (event == NULL) 973 return false; 974 975 event->team = thread->team->id; 976 event->thread = thread->id; 977 strlcpy(event->name, thread->name, sizeof(event->name)); 978 979 fHeader->size = fBufferSize; 980 981 return true; 982 } 983 984 985 bool 986 SystemProfiler::_ThreadRemoved(Thread* thread) 987 { 988 // TODO: It is possible that we get remove notifications for threads that 989 // had already been removed from the global thread list when we did the 990 // initial scan, but were still in the process of dying. ATM it is not 991 // really possible to identify such a case. 992 993 ThreadLocker threadLocker(thread); 994 InterruptsSpinLocker locker(fLock); 995 996 system_profiler_thread_removed* event 997 = (system_profiler_thread_removed*) 998 _AllocateBuffer(sizeof(system_profiler_thread_removed), 999 B_SYSTEM_PROFILER_THREAD_REMOVED, 0, 0); 1000 if (event == NULL) 1001 return false; 1002 1003 event->team = thread->team->id; 1004 event->thread = thread->id; 1005 1006 fHeader->size = fBufferSize; 1007 1008 return true; 1009 } 1010 1011 1012 bool 1013 SystemProfiler::_ImageAdded(struct image* image) 1014 { 1015 InterruptsSpinLocker locker(fLock); 1016 1017 system_profiler_image_added* event = (system_profiler_image_added*) 1018 _AllocateBuffer(sizeof(system_profiler_image_added), 1019 B_SYSTEM_PROFILER_IMAGE_ADDED, 0, 0); 1020 if (event == NULL) 1021 return false; 1022 1023 event->team = image->team; 1024 event->info = image->info.basic_info; 1025 1026 fHeader->size = fBufferSize; 1027 1028 return true; 1029 } 1030 1031 1032 bool 1033 SystemProfiler::_ImageRemoved(struct image* image) 1034 { 1035 InterruptsSpinLocker locker(fLock); 1036 1037 system_profiler_image_removed* event = (system_profiler_image_removed*) 1038 _AllocateBuffer(sizeof(system_profiler_image_removed), 1039 B_SYSTEM_PROFILER_IMAGE_REMOVED, 0, 0); 1040 if (event == NULL) 1041 return false; 1042 1043 event->team = image->team; 1044 event->image = image->info.basic_info.id; 1045 1046 fHeader->size = fBufferSize; 1047 1048 return true; 1049 } 1050 1051 1052 bool 1053 SystemProfiler::_IOSchedulerAdded(IOScheduler* scheduler) 1054 { 1055 size_t nameLen = strlen(scheduler->Name()); 1056 1057 InterruptsSpinLocker locker(fLock); 1058 1059 system_profiler_io_scheduler_added* event 1060 = (system_profiler_io_scheduler_added*)_AllocateBuffer( 1061 sizeof(system_profiler_io_scheduler_added) + nameLen, 1062 B_SYSTEM_PROFILER_IO_SCHEDULER_ADDED, 0, 0); 1063 if (event == NULL) 1064 return false; 1065 1066 event->scheduler = scheduler->ID(); 1067 strcpy(event->name, scheduler->Name()); 1068 1069 fHeader->size = fBufferSize; 1070 1071 return true; 1072 } 1073 1074 1075 bool 1076 SystemProfiler::_IOSchedulerRemoved(IOScheduler* scheduler) 1077 { 1078 InterruptsSpinLocker locker(fLock); 1079 1080 system_profiler_io_scheduler_removed* event 1081 = (system_profiler_io_scheduler_removed*)_AllocateBuffer( 1082 sizeof(system_profiler_io_scheduler_removed), 1083 B_SYSTEM_PROFILER_IO_SCHEDULER_REMOVED, 0, 0); 1084 if (event == NULL) 1085 return false; 1086 1087 event->scheduler = scheduler->ID(); 1088 1089 fHeader->size = fBufferSize; 1090 1091 return true; 1092 } 1093 1094 1095 bool 1096 SystemProfiler::_IORequestScheduled(IOScheduler* scheduler, IORequest* request) 1097 { 1098 InterruptsSpinLocker locker(fLock); 1099 1100 system_profiler_io_request_scheduled* event 1101 = (system_profiler_io_request_scheduled*)_AllocateBuffer( 1102 sizeof(system_profiler_io_request_scheduled), 1103 B_SYSTEM_PROFILER_IO_REQUEST_SCHEDULED, 0, 0); 1104 if (event == NULL) 1105 return false; 1106 1107 IORequestOwner* owner = request->Owner(); 1108 1109 event->time = system_time_nsecs(); 1110 event->scheduler = scheduler->ID(); 1111 event->team = owner->team; 1112 event->thread = owner->thread; 1113 event->request = request; 1114 event->offset = request->Offset(); 1115 event->length = request->Length(); 1116 event->write = request->IsWrite(); 1117 event->priority = owner->priority; 1118 1119 fHeader->size = fBufferSize; 1120 1121 return true; 1122 } 1123 1124 1125 bool 1126 SystemProfiler::_IORequestFinished(IOScheduler* scheduler, IORequest* request) 1127 { 1128 InterruptsSpinLocker locker(fLock); 1129 1130 system_profiler_io_request_finished* event 1131 = (system_profiler_io_request_finished*)_AllocateBuffer( 1132 sizeof(system_profiler_io_request_finished), 1133 B_SYSTEM_PROFILER_IO_REQUEST_FINISHED, 0, 0); 1134 if (event == NULL) 1135 return false; 1136 1137 event->time = system_time_nsecs(); 1138 event->scheduler = scheduler->ID(); 1139 event->request = request; 1140 event->status = request->Status(); 1141 event->transferred = request->TransferredBytes(); 1142 1143 fHeader->size = fBufferSize; 1144 1145 return true; 1146 } 1147 1148 1149 bool 1150 SystemProfiler::_IOOperationStarted(IOScheduler* scheduler, IORequest* request, 1151 IOOperation* operation) 1152 { 1153 InterruptsSpinLocker locker(fLock); 1154 1155 system_profiler_io_operation_started* event 1156 = (system_profiler_io_operation_started*)_AllocateBuffer( 1157 sizeof(system_profiler_io_operation_started), 1158 B_SYSTEM_PROFILER_IO_OPERATION_STARTED, 0, 0); 1159 if (event == NULL) 1160 return false; 1161 1162 event->time = system_time_nsecs(); 1163 event->scheduler = scheduler->ID(); 1164 event->request = request; 1165 event->operation = operation; 1166 event->offset = request->Offset(); 1167 event->length = request->Length(); 1168 event->write = request->IsWrite(); 1169 1170 fHeader->size = fBufferSize; 1171 1172 return true; 1173 } 1174 1175 1176 bool 1177 SystemProfiler::_IOOperationFinished(IOScheduler* scheduler, IORequest* request, 1178 IOOperation* operation) 1179 { 1180 InterruptsSpinLocker locker(fLock); 1181 1182 system_profiler_io_operation_finished* event 1183 = (system_profiler_io_operation_finished*)_AllocateBuffer( 1184 sizeof(system_profiler_io_operation_finished), 1185 B_SYSTEM_PROFILER_IO_OPERATION_FINISHED, 0, 0); 1186 if (event == NULL) 1187 return false; 1188 1189 event->time = system_time_nsecs(); 1190 event->scheduler = scheduler->ID(); 1191 event->request = request; 1192 event->operation = operation; 1193 event->status = request->Status(); 1194 event->transferred = request->TransferredBytes(); 1195 1196 fHeader->size = fBufferSize; 1197 1198 return true; 1199 } 1200 1201 1202 void 1203 SystemProfiler::_WaitObjectCreated(addr_t object, uint32 type) 1204 { 1205 SpinLocker locker(fLock); 1206 1207 // look up the object 1208 WaitObjectKey key; 1209 key.object = object; 1210 key.type = type; 1211 WaitObject* waitObject = fWaitObjectTable.Lookup(key); 1212 1213 // If found, remove it and add it to the free list. This might sound weird, 1214 // but it makes sense, since we lazily track *used* wait objects only. 1215 // I.e. the object in the table is now guaranteedly obsolete. 1216 if (waitObject) { 1217 fWaitObjectTable.RemoveUnchecked(waitObject); 1218 fUsedWaitObjects.Remove(waitObject); 1219 fFreeWaitObjects.Add(waitObject, false); 1220 } 1221 } 1222 1223 void 1224 SystemProfiler::_WaitObjectUsed(addr_t object, uint32 type) 1225 { 1226 // look up the object 1227 WaitObjectKey key; 1228 key.object = object; 1229 key.type = type; 1230 WaitObject* waitObject = fWaitObjectTable.Lookup(key); 1231 1232 // If already known, re-queue it as most recently used and be done. 1233 if (waitObject != NULL) { 1234 fUsedWaitObjects.Remove(waitObject); 1235 fUsedWaitObjects.Add(waitObject); 1236 return; 1237 } 1238 1239 // not known yet -- get the info 1240 const char* name = NULL; 1241 const void* referencedObject = NULL; 1242 1243 switch (type) { 1244 case THREAD_BLOCK_TYPE_SEMAPHORE: 1245 { 1246 name = sem_get_name_unsafe((sem_id)object); 1247 break; 1248 } 1249 1250 case THREAD_BLOCK_TYPE_CONDITION_VARIABLE: 1251 { 1252 ConditionVariable* variable = (ConditionVariable*)object; 1253 name = variable->ObjectType(); 1254 referencedObject = variable->Object(); 1255 break; 1256 } 1257 1258 case THREAD_BLOCK_TYPE_MUTEX: 1259 { 1260 mutex* lock = (mutex*)object; 1261 name = lock->name; 1262 break; 1263 } 1264 1265 case THREAD_BLOCK_TYPE_RW_LOCK: 1266 { 1267 rw_lock* lock = (rw_lock*)object; 1268 name = lock->name; 1269 break; 1270 } 1271 1272 case THREAD_BLOCK_TYPE_OTHER: 1273 { 1274 name = (const char*)(void*)object; 1275 break; 1276 } 1277 1278 case THREAD_BLOCK_TYPE_SNOOZE: 1279 case THREAD_BLOCK_TYPE_SIGNAL: 1280 default: 1281 return; 1282 } 1283 1284 // add the event 1285 size_t nameLen = name != NULL ? strlen(name) : 0; 1286 1287 system_profiler_wait_object_info* event 1288 = (system_profiler_wait_object_info*) 1289 _AllocateBuffer(sizeof(system_profiler_wait_object_info) + nameLen, 1290 B_SYSTEM_PROFILER_WAIT_OBJECT_INFO, 0, 0); 1291 if (event == NULL) 1292 return; 1293 1294 event->type = type; 1295 event->object = object; 1296 event->referenced_object = (addr_t)referencedObject; 1297 if (name != NULL) 1298 strcpy(event->name, name); 1299 else 1300 event->name[0] = '\0'; 1301 1302 fHeader->size = fBufferSize; 1303 1304 // add the wait object 1305 1306 // get a free one or steal the least recently used one 1307 waitObject = fFreeWaitObjects.RemoveHead(); 1308 if (waitObject == NULL) { 1309 waitObject = fUsedWaitObjects.RemoveHead(); 1310 fWaitObjectTable.RemoveUnchecked(waitObject); 1311 } 1312 1313 waitObject->object = object; 1314 waitObject->type = type; 1315 fWaitObjectTable.InsertUnchecked(waitObject); 1316 fUsedWaitObjects.Add(waitObject); 1317 } 1318 1319 1320 /*static*/ bool 1321 SystemProfiler::_InitialImageIterator(struct image* image, void* cookie) 1322 { 1323 SystemProfiler* self = (SystemProfiler*)cookie; 1324 self->fImageNotificationsEnabled = true; 1325 // Set that here, since the image lock is being held now. 1326 return !self->_ImageAdded(image); 1327 } 1328 1329 1330 void* 1331 SystemProfiler::_AllocateBuffer(size_t size, int event, int cpu, int count) 1332 { 1333 size = (size + 3) / 4 * 4; 1334 size += sizeof(system_profiler_event_header); 1335 1336 size_t end = fBufferStart + fBufferSize; 1337 if (end + size > fBufferCapacity) { 1338 // Buffer is wrapped or needs wrapping. 1339 if (end < fBufferCapacity) { 1340 // not wrapped yet, but needed 1341 system_profiler_event_header* header 1342 = (system_profiler_event_header*)(fBufferBase + end); 1343 header->event = B_SYSTEM_PROFILER_BUFFER_END; 1344 fBufferSize = fBufferCapacity - fBufferStart; 1345 end = 0; 1346 } else 1347 end -= fBufferCapacity; 1348 1349 if (end + size > fBufferStart) { 1350 fDroppedEvents++; 1351 return NULL; 1352 } 1353 } 1354 1355 system_profiler_event_header* header 1356 = (system_profiler_event_header*)(fBufferBase + end); 1357 header->event = event; 1358 header->cpu = cpu; 1359 header->size = size - sizeof(system_profiler_event_header); 1360 1361 fBufferSize += size; 1362 1363 return header + 1; 1364 } 1365 1366 1367 /*static*/ void 1368 SystemProfiler::_InitTimers(void* cookie, int cpu) 1369 { 1370 SystemProfiler* self = (SystemProfiler*)cookie; 1371 self->_ScheduleTimer(cpu); 1372 } 1373 1374 1375 /*static*/ void 1376 SystemProfiler::_UninitTimers(void* cookie, int cpu) 1377 { 1378 SystemProfiler* self = (SystemProfiler*)cookie; 1379 1380 CPUProfileData& cpuData = self->fCPUData[cpu]; 1381 cancel_timer(&cpuData.timer); 1382 cpuData.timerScheduled = false; 1383 } 1384 1385 1386 void 1387 SystemProfiler::_ScheduleTimer(int cpu) 1388 { 1389 CPUProfileData& cpuData = fCPUData[cpu]; 1390 cpuData.timerEnd = system_time() + fInterval; 1391 cpuData.timer.user_data = this; 1392 add_timer(&cpuData.timer, &_ProfilingEvent, fInterval, 1393 B_ONE_SHOT_RELATIVE_TIMER); 1394 cpuData.timerScheduled = true; 1395 } 1396 1397 1398 void 1399 SystemProfiler::_DoSample() 1400 { 1401 Thread* thread = thread_get_current_thread(); 1402 int cpu = thread->cpu->cpu_num; 1403 CPUProfileData& cpuData = fCPUData[cpu]; 1404 1405 // get the samples 1406 int32 count = arch_debug_get_stack_trace(cpuData.buffer, fStackDepth, 1, 1407 0, STACK_TRACE_KERNEL | STACK_TRACE_USER); 1408 1409 InterruptsSpinLocker locker(fLock); 1410 1411 system_profiler_samples* event = (system_profiler_samples*) 1412 _AllocateBuffer(sizeof(system_profiler_samples) 1413 + count * sizeof(addr_t), 1414 B_SYSTEM_PROFILER_SAMPLES, cpu, count); 1415 if (event == NULL) 1416 return; 1417 1418 event->thread = thread->id; 1419 memcpy(event->samples, cpuData.buffer, count * sizeof(addr_t)); 1420 1421 fHeader->size = fBufferSize; 1422 } 1423 1424 1425 /*static*/ int32 1426 SystemProfiler::_ProfilingEvent(struct timer* timer) 1427 { 1428 SystemProfiler* self = (SystemProfiler*)timer->user_data; 1429 1430 self->_DoSample(); 1431 self->_ScheduleTimer(timer->cpu); 1432 1433 return B_HANDLED_INTERRUPT; 1434 } 1435 1436 1437 // #pragma mark - private kernel API 1438 1439 1440 #if SYSTEM_PROFILER 1441 1442 status_t 1443 start_system_profiler(size_t areaSize, uint32 stackDepth, bigtime_t interval) 1444 { 1445 struct ParameterDeleter { 1446 ParameterDeleter(area_id area) 1447 : 1448 fArea(area), 1449 fDetached(false) 1450 { 1451 } 1452 1453 ~ParameterDeleter() 1454 { 1455 if (!fDetached) { 1456 delete_area(fArea); 1457 delete sRecordedParameters; 1458 sRecordedParameters = NULL; 1459 } 1460 } 1461 1462 void Detach() 1463 { 1464 fDetached = true; 1465 } 1466 1467 private: 1468 area_id fArea; 1469 bool fDetached; 1470 }; 1471 1472 void* address; 1473 area_id area = create_area("kernel profile data", &address, 1474 B_ANY_KERNEL_ADDRESS, areaSize, B_FULL_LOCK, 1475 B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA); 1476 if (area < 0) 1477 return area; 1478 1479 ParameterDeleter parameterDeleter(area); 1480 1481 sRecordedParameters = new(std::nothrow) system_profiler_parameters; 1482 if (sRecordedParameters == NULL) 1483 return B_NO_MEMORY; 1484 1485 sRecordedParameters->buffer_area = area; 1486 sRecordedParameters->flags = B_SYSTEM_PROFILER_TEAM_EVENTS 1487 | B_SYSTEM_PROFILER_THREAD_EVENTS | B_SYSTEM_PROFILER_IMAGE_EVENTS 1488 | B_SYSTEM_PROFILER_IO_SCHEDULING_EVENTS 1489 | B_SYSTEM_PROFILER_SAMPLING_EVENTS; 1490 sRecordedParameters->locking_lookup_size = 4096; 1491 sRecordedParameters->interval = interval; 1492 sRecordedParameters->stack_depth = stackDepth; 1493 1494 area_info areaInfo; 1495 get_area_info(area, &areaInfo); 1496 1497 // initialize the profiler 1498 SystemProfiler* profiler = new(std::nothrow) SystemProfiler(B_SYSTEM_TEAM, 1499 areaInfo, *sRecordedParameters); 1500 if (profiler == NULL) 1501 return B_NO_MEMORY; 1502 1503 ObjectDeleter<SystemProfiler> profilerDeleter(profiler); 1504 1505 status_t error = profiler->Init(); 1506 if (error != B_OK) 1507 return error; 1508 1509 // set the new profiler 1510 InterruptsSpinLocker locker(sProfilerLock); 1511 if (sProfiler != NULL) 1512 return B_BUSY; 1513 1514 parameterDeleter.Detach(); 1515 profilerDeleter.Detach(); 1516 sProfiler = profiler; 1517 locker.Unlock(); 1518 1519 return B_OK; 1520 } 1521 1522 1523 void 1524 stop_system_profiler() 1525 { 1526 InterruptsSpinLocker locker(sProfilerLock); 1527 if (sProfiler == NULL) 1528 return; 1529 1530 SystemProfiler* profiler = sProfiler; 1531 sProfiler = NULL; 1532 locker.Unlock(); 1533 1534 profiler->ReleaseReference(); 1535 } 1536 1537 #endif // SYSTEM_PROFILER 1538 1539 1540 // #pragma mark - syscalls 1541 1542 1543 status_t 1544 _user_system_profiler_start(struct system_profiler_parameters* userParameters) 1545 { 1546 // copy params to the kernel 1547 struct system_profiler_parameters parameters; 1548 if (userParameters == NULL || !IS_USER_ADDRESS(userParameters) 1549 || user_memcpy(¶meters, userParameters, sizeof(parameters)) 1550 != B_OK) { 1551 return B_BAD_ADDRESS; 1552 } 1553 1554 // check the parameters 1555 team_id team = thread_get_current_thread()->team->id; 1556 1557 area_info areaInfo; 1558 status_t error = get_area_info(parameters.buffer_area, &areaInfo); 1559 if (error != B_OK) 1560 return error; 1561 1562 if (areaInfo.team != team) 1563 return B_BAD_VALUE; 1564 1565 if ((parameters.flags & B_SYSTEM_PROFILER_SAMPLING_EVENTS) != 0) { 1566 if (parameters.stack_depth < 1) 1567 return B_BAD_VALUE; 1568 1569 if (parameters.interval < B_DEBUG_MIN_PROFILE_INTERVAL) 1570 parameters.interval = B_DEBUG_MIN_PROFILE_INTERVAL; 1571 1572 if (parameters.stack_depth > B_DEBUG_STACK_TRACE_DEPTH) 1573 parameters.stack_depth = B_DEBUG_STACK_TRACE_DEPTH; 1574 } 1575 1576 // quick check to see whether we do already have a profiler installed 1577 InterruptsSpinLocker locker(sProfilerLock); 1578 if (sProfiler != NULL) 1579 return B_BUSY; 1580 locker.Unlock(); 1581 1582 // initialize the profiler 1583 SystemProfiler* profiler = new(std::nothrow) SystemProfiler(team, areaInfo, 1584 parameters); 1585 if (profiler == NULL) 1586 return B_NO_MEMORY; 1587 ObjectDeleter<SystemProfiler> profilerDeleter(profiler); 1588 1589 error = profiler->Init(); 1590 if (error != B_OK) 1591 return error; 1592 1593 // set the new profiler 1594 locker.Lock(); 1595 if (sProfiler != NULL) 1596 return B_BUSY; 1597 1598 profilerDeleter.Detach(); 1599 sProfiler = profiler; 1600 locker.Unlock(); 1601 1602 return B_OK; 1603 } 1604 1605 1606 status_t 1607 _user_system_profiler_next_buffer(size_t bytesRead, uint64* _droppedEvents) 1608 { 1609 if (_droppedEvents != NULL && !IS_USER_ADDRESS(_droppedEvents)) 1610 return B_BAD_ADDRESS; 1611 1612 team_id team = thread_get_current_thread()->team->id; 1613 1614 InterruptsSpinLocker locker(sProfilerLock); 1615 if (sProfiler == NULL || sProfiler->TeamID() != team) 1616 return B_BAD_VALUE; 1617 1618 // get a reference to the profiler 1619 SystemProfiler* profiler = sProfiler; 1620 BReference<SystemProfiler> reference(profiler); 1621 locker.Unlock(); 1622 1623 uint64 droppedEvents; 1624 status_t error = profiler->NextBuffer(bytesRead, 1625 _droppedEvents != NULL ? &droppedEvents : NULL); 1626 if (error == B_OK && _droppedEvents != NULL) 1627 user_memcpy(_droppedEvents, &droppedEvents, sizeof(droppedEvents)); 1628 1629 return error; 1630 } 1631 1632 1633 status_t 1634 _user_system_profiler_stop() 1635 { 1636 team_id team = thread_get_current_thread()->team->id; 1637 1638 InterruptsSpinLocker locker(sProfilerLock); 1639 if (sProfiler == NULL || sProfiler->TeamID() != team) 1640 return B_BAD_VALUE; 1641 1642 SystemProfiler* profiler = sProfiler; 1643 sProfiler = NULL; 1644 locker.Unlock(); 1645 1646 profiler->ReleaseReference(); 1647 1648 return B_OK; 1649 } 1650 1651 1652 status_t 1653 _user_system_profiler_recorded(system_profiler_parameters* userParameters) 1654 { 1655 if (userParameters == NULL || !IS_USER_ADDRESS(userParameters)) 1656 return B_BAD_ADDRESS; 1657 if (sRecordedParameters == NULL) 1658 return B_ERROR; 1659 1660 #if SYSTEM_PROFILER 1661 stop_system_profiler(); 1662 1663 // Transfer the area to the userland process 1664 1665 void* address; 1666 area_id newArea = transfer_area(sRecordedParameters->buffer_area, &address, 1667 B_ANY_ADDRESS, team_get_current_team_id(), true); 1668 if (newArea < 0) 1669 return newArea; 1670 1671 status_t status = set_area_protection(newArea, B_READ_AREA); 1672 if (status == B_OK) { 1673 sRecordedParameters->buffer_area = newArea; 1674 1675 status = user_memcpy(userParameters, sRecordedParameters, 1676 sizeof(system_profiler_parameters)); 1677 } 1678 if (status != B_OK) 1679 delete_area(newArea); 1680 1681 delete sRecordedParameters; 1682 sRecordedParameters = NULL; 1683 1684 return status; 1685 #else 1686 return B_NOT_SUPPORTED; 1687 #endif // SYSTEM_PROFILER 1688 } 1689