Commit | Line | Data |
---|---|---|
a09e091a JB |
1 | /*********************************************************** |
2 | ||
3 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
4 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
5 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
6 | AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN | |
7 | AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
8 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
9 | ||
10 | ******************************************************************/ | |
11 | ||
12 | #ifndef PRIVATES_H | |
13 | #define PRIVATES_H 1 | |
14 | ||
15 | #include <X11/Xdefs.h> | |
16 | #include <X11/Xosdefs.h> | |
17 | #include <X11/Xfuncproto.h> | |
18 | #include "misc.h" | |
19 | ||
20 | /***************************************************************** | |
21 | * STUFF FOR PRIVATES | |
22 | *****************************************************************/ | |
23 | ||
24 | typedef struct _Private PrivateRec, *PrivatePtr; | |
25 | ||
26 | typedef enum { | |
27 | /* XSELinux uses the same private keys for numerous objects */ | |
28 | PRIVATE_XSELINUX, | |
29 | ||
30 | /* Otherwise, you get a private in just the requested structure | |
31 | */ | |
32 | /* These can have objects created before all of the keys are registered */ | |
33 | PRIVATE_SCREEN, | |
34 | PRIVATE_EXTENSION, | |
35 | PRIVATE_COLORMAP, | |
36 | PRIVATE_DEVICE, | |
37 | ||
38 | /* These cannot have any objects before all relevant keys are registered */ | |
39 | PRIVATE_CLIENT, | |
40 | PRIVATE_PROPERTY, | |
41 | PRIVATE_SELECTION, | |
42 | PRIVATE_WINDOW, | |
43 | PRIVATE_PIXMAP, | |
44 | PRIVATE_GC, | |
45 | PRIVATE_CURSOR, | |
46 | PRIVATE_CURSOR_BITS, | |
47 | ||
48 | /* extension privates */ | |
49 | PRIVATE_DAMAGE, | |
50 | PRIVATE_GLYPH, | |
51 | PRIVATE_GLYPHSET, | |
52 | PRIVATE_PICTURE, | |
53 | PRIVATE_SYNC_FENCE, | |
54 | ||
55 | /* last private type */ | |
56 | PRIVATE_LAST, | |
57 | } DevPrivateType; | |
58 | ||
59 | typedef struct _DevPrivateKeyRec { | |
60 | int offset; | |
61 | int size; | |
62 | Bool initialized; | |
63 | Bool allocated; | |
64 | DevPrivateType type; | |
65 | struct _DevPrivateKeyRec *next; | |
66 | } DevPrivateKeyRec, *DevPrivateKey; | |
67 | ||
68 | typedef struct _DevPrivateSetRec { | |
69 | DevPrivateKey key; | |
70 | unsigned offset; | |
71 | int created; | |
72 | int allocated; | |
73 | } DevPrivateSetRec, *DevPrivateSetPtr; | |
74 | ||
75 | typedef struct _DevScreenPrivateKeyRec { | |
76 | DevPrivateKeyRec screenKey; | |
77 | } DevScreenPrivateKeyRec, *DevScreenPrivateKey; | |
78 | ||
79 | /* | |
80 | * Let drivers know how to initialize private keys | |
81 | */ | |
82 | ||
83 | #define HAS_DEVPRIVATEKEYREC 1 | |
84 | #define HAS_DIXREGISTERPRIVATEKEY 1 | |
85 | ||
86 | /* | |
87 | * Register a new private index for the private type. | |
88 | * | |
89 | * This initializes the specified key and optionally requests pre-allocated | |
90 | * private space for your driver/module. If you request no extra space, you | |
91 | * may set and get a single pointer value using this private key. Otherwise, | |
92 | * you can get the address of the extra space and store whatever data you like | |
93 | * there. | |
94 | * | |
95 | * You may call dixRegisterPrivateKey more than once on the same key, but the | |
96 | * size and type must match or the server will abort. | |
97 | * | |
98 | * dixRegisterPrivateKey returns FALSE if it fails to allocate memory | |
99 | * during its operation. | |
100 | */ | |
101 | extern _X_EXPORT Bool | |
102 | dixRegisterPrivateKey(DevPrivateKey key, DevPrivateType type, unsigned size); | |
103 | ||
104 | /* | |
105 | * Check whether a private key has been registered | |
106 | */ | |
107 | static inline Bool | |
108 | dixPrivateKeyRegistered(DevPrivateKey key) | |
109 | { | |
110 | return key->initialized; | |
111 | } | |
112 | ||
113 | /* | |
114 | * Get the address of the private storage. | |
115 | * | |
116 | * For keys with pre-defined storage, this gets the base of that storage | |
117 | * Otherwise, it returns the place where the private pointer is stored. | |
118 | */ | |
119 | static inline void * | |
120 | dixGetPrivateAddr(PrivatePtr *privates, const DevPrivateKey key) | |
121 | { | |
122 | assert(key->initialized); | |
123 | return (char *) (*privates) + key->offset; | |
124 | } | |
125 | ||
126 | /* | |
127 | * Fetch a private pointer stored in the object | |
128 | * | |
129 | * Returns the pointer stored with dixSetPrivate. | |
130 | * This must only be used with keys that have | |
131 | * no pre-defined storage | |
132 | */ | |
133 | static inline void * | |
134 | dixGetPrivate(PrivatePtr *privates, const DevPrivateKey key) | |
135 | { | |
136 | assert(key->size == 0); | |
137 | return *(void **) dixGetPrivateAddr(privates, key); | |
138 | } | |
139 | ||
140 | /* | |
141 | * Associate 'val' with 'key' in 'privates' so that later calls to | |
142 | * dixLookupPrivate(privates, key) will return 'val'. | |
143 | */ | |
144 | static inline void | |
145 | dixSetPrivate(PrivatePtr *privates, const DevPrivateKey key, pointer val) | |
146 | { | |
147 | assert(key->size == 0); | |
148 | *(pointer *) dixGetPrivateAddr(privates, key) = val; | |
149 | } | |
150 | ||
151 | #include "dix.h" | |
152 | #include "resource.h" | |
153 | ||
154 | /* | |
155 | * Lookup a pointer to the private record. | |
156 | * | |
157 | * For privates with defined storage, return the address of the | |
158 | * storage. For privates without defined storage, return the pointer | |
159 | * contents | |
160 | */ | |
161 | static inline pointer | |
162 | dixLookupPrivate(PrivatePtr *privates, const DevPrivateKey key) | |
163 | { | |
164 | if (key->size) | |
165 | return dixGetPrivateAddr(privates, key); | |
166 | else | |
167 | return dixGetPrivate(privates, key); | |
168 | } | |
169 | ||
170 | /* | |
171 | * Look up the address of the pointer to the storage | |
172 | * | |
173 | * This returns the place where the private pointer is stored, | |
174 | * which is only valid for privates without predefined storage. | |
175 | */ | |
176 | static inline pointer * | |
177 | dixLookupPrivateAddr(PrivatePtr *privates, const DevPrivateKey key) | |
178 | { | |
179 | assert(key->size == 0); | |
180 | return (pointer *) dixGetPrivateAddr(privates, key); | |
181 | } | |
182 | ||
183 | extern _X_EXPORT Bool | |
184 | ||
185 | dixRegisterScreenPrivateKey(DevScreenPrivateKey key, ScreenPtr pScreen, | |
186 | DevPrivateType type, unsigned size); | |
187 | ||
188 | extern _X_EXPORT DevPrivateKey | |
189 | _dixGetScreenPrivateKey(const DevScreenPrivateKey key, ScreenPtr pScreen); | |
190 | ||
191 | static inline void * | |
192 | dixGetScreenPrivateAddr(PrivatePtr *privates, const DevScreenPrivateKey key, | |
193 | ScreenPtr pScreen) | |
194 | { | |
195 | return dixGetPrivateAddr(privates, _dixGetScreenPrivateKey(key, pScreen)); | |
196 | } | |
197 | ||
198 | static inline void * | |
199 | dixGetScreenPrivate(PrivatePtr *privates, const DevScreenPrivateKey key, | |
200 | ScreenPtr pScreen) | |
201 | { | |
202 | return dixGetPrivate(privates, _dixGetScreenPrivateKey(key, pScreen)); | |
203 | } | |
204 | ||
205 | static inline void | |
206 | dixSetScreenPrivate(PrivatePtr *privates, const DevScreenPrivateKey key, | |
207 | ScreenPtr pScreen, pointer val) | |
208 | { | |
209 | dixSetPrivate(privates, _dixGetScreenPrivateKey(key, pScreen), val); | |
210 | } | |
211 | ||
212 | static inline pointer | |
213 | dixLookupScreenPrivate(PrivatePtr *privates, const DevScreenPrivateKey key, | |
214 | ScreenPtr pScreen) | |
215 | { | |
216 | return dixLookupPrivate(privates, _dixGetScreenPrivateKey(key, pScreen)); | |
217 | } | |
218 | ||
219 | static inline pointer * | |
220 | dixLookupScreenPrivateAddr(PrivatePtr *privates, const DevScreenPrivateKey key, | |
221 | ScreenPtr pScreen) | |
222 | { | |
223 | return dixLookupPrivateAddr(privates, | |
224 | _dixGetScreenPrivateKey(key, pScreen)); | |
225 | } | |
226 | ||
227 | /* | |
228 | * These functions relate to allocations related to a specific screen; | |
229 | * space will only be available for objects allocated for use on that | |
230 | * screen. As such, only objects which are related directly to a specific | |
231 | * screen are candidates for allocation this way, this includes | |
232 | * windows, pixmaps, gcs, pictures and colormaps. This key is | |
233 | * used just like any other key using dixGetPrivate and friends. | |
234 | * | |
235 | * This is distinctly different from the ScreenPrivateKeys above which | |
236 | * allocate space in global objects like cursor bits for a specific | |
237 | * screen, allowing multiple screen-related chunks of storage in a | |
238 | * single global object. | |
239 | */ | |
240 | ||
241 | #define HAVE_SCREEN_SPECIFIC_PRIVATE_KEYS 1 | |
242 | ||
243 | extern _X_EXPORT Bool | |
244 | dixRegisterScreenSpecificPrivateKey(ScreenPtr pScreen, DevPrivateKey key, | |
245 | DevPrivateType type, unsigned size); | |
246 | ||
247 | /* Clean up screen-specific privates before CloseScreen */ | |
248 | extern void | |
249 | dixFreeScreenSpecificPrivates(ScreenPtr pScreen); | |
250 | ||
251 | /* Initialize screen-specific privates in AddScreen */ | |
252 | extern void | |
253 | dixInitScreenSpecificPrivates(ScreenPtr pScreen); | |
254 | ||
255 | extern _X_EXPORT void * | |
256 | _dixAllocateScreenObjectWithPrivates(ScreenPtr pScreen, | |
257 | unsigned size, | |
258 | unsigned clear, | |
259 | unsigned offset, | |
260 | DevPrivateType type); | |
261 | ||
262 | #define dixAllocateScreenObjectWithPrivates(s, t, type) _dixAllocateScreenObjectWithPrivates(s, sizeof(t), sizeof(t), offsetof(t, devPrivates), type) | |
263 | ||
264 | extern _X_EXPORT int | |
265 | dixScreenSpecificPrivatesSize(ScreenPtr pScreen, DevPrivateType type); | |
266 | ||
267 | extern _X_EXPORT void | |
268 | _dixInitScreenPrivates(ScreenPtr pScreen, PrivatePtr *privates, void *addr, DevPrivateType type); | |
269 | ||
270 | #define dixInitScreenPrivates(s, o, v, type) _dixInitScreenPrivates(s, &(o)->devPrivates, (v), type); | |
271 | ||
272 | /* | |
273 | * Allocates private data separately from main object. | |
274 | * | |
275 | * For objects created during server initialization, this allows those | |
276 | * privates to be re-allocated as new private keys are registered. | |
277 | * | |
278 | * This includes screens, the serverClient, default colormaps and | |
279 | * extensions entries. | |
280 | */ | |
281 | extern _X_EXPORT Bool | |
282 | dixAllocatePrivates(PrivatePtr *privates, DevPrivateType type); | |
283 | ||
284 | /* | |
285 | * Frees separately allocated private data | |
286 | */ | |
287 | extern _X_EXPORT void | |
288 | dixFreePrivates(PrivatePtr privates, DevPrivateType type); | |
289 | ||
290 | /* | |
291 | * Initialize privates by zeroing them | |
292 | */ | |
293 | extern _X_EXPORT void | |
294 | _dixInitPrivates(PrivatePtr *privates, void *addr, DevPrivateType type); | |
295 | ||
296 | #define dixInitPrivates(o, v, type) _dixInitPrivates(&(o)->devPrivates, (v), type); | |
297 | ||
298 | /* | |
299 | * Clean up privates | |
300 | */ | |
301 | extern _X_EXPORT void | |
302 | _dixFiniPrivates(PrivatePtr privates, DevPrivateType type); | |
303 | ||
304 | #define dixFiniPrivates(o,t) _dixFiniPrivates((o)->devPrivates,t) | |
305 | ||
306 | /* | |
307 | * Allocates private data at object creation time. Required | |
308 | * for almost all objects, except for the list described | |
309 | * above for dixAllocatePrivates. | |
310 | */ | |
311 | extern _X_EXPORT void *_dixAllocateObjectWithPrivates(unsigned size, | |
312 | unsigned clear, | |
313 | unsigned offset, | |
314 | DevPrivateType type); | |
315 | ||
316 | #define dixAllocateObjectWithPrivates(t, type) (t *) _dixAllocateObjectWithPrivates(sizeof(t), sizeof(t), offsetof(t, devPrivates), type) | |
317 | ||
318 | extern _X_EXPORT void | |
319 | ||
320 | _dixFreeObjectWithPrivates(void *object, PrivatePtr privates, | |
321 | DevPrivateType type); | |
322 | ||
323 | #define dixFreeObjectWithPrivates(o,t) _dixFreeObjectWithPrivates(o, (o)->devPrivates, t) | |
324 | ||
325 | /* | |
326 | * Return size of privates for the specified type | |
327 | */ | |
328 | extern _X_EXPORT int | |
329 | dixPrivatesSize(DevPrivateType type); | |
330 | ||
331 | /* | |
332 | * Dump out private stats to ErrorF | |
333 | */ | |
334 | extern void | |
335 | dixPrivateUsage(void); | |
336 | ||
337 | /* | |
338 | * Resets the privates subsystem. dixResetPrivates is called from the main loop | |
339 | * before each server generation. This function must only be called by main(). | |
340 | */ | |
341 | extern _X_EXPORT void | |
342 | dixResetPrivates(void); | |
343 | ||
344 | /* | |
345 | * Looks up the offset where the devPrivates field is located. | |
346 | * | |
347 | * Returns -1 if the specified resource has no dev privates. | |
348 | * The position of the devPrivates field varies by structure | |
349 | * and calling code might only know the resource type, not the | |
350 | * structure definition. | |
351 | */ | |
352 | extern _X_EXPORT int | |
353 | dixLookupPrivateOffset(RESTYPE type); | |
354 | ||
355 | /* | |
356 | * Convenience macro for adding an offset to an object pointer | |
357 | * when making a call to one of the devPrivates functions | |
358 | */ | |
359 | #define DEVPRIV_AT(ptr, offset) ((PrivatePtr *)((char *)(ptr) + offset)) | |
360 | ||
361 | #endif /* PRIVATES_H */ |