1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2020 Intel Corporation 4 */ 5 6 #include <drm/drm_fourcc.h> 7 8 #include "gem/i915_gem_ioctls.h" 9 #include "gem/i915_gem_lmem.h" 10 #include "gem/i915_gem_region.h" 11 #include "pxp/intel_pxp.h" 12 13 #include "i915_drv.h" 14 #include "i915_gem_create.h" 15 #include "i915_trace.h" 16 #include "i915_user_extensions.h" 17 18 static u32 object_max_page_size(struct intel_memory_region **placements, 19 unsigned int n_placements) 20 { 21 u32 max_page_size = 0; 22 int i; 23 24 for (i = 0; i < n_placements; i++) { 25 struct intel_memory_region *mr = placements[i]; 26 27 GEM_BUG_ON(!is_power_of_2(mr->min_page_size)); 28 max_page_size = max_t(u32, max_page_size, mr->min_page_size); 29 } 30 31 GEM_BUG_ON(!max_page_size); 32 return max_page_size; 33 } 34 35 static int object_set_placements(struct drm_i915_gem_object *obj, 36 struct intel_memory_region **placements, 37 unsigned int n_placements) 38 { 39 struct intel_memory_region **arr; 40 unsigned int i; 41 42 GEM_BUG_ON(!n_placements); 43 44 /* 45 * For the common case of one memory region, skip storing an 46 * allocated array and just point at the region directly. 47 */ 48 if (n_placements == 1) { 49 struct intel_memory_region *mr = placements[0]; 50 struct drm_i915_private *i915 = mr->i915; 51 52 obj->mm.placements = &i915->mm.regions[mr->id]; 53 obj->mm.n_placements = 1; 54 } else { 55 arr = kmalloc_array(n_placements, 56 sizeof(struct intel_memory_region *), 57 GFP_KERNEL); 58 if (!arr) 59 return -ENOMEM; 60 61 for (i = 0; i < n_placements; i++) 62 arr[i] = placements[i]; 63 64 obj->mm.placements = arr; 65 obj->mm.n_placements = n_placements; 66 } 67 68 return 0; 69 } 70 71 static int i915_gem_publish(struct drm_i915_gem_object *obj, 72 struct drm_file *file, 73 u64 *size_p, 74 u32 *handle_p) 75 { 76 u64 size = obj->base.size; 77 int ret; 78 79 ret = drm_gem_handle_create(file, &obj->base, handle_p); 80 /* drop reference from allocate - handle holds it now */ 81 i915_gem_object_put(obj); 82 if (ret) 83 return ret; 84 85 *size_p = size; 86 return 0; 87 } 88 89 static struct drm_i915_gem_object * 90 __i915_gem_object_create_user_ext(struct drm_i915_private *i915, u64 size, 91 struct intel_memory_region **placements, 92 unsigned int n_placements, 93 unsigned int ext_flags) 94 { 95 struct intel_memory_region *mr = placements[0]; 96 struct drm_i915_gem_object *obj; 97 unsigned int flags; 98 int ret; 99 100 i915_gem_flush_free_objects(i915); 101 102 size = round_up(size, object_max_page_size(placements, n_placements)); 103 if (size == 0) 104 return ERR_PTR(-EINVAL); 105 106 /* For most of the ABI (e.g. mmap) we think in system pages */ 107 GEM_BUG_ON(!IS_ALIGNED(size, PAGE_SIZE)); 108 109 if (i915_gem_object_size_2big(size)) 110 return ERR_PTR(-E2BIG); 111 112 obj = i915_gem_object_alloc(); 113 if (!obj) 114 return ERR_PTR(-ENOMEM); 115 116 ret = object_set_placements(obj, placements, n_placements); 117 if (ret) 118 goto object_free; 119 120 /* 121 * I915_BO_ALLOC_USER will make sure the object is cleared before 122 * any user access. 123 */ 124 flags = I915_BO_ALLOC_USER; 125 126 ret = mr->ops->init_object(mr, obj, I915_BO_INVALID_OFFSET, size, 0, flags); 127 if (ret) 128 goto object_free; 129 130 GEM_BUG_ON(size != obj->base.size); 131 132 /* Add any flag set by create_ext options */ 133 obj->flags |= ext_flags; 134 135 trace_i915_gem_object_create(obj); 136 return obj; 137 138 object_free: 139 if (obj->mm.n_placements > 1) 140 kfree(obj->mm.placements); 141 i915_gem_object_free(obj); 142 return ERR_PTR(ret); 143 } 144 145 /** 146 * Creates a new object using the same path as DRM_I915_GEM_CREATE_EXT 147 * @i915: i915 private 148 * @size: size of the buffer, in bytes 149 * @placements: possible placement regions, in priority order 150 * @n_placements: number of possible placement regions 151 * 152 * This function is exposed primarily for selftests and does very little 153 * error checking. It is assumed that the set of placement regions has 154 * already been verified to be valid. 155 */ 156 struct drm_i915_gem_object * 157 __i915_gem_object_create_user(struct drm_i915_private *i915, u64 size, 158 struct intel_memory_region **placements, 159 unsigned int n_placements) 160 { 161 return __i915_gem_object_create_user_ext(i915, size, placements, 162 n_placements, 0); 163 } 164 165 int 166 i915_gem_dumb_create(struct drm_file *file, 167 struct drm_device *dev, 168 struct drm_mode_create_dumb *args) 169 { 170 struct drm_i915_gem_object *obj; 171 struct intel_memory_region *mr; 172 enum intel_memory_type mem_type; 173 int cpp = DIV_ROUND_UP(args->bpp, 8); 174 u32 format; 175 176 switch (cpp) { 177 case 1: 178 format = DRM_FORMAT_C8; 179 break; 180 case 2: 181 format = DRM_FORMAT_RGB565; 182 break; 183 case 4: 184 format = DRM_FORMAT_XRGB8888; 185 break; 186 default: 187 return -EINVAL; 188 } 189 190 /* have to work out size/pitch and return them */ 191 args->pitch = ALIGN(args->width * cpp, 64); 192 193 /* align stride to page size so that we can remap */ 194 if (args->pitch > intel_plane_fb_max_stride(to_i915(dev), format, 195 DRM_FORMAT_MOD_LINEAR)) 196 args->pitch = ALIGN(args->pitch, 4096); 197 198 if (args->pitch < args->width) 199 return -EINVAL; 200 201 args->size = mul_u32_u32(args->pitch, args->height); 202 203 mem_type = INTEL_MEMORY_SYSTEM; 204 if (HAS_LMEM(to_i915(dev))) 205 mem_type = INTEL_MEMORY_LOCAL; 206 207 mr = intel_memory_region_by_type(to_i915(dev), mem_type); 208 209 obj = __i915_gem_object_create_user(to_i915(dev), args->size, &mr, 1); 210 if (IS_ERR(obj)) 211 return PTR_ERR(obj); 212 213 return i915_gem_publish(obj, file, &args->size, &args->handle); 214 } 215 216 /** 217 * Creates a new mm object and returns a handle to it. 218 * @dev: drm device pointer 219 * @data: ioctl data blob 220 * @file: drm file pointer 221 */ 222 int 223 i915_gem_create_ioctl(struct drm_device *dev, void *data, 224 struct drm_file *file) 225 { 226 struct drm_i915_private *i915 = to_i915(dev); 227 struct drm_i915_gem_create *args = data; 228 struct drm_i915_gem_object *obj; 229 struct intel_memory_region *mr; 230 231 mr = intel_memory_region_by_type(i915, INTEL_MEMORY_SYSTEM); 232 233 obj = __i915_gem_object_create_user(i915, args->size, &mr, 1); 234 if (IS_ERR(obj)) 235 return PTR_ERR(obj); 236 237 return i915_gem_publish(obj, file, &args->size, &args->handle); 238 } 239 240 struct create_ext { 241 struct drm_i915_private *i915; 242 struct intel_memory_region *placements[INTEL_REGION_UNKNOWN]; 243 unsigned int n_placements; 244 unsigned int placement_mask; 245 unsigned long flags; 246 }; 247 248 static void repr_placements(char *buf, size_t size, 249 struct intel_memory_region **placements, 250 int n_placements) 251 { 252 int i; 253 254 buf[0] = '\0'; 255 256 for (i = 0; i < n_placements; i++) { 257 struct intel_memory_region *mr = placements[i]; 258 int r; 259 260 r = snprintf(buf, size, "\n %s -> { class: %d, inst: %d }", 261 mr->name, mr->type, mr->instance); 262 if (r >= size) 263 return; 264 265 buf += r; 266 size -= r; 267 } 268 } 269 270 static int set_placements(struct drm_i915_gem_create_ext_memory_regions *args, 271 struct create_ext *ext_data) 272 { 273 struct drm_i915_private *i915 = ext_data->i915; 274 struct drm_i915_gem_memory_class_instance __user *uregions = 275 u64_to_user_ptr(args->regions); 276 struct intel_memory_region *placements[INTEL_REGION_UNKNOWN]; 277 u32 mask; 278 int i, ret = 0; 279 280 if (args->pad) { 281 drm_dbg(&i915->drm, "pad should be zero\n"); 282 ret = -EINVAL; 283 } 284 285 if (!args->num_regions) { 286 drm_dbg(&i915->drm, "num_regions is zero\n"); 287 ret = -EINVAL; 288 } 289 290 BUILD_BUG_ON(ARRAY_SIZE(i915->mm.regions) != ARRAY_SIZE(placements)); 291 BUILD_BUG_ON(ARRAY_SIZE(ext_data->placements) != ARRAY_SIZE(placements)); 292 if (args->num_regions > ARRAY_SIZE(i915->mm.regions)) { 293 drm_dbg(&i915->drm, "num_regions is too large\n"); 294 ret = -EINVAL; 295 } 296 297 if (ret) 298 return ret; 299 300 mask = 0; 301 for (i = 0; i < args->num_regions; i++) { 302 struct drm_i915_gem_memory_class_instance region; 303 struct intel_memory_region *mr; 304 305 if (copy_from_user(®ion, uregions, sizeof(region))) 306 return -EFAULT; 307 308 mr = intel_memory_region_lookup(i915, 309 region.memory_class, 310 region.memory_instance); 311 if (!mr || mr->private) { 312 drm_dbg(&i915->drm, "Device is missing region { class: %d, inst: %d } at index = %d\n", 313 region.memory_class, region.memory_instance, i); 314 ret = -EINVAL; 315 goto out_dump; 316 } 317 318 if (mask & BIT(mr->id)) { 319 drm_dbg(&i915->drm, "Found duplicate placement %s -> { class: %d, inst: %d } at index = %d\n", 320 mr->name, region.memory_class, 321 region.memory_instance, i); 322 ret = -EINVAL; 323 goto out_dump; 324 } 325 326 placements[i] = mr; 327 mask |= BIT(mr->id); 328 329 ++uregions; 330 } 331 332 if (ext_data->n_placements) { 333 ret = -EINVAL; 334 goto out_dump; 335 } 336 337 ext_data->n_placements = args->num_regions; 338 for (i = 0; i < args->num_regions; i++) 339 ext_data->placements[i] = placements[i]; 340 341 ext_data->placement_mask = mask; 342 return 0; 343 344 out_dump: 345 if (1) { 346 char buf[256]; 347 348 if (ext_data->n_placements) { 349 repr_placements(buf, 350 sizeof(buf), 351 ext_data->placements, 352 ext_data->n_placements); 353 drm_dbg(&i915->drm, 354 "Placements were already set in previous EXT. Existing placements: %s\n", 355 buf); 356 } 357 358 repr_placements(buf, sizeof(buf), placements, i); 359 drm_dbg(&i915->drm, "New placements(so far validated): %s\n", buf); 360 } 361 362 return ret; 363 } 364 365 static int ext_set_placements(struct i915_user_extension __user *base, 366 void *data) 367 { 368 struct drm_i915_gem_create_ext_memory_regions ext; 369 370 if (copy_from_user(&ext, base, sizeof(ext))) 371 return -EFAULT; 372 373 return set_placements(&ext, data); 374 } 375 376 static int ext_set_protected(struct i915_user_extension __user *base, void *data) 377 { 378 struct drm_i915_gem_create_ext_protected_content ext; 379 struct create_ext *ext_data = data; 380 381 if (copy_from_user(&ext, base, sizeof(ext))) 382 return -EFAULT; 383 384 if (ext.flags) 385 return -EINVAL; 386 387 if (!intel_pxp_is_enabled(&to_gt(ext_data->i915)->pxp)) 388 return -ENODEV; 389 390 ext_data->flags |= I915_BO_PROTECTED; 391 392 return 0; 393 } 394 395 static const i915_user_extension_fn create_extensions[] = { 396 [I915_GEM_CREATE_EXT_MEMORY_REGIONS] = ext_set_placements, 397 [I915_GEM_CREATE_EXT_PROTECTED_CONTENT] = ext_set_protected, 398 }; 399 400 /** 401 * Creates a new mm object and returns a handle to it. 402 * @dev: drm device pointer 403 * @data: ioctl data blob 404 * @file: drm file pointer 405 */ 406 int 407 i915_gem_create_ext_ioctl(struct drm_device *dev, void *data, 408 struct drm_file *file) 409 { 410 struct drm_i915_private *i915 = to_i915(dev); 411 struct drm_i915_gem_create_ext *args = data; 412 struct create_ext ext_data = { .i915 = i915 }; 413 struct drm_i915_gem_object *obj; 414 int ret; 415 416 if (args->flags & ~I915_GEM_CREATE_EXT_FLAG_NEEDS_CPU_ACCESS) 417 return -EINVAL; 418 419 ret = i915_user_extensions(u64_to_user_ptr(args->extensions), 420 create_extensions, 421 ARRAY_SIZE(create_extensions), 422 &ext_data); 423 if (ret) 424 return ret; 425 426 if (!ext_data.n_placements) { 427 ext_data.placements[0] = 428 intel_memory_region_by_type(i915, INTEL_MEMORY_SYSTEM); 429 ext_data.n_placements = 1; 430 } 431 432 if (args->flags & I915_GEM_CREATE_EXT_FLAG_NEEDS_CPU_ACCESS) { 433 if (ext_data.n_placements == 1) 434 return -EINVAL; 435 436 /* 437 * We always need to be able to spill to system memory, if we 438 * can't place in the mappable part of LMEM. 439 */ 440 if (!(ext_data.placement_mask & BIT(INTEL_REGION_SMEM))) 441 return -EINVAL; 442 } else { 443 if (ext_data.n_placements > 1 || 444 ext_data.placements[0]->type != INTEL_MEMORY_SYSTEM) 445 ext_data.flags |= I915_BO_ALLOC_GPU_ONLY; 446 } 447 448 obj = __i915_gem_object_create_user_ext(i915, args->size, 449 ext_data.placements, 450 ext_data.n_placements, 451 ext_data.flags); 452 if (IS_ERR(obj)) 453 return PTR_ERR(obj); 454 455 return i915_gem_publish(obj, file, &args->size, &args->handle); 456 } 457