1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/types.h>
3 #include <linux/vmalloc.h>
4 #include <linux/mm.h>
5 #include <linux/clockchips.h>
6 #include <linux/acpi.h>
7 #include <linux/hyperv.h>
8 #include <linux/slab.h>
9 #include <linux/cpuhotplug.h>
10 #include <linux/minmax.h>
11 #include <asm/hypervisor.h>
12 #include <asm/mshyperv.h>
13 #include <asm/apic.h>
14 
15 #include <asm/trace/hyperv.h>
16 
17 /*
18  * See struct hv_deposit_memory. The first u64 is partition ID, the rest
19  * are GPAs.
20  */
21 #define HV_DEPOSIT_MAX (HV_HYP_PAGE_SIZE / sizeof(u64) - 1)
22 
23 /* Deposits exact number of pages. Must be called with interrupts enabled.  */
hv_call_deposit_pages(int node,u64 partition_id,u32 num_pages)24 int hv_call_deposit_pages(int node, u64 partition_id, u32 num_pages)
25 {
26 	struct page **pages, *page;
27 	int *counts;
28 	int num_allocations;
29 	int i, j, page_count;
30 	int order;
31 	u64 status;
32 	int ret;
33 	u64 base_pfn;
34 	struct hv_deposit_memory *input_page;
35 	unsigned long flags;
36 
37 	if (num_pages > HV_DEPOSIT_MAX)
38 		return -E2BIG;
39 	if (!num_pages)
40 		return 0;
41 
42 	/* One buffer for page pointers and counts */
43 	page = alloc_page(GFP_KERNEL);
44 	if (!page)
45 		return -ENOMEM;
46 	pages = page_address(page);
47 
48 	counts = kcalloc(HV_DEPOSIT_MAX, sizeof(int), GFP_KERNEL);
49 	if (!counts) {
50 		free_page((unsigned long)pages);
51 		return -ENOMEM;
52 	}
53 
54 	/* Allocate all the pages before disabling interrupts */
55 	i = 0;
56 
57 	while (num_pages) {
58 		/* Find highest order we can actually allocate */
59 		order = 31 - __builtin_clz(num_pages);
60 
61 		while (1) {
62 			pages[i] = alloc_pages_node(node, GFP_KERNEL, order);
63 			if (pages[i])
64 				break;
65 			if (!order) {
66 				ret = -ENOMEM;
67 				num_allocations = i;
68 				goto err_free_allocations;
69 			}
70 			--order;
71 		}
72 
73 		split_page(pages[i], order);
74 		counts[i] = 1 << order;
75 		num_pages -= counts[i];
76 		i++;
77 	}
78 	num_allocations = i;
79 
80 	local_irq_save(flags);
81 
82 	input_page = *this_cpu_ptr(hyperv_pcpu_input_arg);
83 
84 	input_page->partition_id = partition_id;
85 
86 	/* Populate gpa_page_list - these will fit on the input page */
87 	for (i = 0, page_count = 0; i < num_allocations; ++i) {
88 		base_pfn = page_to_pfn(pages[i]);
89 		for (j = 0; j < counts[i]; ++j, ++page_count)
90 			input_page->gpa_page_list[page_count] = base_pfn + j;
91 	}
92 	status = hv_do_rep_hypercall(HVCALL_DEPOSIT_MEMORY,
93 				     page_count, 0, input_page, NULL);
94 	local_irq_restore(flags);
95 	if (!hv_result_success(status)) {
96 		pr_err("Failed to deposit pages: %lld\n", status);
97 		ret = hv_result(status);
98 		goto err_free_allocations;
99 	}
100 
101 	ret = 0;
102 	goto free_buf;
103 
104 err_free_allocations:
105 	for (i = 0; i < num_allocations; ++i) {
106 		base_pfn = page_to_pfn(pages[i]);
107 		for (j = 0; j < counts[i]; ++j)
108 			__free_page(pfn_to_page(base_pfn + j));
109 	}
110 
111 free_buf:
112 	free_page((unsigned long)pages);
113 	kfree(counts);
114 	return ret;
115 }
116 
hv_call_add_logical_proc(int node,u32 lp_index,u32 apic_id)117 int hv_call_add_logical_proc(int node, u32 lp_index, u32 apic_id)
118 {
119 	struct hv_add_logical_processor_in *input;
120 	struct hv_add_logical_processor_out *output;
121 	u64 status;
122 	unsigned long flags;
123 	int ret = HV_STATUS_SUCCESS;
124 	int pxm = node_to_pxm(node);
125 
126 	/*
127 	 * When adding a logical processor, the hypervisor may return
128 	 * HV_STATUS_INSUFFICIENT_MEMORY. When that happens, we deposit more
129 	 * pages and retry.
130 	 */
131 	do {
132 		local_irq_save(flags);
133 
134 		input = *this_cpu_ptr(hyperv_pcpu_input_arg);
135 		/* We don't do anything with the output right now */
136 		output = *this_cpu_ptr(hyperv_pcpu_output_arg);
137 
138 		input->lp_index = lp_index;
139 		input->apic_id = apic_id;
140 		input->flags = 0;
141 		input->proximity_domain_info.domain_id = pxm;
142 		input->proximity_domain_info.flags.reserved = 0;
143 		input->proximity_domain_info.flags.proximity_info_valid = 1;
144 		input->proximity_domain_info.flags.proximity_preferred = 1;
145 		status = hv_do_hypercall(HVCALL_ADD_LOGICAL_PROCESSOR,
146 					 input, output);
147 		local_irq_restore(flags);
148 
149 		if (hv_result(status) != HV_STATUS_INSUFFICIENT_MEMORY) {
150 			if (!hv_result_success(status)) {
151 				pr_err("%s: cpu %u apic ID %u, %lld\n", __func__,
152 				       lp_index, apic_id, status);
153 				ret = hv_result(status);
154 			}
155 			break;
156 		}
157 		ret = hv_call_deposit_pages(node, hv_current_partition_id, 1);
158 	} while (!ret);
159 
160 	return ret;
161 }
162 
hv_call_create_vp(int node,u64 partition_id,u32 vp_index,u32 flags)163 int hv_call_create_vp(int node, u64 partition_id, u32 vp_index, u32 flags)
164 {
165 	struct hv_create_vp *input;
166 	u64 status;
167 	unsigned long irq_flags;
168 	int ret = HV_STATUS_SUCCESS;
169 	int pxm = node_to_pxm(node);
170 
171 	/* Root VPs don't seem to need pages deposited */
172 	if (partition_id != hv_current_partition_id) {
173 		/* The value 90 is empirically determined. It may change. */
174 		ret = hv_call_deposit_pages(node, partition_id, 90);
175 		if (ret)
176 			return ret;
177 	}
178 
179 	do {
180 		local_irq_save(irq_flags);
181 
182 		input = *this_cpu_ptr(hyperv_pcpu_input_arg);
183 
184 		input->partition_id = partition_id;
185 		input->vp_index = vp_index;
186 		input->flags = flags;
187 		input->subnode_type = HvSubnodeAny;
188 		if (node != NUMA_NO_NODE) {
189 			input->proximity_domain_info.domain_id = pxm;
190 			input->proximity_domain_info.flags.reserved = 0;
191 			input->proximity_domain_info.flags.proximity_info_valid = 1;
192 			input->proximity_domain_info.flags.proximity_preferred = 1;
193 		} else {
194 			input->proximity_domain_info.as_uint64 = 0;
195 		}
196 		status = hv_do_hypercall(HVCALL_CREATE_VP, input, NULL);
197 		local_irq_restore(irq_flags);
198 
199 		if (hv_result(status) != HV_STATUS_INSUFFICIENT_MEMORY) {
200 			if (!hv_result_success(status)) {
201 				pr_err("%s: vcpu %u, lp %u, %lld\n", __func__,
202 				       vp_index, flags, status);
203 				ret = hv_result(status);
204 			}
205 			break;
206 		}
207 		ret = hv_call_deposit_pages(node, partition_id, 1);
208 
209 	} while (!ret);
210 
211 	return ret;
212 }
213 
214