Re: [Xen-devel] [PATCH] x86/msr: Fix fallout from mostly c/s 832c180

["Jan Beulich" <JBeulich@xxxxxxxx>]

>>> On 11.04.19 at 20:20, <andrew.cooper3@xxxxxxxxxx> wrote:
> On 10/04/2019 11:24, Jan Beulich wrote:
>>>>> On 09.04.19 at 19:53, <andrew.cooper3@xxxxxxxxxx> wrote:
>>> The series 832c1803^..f61685a6 was committed without adequate review.
>>>
>>>  * Fix the shim build by providing a !CONFIG_HVM declaration for
>>>    hvm_get_guest_bndcfgs()
>>>  * Revert the bogus de-const'ing of the vcpu pointer in
>>>    vmx_get_guest_bndcfgs().  vmx_vmcs_enter() really does mutate the vcpu, 
>>> and
>>>    may cause it to undergo a full de/reschedule, which is in violation of 
>>> the
>>>    ABI described by hvm_get_guest_bndcfgs().  guest_rdmsr() was always going
>>>    to need to lose its const parameter, and this was the correct time for it
>>>    to happen.
>> I'd like to ask for a better explanation of the actual issue you see
>> here. By declaring a function parameter pointer to const, nothing
>> tells the compiler that the object may not change (e.g. across
>> function calls made out of this function).
> 
> False.
> 
>> All it tells the compiler is
>> that the function promises to not itself alter the pointed to object.
> 
> Nonsense.

Excuse me?

>  The function promising not to alter the pointed-to-object
> includes the entire child callgraph.
> 
> 
> The code you insisted Paul to add is:
> 
> struct vcpu *v = cv->domain->vcpu[cv->vcpu_id];
> 
> which is identical to:
> 
> struct vcpu *v = (struct vcpu *)cv;

It is not identical; it is having the same effective behavior when
compiled with today's compilers.

> Which highlights very clearly that this function has undefined behaviour.

It doesn't, no.

> An optimising compiler which uses an object, and passes a const pointer
> to that object to a function, is permitted to retain assumptions derived
> from that state across the function call sequence point, because the ABI
> of the function states that the content of the object doesn't change.

Very much not so, no. Take this simple (and granted contrived)
example:

int integer;

int test(void) {
        func(&integer);
        return integer;
}

and in a different CU (just to avoid the effect of the compiler
inlining the whole thing)

void func(const int*pi) {
        integer = ~*pi;
}

Various other examples are possible, including ones where
there's nothing contrived at all.

> But if you'd prefer a different argument, how about a contradiction.
> 
> By your interpretation, the const keyword is utterly useless because a
> compiler must treat all const pointers as non-const, because the
> pointed-to object can change in any arbitrary way at any point.  If this
> were the intended interpretation, const would never have been added to
> the C language because it would waste space in the compiler for 0 gain.
> 
> The fact it was added demonstrates that it had real material gains,
> which means it isn't a useless keyword, which means the compiler really
> may depend on the content of a const pointed-to-object not changing at all.

I doubt this, and you provide no source where you take from that
this was the intention. And despite what you say, "const" has its
value nevertheless - it allows the compiler to tell you when a piece
of code modifies an object that you didn't mean to alter.

Quote from the language spec:

"If an attempt is made to modify an object defined with a const-
 qualified type through use of an lvalue with non-const-qualified
 type, the behavior is undefined. If an attempt is made to refer
 to an object defined with a volatile-qualified type through use
 of an lvalue with non-volatile-qualified type, the behavior is
 undefined."

And the respective footnote:

"This applies to those objects that behave as if they were
 defined with qualified types, even if they are never actually
 defined as objects in the program (such as an object at a
 memory-mapped input/output address)."

Throughout the verb used is "defined", not "declared". If any
struct vcpu instance actually lived in .rodata (for example),
then (without casting away constness) it would be impossible to
construct a non-const pointer to it. Hence there would be no
legitimate means to create a way to modify that instance. But
that's specifically not the case here (or in the example given).

>>>  * Remove the introduced ASSERT(is_hvm_domain(d)) and check the predicate
>>>    directly.  While we expect it to be true, the result is potential type
>>>    confusion in release builds based on several subtle aspects of the CPUID
>>>    feature derivation logic with no other safety checks.  This also fixes 
>>> the
>>>    a linker error in the release build of the shim, again for !CONFIG_HVM
>>>    reasons.
>> I don't understand "no other safety checks": To me the "S" in
>>
>> XEN_CPUFEATURE(MPX,           5*32+14) /*S  Memory Protection Extensions */
>>
>> is clear enough. While perhaps not towards "potential type confusion"
> 
> "type confusion" here is mixing up v->arch.hvm and v->arch.pv, which is
> what happens when you've actually got a PV vcpu and you call an hvm_*
> function.
> 
> "No other safety checks" means that cp->feat.mpx becoming accidentally
> set results in bad things happening if a PV and HVM vcpu get mixed up.

If whatever bit / field / variable accidentally gains a wrong value,
bad things are going to be happening. There's no escape from this.

> It is same reasoning which causes us to do this:
> 
> if ( !cond )
> {
>     ASSERT_UNREACHABLE();
>     goto something_safer;
> }
> 
> rather than ASSERT(cond)

Right, and just to remind you: I'm not objecting to the change
itself. I dislike how you call it all broken without demonstrating its
brokenness. I'd like to add though that this part of the patch
description is perhaps acceptable, if there wasn't the overall
initial statement regarding "adequate review".

>> as you word it, there are other cases where we make implications
>> from the scope stated in the public header: MSR_FLUSH_CMD, for
>> example, is supposed to be inaccessible to PV guests, but there's no
>> explicit !PV check in its handling code.
> 
> Nothing with the handling of FLUSH_CMD gets into any form of UB
> whatsoever if cp->feat.l1d_flush becomes accidentally set for a PV guest.

Mind me adjusting this to "Nothing ... currently gets into ..."?

>>  I would call the current state
>> as inconsistent (seeing e.g. guest_{rd,wr}msr_x2apic() again being
>> behind is_hvm_domain() checks), and hence it's not really possible
>> to derive in which case which approach is to be preferred (or, as in
>> the case here, would be objected to).
> 
> The very first thing guest_{rd,wr}msr_x2apic() does is operate on
> v->arch.hvm

But along the lines of the previous comment: I think the checking
done in the caller should not depend on implementation details of
the callee. It should be consistent in itself.

> Anyway, as was included in the bullet point, the is_hvm_domain() check
> is a critical part of making the shim build work, given that it depends
> on dead code elimination.  Omitting the is_hvm_domain() check really
> does result in a link error.

This is one way of addressing the build problem, but not the only
one. Yet again - I'm okay with the code changes you propose, but
please with a more civil (and, in the case of the const aspect,
factually correct) description.

Jan


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxxx
https://lists.xenproject.org/mailman/listinfo/xen-devel