The open source OpenXR runtime
ipc: Fix headless sessions
+79
-33
+9
-11
src/xrt/ipc/client/ipc_client_compositor.c
+9
-11
src/xrt/ipc/client/ipc_client_compositor.c
···
808
808
809
809
assert(icc->compositor_created);
810
810
811
-
xret = ipc_call_session_destroy(icc->ipc_c);
812
-
813
-
/*
814
-
* We are probably in a really bad state if we fail, at
815
-
* least print out the error and continue as best we can.
816
-
*/
817
-
IPC_CHK_ONLY_PRINT(icc->ipc_c, xret, "ipc_call_session_destroy");
818
-
819
-
820
811
os_precise_sleeper_deinit(&icc->sleeper);
821
812
822
813
icc->compositor_created = false;
···
1018
1009
return XRT_ERROR_MULTI_SESSION_NOT_IMPLEMENTED;
1019
1010
}
1020
1011
1021
-
// Needs to be done before init.
1022
-
xret = ipc_call_session_create(icc->ipc_c, xsi);
1012
+
/*
1013
+
* Needs to be done before init, we don't own the service side session
1014
+
* the session does. But we create it here in case any extra arguments
1015
+
* that only the compositor knows about needs to be sent.
1016
+
*/
1017
+
xret = ipc_call_session_create( //
1018
+
icc->ipc_c, // ipc_c
1019
+
xsi, // xsi
1020
+
true); // create_native_compositor
1023
1021
IPC_CHK_AND_RET(icc->ipc_c, xret, "ipc_call_session_create");
1024
1022
1025
1023
// Needs to be done after session create call.
+13
src/xrt/ipc/client/ipc_client_session.c
+13
src/xrt/ipc/client/ipc_client_session.c
···
60
60
ipc_client_session_destroy(struct xrt_session *xs)
61
61
{
62
62
struct ipc_client_session *ics = ipc_session(xs);
63
+
xrt_result_t xret;
64
+
65
+
/*
66
+
* We own the session in both cases of headless or created with a
67
+
* native compositor, so we need to destroy it.
68
+
*/
69
+
xret = ipc_call_session_destroy(ics->ipc_c);
70
+
71
+
/*
72
+
* We are probably in a really bad state if we fail, at
73
+
* least print out the error and continue as best we can.
74
+
*/
75
+
IPC_CHK_ONLY_PRINT(ics->ipc_c, xret, "ipc_call_session_destroy");
63
76
64
77
free(ics);
65
78
}
+48
-20
src/xrt/ipc/client/ipc_client_system.c
+48
-20
src/xrt/ipc/client/ipc_client_system.c
···
42
42
return (struct ipc_client_system *)xsys;
43
43
}
44
44
45
+
static inline xrt_result_t
46
+
create_headless(struct ipc_client_system *icsys, const struct xrt_session_info *xsi, struct xrt_session **out_xs)
47
+
{
48
+
xrt_result_t xret = XRT_SUCCESS;
49
+
50
+
// We create the session ourselves.
51
+
xret = ipc_call_session_create( //
52
+
icsys->ipc_c, // ipc_c
53
+
xsi, // xsi
54
+
false); // create_native_compositor
55
+
IPC_CHK_AND_RET(icsys->ipc_c, xret, "ipc_call_session_create");
56
+
57
+
struct xrt_session *xs = ipc_client_session_create(icsys->ipc_c);
58
+
assert(xs != NULL);
59
+
60
+
*out_xs = xs;
61
+
62
+
return XRT_SUCCESS;
63
+
}
64
+
65
+
static inline xrt_result_t
66
+
create_with_comp(struct ipc_client_system *icsys,
67
+
const struct xrt_session_info *xsi,
68
+
struct xrt_session **out_xs,
69
+
struct xrt_compositor_native **out_xcn)
70
+
{
71
+
xrt_result_t xret = XRT_SUCCESS;
72
+
73
+
assert(icsys->xsysc != NULL);
74
+
75
+
// The native compositor creates the session.
76
+
xret = ipc_client_create_native_compositor( //
77
+
icsys->xsysc, //
78
+
xsi, //
79
+
out_xcn); //
80
+
IPC_CHK_AND_RET(icsys->ipc_c, xret, "ipc_client_create_native_compositor");
81
+
82
+
struct xrt_session *xs = ipc_client_session_create(icsys->ipc_c);
83
+
assert(xs != NULL);
84
+
85
+
*out_xs = xs;
86
+
87
+
return XRT_SUCCESS;
88
+
}
89
+
45
90
46
91
/*
47
92
*
···
56
101
struct xrt_compositor_native **out_xcn)
57
102
{
58
103
struct ipc_client_system *icsys = ipc_system(xsys);
59
-
xrt_result_t xret = XRT_SUCCESS;
60
104
61
105
if (out_xcn != NULL && icsys->xsysc == NULL) {
62
106
U_LOG_E("No system compositor in system, can't create native compositor.");
63
107
return XRT_ERROR_COMPOSITOR_NOT_SUPPORTED;
64
108
}
65
109
66
-
struct xrt_session *xs = ipc_client_session_create(icsys->ipc_c);
67
-
68
110
// Skip making a native compositor if not asked for.
69
111
if (out_xcn == NULL) {
70
-
goto out_session;
71
-
}
72
-
73
-
xret = ipc_client_create_native_compositor( //
74
-
icsys->xsysc, //
75
-
xsi, //
76
-
out_xcn); //
77
-
if (xret != XRT_SUCCESS) {
78
-
goto err;
112
+
return create_headless(icsys, xsi, out_xs);
113
+
} else {
114
+
return create_with_comp(icsys, xsi, out_xs, out_xcn);
79
115
}
80
-
81
-
out_session:
82
-
*out_xs = xs;
83
-
84
-
return XRT_SUCCESS;
85
-
86
-
err:
87
-
return xret;
88
116
}
89
117
90
118
static void
+7
-1
src/xrt/ipc/server/ipc_server_handler.c
+7
-1
src/xrt/ipc/server/ipc_server_handler.c
···
204
204
}
205
205
206
206
xrt_result_t
207
-
ipc_handle_session_create(volatile struct ipc_client_state *ics, const struct xrt_session_info *xsi)
207
+
ipc_handle_session_create(volatile struct ipc_client_state *ics,
208
+
const struct xrt_session_info *xsi,
209
+
bool create_native_compositor)
208
210
{
209
211
IPC_TRACE_MARKER();
210
212
···
213
215
214
216
if (ics->xs != NULL) {
215
217
return XRT_ERROR_IPC_SESSION_ALREADY_CREATED;
218
+
}
219
+
220
+
if (!create_native_compositor) {
221
+
IPC_INFO(ics->server, "App asked for headless session, creating native compositor anyways");
216
222
}
217
223
218
224
xrt_result_t xret = xrt_system_create_session(ics->server->xsys, xsi, &xs, &xcn);