1// SPDX-License-Identifier: GPL-2.0
 2#include <linux/dma-mapping.h>
 3#include <asm/iommu_table.h>
 4#include <linux/string.h>
 5#include <linux/kallsyms.h>
 6
 7
 8#define DEBUG 1
 9
10static struct iommu_table_entry * __init
11find_dependents_of(struct iommu_table_entry *start,
12		   struct iommu_table_entry *finish,
13		   struct iommu_table_entry *q)
14{
15	struct iommu_table_entry *p;
16
17	if (!q)
18		return NULL;
19
20	for (p = start; p < finish; p++)
21		if (p->detect == q->depend)
22			return p;
23
24	return NULL;
25}
26
27
28void __init sort_iommu_table(struct iommu_table_entry *start,
29			     struct iommu_table_entry *finish) {
30
31	struct iommu_table_entry *p, *q, tmp;
32
33	for (p = start; p < finish; p++) {
34again:
35		q = find_dependents_of(start, finish, p);
36		/* We are bit sneaky here. We use the memory address to figure
37		 * out if the node we depend on is past our point, if so, swap.
38		 */
39		if (q > p) {
40			tmp = *p;
41			memmove(p, q, sizeof(*p));
42			*q = tmp;
43			goto again;
44		}
45	}
46
47}
48
49#ifdef DEBUG
50void __init check_iommu_entries(struct iommu_table_entry *start,
51				struct iommu_table_entry *finish)
52{
53	struct iommu_table_entry *p, *q, *x;
54
55	/* Simple cyclic dependency checker. */
56	for (p = start; p < finish; p++) {
57		q = find_dependents_of(start, finish, p);
58		x = find_dependents_of(start, finish, q);
59		if (p == x) {
60			printk(KERN_ERR "CYCLIC DEPENDENCY FOUND! %pS depends on %pS and vice-versa. BREAKING IT.\n",
61			       p->detect, q->detect);
62			/* Heavy handed way..*/
63			x->depend = NULL;
64		}
65	}
66
67	for (p = start; p < finish; p++) {
68		q = find_dependents_of(p, finish, p);
69		if (q && q > p) {
70			printk(KERN_ERR "EXECUTION ORDER INVALID! %pS should be called before %pS!\n",
71			       p->detect, q->detect);
72		}
73	}
74}
75#else
76void __init check_iommu_entries(struct iommu_table_entry *start,
77				       struct iommu_table_entry *finish)
78{
79}
80#endif

 1// SPDX-License-Identifier: GPL-2.0
 2#include <linux/dma-mapping.h>
 3#include <asm/iommu_table.h>
 4#include <linux/string.h>
 5#include <linux/kallsyms.h>
 6
 
 
 
 7static struct iommu_table_entry * __init
 8find_dependents_of(struct iommu_table_entry *start,
 9		   struct iommu_table_entry *finish,
10		   struct iommu_table_entry *q)
11{
12	struct iommu_table_entry *p;
13
14	if (!q)
15		return NULL;
16
17	for (p = start; p < finish; p++)
18		if (p->detect == q->depend)
19			return p;
20
21	return NULL;
22}
23
24
25void __init sort_iommu_table(struct iommu_table_entry *start,
26			     struct iommu_table_entry *finish) {
27
28	struct iommu_table_entry *p, *q, tmp;
29
30	for (p = start; p < finish; p++) {
31again:
32		q = find_dependents_of(start, finish, p);
33		/* We are bit sneaky here. We use the memory address to figure
34		 * out if the node we depend on is past our point, if so, swap.
35		 */
36		if (q > p) {
37			tmp = *p;
38			memmove(p, q, sizeof(*p));
39			*q = tmp;
40			goto again;
41		}
42	}
43
44}
45
46#ifdef DEBUG
47void __init check_iommu_entries(struct iommu_table_entry *start,
48				struct iommu_table_entry *finish)
49{
50	struct iommu_table_entry *p, *q, *x;
51
52	/* Simple cyclic dependency checker. */
53	for (p = start; p < finish; p++) {
54		q = find_dependents_of(start, finish, p);
55		x = find_dependents_of(start, finish, q);
56		if (p == x) {
57			printk(KERN_ERR "CYCLIC DEPENDENCY FOUND! %pS depends on %pS and vice-versa. BREAKING IT.\n",
58			       p->detect, q->detect);
59			/* Heavy handed way..*/
60			x->depend = NULL;
61		}
62	}
63
64	for (p = start; p < finish; p++) {
65		q = find_dependents_of(p, finish, p);
66		if (q && q > p) {
67			printk(KERN_ERR "EXECUTION ORDER INVALID! %pS should be called before %pS!\n",
68			       p->detect, q->detect);
69		}
70	}
71}
72#else
73void __init check_iommu_entries(struct iommu_table_entry *start,
74				       struct iommu_table_entry *finish)
75{
76}
77#endif