xref: /openbmc/linux/drivers/xen/pcpu.c (revision b34e08d5)
1 /******************************************************************************
2  * pcpu.c
3  * Management physical cpu in dom0, get pcpu info and provide sys interface
4  *
5  * Copyright (c) 2012 Intel Corporation
6  * Author: Liu, Jinsong <jinsong.liu@intel.com>
7  * Author: Jiang, Yunhong <yunhong.jiang@intel.com>
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License version 2
11  * as published by the Free Software Foundation; or, when distributed
12  * separately from the Linux kernel or incorporated into other
13  * software packages, subject to the following license:
14  *
15  * Permission is hereby granted, free of charge, to any person obtaining a copy
16  * of this source file (the "Software"), to deal in the Software without
17  * restriction, including without limitation the rights to use, copy, modify,
18  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
19  * and to permit persons to whom the Software is furnished to do so, subject to
20  * the following conditions:
21  *
22  * The above copyright notice and this permission notice shall be included in
23  * all copies or substantial portions of the Software.
24  *
25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
26  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
27  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
28  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
29  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
30  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
31  * IN THE SOFTWARE.
32  */
33 
34 #define pr_fmt(fmt) "xen_cpu: " fmt
35 
36 #include <linux/interrupt.h>
37 #include <linux/spinlock.h>
38 #include <linux/cpu.h>
39 #include <linux/stat.h>
40 #include <linux/capability.h>
41 
42 #include <xen/xen.h>
43 #include <xen/acpi.h>
44 #include <xen/xenbus.h>
45 #include <xen/events.h>
46 #include <xen/interface/platform.h>
47 #include <asm/xen/hypervisor.h>
48 #include <asm/xen/hypercall.h>
49 
50 
51 /*
52  * @cpu_id: Xen physical cpu logic number
53  * @flags: Xen physical cpu status flag
54  * - XEN_PCPU_FLAGS_ONLINE: cpu is online
55  * - XEN_PCPU_FLAGS_INVALID: cpu is not present
56  */
57 struct pcpu {
58 	struct list_head list;
59 	struct device dev;
60 	uint32_t cpu_id;
61 	uint32_t flags;
62 };
63 
64 static struct bus_type xen_pcpu_subsys = {
65 	.name = "xen_cpu",
66 	.dev_name = "xen_cpu",
67 };
68 
69 static DEFINE_MUTEX(xen_pcpu_lock);
70 
71 static LIST_HEAD(xen_pcpus);
72 
73 static int xen_pcpu_down(uint32_t cpu_id)
74 {
75 	struct xen_platform_op op = {
76 		.cmd			= XENPF_cpu_offline,
77 		.interface_version	= XENPF_INTERFACE_VERSION,
78 		.u.cpu_ol.cpuid		= cpu_id,
79 	};
80 
81 	return HYPERVISOR_dom0_op(&op);
82 }
83 
84 static int xen_pcpu_up(uint32_t cpu_id)
85 {
86 	struct xen_platform_op op = {
87 		.cmd			= XENPF_cpu_online,
88 		.interface_version	= XENPF_INTERFACE_VERSION,
89 		.u.cpu_ol.cpuid		= cpu_id,
90 	};
91 
92 	return HYPERVISOR_dom0_op(&op);
93 }
94 
95 static ssize_t show_online(struct device *dev,
96 			   struct device_attribute *attr,
97 			   char *buf)
98 {
99 	struct pcpu *cpu = container_of(dev, struct pcpu, dev);
100 
101 	return sprintf(buf, "%u\n", !!(cpu->flags & XEN_PCPU_FLAGS_ONLINE));
102 }
103 
104 static ssize_t __ref store_online(struct device *dev,
105 				  struct device_attribute *attr,
106 				  const char *buf, size_t count)
107 {
108 	struct pcpu *pcpu = container_of(dev, struct pcpu, dev);
109 	unsigned long long val;
110 	ssize_t ret;
111 
112 	if (!capable(CAP_SYS_ADMIN))
113 		return -EPERM;
114 
115 	if (kstrtoull(buf, 0, &val) < 0)
116 		return -EINVAL;
117 
118 	switch (val) {
119 	case 0:
120 		ret = xen_pcpu_down(pcpu->cpu_id);
121 		break;
122 	case 1:
123 		ret = xen_pcpu_up(pcpu->cpu_id);
124 		break;
125 	default:
126 		ret = -EINVAL;
127 	}
128 
129 	if (ret >= 0)
130 		ret = count;
131 	return ret;
132 }
133 static DEVICE_ATTR(online, S_IRUGO | S_IWUSR, show_online, store_online);
134 
135 static bool xen_pcpu_online(uint32_t flags)
136 {
137 	return !!(flags & XEN_PCPU_FLAGS_ONLINE);
138 }
139 
140 static void pcpu_online_status(struct xenpf_pcpuinfo *info,
141 			       struct pcpu *pcpu)
142 {
143 	if (xen_pcpu_online(info->flags) &&
144 	   !xen_pcpu_online(pcpu->flags)) {
145 		/* the pcpu is onlined */
146 		pcpu->flags |= XEN_PCPU_FLAGS_ONLINE;
147 		kobject_uevent(&pcpu->dev.kobj, KOBJ_ONLINE);
148 	} else if (!xen_pcpu_online(info->flags) &&
149 		    xen_pcpu_online(pcpu->flags)) {
150 		/* The pcpu is offlined */
151 		pcpu->flags &= ~XEN_PCPU_FLAGS_ONLINE;
152 		kobject_uevent(&pcpu->dev.kobj, KOBJ_OFFLINE);
153 	}
154 }
155 
156 static struct pcpu *get_pcpu(uint32_t cpu_id)
157 {
158 	struct pcpu *pcpu;
159 
160 	list_for_each_entry(pcpu, &xen_pcpus, list) {
161 		if (pcpu->cpu_id == cpu_id)
162 			return pcpu;
163 	}
164 
165 	return NULL;
166 }
167 
168 static void pcpu_release(struct device *dev)
169 {
170 	struct pcpu *pcpu = container_of(dev, struct pcpu, dev);
171 
172 	list_del(&pcpu->list);
173 	kfree(pcpu);
174 }
175 
176 static void unregister_and_remove_pcpu(struct pcpu *pcpu)
177 {
178 	struct device *dev;
179 
180 	if (!pcpu)
181 		return;
182 
183 	dev = &pcpu->dev;
184 	if (dev->id)
185 		device_remove_file(dev, &dev_attr_online);
186 
187 	/* pcpu remove would be implicitly done */
188 	device_unregister(dev);
189 }
190 
191 static int register_pcpu(struct pcpu *pcpu)
192 {
193 	struct device *dev;
194 	int err = -EINVAL;
195 
196 	if (!pcpu)
197 		return err;
198 
199 	dev = &pcpu->dev;
200 	dev->bus = &xen_pcpu_subsys;
201 	dev->id = pcpu->cpu_id;
202 	dev->release = pcpu_release;
203 
204 	err = device_register(dev);
205 	if (err) {
206 		pcpu_release(dev);
207 		return err;
208 	}
209 
210 	/*
211 	 * Xen never offline cpu0 due to several restrictions
212 	 * and assumptions. This basically doesn't add a sys control
213 	 * to user, one cannot attempt to offline BSP.
214 	 */
215 	if (dev->id) {
216 		err = device_create_file(dev, &dev_attr_online);
217 		if (err) {
218 			device_unregister(dev);
219 			return err;
220 		}
221 	}
222 
223 	return 0;
224 }
225 
226 static struct pcpu *create_and_register_pcpu(struct xenpf_pcpuinfo *info)
227 {
228 	struct pcpu *pcpu;
229 	int err;
230 
231 	if (info->flags & XEN_PCPU_FLAGS_INVALID)
232 		return ERR_PTR(-ENODEV);
233 
234 	pcpu = kzalloc(sizeof(struct pcpu), GFP_KERNEL);
235 	if (!pcpu)
236 		return ERR_PTR(-ENOMEM);
237 
238 	INIT_LIST_HEAD(&pcpu->list);
239 	pcpu->cpu_id = info->xen_cpuid;
240 	pcpu->flags = info->flags;
241 
242 	/* Need hold on xen_pcpu_lock before pcpu list manipulations */
243 	list_add_tail(&pcpu->list, &xen_pcpus);
244 
245 	err = register_pcpu(pcpu);
246 	if (err) {
247 		pr_warn("Failed to register pcpu%u\n", info->xen_cpuid);
248 		return ERR_PTR(-ENOENT);
249 	}
250 
251 	return pcpu;
252 }
253 
254 /*
255  * Caller should hold the xen_pcpu_lock
256  */
257 static int sync_pcpu(uint32_t cpu, uint32_t *max_cpu)
258 {
259 	int ret;
260 	struct pcpu *pcpu = NULL;
261 	struct xenpf_pcpuinfo *info;
262 	struct xen_platform_op op = {
263 		.cmd                   = XENPF_get_cpuinfo,
264 		.interface_version     = XENPF_INTERFACE_VERSION,
265 		.u.pcpu_info.xen_cpuid = cpu,
266 	};
267 
268 	ret = HYPERVISOR_dom0_op(&op);
269 	if (ret)
270 		return ret;
271 
272 	info = &op.u.pcpu_info;
273 	if (max_cpu)
274 		*max_cpu = info->max_present;
275 
276 	pcpu = get_pcpu(cpu);
277 
278 	/*
279 	 * Only those at cpu present map has its sys interface.
280 	 */
281 	if (info->flags & XEN_PCPU_FLAGS_INVALID) {
282 		unregister_and_remove_pcpu(pcpu);
283 		return 0;
284 	}
285 
286 	if (!pcpu) {
287 		pcpu = create_and_register_pcpu(info);
288 		if (IS_ERR_OR_NULL(pcpu))
289 			return -ENODEV;
290 	} else
291 		pcpu_online_status(info, pcpu);
292 
293 	return 0;
294 }
295 
296 /*
297  * Sync dom0's pcpu information with xen hypervisor's
298  */
299 static int xen_sync_pcpus(void)
300 {
301 	/*
302 	 * Boot cpu always have cpu_id 0 in xen
303 	 */
304 	uint32_t cpu = 0, max_cpu = 0;
305 	int err = 0;
306 	struct pcpu *pcpu, *tmp;
307 
308 	mutex_lock(&xen_pcpu_lock);
309 
310 	while (!err && (cpu <= max_cpu)) {
311 		err = sync_pcpu(cpu, &max_cpu);
312 		cpu++;
313 	}
314 
315 	if (err)
316 		list_for_each_entry_safe(pcpu, tmp, &xen_pcpus, list)
317 			unregister_and_remove_pcpu(pcpu);
318 
319 	mutex_unlock(&xen_pcpu_lock);
320 
321 	return err;
322 }
323 
324 static void xen_pcpu_work_fn(struct work_struct *work)
325 {
326 	xen_sync_pcpus();
327 }
328 static DECLARE_WORK(xen_pcpu_work, xen_pcpu_work_fn);
329 
330 static irqreturn_t xen_pcpu_interrupt(int irq, void *dev_id)
331 {
332 	schedule_work(&xen_pcpu_work);
333 	return IRQ_HANDLED;
334 }
335 
336 /* Sync with Xen hypervisor after cpu hotadded */
337 void xen_pcpu_hotplug_sync(void)
338 {
339 	schedule_work(&xen_pcpu_work);
340 }
341 EXPORT_SYMBOL_GPL(xen_pcpu_hotplug_sync);
342 
343 /*
344  * For hypervisor presented cpu, return logic cpu id;
345  * For hypervisor non-presented cpu, return -ENODEV.
346  */
347 int xen_pcpu_id(uint32_t acpi_id)
348 {
349 	int cpu_id = 0, max_id = 0;
350 	struct xen_platform_op op;
351 
352 	op.cmd = XENPF_get_cpuinfo;
353 	while (cpu_id <= max_id) {
354 		op.u.pcpu_info.xen_cpuid = cpu_id;
355 		if (HYPERVISOR_dom0_op(&op)) {
356 			cpu_id++;
357 			continue;
358 		}
359 
360 		if (acpi_id == op.u.pcpu_info.acpi_id)
361 			return cpu_id;
362 		if (op.u.pcpu_info.max_present > max_id)
363 			max_id = op.u.pcpu_info.max_present;
364 		cpu_id++;
365 	}
366 
367 	return -ENODEV;
368 }
369 EXPORT_SYMBOL_GPL(xen_pcpu_id);
370 
371 static int __init xen_pcpu_init(void)
372 {
373 	int irq, ret;
374 
375 	if (!xen_initial_domain())
376 		return -ENODEV;
377 
378 	irq = bind_virq_to_irqhandler(VIRQ_PCPU_STATE, 0,
379 				      xen_pcpu_interrupt, 0,
380 				      "xen-pcpu", NULL);
381 	if (irq < 0) {
382 		pr_warn("Failed to bind pcpu virq\n");
383 		return irq;
384 	}
385 
386 	ret = subsys_system_register(&xen_pcpu_subsys, NULL);
387 	if (ret) {
388 		pr_warn("Failed to register pcpu subsys\n");
389 		goto err1;
390 	}
391 
392 	ret = xen_sync_pcpus();
393 	if (ret) {
394 		pr_warn("Failed to sync pcpu info\n");
395 		goto err2;
396 	}
397 
398 	return 0;
399 
400 err2:
401 	bus_unregister(&xen_pcpu_subsys);
402 err1:
403 	unbind_from_irqhandler(irq, NULL);
404 	return ret;
405 }
406 arch_initcall(xen_pcpu_init);
407