drivers/gpu/arm/midgard/mali_kbase_debug_job_fault.c

   1 /*
   2  *
   3  * (C) COPYRIGHT 2012-2016 ARM Limited. All rights reserved.
   4  *
   5  * This program is free software and is provided to you under the terms of the
   6  * GNU General Public License version 2 as published by the Free Software
   7  * Foundation, and any use by you of this program is subject to the terms
   8  * of such GNU licence.
   9  *
  10  * A copy of the licence is included with the program, and can also be obtained
  11  * from Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  12  * Boston, MA  02110-1301, USA.
  13  *
  14  */
  15
  16
  17
  18 #include <mali_kbase.h>
  19 #include <linux/spinlock.h>
  20
  21 #ifdef CONFIG_DEBUG_FS
  22
  23 static bool kbase_is_job_fault_event_pending(struct kbase_device *kbdev)
  24 {
  25         struct list_head *event_list = &kbdev->job_fault_event_list;
  26         unsigned long    flags;
  27         bool             ret;
  28
  29         spin_lock_irqsave(&kbdev->job_fault_event_lock, flags);
  30         ret = !list_empty(event_list);
  31         spin_unlock_irqrestore(&kbdev->job_fault_event_lock, flags);
  32
  33         return ret;
  34 }
  35
  36 static bool kbase_ctx_has_no_event_pending(struct kbase_context *kctx)
  37 {
  38         struct kbase_device *kbdev = kctx->kbdev;
  39         struct list_head *event_list = &kctx->kbdev->job_fault_event_list;
  40         struct base_job_fault_event *event;
  41         unsigned long               flags;
  42
  43         spin_lock_irqsave(&kbdev->job_fault_event_lock, flags);
  44         if (list_empty(event_list)) {
  45                 spin_unlock_irqrestore(&kbdev->job_fault_event_lock, flags);
  46                 return true;
  47         }
  48         list_for_each_entry(event, event_list, head) {
  49                 if (event->katom->kctx == kctx) {
  50                         spin_unlock_irqrestore(&kbdev->job_fault_event_lock,
  51                                         flags);
  52                         return false;
  53                 }
  54         }
  55         spin_unlock_irqrestore(&kbdev->job_fault_event_lock, flags);
  56         return true;
  57 }
  58
  59 /* wait until the fault happen and copy the event */
  60 static int kbase_job_fault_event_wait(struct kbase_device *kbdev,
  61                 struct base_job_fault_event *event)
  62 {
  63         struct list_head            *event_list = &kbdev->job_fault_event_list;
  64         struct base_job_fault_event *event_in;
  65         unsigned long               flags;
  66
  67         spin_lock_irqsave(&kbdev->job_fault_event_lock, flags);
  68         if (list_empty(event_list)) {
  69                 spin_unlock_irqrestore(&kbdev->job_fault_event_lock, flags);
  70                 if (wait_event_interruptible(kbdev->job_fault_wq,
  71                                  kbase_is_job_fault_event_pending(kbdev)))
  72                         return -ERESTARTSYS;
  73                 spin_lock_irqsave(&kbdev->job_fault_event_lock, flags);
  74         }
  75
  76         event_in = list_entry(event_list->next,
  77                         struct base_job_fault_event, head);
  78         event->event_code = event_in->event_code;
  79         event->katom = event_in->katom;
  80
  81         spin_unlock_irqrestore(&kbdev->job_fault_event_lock, flags);
  82
  83         return 0;
  84
  85 }
  86
  87 /* remove the event from the queue */
  88 static struct base_job_fault_event *kbase_job_fault_event_dequeue(
  89                 struct kbase_device *kbdev, struct list_head *event_list)
  90 {
  91         struct base_job_fault_event *event;
  92
  93         event = list_entry(event_list->next,
  94                         struct base_job_fault_event, head);
  95         list_del(event_list->next);
  96
  97         return event;
  98
  99 }
 100
 101 /* Remove all the following atoms after the failed atom in the same context
 102  * Call the postponed bottom half of job done.
 103  * Then, this context could be rescheduled.
 104  */
 105 static void kbase_job_fault_resume_event_cleanup(struct kbase_context *kctx)
 106 {
 107         struct list_head *event_list = &kctx->job_fault_resume_event_list;
 108
 109         while (!list_empty(event_list)) {
 110                 struct base_job_fault_event *event;
 111
 112                 event = kbase_job_fault_event_dequeue(kctx->kbdev,
 113                                 &kctx->job_fault_resume_event_list);
 114                 kbase_jd_done_worker(&event->katom->work);
 115         }
 116
 117 }
 118
 119 /* Remove all the failed atoms that belong to different contexts
 120  * Resume all the contexts that were suspend due to failed job
 121  */
 122 static void kbase_job_fault_event_cleanup(struct kbase_device *kbdev)
 123 {
 124         struct list_head *event_list = &kbdev->job_fault_event_list;
 125         unsigned long    flags;
 126
 127         spin_lock_irqsave(&kbdev->job_fault_event_lock, flags);
 128         while (!list_empty(event_list)) {
 129                 kbase_job_fault_event_dequeue(kbdev, event_list);
 130                 spin_unlock_irqrestore(&kbdev->job_fault_event_lock, flags);
 131                 wake_up(&kbdev->job_fault_resume_wq);
 132                 spin_lock_irqsave(&kbdev->job_fault_event_lock, flags);
 133         }
 134         spin_unlock_irqrestore(&kbdev->job_fault_event_lock, flags);
 135 }
 136
 137 static void kbase_job_fault_resume_worker(struct work_struct *data)
 138 {
 139         struct base_job_fault_event *event = container_of(data,
 140                         struct base_job_fault_event, job_fault_work);
 141         struct kbase_context *kctx;
 142         struct kbase_jd_atom *katom;
 143
 144         katom = event->katom;
 145         kctx = katom->kctx;
 146
 147         dev_info(kctx->kbdev->dev, "Job dumping wait\n");
 148
 149         /* When it was waked up, it need to check if queue is empty or the
 150          * failed atom belongs to different context. If yes, wake up. Both
 151          * of them mean the failed job has been dumped. Please note, it
 152          * should never happen that the job_fault_event_list has the two
 153          * atoms belong to the same context.
 154          */
 155         wait_event(kctx->kbdev->job_fault_resume_wq,
 156                          kbase_ctx_has_no_event_pending(kctx));
 157
 158         atomic_set(&kctx->job_fault_count, 0);
 159         kbase_jd_done_worker(&katom->work);
 160
 161         /* In case the following atoms were scheduled during failed job dump
 162          * the job_done_worker was held. We need to rerun it after the dump
 163          * was finished
 164          */
 165         kbase_job_fault_resume_event_cleanup(kctx);
 166
 167         dev_info(kctx->kbdev->dev, "Job dumping finish, resume scheduler\n");
 168 }
 169
 170 static struct base_job_fault_event *kbase_job_fault_event_queue(
 171                 struct list_head *event_list,
 172                 struct kbase_jd_atom *atom,
 173                 u32 completion_code)
 174 {
 175         struct base_job_fault_event *event;
 176
 177         event = &atom->fault_event;
 178
 179         event->katom = atom;
 180         event->event_code = completion_code;
 181
 182         list_add_tail(&event->head, event_list);
 183
 184         return event;
 185
 186 }
 187
 188 static void kbase_job_fault_event_post(struct kbase_device *kbdev,
 189                 struct kbase_jd_atom *katom, u32 completion_code)
 190 {
 191         struct base_job_fault_event *event;
 192         unsigned long flags;
 193
 194         spin_lock_irqsave(&kbdev->job_fault_event_lock, flags);
 195         event = kbase_job_fault_event_queue(&kbdev->job_fault_event_list,
 196                                 katom, completion_code);
 197         spin_unlock_irqrestore(&kbdev->job_fault_event_lock, flags);
 198
 199         wake_up_interruptible(&kbdev->job_fault_wq);
 200
 201         INIT_WORK(&event->job_fault_work, kbase_job_fault_resume_worker);
 202         queue_work(kbdev->job_fault_resume_workq, &event->job_fault_work);
 203
 204         dev_info(katom->kctx->kbdev->dev, "Job fault happen, start dump: %d_%d",
 205                         katom->kctx->tgid, katom->kctx->id);
 206
 207 }
 208
 209 /*
 210  * This function will process the job fault
 211  * Get the register copy
 212  * Send the failed job dump event
 213  * Create a Wait queue to wait until the job dump finish
 214  */
 215
 216 bool kbase_debug_job_fault_process(struct kbase_jd_atom *katom,
 217                 u32 completion_code)
 218 {
 219         struct kbase_context *kctx = katom->kctx;
 220
 221         /* Check if dumping is in the process
 222          * only one atom of each context can be dumped at the same time
 223          * If the atom belongs to different context, it can be dumped
 224          */
 225         if (atomic_read(&kctx->job_fault_count) > 0) {
 226                 kbase_job_fault_event_queue(
 227                                 &kctx->job_fault_resume_event_list,
 228                                 katom, completion_code);
 229                 dev_info(kctx->kbdev->dev, "queue:%d\n",
 230                                 kbase_jd_atom_id(kctx, katom));
 231                 return true;
 232         }
 233
 234         if (kctx->kbdev->job_fault_debug == true) {
 235
 236                 if (completion_code != BASE_JD_EVENT_DONE) {
 237
 238                         if (kbase_job_fault_get_reg_snapshot(kctx) == false) {
 239                                 dev_warn(kctx->kbdev->dev, "get reg dump failed\n");
 240                                 return false;
 241                         }
 242
 243                         kbase_job_fault_event_post(kctx->kbdev, katom,
 244                                         completion_code);
 245                         atomic_inc(&kctx->job_fault_count);
 246                         dev_info(kctx->kbdev->dev, "post:%d\n",
 247                                         kbase_jd_atom_id(kctx, katom));
 248                         return true;
 249
 250                 }
 251         }
 252         return false;
 253
 254 }
 255
 256 static int debug_job_fault_show(struct seq_file *m, void *v)
 257 {
 258         struct kbase_device *kbdev = m->private;
 259         struct base_job_fault_event *event = (struct base_job_fault_event *)v;
 260         struct kbase_context *kctx = event->katom->kctx;
 261         int i;
 262
 263         dev_info(kbdev->dev, "debug job fault seq show:%d_%d, %d",
 264                         kctx->tgid, kctx->id, event->reg_offset);
 265
 266         if (kctx->reg_dump == NULL) {
 267                 dev_warn(kbdev->dev, "reg dump is NULL");
 268                 return -1;
 269         }
 270
 271         if (kctx->reg_dump[event->reg_offset] ==
 272                         REGISTER_DUMP_TERMINATION_FLAG) {
 273                 /* Return the error here to stop the read. And the
 274                  * following next() will not be called. The stop can
 275                  * get the real event resource and release it
 276                  */
 277                 return -1;
 278         }
 279
 280         if (event->reg_offset == 0)
 281                 seq_printf(m, "%d_%d\n", kctx->tgid, kctx->id);
 282
 283         for (i = 0; i < 50; i++) {
 284                 if (kctx->reg_dump[event->reg_offset] ==
 285                                 REGISTER_DUMP_TERMINATION_FLAG) {
 286                         break;
 287                 }
 288                 seq_printf(m, "%08x: %08x\n",
 289                                 kctx->reg_dump[event->reg_offset],
 290                                 kctx->reg_dump[1+event->reg_offset]);
 291                 event->reg_offset += 2;
 292
 293         }
 294
 295
 296         return 0;
 297 }
 298 static void *debug_job_fault_next(struct seq_file *m, void *v, loff_t *pos)
 299 {
 300         struct kbase_device *kbdev = m->private;
 301         struct base_job_fault_event *event = (struct base_job_fault_event *)v;
 302
 303         dev_info(kbdev->dev, "debug job fault seq next:%d, %d",
 304                         event->reg_offset, (int)*pos);
 305
 306         return event;
 307 }
 308
 309 static void *debug_job_fault_start(struct seq_file *m, loff_t *pos)
 310 {
 311         struct kbase_device *kbdev = m->private;
 312         struct base_job_fault_event *event;
 313
 314         dev_info(kbdev->dev, "fault job seq start:%d", (int)*pos);
 315
 316         /* The condition is trick here. It needs make sure the
 317          * fault hasn't happened and the dumping hasn't been started,
 318          * or the dumping has finished
 319          */
 320         if (*pos == 0) {
 321                 event = kmalloc(sizeof(*event), GFP_KERNEL);
 322                 if (!event)
 323                         return NULL;
 324                 event->reg_offset = 0;
 325                 if (kbase_job_fault_event_wait(kbdev, event)) {
 326                         kfree(event);
 327                         return NULL;
 328                 }
 329
 330                 /* The cache flush workaround is called in bottom half of
 331                  * job done but we delayed it. Now we should clean cache
 332                  * earlier. Then the GPU memory dump should be correct.
 333                  */
 334                 if (event->katom->need_cache_flush_cores_retained) {
 335                         kbase_gpu_cacheclean(kbdev, event->katom);
 336                         event->katom->need_cache_flush_cores_retained = 0;
 337                 }
 338
 339         } else
 340                 return NULL;
 341
 342         return event;
 343 }
 344
 345 static void debug_job_fault_stop(struct seq_file *m, void *v)
 346 {
 347         struct kbase_device *kbdev = m->private;
 348
 349         /* here we wake up the kbase_jd_done_worker after stop, it needs
 350          * get the memory dump before the register dump in debug daemon,
 351          * otherwise, the memory dump may be incorrect.
 352          */
 353
 354         if (v != NULL) {
 355                 kfree(v);
 356                 dev_info(kbdev->dev, "debug job fault seq stop stage 1");
 357
 358         } else {
 359                 unsigned long flags;
 360
 361                 spin_lock_irqsave(&kbdev->job_fault_event_lock, flags);
 362                 if (!list_empty(&kbdev->job_fault_event_list)) {
 363                         kbase_job_fault_event_dequeue(kbdev,
 364                                 &kbdev->job_fault_event_list);
 365                         wake_up(&kbdev->job_fault_resume_wq);
 366                 }
 367                 spin_unlock_irqrestore(&kbdev->job_fault_event_lock, flags);
 368                 dev_info(kbdev->dev, "debug job fault seq stop stage 2");
 369         }
 370
 371 }
 372
 373 static const struct seq_operations ops = {
 374         .start = debug_job_fault_start,
 375         .next = debug_job_fault_next,
 376         .stop = debug_job_fault_stop,
 377         .show = debug_job_fault_show,
 378 };
 379
 380 static int debug_job_fault_open(struct inode *in, struct file *file)
 381 {
 382         struct kbase_device *kbdev = in->i_private;
 383
 384         seq_open(file, &ops);
 385
 386         ((struct seq_file *)file->private_data)->private = kbdev;
 387         dev_info(kbdev->dev, "debug job fault seq open");
 388
 389         kbdev->job_fault_debug = true;
 390
 391         return 0;
 392
 393 }
 394
 395 static int debug_job_fault_release(struct inode *in, struct file *file)
 396 {
 397         struct kbase_device *kbdev = in->i_private;
 398
 399         seq_release(in, file);
 400
 401         kbdev->job_fault_debug = false;
 402
 403         /* Clean the unprocessed job fault. After that, all the suspended
 404          * contexts could be rescheduled.
 405          */
 406         kbase_job_fault_event_cleanup(kbdev);
 407
 408         dev_info(kbdev->dev, "debug job fault seq close");
 409
 410         return 0;
 411 }
 412
 413 static const struct file_operations kbasep_debug_job_fault_fops = {
 414         .open = debug_job_fault_open,
 415         .read = seq_read,
 416         .llseek = seq_lseek,
 417         .release = debug_job_fault_release,
 418 };
 419
 420 /*
 421  *  Initialize debugfs entry for job fault dump
 422  */
 423 void kbase_debug_job_fault_debugfs_init(struct kbase_device *kbdev)
 424 {
 425         debugfs_create_file("job_fault", S_IRUGO,
 426                         kbdev->mali_debugfs_directory, kbdev,
 427                         &kbasep_debug_job_fault_fops);
 428 }
 429
 430
 431 int kbase_debug_job_fault_dev_init(struct kbase_device *kbdev)
 432 {
 433
 434         INIT_LIST_HEAD(&kbdev->job_fault_event_list);
 435
 436         init_waitqueue_head(&(kbdev->job_fault_wq));
 437         init_waitqueue_head(&(kbdev->job_fault_resume_wq));
 438         spin_lock_init(&kbdev->job_fault_event_lock);
 439
 440         kbdev->job_fault_resume_workq = alloc_workqueue(
 441                         "kbase_job_fault_resume_work_queue", WQ_MEM_RECLAIM, 1);
 442         if (!kbdev->job_fault_resume_workq)
 443                 return -ENOMEM;
 444
 445         kbdev->job_fault_debug = false;
 446
 447         return 0;
 448 }
 449
 450 /*
 451  * Release the relevant resource per device
 452  */
 453 void kbase_debug_job_fault_dev_term(struct kbase_device *kbdev)
 454 {
 455         destroy_workqueue(kbdev->job_fault_resume_workq);
 456 }
 457
 458
 459 /*
 460  *  Initialize the relevant data structure per context
 461  */
 462 void kbase_debug_job_fault_context_init(struct kbase_context *kctx)
 463 {
 464
 465         /* We need allocate double size register range
 466          * Because this memory will keep the register address and value
 467          */
 468         kctx->reg_dump = vmalloc(0x4000 * 2);
 469         if (kctx->reg_dump == NULL)
 470                 return;
 471
 472         if (kbase_debug_job_fault_reg_snapshot_init(kctx, 0x4000) == false) {
 473                 vfree(kctx->reg_dump);
 474                 kctx->reg_dump = NULL;
 475         }
 476         INIT_LIST_HEAD(&kctx->job_fault_resume_event_list);
 477         atomic_set(&kctx->job_fault_count, 0);
 478
 479 }
 480
 481 /*
 482  *  release the relevant resource per context
 483  */
 484 void kbase_debug_job_fault_context_term(struct kbase_context *kctx)
 485 {
 486         vfree(kctx->reg_dump);
 487 }
 488
 489 #else /* CONFIG_DEBUG_FS */
 490
 491 int kbase_debug_job_fault_dev_init(struct kbase_device *kbdev)
 492 {
 493         kbdev->job_fault_debug = false;
 494
 495         return 0;
 496 }
 497
 498 void kbase_debug_job_fault_dev_term(struct kbase_device *kbdev)
 499 {
 500 }
 501
 502 #endif /* CONFIG_DEBUG_FS */