drivers/tty/hvc/hvc_xen.c

   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);