The open source OpenXR runtime
ipc: Add xrt_space support
+619
-4
+1
src/xrt/ipc/CMakeLists.txt
+1
src/xrt/ipc/CMakeLists.txt
+3
src/xrt/ipc/client/ipc_client.h
+3
src/xrt/ipc/client/ipc_client.h
+231
src/xrt/ipc/client/ipc_client_space_overseer.c
+231
src/xrt/ipc/client/ipc_client_space_overseer.c
···
1
+
// Copyright 2023, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
/*!
4
+
* @file
5
+
* @brief IPC Client space overseer.
6
+
* @author Jakob Bornecrantz <jakob@collabora.com>
7
+
* @ingroup ipc_client
8
+
*/
9
+
10
+
#include "xrt/xrt_space.h"
11
+
12
+
#include "ipc_client_generated.h"
13
+
14
+
15
+
struct ipc_client_space
16
+
{
17
+
struct xrt_space base;
18
+
19
+
struct ipc_connection *ipc_c;
20
+
21
+
uint32_t id;
22
+
};
23
+
24
+
struct ipc_client_space_overseer
25
+
{
26
+
struct xrt_space_overseer base;
27
+
28
+
struct ipc_connection *ipc_c;
29
+
};
30
+
31
+
32
+
/*
33
+
*
34
+
* Helpers
35
+
*
36
+
*/
37
+
38
+
static inline struct ipc_client_space *
39
+
ipc_client_space(struct xrt_space *xs)
40
+
{
41
+
return (struct ipc_client_space *)xs;
42
+
}
43
+
44
+
static inline struct ipc_client_space_overseer *
45
+
ipc_client_space_overseer(struct xrt_space_overseer *xso)
46
+
{
47
+
return (struct ipc_client_space_overseer *)xso;
48
+
}
49
+
50
+
51
+
/*
52
+
*
53
+
* Space member functions.
54
+
*
55
+
*/
56
+
57
+
static void
58
+
space_destroy(struct xrt_space *xs)
59
+
{
60
+
struct ipc_client_space *icsp = ipc_client_space(xs);
61
+
62
+
ipc_call_space_destroy(icsp->ipc_c, icsp->id);
63
+
64
+
free(xs);
65
+
}
66
+
67
+
static void
68
+
alloc_space_with_id(struct ipc_client_space_overseer *icspo, uint32_t id, struct xrt_space **out_space)
69
+
{
70
+
struct ipc_client_space *icsp = U_TYPED_CALLOC(struct ipc_client_space);
71
+
icsp->base.reference.count = 1;
72
+
icsp->base.destroy = space_destroy;
73
+
icsp->ipc_c = icspo->ipc_c;
74
+
icsp->id = id;
75
+
76
+
*out_space = &icsp->base;
77
+
}
78
+
79
+
80
+
/*
81
+
*
82
+
* Overseer member functions.
83
+
*
84
+
*/
85
+
86
+
static xrt_result_t
87
+
create_offset_space(struct xrt_space_overseer *xso,
88
+
struct xrt_space *parent,
89
+
const struct xrt_pose *offset,
90
+
struct xrt_space **out_space)
91
+
{
92
+
struct ipc_client_space_overseer *icspo = ipc_client_space_overseer(xso);
93
+
xrt_result_t xret;
94
+
uint32_t parent_id = ipc_client_space(parent)->id;
95
+
uint32_t id = 0;
96
+
97
+
xret = ipc_call_space_create_offset(icspo->ipc_c, parent_id, offset, &id);
98
+
if (xret != XRT_SUCCESS) {
99
+
return xret;
100
+
}
101
+
102
+
alloc_space_with_id(icspo, id, out_space);
103
+
104
+
return XRT_SUCCESS;
105
+
}
106
+
107
+
static xrt_result_t
108
+
create_pose_space(struct xrt_space_overseer *xso,
109
+
struct xrt_device *xdev,
110
+
enum xrt_input_name name,
111
+
struct xrt_space **out_space)
112
+
{
113
+
struct ipc_client_space_overseer *icspo = ipc_client_space_overseer(xso);
114
+
xrt_result_t xret;
115
+
uint32_t xdev_id = ipc_client_xdev(xdev)->device_id;
116
+
uint32_t id = 0;
117
+
118
+
xret = ipc_call_space_create_pose(icspo->ipc_c, xdev_id, name, &id);
119
+
if (xret != XRT_SUCCESS) {
120
+
return xret;
121
+
}
122
+
123
+
alloc_space_with_id(icspo, id, out_space);
124
+
125
+
return XRT_SUCCESS;
126
+
}
127
+
128
+
static xrt_result_t
129
+
locate_space(struct xrt_space_overseer *xso,
130
+
struct xrt_space *base_space,
131
+
const struct xrt_pose *base_offset,
132
+
uint64_t at_timestamp_ns,
133
+
struct xrt_space *space,
134
+
const struct xrt_pose *offset,
135
+
struct xrt_space_relation *out_relation)
136
+
{
137
+
struct ipc_client_space_overseer *icspo = ipc_client_space_overseer(xso);
138
+
139
+
struct ipc_client_space *icsp_base_space = ipc_client_space(base_space);
140
+
struct ipc_client_space *icsp_space = ipc_client_space(space);
141
+
142
+
return ipc_call_space_locate_space( //
143
+
icspo->ipc_c, //
144
+
icsp_base_space->id, //
145
+
base_offset, //
146
+
at_timestamp_ns, //
147
+
icsp_space->id, //
148
+
offset, //
149
+
out_relation); //
150
+
}
151
+
152
+
static xrt_result_t
153
+
locate_device(struct xrt_space_overseer *xso,
154
+
struct xrt_space *base_space,
155
+
const struct xrt_pose *base_offset,
156
+
uint64_t at_timestamp_ns,
157
+
struct xrt_device *xdev,
158
+
struct xrt_space_relation *out_relation)
159
+
{
160
+
struct ipc_client_space_overseer *icspo = ipc_client_space_overseer(xso);
161
+
162
+
struct ipc_client_space *icsp_base_space = ipc_client_space(base_space);
163
+
uint32_t xdev_id = ipc_client_xdev(xdev)->device_id;
164
+
165
+
return ipc_call_space_locate_device( //
166
+
icspo->ipc_c, //
167
+
icsp_base_space->id, //
168
+
base_offset, //
169
+
at_timestamp_ns, //
170
+
xdev_id, //
171
+
out_relation); //
172
+
}
173
+
174
+
static void
175
+
destroy(struct xrt_space_overseer *xso)
176
+
{
177
+
struct ipc_client_space_overseer *icspo = ipc_client_space_overseer(xso);
178
+
179
+
xrt_space_reference(&icspo->base.semantic.root, NULL);
180
+
xrt_space_reference(&icspo->base.semantic.view, NULL);
181
+
xrt_space_reference(&icspo->base.semantic.local, NULL);
182
+
xrt_space_reference(&icspo->base.semantic.stage, NULL);
183
+
xrt_space_reference(&icspo->base.semantic.unbounded, NULL);
184
+
185
+
free(icspo);
186
+
}
187
+
188
+
189
+
/*
190
+
*
191
+
* 'Exported' functions.
192
+
*
193
+
*/
194
+
195
+
struct xrt_space_overseer *
196
+
ipc_client_space_overseer_create(struct ipc_connection *ipc_c)
197
+
{
198
+
struct ipc_client_space_overseer *icspo = U_TYPED_CALLOC(struct ipc_client_space_overseer);
199
+
icspo->base.create_offset_space = create_offset_space;
200
+
icspo->base.create_pose_space = create_pose_space;
201
+
icspo->base.locate_space = locate_space;
202
+
icspo->base.locate_device = locate_device;
203
+
icspo->base.destroy = destroy;
204
+
icspo->ipc_c = ipc_c;
205
+
206
+
uint32_t root_id = UINT32_MAX;
207
+
uint32_t view_id = UINT32_MAX;
208
+
uint32_t local_id = UINT32_MAX;
209
+
uint32_t stage_id = UINT32_MAX;
210
+
uint32_t unbounded_id = UINT32_MAX;
211
+
212
+
ipc_call_space_create_semantic_ids(icspo->ipc_c, &root_id, &view_id, &local_id, &stage_id, &unbounded_id);
213
+
214
+
#define CREATE(NAME) \
215
+
do { \
216
+
if (NAME##_id == UINT32_MAX) { \
217
+
break; \
218
+
} \
219
+
alloc_space_with_id(icspo, NAME##_id, &icspo->base.semantic.NAME); \
220
+
} while (false)
221
+
222
+
CREATE(root);
223
+
CREATE(view);
224
+
CREATE(local);
225
+
CREATE(stage);
226
+
CREATE(unbounded);
227
+
228
+
#undef CREATE
229
+
230
+
return &icspo->base;
231
+
}
+20
-1
src/xrt/ipc/server/ipc_server.h
+20
-1
src/xrt/ipc/server/ipc_server.h
···
1
-
// Copyright 2020-2021, Collabora, Ltd.
1
+
// Copyright 2020-2023, Collabora, Ltd.
2
2
// SPDX-License-Identifier: BSL-1.0
3
3
/*!
4
4
* @file
···
13
13
14
14
#include "xrt/xrt_compiler.h"
15
15
#include "xrt/xrt_system.h"
16
+
#include "xrt/xrt_space.h"
16
17
17
18
#include "util/u_logging.h"
18
19
···
47
48
48
49
#define IPC_MAX_CLIENT_SEMAPHORES 8
49
50
#define IPC_MAX_CLIENT_SWAPCHAINS 32
51
+
#define IPC_MAX_CLIENT_SPACES 128
50
52
//#define IPC_MAX_CLIENTS 8
51
53
52
54
struct xrt_instance;
···
99
101
100
102
//! Ptrs to the semaphores.
101
103
struct xrt_compositor_semaphore *xcsems[IPC_MAX_CLIENT_SEMAPHORES];
104
+
105
+
struct
106
+
{
107
+
uint32_t root;
108
+
uint32_t local;
109
+
uint32_t stage;
110
+
uint32_t unbounded;
111
+
} semantic_spaces;
112
+
113
+
//! Number of spaces.
114
+
uint32_t space_count;
115
+
116
+
//! Ptrs to the spaces.
117
+
struct xtr_space *xspcs[IPC_MAX_CLIENT_SPACES];
102
118
103
119
//! Socket fd used for client comms
104
120
struct ipc_message_channel imc;
···
299
315
300
316
//! System devices.
301
317
struct xrt_system_devices *xsysd;
318
+
319
+
//! Space overseer.
320
+
struct xrt_space_overseer *xso;
302
321
303
322
//! System compositor.
304
323
struct xrt_system_compositor *xsysc;
+289
-1
src/xrt/ipc/server/ipc_server_handler.c
+289
-1
src/xrt/ipc/server/ipc_server_handler.c
···
1
-
// Copyright 2020-2021, Collabora, Ltd.
1
+
// Copyright 2020-2023, Collabora, Ltd.
2
2
// SPDX-License-Identifier: BSL-1.0
3
3
/*!
4
4
* @file
5
5
* @brief Handling functions called from generated dispatch function.
6
6
* @author Pete Black <pblack@collabora.com>
7
+
* @author Jakob Bornecrantz <jakob@collabora.com>
7
8
* @ingroup ipc_server
8
9
*/
9
10
···
26
27
*/
27
28
28
29
static xrt_result_t
30
+
validate_device_id(volatile struct ipc_client_state *ics, int64_t device_id, struct xrt_device **out_device)
31
+
{
32
+
if (device_id >= XRT_SYSTEM_MAX_DEVICES) {
33
+
IPC_ERROR(ics->server, "Invalid device ID (device_id >= XRT_SYSTEM_MAX_DEVICES)!");
34
+
return XRT_ERROR_IPC_FAILURE;
35
+
}
36
+
37
+
struct xrt_device *xdev = ics->server->idevs[device_id].xdev;
38
+
if (xdev == NULL) {
39
+
IPC_ERROR(ics->server, "Invalid device ID (xdev is NULL)!");
40
+
return XRT_ERROR_IPC_FAILURE;
41
+
}
42
+
43
+
*out_device = xdev;
44
+
45
+
return XRT_SUCCESS;
46
+
}
47
+
48
+
static xrt_result_t
29
49
validate_swapchain_state(volatile struct ipc_client_state *ics, uint32_t *out_index)
30
50
{
31
51
// Our handle is just the index for now.
···
60
80
ics->swapchain_data[index].image_count = xsc->image_count;
61
81
}
62
82
83
+
static xrt_result_t
84
+
validate_space_id(volatile struct ipc_client_state *ics, int64_t space_id, struct xrt_space **out_xspc)
85
+
{
86
+
if (space_id < 0) {
87
+
return XRT_ERROR_IPC_FAILURE;
88
+
}
89
+
90
+
if (space_id >= IPC_MAX_CLIENT_SPACES) {
91
+
return XRT_ERROR_IPC_FAILURE;
92
+
}
93
+
94
+
if (ics->xspcs[space_id] == NULL) {
95
+
return XRT_ERROR_IPC_FAILURE;
96
+
}
97
+
98
+
*out_xspc = (struct xrt_space *)ics->xspcs[space_id];
99
+
100
+
return XRT_SUCCESS;
101
+
}
102
+
103
+
static xrt_result_t
104
+
get_new_space_id(volatile struct ipc_client_state *ics, uint32_t *out_id)
105
+
{
106
+
// Our handle is just the index for now.
107
+
uint32_t index = 0;
108
+
for (; index < IPC_MAX_CLIENT_SPACES; index++) {
109
+
if (ics->xspcs[index] == NULL) {
110
+
break;
111
+
}
112
+
}
113
+
114
+
if (index >= IPC_MAX_CLIENT_SPACES) {
115
+
IPC_ERROR(ics->server, "Too many spaces!");
116
+
return XRT_ERROR_IPC_FAILURE;
117
+
}
118
+
119
+
*out_id = index;
120
+
121
+
return XRT_SUCCESS;
122
+
}
123
+
124
+
static xrt_result_t
125
+
track_space(volatile struct ipc_client_state *ics, struct xrt_space *xs, uint32_t *out_id)
126
+
{
127
+
uint32_t id = UINT32_MAX;
128
+
xrt_result_t xret = get_new_space_id(ics, &id);
129
+
if (xret != XRT_SUCCESS) {
130
+
return xret;
131
+
}
132
+
133
+
// Remove volatile
134
+
struct xrt_space **xs_ptr = (struct xrt_space **)&ics->xspcs[id];
135
+
xrt_space_reference(xs_ptr, xs);
136
+
137
+
*out_id = id;
138
+
139
+
return XRT_SUCCESS;
140
+
}
141
+
63
142
64
143
/*
65
144
*
···
159
238
}
160
239
161
240
ipc_server_client_destroy_compositor(ics);
241
+
242
+
return XRT_SUCCESS;
243
+
}
244
+
245
+
xrt_result_t
246
+
ipc_handle_space_create_semantic_ids(volatile struct ipc_client_state *ics,
247
+
uint32_t *out_root_id,
248
+
uint32_t *out_view_id,
249
+
uint32_t *out_local_id,
250
+
uint32_t *out_stage_id,
251
+
uint32_t *out_unbounded_id)
252
+
{
253
+
IPC_TRACE_MARKER();
254
+
255
+
struct xrt_space_overseer *xso = ics->server->xso;
256
+
257
+
#define CREATE(NAME) \
258
+
do { \
259
+
*out_##NAME##_id = UINT32_MAX; \
260
+
if (xso->semantic.NAME == NULL) { \
261
+
break; \
262
+
} \
263
+
uint32_t id = 0; \
264
+
xrt_result_t xret = track_space(ics, xso->semantic.NAME, &id); \
265
+
if (xret != XRT_SUCCESS) { \
266
+
break; \
267
+
} \
268
+
*out_##NAME##_id = id; \
269
+
} while (false)
270
+
271
+
CREATE(root);
272
+
CREATE(view);
273
+
CREATE(local);
274
+
CREATE(stage);
275
+
CREATE(unbounded);
276
+
277
+
#undef CREATE
278
+
279
+
return XRT_SUCCESS;
280
+
}
281
+
282
+
xrt_result_t
283
+
ipc_handle_space_create_offset(volatile struct ipc_client_state *ics,
284
+
uint32_t parent_id,
285
+
const struct xrt_pose *offset,
286
+
uint32_t *out_space_id)
287
+
{
288
+
IPC_TRACE_MARKER();
289
+
290
+
struct xrt_space_overseer *xso = ics->server->xso;
291
+
292
+
struct xrt_space *parent = NULL;
293
+
xrt_result_t xret = validate_space_id(ics, parent_id, &parent);
294
+
if (xret != XRT_SUCCESS) {
295
+
return xret;
296
+
}
297
+
298
+
299
+
struct xrt_space *xs = NULL;
300
+
xret = xrt_space_overseer_create_offset_space(xso, parent, offset, &xs);
301
+
if (xret != XRT_SUCCESS) {
302
+
return xret;
303
+
}
304
+
305
+
uint32_t space_id = UINT32_MAX;
306
+
xret = track_space(ics, xs, &space_id);
307
+
308
+
// Track space grabs a reference, or it errors and we don't want to keep it around.
309
+
xrt_space_reference(&xs, NULL);
310
+
311
+
if (xret != XRT_SUCCESS) {
312
+
return xret;
313
+
}
314
+
315
+
*out_space_id = space_id;
316
+
317
+
return XRT_SUCCESS;
318
+
}
319
+
320
+
xrt_result_t
321
+
ipc_handle_space_create_pose(volatile struct ipc_client_state *ics,
322
+
uint32_t xdev_id,
323
+
enum xrt_input_name name,
324
+
uint32_t *out_space_id)
325
+
{
326
+
IPC_TRACE_MARKER();
327
+
328
+
struct xrt_space_overseer *xso = ics->server->xso;
329
+
330
+
struct xrt_device *xdev = NULL;
331
+
xrt_result_t xret = validate_device_id(ics, xdev_id, &xdev);
332
+
if (xret != XRT_SUCCESS) {
333
+
U_LOG_E("Invalid device_id!");
334
+
return xret;
335
+
}
336
+
337
+
struct xrt_space *xs = NULL;
338
+
xret = xrt_space_overseer_create_pose_space(xso, xdev, name, &xs);
339
+
if (xret != XRT_SUCCESS) {
340
+
return xret;
341
+
}
342
+
343
+
uint32_t space_id = UINT32_MAX;
344
+
xret = track_space(ics, xs, &space_id);
345
+
346
+
// Track space grabs a reference, or it errors and we don't want to keep it around.
347
+
xrt_space_reference(&xs, NULL);
348
+
349
+
if (xret != XRT_SUCCESS) {
350
+
return xret;
351
+
}
352
+
353
+
*out_space_id = space_id;
354
+
355
+
return xret;
356
+
}
357
+
358
+
xrt_result_t
359
+
ipc_handle_space_locate_space(volatile struct ipc_client_state *ics,
360
+
uint32_t base_space_id,
361
+
const struct xrt_pose *base_offset,
362
+
uint64_t at_timestamp,
363
+
uint32_t space_id,
364
+
const struct xrt_pose *offset,
365
+
struct xrt_space_relation *out_relation)
366
+
{
367
+
IPC_TRACE_MARKER();
368
+
369
+
struct xrt_space_overseer *xso = ics->server->xso;
370
+
struct xrt_space *base_space = NULL;
371
+
struct xrt_space *space = NULL;
372
+
xrt_result_t xret;
373
+
374
+
xret = validate_space_id(ics, base_space_id, &base_space);
375
+
if (xret != XRT_SUCCESS) {
376
+
U_LOG_E("Invalid base_space_id!");
377
+
return xret;
378
+
}
379
+
380
+
xret = validate_space_id(ics, space_id, &space);
381
+
if (xret != XRT_SUCCESS) {
382
+
U_LOG_E("Invalid space_id!");
383
+
return xret;
384
+
}
385
+
386
+
return xrt_space_overseer_locate_space( //
387
+
xso, //
388
+
base_space, //
389
+
base_offset, //
390
+
at_timestamp, //
391
+
space, //
392
+
offset, //
393
+
out_relation); //
394
+
}
395
+
396
+
xrt_result_t
397
+
ipc_handle_space_locate_device(volatile struct ipc_client_state *ics,
398
+
uint32_t base_space_id,
399
+
const struct xrt_pose *base_offset,
400
+
uint64_t at_timestamp,
401
+
uint32_t xdev_id,
402
+
struct xrt_space_relation *out_relation)
403
+
{
404
+
IPC_TRACE_MARKER();
405
+
406
+
struct xrt_space_overseer *xso = ics->server->xso;
407
+
struct xrt_space *base_space = NULL;
408
+
struct xrt_device *xdev = NULL;
409
+
xrt_result_t xret;
410
+
411
+
xret = validate_space_id(ics, base_space_id, &base_space);
412
+
if (xret != XRT_SUCCESS) {
413
+
U_LOG_E("Invalid base_space_id!");
414
+
return xret;
415
+
}
416
+
417
+
xret = validate_device_id(ics, xdev_id, &xdev);
418
+
if (xret != XRT_SUCCESS) {
419
+
U_LOG_E("Invalid device_id!");
420
+
return xret;
421
+
}
422
+
423
+
return xrt_space_overseer_locate_device( //
424
+
xso, //
425
+
base_space, //
426
+
base_offset, //
427
+
at_timestamp, //
428
+
xdev, //
429
+
out_relation); //
430
+
}
431
+
432
+
xrt_result_t
433
+
ipc_handle_space_destroy(volatile struct ipc_client_state *ics, uint32_t space_id)
434
+
{
435
+
struct xrt_space *xs = NULL;
436
+
xrt_result_t xret;
437
+
438
+
xret = validate_space_id(ics, space_id, &xs);
439
+
if (xret != XRT_SUCCESS) {
440
+
U_LOG_E("Invalid space_id!");
441
+
return xret;
442
+
}
443
+
444
+
assert(xs != NULL);
445
+
xs = NULL;
446
+
447
+
// Remove volatile
448
+
struct xrt_space **xs_ptr = (struct xrt_space **)&ics->xspcs[space_id];
449
+
xrt_space_reference(xs_ptr, NULL);
162
450
163
451
return XRT_SUCCESS;
164
452
}
+12
src/xrt/ipc/server/ipc_server_per_client_thread.c
+12
src/xrt/ipc/server/ipc_server_per_client_thread.c
···
139
139
140
140
ipc_server_client_destroy_compositor(ics);
141
141
142
+
// Make sure undestroyed spaces are unreferenced
143
+
for (uint32_t i = 0; i < IPC_MAX_CLIENT_SPACES; i++) {
144
+
// Cast away volatile.
145
+
xrt_space_reference((struct xrt_space **)&ics->xspcs[i], NULL);
146
+
}
147
+
142
148
// Should we stop the server when a client disconnects?
143
149
if (ics->server->exit_on_disconnect) {
144
150
ics->server->running = false;
···
199
205
os_mutex_unlock(&ics->server->global_state.lock);
200
206
201
207
ipc_server_client_destroy_compositor(ics);
208
+
209
+
// Make sure undestroyed spaces are unreferenced
210
+
for (uint32_t i = 0; i < IPC_MAX_CLIENT_SPACES; i++) {
211
+
// Cast away volatile.
212
+
xrt_space_reference((struct xrt_space **)&ics->xspcs[i], NULL);
213
+
}
202
214
203
215
// Should we stop the server when a client disconnects?
204
216
if (ics->server->exit_on_disconnect) {