usleep or some other form of delay

[WEREMSOFT]

Does the kernel provides a way to do
usleep(100000);
or I should write the function myself?

For now I'm using this

static inline uint64_t rdtsc(void) {
    uint32_t lo, hi;
    asm volatile ("rdtsc" : "=a" (lo), "=d" (hi));
    return ((uint64_t)hi << 32) | lo;
}

void usleep(uint64_t microseconds) {
    // CPU freq, may need adjustments
    uint64_t cpu_frequency_hz = 3000000000;
    uint64_t cycles_to_wait = (cpu_frequency_hz / 1000000) * microseconds;

    uint64_t start = rdtsc();
    while ((rdtsc() - start) < cycles_to_wait) {
        // Espera ocupada (busy-wait)
    }
}

[IanSeyler]

The kernel delay function needs to be updated or replaced. The HPET is enabled on the system and delay will likely be set to pull timing data from that. This is on my TODO list as some drivers want a delay when initializing the hardware.

[macpacheco]

Recommend putting an asm("hlt"); inside the busy wait to reduce CPU usage. HLT waits until the next interrupt to resume execution.
This makes a huge difference in qemu CPU consumption (from 5% to 100% in an infinite busy loop - with/without HLT).
Notice this works in BareMetal but won't work in Windows / Linux userland code as HLT is a priviledged instruction.

[macpacheco]

Trying to implement my first system call, so I opted to adapt your code.
Since os_delay was empty, I changed it to delay by micro seconds instead of 8ths of a second.
I wanted to have a HLT instruction in the busy-wait, but it freezes and never returns. commenting it works, though I'm unsure if the delay is precisely correct (if os_CoreSpeed can be relied for this purpose).

src/BareMetal/src/syscalls/system.asm (replace empty os_delay implementation)

; -----------------------------------------------------------------------------
; os_delay -- Delay by X micro seconds
; IN:   RAX = Time in micro seconds
; OUT:  All registers preserved
os_delay:
        push  rax
        push  rbx
        push  rcx
        push  rdx

; os_CoreSpeed is in MHz which is the inverse of micro seconds
        movzx ebx,WORD [os_CoreSpeed]
; rbx = os_CoreSpeed * delay (cycles)
        imul  rbx,rax
; Read Time Stamp Counter (EDX:EAX)
        rdtsc
; RCX=(RDX<<32)|RAX
        mov   rcx,rax
        shl   rdx,32
        or    rcx,rdx
microsleep_loop:
; Read Time Stamp Counter (EDX:EAX)
        rdtsc
; RAX=(RDX<<32)|RAX - RCX
        shl   rdx,32
        or    rax,rdx
        sub   rax,rcx
; if (rax >= rbx) goto microsleep_end; else { hlt; goto microsleep_loop; }
        cmp   rax,rbx
        jae   microsleep_end
        ;hlt
        jmp   microsleep_loop
microsleep_end:
        pop   rdx
        pop   rcx
        pop   rbx
        pop   rax
        ret
; -----------------------------------------------------------------------------

src/BareMetal-Demo/src/libBareMetal.c:
add:

void b_system_delay(unsigned long long delay) {
        asm volatile ("call *0x00100048" : : "c"(6), "a"(delay));
}

A 100 000 000 delay seems to complete 4 seconds earlier than a sleep 100 on a shell on the same host system.

[macpacheco]

Same idea, however replace RDTSC with HPET timer, assumes the timer is in 64 bit mode. Warning, this code isn't 100% proper or really robust.

; -----------------------------------------------------------------------------
; os_delay -- Delay by X micro seconds
; IN:	RAX = Time in micro seconds
; OUT:	All registers preserved
os_delay:
	push  rax
	push  rbx
	push  rcx
	push  rdx

; Save delay to rbx
	mov   rbx, rax
; Zero rdx
	xor   rdx, rdx
; Get HPET General Capabilities and ID Register
	mov   ecx, 0
	call  os_hpet_read
; RCX = RAX >> 32 (timer period in femtoseconds)
	shr   rax, 32
	mov   rcx, rax
; Divide 10E9 (RDX:RAX) / RCX (converting from period in femtoseconds to frequency in MHz)
	mov   rax, 1000000000
	div   rcx
; RAX *= RBX, should get number of HPET cycles to wait, save result in RBX
	mul   rbx
	mov   rbx, rax
; Get HPET counter in RAX
	mov   ecx, 0xF0
	call  os_hpet_read
; RBX+=RAX Until when to wait
	add   rbx, rax
microsleep_loop:
; Get HPET counter in RAX
	mov   ecx, 0xF0
	call  os_hpet_read
; if (rax >= rbx) goto microsleep_end; else { hlt; goto microsleep_loop; }
	cmp   rax,rbx
	jae   microsleep_end
;	hlt
	jmp   microsleep_loop
microsleep_end:
	pop   rdx
	pop   rcx
	pop   rbx
	pop   rax
	ret
; -----------------------------------------------------------------------------

Now a 100 000 000 delay seems to complete as precisely as my eyes can visually verify.

[IanSeyler]

Well done! I’ll look into this on my end and merge this functionality.

hlt can’t be used at the moment since there are no interrupts firing at any set rate.

[IanSeyler]

I've added your HPET code to b_delay. I did change the formatting a bit to get in line with the code style of the rest of the project. Thank you for the contribution! I tested this in QEMU, as well as a physical host with a 10-second delay.

ReturnInfinity/BareMetal@f6079c2

[WEREMSOFT]

I don't see b_delay implemented in libBareMetal.h. It will be great to have it.

[IanSeyler]

I’ll add it.

[IanSeyler]

Oops - it is there already. Make sure you've pulled the latest kernel as it comes with the updated API headers.

[WEREMSOFT]

ok, I'm checking this: https://github.com/ReturnInfinity/BareMetal/blob/master/api/libBareMetal.h

that is the latest version on master, and b_delay is not there. But it is here
https://github.com/ReturnInfinity/BareMetal/blob/master/src/syscalls/system.asm

I'm missing something? I was expecting something like this:

void b_delay(unsigned long long delay) {
        asm volatile ("call *0x00100048" : : "c"(6), "a"(delay));
}

[WEREMSOFT]

Wow. Amazing.