fix: compiler warning `-Wswitch-enum`

[librseq.git] / include / rseq / rseq.h

diff --git a/include/rseq/rseq.h b/include/rseq/rseq.h
index 53376aeb6d547d9467c80ce626c73a03ffdd72a6..080508e2988de275367e101a8d571398fc72cfa1 100644 (file)
--- a/include/rseq/rseq.h
+++ b/include/rseq/rseq.h
@@ -97,6 +97,20 @@ static inline struct rseq_abi *rseq_get_abi(void)
 
 #endif /* RSEQ_GET_ABI_OVERRIDE */
 
+enum rseq_mo {
+       RSEQ_MO_RELAXED = 0,
+       RSEQ_MO_CONSUME = 1,    /* Unused */
+       RSEQ_MO_ACQUIRE = 2,    /* Unused */
+       RSEQ_MO_RELEASE = 3,
+       RSEQ_MO_ACQ_REL = 4,    /* Unused */
+       RSEQ_MO_SEQ_CST = 5,    /* Unused */
+};
+
+enum rseq_percpu_mode {
+       RSEQ_PERCPU_CPU_ID = 0,
+       RSEQ_PERCPU_MM_CID = 1,
+};
+
 #define rseq_likely(x)         __builtin_expect(!!(x), 1)
 #define rseq_unlikely(x)       __builtin_expect(!!(x), 0)
 #define rseq_barrier()         __asm__ __volatile__("" : : : "memory")
@@ -235,7 +249,7 @@ static inline uint32_t rseq_current_mm_cid(void)
 
 static inline void rseq_clear_rseq_cs(void)
 {
-       RSEQ_WRITE_ONCE(rseq_get_abi()->rseq_cs, 0);
+       RSEQ_WRITE_ONCE(rseq_get_abi()->rseq_cs.arch.ptr, 0);
 }
 
 /*
@@ -254,6 +268,168 @@ static inline void rseq_prepare_unload(void)
        rseq_clear_rseq_cs();
 }
 
+static inline __attribute__((always_inline))
+int rseq_cmpeqv_storev(enum rseq_mo rseq_mo, enum rseq_percpu_mode percpu_mode,
+                      intptr_t *v, intptr_t expect,
+                      intptr_t newv, int cpu)
+{
+       if (rseq_mo != RSEQ_MO_RELAXED)
+               return -1;
+       switch (percpu_mode) {
+       case RSEQ_PERCPU_CPU_ID:
+               return rseq_cmpeqv_storev_relaxed_cpu_id(v, expect, newv, cpu);
+       case RSEQ_PERCPU_MM_CID:
+               return rseq_cmpeqv_storev_relaxed_mm_cid(v, expect, newv, cpu);
+       default:
+               return -1;
+       }
+}
+
+/*
+ * Compare @v against @expectnot. When it does _not_ match, load @v
+ * into @load, and store the content of *@v + voffp into @v.
+ */
+static inline __attribute__((always_inline))
+int rseq_cmpnev_storeoffp_load(enum rseq_mo rseq_mo, enum rseq_percpu_mode percpu_mode,
+                              intptr_t *v, intptr_t expectnot, long voffp, intptr_t *load,
+                              int cpu)
+{
+       if (rseq_mo != RSEQ_MO_RELAXED)
+               return -1;
+       switch (percpu_mode) {
+       case RSEQ_PERCPU_CPU_ID:
+               return rseq_cmpnev_storeoffp_load_relaxed_cpu_id(v, expectnot, voffp, load, cpu);
+       case RSEQ_PERCPU_MM_CID:
+               return rseq_cmpnev_storeoffp_load_relaxed_mm_cid(v, expectnot, voffp, load, cpu);
+       default:
+               return -1;
+       }
+}
+
+static inline __attribute__((always_inline))
+int rseq_addv(enum rseq_mo rseq_mo, enum rseq_percpu_mode percpu_mode,
+             intptr_t *v, intptr_t count, int cpu)
+{
+       if (rseq_mo != RSEQ_MO_RELAXED)
+               return -1;
+       switch (percpu_mode) {
+       case RSEQ_PERCPU_CPU_ID:
+               return rseq_addv_relaxed_cpu_id(v, count, cpu);
+       case RSEQ_PERCPU_MM_CID:
+               return rseq_addv_relaxed_mm_cid(v, count, cpu);
+       default:
+               return -1;
+       }
+}
+
+#ifdef RSEQ_ARCH_HAS_OFFSET_DEREF_ADDV
+/*
+ *   pval = *(ptr+off)
+ *  *pval += inc;
+ */
+static inline __attribute__((always_inline))
+int rseq_offset_deref_addv(enum rseq_mo rseq_mo, enum rseq_percpu_mode percpu_mode,
+                          intptr_t *ptr, long off, intptr_t inc, int cpu)
+{
+       if (rseq_mo != RSEQ_MO_RELAXED)
+               return -1;
+       switch (percpu_mode) {
+       case RSEQ_PERCPU_CPU_ID:
+               return rseq_offset_deref_addv_relaxed_cpu_id(ptr, off, inc, cpu);
+       case RSEQ_PERCPU_MM_CID:
+               return rseq_offset_deref_addv_relaxed_mm_cid(ptr, off, inc, cpu);
+       default:
+               return -1;
+       }
+}
+#endif
+
+static inline __attribute__((always_inline))
+int rseq_cmpeqv_trystorev_storev(enum rseq_mo rseq_mo, enum rseq_percpu_mode percpu_mode,
+                                intptr_t *v, intptr_t expect,
+                                intptr_t *v2, intptr_t newv2,
+                                intptr_t newv, int cpu)
+{
+       switch (rseq_mo) {
+       case RSEQ_MO_RELAXED:
+               switch (percpu_mode) {
+               case RSEQ_PERCPU_CPU_ID:
+                       return rseq_cmpeqv_trystorev_storev_relaxed_cpu_id(v, expect, v2, newv2, newv, cpu);
+               case RSEQ_PERCPU_MM_CID:
+                       return rseq_cmpeqv_trystorev_storev_relaxed_mm_cid(v, expect, v2, newv2, newv, cpu);
+               default:
+                       return -1;
+               }
+       case RSEQ_MO_RELEASE:
+               switch (percpu_mode) {
+               case RSEQ_PERCPU_CPU_ID:
+                       return rseq_cmpeqv_trystorev_storev_release_cpu_id(v, expect, v2, newv2, newv, cpu);
+               case RSEQ_PERCPU_MM_CID:
+                       return rseq_cmpeqv_trystorev_storev_release_mm_cid(v, expect, v2, newv2, newv, cpu);
+               default:
+                       return -1;
+               }
+       case RSEQ_MO_ACQUIRE:   /* Fallthrough */
+       case RSEQ_MO_ACQ_REL:   /* Fallthrough */
+       case RSEQ_MO_CONSUME:   /* Fallthrough */
+       case RSEQ_MO_SEQ_CST:   /* Fallthrough */
+       default:
+               return -1;
+       }
+}
+
+static inline __attribute__((always_inline))
+int rseq_cmpeqv_cmpeqv_storev(enum rseq_mo rseq_mo, enum rseq_percpu_mode percpu_mode,
+                             intptr_t *v, intptr_t expect,
+                             intptr_t *v2, intptr_t expect2,
+                             intptr_t newv, int cpu)
+{
+       if (rseq_mo != RSEQ_MO_RELAXED)
+               return -1;
+       switch (percpu_mode) {
+       case RSEQ_PERCPU_CPU_ID:
+               return rseq_cmpeqv_cmpeqv_storev_relaxed_cpu_id(v, expect, v2, expect2, newv, cpu);
+       case RSEQ_PERCPU_MM_CID:
+               return rseq_cmpeqv_cmpeqv_storev_relaxed_mm_cid(v, expect, v2, expect2, newv, cpu);
+       default:
+               return -1;
+       }
+}
+
+static inline __attribute__((always_inline))
+int rseq_cmpeqv_trymemcpy_storev(enum rseq_mo rseq_mo, enum rseq_percpu_mode percpu_mode,
+                                intptr_t *v, intptr_t expect,
+                                void *dst, void *src, size_t len,
+                                intptr_t newv, int cpu)
+{
+       switch (rseq_mo) {
+       case RSEQ_MO_RELAXED:
+               switch (percpu_mode) {
+               case RSEQ_PERCPU_CPU_ID:
+                       return rseq_cmpeqv_trymemcpy_storev_relaxed_cpu_id(v, expect, dst, src, len, newv, cpu);
+               case RSEQ_PERCPU_MM_CID:
+                       return rseq_cmpeqv_trymemcpy_storev_relaxed_mm_cid(v, expect, dst, src, len, newv, cpu);
+               default:
+                       return -1;
+               }
+       case RSEQ_MO_RELEASE:
+               switch (percpu_mode) {
+               case RSEQ_PERCPU_CPU_ID:
+                       return rseq_cmpeqv_trymemcpy_storev_release_cpu_id(v, expect, dst, src, len, newv, cpu);
+               case RSEQ_PERCPU_MM_CID:
+                       return rseq_cmpeqv_trymemcpy_storev_release_mm_cid(v, expect, dst, src, len, newv, cpu);
+               default:
+                       return -1;
+               }
+       case RSEQ_MO_ACQUIRE:   /* Fallthrough */
+       case RSEQ_MO_ACQ_REL:   /* Fallthrough */
+       case RSEQ_MO_CONSUME:   /* Fallthrough */
+       case RSEQ_MO_SEQ_CST:   /* Fallthrough */
+       default:
+               return -1;
+       }
+}
+
 #ifdef __cplusplus
 }
 #endif