lkml.org 
[lkml]   [2019]   [Feb]   [21]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    SubjectRe: [PATCH] sched/x86: Save [ER]FLAGS on context switch
    From
    Date


    On 20/02/2019 22:55, H. Peter Anvin wrote:
    > On 2/19/19 4:48 AM, Will Deacon wrote:
    >>
    >> I think you'll still hate this, but could we not disable preemption during
    >> the uaccess-enabled region, re-enabling it on the fault path after we've
    >> toggled uaccess off and disable it again when we return back to the
    >> uaccess-enabled region? Doesn't help with tracing, but it should at least
    >> handle the common case.
    >>
    >
    > There is a worse problem with this, I still realize: this would mean blocking
    > preemption across what could possibly be a *very* large copy_from_user(), for
    > example.
    >

    Yes, that's a good point. And I guess a userspace program could forcibly
    trigger the kernel into a large copy_from/to_user(), knowingly disabling
    preemption.

    I don't know how bad this could get.

    > Exceptions *have* to handle this; there is no way around it. Perhaps the
    > scheduler isn't the right place to put these kinds of asserts, either.
    >

    Maybe I'm misunderstanding what you mean with "Exceptions *have* to
    handle this". Isn't the fact that the AC/PAN flags gets saved on
    exception entry and set back to "user accesses disabled" already
    handling it? Or are you referring to something else?

    So far my understanding is that the exception/interrupt case is fine.
    The worrying case is what gets called in the user access regions
    (schedule(), preempt_enable(), tracing...).

    Did I get lost somewhere?

    > Now, __fentry__ is kind of a special beast; in some ways it is an "exception
    > implemented as a function call"; on x86 one could even consider using an INT
    > instruction in order to reduce the NOP footprint in the unarmed case. Nor is
    > __fentry__ a C function; it has far more of an exception-like ABI.
    > *Regardless* of what else we do, I believe __fentry__ ought to
    > save/disable/restore AC, just like an exception does.
    >

    That does make sense to me. However it doesn't solve the issue of
    calling (or preventing to call) some function that rescheds.


    > The idea of using s/a gcc plugin/objtool/ for this isn't really a bad idea.
    > Obviously the general problem is undecidable :) but the enforcement of some
    > simple, fairly draconian rules ("as tight as possible, but no tighter")
    > shouldn't be a huge problem.
    >
    > An actual gcc plugin -- which would probably be quite complex -- could make
    > gcc itself aware of user space accesses and be able to rearrange them to
    > minimize STAC/CLAC and avoid kernel-space accesses inside those brackets.
    >

    Not sure I get this. The data that is retrieved from/stored user space
    is generally obtained from/saved into kernel-space address. And when you
    start the user_access_begin() it means you plan on doing a bunch of user
    access, so I wouldn't expect to be able to batch everything into registers.

    Cheers,

    --
    Julien Thierry

    \
     
     \ /
      Last update: 2019-02-21 13:07    [W:4.086 / U:0.016 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site