Page MenuHomeFreeBSD
Files F157567333

D23912.id69041.diff
No OneTemporary
Actions

D23912.id69041.diff
View Options

Index: sys/sys/_smr.h
===================================================================
--- sys/sys/_smr.h
+++ sys/sys/_smr.h
@@ -35,4 +35,110 @@
typedef int32_t smr_delta_t;
typedef struct smr *smr_t;
+#define SMR_ENTERED(smr) \
+ (curthread->td_critnest != 0 && zpcpu_get((smr))->c_seq != SMR_SEQ_INVALID)
+
+#define SMR_ASSERT_ENTERED(smr) \
+ KASSERT(SMR_ENTERED(smr), ("Not in smr section"))
+
+#define SMR_ASSERT_NOT_ENTERED(smr) \
+ KASSERT(!SMR_ENTERED(smr), ("In smr section."));
+
+#define SMR_ASSERT(ex, fn) \
+ KASSERT((ex), (fn ": Assertion " #ex " failed at %s:%d", __FILE__, __LINE__))
+
+/* Type restricting pointer access to force smr accessors. */
+#define SMR_TYPE_DECLARE(smrtype, type) \
+typedef struct { \
+ type __ptr; /* Do not access directly */ \
+} smrtype
+
+/*
+ * SMR Accessors are meant to provide safe access to SMR protected
+ * pointers and prevent misuse and accidental access.
+ *
+ * Accessors are grouped by type:
+ * entered - Use while in a read section (between smr_enter/smr_exit())
+ * serialized - Use while holding a lock that serializes writers. Updates
+ * are synchronized with readers via included barriers.
+ * unserialized - Use after the memory is out of scope and not visible to
+ * readers.
+ *
+ * All acceses include a parameter for an assert to verify the required
+ * synchronization. For example, a writer might use:
+ *
+ * smr_serialized_store(pointer, value, mtx_owned(&writelock));
+ *
+ * These are only enabled in INVARIANTS kernels.
+ */
+
+/*
+ * Read from an SMR protected pointer while in a read section.
+ */
+#define smr_entered_load(p, smr) ({ \
+ SMR_ASSERT(SMR_ENTERED((smr)), "smr_entered_load"); \
+ (__typeof((p)->__ptr))atomic_load_acq_ptr((uintptr_t *)&(p)->__ptr); \
+})
+
+/*
+ * Read from an SMR protected pointer while serialized by an
+ * external mechanism. 'ex' should contain an assert that the
+ * external mechanism is held. i.e. mtx_owned()
+ */
+#define smr_serialized_load(p, ex) ({ \
+ SMR_ASSERT(ex, "smr_serialized_load"); \
+ (__typeof((p)->__ptr))atomic_load_ptr(&(p)->__ptr); \
+})
+
+/*
+ * Store 'v' to an SMR protected pointer while serialized by an
+ * external mechanism. 'ex' should contain an assert that the
+ * external mechanism is held. i.e. mtx_owned()
+ *
+ * Writers that are serialized with mutual exclusion or on a single
+ * thread should use smr_serialized_store() rather than swap.
+ */
+#define smr_serialized_store(p, v, ex) do { \
+ SMR_ASSERT(ex, "smr_serialized_store"); \
+ __typeof((p)->__ptr) _v = (v); \
+ atomic_store_rel_ptr((uintptr_t *)&(p)->__ptr, (uintptr_t)_v); \
+} while (0)
+
+/*
+ * swap 'v' with an SMR protected pointer and return the old value
+ * while serialized by an external mechanism. 'ex' should contain
+ * an assert that the external mechanism is provided. i.e. mtx_owned()
+ *
+ * Swap permits multiple writers to update a pointer concurrently.
+ */
+#define smr_serialized_swap(p, v, ex) ({ \
+ SMR_ASSERT(ex, "smr_serialized_swap"); \
+ __typeof((p)->__ptr) _v = (v); \
+ /* Release barrier guarantees contents are visible to reader */ \
+ atomic_thread_fence_rel(); \
+ (__typeof((p)->__ptr))atomic_swap_ptr( \
+ (uintptr_t *)&(p)->__ptr, (uintptr_t)_v); \
+})
+
+/*
+ * Read from an SMR protected pointer when no serialization is required
+ * such as in the destructor callback or when the caller guarantees other
+ * synchronization.
+ */
+#define smr_unserialized_load(p, ex) ({ \
+ SMR_ASSERT(ex, "smr_unserialized_load"); \
+ (__typeof((p)->__ptr))atomic_load_ptr(&(p)->__ptr); \
+})
+
+/*
+ * Store to an SMR protected pointer when no serialiation is required
+ * such as in the destructor callback or when the caller guarantees other
+ * synchronization.
+ */
+#define smr_unserialized_store(p, v, ex) do { \
+ SMR_ASSERT(ex, "smr_unserialized_store"); \
+ __typeof((p)->__ptr) _v = (v); \
+ atomic_store_ptr((uintptr_t *)&(p)->__ptr, (uintptr_t)_v); \
+} while (0)
+
#endif /* __SYS_SMR_H_ */
Index: sys/sys/smr.h
===================================================================
--- sys/sys/smr.h
+++ sys/sys/smr.h
@@ -82,111 +82,9 @@
#define SMR_LAZY 0x0001 /* Higher latency write, fast read. */
#define SMR_DEFERRED 0x0002 /* Aggregate updates to wr_seq. */
-#define SMR_ENTERED(smr) \
- (curthread->td_critnest != 0 && zpcpu_get((smr))->c_seq != SMR_SEQ_INVALID)
-
-#define SMR_ASSERT_ENTERED(smr) \
- KASSERT(SMR_ENTERED(smr), ("Not in smr section"))
-
-#define SMR_ASSERT_NOT_ENTERED(smr) \
- KASSERT(!SMR_ENTERED(smr), ("In smr section."));
-
-#define SMR_ASSERT(ex, fn) \
- KASSERT((ex), (fn ": Assertion " #ex " failed at %s:%d", __FILE__, __LINE__))
-
-/*
- * SMR Accessors are meant to provide safe access to SMR protected
- * pointers and prevent misuse and accidental access.
- *
- * Accessors are grouped by type:
- * entered - Use while in a read section (between smr_enter/smr_exit())
- * serialized - Use while holding a lock that serializes writers. Updates
- * are synchronized with readers via included barriers.
- * unserialized - Use after the memory is out of scope and not visible to
- * readers.
- *
- * All acceses include a parameter for an assert to verify the required
- * synchronization. For example, a writer might use:
- *
- * smr_serialized_store(pointer, value, mtx_owned(&writelock));
- *
- * These are only enabled in INVARIANTS kernels.
- */
-
-/* Type restricting pointer access to force smr accessors. */
-#define SMR_TYPE_DECLARE(smrtype, type) \
-typedef struct { \
- type __ptr; /* Do not access directly */ \
-} smrtype
-
-/*
- * Read from an SMR protected pointer while in a read section.
- */
-#define smr_entered_load(p, smr) ({ \
- SMR_ASSERT(SMR_ENTERED((smr)), "smr_entered_load"); \
- (__typeof((p)->__ptr))atomic_load_acq_ptr((uintptr_t *)&(p)->__ptr); \
-})
-
-/*
- * Read from an SMR protected pointer while serialized by an
- * external mechanism. 'ex' should contain an assert that the
- * external mechanism is held. i.e. mtx_owned()
- */
-#define smr_serialized_load(p, ex) ({ \
- SMR_ASSERT(ex, "smr_serialized_load"); \
- (__typeof((p)->__ptr))atomic_load_ptr(&(p)->__ptr); \
-})
-
-/*
- * Store 'v' to an SMR protected pointer while serialized by an
- * external mechanism. 'ex' should contain an assert that the
- * external mechanism is held. i.e. mtx_owned()
- *
- * Writers that are serialized with mutual exclusion or on a single
- * thread should use smr_serialized_store() rather than swap.
- */
-#define smr_serialized_store(p, v, ex) do { \
- SMR_ASSERT(ex, "smr_serialized_store"); \
- __typeof((p)->__ptr) _v = (v); \
- atomic_store_rel_ptr((uintptr_t *)&(p)->__ptr, (uintptr_t)_v); \
-} while (0)
-
-/*
- * swap 'v' with an SMR protected pointer and return the old value
- * while serialized by an external mechanism. 'ex' should contain
- * an assert that the external mechanism is provided. i.e. mtx_owned()
- *
- * Swap permits multiple writers to update a pointer concurrently.
- */
-#define smr_serialized_swap(p, v, ex) ({ \
- SMR_ASSERT(ex, "smr_serialized_swap"); \
- __typeof((p)->__ptr) _v = (v); \
- /* Release barrier guarantees contents are visible to reader */ \
- atomic_thread_fence_rel(); \
- (__typeof((p)->__ptr))atomic_swap_ptr( \
- (uintptr_t *)&(p)->__ptr, (uintptr_t)_v); \
-})
-
-/*
- * Read from an SMR protected pointer when no serialization is required
- * such as in the destructor callback or when the caller guarantees other
- * synchronization.
- */
-#define smr_unserialized_load(p, ex) ({ \
- SMR_ASSERT(ex, "smr_unserialized_load"); \
- (__typeof((p)->__ptr))atomic_load_ptr(&(p)->__ptr); \
-})
-
/*
- * Store to an SMR protected pointer when no serialiation is required
- * such as in the destructor callback or when the caller guarantees other
- * synchronization.
+ * This API provides accessors for safe use. See sys/_smr.h.
*/
-#define smr_unserialized_store(p, v, ex) do { \
- SMR_ASSERT(ex, "smr_unserialized_store"); \
- __typeof((p)->__ptr) _v = (v); \
- atomic_store_ptr((uintptr_t *)&(p)->__ptr, (uintptr_t)_v); \
-} while (0)
/*
* Return the current write sequence number. This is not the same as the

File Metadata

Mime Type
text/plain
Expires
Sat, May 23, 10:13 PM (19 h, 10 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
33439315
Default Alt Text
D23912.id69041.diff (8 KB)

Event Timeline