[ceph.git] / ceph / src / pmdk / src / core / valgrind / pmemcheck.h

/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright 2014-2020, Intel Corporation */

#ifndef __PMEMCHECK_H
#define __PMEMCHECK_H


/* This file is for inclusion into client (your!) code.

   You can use these macros to manipulate and query memory permissions
   inside your own programs.

   See comment near the top of valgrind.h on how to use them.
*/

#include "valgrind.h"

/* !! ABIWARNING !! ABIWARNING !! ABIWARNING !! ABIWARNING !!
   This enum comprises an ABI exported by Valgrind to programs
   which use client requests.  DO NOT CHANGE THE ORDER OF THESE
   ENTRIES, NOR DELETE ANY -- add new ones at the end. */
typedef
   enum {
       VG_USERREQ__PMC_REGISTER_PMEM_MAPPING = VG_USERREQ_TOOL_BASE('P','C'),
       VG_USERREQ__PMC_REGISTER_PMEM_FILE,
       VG_USERREQ__PMC_REMOVE_PMEM_MAPPING,
       VG_USERREQ__PMC_CHECK_IS_PMEM_MAPPING,
       VG_USERREQ__PMC_PRINT_PMEM_MAPPINGS,
       VG_USERREQ__PMC_DO_FLUSH,
       VG_USERREQ__PMC_DO_FENCE,
       VG_USERREQ__PMC_RESERVED1,  /* Do not use. */
       VG_USERREQ__PMC_WRITE_STATS,
       VG_USERREQ__PMC_RESERVED2,  /* Do not use. */
       VG_USERREQ__PMC_RESERVED3,  /* Do not use. */
       VG_USERREQ__PMC_RESERVED4,  /* Do not use. */
       VG_USERREQ__PMC_RESERVED5,  /* Do not use. */
       VG_USERREQ__PMC_RESERVED7,  /* Do not use. */
       VG_USERREQ__PMC_RESERVED8,  /* Do not use. */
       VG_USERREQ__PMC_RESERVED9,  /* Do not use. */
       VG_USERREQ__PMC_RESERVED10, /* Do not use. */
       VG_USERREQ__PMC_SET_CLEAN,
       /* transaction support */
       VG_USERREQ__PMC_START_TX,
       VG_USERREQ__PMC_START_TX_N,
       VG_USERREQ__PMC_END_TX,
       VG_USERREQ__PMC_END_TX_N,
       VG_USERREQ__PMC_ADD_TO_TX,
       VG_USERREQ__PMC_ADD_TO_TX_N,
       VG_USERREQ__PMC_REMOVE_FROM_TX,
       VG_USERREQ__PMC_REMOVE_FROM_TX_N,
       VG_USERREQ__PMC_ADD_THREAD_TO_TX_N,
       VG_USERREQ__PMC_REMOVE_THREAD_FROM_TX_N,
       VG_USERREQ__PMC_ADD_TO_GLOBAL_TX_IGNORE,
       VG_USERREQ__PMC_RESERVED6,  /* Do not use. */
       VG_USERREQ__PMC_EMIT_LOG,
   } Vg_PMemCheckClientRequest;


/* Client-code macros to manipulate pmem mappings */

/** Register a persistent memory mapping region */
#define VALGRIND_PMC_REGISTER_PMEM_MAPPING(_qzz_addr, _qzz_len)             \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_REGISTER_PMEM_MAPPING,          \
                            (_qzz_addr), (_qzz_len), 0, 0, 0)

/** Register a persistent memory file */
#define VALGRIND_PMC_REGISTER_PMEM_FILE(_qzz_desc, _qzz_addr_base,          \
                                        _qzz_size, _qzz_offset)             \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_REGISTER_PMEM_FILE,             \
                            (_qzz_desc), (_qzz_addr_base), (_qzz_size),     \
                            (_qzz_offset), 0)

/** Remove a persistent memory mapping region */
#define VALGRIND_PMC_REMOVE_PMEM_MAPPING(_qzz_addr,_qzz_len)                \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_REMOVE_PMEM_MAPPING,            \
                            (_qzz_addr), (_qzz_len), 0, 0, 0)

/** Check if the given range is a registered persistent memory mapping */
#define VALGRIND_PMC_CHECK_IS_PMEM_MAPPING(_qzz_addr,_qzz_len)              \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_CHECK_IS_PMEM_MAPPING,          \
                            (_qzz_addr), (_qzz_len), 0, 0, 0)

/** Register an SFENCE */
#define VALGRIND_PMC_PRINT_PMEM_MAPPINGS                                    \
    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_PRINT_PMEM_MAPPINGS,    \
                                    0, 0, 0, 0, 0)

/** Register a CLFLUSH-like operation */
#define VALGRIND_PMC_DO_FLUSH(_qzz_addr,_qzz_len)                           \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_DO_FLUSH,                       \
                            (_qzz_addr), (_qzz_len), 0, 0, 0)

/** Register an SFENCE */
#define VALGRIND_PMC_DO_FENCE                                               \
    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_DO_FENCE,               \
                                    0, 0, 0, 0, 0)

/** Write tool stats */
#define VALGRIND_PMC_WRITE_STATS                                            \
    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_WRITE_STATS,            \
                                    0, 0, 0, 0, 0)

/** Emit user log */
#define VALGRIND_PMC_EMIT_LOG(_qzz_emit_log)                                \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_EMIT_LOG,                       \
                            (_qzz_emit_log), 0, 0, 0, 0)

/** Set a region of persistent memory as clean */
#define VALGRIND_PMC_SET_CLEAN(_qzz_addr,_qzz_len)                          \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_SET_CLEAN,                      \
                            (_qzz_addr), (_qzz_len), 0, 0, 0)

/** Support for transactions */

/** Start an implicit persistent memory transaction */
#define VALGRIND_PMC_START_TX                                               \
    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_START_TX,               \
                                    0, 0, 0, 0, 0)

/** Start an explicit persistent memory transaction */
#define VALGRIND_PMC_START_TX_N(_qzz_txn)                                   \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_START_TX_N,                     \
                            (_qzz_txn), 0, 0, 0, 0)

/** End an implicit persistent memory transaction */
#define VALGRIND_PMC_END_TX                                                 \
    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_END_TX,                 \
                                    0, 0, 0, 0, 0)

/** End an explicit persistent memory transaction */
#define VALGRIND_PMC_END_TX_N(_qzz_txn)                                     \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_END_TX_N,                       \
                            (_qzz_txn), 0, 0, 0, 0)

/** Add a persistent memory region to the implicit transaction */
#define VALGRIND_PMC_ADD_TO_TX(_qzz_addr,_qzz_len)                          \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_ADD_TO_TX,                      \
                            (_qzz_addr), (_qzz_len), 0, 0, 0)

/** Add a persistent memory region to an explicit transaction */
#define VALGRIND_PMC_ADD_TO_TX_N(_qzz_txn,_qzz_addr,_qzz_len)               \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_ADD_TO_TX_N,                    \
                            (_qzz_txn), (_qzz_addr), (_qzz_len), 0, 0)

/** Remove a persistent memory region from the implicit transaction */
#define VALGRIND_PMC_REMOVE_FROM_TX(_qzz_addr,_qzz_len)                     \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_REMOVE_FROM_TX,                 \
                            (_qzz_addr), (_qzz_len), 0, 0, 0)

/** Remove a persistent memory region from an explicit transaction */
#define VALGRIND_PMC_REMOVE_FROM_TX_N(_qzz_txn,_qzz_addr,_qzz_len)          \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_REMOVE_FROM_TX_N,               \
                            (_qzz_txn), (_qzz_addr), (_qzz_len), 0, 0)

/** End an explicit persistent memory transaction */
#define VALGRIND_PMC_ADD_THREAD_TX_N(_qzz_txn)                              \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_ADD_THREAD_TO_TX_N,             \
                            (_qzz_txn), 0, 0, 0, 0)

/** End an explicit persistent memory transaction */
#define VALGRIND_PMC_REMOVE_THREAD_FROM_TX_N(_qzz_txn)                      \
    VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */,                 \
                            VG_USERREQ__PMC_REMOVE_THREAD_FROM_TX_N,        \
                            (_qzz_txn), 0, 0, 0, 0)

/** Remove a persistent memory region from the implicit transaction */
#define VALGRIND_PMC_ADD_TO_GLOBAL_TX_IGNORE(_qzz_addr,_qzz_len)            \
    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_ADD_TO_GLOBAL_TX_IGNORE,\
                                    (_qzz_addr), (_qzz_len), 0, 0, 0)

#endif
Commit	Line	Data
a4b75251 TL	1	/* SPDX-License-Identifier: BSD-3-Clause */
	2	/* Copyright 2014-2020, Intel Corporation */
	3
	4	#ifndef __PMEMCHECK_H
	5	#define __PMEMCHECK_H
	6
	7
	8	/* This file is for inclusion into client (your!) code.
	9
	10	You can use these macros to manipulate and query memory permissions
	11	inside your own programs.
	12
	13	See comment near the top of valgrind.h on how to use them.
	14	*/
	15
	16	#include "valgrind.h"
	17
	18	/* !! ABIWARNING !! ABIWARNING !! ABIWARNING !! ABIWARNING !!
	19	This enum comprises an ABI exported by Valgrind to programs
	20	which use client requests. DO NOT CHANGE THE ORDER OF THESE
	21	ENTRIES, NOR DELETE ANY -- add new ones at the end. */
	22	typedef
	23	enum {
	24	VG_USERREQ__PMC_REGISTER_PMEM_MAPPING = VG_USERREQ_TOOL_BASE('P','C'),
	25	VG_USERREQ__PMC_REGISTER_PMEM_FILE,
	26	VG_USERREQ__PMC_REMOVE_PMEM_MAPPING,
	27	VG_USERREQ__PMC_CHECK_IS_PMEM_MAPPING,
	28	VG_USERREQ__PMC_PRINT_PMEM_MAPPINGS,
	29	VG_USERREQ__PMC_DO_FLUSH,
	30	VG_USERREQ__PMC_DO_FENCE,
	31	VG_USERREQ__PMC_RESERVED1, /* Do not use. */
	32	VG_USERREQ__PMC_WRITE_STATS,
	33	VG_USERREQ__PMC_RESERVED2, /* Do not use. */
	34	VG_USERREQ__PMC_RESERVED3, /* Do not use. */
	35	VG_USERREQ__PMC_RESERVED4, /* Do not use. */
	36	VG_USERREQ__PMC_RESERVED5, /* Do not use. */
	37	VG_USERREQ__PMC_RESERVED7, /* Do not use. */
	38	VG_USERREQ__PMC_RESERVED8, /* Do not use. */
	39	VG_USERREQ__PMC_RESERVED9, /* Do not use. */
	40	VG_USERREQ__PMC_RESERVED10, /* Do not use. */
	41	VG_USERREQ__PMC_SET_CLEAN,
	42	/* transaction support */
	43	VG_USERREQ__PMC_START_TX,
	44	VG_USERREQ__PMC_START_TX_N,
	45	VG_USERREQ__PMC_END_TX,
	46	VG_USERREQ__PMC_END_TX_N,
	47	VG_USERREQ__PMC_ADD_TO_TX,
	48	VG_USERREQ__PMC_ADD_TO_TX_N,
	49	VG_USERREQ__PMC_REMOVE_FROM_TX,
	50	VG_USERREQ__PMC_REMOVE_FROM_TX_N,
	51	VG_USERREQ__PMC_ADD_THREAD_TO_TX_N,
	52	VG_USERREQ__PMC_REMOVE_THREAD_FROM_TX_N,
	53	VG_USERREQ__PMC_ADD_TO_GLOBAL_TX_IGNORE,
	54	VG_USERREQ__PMC_RESERVED6, /* Do not use. */
	55	VG_USERREQ__PMC_EMIT_LOG,
	56	} Vg_PMemCheckClientRequest;
	57
	58
	59
	60	/* Client-code macros to manipulate pmem mappings */
	61
	62	/** Register a persistent memory mapping region */
	63	#define VALGRIND_PMC_REGISTER_PMEM_MAPPING(_qzz_addr, _qzz_len) \
	64	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
65	VG_USERREQ__PMC_REGISTER_PMEM_MAPPING, \
66	(_qzz_addr), (_qzz_len), 0, 0, 0)
67
68	/** Register a persistent memory file */
69	#define VALGRIND_PMC_REGISTER_PMEM_FILE(_qzz_desc, _qzz_addr_base, \
70	_qzz_size, _qzz_offset) \
71	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
72	VG_USERREQ__PMC_REGISTER_PMEM_FILE, \
73	(_qzz_desc), (_qzz_addr_base), (_qzz_size), \
74	(_qzz_offset), 0)
75
76	/** Remove a persistent memory mapping region */
77	#define VALGRIND_PMC_REMOVE_PMEM_MAPPING(_qzz_addr,_qzz_len) \
78	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
79	VG_USERREQ__PMC_REMOVE_PMEM_MAPPING, \
80	(_qzz_addr), (_qzz_len), 0, 0, 0)
81
82	/** Check if the given range is a registered persistent memory mapping */
83	#define VALGRIND_PMC_CHECK_IS_PMEM_MAPPING(_qzz_addr,_qzz_len) \
84	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
85	VG_USERREQ__PMC_CHECK_IS_PMEM_MAPPING, \
86	(_qzz_addr), (_qzz_len), 0, 0, 0)
87
88	/** Register an SFENCE */
89	#define VALGRIND_PMC_PRINT_PMEM_MAPPINGS \
90	VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_PRINT_PMEM_MAPPINGS, \
91	0, 0, 0, 0, 0)
92
93	/** Register a CLFLUSH-like operation */
94	#define VALGRIND_PMC_DO_FLUSH(_qzz_addr,_qzz_len) \
95	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
96	VG_USERREQ__PMC_DO_FLUSH, \
97	(_qzz_addr), (_qzz_len), 0, 0, 0)
98
99	/** Register an SFENCE */
100	#define VALGRIND_PMC_DO_FENCE \
101	VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_DO_FENCE, \
102	0, 0, 0, 0, 0)
103
104	/** Write tool stats */
105	#define VALGRIND_PMC_WRITE_STATS \
106	VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_WRITE_STATS, \
107	0, 0, 0, 0, 0)
108
109	/** Emit user log */
110	#define VALGRIND_PMC_EMIT_LOG(_qzz_emit_log) \
111	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
112	VG_USERREQ__PMC_EMIT_LOG, \
113	(_qzz_emit_log), 0, 0, 0, 0)
114
115	/** Set a region of persistent memory as clean */
116	#define VALGRIND_PMC_SET_CLEAN(_qzz_addr,_qzz_len) \
117	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
118	VG_USERREQ__PMC_SET_CLEAN, \
119	(_qzz_addr), (_qzz_len), 0, 0, 0)
120
121	/** Support for transactions */
122
123	/** Start an implicit persistent memory transaction */
124	#define VALGRIND_PMC_START_TX \
125	VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_START_TX, \
126	0, 0, 0, 0, 0)
127
128	/** Start an explicit persistent memory transaction */
129	#define VALGRIND_PMC_START_TX_N(_qzz_txn) \
130	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
131	VG_USERREQ__PMC_START_TX_N, \
132	(_qzz_txn), 0, 0, 0, 0)
133
134	/** End an implicit persistent memory transaction */
135	#define VALGRIND_PMC_END_TX \
136	VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_END_TX, \
137	0, 0, 0, 0, 0)
138
139	/** End an explicit persistent memory transaction */
140	#define VALGRIND_PMC_END_TX_N(_qzz_txn) \
141	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
142	VG_USERREQ__PMC_END_TX_N, \
143	(_qzz_txn), 0, 0, 0, 0)
144
145	/** Add a persistent memory region to the implicit transaction */
146	#define VALGRIND_PMC_ADD_TO_TX(_qzz_addr,_qzz_len) \
147	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
148	VG_USERREQ__PMC_ADD_TO_TX, \
149	(_qzz_addr), (_qzz_len), 0, 0, 0)
150
151	/** Add a persistent memory region to an explicit transaction */
152	#define VALGRIND_PMC_ADD_TO_TX_N(_qzz_txn,_qzz_addr,_qzz_len) \
153	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
154	VG_USERREQ__PMC_ADD_TO_TX_N, \
155	(_qzz_txn), (_qzz_addr), (_qzz_len), 0, 0)
156
157	/** Remove a persistent memory region from the implicit transaction */
158	#define VALGRIND_PMC_REMOVE_FROM_TX(_qzz_addr,_qzz_len) \
159	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
160	VG_USERREQ__PMC_REMOVE_FROM_TX, \
161	(_qzz_addr), (_qzz_len), 0, 0, 0)
162
163	/** Remove a persistent memory region from an explicit transaction */
164	#define VALGRIND_PMC_REMOVE_FROM_TX_N(_qzz_txn,_qzz_addr,_qzz_len) \
165	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
166	VG_USERREQ__PMC_REMOVE_FROM_TX_N, \
167	(_qzz_txn), (_qzz_addr), (_qzz_len), 0, 0)
168
169	/** End an explicit persistent memory transaction */
170	#define VALGRIND_PMC_ADD_THREAD_TX_N(_qzz_txn) \
171	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
172	VG_USERREQ__PMC_ADD_THREAD_TO_TX_N, \
173	(_qzz_txn), 0, 0, 0, 0)
174
175	/** End an explicit persistent memory transaction */
176	#define VALGRIND_PMC_REMOVE_THREAD_FROM_TX_N(_qzz_txn) \
177	VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
178	VG_USERREQ__PMC_REMOVE_THREAD_FROM_TX_N, \
179	(_qzz_txn), 0, 0, 0, 0)
180
181	/** Remove a persistent memory region from the implicit transaction */
182	#define VALGRIND_PMC_ADD_TO_GLOBAL_TX_IGNORE(_qzz_addr,_qzz_len) \
183	VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PMC_ADD_TO_GLOBAL_TX_IGNORE,\
184	(_qzz_addr), (_qzz_len), 0, 0, 0)
185
186	#endif