STRUCT USER_REGSET(9)

💅 NAME

struct user_regset — the accessible thread CPU state, bestie. That's the whole vibe. ✨

(oh and hiii, this is a page from the Kernel API Manual, welcome to the group chat 🫶)

---

✨ SYNOPSIS ✨

struct user_regset {
    user_regset_get2_fn *regset_get;
    user_regset_set_fn *set;
    user_regset_active_fn *active;
    user_regset_writeback_fn *writeback;
    unsigned int                    n;
    unsigned int                    size;
    unsigned int                    align;
    unsigned int                    bias;
    unsigned int                    core_note_type;
    const char                      *core_note_name;
 };

Look at her. Iconic. No notes. 🔥

---

🎀 MEMBERS 🎀

Okay so each of these fields is a whole personality, let me introduce you 💖

• regset_get — Function to fetch values. Get you a function that can do both etc etc.
• set — Function to store values. The getter's other half, we love a duo 👑
• active — Function to report if the regset is active, or NULL. Yes she can be NULL, it's called range 💅
• writeback — Function to write data back to user memory, or NULL. Optional queen.
• n — Number of slots (registers). Count 'em.
• size — Size in bytes of a slot (register).
• align — Required alignment, in bytes.
• bias — Bias from natural indexing. Very "which index are you actually" energy ngl.
• core_note_type — ELF note n_type value used in core dumps.
• core_note_name — ELF note name to qualify the note type.

---

💖 DESCRIPTION 💖

So. This data structure describes a machine resource we call a register set. And before you come for me — this is part of the state of an individual thread, not necessarily actual CPU registers per se, okay? Words matter. 🌸

A register set consists of a number of similar slots, given by n. Each slot is size bytes, and aligned to align bytes (which is at least size). And for dynamically-sized regsets, n must contain the maximum possible number of slots for the regset — no shrinking, bestie, we plan ahead 💅

For backward compatibility, the get and set methods must pad to, or accept, n * size bytes, even if the current regset size is smaller. The precise semantics of these operations depend on the regset being accessed. So basically: know your regset. 🧚

Okay this next part is the serious part, so listen up fr fr. The functions to which struct user_regset members point must be called only on the current thread or on a thread that is in TASK_STOPPED or TASK_TRACED state, that we are guaranteed will not be woken up and return to user mode, and that we have called wait_task_inactive on. (The target thread always might wake up for SIGKILL while these functions are working, in which case that thread's user_regset state might be scrambled.) 💀 Yes. Scrambled. Do not test her.

The pos argument must be aligned according to align; the count argument must be a multiple of size. And heads up — these functions are not responsible for checking for invalid arguments. That's on you, boo. 🙈

When there is a natural value to use as an index, bias gives the difference between the natural index and the slot index for the register set. Example time, and it's a good one: x86 GDT segment descriptors form a regset; the segment selector produces a natural index, but only a subset of that index space is available as a regset (the TLS slots); subtracting bias from a segment selector index value computes the regset slot. Math ate, honestly. 🔥

If nonzero, core_note_type gives the n_type field (NT_* value) of the core file note in which this regset's data appears. And core_note_name specifies the note name. The preferred way to specify these two fields is to use the USER_REGSET_NOTE_TYPE macro — use the macro, it's literally right there 🎀

NT_PRSTATUS is a special case in that the regset data starts at offsetof(struct elf_prstatus, pr_reg) into the note data; that is part of the per-machine ELF formats userland knows about. In other cases, the core file note contains exactly the whole regset (n * size) and nothing else. And the core file note is normally omitted when there is an active function and it returns zero. Periodt. 👑

---

🌈 SEE ALSO 🌈

Go read these next, iykyk 💜

Kernel file ./include/linux/regset.h user_regset_active_fn(9), user_regset_set_fn(9), user_regset_writeback_fn(9), struct user_regset_view(9), task_user_regset_view(9), copy_regset_from_user(9)

---

Okay that's the whole page, you ate that ngl 🍓 This lil legend came out of ./include/linux — October 2026, kernel API manual, mwah 💋 stay hydrated and may all your regsets be aligned ✨🦋