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

/*
 * Copyright 2014 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include <linux/mutex.h>
#include <linux/log2.h>
#include <linux/sched.h>
#include <linux/sched/mm.h>
#include <linux/slab.h>
#include <linux/amd-iommu.h>
#include <linux/notifier.h>
#include <linux/compat.h>

struct mm_struct;

#include "kfd_priv.h"
#include "kfd_dbgmgr.h"

/*
 * List of struct kfd_process (field kfd_process).
 * Unique/indexed by mm_struct*
 */

#define KFD_PROCESS_TABLE_SIZE 5 
/* bits: 32 entries */
static DEFINE_HASHTABLE(kfd_processes_table, KFD_PROCESS_TABLE_SIZE);
static DEFINE_MUTEX(kfd_processes_mutex);


DEFINE_STATIC_SRCU(kfd_processes_srcu);


static struct workqueue_struct *kfd_process_wq;


struct kfd_process_release_work {
	
struct work_struct kfd_work;
	
struct kfd_process *p;
};

static struct kfd_process *find_process(const struct task_struct *thread);
static struct kfd_process *create_process(const struct task_struct *thread);



void kfd_process_create_wq(void)
{
	if (!kfd_process_wq)
		kfd_process_wq = alloc_workqueue("kfd_process_wq", 0, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
18
78.26%
1
50.00%
Bhaktipriya Shridhar
5
21.74%
1
50.00%
Total
23
100.00%
2
100.00%



void kfd_process_destroy_wq(void)
{
	if (kfd_process_wq) {
		destroy_workqueue(kfd_process_wq);
		kfd_process_wq = NULL;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
22
100.00%
1
100.00%
Total
22
100.00%
1
100.00%



struct kfd_process *kfd_create_process(const struct task_struct *thread)
{
	struct kfd_process *process;

	if (!thread->mm)
		return ERR_PTR(-EINVAL);

	/* Only the pthreads threading model is supported. */
	if (thread->group_leader->mm != thread->mm)
		return ERR_PTR(-EINVAL);

	/* Take mmap_sem because we call __mmu_notifier_register inside */
	down_write(&thread->mm->mmap_sem);

	/*
         * take kfd processes mutex before starting of process creation
         * so there won't be a case where two threads of the same process
         * create two kfd_process structures
         */
	mutex_lock(&kfd_processes_mutex);

	/* A prior open of /dev/kfd could have already created the process. */
	process = find_process(thread);
	if (process)
		pr_debug("Process already found\n");

	if (!process)
		process = create_process(thread);

	mutex_unlock(&kfd_processes_mutex);

	up_write(&thread->mm->mmap_sem);

	return process;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
116
98.31%
1
33.33%
Kent Russell
2
1.69%
2
66.67%
Total
118
100.00%
3
100.00%



struct kfd_process *kfd_get_process(const struct task_struct *thread)
{
	struct kfd_process *process;

	if (!thread->mm)
		return ERR_PTR(-EINVAL);

	/* Only the pthreads threading model is supported. */
	if (thread->group_leader->mm != thread->mm)
		return ERR_PTR(-EINVAL);

	process = find_process(thread);

	return process;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
61
98.39%
1
50.00%
Kent Russell
1
1.61%
1
50.00%
Total
62
100.00%
2
100.00%



static struct kfd_process *find_process_by_mm(const struct mm_struct *mm)
{
	struct kfd_process *process;

	hash_for_each_possible_rcu(kfd_processes_table, process,
					kfd_processes, (uintptr_t)mm)
		if (process->mm == mm)
			return process;

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
43
100.00%
1
100.00%
Total
43
100.00%
1
100.00%



static struct kfd_process *find_process(const struct task_struct *thread)
{
	struct kfd_process *p;
	int idx;

	idx = srcu_read_lock(&kfd_processes_srcu);
	p = find_process_by_mm(thread->mm);
	srcu_read_unlock(&kfd_processes_srcu, idx);

	return p;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
50
100.00%
1
100.00%
Total
50
100.00%
1
100.00%



static void kfd_process_wq_release(struct work_struct *work)
{
	struct kfd_process_release_work *my_work;
	struct kfd_process_device *pdd, *temp;
	struct kfd_process *p;

	my_work = (struct kfd_process_release_work *) work;

	p = my_work->p;

	pr_debug("Releasing process (pasid %d) in workqueue\n",
			p->pasid);

	mutex_lock(&p->mutex);

	list_for_each_entry_safe(pdd, temp, &p->per_device_data,
							per_device_list) {
		pr_debug("Releasing pdd (topology id %d) for process (pasid %d) in workqueue\n",
				pdd->dev->id, p->pasid);

		if (pdd->bound == PDD_BOUND)
			amd_iommu_unbind_pasid(pdd->dev->pdev, p->pasid);

		list_del(&pdd->per_device_list);
		kfree(pdd);
	}

	kfd_event_free_process(p);

	kfd_pasid_free(p->pasid);
	kfd_free_process_doorbells(p);

	mutex_unlock(&p->mutex);

	mutex_destroy(&p->mutex);

	kfree(p);

	kfree(work);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
147
89.09%
3
37.50%
Andrew Lewycky
5
3.03%
1
12.50%
Felix Kuehling
5
3.03%
1
12.50%
Ben Goz
4
2.42%
2
25.00%
Yong Zhao
4
2.42%
1
12.50%
Total
165
100.00%
8
100.00%



static void kfd_process_destroy_delayed(struct rcu_head *rcu)
{
	struct kfd_process_release_work *work;
	struct kfd_process *p;

	p = container_of(rcu, struct kfd_process, rcu);

	mmdrop(p->mm);

	work = kmalloc(sizeof(struct kfd_process_release_work), GFP_ATOMIC);

	if (work) {
		INIT_WORK((struct work_struct *) work, kfd_process_wq_release);
		work->p = p;
		queue_work(kfd_process_wq, (struct work_struct *) work);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
88
98.88%
1
50.00%
Sasha Levin
1
1.12%
1
50.00%
Total
89
100.00%
2
100.00%



static void kfd_process_notifier_release(struct mmu_notifier *mn,
					struct mm_struct *mm)
{
	struct kfd_process *p;
	struct kfd_process_device *pdd = NULL;

	/*
         * The kfd_process structure can not be free because the
         * mmu_notifier srcu is read locked
         */
	p = container_of(mn, struct kfd_process, mmu_notifier);
	if (WARN_ON(p->mm != mm))
		return;

	mutex_lock(&kfd_processes_mutex);
	hash_del_rcu(&p->kfd_processes);
	mutex_unlock(&kfd_processes_mutex);
	synchronize_srcu(&kfd_processes_srcu);

	mutex_lock(&p->mutex);

	/* Iterate over all process device data structures and if the
         * pdd is in debug mode, we should first force unregistration,
         * then we will be able to destroy the queues
         */
	list_for_each_entry(pdd, &p->per_device_data, per_device_list) {
		struct kfd_dev *dev = pdd->dev;

		mutex_lock(kfd_get_dbgmgr_mutex());
		if (dev && dev->dbgmgr && dev->dbgmgr->pasid == p->pasid) {
			if (!kfd_dbgmgr_unregister(dev->dbgmgr, p)) {
				kfd_dbgmgr_destroy(dev->dbgmgr);
				dev->dbgmgr = NULL;
			}
		}
		mutex_unlock(kfd_get_dbgmgr_mutex());
	}

	kfd_process_dequeue_from_all_devices(p);
	pqm_uninit(&p->pqm);

	mutex_unlock(&p->mutex);

	/*
         * Because we drop mm_count inside kfd_process_destroy_delayed
         * and because the mmu_notifier_unregister function also drop
         * mm_count we need to take an extra count here.
         */
	mmgrab(p->mm);
	mmu_notifier_unregister_no_release(&p->mmu_notifier, p->mm);
	mmu_notifier_call_srcu(&p->rcu, &kfd_process_destroy_delayed);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
121
55.50%
2
28.57%
Yair Shachar
60
27.52%
1
14.29%
Ben Goz
31
14.22%
2
28.57%
Felix Kuehling
5
2.29%
1
14.29%
Vegard Nossum
1
0.46%
1
14.29%
Total
218
100.00%
7
100.00%


static const struct mmu_notifier_ops kfd_process_mmu_notifier_ops = {
	.release = kfd_process_notifier_release,
};



static struct kfd_process *create_process(const struct task_struct *thread)
{
	struct kfd_process *process;
	int err = -ENOMEM;

	process = kzalloc(sizeof(*process), GFP_KERNEL);

	if (!process)
		goto err_alloc_process;

	process->pasid = kfd_pasid_alloc();
	if (process->pasid == 0)
		goto err_alloc_pasid;

	if (kfd_alloc_process_doorbells(process) < 0)
		goto err_alloc_doorbells;

	mutex_init(&process->mutex);

	process->mm = thread->mm;

	/* register notifier */
	process->mmu_notifier.ops = &kfd_process_mmu_notifier_ops;
	err = __mmu_notifier_register(&process->mmu_notifier, process->mm);
	if (err)
		goto err_mmu_notifier;

	hash_add_rcu(kfd_processes_table, &process->kfd_processes,
			(uintptr_t)process->mm);

	process->lead_thread = thread->group_leader;

	INIT_LIST_HEAD(&process->per_device_data);

	kfd_event_init_process(process);

	err = pqm_init(&process->pqm, process);
	if (err != 0)
		goto err_process_pqm_init;

	/* init process apertures*/
	process->is_32bit_user_mode = in_compat_syscall();
	err = kfd_init_apertures(process);
	if (err != 0)
		goto err_init_apertures;

	return process;

err_init_apertures:
	pqm_uninit(&process->pqm);
err_process_pqm_init:
	hash_del_rcu(&process->kfd_processes);
	synchronize_rcu();
	mmu_notifier_unregister_no_release(&process->mmu_notifier, process->mm);
err_mmu_notifier:
	mutex_destroy(&process->mutex);
	kfd_free_process_doorbells(process);
err_alloc_doorbells:
	kfd_pasid_free(process->pasid);
err_alloc_pasid:
	kfree(process);
err_alloc_process:
	return ERR_PTR(err);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
179
63.25%
2
22.22%
Ben Goz
46
16.25%
1
11.11%
Alexey Skidanov
25
8.83%
1
11.11%
Felix Kuehling
19
6.71%
1
11.11%
Dan Carpenter
6
2.12%
1
11.11%
Andrew Lewycky
5
1.77%
1
11.11%
Geert Uytterhoeven
2
0.71%
1
11.11%
Andrew Lutomirski
1
0.35%
1
11.11%
Total
283
100.00%
9
100.00%



struct kfd_process_device *kfd_get_process_device_data(struct kfd_dev *dev,
							struct kfd_process *p)
{
	struct kfd_process_device *pdd = NULL;

	list_for_each_entry(pdd, &p->per_device_data, per_device_list)
		if (pdd->dev == dev)
			return pdd;

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
42
91.30%
1
33.33%
Yong Zhao
3
6.52%
1
33.33%
Alexey Skidanov
1
2.17%
1
33.33%
Total
46
100.00%
3
100.00%



struct kfd_process_device *kfd_create_process_device_data(struct kfd_dev *dev,
							struct kfd_process *p)
{
	struct kfd_process_device *pdd = NULL;

	pdd = kzalloc(sizeof(*pdd), GFP_KERNEL);
	if (pdd != NULL) {
		pdd->dev = dev;
		INIT_LIST_HEAD(&pdd->qpd.queues_list);
		INIT_LIST_HEAD(&pdd->qpd.priv_queue_list);
		pdd->qpd.dqm = dev->dqm;
		pdd->process = p;
		pdd->bound = PDD_UNBOUND;
		pdd->already_dequeued = false;
		list_add(&pdd->per_device_list, &p->per_device_data);
	}

	return pdd;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
45
39.13%
1
16.67%
Ben Goz
34
29.57%
2
33.33%
Alexey Skidanov
22
19.13%
1
16.67%
Felix Kuehling
8
6.96%
1
16.67%
Yong Zhao
6
5.22%
1
16.67%
Total
115
100.00%
6
100.00%

/*
 * Direct the IOMMU to bind the process (specifically the pasid->mm)
 * to the device.
 * Unbinding occurs when the process dies or the device is removed.
 *
 * Assumes that the process lock is held.
 */


struct kfd_process_device *kfd_bind_process_to_device(struct kfd_dev *dev,
							struct kfd_process *p)
{
	struct kfd_process_device *pdd;
	int err;

	pdd = kfd_get_process_device_data(dev, p);
	if (!pdd) {
		pr_err("Process device data doesn't exist\n");
		return ERR_PTR(-ENOMEM);
	}

	if (pdd->bound == PDD_BOUND) {
		return pdd;
	} else if (unlikely(pdd->bound == PDD_BOUND_SUSPENDED)) {
		pr_err("Binding PDD_BOUND_SUSPENDED pdd is unexpected!\n");
		return ERR_PTR(-EINVAL);
	}

	err = amd_iommu_bind_pasid(dev->pdev, p->pasid, p->lead_thread);
	if (err < 0)
		return ERR_PTR(err);

	pdd->bound = PDD_BOUND;

	return pdd;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
84
64.62%
2
50.00%
Yong Zhao
31
23.85%
1
25.00%
Alexey Skidanov
15
11.54%
1
25.00%
Total
130
100.00%
4
100.00%

/*
 * Bind processes do the device that have been temporarily unbound
 * (PDD_BOUND_SUSPENDED) in kfd_unbind_processes_from_device.
 */


int kfd_bind_processes_to_device(struct kfd_dev *dev)
{
	struct kfd_process_device *pdd;
	struct kfd_process *p;
	unsigned int temp;
	int err = 0;

	int idx = srcu_read_lock(&kfd_processes_srcu);

	hash_for_each_rcu(kfd_processes_table, temp, p, kfd_processes) {
		mutex_lock(&p->mutex);
		pdd = kfd_get_process_device_data(dev, p);
		if (pdd->bound != PDD_BOUND_SUSPENDED) {
			mutex_unlock(&p->mutex);
			continue;
		}

		err = amd_iommu_bind_pasid(dev->pdev, p->pasid,
				p->lead_thread);
		if (err < 0) {
			pr_err("Unexpected pasid %d binding failure\n",
					p->pasid);
			mutex_unlock(&p->mutex);
			break;
		}

		pdd->bound = PDD_BOUND;
		mutex_unlock(&p->mutex);
	}

	srcu_read_unlock(&kfd_processes_srcu, idx);

	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Yong Zhao
153
99.35%
1
50.00%
Felix Kuehling
1
0.65%
1
50.00%
Total
154
100.00%
2
100.00%

/*
 * Mark currently bound processes as PDD_BOUND_SUSPENDED. These
 * processes will be restored to PDD_BOUND state in
 * kfd_bind_processes_to_device.
 */


void kfd_unbind_processes_from_device(struct kfd_dev *dev)
{
	struct kfd_process_device *pdd;
	struct kfd_process *p;
	unsigned int temp;

	int idx = srcu_read_lock(&kfd_processes_srcu);

	hash_for_each_rcu(kfd_processes_table, temp, p, kfd_processes) {
		mutex_lock(&p->mutex);
		pdd = kfd_get_process_device_data(dev, p);

		if (pdd->bound == PDD_BOUND)
			pdd->bound = PDD_BOUND_SUSPENDED;
		mutex_unlock(&p->mutex);
	}

	srcu_read_unlock(&kfd_processes_srcu, idx);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Yong Zhao
92
100.00%
1
100.00%
Total
92
100.00%
1
100.00%



void kfd_process_iommu_unbind_callback(struct kfd_dev *dev, unsigned int pasid)
{
	struct kfd_process *p;
	struct kfd_process_device *pdd;

	/*
         * Look for the process that matches the pasid. If there is no such
         * process, we either released it in amdkfd's own notifier, or there
         * is a bug. Unfortunately, there is no way to tell...
         */
	p = kfd_lookup_process_by_pasid(pasid);
	if (!p)
		return;

	pr_debug("Unbinding process %d from IOMMU\n", pasid);

	mutex_lock(kfd_get_dbgmgr_mutex());

	if (dev->dbgmgr && dev->dbgmgr->pasid == p->pasid) {
		if (!kfd_dbgmgr_unregister(dev->dbgmgr, p)) {
			kfd_dbgmgr_destroy(dev->dbgmgr);
			dev->dbgmgr = NULL;
		}
	}

	mutex_unlock(kfd_get_dbgmgr_mutex());

	pdd = kfd_get_process_device_data(dev, p);
	if (pdd)
		/* For GPU relying on IOMMU, we need to dequeue here
                 * when PASID is still bound.
                 */
		kfd_process_dequeue_from_device(pdd);

	mutex_unlock(&p->mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
46
35.66%
2
22.22%
Ben Goz
38
29.46%
2
22.22%
Yair Shachar
34
26.36%
1
11.11%
Edward O'Callaghan
6
4.65%
1
11.11%
Maninder Singh
2
1.55%
1
11.11%
Felix Kuehling
2
1.55%
1
11.11%
Yong Zhao
1
0.78%
1
11.11%
Total
129
100.00%
9
100.00%



struct kfd_process_device *kfd_get_first_process_device_data(
						struct kfd_process *p)
{
	return list_first_entry(&p->per_device_data,
				struct kfd_process_device,
				per_device_list);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
26
100.00%
1
100.00%
Total
26
100.00%
1
100.00%



struct kfd_process_device *kfd_get_next_process_device_data(
						struct kfd_process *p,
						struct kfd_process_device *pdd)
{
	if (list_is_last(&pdd->per_device_list, &p->per_device_data))
		return NULL;
	return list_next_entry(pdd, per_device_list);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
43
100.00%
1
100.00%
Total
43
100.00%
1
100.00%



bool kfd_has_process_device_data(struct kfd_process *p)
{
	return !(list_empty(&p->per_device_data));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
22
100.00%
1
100.00%
Total
22
100.00%
1
100.00%

/* This returns with process->mutex locked. */


struct kfd_process *kfd_lookup_process_by_pasid(unsigned int pasid)
{
	struct kfd_process *p;
	unsigned int temp;

	int idx = srcu_read_lock(&kfd_processes_srcu);

	hash_for_each_rcu(kfd_processes_table, temp, p, kfd_processes) {
		if (p->pasid == pasid) {
			mutex_lock(&p->mutex);
			break;
		}
	}

	srcu_read_unlock(&kfd_processes_srcu, idx);

	return p;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Andrew Lewycky
71
100.00%
1
100.00%
Total
71
100.00%
1
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Oded Gabbay
1263
62.43%
6
20.00%
Yong Zhao
292
14.43%
2
6.67%
Ben Goz
156
7.71%
3
10.00%
Yair Shachar
94
4.65%
1
3.33%
Andrew Lewycky
82
4.05%
1
3.33%
Alexey Skidanov
66
3.26%
2
6.67%
Felix Kuehling
40
1.98%
4
13.33%
Dan Carpenter
6
0.30%
1
3.33%
Edward O'Callaghan
6
0.30%
1
3.33%
Bhaktipriya Shridhar
5
0.25%
1
3.33%
Ingo Molnar
3
0.15%
1
3.33%
Kent Russell
3
0.15%
2
6.67%
Geert Uytterhoeven
2
0.10%
1
3.33%
Maninder Singh
2
0.10%
1
3.33%
Andrew Lutomirski
1
0.05%
1
3.33%
Vegard Nossum
1
0.05%
1
3.33%
Sasha Levin
1
0.05%
1
3.33%
Total
2023
100.00%
30
100.00%
Directory: drivers/gpu/drm/amd/amdkfd

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.