1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/*
* Copyright 2020 Google LLC
* SPDX-License-Identifier: MIT
*/
#ifndef VKR_CONTEXT_H
#define VKR_CONTEXT_H
#include "vkr_common.h"
#include "venus-protocol/vn_protocol_renderer_defines.h"
#include "virgl_context.h"
#include "vrend_iov.h"
#include "vkr_cs.h"
struct virgl_resource;
/*
* When a virgl_resource is attached in vkr_context_attach_resource, a
* vkr_resource_attachment is created. A vkr_resource_attachment is valid
* until the resource it tracks is detached.
*/
struct vkr_resource_attachment {
struct virgl_resource *resource;
/* if VIRGL_RESOURCE_FD_SHM, this is the mapping of the shm and iov below
* points to this
*/
struct iovec shm_iov;
const struct iovec *iov;
int iov_count;
};
enum vkr_context_validate_level {
/* no validation */
VKR_CONTEXT_VALIDATE_NONE,
/* force enabling a subset of the validation layer */
VKR_CONTEXT_VALIDATE_ON,
/* force enabling the validation layer */
VKR_CONTEXT_VALIDATE_FULL,
};
struct vkr_context {
struct virgl_context base;
char *debug_name;
enum vkr_context_validate_level validate_level;
bool validate_fatal;
mtx_t mutex;
struct list_head rings;
struct hash_table *object_table;
struct hash_table *resource_table;
struct vkr_cs_encoder encoder;
struct vkr_cs_decoder decoder;
struct vn_dispatch_context dispatch;
int fence_eventfd;
struct list_head busy_queues;
struct list_head signaled_syncs;
struct vkr_queue *sync_queues[64];
struct vkr_instance *instance;
char *instance_name;
};
void
vkr_context_free_resource(struct hash_entry *entry);
static inline void
vkr_context_add_resource(struct vkr_context *ctx, struct vkr_resource_attachment *att)
{
assert(!_mesa_hash_table_search(ctx->resource_table, &att->resource->res_id));
_mesa_hash_table_insert(ctx->resource_table, &att->resource->res_id, att);
}
static inline void
vkr_context_remove_resource(struct vkr_context *ctx, uint32_t res_id)
{
struct hash_entry *entry = _mesa_hash_table_search(ctx->resource_table, &res_id);
if (likely(entry)) {
vkr_context_free_resource(entry);
_mesa_hash_table_remove(ctx->resource_table, entry);
}
}
static inline struct vkr_resource_attachment *
vkr_context_get_resource(struct vkr_context *ctx, uint32_t res_id)
{
const struct hash_entry *entry = _mesa_hash_table_search(ctx->resource_table, &res_id);
return likely(entry) ? entry->data : NULL;
}
static inline bool
vkr_context_validate_object_id(struct vkr_context *ctx, vkr_object_id id)
{
if (unlikely(!id || _mesa_hash_table_search(ctx->object_table, &id))) {
vkr_log("invalid object id %" PRIu64, id);
vkr_cs_decoder_set_fatal(&ctx->decoder);
return false;
}
return true;
}
static inline void *
vkr_context_alloc_object(UNUSED struct vkr_context *ctx,
size_t size,
VkObjectType type,
const void *id_handle)
{
const vkr_object_id id = vkr_cs_handle_load_id((const void **)id_handle, type);
if (!vkr_context_validate_object_id(ctx, id))
return NULL;
return vkr_object_alloc(size, type, id);
}
void
vkr_context_free_object(struct hash_entry *entry);
static inline void
vkr_context_add_object(struct vkr_context *ctx, struct vkr_object *obj)
{
assert(vkr_is_recognized_object_type(obj->type));
assert(obj->id);
assert(!_mesa_hash_table_search(ctx->object_table, &obj->id));
_mesa_hash_table_insert(ctx->object_table, &obj->id, obj);
}
static inline void
vkr_context_remove_object(struct vkr_context *ctx, struct vkr_object *obj)
{
assert(_mesa_hash_table_search(ctx->object_table, &obj->id));
struct hash_entry *entry = _mesa_hash_table_search(ctx->object_table, &obj->id);
if (likely(entry)) {
vkr_context_free_object(entry);
_mesa_hash_table_remove(ctx->object_table, entry);
}
}
static inline void
vkr_context_remove_objects(struct vkr_context *ctx, struct list_head *objects)
{
struct vkr_object *obj, *tmp;
LIST_FOR_EACH_ENTRY_SAFE (obj, tmp, objects, track_head)
vkr_context_remove_object(ctx, obj);
/* objects should be reinitialized if to be reused */
}
static inline void *
vkr_context_get_object(struct vkr_context *ctx, vkr_object_id obj_id)
{
const struct hash_entry *entry = _mesa_hash_table_search(ctx->object_table, &obj_id);
return likely(entry) ? entry->data : NULL;
}
static inline const char *
vkr_context_get_name(const struct vkr_context *ctx)
{
/* ctx->instance_name is the application name while ctx->debug_name is
* usually the guest process name or the hypervisor name. This never
* returns NULL because ctx->debug_name is never NULL.
*/
return ctx->instance_name ? ctx->instance_name : ctx->debug_name;
}
void
vkr_context_add_instance(struct vkr_context *ctx,
struct vkr_instance *instance,
const char *name);
void
vkr_context_remove_instance(struct vkr_context *ctx, struct vkr_instance *instance);
#endif /* VKR_CONTEXT_H */
|
