similar to: [RFC PATCH 09/26] x86/paravirt: Add runtime_patch()

On 08.04.20 07:02, Ankur Arora wrote: > A KVM host (or another hypervisor) might advertise paravirtualized > features and optimization hints (ex KVM_HINTS_REALTIME) which might > become stale over the lifetime of the guest. For instance, the Then this hint is wrong if it can't be guaranteed. > host might go from being undersubscribed to being oversubscribed > (or the other way

On Tue, Apr 07, 2020 at 10:02:57PM -0700, Ankur Arora wrote: > A KVM host (or another hypervisor) might advertise paravirtualized > features and optimization hints (ex KVM_HINTS_REALTIME) which might > become stale over the lifetime of the guest. For instance, the > host might go from being undersubscribed to being oversubscribed > (or the other way round) and it would make sense

On Tue, Apr 07, 2020 at 10:02:57PM -0700, Ankur Arora wrote: > A KVM host (or another hypervisor) might advertise paravirtualized > features and optimization hints (ex KVM_HINTS_REALTIME) which might > become stale over the lifetime of the guest. For instance, the > host might go from being undersubscribed to being oversubscribed > (or the other way round) and it would make sense

Ankur Arora <ankur.a.arora at oracle.com> writes: > A KVM host (or another hypervisor) might advertise paravirtualized > features and optimization hints (ex KVM_HINTS_REALTIME) which might > become stale over the lifetime of the guest. For instance, the > host might go from being undersubscribed to being oversubscribed > (or the other way round) and it would make sense for the

On Tue, Apr 07, 2020 at 10:03:11PM -0700, Ankur Arora wrote: > struct text_poke_loc { > s32 rel_addr; /* addr := _stext + rel_addr */ > - s32 rel32; > - u8 opcode; > + union { > + struct { > + s32 rel32; > + u8 opcode; > + } emulated; > + struct { > + u8 len; > + } native; > + }; > const u8 text[POKE_MAX_OPCODE_SIZE]; > }; NAK, this

On Tue, Apr 07, 2020 at 10:03:12PM -0700, Ankur Arora wrote: > +static int __maybe_unused text_poke_late(patch_worker_t worker, void *stage) > +{ > + int ret; > + > + lockdep_assert_held(&text_mutex); > + > + if (system_state != SYSTEM_RUNNING) > + return -EINVAL; > + > + text_poke_state.stage = stage; > + text_poke_state.num_acks =

On Tue, Apr 07, 2020 at 10:03:12PM -0700, Ankur Arora wrote: > +static void __maybe_unused sync_one(void) > +{ > + /* > + * We might be executing in NMI context, and so cannot use > + * IRET as a synchronizing instruction. > + * > + * We could use native_write_cr2() but that is not guaranteed > + * to work on Xen-PV -- it is emulated by Xen and might not > + *

On Tue, Apr 07, 2020 at 10:03:11PM -0700, Ankur Arora wrote: > @@ -1071,10 +1079,13 @@ int notrace poke_int3_handler(struct pt_regs *regs) > goto out_put; > } > > - len = text_opcode_size(tp->opcode); > + if (desc->native) > + BUG(); > + Subject: x86/alternatives: Handle native insns in text_poke_loc*() That's not really handling, is it..

On Tue, Apr 07, 2020 at 10:03:16PM -0700, Ankur Arora wrote: > @@ -1807,12 +1911,20 @@ static int __maybe_unused text_poke_late(patch_worker_t worker, void *stage) > text_poke_state.state = PATCH_SYNC_DONE; /* Start state */ > text_poke_state.primary_cpu = smp_processor_id(); > > + text_poke_state.nmi_context = nmi; > + > + if (nmi) > +

On 08.04.20 14:08, Peter Zijlstra wrote: > On Tue, Apr 07, 2020 at 10:02:57PM -0700, Ankur Arora wrote: >> Mechanism: the patching itself is done using stop_machine(). That is >> not ideal -- text_poke_stop_machine() was replaced with INT3+emulation >> via text_poke_bp(), but I'm using this to address two issues: >> 1) emulation in text_poke() can only easily

Both call sites, that access kmmio_ctx, access kmmio_ctx with interrupts disabled. There is no need to use get_cpu_var() which additionally disables preemption. Use this_cpu_ptr() to access the kmmio_ctx variable of the current CPU. Signed-off-by: Sebastian Andrzej Siewior <bigeasy at linutronix.de> --- arch/x86/mm/kmmio.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-)

Now that the kmap atomic index is stored in task struct provide a preemptible variant. On context switch the maps of an outgoing task are removed and the map of the incoming task are restored. That's obviously slow, but highmem is slow anyway. The kmap_local.*() functions can be invoked from both preemptible and atomic context. kmap local sections disable migration to keep the resulting

Hi Ahmad, Yes, merging works good. However, my problem is like this - I have a C library which consists of 1000's of functions spread through various files. The functions do not have dependency amoung each other. I want to link only relavant files( files which have functions called from my application). Since ar has a global symbol table, I believe it should be faster to look for a symol in

Hi Ankur, Since you use -Xclang, the clang executable passes multiple triples to "clang -cc1". You can see that if you add the -v option. I'm sure there is someone here who can explain it better than I... Anyhow, I think you better use clang -cc1. Make sure -cc1 is the first command line option you use. $ clang -cc1 -fno-builtin -emit-llvm-bc -triple spir-unknown-unknown

Hi Ankur, Why do you need archive in this case? The other way of doing this is to merge all bitcode files into single file: $ clang -c -emit-llvm abc.c -o abc.bc $ clang -c -emit-llvm bcd.c -o bcd.bc llvm-link bcd.bc abc.bc -o merged.bc Cheers, Ahmad From: llvmdev-bounces at cs.uiuc.edu [mailto:llvmdev-bounces at cs.uiuc.edu] On Behalf Of ankur deshwal Sent: 21 February 2013 17:54 To:

Hi Ankur, For a MachineBasicBlock you can call getBasicBlock() to find the IR level BasicBlock from which it was generated (if there isn't a one, it will return NULL). I don't know of a way to get a finer granularity than that, though. -Jim On Jul 1, 2011, at 1:06 AM, ankur deshwal wrote: > Hi, > > Is there any way to get a pointer to the LLVM Instr from which a >

Move the gory details of kmap & al into a private header and only document the interfaces which are usable by drivers. Signed-off-by: Thomas Gleixner <tglx at linutronix.de> --- V3: New patch --- include/linux/highmem-internal.h | 174 +++++++++++++++++++++++++ include/linux/highmem.h | 270 ++++++++++++++------------------------- mm/highmem.c | 11 - 3

The kmap_atomic* interfaces in all architectures are pretty much the same except for post map operations (flush) and pre- and post unmap operations. Provide a generic variant for that. Signed-off-by: Thomas Gleixner <tglx at linutronix.de> Cc: Andrew Morton <akpm at linux-foundation.org> Cc: linux-mm at kvack.org --- V3: Do not reuse the kmap_atomic_idx pile and use kmap_size.h right

I guess I miss-interpreted the text in [2]. It talks about the optimizations are hindered if the compiler driver invokes link time optimizer "separately". I found that all files compiled are in bc format. Also in library archives, the embedded files were in bitcode format. So the gold linker and LLVMgold plugin are indeed working fine. However, there is still question over only 6% gain

Thanks a lot for replying Chris, I m trying to randomize the blocks in a program.I generate a random number( between the current "InsertPos" and the last block), and then iterate through the list of basicblocks , picking up block with position equal to that of the random number and place it into the current InsertPos and increment InsertPos. Running it like this: