drivers/gpu/drm/amd/amdkfd/kfd_process.c

   1 /*
   2  * Copyright 2014 Advanced Micro Devices, Inc.
   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 shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 #include <linux/mutex.h>
  24 #include <linux/log2.h>
  25 #include <linux/sched.h>
  26 #include <linux/slab.h>
  27 #include <linux/amd-iommu.h>
  28 #include <linux/notifier.h>
  29 #include <linux/compat.h>
  30
  31 struct mm_struct;
  32
  33 #include "kfd_priv.h"
  34 #include "kfd_dbgmgr.h"
  35
  36 /*
  37  * Initial size for the array of queues.
  38  * The allocated size is doubled each time
  39  * it is exceeded up to MAX_PROCESS_QUEUES.
  40  */
  41 #define INITIAL_QUEUE_ARRAY_SIZE 16
  42
  43 /*
  44  * List of struct kfd_process (field kfd_process).
  45  * Unique/indexed by mm_struct*
  46  */
  47 #define KFD_PROCESS_TABLE_SIZE 5 /* bits: 32 entries */
  48 static DEFINE_HASHTABLE(kfd_processes_table, KFD_PROCESS_TABLE_SIZE);
  49 static DEFINE_MUTEX(kfd_processes_mutex);
  50
  51 DEFINE_STATIC_SRCU(kfd_processes_srcu);
  52
  53 static struct workqueue_struct *kfd_process_wq;
  54
  55 struct kfd_process_release_work {
  56         struct work_struct kfd_work;
  57         struct kfd_process *p;
  58 };
  59
  60 static struct kfd_process *find_process(const struct task_struct *thread);
  61 static struct kfd_process *create_process(const struct task_struct *thread);
  62
  63 void kfd_process_create_wq(void)
  64 {
  65         if (!kfd_process_wq)
  66                 kfd_process_wq = alloc_workqueue("kfd_process_wq", 0, 0);
  67 }
  68
  69 void kfd_process_destroy_wq(void)
  70 {
  71         if (kfd_process_wq) {
  72                 destroy_workqueue(kfd_process_wq);
  73                 kfd_process_wq = NULL;
  74         }
  75 }
  76
  77 struct kfd_process *kfd_create_process(const struct task_struct *thread)
  78 {
  79         struct kfd_process *process;
  80
  81         BUG_ON(!kfd_process_wq);
  82
  83         if (thread->mm == NULL)
  84                 return ERR_PTR(-EINVAL);
  85
  86         /* Only the pthreads threading model is supported. */
  87         if (thread->group_leader->mm != thread->mm)
  88                 return ERR_PTR(-EINVAL);
  89
  90         /* Take mmap_sem because we call __mmu_notifier_register inside */
  91         down_write(&thread->mm->mmap_sem);
  92
  93         /*
  94          * take kfd processes mutex before starting of process creation
  95          * so there won't be a case where two threads of the same process
  96          * create two kfd_process structures
  97          */
  98         mutex_lock(&kfd_processes_mutex);
  99
 100         /* A prior open of /dev/kfd could have already created the process. */
 101         process = find_process(thread);
 102         if (process)
 103                 pr_debug("kfd: process already found\n");
 104
 105         if (!process)
 106                 process = create_process(thread);
 107
 108         mutex_unlock(&kfd_processes_mutex);
 109
 110         up_write(&thread->mm->mmap_sem);
 111
 112         return process;
 113 }
 114
 115 struct kfd_process *kfd_get_process(const struct task_struct *thread)
 116 {
 117         struct kfd_process *process;
 118
 119         if (thread->mm == NULL)
 120                 return ERR_PTR(-EINVAL);
 121
 122         /* Only the pthreads threading model is supported. */
 123         if (thread->group_leader->mm != thread->mm)
 124                 return ERR_PTR(-EINVAL);
 125
 126         process = find_process(thread);
 127         if (!process)
 128                 return ERR_PTR(-EINVAL);
 129
 130         return process;
 131 }
 132
 133 static struct kfd_process *find_process_by_mm(const struct mm_struct *mm)
 134 {
 135         struct kfd_process *process;
 136
 137         hash_for_each_possible_rcu(kfd_processes_table, process,
 138                                         kfd_processes, (uintptr_t)mm)
 139                 if (process->mm == mm)
 140                         return process;
 141
 142         return NULL;
 143 }
 144
 145 static struct kfd_process *find_process(const struct task_struct *thread)
 146 {
 147         struct kfd_process *p;
 148         int idx;
 149
 150         idx = srcu_read_lock(&kfd_processes_srcu);
 151         p = find_process_by_mm(thread->mm);
 152         srcu_read_unlock(&kfd_processes_srcu, idx);
 153
 154         return p;
 155 }
 156
 157 static void kfd_process_wq_release(struct work_struct *work)
 158 {
 159         struct kfd_process_release_work *my_work;
 160         struct kfd_process_device *pdd, *temp;
 161         struct kfd_process *p;
 162
 163         my_work = (struct kfd_process_release_work *) work;
 164
 165         p = my_work->p;
 166
 167         pr_debug("Releasing process (pasid %d) in workqueue\n",
 168                         p->pasid);
 169
 170         mutex_lock(&p->mutex);
 171
 172         list_for_each_entry_safe(pdd, temp, &p->per_device_data,
 173                                                         per_device_list) {
 174                 pr_debug("Releasing pdd (topology id %d) for process (pasid %d) in workqueue\n",
 175                                 pdd->dev->id, p->pasid);
 176
 177                 if (pdd->reset_wavefronts)
 178                         dbgdev_wave_reset_wavefronts(pdd->dev, p);
 179
 180                 amd_iommu_unbind_pasid(pdd->dev->pdev, p->pasid);
 181                 list_del(&pdd->per_device_list);
 182
 183                 kfree(pdd);
 184         }
 185
 186         kfd_event_free_process(p);
 187
 188         kfd_pasid_free(p->pasid);
 189
 190         mutex_unlock(&p->mutex);
 191
 192         mutex_destroy(&p->mutex);
 193
 194         kfree(p->queues);
 195
 196         kfree(p);
 197
 198         kfree(work);
 199 }
 200
 201 static void kfd_process_destroy_delayed(struct rcu_head *rcu)
 202 {
 203         struct kfd_process_release_work *work;
 204         struct kfd_process *p;
 205
 206         BUG_ON(!kfd_process_wq);
 207
 208         p = container_of(rcu, struct kfd_process, rcu);
 209         BUG_ON(atomic_read(&p->mm->mm_count) <= 0);
 210
 211         mmdrop(p->mm);
 212
 213         work = kmalloc(sizeof(struct kfd_process_release_work), GFP_ATOMIC);
 214
 215         if (work) {
 216                 INIT_WORK((struct work_struct *) work, kfd_process_wq_release);
 217                 work->p = p;
 218                 queue_work(kfd_process_wq, (struct work_struct *) work);
 219         }
 220 }
 221
 222 static void kfd_process_notifier_release(struct mmu_notifier *mn,
 223                                         struct mm_struct *mm)
 224 {
 225         struct kfd_process *p;
 226         struct kfd_process_device *pdd = NULL;
 227
 228         /*
 229          * The kfd_process structure can not be free because the
 230          * mmu_notifier srcu is read locked
 231          */
 232         p = container_of(mn, struct kfd_process, mmu_notifier);
 233         BUG_ON(p->mm != mm);
 234
 235         mutex_lock(&kfd_processes_mutex);
 236         hash_del_rcu(&p->kfd_processes);
 237         mutex_unlock(&kfd_processes_mutex);
 238         synchronize_srcu(&kfd_processes_srcu);
 239
 240         mutex_lock(&p->mutex);
 241
 242         /* In case our notifier is called before IOMMU notifier */
 243         pqm_uninit(&p->pqm);
 244
 245         /* Iterate over all process device data structure and check
 246          * if we should delete debug managers and reset all wavefronts
 247          */
 248         list_for_each_entry(pdd, &p->per_device_data, per_device_list) {
 249                 if ((pdd->dev->dbgmgr) &&
 250                                 (pdd->dev->dbgmgr->pasid == p->pasid))
 251                         kfd_dbgmgr_destroy(pdd->dev->dbgmgr);
 252
 253                 if (pdd->reset_wavefronts) {
 254                         pr_warn("amdkfd: Resetting all wave fronts\n");
 255                         dbgdev_wave_reset_wavefronts(pdd->dev, p);
 256                         pdd->reset_wavefronts = false;
 257                 }
 258         }
 259
 260         mutex_unlock(&p->mutex);
 261
 262         /*
 263          * Because we drop mm_count inside kfd_process_destroy_delayed
 264          * and because the mmu_notifier_unregister function also drop
 265          * mm_count we need to take an extra count here.
 266          */
 267         atomic_inc(&p->mm->mm_count);
 268         mmu_notifier_unregister_no_release(&p->mmu_notifier, p->mm);
 269         mmu_notifier_call_srcu(&p->rcu, &kfd_process_destroy_delayed);
 270 }
 271
 272 static const struct mmu_notifier_ops kfd_process_mmu_notifier_ops = {
 273         .release = kfd_process_notifier_release,
 274 };
 275
 276 static struct kfd_process *create_process(const struct task_struct *thread)
 277 {
 278         struct kfd_process *process;
 279         int err = -ENOMEM;
 280
 281         process = kzalloc(sizeof(*process), GFP_KERNEL);
 282
 283         if (!process)
 284                 goto err_alloc_process;
 285
 286         process->queues = kmalloc_array(INITIAL_QUEUE_ARRAY_SIZE,
 287                                         sizeof(process->queues[0]), GFP_KERNEL);
 288         if (!process->queues)
 289                 goto err_alloc_queues;
 290
 291         process->pasid = kfd_pasid_alloc();
 292         if (process->pasid == 0)
 293                 goto err_alloc_pasid;
 294
 295         mutex_init(&process->mutex);
 296
 297         process->mm = thread->mm;
 298
 299         /* register notifier */
 300         process->mmu_notifier.ops = &kfd_process_mmu_notifier_ops;
 301         err = __mmu_notifier_register(&process->mmu_notifier, process->mm);
 302         if (err)
 303                 goto err_mmu_notifier;
 304
 305         hash_add_rcu(kfd_processes_table, &process->kfd_processes,
 306                         (uintptr_t)process->mm);
 307
 308         process->lead_thread = thread->group_leader;
 309
 310         process->queue_array_size = INITIAL_QUEUE_ARRAY_SIZE;
 311
 312         INIT_LIST_HEAD(&process->per_device_data);
 313
 314         kfd_event_init_process(process);
 315
 316         err = pqm_init(&process->pqm, process);
 317         if (err != 0)
 318                 goto err_process_pqm_init;
 319
 320         /* init process apertures*/
 321         process->is_32bit_user_mode = in_compat_syscall();
 322         err = kfd_init_apertures(process);
 323         if (err != 0)
 324                 goto err_init_apretures;
 325
 326         return process;
 327
 328 err_init_apretures:
 329         pqm_uninit(&process->pqm);
 330 err_process_pqm_init:
 331         hash_del_rcu(&process->kfd_processes);
 332         synchronize_rcu();
 333         mmu_notifier_unregister_no_release(&process->mmu_notifier, process->mm);
 334 err_mmu_notifier:
 335         mutex_destroy(&process->mutex);
 336         kfd_pasid_free(process->pasid);
 337 err_alloc_pasid:
 338         kfree(process->queues);
 339 err_alloc_queues:
 340         kfree(process);
 341 err_alloc_process:
 342         return ERR_PTR(err);
 343 }
 344
 345 struct kfd_process_device *kfd_get_process_device_data(struct kfd_dev *dev,
 346                                                         struct kfd_process *p)
 347 {
 348         struct kfd_process_device *pdd = NULL;
 349
 350         list_for_each_entry(pdd, &p->per_device_data, per_device_list)
 351                 if (pdd->dev == dev)
 352                         break;
 353
 354         return pdd;
 355 }
 356
 357 struct kfd_process_device *kfd_create_process_device_data(struct kfd_dev *dev,
 358                                                         struct kfd_process *p)
 359 {
 360         struct kfd_process_device *pdd = NULL;
 361
 362         pdd = kzalloc(sizeof(*pdd), GFP_KERNEL);
 363         if (pdd != NULL) {
 364                 pdd->dev = dev;
 365                 INIT_LIST_HEAD(&pdd->qpd.queues_list);
 366                 INIT_LIST_HEAD(&pdd->qpd.priv_queue_list);
 367                 pdd->qpd.dqm = dev->dqm;
 368                 pdd->reset_wavefronts = false;
 369                 list_add(&pdd->per_device_list, &p->per_device_data);
 370         }
 371
 372         return pdd;
 373 }
 374
 375 /*
 376  * Direct the IOMMU to bind the process (specifically the pasid->mm)
 377  * to the device.
 378  * Unbinding occurs when the process dies or the device is removed.
 379  *
 380  * Assumes that the process lock is held.
 381  */
 382 struct kfd_process_device *kfd_bind_process_to_device(struct kfd_dev *dev,
 383                                                         struct kfd_process *p)
 384 {
 385         struct kfd_process_device *pdd;
 386         int err;
 387
 388         pdd = kfd_get_process_device_data(dev, p);
 389         if (!pdd) {
 390                 pr_err("Process device data doesn't exist\n");
 391                 return ERR_PTR(-ENOMEM);
 392         }
 393
 394         if (pdd->bound)
 395                 return pdd;
 396
 397         err = amd_iommu_bind_pasid(dev->pdev, p->pasid, p->lead_thread);
 398         if (err < 0)
 399                 return ERR_PTR(err);
 400
 401         pdd->bound = true;
 402
 403         return pdd;
 404 }
 405
 406 void kfd_unbind_process_from_device(struct kfd_dev *dev, unsigned int pasid)
 407 {
 408         struct kfd_process *p;
 409         struct kfd_process_device *pdd;
 410
 411         BUG_ON(dev == NULL);
 412
 413         /*
 414          * Look for the process that matches the pasid. If there is no such
 415          * process, we either released it in amdkfd's own notifier, or there
 416          * is a bug. Unfortunately, there is no way to tell...
 417          */
 418         p = kfd_lookup_process_by_pasid(pasid);
 419         if (!p)
 420                 return;
 421
 422         pr_debug("Unbinding process %d from IOMMU\n", pasid);
 423
 424         if ((dev->dbgmgr) && (dev->dbgmgr->pasid == p->pasid))
 425                 kfd_dbgmgr_destroy(dev->dbgmgr);
 426
 427         pqm_uninit(&p->pqm);
 428
 429         pdd = kfd_get_process_device_data(dev, p);
 430
 431         if (!pdd) {
 432                 mutex_unlock(&p->mutex);
 433                 return;
 434         }
 435
 436         if (pdd->reset_wavefronts) {
 437                 dbgdev_wave_reset_wavefronts(pdd->dev, p);
 438                 pdd->reset_wavefronts = false;
 439         }
 440
 441         /*
 442          * Just mark pdd as unbound, because we still need it
 443          * to call amd_iommu_unbind_pasid() in when the
 444          * process exits.
 445          * We don't call amd_iommu_unbind_pasid() here
 446          * because the IOMMU called us.
 447          */
 448         pdd->bound = false;
 449
 450         mutex_unlock(&p->mutex);
 451 }
 452
 453 struct kfd_process_device *kfd_get_first_process_device_data(struct kfd_process *p)
 454 {
 455         return list_first_entry(&p->per_device_data,
 456                                 struct kfd_process_device,
 457                                 per_device_list);
 458 }
 459
 460 struct kfd_process_device *kfd_get_next_process_device_data(struct kfd_process *p,
 461                                                 struct kfd_process_device *pdd)
 462 {
 463         if (list_is_last(&pdd->per_device_list, &p->per_device_data))
 464                 return NULL;
 465         return list_next_entry(pdd, per_device_list);
 466 }
 467
 468 bool kfd_has_process_device_data(struct kfd_process *p)
 469 {
 470         return !(list_empty(&p->per_device_data));
 471 }
 472
 473 /* This returns with process->mutex locked. */
 474 struct kfd_process *kfd_lookup_process_by_pasid(unsigned int pasid)
 475 {
 476         struct kfd_process *p;
 477         unsigned int temp;
 478
 479         int idx = srcu_read_lock(&kfd_processes_srcu);
 480
 481         hash_for_each_rcu(kfd_processes_table, temp, p, kfd_processes) {
 482                 if (p->pasid == pasid) {
 483                         mutex_lock(&p->mutex);
 484                         break;
 485                 }
 486         }
 487
 488         srcu_read_unlock(&kfd_processes_srcu, idx);
 489
 490         return p;
 491 }