[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Xen-devel] [PATCH 00/17 v5] SBSA UART emulation support in Xen

On 05/07/2017 20:43, Julien Grall wrote:

On 05/07/2017 20:06, Stefano Stabellini wrote:
On Wed, 5 Jul 2017, Julien Grall wrote:
On 07/04/2017 08:31 AM, Bhupinder Thakur wrote:
Hi Julien,

Hi Bhupinder,

Thank you for the summary!


Currently, UEFI firmware uses hvc as the console for input/output. Now
with the support
of SBSA UART in Xen, it is preferrable that UEFI firmware should be
able to the uart
as well.

One option which was discussed was to use pl011 purely as a debug
port. Currently the debug
prints are intermixed with the normal console output. Now with uart
port becoming available
the debug prints can be redirected to pl011 thus cleaning up the

Other option is to output everything on both HVC and pl011 both but it
takes away the advantage
of separating out the debug and normal console prints. However, pl011
can be used as debug
port based on a compile time flag. If this compile-time is off, then
the output can be sent to both
HVC and pl011.

Based on this discussion I feel that:
- the default behaviour should be writing the output to both HVC and

Hmmm. If I remember correctly this was suggested but ruled out. It was
considered that pl011 and PV console should not be treated equal.
PL011 would
be used for boot diagnostics (i.e imagine an Image with no Xen support).

Actually I remember the opposite:
afd2e931-706b-6e25-1f0e-feee16e83c88@xxxxxxxxxx (this was a private
reply though).

This was an answer to my question whether a user could select the serial
by himself. To this reply, you asked whether it was feasible to output
on all the serials console, but I don't see any yes/no answer.

On the rest of the thread, it has been mentioned it was difficult to
multiplex to serial console (I forwarded you the thread). Christoffer,
Laszlo and Ard agreed that PL011 should only be used as boot diagnostics
and debug (if selected at compile time).

Actually copying here as answer as Laszlo was happy to forward the answer on public list: (+CC Christoffer and Ard)

* So, first of all, the debug port must be a super dumb device,
  available to the earliest firmware phases. It basically has to be a
  platform device, whose location and attributes can be figured out
  without hw discovery or enumeration. (Scanning the DTB is fine, albeit
  already quite laborious in the earliest phases.) PCI, virtio, or XenPV
  devices are unsuitable for this.

* In OVMF (x86), we use the QEMU debug port for this purpose
  (hard-coding the accesses to IO port 0x402). For this, we have a
  specialized DebugLib instance, under

* The serial port ("COM1") is used equivalently with the graphical
  display and the USB and PS/2 keyboard(s), for console purposes. The
  console(s) become available much later during firmware boot (only in
  the BDS phase).

* In order for a device to be usable as a console, the driver stack must
  (recursively) provide the following two "higher level abstractions" on
  top of the device:

  - EfiSimpleTextInProtocol OR EfiSimpleTextInputExProtocol,
  - AND EfiSimpleTextOutProtocol

  If these are provided, then the console splitter / multiplexer
  mentioned by Ard will take care of the rest.

* In OVMF (x86), this is the relevant protocol and driver stack for the
  "COM1" serial port (note that the necessary "high level abstractions"
  I mentioned above are at the bottom):


  Most of this stack is platform dependent (up to and including
  IsaSerialDxe, which produces [EfiSerialIoProtocol]). The universal
  part starts only with TerminalDxe, which consumes
  [EfiSerialIoProtocol], and produces the needed higher level
  abstractions on top.

* OVMF can be built (with -D DEBUG_ON_SERIAL_PORT) to ignore the QEMU
  debug port and to direct debug messages to the serial port instead. In
  that case, we use the following library instances, for directing debug
  messages to the serial port:

  - SerialPortLib: PcAtChipsetPkg/Library/SerialIoLib
  - DebugLib: MdePkg/Library/BaseDebugLibSerialPort

  The DebugLib instance uses SerialPortLib interfaces to print
  characters, and the SerialPortLib instance mentioned above hardcodes
  0x3F8 as the "COM1" UART base address.

  This debug-on-serial build works, but once we're in the BDS phase, the
  serial output will be a mixture of console stuff and debug messages,
  because the two separate paths described above dump output to the
  exact same device.

  So the recommended (and default) build is to send DEBUGs to the QEMU
  debug port (redirecting them to a host side file), and to use "COM1"
  only for console purposes.

* qemu-system-aarch64 has no "debug port", so in ArmVirtQemu we have
  something that can be compared to the (sub-optimal) "-D
  DEBUG_ON_SERIAL_PORT" build of OVMF. Namely, debug messages and
  console output are intermixed.

* In particular, for the DEBUG messages, we use the following library

  - PL011UartLib: ArmPlatformPkg/Drivers/PL011Uart/PL011Uart.inf

  - SerialPortLib [1]:
    (in early firmware phases with no writeable RAM)

  - SerialPortLib [2]:
    (later firmware phases with writeable RAM)

  - DebugLib: MdePkg/Library/BaseDebugLibSerialPort

  The DebugLib instance is the same as in OVMF's -D DEBUG_ON_SERIAL_PORT
  build, but the serial port APIs are filled in by different library

  For the early firmware phases, we use EarlyFdtPL011SerialPortLib,
  which parses the PL011 location from the DTB on every single serial
  port API invocation. In later firmware phases, we use
  FdtPL011SerialPortLib, which can cache the parsed location in static

  Finally, both SerialPortLib instances ask the same PL011UartLib to
  perform the actual PL011 accesses.

* Now that we got the DEBUG message printing for ArmVirtQemu out of the
  way, let's look at how PL011 is used for console purposes. (Again,
  sharing the same PL011 between console and DEBUG messages is not
  optimal, but there is no separate debug port for the aarch64 target.)


  All the drivers in this stack are universal, and SerialDxe produces
  exactly one [EfiSerialIoProtocol] instance without consuming other
  protocol instances. The trick is that it delegates the actual work to
  the platform's SerialPortLib instance (which is linked into the
  SerialDxe executable).

  In ArmVirtQemu's case, this instance is the one marked above as
  "SerialPortLib [2]", which in turn pulls in PL011UartLib as well.

* Considering the ArmVirtXen case. Both paths (DEBUG messages and
  console IO) are identical to those in ArmVirtQemu, except we use the
  following serial port library instance:

  - SerialPortLib: OvmfPkg/Library/XenConsoleSerialPortLib

  You might notice that we don't have two SerialPortLib instances here,
  one for "early" (RAM-less) phases and another for "late" (RAM-ful)
  phases, like we have in ArmVirtQemu. As far as I understand, the
  reason is that Xen guests lack the "early" (RAM-less) phases totally,
  and so we can get away with just a SerialPortLib instance that
  requires writeable RAM.

  This library instance performs Xen hypercalls. But, that makes no
  difference that the same SerialPortLib instance is used for *both*
  paths, namely console IO and DEBUG messages.

* Now, assuming Xen gets another serial port, i.e. it'll have both
  emulated PL011 and the paravirt console device. Based on my experience
  with OVMF (where DEBUGs and console IO use different devices), I'd
  recommend to dedicate one device to DEBUG messages, and another to
  console IO. I would *not* recommend multiplexing UEFI console IO to
  both PL011 and the XenPV console -- simply because separating DEBUGs
  from console IO is much more important than that. So if you gain
  another, primitive enough serial port-like device, definitely dedicate
  it to this separation, IMHO!

  Whether you assign PL011 to DEBUGs and keep UEFI console IO (including
  grub2 IO, for example) on XenPV, or assign them the other way around,
  is a matter of taste (or standards), I guess.

  - For keeping the UEFI console IO on XenPV, and moving the DEBUG
    messages to the new PL011: implement a new DebugLib instance that
    grabs the PL011 location in a manner that is specific to Xen guests
    (my guess: simply open-code it?) and then delegates the transmit
    work to PL011UartLib. That's all.

  - For the inverse: add a new DebugLib instance that embeds
    XenConsoleSerialPortLib's functionality, and add a SerialPortLib
    instace -- a variant of FdtPL011SerialPortLib.inf -- that grabs the
    PL011 location in a Xen-specific way, and delegates the transmit
    work to PL011UartLib.

  Both of these involve the introduction of a DebugLib instance that
  does *not* depend on the SerialPortLib class.

* Off the top of my head, I can't say how (and *whether*) this division
  of log devices in UEFI should be mirrored to the Linux guest OS as
  well. Earlier I made an effort to understand how Linux handled DBG2
  versus SPCR versus... whatever, but I've forgotten all that by now.

* If you *absolutely* want to multiplex both debug messages and console
  IO to both PL011 and the XenPV console, then a new DXE driver will be
  necessary that produces another EfiSerialIoProtocol instance, without
  going through the SerialPortLib class.

  This driver could be a clone of SerialDxe, but instead of consuming
  SerialPortLib (which we resolve to XenConsoleSerialPortLib in
  ArmVirtXen), it could be modified to:

  - grab the PL011 location in a Xen-specific way,

  - talk to PL011UartLib directly.

  Again, I do not recommend this; it would just duplicate the number of
  devices on which you'd get a mixture of DEBUGs and console IO. If Xen
  is gaining another serial port, use that opportunity to separate
  DEBUGs from console IO, like OVMF does. Which device is going to be
  used for which role is a matter of taste, or maybe it can be deduced
  from the relevant specs (ARM VM spec or maybe the SBBR).

PS: pls feel free to fwd this to some public list so that others can
comment should they want to.

Julien Grall

Xen-devel mailing list



Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.