jahdiel-alvarez

This commit provides a **bug fix** for the **tracing service's `shared_memory_arbiter`**, specifically addressing issues encountered in **SMB emulation mode**. It introduces logic to **split `CommitDataRequest` IPC calls** into multiple smaller requests when the pending chunk data exceeds the `kIPCBufferSize` limit. This prevents "IPC frame too large" errors, ensuring that **remote producers** can reliably commit tracing data without encountering IPC buffer overflows and improving the stability of the tracing system. The core changes are implemented in `src/tracing/core/shared_memory_arbiter_impl.cc` and `src/tracing/core/shared_memory_arbiter_impl.h`.

This commit introduces an `is_idle` boolean field to **generic kernel thread definitions** within the **trace protobuf schemas**, allowing trace producers to explicitly mark threads as idle. This **new capability** removes the previous assumption that only PID/TID 0 represents the idle thread, making the **trace processor's generic kernel importer** more flexible and platform-agnostic. The change impacts the **`ProcessTracker` logic** and the **internal `THREAD_TABLE`**, enabling accurate identification and storage of potentially multiple idle threads from various kernel environments.

This commit introduces a **new capability** for **producer-side shared memory buffer (SMB) scraping** to correctly handle trace data from producers utilizing shared memory emulation. Previously, the **tracing service** could not directly scrape these buffers, leading to potential data loss; now, producers will self-scrape their buffers upon receiving a flush request and send the data via an updated `CommitDataRequest` that includes a `chunk_incomplete` flag. Concurrently, the **tracing service** has been **refactored** to always emit flush requests for emulated shared memory producers and no longer performs service-side scraping for them, alongside a **bug fix** ensuring the `use_shmem_emulation` flag is correctly set during shared memory setup. This change significantly improves the reliability of trace data collection for emulated shared memory scenarios by distributing the scraping responsibility across the **tracing service** and **producer IPC client**.

This commit **fixes a bug** in the **AndroidLog panel** that prevented machine IDs from being displayed and filtered during multi-VM tracing sessions when `ftrace` was not an active data source. The `getMachineIds` function within `ui/src/plugins/com.android.AndroidLog/index.ts` is updated to query machine identifiers from the `machine` table instead of the `cpu` table. This change addresses an issue where the `cpu` table might not be populated under certain conditions, leading to missing machine information. Consequently, the **AndroidLog panel** will now reliably show the machine ID column and filter button, significantly improving the user experience for **multi-VM trace analysis** by ensuring consistent machine identification.

This commit introduces a **validation enhancement** and **bug fix** within the **trace processor's thread state tracking** to prevent and report invalid data. It modifies the `PushThreadState` function in `src/trace_processor/importers/common/thread_state_tracker.cc` to **emit an error** and increment an error statistic when two thread state events are recorded at the exact same timestamp, a logically impossible scenario. This ensures the integrity of the **kernel event parsing and state machine logic**. Additionally, it includes a minor **refactoring** by introducing the `GetLastRowRef` helper for cleaner state access. **New diff tests** have been added to verify the correct reporting of these temporal conflicts, improving the overall reliability of trace analysis.

This commit **refactors** the **thread state lifecycle handling** within the **trace processor** and **updates the UI** to provide a more accurate and informative visualization of thread activity. The `generic_kernel_parser.cc` now correctly interprets the `DESTROYED` state event as the definitive end of a thread, resolving a **bug** where `DEAD` states led to misleading "zombie" thread slices in the UI. Furthermore, the **UI's Sched plugin** has been enhanced to visualize gaps in context switch events as `[Unknown]` slices, improving the clarity of thread state tracks and details panels. This **bug fix** and **feature enhancement** significantly improves the **accuracy of trace analysis** by preventing erroneous thread termination and highlighting periods of unknown thread activity.

This commit performs a **refactoring** within the **trace processor's process tracking module** by removing the redundant `AssociateThreadToProcess` function from `src/trace_processor/importers/common/process_tracker.cc`. This **maintenance cleanup** streamlines the API by eliminating an unused method that was no longer needed in the current implementation. Call sites that previously used `AssociateThreadToProcess` have been updated to directly invoke its constituent functions, `AssociateThreadToProcessInternal` and `ResolvePendingAssociations`. The change improves code tidiness and maintainability within the `process_tracker` subsystem without altering the functional behavior of thread-to-process association.

This commit introduces a **new capability** to the **TraceProcessor's generic kernel importer** by adding support for parsing the `GenericKernelProcessTree` protobuf. This **enhances the Perfetto trace format** to include detailed kernel process hierarchy information, defined in `generic_task.proto` and integrated into `TracePacket`. The parsed data is processed by `ParseGenericProcessTree` and used to update the internal process and thread tracking via `process_tracker.cc`. This `grow` work enables the **UI to accurately display process/thread nesting and relationships**, resolving a previous limitation (Bug: 425694654) by providing crucial context for trace analysis.

This commit **refactors** the **trace processor's `process_tracker` thread APIs** to explicitly manage main thread identification, **decoupling the process ID (PID) from the main thread's thread ID (TID)**. Previously, the system assumed the main thread's TID would match the PID, which is not always true on **non-Linux operating systems**. This change enhances the **robustness and cross-platform compatibility** of thread tracking by requiring an explicit `associate_main_threads` flag in calls like `AssociateThreads`. The `ftrace_parser` was updated to use this new API, and **new unit tests** were added to validate the updated logic and ensure correct behavior.

This commit introduces a significant **refactoring** within the **`ProcessTracker`** component of the trace processor, modifying how processes are created and managed. The `GetOrCreateProcess` and `StartNewProcess` APIs have been split into new variants, `*WithoutMainThread`, enabling **process creation without automatically associating a main thread**. This change is a foundational step towards **decoupling the Process ID (PID) from the main Thread ID (TID)**, which will simplify the integration of non-Linux operating systems into Perfetto by providing more flexible process modeling. Existing trace parsers in `system_probes_parser.cc` and `systrace_trace_parser.cc` have been updated to explicitly maintain their previous behavior of associating a main thread.

This commit **refactors** the **`ProcessTracker` module** to generalize how new processes are associated with their parents, moving away from Linux-specific PID/TID assumptions. The `StartNewProcess` method now accepts an optional parent `UniquePid`, and a new method, `AssociateCreatedProcessToParentThread`, is introduced to explicitly handle parent-thread associations. This **generalization** improves the **portability and maintainability** of the process tracking logic, particularly impacting the **`Ftrace` importer** which now utilizes the new association method in `ParseTaskNewTask`.

This commit **refactors** the **`ProcessTracker` API** within `trace_processor/importers/common` by splitting the `SetProcessMetadata` function into two distinct APIs. A new function, `UpdateProcessWithParent`, is introduced to specifically handle associating a process with its parent, while the original `SetProcessMetadata` is simplified to solely set general process metadata. This **refactoring** improves the **API semantics** by reducing side effects and enhancing clarity in how process metadata and parent relationships are managed. Consequently, various trace importers, including **Fuchsia**, **JSON**, **Proto**, and **Systrace**, have been updated to utilize these more focused functions, along with their corresponding unit tests.

This commit **refactors** the `ProcessTracker::SetProcessMetadata` function within the **`trace_processor`** to accept `UniquePid` objects directly, rather than raw PIDs. This **simplifies its API** by decoupling process creation from metadata setting, improving code clarity and reducing complexity in the core process tracking logic. Consequently, various trace **importers** including `Ftrace`, `Fuchsia`, `JSON`, `Proto`, and `Systrace` have been updated to adapt to this new signature, ensuring they obtain `UniquePid`s before calling `SetProcessMetadata`. This **maintenance** and **refactoring** effort enhances the maintainability of the process tracking subsystem and its integration with different trace formats, with corresponding unit tests also updated.

This commit **refactors** the `ProcessTracker` module within the **trace processor** to enhance the accuracy of thread identification. Specifically, the `UpdateThreadNameAndMaybeProcessName` function now accepts a `UniqueTid` instead of a raw `tid`, which is essential for correctly disambiguating threads given that Perfetto allows concurrent `tids`. This change impacts several **trace importers**, including those for ART method, ftrace, generic kernel, and perf text, by updating their calls to pass the more precise `UniqueTid`. The **refactoring** ensures more robust and accurate tracking of thread and process names across the system.

This commit introduces a **new capability** to **filter data source producers by machine name** within the Perfetto tracing system, significantly enhancing control in **multi-VM tracing environments**. It extends the `TraceConfig.DataSource` proto with a `machine_name_filter` field, allowing users to specify which machine's data sources should be enabled. The machine name is determined via environment variables, Android system properties, or `utsname`, and is propagated through the **IPC layer** and **tracing service** during producer connection, enabling the `tracing_service_impl` to apply the filter. This **feature addition** provides more granular control over trace data collection, ensuring only relevant data from specified machines is captured.

This commit **refactors** the **`ProcessTracker`** module to enforce a **one-to-one mapping between a Thread ID (TID) and an active thread**, resolving a bug where multiple threads could share the same TID. It introduces a new `ClearThread` method to remove all preexisting Unique Thread IDs (UTIDs) for a given TID, acting as a barrier for new thread creation. The `GetOrCreateThread` method is now the primary entry point for thread creation, centralizing and simplifying thread lifecycle management across various trace importers like `ftrace` and `generic_kernel`. This change significantly improves the **semantic correctness of thread tracking** within the trace processor, leading to more robust and reliable data processing.

This commit introduces a **new capability** to the **TraceProcessor's proto import pipeline** to correctly handle `ChromeThreadDescriptor`'s `is_sandboxed_tid` field. It enables the generation of **unique synthetic TIDs** for sandboxed threads, addressing the challenge of non-unique or unavailable root-level TIDs from the Chrome browser. The changes involve modifying `track_event_parser` and `track_event_tokenizer` to determine and apply the `is_sandboxed` flag, utilizing a new `CreateSyntheticTid` helper in `process_tracker`. This ensures **correct and unique thread lifetime tracking** within the **TraceProcessor**, which is vital for accurate analysis of Chrome traces involving sandboxed processes. Additionally, `pid` and `tid` types in `TrackReservation` are **refactored** to `int64_t` to accommodate these synthetic IDs.

This commit introduces a **bug fix** and **validation enhancement** within the **trace processor's track event system**. It prevents the `tid_override` field from being incorrectly set to 0, a value specifically reserved for the swapper thread, by adding validation within the `ParseTrackEvent` function in `src/trace_processor/importers/proto/track_event_event_importer.h`. This change ensures that events are not erroneously attributed to the swapper thread, thereby improving the **accuracy and reliability of trace data processing**. A new test case confirms that `tid_override` values of 0 are now correctly ignored.

This commit performs a **maintenance refactoring** within the **`ProcessTracker`** component, specifically affecting its thread lookup methods. It simplifies the single-argument `GetThreadOrNull(tid)` by refactoring it to delegate to the two-argument `GetThreadOrNull(tid, pid)` overload, passing `std::nullopt` for the optional `pid`. This change clarifies that calling `GetThreadOrNull(tid, std::nullopt)` is semantically identical to `GetThreadOrNull(tid)`. The refactoring also centralizes common `DCHECK`s into the two-argument method, improving code clarity and reducing redundancy in the `src/trace_processor/importers/common/process_tracker.cc` file.

This commit **refactors** the **`ProcessTracker`** component within the trace processor to standardize its thread naming APIs. The `UpdateThreadName` method is now exclusively `UniqueTid` (UTID)-based, achieved by removing the `tid`-based overload and renaming `UpdateThreadNameByUtid` to `UpdateThreadName`. This **refactoring** improves API consistency by enforcing the use of `UTID` as a primitive identifier for threads. Consequently, numerous **trace importers** across the project (e.g., `ftrace`, `json`, `proto`, `systrace`) have been updated to use the new `UTID`-centric `UpdateThreadName` API, ensuring a more unified and robust approach to thread tracking during **trace processing**.