drivers/gpu/drm/i915/gt/sysfs_engines.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2019 Intel Corporation
   4  */
   5
   6 #include <linux/kobject.h>
   7 #include <linux/sysfs.h>
   8
   9 #include "i915_drv.h"
  10 #include "intel_engine.h"
  11 #include "intel_engine_heartbeat.h"
  12 #include "sysfs_engines.h"
  13
  14 struct kobj_engine {
  15         struct kobject base;
  16         struct intel_engine_cs *engine;
  17 };
  18
  19 static struct intel_engine_cs *kobj_to_engine(struct kobject *kobj)
  20 {
  21         return container_of(kobj, struct kobj_engine, base)->engine;
  22 }
  23
  24 static ssize_t
  25 name_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
  26 {
  27         return sprintf(buf, "%s\n", kobj_to_engine(kobj)->name);
  28 }
  29
  30 static struct kobj_attribute name_attr =
  31 __ATTR(name, 0444, name_show, NULL);
  32
  33 static ssize_t
  34 class_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
  35 {
  36         return sprintf(buf, "%d\n", kobj_to_engine(kobj)->uabi_class);
  37 }
  38
  39 static struct kobj_attribute class_attr =
  40 __ATTR(class, 0444, class_show, NULL);
  41
  42 static ssize_t
  43 inst_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
  44 {
  45         return sprintf(buf, "%d\n", kobj_to_engine(kobj)->uabi_instance);
  46 }
  47
  48 static struct kobj_attribute inst_attr =
  49 __ATTR(instance, 0444, inst_show, NULL);
  50
  51 static ssize_t
  52 mmio_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
  53 {
  54         return sprintf(buf, "0x%x\n", kobj_to_engine(kobj)->mmio_base);
  55 }
  56
  57 static struct kobj_attribute mmio_attr =
  58 __ATTR(mmio_base, 0444, mmio_show, NULL);
  59
  60 static const char * const vcs_caps[] = {
  61         [ilog2(I915_VIDEO_CLASS_CAPABILITY_HEVC)] = "hevc",
  62         [ilog2(I915_VIDEO_AND_ENHANCE_CLASS_CAPABILITY_SFC)] = "sfc",
  63 };
  64
  65 static const char * const vecs_caps[] = {
  66         [ilog2(I915_VIDEO_AND_ENHANCE_CLASS_CAPABILITY_SFC)] = "sfc",
  67 };
  68
  69 static ssize_t repr_trim(char *buf, ssize_t len)
  70 {
  71         /* Trim off the trailing space and replace with a newline */
  72         if (len > PAGE_SIZE)
  73                 len = PAGE_SIZE;
  74         if (len > 0)
  75                 buf[len - 1] = '\n';
  76
  77         return len;
  78 }
  79
  80 static ssize_t
  81 __caps_show(struct intel_engine_cs *engine,
  82             u32 caps, char *buf, bool show_unknown)
  83 {
  84         const char * const *repr;
  85         int count, n;
  86         ssize_t len;
  87
  88         BUILD_BUG_ON(!typecheck(typeof(caps), engine->uabi_capabilities));
  89
  90         switch (engine->class) {
  91         case VIDEO_DECODE_CLASS:
  92                 repr = vcs_caps;
  93                 count = ARRAY_SIZE(vcs_caps);
  94                 break;
  95
  96         case VIDEO_ENHANCEMENT_CLASS:
  97                 repr = vecs_caps;
  98                 count = ARRAY_SIZE(vecs_caps);
  99                 break;
 100
 101         default:
 102                 repr = NULL;
 103                 count = 0;
 104                 break;
 105         }
 106         GEM_BUG_ON(count > BITS_PER_TYPE(typeof(caps)));
 107
 108         len = 0;
 109         for_each_set_bit(n,
 110                          (unsigned long *)&caps,
 111                          show_unknown ? BITS_PER_TYPE(typeof(caps)) : count) {
 112                 if (n >= count || !repr[n]) {
 113                         if (GEM_WARN_ON(show_unknown))
 114                                 len += snprintf(buf + len, PAGE_SIZE - len,
 115                                                 "[%x] ", n);
 116                 } else {
 117                         len += snprintf(buf + len, PAGE_SIZE - len,
 118                                         "%s ", repr[n]);
 119                 }
 120                 if (GEM_WARN_ON(len >= PAGE_SIZE))
 121                         break;
 122         }
 123         return repr_trim(buf, len);
 124 }
 125
 126 static ssize_t
 127 caps_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 128 {
 129         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 130
 131         return __caps_show(engine, engine->uabi_capabilities, buf, true);
 132 }
 133
 134 static struct kobj_attribute caps_attr =
 135 __ATTR(capabilities, 0444, caps_show, NULL);
 136
 137 static ssize_t
 138 all_caps_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 139 {
 140         return __caps_show(kobj_to_engine(kobj), -1, buf, false);
 141 }
 142
 143 static struct kobj_attribute all_caps_attr =
 144 __ATTR(known_capabilities, 0444, all_caps_show, NULL);
 145
 146 static ssize_t
 147 max_spin_store(struct kobject *kobj, struct kobj_attribute *attr,
 148                const char *buf, size_t count)
 149 {
 150         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 151         unsigned long long duration;
 152         int err;
 153
 154         /*
 155          * When waiting for a request, if is it currently being executed
 156          * on the GPU, we busywait for a short while before sleeping. The
 157          * premise is that most requests are short, and if it is already
 158          * executing then there is a good chance that it will complete
 159          * before we can setup the interrupt handler and go to sleep.
 160          * We try to offset the cost of going to sleep, by first spinning
 161          * on the request -- if it completed in less time than it would take
 162          * to go sleep, process the interrupt and return back to the client,
 163          * then we have saved the client some latency, albeit at the cost
 164          * of spinning on an expensive CPU core.
 165          *
 166          * While we try to avoid waiting at all for a request that is unlikely
 167          * to complete, deciding how long it is worth spinning is for is an
 168          * arbitrary decision: trading off power vs latency.
 169          */
 170
 171         err = kstrtoull(buf, 0, &duration);
 172         if (err)
 173                 return err;
 174
 175         if (duration > jiffies_to_nsecs(2))
 176                 return -EINVAL;
 177
 178         WRITE_ONCE(engine->props.max_busywait_duration_ns, duration);
 179
 180         return count;
 181 }
 182
 183 static ssize_t
 184 max_spin_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 185 {
 186         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 187
 188         return sprintf(buf, "%lu\n", engine->props.max_busywait_duration_ns);
 189 }
 190
 191 static struct kobj_attribute max_spin_attr =
 192 __ATTR(max_busywait_duration_ns, 0644, max_spin_show, max_spin_store);
 193
 194 static ssize_t
 195 max_spin_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 196 {
 197         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 198
 199         return sprintf(buf, "%lu\n", engine->defaults.max_busywait_duration_ns);
 200 }
 201
 202 static struct kobj_attribute max_spin_def =
 203 __ATTR(max_busywait_duration_ns, 0444, max_spin_default, NULL);
 204
 205 static ssize_t
 206 timeslice_store(struct kobject *kobj, struct kobj_attribute *attr,
 207                 const char *buf, size_t count)
 208 {
 209         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 210         unsigned long long duration;
 211         int err;
 212
 213         /*
 214          * Execlists uses a scheduling quantum (a timeslice) to alternate
 215          * execution between ready-to-run contexts of equal priority. This
 216          * ensures that all users (though only if they of equal importance)
 217          * have the opportunity to run and prevents livelocks where contexts
 218          * may have implicit ordering due to userspace semaphores.
 219          */
 220
 221         err = kstrtoull(buf, 0, &duration);
 222         if (err)
 223                 return err;
 224
 225         if (duration > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
 226                 return -EINVAL;
 227
 228         WRITE_ONCE(engine->props.timeslice_duration_ms, duration);
 229
 230         if (execlists_active(&engine->execlists))
 231                 set_timer_ms(&engine->execlists.timer, duration);
 232
 233         return count;
 234 }
 235
 236 static ssize_t
 237 timeslice_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 238 {
 239         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 240
 241         return sprintf(buf, "%lu\n", engine->props.timeslice_duration_ms);
 242 }
 243
 244 static struct kobj_attribute timeslice_duration_attr =
 245 __ATTR(timeslice_duration_ms, 0644, timeslice_show, timeslice_store);
 246
 247 static ssize_t
 248 timeslice_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 249 {
 250         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 251
 252         return sprintf(buf, "%lu\n", engine->defaults.timeslice_duration_ms);
 253 }
 254
 255 static struct kobj_attribute timeslice_duration_def =
 256 __ATTR(timeslice_duration_ms, 0444, timeslice_default, NULL);
 257
 258 static ssize_t
 259 stop_store(struct kobject *kobj, struct kobj_attribute *attr,
 260            const char *buf, size_t count)
 261 {
 262         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 263         unsigned long long duration;
 264         int err;
 265
 266         /*
 267          * When we allow ourselves to sleep before a GPU reset after disabling
 268          * submission, even for a few milliseconds, gives an innocent context
 269          * the opportunity to clear the GPU before the reset occurs. However,
 270          * how long to sleep depends on the typical non-preemptible duration
 271          * (a similar problem to determining the ideal preempt-reset timeout
 272          * or even the heartbeat interval).
 273          */
 274
 275         err = kstrtoull(buf, 0, &duration);
 276         if (err)
 277                 return err;
 278
 279         if (duration > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
 280                 return -EINVAL;
 281
 282         WRITE_ONCE(engine->props.stop_timeout_ms, duration);
 283         return count;
 284 }
 285
 286 static ssize_t
 287 stop_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 288 {
 289         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 290
 291         return sprintf(buf, "%lu\n", engine->props.stop_timeout_ms);
 292 }
 293
 294 static struct kobj_attribute stop_timeout_attr =
 295 __ATTR(stop_timeout_ms, 0644, stop_show, stop_store);
 296
 297 static ssize_t
 298 stop_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 299 {
 300         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 301
 302         return sprintf(buf, "%lu\n", engine->defaults.stop_timeout_ms);
 303 }
 304
 305 static struct kobj_attribute stop_timeout_def =
 306 __ATTR(stop_timeout_ms, 0444, stop_default, NULL);
 307
 308 static ssize_t
 309 preempt_timeout_store(struct kobject *kobj, struct kobj_attribute *attr,
 310                       const char *buf, size_t count)
 311 {
 312         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 313         unsigned long long timeout;
 314         int err;
 315
 316         /*
 317          * After initialising a preemption request, we give the current
 318          * resident a small amount of time to vacate the GPU. The preemption
 319          * request is for a higher priority context and should be immediate to
 320          * maintain high quality of service (and avoid priority inversion).
 321          * However, the preemption granularity of the GPU can be quite coarse
 322          * and so we need a compromise.
 323          */
 324
 325         err = kstrtoull(buf, 0, &timeout);
 326         if (err)
 327                 return err;
 328
 329         if (timeout > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
 330                 return -EINVAL;
 331
 332         WRITE_ONCE(engine->props.preempt_timeout_ms, timeout);
 333
 334         if (READ_ONCE(engine->execlists.pending[0]))
 335                 set_timer_ms(&engine->execlists.preempt, timeout);
 336
 337         return count;
 338 }
 339
 340 static ssize_t
 341 preempt_timeout_show(struct kobject *kobj, struct kobj_attribute *attr,
 342                      char *buf)
 343 {
 344         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 345
 346         return sprintf(buf, "%lu\n", engine->props.preempt_timeout_ms);
 347 }
 348
 349 static struct kobj_attribute preempt_timeout_attr =
 350 __ATTR(preempt_timeout_ms, 0644, preempt_timeout_show, preempt_timeout_store);
 351
 352 static ssize_t
 353 preempt_timeout_default(struct kobject *kobj, struct kobj_attribute *attr,
 354                         char *buf)
 355 {
 356         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 357
 358         return sprintf(buf, "%lu\n", engine->defaults.preempt_timeout_ms);
 359 }
 360
 361 static struct kobj_attribute preempt_timeout_def =
 362 __ATTR(preempt_timeout_ms, 0444, preempt_timeout_default, NULL);
 363
 364 static ssize_t
 365 heartbeat_store(struct kobject *kobj, struct kobj_attribute *attr,
 366                 const char *buf, size_t count)
 367 {
 368         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 369         unsigned long long delay;
 370         int err;
 371
 372         /*
 373          * We monitor the health of the system via periodic heartbeat pulses.
 374          * The pulses also provide the opportunity to perform garbage
 375          * collection.  However, we interpret an incomplete pulse (a missed
 376          * heartbeat) as an indication that the system is no longer responsive,
 377          * i.e. hung, and perform an engine or full GPU reset. Given that the
 378          * preemption granularity can be very coarse on a system, the optimal
 379          * value for any workload is unknowable!
 380          */
 381
 382         err = kstrtoull(buf, 0, &delay);
 383         if (err)
 384                 return err;
 385
 386         if (delay >= jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
 387                 return -EINVAL;
 388
 389         err = intel_engine_set_heartbeat(engine, delay);
 390         if (err)
 391                 return err;
 392
 393         return count;
 394 }
 395
 396 static ssize_t
 397 heartbeat_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 398 {
 399         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 400
 401         return sprintf(buf, "%lu\n", engine->props.heartbeat_interval_ms);
 402 }
 403
 404 static struct kobj_attribute heartbeat_interval_attr =
 405 __ATTR(heartbeat_interval_ms, 0644, heartbeat_show, heartbeat_store);
 406
 407 static ssize_t
 408 heartbeat_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 409 {
 410         struct intel_engine_cs *engine = kobj_to_engine(kobj);
 411
 412         return sprintf(buf, "%lu\n", engine->defaults.heartbeat_interval_ms);
 413 }
 414
 415 static struct kobj_attribute heartbeat_interval_def =
 416 __ATTR(heartbeat_interval_ms, 0444, heartbeat_default, NULL);
 417
 418 static void kobj_engine_release(struct kobject *kobj)
 419 {
 420         kfree(kobj);
 421 }
 422
 423 static struct kobj_type kobj_engine_type = {
 424         .release = kobj_engine_release,
 425         .sysfs_ops = &kobj_sysfs_ops
 426 };
 427
 428 static struct kobject *
 429 kobj_engine(struct kobject *dir, struct intel_engine_cs *engine)
 430 {
 431         struct kobj_engine *ke;
 432
 433         ke = kzalloc(sizeof(*ke), GFP_KERNEL);
 434         if (!ke)
 435                 return NULL;
 436
 437         kobject_init(&ke->base, &kobj_engine_type);
 438         ke->engine = engine;
 439
 440         if (kobject_add(&ke->base, dir, "%s", engine->name)) {
 441                 kobject_put(&ke->base);
 442                 return NULL;
 443         }
 444
 445         /* xfer ownership to sysfs tree */
 446         return &ke->base;
 447 }
 448
 449 static void add_defaults(struct kobj_engine *parent)
 450 {
 451         static const struct attribute *files[] = {
 452                 &max_spin_def.attr,
 453                 &stop_timeout_def.attr,
 454 #if CONFIG_DRM_I915_HEARTBEAT_INTERVAL
 455                 &heartbeat_interval_def.attr,
 456 #endif
 457                 NULL
 458         };
 459         struct kobj_engine *ke;
 460
 461         ke = kzalloc(sizeof(*ke), GFP_KERNEL);
 462         if (!ke)
 463                 return;
 464
 465         kobject_init(&ke->base, &kobj_engine_type);
 466         ke->engine = parent->engine;
 467
 468         if (kobject_add(&ke->base, &parent->base, "%s", ".defaults")) {
 469                 kobject_put(&ke->base);
 470                 return;
 471         }
 472
 473         if (sysfs_create_files(&ke->base, files))
 474                 return;
 475
 476         if (intel_engine_has_timeslices(ke->engine) &&
 477             sysfs_create_file(&ke->base, &timeslice_duration_def.attr))
 478                 return;
 479
 480         if (intel_engine_has_preempt_reset(ke->engine) &&
 481             sysfs_create_file(&ke->base, &preempt_timeout_def.attr))
 482                 return;
 483 }
 484
 485 void intel_engines_add_sysfs(struct drm_i915_private *i915)
 486 {
 487         static const struct attribute *files[] = {
 488                 &name_attr.attr,
 489                 &class_attr.attr,
 490                 &inst_attr.attr,
 491                 &mmio_attr.attr,
 492                 &caps_attr.attr,
 493                 &all_caps_attr.attr,
 494                 &max_spin_attr.attr,
 495                 &stop_timeout_attr.attr,
 496 #if CONFIG_DRM_I915_HEARTBEAT_INTERVAL
 497                 &heartbeat_interval_attr.attr,
 498 #endif
 499                 NULL
 500         };
 501
 502         struct device *kdev = i915->drm.primary->kdev;
 503         struct intel_engine_cs *engine;
 504         struct kobject *dir;
 505
 506         dir = kobject_create_and_add("engine", &kdev->kobj);
 507         if (!dir)
 508                 return;
 509
 510         for_each_uabi_engine(engine, i915) {
 511                 struct kobject *kobj;
 512
 513                 kobj = kobj_engine(dir, engine);
 514                 if (!kobj)
 515                         goto err_engine;
 516
 517                 if (sysfs_create_files(kobj, files))
 518                         goto err_object;
 519
 520                 if (intel_engine_has_timeslices(engine) &&
 521                     sysfs_create_file(kobj, &timeslice_duration_attr.attr))
 522                         goto err_engine;
 523
 524                 if (intel_engine_has_preempt_reset(engine) &&
 525                     sysfs_create_file(kobj, &preempt_timeout_attr.attr))
 526                         goto err_engine;
 527
 528                 add_defaults(container_of(kobj, struct kobj_engine, base));
 529
 530                 if (0) {
 531 err_object:
 532                         kobject_put(kobj);
 533 err_engine:
 534                         dev_err(kdev, "Failed to add sysfs engine '%s'\n",
 535                                 engine->name);
 536                         break;
 537                 }
 538         }
 539 }