Merge pull request #127 from haraldh/stable

enable usage with non-nightly rust

Author: phil-opp

.github/workflows/build.yml

@@ -56,9 +56,17 @@ jobs:
     - name: "Run cargo build"
       run: cargo build
 
+    - name: "Run cargo build for stable"
+      run: cargo build --no-default-features --features stable
+      if: runner.os != 'Windows'
+
     - name: "Run cargo test"
       run: cargo test
 
+    - name: "Run cargo test for stable"
+      run: cargo test --no-default-features --features stable
+      if: runner.os != 'Windows'
+
     - name: 'Deny Warnings'
       run: cargo build --features deny-warnings
 

Cargo.toml

@@ -28,6 +28,16 @@ edition = "2018"
 [dependencies]
 bit_field = "0.9.0"
 bitflags = "1.0.4"
+array-init = { version = "0.1.1", optional = true }
+
+[build-dependencies]
+cc = { version = "1.0.37", optional = true }
 
 [features]
+default = [ "nightly" ]
 deny-warnings = []
+stable = [ "cc", "array-init" ]
+nightly = [ "inline_asm", "const_fn", "abi_x86_interrupt" ]
+inline_asm = []
+abi_x86_interrupt = []
+const_fn = []

README.md

@@ -3,3 +3,13 @@
 [![Build Status](https://github.com/rust-osdev/x86_64/workflows/Build/badge.svg)](https://github.com/rust-osdev/x86_64/actions?query=workflow%3ABuild) [![docs.rs](https://img.shields.io/badge/docs.rs-documentation-green.svg)](https://docs.rs/x86_64)
 
 Support for x86_64 specific instructions (e.g. TLB flush), registers (e.g. control registers), and structures (e.g. page tables).
+
+## Crate Feature Flags
+
+* `nightly`: This is the default.
+* `stable`: Use this to build with non-nightly rust. Needs `default-features = false`.
+
+## Building with stable rust
+
+This needs to have the [compile-time requirements](https://github.com/alexcrichton/cc-rs#compile-time-requirements) of the `cc` crate installed on your system.
+It was currently only tested on Linux and MacOS.

build.rs

@@ -0,0 +1,40 @@
+#[cfg(feature = "inline_asm")]
+fn main() {}
+
+#[cfg(all(not(feature = "inline_asm"), not(feature = "stable")))]
+fn check_inline_asm() {
+    compile_error!("Neither feature \"stable\" nor \"inline_asm\" was set!");
+}
+
+#[cfg(all(not(feature = "inline_asm"), feature = "stable"))]
+fn main() {
+    use std::ffi::OsString;
+    use std::fs;
+
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let entries = fs::read_dir("src/asm")
+        .unwrap()
+        .filter_map(|f| {
+            f.ok().and_then(|e| {
+                let path = e.path();
+                match path.extension() {
+                    Some(ext) if ext.eq(&OsString::from("s")) => Some(path),
+                    _ => None,
+                }
+            })
+        })
+        .collect::<Vec<_>>();
+
+    cc::Build::new()
+        .no_default_flags(true)
+        .files(&entries)
+        .pic(true)
+        .static_flag(true)
+        .shared_flag(false)
+        .compile("x86_64_asm");
+
+    for e in entries {
+        println!("cargo:rerun-if-changed={}", e.to_str().unwrap());
+    }
+}

src/asm/asm.s

@@ -0,0 +1,228 @@
+.text
+.code64
+
+.global _x86_64_asm_interrupt_enable
+.p2align 4
+_x86_64_asm_interrupt_enable:
+    sti
+    retq
+
+.global _x86_64_asm_interrupt_disable
+.p2align 4
+_x86_64_asm_interrupt_disable:
+    cli
+    retq
+
+.global _x86_64_asm_int3
+.p2align 4
+_x86_64_asm_int3:
+    int3
+    retq
+
+.global _x86_64_asm_read_from_port_u8
+.p2align 4
+_x86_64_asm_read_from_port_u8:
+    mov    %edi, %edx
+    inb    (%dx), %al
+    retq
+
+.global _x86_64_asm_read_from_port_u16
+.p2align 4
+_x86_64_asm_read_from_port_u16:
+    mov    %edi, %edx
+    inw    (%dx), %ax
+    retq
+
+.global _x86_64_asm_read_from_port_u32
+.p2align 4
+_x86_64_asm_read_from_port_u32:
+    mov    %edi, %edx
+    inl    (%dx), %eax
+    retq
+
+
+.global _x86_64_asm_write_to_port_u8
+.p2align 4
+_x86_64_asm_write_to_port_u8:
+    mov    %edi, %edx
+    mov    %si, %ax
+    outb   %al, (%dx)
+    retq
+
+.global _x86_64_asm_write_to_port_u16
+.p2align 4
+_x86_64_asm_write_to_port_u16:
+    mov    %edi, %edx
+    mov    %si, %ax
+    outw   %ax, (%dx)
+    retq
+
+.global _x86_64_asm_write_to_port_u32
+.p2align 4
+_x86_64_asm_write_to_port_u32:
+    mov    %edi, %edx
+    mov    %esi, %eax
+    outl   %eax, (%dx)
+    retq
+
+.global _x86_64_asm_set_cs
+.p2align 4
+_x86_64_asm_set_cs:
+    pushq %rdi
+    leaq  1f(%rip), %rax
+    pushq %rax
+    lretq
+1:
+    retq
+
+.global _x86_64_asm_get_cs
+.p2align 4
+_x86_64_asm_get_cs:
+    mov %cs, %ax
+    retq
+
+.global _x86_64_asm_invlpg
+.p2align 4
+_x86_64_asm_invlpg:
+    invlpg (%rdi)
+    retq
+
+.global _x86_64_asm_ltr
+.p2align 4
+_x86_64_asm_ltr:
+    mov %edi, %edx
+    ltr %dx
+    retq
+
+.global _x86_64_asm_lgdt
+.p2align 4
+_x86_64_asm_lgdt:
+    lgdt (%rdi)
+    retq
+
+.global _x86_64_asm_lidt
+.p2align 4
+_x86_64_asm_lidt:
+    lidt (%rdi)
+    retq
+
+.global _x86_64_asm_write_rflags
+.p2align 4
+_x86_64_asm_write_rflags:
+    pushq %rdi
+    popfq
+    retq
+
+.global _x86_64_asm_read_rflags
+.p2align 4
+_x86_64_asm_read_rflags:
+    pushq   %rbp
+    movq    %rsp, %rbp
+    pushfq
+    popq    %rax
+    popq    %rbp
+    retq
+
+.global _x86_64_asm_load_ss
+.p2align 4
+_x86_64_asm_load_ss:
+    mov %di, %ss
+    retq
+
+.global _x86_64_asm_load_ds
+.p2align 4
+_x86_64_asm_load_ds:
+    mov %di, %ds
+    retq
+
+.global _x86_64_asm_load_es
+.p2align 4
+_x86_64_asm_load_es:
+    mov %di, %es
+    retq
+
+.global _x86_64_asm_load_fs
+.p2align 4
+_x86_64_asm_load_fs:
+    mov %di, %fs
+    retq
+
+.global _x86_64_asm_load_gs
+.p2align 4
+_x86_64_asm_load_gs:
+    mov %di, %gs
+    retq
+
+.global _x86_64_asm_swapgs
+.p2align 4
+_x86_64_asm_swapgs:
+    swapgs
+    retq
+
+.global _x86_64_asm_read_cr0
+.p2align 4
+_x86_64_asm_read_cr0:
+    movq %cr0, %rax
+    retq
+
+.global _x86_64_asm_read_cr2
+.p2align 4
+_x86_64_asm_read_cr2:
+    movq %cr2, %rax
+    retq
+
+.global _x86_64_asm_read_cr3
+.p2align 4
+_x86_64_asm_read_cr3:
+    movq %cr3, %rax
+    retq
+
+.global _x86_64_asm_read_cr4
+.p2align 4
+_x86_64_asm_read_cr4:
+    movq %cr4, %rax
+    retq
+
+.global _x86_64_asm_write_cr0
+.p2align 4
+_x86_64_asm_write_cr0:
+    movq %rdi, %cr0
+    retq
+
+.global _x86_64_asm_write_cr3
+.p2align 4
+_x86_64_asm_write_cr3:
+    movq %rdi, %cr3
+    retq
+
+.global _x86_64_asm_write_cr4
+.p2align 4
+_x86_64_asm_write_cr4:
+    movq %rdi, %cr4
+    retq
+
+.global _x86_64_asm_rdmsr
+.p2align 4
+_x86_64_asm_rdmsr:
+    mov   %edi,%ecx
+    rdmsr
+    shl    $0x20,%rdx   # shift edx to upper 32bit
+    mov    %eax,%eax    # clear upper 32bit of rax
+    or     %rdx,%rax    # or with rdx
+    retq
+
+.global _x86_64_asm_wrmsr
+.p2align 4
+_x86_64_asm_wrmsr:
+    mov   %edi,%ecx
+    movq  %rsi,%rax
+    movq  %rsi,%rdx
+    shr   $0x20,%rdx
+    wrmsr
+    retq
+
+.global _x86_64_asm_hlt
+.p2align 4
+_x86_64_asm_hlt:
+    hlt
+    retq

src/asm/mod.rs

@@ -0,0 +1,69 @@
+#[link(name = "x86_64_asm", kind = "static")]
+extern "C" {
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_interrupt_enable")]
+    pub(crate) fn x86_64_asm_interrupt_enable();
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_interrupt_disable")]
+    pub(crate) fn x86_64_asm_interrupt_disable();
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_int3")]
+    pub(crate) fn x86_64_asm_int3();
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_hlt")]
+    pub(crate) fn x86_64_asm_hlt();
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_read_from_port_u8")]
+    pub(crate) fn x86_64_asm_read_from_port_u8(port: u16) -> u8;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_read_from_port_u16")]
+    pub(crate) fn x86_64_asm_read_from_port_u16(port: u16) -> u16;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_read_from_port_u32")]
+    pub(crate) fn x86_64_asm_read_from_port_u32(port: u16) -> u32;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_write_to_port_u8")]
+    pub(crate) fn x86_64_asm_write_to_port_u8(port: u16, value: u8);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_write_to_port_u16")]
+    pub(crate) fn x86_64_asm_write_to_port_u16(port: u16, value: u16);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_write_to_port_u32")]
+    pub(crate) fn x86_64_asm_write_to_port_u32(port: u16, value: u32);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_set_cs")]
+    pub(crate) fn x86_64_asm_set_cs(sel: u64);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_load_ss")]
+    pub(crate) fn x86_64_asm_load_ss(sel: u16);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_load_ds")]
+    pub(crate) fn x86_64_asm_load_ds(sel: u16);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_load_es")]
+    pub(crate) fn x86_64_asm_load_es(sel: u16);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_load_fs")]
+    pub(crate) fn x86_64_asm_load_fs(sel: u16);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_load_gs")]
+    pub(crate) fn x86_64_asm_load_gs(sel: u16);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_swapgs")]
+    pub(crate) fn x86_64_asm_swapgs();
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_get_cs")]
+    pub(crate) fn x86_64_asm_get_cs() -> u16;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_lgdt")]
+    pub(crate) fn x86_64_asm_lgdt(gdt: *const crate::instructions::tables::DescriptorTablePointer);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_lidt")]
+    pub(crate) fn x86_64_asm_lidt(idt: *const crate::instructions::tables::DescriptorTablePointer);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_ltr")]
+    pub(crate) fn x86_64_asm_ltr(sel: u16);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_invlpg")]
+    pub(crate) fn x86_64_asm_invlpg(addr: u64);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_read_cr0")]
+    pub(crate) fn x86_64_asm_read_cr0() -> u64;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_write_cr0")]
+    pub(crate) fn x86_64_asm_write_cr0(value: u64);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_read_cr2")]
+    pub(crate) fn x86_64_asm_read_cr2() -> u64;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_read_cr3")]
+    pub(crate) fn x86_64_asm_read_cr3() -> u64;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_write_cr3")]
+    pub(crate) fn x86_64_asm_write_cr3(value: u64);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_read_cr4")]
+    pub(crate) fn x86_64_asm_read_cr4() -> u64;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_write_cr4")]
+    pub(crate) fn x86_64_asm_write_cr4(value: u64);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_rdmsr")]
+    pub(crate) fn x86_64_asm_rdmsr(msr: u32) -> u64;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_wrmsr")]
+    pub(crate) fn x86_64_asm_wrmsr(msr: u32, value: u64);
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_read_rflags")]
+    pub(crate) fn x86_64_asm_read_rflags() -> u64;
+    #[cfg_attr(target_env = "gnu", link_name = "_x86_64_asm_write_rflags")]
+    pub(crate) fn x86_64_asm_write_rflags(val: u64);
+}