| @@ -10,13 +10,8 @@ · 9 unmodified lines |
| 10 | 10 | * Copyright (c) 2015-2018 Mathieu Desnoyers <mathieu.desnoyers@efficios.com> |
| 11 | 11 | */ |
| 12 | 12 | |
| 13 | | −#ifdef __KERNEL__ |
| 14 | | −# include <linux/types.h> |
| 15 | | −#else |
| 16 | | −# include <stdint.h> |
| 17 | | −#endif |
| 18 | | − |
| 19 | | −#include <linux/types_32_64.h> |
| 13 | +#include <linux/types.h> |
| 14 | +#include <asm/byteorder.h> |
| 20 | 15 | |
| 21 | 16 | enum rseq_cpu_id_state { |
| 22 | 17 | RSEQ_CPU_ID_UNINITIALIZED = -1, |
| @@ -52,10 +47,10 @@ struct rseq_cs { · 29 unmodified lines |
| 52 | 47 | __u32 version; |
| 53 | 48 | /* enum rseq_cs_flags */ |
| 54 | 49 | __u32 flags; |
| 55 | | − LINUX_FIELD_u32_u64(start_ip); |
| 50 | + __u64 start_ip; |
| 56 | 51 | /* Offset from start_ip. */ |
| 57 | | − LINUX_FIELD_u32_u64(post_commit_offset); |
| 58 | | − LINUX_FIELD_u32_u64(abort_ip); |
| 52 | + __u64 post_commit_offset; |
| 53 | + __u64 abort_ip; |
| 59 | 54 | } __attribute__((aligned(4 * sizeof(__u64)))); |
| 60 | 55 | |
| 61 | 56 | /* |
| @@ -67,28 +62,30 @@ struct rseq_cs { · 5 unmodified lines |
| 67 | 62 | struct rseq { |
| 68 | 63 | /* |
| 69 | 64 | * Restartable sequences cpu_id_start field. Updated by the |
| 70 | | − * kernel, and read by user-space with single-copy atomicity |
| 71 | | − * semantics. Aligned on 32-bit. Always contains a value in the |
| 72 | | − * range of possible CPUs, although the value may not be the |
| 73 | | − * actual current CPU (e.g. if rseq is not initialized). This |
| 74 | | − * CPU number value should always be compared against the value |
| 75 | | − * of the cpu_id field before performing a rseq commit or |
| 76 | | − * returning a value read from a data structure indexed using |
| 77 | | − * the cpu_id_start value. |
| 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. |
| 78 | 74 | */ |
| 79 | 75 | __u32 cpu_id_start; |
| 80 | 76 | /* |
| 81 | | − * Restartable sequences cpu_id field. Updated by the kernel, |
| 82 | | − * and read by user-space with single-copy atomicity semantics. |
| 83 | | − * Aligned on 32-bit. Values RSEQ_CPU_ID_UNINITIALIZED and |
| 84 | | − * RSEQ_CPU_ID_REGISTRATION_FAILED have a special semantic: the |
| 85 | | − * former means "rseq uninitialized", and latter means "rseq |
| 86 | | − * initialization failed". This value is meant to be read within |
| 87 | | − * rseq critical sections and compared with the cpu_id_start |
| 88 | | − * value previously read, before performing the commit instruction, |
| 89 | | − * or read and compared with the cpu_id_start value before returning |
| 90 | | − * a value loaded from a data structure indexed using the |
| 91 | | − * cpu_id_start value. |
| 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. |
| 92 | 89 | */ |
| 93 | 90 | __u32 cpu_id; |
| 94 | 91 | /* |
| @@ -105,27 +102,44 @@ struct rseq { · 10 unmodified lines |
| 105 | 102 | * targeted by the rseq_cs. Also needs to be set to NULL by user-space |
| 106 | 103 | * before reclaiming memory that contains the targeted struct rseq_cs. |
| 107 | 104 | * |
| 108 | | − * Read and set by the kernel with single-copy atomicity semantics. |
| 109 | | − * Set by user-space with single-copy atomicity semantics. Aligned |
| 110 | | − * on 64-bit. |
| 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. |
| 111 | 108 | */ |
| 112 | | − LINUX_FIELD_u32_u64(rseq_cs); |
| 109 | + union { |
| 110 | + __u64 ptr64; |
| 111 | +#ifdef __LP64__ |
| 112 | + __u64 ptr; |
| 113 | +#else |
| 114 | + struct { |
| 115 | +#if (defined(__BYTE_ORDER) && (__BYTE_ORDER == __BIG_ENDIAN)) || defined(__BIG_ENDIAN) |
| 116 | + __u32 padding; /* Initialized to zero. */ |
| 117 | + __u32 ptr32; |
| 118 | +#else /* LITTLE */ |
| 119 | + __u32 ptr32; |
| 120 | + __u32 padding; /* Initialized to zero. */ |
| 121 | +#endif /* ENDIAN */ |
| 122 | + } ptr; |
| 123 | +#endif |
| 124 | + } rseq_cs; |
| 125 | + |
| 113 | 126 | /* |
| 114 | | − * - RSEQ_DISABLE flag: |
| 127 | + * Restartable sequences flags field. |
| 128 | + * |
| 129 | + * This field should only be updated by the thread which |
| 130 | + * registered this data structure. Read by the kernel. |
| 131 | + * Mainly used for single-stepping through rseq critical sections |
| 132 | + * with debuggers. |
| 115 | 133 | * |
| 116 | | − * Fallback fast-track flag for single-stepping. |
| 117 | | − * Set by user-space if lack of progress is detected. |
| 118 | | − * Cleared by user-space after rseq finish. |
| 119 | | − * Read by the kernel. |
| 120 | 134 | * - RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT |
| 121 | | − * Inhibit instruction sequence block restart and event |
| 122 | | − * counter increment on preemption for this thread. |
| 135 | + * Inhibit instruction sequence block restart on preemption |
| 136 | + * for this thread. |
| 123 | 137 | * - RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL |
| 124 | | − * Inhibit instruction sequence block restart and event |
| 125 | | − * counter increment on signal delivery for this thread. |
| 138 | + * Inhibit instruction sequence block restart on signal |
| 139 | + * delivery for this thread. |
| 126 | 140 | * - RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE |
| 127 | | − * Inhibit instruction sequence block restart and event |
| 128 | | − * counter increment on migration for this thread. |
| 141 | + * Inhibit instruction sequence block restart on migration for |
| 142 | + * this thread. |
| 129 | 143 | */ |
| 130 | 144 | __u32 flags; |
| 131 | 145 | } __attribute__((aligned(4 * sizeof(__u64)))); |