cpuid | A simple CPUID decoder/dumper for x86/x86_64 | Reverse Engineering library

There is no need to allocate memory for this task: pass a pointer to a local array along with its size and use strlcat properly:

Try this:

If you really want to write, as just an exercise, an assembly function that "conforms" to all the common calling conventions for x86_64 (I know only the Windows one and the System V one), without relying on attributes or compiler flags to force the calling convention, let's take a look at what's common.

The Windows GPR passing order is rcx, rdx, r8, r9. The System V passing order is rdi, rsi, rdx, rcx, r8, r9. In both cases, rax holds the return value if it fits and is a piece of POD. Technically speaking, you can get away with a "polyglot" called function if it (0) saves the union of what each ABI considers non-volatile, and (1) returns something that can fit in a single register, and (2) takes no more than 2 GPR arguments, because overlap would happen past that. To be absolutely generic, you could make it take a single pointer to some structure that would hold whatever arbitrary return data you want.

So now our arguments will come through either rcx and rdx or rdi and rsi. How do you tell which will contain the arguments? I'm actually not sure of a good way. Maybe what you could do instead is have a wrapper that puts the arguments in the right spot, and have your actual function take "padding" arguments, so that your arguments always land in rcx and rdx. You could technically expand to r8 and r9 this way.

Basically, yes it ended up being SHA1. I grabbed a SHA1 script from here and added it to Google Sheets scripts to generate the hash. I chose Sheets only because I already had a doc I was sharing with non technical folks which builds up the curl query to run with some defined variables.

Here's the relevant code in case the link goes down...

The documentation in AMD's manual (vol 3, rev 3.33) does not say that ECX[0] = 0 will mask interrupts even if IF=1 in E/RFLAGS. It would be insane for user-space to be able to do that without having IO privilege level = 0 (which would allow you to run a cli instruction), and the wording doesn't really hint at it.

In user-space, there should be no way to get a CPU stuck in a way that would make it hard for the kernel to wake it up! If you want to go for longer before asking the OS to put this thread to sleep (e.g. with Linux futex to wake you back up on memory change), you could use it in a loop exactly like a spin-wait loop that uses pause or something. From the OS's perspective it'd be the same: this thread is occupying the CPU for the entire time.

It's likely that your code does actually arm the monitor and enter the optimized sleep state, but wakes on the next timer interrupt after at most a few milliseconds. Check with rdtsc to see how long it sleeps for, because human perception of screen output can't distinguish that from failing to sleep at all.

What the documentation actually does say about the supported extension flags in ECX:

Bit 0: When set, allows interrupts to wake MWAITX, even when eFLAGS.IF = 0. Support for this extension is indicated by a feature flag returned by the CPUID instruction.

So, as an extension, you can override the fact that interrupts are disabled in eFLAGS, to make sure you don't enter a sleep state that lasts until an NMI. Otherwise, with ECX[0] = 0, all previous stuff in the documentation applies, including:

Events that cause an exit from the monitor event pending state include:

• A store from another processor matches the address range established by the MONITORX instruction.
• The timer expires.
• Any unmasked interrupt, including INTR, NMI, SMI, INIT.
• RESET.
• Any far control transfer that occurs between the MONITORX and the MWAITX.

If you actually did want to do put the CPU into a sleep that wouldn't be ended by pending interrupts, you'd use cli before monitorx / mwaitx. Or use traditional monitor / mwait if you're in kernel mode proper, rather than user-space after a Linux iopl() system call or other way of getting IOPL=0 with CPL=3 (current privilege level), so you can't run privileged instructions in general, only the specific ones allowed by the IO privilege level, like in/out / cli/sti.

Unfortunately:

There is no indication after exiting MWAITX of why the processor exited or if the timer expired. It is up to software to check whether the awaiting store has occurred, and if not, determining how much time has elapsed if it wants to re-establish the MONITORX with a new timer value.

BTW, if you don't want the timer to be a possible exit condition, you can just leave ECX[1] = 0

Bit 1: When set, EBX contains the maximum wait time expressed in Software P0 clocks, the same clocks counted by the TSC. Setting bit 1 but passing in a value of zero on EBX is equivalent to setting bit 1 to a zero. The timer will not be an exit condition.

And BTW, EAX=0 isn't "no hints"; EAX[7:4] is always the desired C-state level, encoded at C-state - 1. So EAX=0 hints that you want C1 state. (To hint that you want C0 state, a less deep sleep that's faster to wake from, you'd set EAX = 0xf0, because F + 1 = 0.)

It's also pointless to do xor rax,rax instead of xor eax,eax; writing a 32-bit register implicitly zeroes the upper bits of the full 64-bit register, so there's no false dependency. And there's no need to tempt the assembler into wasting a REX prefix to actually encode it as written. The MWAITX implicit input registers are all 32-bit anyway, so xor ecx, ecx would also be appropriate.

Also, r9 is call-clobbered (aka volatile) in the Windows x64 calling convention; you can just use it without saving/restoring, along with r8..r11.

And no you don't have to run a cpuid every time you want to do monitorx / mwaitx! AMD's documentation says you need to check once per program / library init, but there's no way the CPU can actually enforce that. It's not going to track across context switches which user-space process has actually run a CPUID.

The problem is that eax, ecx, and edx are 32 bit registers, but it was being assembled in 64 bit mode. Because the first operand is pointer size, it must be 64 bits. The following code will work on 64 bit programs:

You might be sieving, but what about counting? And a upper limit, so one can compare? And OMP like primesieve?

You are stuck because you are not even counting or comparing, only with yourself.

I made a segmented sieve just with a 30Kb char array. At 2 billion, it takes quite exactly 3 times as long as primesieve, and works with OMP. So all your bit mapping and unrolling is not measurable.

Since stdout is line buffered, putchar doesn't write to the terminal directly; it puts the character into a buffer, which is flushed when a newline is encountered. And the buffer for stdout happens to be located on the heap following your heap_book allocation.

So at some point in your copy, you putchar all the characters of your secretinfo method. They are now in the output buffer. A little later, heap_book[i] is within the stdout buffer itself, so you encounter the copy of secretinfo that is there. When you putchar it, you effectively create another copy a little further along in the buffer, and the process repeats.

You can verify this in your debugger. The address of the stdout buffer, on glibc, can be found with p stdout->_IO_buf_base. In my test it's exactly 160 bytes past heap_book.

There's too much for me to put this in a comment, so I will summarize here. Maybe it will help you, or someone else. I should also mention this is for RHEL EC2 instances behind a corporate proxy (not Arch Linux), but I still feel like it may help. I had to do the following to get puppeteer working. This is straight from my docs, but I had to hand-jam the contents because my docs are on an intranet.

I had to install all of these libraries manually. I also don't know what the Arch Linux equivalents are. Some are duplicates from your question, but I don't think they all are:
pango libXcomposite libXcursor libXdamage libXext libXi libXtst cups-libs libXScrnSaver libXrandr GConf2 alsa-lib atk gtk3 ipa-gothic-fonts xorg-x11-fonts-100dpi xorg-x11-fonts-75dpi xorg-x11-utils xorg-x11-fonts-cyrillic xorg-x11-fonts-Type1 xorg-x11-fonts-misc liberation-mono-fonts liberation-narrow-fonts liberation-narrow-fonts liberation-sans-fonts liberation-serif-fonts glib2

If Arch Linux uses SELinux, you may also have to run this:
setsebool -P unconfirmed_chrome_sandbox_transition 0

It is also worth adding dumpio: true to your options to debug. Should give you a more detailed output from puppeteer, instead of the generic error. As I mentioned in my comment. I have this option ignoreDefaultArgs: ['--disable-extensions']. I can't tell you why because I don't remember. I think it is related to this issue, but also could be related to my corporate proxy.