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