GNU Linux-libre 6.9.2-gnu
[releases.git] / include / uapi / linux / rseq.h
1 /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
2 #ifndef _UAPI_LINUX_RSEQ_H
3 #define _UAPI_LINUX_RSEQ_H
4
5 /*
6  * linux/rseq.h
7  *
8  * Restartable sequences system call API
9  *
10  * Copyright (c) 2015-2018 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
11  */
12
13 #include <linux/types.h>
14 #include <asm/byteorder.h>
15
16 enum rseq_cpu_id_state {
17         RSEQ_CPU_ID_UNINITIALIZED               = -1,
18         RSEQ_CPU_ID_REGISTRATION_FAILED         = -2,
19 };
20
21 enum rseq_flags {
22         RSEQ_FLAG_UNREGISTER = (1 << 0),
23 };
24
25 enum rseq_cs_flags_bit {
26         RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT  = 0,
27         RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT   = 1,
28         RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT  = 2,
29 };
30
31 enum rseq_cs_flags {
32         RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT      =
33                 (1U << RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT),
34         RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL       =
35                 (1U << RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT),
36         RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE      =
37                 (1U << RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT),
38 };
39
40 /*
41  * struct rseq_cs is aligned on 4 * 8 bytes to ensure it is always
42  * contained within a single cache-line. It is usually declared as
43  * link-time constant data.
44  */
45 struct rseq_cs {
46         /* Version of this structure. */
47         __u32 version;
48         /* enum rseq_cs_flags */
49         __u32 flags;
50         __u64 start_ip;
51         /* Offset from start_ip. */
52         __u64 post_commit_offset;
53         __u64 abort_ip;
54 } __attribute__((aligned(4 * sizeof(__u64))));
55
56 /*
57  * struct rseq is aligned on 4 * 8 bytes to ensure it is always
58  * contained within a single cache-line.
59  *
60  * A single struct rseq per thread is allowed.
61  */
62 struct rseq {
63         /*
64          * Restartable sequences cpu_id_start field. Updated by the
65          * kernel. Read by user-space with single-copy atomicity
66          * semantics. This field should only be read by the thread which
67          * registered this data structure. Aligned on 32-bit. Always
68          * contains a value in the range of possible CPUs, although the
69          * value may not be the actual current CPU (e.g. if rseq is not
70          * initialized). This CPU number value should always be compared
71          * against the value of the cpu_id field before performing a rseq
72          * commit or returning a value read from a data structure indexed
73          * using the cpu_id_start value.
74          */
75         __u32 cpu_id_start;
76         /*
77          * Restartable sequences cpu_id field. Updated by the kernel.
78          * Read by user-space with single-copy atomicity semantics. This
79          * field should only be read by the thread which registered this
80          * data structure. Aligned on 32-bit. Values
81          * RSEQ_CPU_ID_UNINITIALIZED and RSEQ_CPU_ID_REGISTRATION_FAILED
82          * have a special semantic: the former means "rseq uninitialized",
83          * and latter means "rseq initialization failed". This value is
84          * meant to be read within rseq critical sections and compared
85          * with the cpu_id_start value previously read, before performing
86          * the commit instruction, or read and compared with the
87          * cpu_id_start value before returning a value loaded from a data
88          * structure indexed using the cpu_id_start value.
89          */
90         __u32 cpu_id;
91         /*
92          * Restartable sequences rseq_cs field.
93          *
94          * Contains NULL when no critical section is active for the current
95          * thread, or holds a pointer to the currently active struct rseq_cs.
96          *
97          * Updated by user-space, which sets the address of the currently
98          * active rseq_cs at the beginning of assembly instruction sequence
99          * block, and set to NULL by the kernel when it restarts an assembly
100          * instruction sequence block, as well as when the kernel detects that
101          * it is preempting or delivering a signal outside of the range
102          * targeted by the rseq_cs. Also needs to be set to NULL by user-space
103          * before reclaiming memory that contains the targeted struct rseq_cs.
104          *
105          * Read and set by the kernel. Set by user-space with single-copy
106          * atomicity semantics. This field should only be updated by the
107          * thread which registered this data structure. Aligned on 64-bit.
108          *
109          * 32-bit architectures should update the low order bits of the
110          * rseq_cs field, leaving the high order bits initialized to 0.
111          */
112         __u64 rseq_cs;
113
114         /*
115          * Restartable sequences flags field.
116          *
117          * This field should only be updated by the thread which
118          * registered this data structure. Read by the kernel.
119          * Mainly used for single-stepping through rseq critical sections
120          * with debuggers.
121          *
122          * - RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT
123          *     Inhibit instruction sequence block restart on preemption
124          *     for this thread.
125          * - RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL
126          *     Inhibit instruction sequence block restart on signal
127          *     delivery for this thread.
128          * - RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE
129          *     Inhibit instruction sequence block restart on migration for
130          *     this thread.
131          */
132         __u32 flags;
133
134         /*
135          * Restartable sequences node_id field. Updated by the kernel. Read by
136          * user-space with single-copy atomicity semantics. This field should
137          * only be read by the thread which registered this data structure.
138          * Aligned on 32-bit. Contains the current NUMA node ID.
139          */
140         __u32 node_id;
141
142         /*
143          * Restartable sequences mm_cid field. Updated by the kernel. Read by
144          * user-space with single-copy atomicity semantics. This field should
145          * only be read by the thread which registered this data structure.
146          * Aligned on 32-bit. Contains the current thread's concurrency ID
147          * (allocated uniquely within a memory map).
148          */
149         __u32 mm_cid;
150
151         /*
152          * Flexible array member at end of structure, after last feature field.
153          */
154         char end[];
155 } __attribute__((aligned(4 * sizeof(__u64))));
156
157 #endif /* _UAPI_LINUX_RSEQ_H */