xref: /openbmc/linux/drivers/tty/hvc/hvc_xen.c (revision 236a9bf2) 
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * xen console driver interface to hvc_console.c
4  *
5  * (c) 2007 Gerd Hoffmann <kraxel@suse.de>
6  */
7 
8 #include <linux/console.h>
9 #include <linux/delay.h>
10 #include <linux/err.h>
11 #include <linux/irq.h>
12 #include <linux/init.h>
13 #include <linux/types.h>
14 #include <linux/list.h>
15 #include <linux/serial_core.h>
16 
17 #include <asm/io.h>
18 #include <asm/xen/hypervisor.h>
19 
20 #include <xen/xen.h>
21 #include <xen/interface/xen.h>
22 #include <xen/hvm.h>
23 #include <xen/grant_table.h>
24 #include <xen/page.h>
25 #include <xen/events.h>
26 #include <xen/interface/io/console.h>
27 #include <xen/interface/sched.h>
28 #include <xen/hvc-console.h>
29 #include <xen/xenbus.h>
30 
31 #include "hvc_console.h"
32 
33 #define HVC_COOKIE   0x58656e /* "Xen" in hex */
34 
35 struct xencons_info {
36 	struct list_head list;
37 	struct xenbus_device *xbdev;
38 	struct xencons_interface *intf;
39 	unsigned int evtchn;
40 	XENCONS_RING_IDX out_cons;
41 	unsigned int out_cons_same;
42 	struct hvc_struct *hvc;
43 	int irq;
44 	int vtermno;
45 	grant_ref_t gntref;
46 	spinlock_t ring_lock;
47 };
48 
49 static LIST_HEAD(xenconsoles);
50 static DEFINE_SPINLOCK(xencons_lock);
51 
52 /* ------------------------------------------------------------------ */
53 
54 static struct xencons_info *vtermno_to_xencons(int vtermno)
55 {
56 	struct xencons_info *entry, *ret = NULL;
57 	unsigned long flags;
58 
59 	spin_lock_irqsave(&xencons_lock, flags);
60 	if (list_empty(&xenconsoles)) {
61 		spin_unlock_irqrestore(&xencons_lock, flags);
62 		return NULL;
63 	}
64 
65 	list_for_each_entry(entry, &xenconsoles, list) {
66 		if (entry->vtermno == vtermno) {
67 			ret  = entry;
68 			break;
69 		}
70 	}
71 	spin_unlock_irqrestore(&xencons_lock, flags);
72 
73 	return ret;
74 }
75 
76 static inline int xenbus_devid_to_vtermno(int devid)
77 {
78 	return devid + HVC_COOKIE;
79 }
80 
81 static inline void notify_daemon(struct xencons_info *cons)
82 {
83 	/* Use evtchn: this is called early, before irq is set up. */
84 	notify_remote_via_evtchn(cons->evtchn);
85 }
86 
87 static int __write_console(struct xencons_info *xencons,
88 		const char *data, int len)
89 {
90 	XENCONS_RING_IDX cons, prod;
91 	struct xencons_interface *intf = xencons->intf;
92 	int sent = 0;
93 	unsigned long flags;
94 
95 	spin_lock_irqsave(&xencons->ring_lock, flags);
96 	cons = intf->out_cons;
97 	prod = intf->out_prod;
98 	mb();			/* update queue values before going on */
99 
100 	if ((prod - cons) > sizeof(intf->out)) {
101 		spin_unlock_irqrestore(&xencons->ring_lock, flags);
102 		pr_err_once("xencons: Illegal ring page indices");
103 		return -EINVAL;
104 	}
105 
106 	while ((sent < len) && ((prod - cons) < sizeof(intf->out)))
107 		intf->out[MASK_XENCONS_IDX(prod++, intf->out)] = data[sent++];
108 
109 	wmb();			/* write ring before updating pointer */
110 	intf->out_prod = prod;
111 	spin_unlock_irqrestore(&xencons->ring_lock, flags);
112 
113 	if (sent)
114 		notify_daemon(xencons);
115 	return sent;
116 }
117 
118 static int domU_write_console(uint32_t vtermno, const char *data, int len)
119 {
120 	int ret = len;
121 	struct xencons_info *cons = vtermno_to_xencons(vtermno);
122 	if (cons == NULL)
123 		return -EINVAL;
124 
125 	/*
126 	 * Make sure the whole buffer is emitted, polling if
127 	 * necessary.  We don't ever want to rely on the hvc daemon
128 	 * because the most interesting console output is when the
129 	 * kernel is crippled.
130 	 */
131 	while (len) {
132 		int sent = __write_console(cons, data, len);
133 
134 		if (sent < 0)
135 			return sent;
136 
137 		data += sent;
138 		len -= sent;
139 
140 		if (unlikely(len))
141 			HYPERVISOR_sched_op(SCHEDOP_yield, NULL);
142 	}
143 
144 	return ret;
145 }
146 
147 static int domU_read_console(uint32_t vtermno, char *buf, int len)
148 {
149 	struct xencons_interface *intf;
150 	XENCONS_RING_IDX cons, prod;
151 	int recv = 0;
152 	struct xencons_info *xencons = vtermno_to_xencons(vtermno);
153 	unsigned int eoiflag = 0;
154 	unsigned long flags;
155 
156 	if (xencons == NULL)
157 		return -EINVAL;
158 	intf = xencons->intf;
159 
160 	spin_lock_irqsave(&xencons->ring_lock, flags);
161 	cons = intf->in_cons;
162 	prod = intf->in_prod;
163 	mb();			/* get pointers before reading ring */
164 
165 	if ((prod - cons) > sizeof(intf->in)) {
166 		spin_unlock_irqrestore(&xencons->ring_lock, flags);
167 		pr_err_once("xencons: Illegal ring page indices");
168 		return -EINVAL;
169 	}
170 
171 	while (cons != prod && recv < len)
172 		buf[recv++] = intf->in[MASK_XENCONS_IDX(cons++, intf->in)];
173 
174 	mb();			/* read ring before consuming */
175 	intf->in_cons = cons;
176 
177 	/*
178 	 * When to mark interrupt having been spurious:
179 	 * - there was no new data to be read, and
180 	 * - the backend did not consume some output bytes, and
181 	 * - the previous round with no read data didn't see consumed bytes
182 	 *   (we might have a race with an interrupt being in flight while
183 	 *   updating xencons->out_cons, so account for that by allowing one
184 	 *   round without any visible reason)
185 	 */
186 	if (intf->out_cons != xencons->out_cons) {
187 		xencons->out_cons = intf->out_cons;
188 		xencons->out_cons_same = 0;
189 	}
190 	if (!recv && xencons->out_cons_same++ > 1) {
191 		eoiflag = XEN_EOI_FLAG_SPURIOUS;
192 	}
193 	spin_unlock_irqrestore(&xencons->ring_lock, flags);
194 
195 	if (recv) {
196 		notify_daemon(xencons);
197 	}
198 
199 	xen_irq_lateeoi(xencons->irq, eoiflag);
200 
201 	return recv;
202 }
203 
204 static const struct hv_ops domU_hvc_ops = {
205 	.get_chars = domU_read_console,
206 	.put_chars = domU_write_console,
207 	.notifier_add = notifier_add_irq,
208 	.notifier_del = notifier_del_irq,
209 	.notifier_hangup = notifier_hangup_irq,
210 };
211 
212 static int dom0_read_console(uint32_t vtermno, char *buf, int len)
213 {
214 	return HYPERVISOR_console_io(CONSOLEIO_read, len, buf);
215 }
216 
217 /*
218  * Either for a dom0 to write to the system console, or a domU with a
219  * debug version of Xen
220  */
221 static int dom0_write_console(uint32_t vtermno, const char *str, int len)
222 {
223 	int rc = HYPERVISOR_console_io(CONSOLEIO_write, len, (char *)str);
224 	if (rc < 0)
225 		return rc;
226 
227 	return len;
228 }
229 
230 static const struct hv_ops dom0_hvc_ops = {
231 	.get_chars = dom0_read_console,
232 	.put_chars = dom0_write_console,
233 	.notifier_add = notifier_add_irq,
234 	.notifier_del = notifier_del_irq,
235 	.notifier_hangup = notifier_hangup_irq,
236 };
237 
238 static int xen_hvm_console_init(void)
239 {
240 	int r;
241 	uint64_t v = 0;
242 	unsigned long gfn, flags;
243 	struct xencons_info *info;
244 
245 	if (!xen_hvm_domain())
246 		return -ENODEV;
247 
248 	info = vtermno_to_xencons(HVC_COOKIE);
249 	if (!info) {
250 		info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL);
251 		if (!info)
252 			return -ENOMEM;
253 		spin_lock_init(&info->ring_lock);
254 	} else if (info->intf != NULL) {
255 		/* already configured */
256 		return 0;
257 	}
258 	/*
259 	 * If the toolstack (or the hypervisor) hasn't set these values, the
260 	 * default value is 0. Even though gfn = 0 and evtchn = 0 are
261 	 * theoretically correct values, in practice they never are and they
262 	 * mean that a legacy toolstack hasn't initialized the pv console correctly.
263 	 */
264 	r = hvm_get_parameter(HVM_PARAM_CONSOLE_EVTCHN, &v);
265 	if (r < 0 || v == 0)
266 		goto err;
267 	info->evtchn = v;
268 	v = 0;
269 	r = hvm_get_parameter(HVM_PARAM_CONSOLE_PFN, &v);
270 	if (r < 0 || v == 0)
271 		goto err;
272 	gfn = v;
273 	info->intf = memremap(gfn << XEN_PAGE_SHIFT, XEN_PAGE_SIZE, MEMREMAP_WB);
274 	if (info->intf == NULL)
275 		goto err;
276 	info->vtermno = HVC_COOKIE;
277 
278 	spin_lock_irqsave(&xencons_lock, flags);
279 	list_add_tail(&info->list, &xenconsoles);
280 	spin_unlock_irqrestore(&xencons_lock, flags);
281 
282 	return 0;
283 err:
284 	kfree(info);
285 	return -ENODEV;
286 }
287 
288 static int xencons_info_pv_init(struct xencons_info *info, int vtermno)
289 {
290 	spin_lock_init(&info->ring_lock);
291 	info->evtchn = xen_start_info->console.domU.evtchn;
292 	/* GFN == MFN for PV guest */
293 	info->intf = gfn_to_virt(xen_start_info->console.domU.mfn);
294 	info->vtermno = vtermno;
295 
296 	list_add_tail(&info->list, &xenconsoles);
297 
298 	return 0;
299 }
300 
301 static int xen_pv_console_init(void)
302 {
303 	struct xencons_info *info;
304 	unsigned long flags;
305 
306 	if (!xen_pv_domain())
307 		return -ENODEV;
308 
309 	if (!xen_start_info->console.domU.evtchn)
310 		return -ENODEV;
311 
312 	info = vtermno_to_xencons(HVC_COOKIE);
313 	if (!info) {
314 		info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL);
315 		if (!info)
316 			return -ENOMEM;
317 	} else if (info->intf != NULL) {
318 		/* already configured */
319 		return 0;
320 	}
321 	spin_lock_irqsave(&xencons_lock, flags);
322 	xencons_info_pv_init(info, HVC_COOKIE);
323 	spin_unlock_irqrestore(&xencons_lock, flags);
324 
325 	return 0;
326 }
327 
328 static int xen_initial_domain_console_init(void)
329 {
330 	struct xencons_info *info;
331 	unsigned long flags;
332 
333 	if (!xen_initial_domain())
334 		return -ENODEV;
335 
336 	info = vtermno_to_xencons(HVC_COOKIE);
337 	if (!info) {
338 		info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL);
339 		if (!info)
340 			return -ENOMEM;
341 		spin_lock_init(&info->ring_lock);
342 	}
343 
344 	info->irq = bind_virq_to_irq(VIRQ_CONSOLE, 0, false);
345 	info->vtermno = HVC_COOKIE;
346 
347 	spin_lock_irqsave(&xencons_lock, flags);
348 	list_add_tail(&info->list, &xenconsoles);
349 	spin_unlock_irqrestore(&xencons_lock, flags);
350 
351 	return 0;
352 }
353 
354 static void xen_console_update_evtchn(struct xencons_info *info)
355 {
356 	if (xen_hvm_domain()) {
357 		uint64_t v = 0;
358 		int err;
359 
360 		err = hvm_get_parameter(HVM_PARAM_CONSOLE_EVTCHN, &v);
361 		if (!err && v)
362 			info->evtchn = v;
363 	} else
364 		info->evtchn = xen_start_info->console.domU.evtchn;
365 }
366 
367 void xen_console_resume(void)
368 {
369 	struct xencons_info *info = vtermno_to_xencons(HVC_COOKIE);
370 	if (info != NULL && info->irq) {
371 		if (!xen_initial_domain())
372 			xen_console_update_evtchn(info);
373 		rebind_evtchn_irq(info->evtchn, info->irq);
374 	}
375 }
376 
377 #ifdef CONFIG_HVC_XEN_FRONTEND
378 static void xencons_disconnect_backend(struct xencons_info *info)
379 {
380 	if (info->hvc != NULL)
381 		hvc_remove(info->hvc);
382 	info->hvc = NULL;
383 	if (info->irq > 0) {
384 		evtchn_put(info->evtchn);
385 		info->irq = 0;
386 		info->evtchn = 0;
387 	}
388 	/* evtchn_put() will also close it so this is only an error path */
389 	if (info->evtchn > 0)
390 		xenbus_free_evtchn(info->xbdev, info->evtchn);
391 	info->evtchn = 0;
392 	if (info->gntref > 0)
393 		gnttab_free_grant_references(info->gntref);
394 	info->gntref = 0;
395 }
396 
397 static void xencons_free(struct xencons_info *info)
398 {
399 	free_page((unsigned long)info->intf);
400 	info->intf = NULL;
401 	info->vtermno = 0;
402 	kfree(info);
403 }
404 
405 static int xen_console_remove(struct xencons_info *info)
406 {
407 	unsigned long flags;
408 
409 	xencons_disconnect_backend(info);
410 	spin_lock_irqsave(&xencons_lock, flags);
411 	list_del(&info->list);
412 	spin_unlock_irqrestore(&xencons_lock, flags);
413 	if (info->xbdev != NULL)
414 		xencons_free(info);
415 	else {
416 		if (xen_hvm_domain())
417 			iounmap(info->intf);
418 		kfree(info);
419 	}
420 	return 0;
421 }
422 
423 static void xencons_remove(struct xenbus_device *dev)
424 {
425 	xen_console_remove(dev_get_drvdata(&dev->dev));
426 }
427 
428 static int xencons_connect_backend(struct xenbus_device *dev,
429 				  struct xencons_info *info)
430 {
431 	int ret, evtchn, devid, ref, irq;
432 	struct xenbus_transaction xbt;
433 	grant_ref_t gref_head;
434 
435 	ret = xenbus_alloc_evtchn(dev, &evtchn);
436 	if (ret)
437 		return ret;
438 	info->evtchn = evtchn;
439 	irq = bind_evtchn_to_irq_lateeoi(evtchn);
440 	if (irq < 0)
441 		return irq;
442 	info->irq = irq;
443 	devid = dev->nodename[strlen(dev->nodename) - 1] - '0';
444 	info->hvc = hvc_alloc(xenbus_devid_to_vtermno(devid),
445 			irq, &domU_hvc_ops, 256);
446 	if (IS_ERR(info->hvc))
447 		return PTR_ERR(info->hvc);
448 	ret = gnttab_alloc_grant_references(1, &gref_head);
449 	if (ret < 0)
450 		return ret;
451 	info->gntref = gref_head;
452 	ref = gnttab_claim_grant_reference(&gref_head);
453 	if (ref < 0)
454 		return ref;
455 	gnttab_grant_foreign_access_ref(ref, info->xbdev->otherend_id,
456 					virt_to_gfn(info->intf), 0);
457 
458  again:
459 	ret = xenbus_transaction_start(&xbt);
460 	if (ret) {
461 		xenbus_dev_fatal(dev, ret, "starting transaction");
462 		return ret;
463 	}
464 	ret = xenbus_printf(xbt, dev->nodename, "ring-ref", "%d", ref);
465 	if (ret)
466 		goto error_xenbus;
467 	ret = xenbus_printf(xbt, dev->nodename, "port", "%u",
468 			    evtchn);
469 	if (ret)
470 		goto error_xenbus;
471 	ret = xenbus_transaction_end(xbt, 0);
472 	if (ret) {
473 		if (ret == -EAGAIN)
474 			goto again;
475 		xenbus_dev_fatal(dev, ret, "completing transaction");
476 		return ret;
477 	}
478 
479 	xenbus_switch_state(dev, XenbusStateInitialised);
480 	return 0;
481 
482  error_xenbus:
483 	xenbus_transaction_end(xbt, 1);
484 	xenbus_dev_fatal(dev, ret, "writing xenstore");
485 	return ret;
486 }
487 
488 static int xencons_probe(struct xenbus_device *dev,
489 				  const struct xenbus_device_id *id)
490 {
491 	int ret, devid;
492 	struct xencons_info *info;
493 	unsigned long flags;
494 
495 	devid = dev->nodename[strlen(dev->nodename) - 1] - '0';
496 	if (devid == 0)
497 		return -ENODEV;
498 
499 	info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL);
500 	if (!info)
501 		return -ENOMEM;
502 	spin_lock_init(&info->ring_lock);
503 	dev_set_drvdata(&dev->dev, info);
504 	info->xbdev = dev;
505 	info->vtermno = xenbus_devid_to_vtermno(devid);
506 	info->intf = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
507 	if (!info->intf)
508 		goto error_nomem;
509 
510 	ret = xencons_connect_backend(dev, info);
511 	if (ret < 0)
512 		goto error;
513 	spin_lock_irqsave(&xencons_lock, flags);
514 	list_add_tail(&info->list, &xenconsoles);
515 	spin_unlock_irqrestore(&xencons_lock, flags);
516 
517 	return 0;
518 
519  error_nomem:
520 	ret = -ENOMEM;
521 	xenbus_dev_fatal(dev, ret, "allocating device memory");
522  error:
523 	xencons_disconnect_backend(info);
524 	xencons_free(info);
525 	return ret;
526 }
527 
528 static int xencons_resume(struct xenbus_device *dev)
529 {
530 	struct xencons_info *info = dev_get_drvdata(&dev->dev);
531 
532 	xencons_disconnect_backend(info);
533 	memset(info->intf, 0, XEN_PAGE_SIZE);
534 	return xencons_connect_backend(dev, info);
535 }
536 
537 static void xencons_backend_changed(struct xenbus_device *dev,
538 				   enum xenbus_state backend_state)
539 {
540 	switch (backend_state) {
541 	case XenbusStateReconfiguring:
542 	case XenbusStateReconfigured:
543 	case XenbusStateInitialising:
544 	case XenbusStateInitialised:
545 	case XenbusStateUnknown:
546 		break;
547 
548 	case XenbusStateInitWait:
549 		break;
550 
551 	case XenbusStateConnected:
552 		xenbus_switch_state(dev, XenbusStateConnected);
553 		break;
554 
555 	case XenbusStateClosed:
556 		if (dev->state == XenbusStateClosed)
557 			break;
558 		fallthrough;	/* Missed the backend's CLOSING state */
559 	case XenbusStateClosing: {
560 		struct xencons_info *info = dev_get_drvdata(&dev->dev);;
561 
562 		/*
563 		 * Don't tear down the evtchn and grant ref before the other
564 		 * end has disconnected, but do stop userspace from trying
565 		 * to use the device before we allow the backend to close.
566 		 */
567 		if (info->hvc) {
568 			hvc_remove(info->hvc);
569 			info->hvc = NULL;
570 		}
571 
572 		xenbus_frontend_closed(dev);
573 		break;
574 	}
575 	}
576 }
577 
578 static const struct xenbus_device_id xencons_ids[] = {
579 	{ "console" },
580 	{ "" }
581 };
582 
583 static struct xenbus_driver xencons_driver = {
584 	.name = "xenconsole",
585 	.ids = xencons_ids,
586 	.probe = xencons_probe,
587 	.remove = xencons_remove,
588 	.resume = xencons_resume,
589 	.otherend_changed = xencons_backend_changed,
590 	.not_essential = true,
591 };
592 #endif /* CONFIG_HVC_XEN_FRONTEND */
593 
594 static int __init xen_hvc_init(void)
595 {
596 	int r;
597 	struct xencons_info *info;
598 	const struct hv_ops *ops;
599 
600 	if (!xen_domain())
601 		return -ENODEV;
602 
603 	if (xen_initial_domain()) {
604 		ops = &dom0_hvc_ops;
605 		r = xen_initial_domain_console_init();
606 		if (r < 0)
607 			goto register_fe;
608 		info = vtermno_to_xencons(HVC_COOKIE);
609 	} else {
610 		ops = &domU_hvc_ops;
611 		if (xen_hvm_domain())
612 			r = xen_hvm_console_init();
613 		else
614 			r = xen_pv_console_init();
615 		if (r < 0)
616 			goto register_fe;
617 
618 		info = vtermno_to_xencons(HVC_COOKIE);
619 		info->irq = bind_evtchn_to_irq_lateeoi(info->evtchn);
620 	}
621 	if (info->irq < 0)
622 		info->irq = 0; /* NO_IRQ */
623 	else
624 		irq_set_noprobe(info->irq);
625 
626 	info->hvc = hvc_alloc(HVC_COOKIE, info->irq, ops, 256);
627 	if (IS_ERR(info->hvc)) {
628 		unsigned long flags;
629 
630 		r = PTR_ERR(info->hvc);
631 		spin_lock_irqsave(&xencons_lock, flags);
632 		list_del(&info->list);
633 		spin_unlock_irqrestore(&xencons_lock, flags);
634 		if (info->irq)
635 			evtchn_put(info->evtchn);
636 		kfree(info);
637 		return r;
638 	}
639 
640 	r = 0;
641  register_fe:
642 #ifdef CONFIG_HVC_XEN_FRONTEND
643 	r = xenbus_register_frontend(&xencons_driver);
644 #endif
645 	return r;
646 }
647 device_initcall(xen_hvc_init);
648 
649 static int xen_cons_init(void)
650 {
651 	const struct hv_ops *ops;
652 
653 	if (!xen_domain())
654 		return 0;
655 
656 	if (xen_initial_domain())
657 		ops = &dom0_hvc_ops;
658 	else {
659 		int r;
660 		ops = &domU_hvc_ops;
661 
662 		if (xen_hvm_domain())
663 			r = xen_hvm_console_init();
664 		else
665 			r = xen_pv_console_init();
666 		if (r < 0)
667 			return r;
668 	}
669 
670 	hvc_instantiate(HVC_COOKIE, 0, ops);
671 	return 0;
672 }
673 console_initcall(xen_cons_init);
674 
675 #ifdef CONFIG_X86
676 static void xen_hvm_early_write(uint32_t vtermno, const char *str, int len)
677 {
678 	if (xen_cpuid_base())
679 		outsb(0xe9, str, len);
680 }
681 #else
682 static void xen_hvm_early_write(uint32_t vtermno, const char *str, int len) { }
683 #endif
684 
685 #ifdef CONFIG_EARLY_PRINTK
686 static int __init xenboot_console_setup(struct console *console, char *string)
687 {
688 	static struct xencons_info xenboot;
689 
690 	if (xen_initial_domain() || !xen_pv_domain())
691 		return 0;
692 
693 	return xencons_info_pv_init(&xenboot, 0);
694 }
695 
696 static void xenboot_write_console(struct console *console, const char *string,
697 				  unsigned len)
698 {
699 	unsigned int linelen, off = 0;
700 	const char *pos;
701 
702 	if (dom0_write_console(0, string, len) >= 0)
703 		return;
704 
705 	if (!xen_pv_domain()) {
706 		xen_hvm_early_write(0, string, len);
707 		return;
708 	}
709 
710 	if (domU_write_console(0, "(early) ", 8) < 0)
711 		return;
712 	while (off < len && NULL != (pos = strchr(string+off, '\n'))) {
713 		linelen = pos-string+off;
714 		if (off + linelen > len)
715 			break;
716 		domU_write_console(0, string+off, linelen);
717 		domU_write_console(0, "\r\n", 2);
718 		off += linelen + 1;
719 	}
720 	if (off < len)
721 		domU_write_console(0, string+off, len-off);
722 }
723 
724 struct console xenboot_console = {
725 	.name		= "xenboot",
726 	.write		= xenboot_write_console,
727 	.setup		= xenboot_console_setup,
728 	.flags		= CON_PRINTBUFFER | CON_BOOT | CON_ANYTIME,
729 	.index		= -1,
730 };
731 #endif	/* CONFIG_EARLY_PRINTK */
732 
733 void xen_raw_console_write(const char *str)
734 {
735 	ssize_t len = strlen(str);
736 	int rc = 0;
737 
738 	if (xen_domain()) {
739 		rc = dom0_write_console(0, str, len);
740 		if (rc != -ENOSYS || !xen_hvm_domain())
741 			return;
742 	}
743 	xen_hvm_early_write(0, str, len);
744 }
745 
746 void xen_raw_printk(const char *fmt, ...)
747 {
748 	static char buf[512];
749 	va_list ap;
750 
751 	va_start(ap, fmt);
752 	vsnprintf(buf, sizeof(buf), fmt, ap);
753 	va_end(ap);
754 
755 	xen_raw_console_write(buf);
756 }
757 
758 static void xenboot_earlycon_write(struct console *console,
759 				  const char *string,
760 				  unsigned len)
761 {
762 	dom0_write_console(0, string, len);
763 }
764 
765 static int __init xenboot_earlycon_setup(struct earlycon_device *device,
766 					    const char *opt)
767 {
768 	device->con->write = xenboot_earlycon_write;
769 	return 0;
770 }
771 EARLYCON_DECLARE(xenboot, xenboot_earlycon_setup);
772