2 * User-mode machine state access
4 * Copyright (C) 2007 Red Hat, Inc. All rights reserved.
6 * This copyrighted material is made available to anyone wishing to use,
7 * modify, copy, or redistribute it subject to the terms and conditions
8 * of the GNU General Public License v.2.
10 * Red Hat Author: Roland McGrath.
13 #ifndef _LINUX_REGSET_H
14 #define _LINUX_REGSET_H 1
16 #include <linux/compiler.h>
17 #include <linux/types.h>
18 #include <linux/uaccess.h>
24 * user_regset_active_fn - type of @active function in &struct user_regset
25 * @target: thread being examined
26 * @regset: regset being examined
28 * Return -%ENODEV if not available on the hardware found.
29 * Return %0 if no interesting state in this thread.
30 * Return >%0 number of @size units of interesting state.
31 * Any get call fetching state beyond that number will
32 * see the default initialization state for this data,
33 * so a caller that knows what the default state is need
34 * not copy it all out.
35 * This call is optional; the pointer is %NULL if there
36 * is no inexpensive check to yield a value < @n.
38 typedef int user_regset_active_fn(struct task_struct
*target
,
39 const struct user_regset
*regset
);
42 * user_regset_get_fn - type of @get function in &struct user_regset
43 * @target: thread being examined
44 * @regset: regset being examined
45 * @pos: offset into the regset data to access, in bytes
46 * @count: amount of data to copy, in bytes
47 * @kbuf: if not %NULL, a kernel-space pointer to copy into
48 * @ubuf: if @kbuf is %NULL, a user-space pointer to copy into
50 * Fetch register values. Return %0 on success; -%EIO or -%ENODEV
51 * are usual failure returns. The @pos and @count values are in
52 * bytes, but must be properly aligned. If @kbuf is non-null, that
53 * buffer is used and @ubuf is ignored. If @kbuf is %NULL, then
54 * ubuf gives a userland pointer to access directly, and an -%EFAULT
55 * return value is possible.
57 typedef int user_regset_get_fn(struct task_struct
*target
,
58 const struct user_regset
*regset
,
59 unsigned int pos
, unsigned int count
,
60 void *kbuf
, void __user
*ubuf
);
63 * user_regset_set_fn - type of @set function in &struct user_regset
64 * @target: thread being examined
65 * @regset: regset being examined
66 * @pos: offset into the regset data to access, in bytes
67 * @count: amount of data to copy, in bytes
68 * @kbuf: if not %NULL, a kernel-space pointer to copy from
69 * @ubuf: if @kbuf is %NULL, a user-space pointer to copy from
71 * Store register values. Return %0 on success; -%EIO or -%ENODEV
72 * are usual failure returns. The @pos and @count values are in
73 * bytes, but must be properly aligned. If @kbuf is non-null, that
74 * buffer is used and @ubuf is ignored. If @kbuf is %NULL, then
75 * ubuf gives a userland pointer to access directly, and an -%EFAULT
76 * return value is possible.
78 typedef int user_regset_set_fn(struct task_struct
*target
,
79 const struct user_regset
*regset
,
80 unsigned int pos
, unsigned int count
,
81 const void *kbuf
, const void __user
*ubuf
);
84 * user_regset_writeback_fn - type of @writeback function in &struct user_regset
85 * @target: thread being examined
86 * @regset: regset being examined
87 * @immediate: zero if writeback at completion of next context switch is OK
89 * This call is optional; usually the pointer is %NULL. When
90 * provided, there is some user memory associated with this regset's
91 * hardware, such as memory backing cached register data on register
92 * window machines; the regset's data controls what user memory is
93 * used (e.g. via the stack pointer value).
95 * Write register data back to user memory. If the @immediate flag
96 * is nonzero, it must be written to the user memory so uaccess or
97 * access_process_vm() can see it when this call returns; if zero,
98 * then it must be written back by the time the task completes a
99 * context switch (as synchronized with wait_task_inactive()).
100 * Return %0 on success or if there was nothing to do, -%EFAULT for
101 * a memory problem (bad stack pointer or whatever), or -%EIO for a
104 typedef int user_regset_writeback_fn(struct task_struct
*target
,
105 const struct user_regset
*regset
,
109 * struct user_regset - accessible thread CPU state
110 * @n: Number of slots (registers).
111 * @size: Size in bytes of a slot (register).
112 * @align: Required alignment, in bytes.
113 * @bias: Bias from natural indexing.
114 * @core_note_type: ELF note @n_type value used in core dumps.
115 * @get: Function to fetch values.
116 * @set: Function to store values.
117 * @active: Function to report if regset is active, or %NULL.
118 * @writeback: Function to write data back to user memory, or %NULL.
120 * This data structure describes a machine resource we call a register set.
121 * This is part of the state of an individual thread, not necessarily
122 * actual CPU registers per se. A register set consists of a number of
123 * similar slots, given by @n. Each slot is @size bytes, and aligned to
124 * @align bytes (which is at least @size).
126 * These functions must be called only on the current thread or on a
127 * thread that is in %TASK_STOPPED or %TASK_TRACED state, that we are
128 * guaranteed will not be woken up and return to user mode, and that we
129 * have called wait_task_inactive() on. (The target thread always might
130 * wake up for SIGKILL while these functions are working, in which case
131 * that thread's user_regset state might be scrambled.)
133 * The @pos argument must be aligned according to @align; the @count
134 * argument must be a multiple of @size. These functions are not
135 * responsible for checking for invalid arguments.
137 * When there is a natural value to use as an index, @bias gives the
138 * difference between the natural index and the slot index for the
139 * register set. For example, x86 GDT segment descriptors form a regset;
140 * the segment selector produces a natural index, but only a subset of
141 * that index space is available as a regset (the TLS slots); subtracting
142 * @bias from a segment selector index value computes the regset slot.
144 * If nonzero, @core_note_type gives the n_type field (NT_* value)
145 * of the core file note in which this regset's data appears.
146 * NT_PRSTATUS is a special case in that the regset data starts at
147 * offsetof(struct elf_prstatus, pr_reg) into the note data; that is
148 * part of the per-machine ELF formats userland knows about. In
149 * other cases, the core file note contains exactly the whole regset
150 * (@n * @size) and nothing else. The core file note is normally
151 * omitted when there is an @active function and it returns zero.
154 user_regset_get_fn
*get
;
155 user_regset_set_fn
*set
;
156 user_regset_active_fn
*active
;
157 user_regset_writeback_fn
*writeback
;
162 unsigned int core_note_type
;
166 * struct user_regset_view - available regsets
167 * @name: Identifier, e.g. UTS_MACHINE string.
168 * @regsets: Array of @n regsets available in this view.
169 * @n: Number of elements in @regsets.
170 * @e_machine: ELF header @e_machine %EM_* value written in core dumps.
171 * @e_flags: ELF header @e_flags value written in core dumps.
172 * @ei_osabi: ELF header @e_ident[%EI_OSABI] value written in core dumps.
174 * A regset view is a collection of regsets (&struct user_regset,
175 * above). This describes all the state of a thread that can be seen
176 * from a given architecture/ABI environment. More than one view might
177 * refer to the same &struct user_regset, or more than one regset
178 * might refer to the same machine-specific state in the thread. For
179 * example, a 32-bit thread's state could be examined from the 32-bit
180 * view or from the 64-bit view. Either method reaches the same thread
181 * register state, doing appropriate widening or truncation.
183 struct user_regset_view
{
185 const struct user_regset
*regsets
;
193 * This is documented here rather than at the definition sites because its
194 * implementation is machine-dependent but its interface is universal.
197 * task_user_regset_view - Return the process's native regset view.
198 * @tsk: a thread of the process in question
200 * Return the &struct user_regset_view that is native for the given process.
201 * For example, what it would access when it called ptrace().
202 * Throughout the life of the process, this only changes at exec.
204 const struct user_regset_view
*task_user_regset_view(struct task_struct
*tsk
);
208 * These are helpers for writing regset get/set functions in arch code.
209 * Because @start_pos and @end_pos are always compile-time constants,
210 * these are inlined into very little code though they look large.
212 * Use one or more calls sequentially for each chunk of regset data stored
213 * contiguously in memory. Call with constants for @start_pos and @end_pos,
214 * giving the range of byte positions in the regset that data corresponds
215 * to; @end_pos can be -1 if this chunk is at the end of the regset layout.
216 * Each call updates the arguments to point past its chunk.
219 static inline int user_regset_copyout(unsigned int *pos
, unsigned int *count
,
221 void __user
**ubuf
, const void *data
,
222 const int start_pos
, const int end_pos
)
226 BUG_ON(*pos
< start_pos
);
227 if (end_pos
< 0 || *pos
< end_pos
) {
228 unsigned int copy
= (end_pos
< 0 ? *count
229 : min(*count
, end_pos
- *pos
));
230 data
+= *pos
- start_pos
;
232 memcpy(*kbuf
, data
, copy
);
234 } else if (__copy_to_user(*ubuf
, data
, copy
))
244 static inline int user_regset_copyin(unsigned int *pos
, unsigned int *count
,
246 const void __user
**ubuf
, void *data
,
247 const int start_pos
, const int end_pos
)
251 BUG_ON(*pos
< start_pos
);
252 if (end_pos
< 0 || *pos
< end_pos
) {
253 unsigned int copy
= (end_pos
< 0 ? *count
254 : min(*count
, end_pos
- *pos
));
255 data
+= *pos
- start_pos
;
257 memcpy(data
, *kbuf
, copy
);
259 } else if (__copy_from_user(data
, *ubuf
, copy
))
270 * These two parallel the two above, but for portions of a regset layout
271 * that always read as all-zero or for which writes are ignored.
273 static inline int user_regset_copyout_zero(unsigned int *pos
,
275 void **kbuf
, void __user
**ubuf
,
281 BUG_ON(*pos
< start_pos
);
282 if (end_pos
< 0 || *pos
< end_pos
) {
283 unsigned int copy
= (end_pos
< 0 ? *count
284 : min(*count
, end_pos
- *pos
));
286 memset(*kbuf
, 0, copy
);
288 } else if (__clear_user(*ubuf
, copy
))
298 static inline int user_regset_copyin_ignore(unsigned int *pos
,
301 const void __user
**ubuf
,
307 BUG_ON(*pos
< start_pos
);
308 if (end_pos
< 0 || *pos
< end_pos
) {
309 unsigned int copy
= (end_pos
< 0 ? *count
310 : min(*count
, end_pos
- *pos
));
322 * copy_regset_to_user - fetch a thread's user_regset data into user memory
323 * @target: thread to be examined
324 * @view: &struct user_regset_view describing user thread machine state
325 * @setno: index in @view->regsets
326 * @offset: offset into the regset data, in bytes
327 * @size: amount of data to copy, in bytes
328 * @data: user-mode pointer to copy into
330 static inline int copy_regset_to_user(struct task_struct
*target
,
331 const struct user_regset_view
*view
,
333 unsigned int offset
, unsigned int size
,
336 const struct user_regset
*regset
= &view
->regsets
[setno
];
338 if (!access_ok(VERIFY_WRITE
, data
, size
))
341 return regset
->get(target
, regset
, offset
, size
, NULL
, data
);
345 * copy_regset_from_user - store into thread's user_regset data from user memory
346 * @target: thread to be examined
347 * @view: &struct user_regset_view describing user thread machine state
348 * @setno: index in @view->regsets
349 * @offset: offset into the regset data, in bytes
350 * @size: amount of data to copy, in bytes
351 * @data: user-mode pointer to copy from
353 static inline int copy_regset_from_user(struct task_struct
*target
,
354 const struct user_regset_view
*view
,
356 unsigned int offset
, unsigned int size
,
357 const void __user
*data
)
359 const struct user_regset
*regset
= &view
->regsets
[setno
];
361 if (!access_ok(VERIFY_READ
, data
, size
))
364 return regset
->set(target
, regset
, offset
, size
, NULL
, data
);
368 #endif /* <linux/regset.h> */
This page took 0.037544 seconds and 5 git commands to generate.