]>
Commit | Line | Data |
---|---|---|
6095868a CW |
1 | /* |
2 | * Copyright © 2016 Intel Corporation | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining a | |
5 | * copy of this software and associated documentation files (the "Software"), | |
6 | * to deal in the Software without restriction, including without limitation | |
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
8 | * and/or sell copies of the Software, and to permit persons to whom the | |
9 | * Software is furnished to do so, subject to the following conditions: | |
10 | * | |
11 | * The above copyright notice and this permission notice (including the next | |
12 | * paragraph) shall be included in all copies or substantial portions of the | |
13 | * Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | |
21 | * IN THE SOFTWARE. | |
22 | * | |
23 | */ | |
24 | ||
25 | #ifndef __I915_GEM_CONTEXT_H__ | |
26 | #define __I915_GEM_CONTEXT_H__ | |
27 | ||
28 | #include <linux/bitops.h> | |
29 | #include <linux/list.h> | |
30 | ||
31 | struct pid; | |
32 | ||
33 | struct drm_device; | |
34 | struct drm_file; | |
35 | ||
36 | struct drm_i915_private; | |
37 | struct drm_i915_file_private; | |
38 | struct i915_hw_ppgtt; | |
39 | struct i915_vma; | |
40 | struct intel_ring; | |
41 | ||
42 | #define DEFAULT_CONTEXT_HANDLE 0 | |
43 | ||
44 | /** | |
45 | * struct i915_gem_context - client state | |
46 | * | |
47 | * The struct i915_gem_context represents the combined view of the driver and | |
48 | * logical hardware state for a particular client. | |
49 | */ | |
50 | struct i915_gem_context { | |
51 | /** i915: i915 device backpointer */ | |
52 | struct drm_i915_private *i915; | |
53 | ||
54 | /** file_priv: owning file descriptor */ | |
55 | struct drm_i915_file_private *file_priv; | |
56 | ||
57 | /** | |
58 | * @ppgtt: unique address space (GTT) | |
59 | * | |
60 | * In full-ppgtt mode, each context has its own address space ensuring | |
61 | * complete seperation of one client from all others. | |
62 | * | |
63 | * In other modes, this is a NULL pointer with the expectation that | |
64 | * the caller uses the shared global GTT. | |
65 | */ | |
66 | struct i915_hw_ppgtt *ppgtt; | |
67 | ||
68 | /** | |
69 | * @pid: process id of creator | |
70 | * | |
71 | * Note that who created the context may not be the principle user, | |
72 | * as the context may be shared across a local socket. However, | |
73 | * that should only affect the default context, all contexts created | |
74 | * explicitly by the client are expected to be isolated. | |
75 | */ | |
76 | struct pid *pid; | |
77 | ||
78 | /** | |
79 | * @name: arbitrary name | |
80 | * | |
81 | * A name is constructed for the context from the creator's process | |
82 | * name, pid and user handle in order to uniquely identify the | |
83 | * context in messages. | |
84 | */ | |
85 | const char *name; | |
86 | ||
87 | /** link: place with &drm_i915_private.context_list */ | |
88 | struct list_head link; | |
89 | ||
90 | /** | |
91 | * @ref: reference count | |
92 | * | |
93 | * A reference to a context is held by both the client who created it | |
94 | * and on each request submitted to the hardware using the request | |
95 | * (to ensure the hardware has access to the state until it has | |
96 | * finished all pending writes). See i915_gem_context_get() and | |
97 | * i915_gem_context_put() for access. | |
98 | */ | |
99 | struct kref ref; | |
100 | ||
101 | /** | |
102 | * @flags: small set of booleans | |
103 | */ | |
104 | unsigned long flags; | |
105 | #define CONTEXT_NO_ZEROMAP BIT(0) | |
106 | #define CONTEXT_NO_ERROR_CAPTURE 1 | |
107 | #define CONTEXT_CLOSED 2 | |
108 | #define CONTEXT_BANNABLE 3 | |
109 | #define CONTEXT_BANNED 4 | |
110 | #define CONTEXT_FORCE_SINGLE_SUBMISSION 5 | |
111 | ||
112 | /** | |
113 | * @hw_id: - unique identifier for the context | |
114 | * | |
115 | * The hardware needs to uniquely identify the context for a few | |
116 | * functions like fault reporting, PASID, scheduling. The | |
117 | * &drm_i915_private.context_hw_ida is used to assign a unqiue | |
118 | * id for the lifetime of the context. | |
119 | */ | |
120 | unsigned int hw_id; | |
121 | ||
122 | /** | |
123 | * @user_handle: userspace identifier | |
124 | * | |
125 | * A unique per-file identifier is generated from | |
126 | * &drm_i915_file_private.contexts. | |
127 | */ | |
128 | u32 user_handle; | |
129 | ||
130 | /** | |
131 | * @priority: execution and service priority | |
132 | * | |
133 | * All clients are equal, but some are more equal than others! | |
134 | * | |
135 | * Requests from a context with a greater (more positive) value of | |
136 | * @priority will be executed before those with a lower @priority | |
137 | * value, forming a simple QoS. | |
138 | * | |
139 | * The &drm_i915_private.kernel_context is assigned the lowest priority. | |
140 | */ | |
141 | int priority; | |
142 | ||
6095868a CW |
143 | /** ggtt_offset_bias: placement restriction for context objects */ |
144 | u32 ggtt_offset_bias; | |
145 | ||
4ff4b44c CW |
146 | struct i915_gem_context_vma_lut { |
147 | /** ht_size: last request size to allocate the hashtable for. */ | |
148 | unsigned int ht_size; | |
149 | #define I915_CTX_RESIZE_IN_PROGRESS BIT(0) | |
150 | /** ht_bits: real log2(size) of hashtable. */ | |
151 | unsigned int ht_bits; | |
152 | /** ht_count: current number of entries inside the hashtable */ | |
153 | unsigned int ht_count; | |
154 | ||
155 | /** ht: the array of buckets comprising the simple hashtable */ | |
156 | struct hlist_head *ht; | |
157 | ||
158 | /** | |
159 | * resize: After an execbuf completes, we check the load factor | |
160 | * of the hashtable. If the hashtable is too full, or too empty, | |
161 | * we schedule a task to resize the hashtable. During the | |
162 | * resize, the entries are moved between different buckets and | |
163 | * so we cannot simultaneously read the hashtable as it is | |
164 | * being resized (unlike rhashtable). Therefore we treat the | |
165 | * active work as a strong barrier, pausing a subsequent | |
166 | * execbuf to wait for the resize worker to complete, if | |
167 | * required. | |
168 | */ | |
169 | struct work_struct resize; | |
170 | } vma_lut; | |
171 | ||
6095868a CW |
172 | /** engine: per-engine logical HW state */ |
173 | struct intel_context { | |
174 | struct i915_vma *state; | |
175 | struct intel_ring *ring; | |
176 | u32 *lrc_reg_state; | |
177 | u64 lrc_desc; | |
178 | int pin_count; | |
179 | bool initialised; | |
180 | } engine[I915_NUM_ENGINES]; | |
181 | ||
182 | /** ring_size: size for allocating the per-engine ring buffer */ | |
183 | u32 ring_size; | |
184 | /** desc_template: invariant fields for the HW context descriptor */ | |
185 | u32 desc_template; | |
186 | ||
6095868a CW |
187 | /** guilty_count: How many times this context has caused a GPU hang. */ |
188 | unsigned int guilty_count; | |
189 | /** | |
190 | * @active_count: How many times this context was active during a GPU | |
191 | * hang, but did not cause it. | |
192 | */ | |
193 | unsigned int active_count; | |
194 | ||
195 | #define CONTEXT_SCORE_GUILTY 10 | |
196 | #define CONTEXT_SCORE_BAN_THRESHOLD 40 | |
197 | /** ban_score: Accumulated score of all hangs caused by this context. */ | |
198 | int ban_score; | |
199 | ||
200 | /** remap_slice: Bitmask of cache lines that need remapping */ | |
201 | u8 remap_slice; | |
202 | }; | |
203 | ||
204 | static inline bool i915_gem_context_is_closed(const struct i915_gem_context *ctx) | |
205 | { | |
206 | return test_bit(CONTEXT_CLOSED, &ctx->flags); | |
207 | } | |
208 | ||
209 | static inline void i915_gem_context_set_closed(struct i915_gem_context *ctx) | |
210 | { | |
211 | GEM_BUG_ON(i915_gem_context_is_closed(ctx)); | |
212 | __set_bit(CONTEXT_CLOSED, &ctx->flags); | |
213 | } | |
214 | ||
215 | static inline bool i915_gem_context_no_error_capture(const struct i915_gem_context *ctx) | |
216 | { | |
217 | return test_bit(CONTEXT_NO_ERROR_CAPTURE, &ctx->flags); | |
218 | } | |
219 | ||
220 | static inline void i915_gem_context_set_no_error_capture(struct i915_gem_context *ctx) | |
221 | { | |
222 | __set_bit(CONTEXT_NO_ERROR_CAPTURE, &ctx->flags); | |
223 | } | |
224 | ||
225 | static inline void i915_gem_context_clear_no_error_capture(struct i915_gem_context *ctx) | |
226 | { | |
227 | __clear_bit(CONTEXT_NO_ERROR_CAPTURE, &ctx->flags); | |
228 | } | |
229 | ||
230 | static inline bool i915_gem_context_is_bannable(const struct i915_gem_context *ctx) | |
231 | { | |
232 | return test_bit(CONTEXT_BANNABLE, &ctx->flags); | |
233 | } | |
234 | ||
235 | static inline void i915_gem_context_set_bannable(struct i915_gem_context *ctx) | |
236 | { | |
237 | __set_bit(CONTEXT_BANNABLE, &ctx->flags); | |
238 | } | |
239 | ||
240 | static inline void i915_gem_context_clear_bannable(struct i915_gem_context *ctx) | |
241 | { | |
242 | __clear_bit(CONTEXT_BANNABLE, &ctx->flags); | |
243 | } | |
244 | ||
245 | static inline bool i915_gem_context_is_banned(const struct i915_gem_context *ctx) | |
246 | { | |
247 | return test_bit(CONTEXT_BANNED, &ctx->flags); | |
248 | } | |
249 | ||
250 | static inline void i915_gem_context_set_banned(struct i915_gem_context *ctx) | |
251 | { | |
252 | __set_bit(CONTEXT_BANNED, &ctx->flags); | |
253 | } | |
254 | ||
255 | static inline bool i915_gem_context_force_single_submission(const struct i915_gem_context *ctx) | |
256 | { | |
257 | return test_bit(CONTEXT_FORCE_SINGLE_SUBMISSION, &ctx->flags); | |
258 | } | |
259 | ||
260 | static inline void i915_gem_context_set_force_single_submission(struct i915_gem_context *ctx) | |
261 | { | |
262 | __set_bit(CONTEXT_FORCE_SINGLE_SUBMISSION, &ctx->flags); | |
263 | } | |
264 | ||
265 | static inline bool i915_gem_context_is_default(const struct i915_gem_context *c) | |
266 | { | |
267 | return c->user_handle == DEFAULT_CONTEXT_HANDLE; | |
268 | } | |
269 | ||
984ff29f CW |
270 | static inline bool i915_gem_context_is_kernel(struct i915_gem_context *ctx) |
271 | { | |
272 | return !ctx->file_priv; | |
273 | } | |
274 | ||
6095868a CW |
275 | /* i915_gem_context.c */ |
276 | int __must_check i915_gem_context_init(struct drm_i915_private *dev_priv); | |
277 | void i915_gem_context_lost(struct drm_i915_private *dev_priv); | |
278 | void i915_gem_context_fini(struct drm_i915_private *dev_priv); | |
279 | int i915_gem_context_open(struct drm_device *dev, struct drm_file *file); | |
280 | void i915_gem_context_close(struct drm_device *dev, struct drm_file *file); | |
281 | int i915_switch_context(struct drm_i915_gem_request *req); | |
282 | int i915_gem_switch_to_kernel_context(struct drm_i915_private *dev_priv); | |
283 | void i915_gem_context_free(struct kref *ctx_ref); | |
284 | struct i915_gem_context * | |
285 | i915_gem_context_create_gvt(struct drm_device *dev); | |
286 | ||
287 | int i915_gem_context_create_ioctl(struct drm_device *dev, void *data, | |
288 | struct drm_file *file); | |
289 | int i915_gem_context_destroy_ioctl(struct drm_device *dev, void *data, | |
290 | struct drm_file *file); | |
291 | int i915_gem_context_getparam_ioctl(struct drm_device *dev, void *data, | |
292 | struct drm_file *file_priv); | |
293 | int i915_gem_context_setparam_ioctl(struct drm_device *dev, void *data, | |
294 | struct drm_file *file_priv); | |
295 | int i915_gem_context_reset_stats_ioctl(struct drm_device *dev, void *data, | |
296 | struct drm_file *file); | |
297 | ||
298 | #endif /* !__I915_GEM_CONTEXT_H__ */ |