Shutdown and return to real mode

[macpacheco]

So I wanted to implement CTRL-ALT-DEL for reboot and CTRL-ALT-SHIFT-DEL for shutdown, straight in the keyboard interrupt.
Reboot is easy peasy.
Shutdown is a pain. I didn't want to do ACPI table parsing so the only generic way was a return to real mode to call APM.
Took me days to figure it out.
1 - Save the real mode IDT from 0x0 to the last bytes of real mode memory (must do it soon enough otherwise it gets wiped out even before long mode gates are built):
Pure64/src/pure64.asm:

BITS 64 
start64:
        mov esp, 0x8000                 ; Set a known free location for the stack
        
        mov edi, 0x5000                 ; Clear the info map and system variable memory
        xor eax, eax
        mov ecx, 960                    ; 3840 bytes (Range is 0x5000 - 0x5EFF)
        rep stosd                       ; Don't overwrite the UEFI/BIOS data at 0x5F00
        
        mov [p_BootMode], bl
        
; Save real mode gates
        xor rsi, rsi
        mov rdi, 0x9fc00 ; The last 1KB in low memory
        mov rcx, 128
        rep movsq
        
        ; Mask all PIC interrupts

2 - Create 16 bit code and data segments in gdt64, 32 bit protected mode segments were created, but unused:
Pure64/sys/sysvar.asm

gdt64:                                  ; This structure is copied to 0x0000000000001000
SYS64_NULL_SEL equ $-gdt64              ; Null Segment
dq 0x0000000000000000
SYS64_CODE_SEL equ $-gdt64              ; Code segment, read/execute, nonconforming
dq 0x00209A0000000000                   ; 53 Long mode code, 47 Present, 44 Code/Data, 43 Executable, 41 Readable
SYS64_DATA_SEL equ $-gdt64              ; Data segment, read/write, expand down
dq 0x0000920000000000                   ; 47 Present, 44 Code/Data, 41 Writable
SYS64_CODE_32_SEL equ $-gdt64           ; Code segment, read/execute, nonconforming, compatibility (32 bit) mode
dq 0x00CF9A000000FFFF                   ; 53 Long mode code, 47 Present, 44 Code/Data, 43 Executable, 41 Readable
SYS64_DATA_32_SEL equ $-gdt64           ; Data segment, read/write, expand down
dq 0x00CF92000000FFFF                   ; 47 Present, 44 Code/Data, 41 Writable
SYS64_CODE_16_SEL equ $-gdt64           ; Code segment, read/execute, nonconforming, compatibility (32 bit) mode
dq 0x00009A000000FFFF                   ; 53 Long mode code, 47 Present, 44 Code/Data, 43 Executable, 41 Readable
SYS64_DATA_16_SEL equ $-gdt64           ; Data segment, read/write, expand down
dq 0x000092000000FFFF                   ; 47 Present, 44 Code/Data, 41 Writable
gdt64_end:

IDTR64:                                 ; Interrupt Descriptor Table Register

3 - Shutdown code per se:

SECTION .text
ALIGN 16
GLOBAL header
EXTERN main
EXTERN __bss_start
header:
dw main-$            ; Relative address to startup code
dw __bss_start-$     ; Size of this binary

reset_IDTR:
dw 0x3ff
; Original Real Mode Interrupt Vectors copied to linear 0x9fc00
dd 0x9fc00

ALIGN 16 ; Already 16 byte aligned, but just in case I change something and forget

GLOBAL shutdown
BITS 64
shutdown:
    ; Do all RIP relative math now as it doesn't exist in .code16 and doesn't work in .code32
    lea rbx, [rel header] ; Header = Label aligned in start of image
    shr rbx, 4 ; We'll use tiny real mode (CS=DS=SS), save real mode segment in BX for now

    lea rax, [rel next]
    cli ; We don't want any interrupts outside long mode
    push 0x28 ; 16 bit protected code selector
    push rax ; There is push next[rip] but it doesn't work
    retfq ; Return to change CS to 0x28
next:
BITS 16 ; Now we are in 16 bit mode, must tell assembler to generate proper opcodes
    mov ax,0x30 ; 16 bit DATA protected mode segment selectors
    mov ds, ax ; This is strictly necessary even though we don't do any DS/SS stuff until real mode
    mov ss, ax ; Otherwise=crash
    xor eax,eax ; Change CR0 to be exactly the same as initial boot
    mov cr0, eax
    mov ecx, 0xc0000080 ; EFER MSR number. 
    rdmsr ; Read EFER. Although the value of EFER is unused this crashes without this instruction
    xor eax,eax ; Initial boot up EFER value
    wrmsr ; Write EFER. 
;    mov eax,0x60000010 ; Unnecessary
;    mov cr0,eax
    xor eax, eax
    mov cr3, eax
    mov cr4, eax
    mov ss,bx
    mov ds,bx
    xor sp,sp ; Next push will wrap to 0xFFFF

    push bx
    push word next1
    retf ; Return to load CS with BX
next1:
    lea bx, [reset_IDTR]
    lidt [bx] ; Point to saved real mode interrupt vectors in place
; Try to set apm version (to 1.2).
;    mov ax, 0x530e
;    xor bx, bx
;    mov cx, 0x0102
;    int 0x15
; Turn off the system.
    mov ax, 0x5307
    mov bx, 0x0001
    mov cx, 0x0003
    int 0x15

Ok, this won't work for UEFI boot. But I couldn't find the explanation anywhere on how to the return to real mode from long mode. Recipes I found wanted to drop from long to protected mode then to real, without 16 bit segments, qemu definitely didn't like this. Instead of just changing the bits that were necessary in CR3 and EFER, I copied the original values when boot sector is executed, seemed safer.

If I could ask to keep the original interrupt vectors untouched and build new ones somewhere else, it would be great. I couldn't figure out a safe location to do so. Point it out that safe location and I'll do it.

[IanSeyler]

ACPI is going to be the necessary evil here as we want something that works on UEFI and BIOS-booted systems.

Pure64 already pulls some data from the ACPI tables. I'll extend it to check for FACP. It's the AML stuff that I haven't looked into yet.

https://wiki.osdev.org/Shutdown#ACPI