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 = xen_remap(gfn << XEN_PAGE_SHIFT, XEN_PAGE_SIZE);
 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 int xencons_remove(struct xenbus_device *dev)
 424 {
 425         return 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_interdomain_evtchn_to_irq_lateeoi(dev->otherend_id, 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 };
 591 #endif /* CONFIG_HVC_XEN_FRONTEND */
 592
 593 static int __init xen_hvc_init(void)
 594 {
 595         int r;
 596         struct xencons_info *info;
 597         const struct hv_ops *ops;
 598
 599         if (!xen_domain())
 600                 return -ENODEV;
 601
 602         if (xen_initial_domain()) {
 603                 ops = &dom0_hvc_ops;
 604                 r = xen_initial_domain_console_init();
 605                 if (r < 0)
 606                         goto register_fe;
 607                 info = vtermno_to_xencons(HVC_COOKIE);
 608         } else {
 609                 ops = &domU_hvc_ops;
 610                 if (xen_hvm_domain())
 611                         r = xen_hvm_console_init();
 612                 else
 613                         r = xen_pv_console_init();
 614                 if (r < 0)
 615                         goto register_fe;
 616
 617                 info = vtermno_to_xencons(HVC_COOKIE);
 618                 info->irq = bind_evtchn_to_irq_lateeoi(info->evtchn);
 619         }
 620         if (info->irq < 0)
 621                 info->irq = 0; /* NO_IRQ */
 622         else
 623                 irq_set_noprobe(info->irq);
 624
 625         info->hvc = hvc_alloc(HVC_COOKIE, info->irq, ops, 256);
 626         if (IS_ERR(info->hvc)) {
 627                 unsigned long flags;
 628
 629                 r = PTR_ERR(info->hvc);
 630                 spin_lock_irqsave(&xencons_lock, flags);
 631                 list_del(&info->list);
 632                 spin_unlock_irqrestore(&xencons_lock, flags);
 633                 if (info->irq)
 634                         evtchn_put(info->evtchn);
 635                 kfree(info);
 636                 return r;
 637         }
 638
 639         r = 0;
 640  register_fe:
 641 #ifdef CONFIG_HVC_XEN_FRONTEND
 642         r = xenbus_register_frontend(&xencons_driver);
 643 #endif
 644         return r;
 645 }
 646 device_initcall(xen_hvc_init);
 647
 648 static int xen_cons_init(void)
 649 {
 650         const struct hv_ops *ops;
 651
 652         if (!xen_domain())
 653                 return 0;
 654
 655         if (xen_initial_domain())
 656                 ops = &dom0_hvc_ops;
 657         else {
 658                 int r;
 659                 ops = &domU_hvc_ops;
 660
 661                 if (xen_hvm_domain())
 662                         r = xen_hvm_console_init();
 663                 else
 664                         r = xen_pv_console_init();
 665                 if (r < 0)
 666                         return r;
 667         }
 668
 669         hvc_instantiate(HVC_COOKIE, 0, ops);
 670         return 0;
 671 }
 672 console_initcall(xen_cons_init);
 673
 674 #ifdef CONFIG_X86
 675 static void xen_hvm_early_write(uint32_t vtermno, const char *str, int len)
 676 {
 677         if (xen_cpuid_base())
 678                 outsb(0xe9, str, len);
 679 }
 680 #else
 681 static void xen_hvm_early_write(uint32_t vtermno, const char *str, int len) { }
 682 #endif
 683
 684 #ifdef CONFIG_EARLY_PRINTK
 685 static int __init xenboot_console_setup(struct console *console, char *string)
 686 {
 687         static struct xencons_info xenboot;
 688
 689         if (xen_initial_domain())
 690                 return 0;
 691         if (!xen_pv_domain())
 692                 return -ENODEV;
 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 (!xen_pv_domain()) {
 704                 xen_hvm_early_write(0, string, len);
 705                 return;
 706         }
 707
 708         dom0_write_console(0, string, len);
 709
 710         if (xen_initial_domain())
 711                 return;
 712
 713         domU_write_console(0, "(early) ", 8);
 714         while (off < len && NULL != (pos = strchr(string+off, '\n'))) {
 715                 linelen = pos-string+off;
 716                 if (off + linelen > len)
 717                         break;
 718                 domU_write_console(0, string+off, linelen);
 719                 domU_write_console(0, "\r\n", 2);
 720                 off += linelen + 1;
 721         }
 722         if (off < len)
 723                 domU_write_console(0, string+off, len-off);
 724 }
 725
 726 struct console xenboot_console = {
 727         .name           = "xenboot",
 728         .write          = xenboot_write_console,
 729         .setup          = xenboot_console_setup,
 730         .flags          = CON_PRINTBUFFER | CON_BOOT | CON_ANYTIME,
 731         .index          = -1,
 732 };
 733 #endif  /* CONFIG_EARLY_PRINTK */
 734
 735 void xen_raw_console_write(const char *str)
 736 {
 737         ssize_t len = strlen(str);
 738         int rc = 0;
 739
 740         if (xen_domain()) {
 741                 rc = dom0_write_console(0, str, len);
 742                 if (rc != -ENOSYS || !xen_hvm_domain())
 743                         return;
 744         }
 745         xen_hvm_early_write(0, str, len);
 746 }
 747
 748 void xen_raw_printk(const char *fmt, ...)
 749 {
 750         static char buf[512];
 751         va_list ap;
 752
 753         va_start(ap, fmt);
 754         vsnprintf(buf, sizeof(buf), fmt, ap);
 755         va_end(ap);
 756
 757         xen_raw_console_write(buf);
 758 }
 759
 760 static void xenboot_earlycon_write(struct console *console,
 761                                   const char *string,
 762                                   unsigned len)
 763 {
 764         dom0_write_console(0, string, len);
 765 }
 766
 767 static int __init xenboot_earlycon_setup(struct earlycon_device *device,
 768                                             const char *opt)
 769 {
 770         device->con->write = xenboot_earlycon_write;
 771         return 0;
 772 }
 773 EARLYCON_DECLARE(xenboot, xenboot_earlycon_setup);