Add screenfetch, WIP: display master mode

Makefile

@@ -32,7 +32,6 @@ OBJDUMP=objdump
 RM=rm
 SED=sed
 SORT=sort
-VB=virtualbox
 VB_AUDIO="pulse"
 VBM=VBoxManage
 VBM_CLEANUP=\
@@ -282,9 +281,10 @@ bins: \
   	filesystem/bin/login \
   	filesystem/bin/minesweeper \
   	filesystem/bin/orbital \
-	filesystem/bin/std-test \
+	filesystem/bin/screenfetch \
   	filesystem/bin/sdl-test \
   	filesystem/bin/sdl-ttf-test \
+	filesystem/bin/std-test \
   	filesystem/bin/sh \
 	filesystem/bin/tar \
 	#TODO: binutils	filesystem/bin/zfs
@@ -556,7 +556,7 @@ virtualbox: $(BUILD)/harddrive.bin
 	$(VBM) storagectl Redox --name ATA --add sata --controller IntelAHCI --bootable on --portcount 1
 	$(VBM) storageattach Redox --storagectl ATA --port 0 --device 0 --type hdd --medium $(BUILD)/harddrive.vdi
 	echo "Run VM"
-	$(VB) --startvm Redox --dbg
+	$(VBM) startvm Redox
 
 bochs: $(BUILD)/harddrive.bin
 	-bochs -f bochs.$(ARCH)

crates/orbital/main.rs

@@ -463,7 +463,7 @@ fn main() {
     let status_daemon = status_mutex.clone();
     let daemon_thread = thread::spawn(move || {
         match Socket::create(":orbital").map(|socket| Arc::new(socket)) {
-            Ok(socket) => match Socket::open("display:").map(|display| Arc::new(display)) {
+            Ok(socket) => match Socket::open("display:manager").map(|display| Arc::new(display)) {
                 Ok(display) => {
                     let path = display.path().map(|path| path.into_os_string().into_string().unwrap_or(String::new())).unwrap_or(String::new());
                     let res = path.split(":").nth(1).unwrap_or("");

crates/screenfetch/main.rs

@@ -0,0 +1,37 @@
+use std::fs::File;
+use std::time::Instant;
+
+fn main() {
+    let uptime = Instant::now().inner().as_secs();
+
+    let mut width = 0;
+    let mut height = 0;
+    if let Ok(display) = File::open("display:") {
+        let path = display.path().map(|path| path.into_os_string().into_string().unwrap_or(String::new())).unwrap_or(String::new());
+        let res = path.split(":").nth(1).unwrap_or("");
+        width = res.split("/").nth(0).unwrap_or("").parse::<i32>().unwrap_or(0);
+        height = res.split("/").nth(1).unwrap_or("").parse::<i32>().unwrap_or(0);
+    }
+
+    println!("\x1B[38;5;75m                `.-/+NMN+-.`                   \x1B[0m\x1B[38;5;75mroot\x1B[0m@\x1B[38;5;75mhostname\x1B[0m");
+    println!("\x1B[38;5;75m           `:+oo+/-.-yds--/+oo+:`              \x1B[0m\x1B[38;5;75mOS:\x1B[0m redox-os");
+    println!("\x1B[38;5;75m        `/ss/++::/+o++++o+/:```:ss/`           \x1B[0m\x1B[38;5;75mKernel:\x1B[0m redox");
+    println!("\x1B[38;5;75m        `/ss/++::/+o++++o+/:```:ss/`           \x1B[0m\x1B[38;5;75mUptime:\x1B[0m {}s", uptime);
+    println!("\x1B[38;5;75m      `+h+``oMMN+.````````.:+syyy:/h+`         \x1B[0m\x1B[38;5;75mShell:\x1B[0m ion");
+    println!("\x1B[38;5;75m     /h/+mmm/://:+oo+//+oo+:. hNNh.`/h/        \x1B[0m\x1B[38;5;75mResolution:\x1B[0m {}x{}", width, height);
+    println!("\x1B[38;5;75m    oy` ydds`/s+:`        `:+s/-.+Ndd-so       \x1B[0m\x1B[38;5;75mDE:\x1B[0m orbital");
+    println!("\x1B[38;5;75m   os `yo  /y:                :y/.dmM- so      \x1B[0m\x1B[38;5;75mWM:\x1B[0m orbital");
+    println!("\x1B[38;5;75m  :h  s+  os`    \x1B[0msmhhhyyy/\x1B[38;5;75m     `so  +s  h:     \x1B[0m\x1B[38;5;75mFont:\x1B[0m unifont");
+    println!("\x1B[38;5;75m  m. -h  /h      \x1B[0myM    .oM+\x1B[38;5;75m      h/  h- .m     \x1B[0m");
+    println!("\x1B[38;5;75m  N  s+  d.      \x1B[0myM     -Ms\x1B[38;5;75m      .d  +s  m     \x1B[0m");
+    println!("\x1B[38;5;75m  h  y/  M       \x1B[0myM :+sydy`\x1B[38;5;75m       M  /y  h     \x1B[0m");
+    println!("\x1B[38;5;75m  M  oo  y/      \x1B[0myM .yNy.  \x1B[38;5;75m      /y  oo  M     \x1B[0m");
+    println!("\x1B[38;5;75m  y/ `m` .d.     \x1B[0myM   :md- \x1B[38;5;75m     .d.:hNy /y     \x1B[0m");
+    println!("\x1B[38;5;75m  .d` :h:--h:    \x1B[0m+s    `ss`\x1B[38;5;75m    :h- oMNh`d.     \x1B[0m");
+    println!("\x1B[38;5;75m   :d.-MMN:.oo:              :oo.+sd+..d:      \x1B[0m");
+    println!("\x1B[38;5;75m    -d//oyy////so/:oyo..ydhos/. +MMM::d-       \x1B[0m");
+    println!("\x1B[38;5;75m     `sy- yMMN. `./MMMo+dNm/ ./ss-./ys`        \x1B[0m");
+    println!("\x1B[38;5;75m       .ss/++:+oo+//:-..:+ooo+-``:ss.          \x1B[0m");
+    println!("\x1B[38;5;75m         `:ss/-` `.--::--.` `-/ss:`            \x1B[0m");
+    println!("\x1B[38;5;75m             ./oooooooooooooo/.                \x1B[0m");
+}

kernel/schemes/display.rs

@@ -1,4 +1,3 @@
-use alloc::arc::Arc;
 use alloc::boxed::Box;
 
 use collections::String;
@@ -8,22 +7,15 @@ use common::event::Event;
 use core::{cmp, ptr};
 use core::mem::size_of;
 
-use graphics::display::Display;
-
 use fs::{KScheme, Resource, ResourceSeek, Url};
 
-use system::error::{Error, Result, ENOENT, EINVAL};
+use system::error::{Error, Result, EACCES, EBADF, ENOENT, EINVAL};
 use system::graphics::fast_copy;
 
-pub struct DisplayScheme;
-
-// Should there only be one display per session?
 /// A display resource
 pub struct DisplayResource {
     /// Path
     path: String,
-    /// The display
-    display: Arc<Box<Display>>,
     /// Seek
     seek: usize,
 }
@@ -32,7 +24,6 @@ impl Resource for DisplayResource {
     fn dup(&self) -> Result<Box<Resource>> {
         Ok(Box::new(DisplayResource {
             path: self.path.clone(),
-            display: self.display.clone(),
             seek: self.seek
         }))
     }
@@ -70,54 +61,76 @@ impl Resource for DisplayResource {
     }
 
     fn write(&mut self, buf: &[u8]) -> Result<usize> {
-        let size = cmp::max(0, cmp::min(self.display.size as isize - self.seek as isize, (buf.len()/4) as isize)) as usize;
+        let console = ::env().console.lock();
+        if let Some(ref display) = console.display {
+            let size = cmp::max(0, cmp::min(display.size as isize - self.seek as isize, (buf.len()/4) as isize)) as usize;
 
-        if size > 0 {
-            unsafe {
-                fast_copy(self.display.onscreen.offset(self.seek as isize), buf.as_ptr() as *const u32, size);
+            if size > 0 {
+                unsafe {
+                    fast_copy(display.onscreen.offset(self.seek as isize), buf.as_ptr() as *const u32, size);
+                }
             }
-        }
 
-        Ok(size)
+            Ok(size)
+        } else {
+            Err(Error::new(EBADF))
+        }
     }
 
     fn seek(&mut self, pos: ResourceSeek) -> Result<usize> {
-        self.seek = match pos {
-            ResourceSeek::Start(offset) => cmp::min(self.display.size, cmp::max(0, offset)),
-            ResourceSeek::Current(offset) => cmp::min(self.display.size, cmp::max(0, self.seek as isize + offset) as usize),
-            ResourceSeek::End(offset) => cmp::min(self.display.size, cmp::max(0, self.display.size as isize + offset) as usize),
-        };
-
-        Ok(self.seek)
+        let console = ::env().console.lock();
+        if let Some(ref display) = console.display {
+            self.seek = match pos {
+                ResourceSeek::Start(offset) => cmp::min(display.size, cmp::max(0, offset)),
+                ResourceSeek::Current(offset) => cmp::min(display.size, cmp::max(0, self.seek as isize + offset) as usize),
+                ResourceSeek::End(offset) => cmp::min(display.size, cmp::max(0, display.size as isize + offset) as usize),
+            };
+
+            Ok(self.seek)
+        } else {
+            Err(Error::new(EBADF))
+        }
     }
 
     fn sync(&mut self) -> Result<()> {
         Ok(())
     }
 }
 
-impl Drop for DisplayScheme {
-    fn drop(&mut self){
-        ::env().console.lock().draw = true;
-    }
-}
+pub struct DisplayScheme;
 
 impl KScheme for DisplayScheme {
     fn scheme(&self) -> &str {
         "display"
     }
 
-    fn open(&mut self, _: Url, _: usize) -> Result<Box<Resource>> {
-        if let Some(display) = Display::root() {
-            ::env().console.lock().draw = false;
-
-            Ok(box DisplayResource {
-                path: format!("display:{}/{}", display.width, display.height),
-                display: Arc::new(display),
-                seek: 0,
-            })
+    fn open(&mut self, url: Url, _: usize) -> Result<Box<Resource>> {
+        if url.reference() == "manager" {
+            let mut console = ::env().console.lock();
+            if console.draw {
+                console.draw = false;
+
+                if let Some(ref display) = console.display {
+                    Ok(box DisplayResource {
+                        path: format!("display:{}/{}", display.width, display.height),
+                        seek: 0,
+                    })
+                } else {
+                    Err(Error::new(ENOENT))
+                }
+            } else {
+                Err(Error::new(EACCES))
+            }
         } else {
-            Err(Error::new(ENOENT))
+            let console = ::env().console.lock();
+            if let Some(ref display) = console.display {
+                Ok(box DisplayResource {
+                    path: format!("display:{}/{}", display.width, display.height),
+                    seek: 0,
+                })
+            } else {
+                Err(Error::new(ENOENT))
+            }
         }
     }
 }

libstd/src/time.rs

@@ -180,6 +180,10 @@ impl Instant {
     pub fn elapsed(&self) -> Duration {
         Instant::now().0 - self.0
     }
+
+    pub fn inner(self) -> Duration {
+        self.0
+    }
 }
 
 #[derive(Copy, Clone)]