|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [xen master] x86: detect CMOS aliasing on ports other than 0x70/0x71
commit 7c3e99b642d321bfe4eafed4d667e1bdd65ac410
Author: Jan Beulich <jbeulich@xxxxxxxx>
AuthorDate: Tue Apr 25 12:17:26 2023 +0200
Commit: Jan Beulich <jbeulich@xxxxxxxx>
CommitDate: Tue Apr 25 12:17:26 2023 +0200
x86: detect CMOS aliasing on ports other than 0x70/0x71
... in order to also intercept Dom0 accesses through the alias ports.
Also stop intercepting accesses to the CMOS ports if we won't ourselves
use the CMOS RTC, because of there being none. This doesn't go as far as
covering port 0x70, as that also has the NMI disable bit, which we don't
want to permit Dom0 to set.
Note that rtc_init() deliberately uses 16 as the upper loop bound,
despite probe_cmos_alias() using 8: The higher bound is benign now, but
would save us touching the code (or, worse, missing to touch it) in case
the lower one was doubled.
Signed-off-by: Jan Beulich <jbeulich@xxxxxxxx>
Reviewed-by: Roger Pau Monné <roger.pau@xxxxxxxxxx>
---
xen/arch/x86/hvm/rtc.c | 18 ++++-
xen/arch/x86/include/asm/mc146818rtc.h | 4 +
xen/arch/x86/pv/emul-priv-op.c | 6 +-
xen/arch/x86/setup.c | 39 +++++-----
xen/arch/x86/time.c | 133 ++++++++++++++++++++++++++++++---
5 files changed, 161 insertions(+), 39 deletions(-)
diff --git a/xen/arch/x86/hvm/rtc.c b/xen/arch/x86/hvm/rtc.c
index 44f2fb668d..c1ab6c7d58 100644
--- a/xen/arch/x86/hvm/rtc.c
+++ b/xen/arch/x86/hvm/rtc.c
@@ -27,7 +27,7 @@
#include <asm/hvm/vpt.h>
#include <asm/hvm/io.h>
#include <asm/hvm/save.h>
-#include <asm/current.h>
+#include <asm/iocap.h>
#include <xen/trace.h>
#include <public/hvm/params.h>
@@ -836,9 +836,19 @@ void rtc_init(struct domain *d)
if ( !has_vrtc(d) )
{
- if ( is_hardware_domain(d) )
- /* Hardware domain gets mediated access to the physical RTC. */
- register_portio_handler(d, RTC_PORT(0), 2, hw_rtc_io);
+ unsigned int port;
+
+ if ( !is_hardware_domain(d) )
+ return;
+
+ /*
+ * Hardware domain gets mediated access to the physical RTC/CMOS (of
+ * course unless we don't use it ourselves, for there being none).
+ */
+ for ( port = RTC_PORT(0); port < RTC_PORT(0) + 0x10; port += 2 )
+ if ( is_cmos_port(port, 2, d) )
+ register_portio_handler(d, port, 2, hw_rtc_io);
+
return;
}
diff --git a/xen/arch/x86/include/asm/mc146818rtc.h
b/xen/arch/x86/include/asm/mc146818rtc.h
index 803b236c0a..1a34512d29 100644
--- a/xen/arch/x86/include/asm/mc146818rtc.h
+++ b/xen/arch/x86/include/asm/mc146818rtc.h
@@ -9,6 +9,10 @@
extern spinlock_t rtc_lock; /* serialize CMOS RAM access */
+struct domain;
+bool is_cmos_port(unsigned int port, unsigned int bytes,
+ const struct domain *d);
+
/**********************************************************************
* register summary
**********************************************************************/
diff --git a/xen/arch/x86/pv/emul-priv-op.c b/xen/arch/x86/pv/emul-priv-op.c
index aae38da089..8a4ef9c35e 100644
--- a/xen/arch/x86/pv/emul-priv-op.c
+++ b/xen/arch/x86/pv/emul-priv-op.c
@@ -208,7 +208,7 @@ static bool admin_io_okay(unsigned int port, unsigned int
bytes,
return false;
/* We also never permit direct access to the RTC/CMOS registers. */
- if ( port <= RTC_PORT(1) && port + bytes > RTC_PORT(0) )
+ if ( is_cmos_port(port, bytes, d) )
return false;
return ioports_access_permitted(d, port, port + bytes - 1);
@@ -278,7 +278,7 @@ static uint32_t guest_io_read(unsigned int port, unsigned
int bytes,
{
sub_data = pv_pit_handler(port, 0, 0);
}
- else if ( port == RTC_PORT(0) || port == RTC_PORT(1) )
+ else if ( is_cmos_port(port, 1, currd) )
{
sub_data = rtc_guest_read(port);
}
@@ -424,7 +424,7 @@ static void guest_io_write(unsigned int port, unsigned int
bytes,
{
pv_pit_handler(port, (uint8_t)data, 1);
}
- else if ( port == RTC_PORT(0) || port == RTC_PORT(1) )
+ else if ( is_cmos_port(port, 1, currd) )
{
rtc_guest_write(port, data);
}
diff --git a/xen/arch/x86/setup.c b/xen/arch/x86/setup.c
index 08ade715a3..74e3915a4d 100644
--- a/xen/arch/x86/setup.c
+++ b/xen/arch/x86/setup.c
@@ -2130,37 +2130,36 @@ int __hwdom_init xen_in_range(unsigned long mfn)
static int __hwdom_init cf_check io_bitmap_cb(
unsigned long s, unsigned long e, void *ctx)
{
- struct domain *d = ctx;
+ const struct domain *d = ctx;
unsigned int i;
ASSERT(e <= INT_MAX);
for ( i = s; i <= e; i++ )
- __clear_bit(i, d->arch.hvm.io_bitmap);
+ /*
+ * Accesses to RTC ports also need to be trapped in order to keep
+ * consistency with hypervisor accesses.
+ */
+ if ( !is_cmos_port(i, 1, d) )
+ __clear_bit(i, d->arch.hvm.io_bitmap);
return 0;
}
void __hwdom_init setup_io_bitmap(struct domain *d)
{
- int rc;
+ if ( !is_hvm_domain(d) )
+ return;
- if ( is_hvm_domain(d) )
- {
- bitmap_fill(d->arch.hvm.io_bitmap, 0x10000);
- rc = rangeset_report_ranges(d->arch.ioport_caps, 0, 0x10000,
- io_bitmap_cb, d);
- BUG_ON(rc);
- /*
- * NB: we need to trap accesses to 0xcf8 in order to intercept
- * 4 byte accesses, that need to be handled by Xen in order to
- * keep consistency.
- * Access to 1 byte RTC ports also needs to be trapped in order
- * to keep consistency with PV.
- */
- __set_bit(0xcf8, d->arch.hvm.io_bitmap);
- __set_bit(RTC_PORT(0), d->arch.hvm.io_bitmap);
- __set_bit(RTC_PORT(1), d->arch.hvm.io_bitmap);
- }
+ bitmap_fill(d->arch.hvm.io_bitmap, 0x10000);
+ if ( rangeset_report_ranges(d->arch.ioport_caps, 0, 0x10000,
+ io_bitmap_cb, d) )
+ BUG();
+
+ /*
+ * We need to trap 4-byte accesses to 0xcf8 (see admin_io_okay(),
+ * guest_io_read(), and guest_io_write()).
+ */
+ __set_bit(0xcf8, d->arch.hvm.io_bitmap);
}
/*
diff --git a/xen/arch/x86/time.c b/xen/arch/x86/time.c
index 4e44a43cc5..bc75e1ae7d 100644
--- a/xen/arch/x86/time.c
+++ b/xen/arch/x86/time.c
@@ -1234,7 +1234,10 @@ static unsigned long get_cmos_time(void)
if ( seconds < 60 )
{
if ( rtc.sec != seconds )
+ {
cmos_rtc_probe = false;
+ acpi_gbl_FADT.boot_flags &= ~ACPI_FADT_NO_CMOS_RTC;
+ }
break;
}
@@ -1249,6 +1252,86 @@ static unsigned long get_cmos_time(void)
return mktime(rtc.year, rtc.mon, rtc.day, rtc.hour, rtc.min, rtc.sec);
}
+static unsigned int __ro_after_init cmos_alias_mask;
+
+static int __init cf_check probe_cmos_alias(void)
+{
+ unsigned int offs;
+
+ if ( acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_CMOS_RTC )
+ return 0;
+
+ for ( offs = 2; offs < 8; offs <<= 1 )
+ {
+ unsigned int i;
+ bool read = true;
+
+ for ( i = RTC_REG_D + 1; i < 0x80; ++i )
+ {
+ uint8_t normal, alt;
+ unsigned long flags;
+
+ if ( i == acpi_gbl_FADT.century )
+ continue;
+
+ spin_lock_irqsave(&rtc_lock, flags);
+
+ normal = CMOS_READ(i);
+ if ( inb(RTC_PORT(offs)) != i )
+ read = false;
+
+ alt = inb(RTC_PORT(offs + 1));
+
+ spin_unlock_irqrestore(&rtc_lock, flags);
+
+ if ( normal != alt )
+ break;
+
+ process_pending_softirqs();
+ }
+ if ( i == 0x80 )
+ {
+ cmos_alias_mask |= offs;
+ dprintk(XENLOG_INFO, "CMOS aliased at %02x, index %s\n",
+ RTC_PORT(offs), read ? "r/w" : "w/o");
+ }
+ }
+
+ return 0;
+}
+__initcall(probe_cmos_alias);
+
+bool is_cmos_port(unsigned int port, unsigned int bytes, const struct domain
*d)
+{
+ unsigned int offs;
+
+ if ( !is_hardware_domain(d) )
+ return port <= RTC_PORT(1) && port + bytes > RTC_PORT(0);
+
+ /*
+ * While not really CMOS-related, port 0x70 always needs intercepting
+ * to deal with the NMI disable bit.
+ */
+ if ( port <= RTC_PORT(0) && port + bytes > RTC_PORT(0) )
+ return true;
+
+ if ( acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_CMOS_RTC )
+ return false;
+
+ if ( port <= RTC_PORT(1) && port + bytes > RTC_PORT(0) )
+ return true;
+
+ for ( offs = 2; offs <= cmos_alias_mask; offs <<= 1 )
+ {
+ if ( !(offs & cmos_alias_mask) )
+ continue;
+ if ( port <= RTC_PORT(offs | 1) && port + bytes > RTC_PORT(offs) )
+ return true;
+ }
+
+ return false;
+}
+
/* Helpers for guest accesses to the physical RTC. */
unsigned int rtc_guest_read(unsigned int port)
{
@@ -1256,23 +1339,36 @@ unsigned int rtc_guest_read(unsigned int port)
unsigned long flags;
unsigned int data = ~0;
- switch ( port )
+ switch ( port & ~cmos_alias_mask )
{
case RTC_PORT(0):
/*
* All PV domains (and PVH dom0) are allowed to read the latched value
* of the first RTC port, as there's no access to the physical IO
- * ports.
+ * ports. Note that we return the index value regardless of whether
+ * underlying hardware would permit doing so.
+ */
+ data = currd->arch.cmos_idx & (0xff >> (port == RTC_PORT(0)));
+
+ /*
+ * When there's (supposedly) no RTC/CMOS, we don't intercept the other
+ * ports. While reading the index register isn't normally possible,
+ * play safe and return back whatever can be read (just in case a value
+ * written through an alias would be attempted to be read back here).
*/
- data = currd->arch.cmos_idx;
+ if ( port == RTC_PORT(0) &&
+ (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_CMOS_RTC) &&
+ ioports_access_permitted(currd, port, port) )
+ data = inb(port) & 0x7f;
break;
case RTC_PORT(1):
- if ( !ioports_access_permitted(currd, RTC_PORT(0), RTC_PORT(1)) )
+ if ( !ioports_access_permitted(currd, port - 1, port) )
break;
spin_lock_irqsave(&rtc_lock, flags);
- outb(currd->arch.cmos_idx & 0x7f, RTC_PORT(0));
- data = inb(RTC_PORT(1));
+ outb(currd->arch.cmos_idx & (0xff >> (port == RTC_PORT(1))),
+ port - 1);
+ data = inb(port);
spin_unlock_irqrestore(&rtc_lock, flags);
break;
@@ -1288,9 +1384,10 @@ void rtc_guest_write(unsigned int port, unsigned int
data)
struct domain *currd = current->domain;
unsigned long flags;
- switch ( port )
+ switch ( port & ~cmos_alias_mask )
{
typeof(pv_rtc_handler) hook;
+ unsigned int idx;
case RTC_PORT(0):
/*
@@ -1298,20 +1395,32 @@ void rtc_guest_write(unsigned int port, unsigned int
data)
* value of the first RTC port, as there's no access to the physical IO
* ports.
*/
- currd->arch.cmos_idx = data;
+ currd->arch.cmos_idx = data & (0xff >> (port == RTC_PORT(0)));
+
+ /*
+ * When there's (supposedly) no RTC/CMOS, we don't intercept the other
+ * ports. Therefore the port write, with the NMI disable bit zapped,
+ * needs carrying out right away.
+ */
+ if ( port == RTC_PORT(0) &&
+ (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_CMOS_RTC) &&
+ ioports_access_permitted(currd, port, port) )
+ outb(data & 0x7f, port);
break;
case RTC_PORT(1):
- if ( !ioports_access_permitted(currd, RTC_PORT(0), RTC_PORT(1)) )
+ if ( !ioports_access_permitted(currd, port - 1, port) )
break;
+ idx = currd->arch.cmos_idx & (0xff >> (port == RTC_PORT(1)));
+
hook = ACCESS_ONCE(pv_rtc_handler);
if ( hook )
- hook(currd->arch.cmos_idx & 0x7f, data);
+ hook(idx, data);
spin_lock_irqsave(&rtc_lock, flags);
- outb(currd->arch.cmos_idx & 0x7f, RTC_PORT(0));
- outb(data, RTC_PORT(1));
+ outb(idx, port - 1);
+ outb(data, port);
spin_unlock_irqrestore(&rtc_lock, flags);
break;
--
generated by git-patchbot for /home/xen/git/xen.git#master
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |