Merge pull request #97 from nabeelomer/master

Added docs to the interrupts crate

Author: steveklabnik

interrupts/src/lib.rs

@@ -1,3 +1,6 @@
+//! This module contains methods and macros to create and register interrupt descriptors and
+//! interrupt handlers
+
 #![feature(asm)]
 #![feature(naked_functions)]
 #![feature(const_fn)]
@@ -12,6 +15,9 @@ use x86::shared::dtables;
 use x86::shared::dtables::DescriptorTablePointer;
 use x86::bits64::irq::IdtEntry;
 
+/// Creates an IDT entry.
+///
+/// Creates an IDT entry that executes the expression in `body`.
 #[macro_export]
 macro_rules! make_idt_entry {
     ($name:ident, $body:expr) => {{
@@ -75,8 +81,12 @@ macro_rules! make_idt_entry {
     }};
 }
 
+/// The Interrupt Descriptor Table
+///
+/// The CPU will look at this table to find the appropriate interrupt handler.
 static IDT: Mutex<[IdtEntry; 256]> = Mutex::new([IdtEntry::MISSING; 256]);
 
+/// Pointer to the Interrupt Descriptor Table
 pub struct IdtRef {
     ptr: DescriptorTablePointer<IdtEntry>,
     idt: &'static Mutex<[IdtEntry; 256]>,
@@ -85,6 +95,7 @@ pub struct IdtRef {
 unsafe impl Sync for IdtRef {}
 
 impl IdtRef {
+    /// Creates a new pointer struct to the IDT.
     pub fn new() -> IdtRef {
         let r = IdtRef {
             ptr: DescriptorTablePointer::new_idtp(&IDT.lock()[..]),
@@ -93,17 +104,17 @@ impl IdtRef {
 
         // This block is safe because by referencing IDT above, we know that we've constructed an
         // IDT.
-        unsafe {
-            dtables::lidt(&r.ptr)
-        };
+        unsafe { dtables::lidt(&r.ptr) };
 
         r
     }
 
+    /// Sets an IdtEntry as a handler for interrupt specified by `index`.
     pub fn set_handler(&self, index: usize, entry: IdtEntry) {
         self.idt.lock()[index] = entry;
     }
 
+    /// Enables interrupts.
     pub fn enable_interrupts(&self) {
         // This unsafe fn is okay becuase, by virtue of having an IdtRef, we know that we have a
         // valid Idt.