STRUCT MSC(9)

💖 NAME 💖

okay so struct msc is literally the MSC device representation — the whole device vibe, packaged up for you, bestie. This page is from the Kernel API Manual, and yes, we're talking about struct msc(9) the entire time. No cap. 🫶

✨ SYNOPSIS ✨

here's the struct in all her exact, character-for-character glory — do not touch the spacing, she's sensitive 💅:

       struct msc {
           void __iomem            *reg_base;
           void __iomem            *msu_base;
           struct intel_th_device  *thdev;
           const struct msu_buffer *mbuf;
           void *mbuf_priv;
           struct work_struct      work;
           struct list_head        win_list;
           struct sg_table         single_sgt;
           struct msc_window       *cur_win;
           struct msc_window       *switch_on_unlock;
           unsigned long           nr_pages;
           unsigned long           single_sz;
           unsigned int            single_wrap : 1;
           void *base;
           dma_addr_t base_addr;
           u32 orig_addr;
           u32 orig_sz;
           atomic_t user_count;
           atomic_t mmap_count;
           struct mutex            buf_mutex;
           struct list_head        iter_list;
           bool stop_on_full;
           unsigned int            enabled : 1, wrap    : 1, do_irq  : 1,
       multi_is_broken : 1;
           unsigned int            mode;
           unsigned int            burst_len;
           unsigned int            index;
        };

🫶 Members 🫶

every member gets her moment, periodt:

• reg_base — the register window base address for the entire MSU. big main-character energy for the whole MSU ✨
• msu_base — the register window base address for this MSC. this one's personal 💅
• thdev — the intel_th_device pointer, just living her life.
• mbuf — the MSU buffer, if one has been assigned.
• mbuf_priv — the MSU buffer's private data, if mbuf exists.
• work — a work item to stop the trace when the buffer is full.
• win_list — the list of windows in multiblock mode.
• single_sgt — the single mode buffer.
• cur_win — the current window.
• switch_on_unlock — the window to switch to when it becomes available.
• nr_pages — total number of pages allocated for this buffer.
• single_sz — the amount of data in single mode.
• single_wrap — a single mode wrap occurred.
• base — the buffer's base pointer.
• base_addr — the buffer's base address.
• orig_addr — the MSC0 buffer's base address.
• orig_sz — the MSC0 buffer's size.
• user_count — number of users of the buffer.
• mmap_count — number of mappings.
• buf_mutex — a mutex to serialize access to buffer-related bits.
• iter_list — list of open file descriptor iterators.
• stop_on_full — stop the trace if the current window is full.
• enabled — MSC is enabled, periodt.
• wrap — wrapping is enabled.
• do_irq — IRQ resource is available, handle interrupts.
• multi_is_broken — multiblock mode enabled (not disabled by PCI drvdata). yes, the name is chaotic, but that's the documented deal.
• mode — MSC operating mode.
• burst_len — write burst length.
• index — number of this MSC in the MSU.

👀 SEE ALSO 👀

Kernel file ./drivers/hwtracing/intel_th/msu.c is the home base, and these besties are all linked:

• struct msc_window(9)
• struct msc_iter(9)
• struct msu_buffer_entry(9)
• msc_is_last_win(9)
• msc_next_window(9)
• msc_find_window(9)
• msc_oldest_window(9)
• msc_win_oldest_sg(9)
• msc_buffer_iterate(9)
• msc_buffer_clear_hw_header(9)
• msc_configure(9)
• msc_disable(9)
• msc_buffer_contig_alloc(9)
• msc_buffer_contig_free(9)
• msc_buffer_contig_get_page(9)
• msc_buffer_win_alloc(9)
• msc_buffer_win_free(9)
• msc_buffer_relink(9)
• msc_buffer_free(9)
• msc_buffer_alloc(9)
• msc_buffer_unlocked_free_unless_used(9)
• msc_buffer_free_unless_used(9)
• msc_buffer_get_page(9)
• struct msc_win_to_user_struct(9)
• msc_win_to_user(9)
• intel_th_msc_window_unlock(9)

later bestie 💅 this page is from the source/version ./drivers/hwtracing/intel_th, dated October 2026, and it's literally struct msc(9). mwah 🎀