diff --git a/src/scheme/debug.rs b/src/scheme/debug.rs
index ddfa120..a699aa8 100644
--- a/src/scheme/debug.rs
+++ b/src/scheme/debug.rs
@@ -64,6 +64,16 @@ impl Scheme for DebugScheme {
         Ok(0)
     }
 
+    fn fpath(&self, _id: usize, buf: &mut [u8]) -> Result<usize> {
+        let mut i = 0;
+        let scheme_path = b"debug:";
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+        Ok(i)
+    }
+
     fn fsync(&self, _file: usize) -> Result<usize> {
         Ok(0)
     }
diff --git a/src/scheme/env.rs b/src/scheme/env.rs
index bc84166..2e03be2 100644
--- a/src/scheme/env.rs
+++ b/src/scheme/env.rs
@@ -154,6 +154,17 @@ impl Scheme for EnvScheme {
         Ok(handle.seek)
     }
 
+    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+        let mut i = 0;
+        //TODO: Get env name
+        let scheme_path = b"env:";
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+        Ok(i)
+    }
+
     fn fstat(&self, id: usize, stat: &mut Stat) -> Result<usize> {
         let handles = self.handles.read();
         let handle = handles.get(&id).ok_or(Error::new(EBADF))?;
diff --git a/src/scheme/event.rs b/src/scheme/event.rs
index 2266141..861a0d4 100644
--- a/src/scheme/event.rs
+++ b/src/scheme/event.rs
@@ -62,6 +62,16 @@ impl Scheme for EventScheme {
         Ok(handle.receive_into(event_buf, true) * mem::size_of::<Event>())
     }
 
+    fn fpath(&self, _id: usize, buf: &mut [u8]) -> Result<usize> {
+        let mut i = 0;
+        let scheme_path = b"event:";
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+        Ok(i)
+    }
+
     fn fsync(&self, id: usize) -> Result<usize> {
         let handles = self.handles.read();
         let handle_weak = handles.get(&id).ok_or(Error::new(EBADF))?;
diff --git a/src/scheme/irq.rs b/src/scheme/irq.rs
index 5892cdd..a65367a 100644
--- a/src/scheme/irq.rs
+++ b/src/scheme/irq.rs
@@ -91,6 +91,16 @@ impl Scheme for IrqScheme {
         Ok(file)
     }
 
+    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+        let mut i = 0;
+        let scheme_path = format!("irq:{}", id).into_bytes();
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+        Ok(i)
+    }
+
     fn fsync(&self, _file: usize) -> Result<usize> {
         Ok(0)
     }
diff --git a/src/scheme/memory.rs b/src/scheme/memory.rs
index c784f0b..0934b10 100644
--- a/src/scheme/memory.rs
+++ b/src/scheme/memory.rs
@@ -23,6 +23,16 @@ impl Scheme for MemoryScheme {
         Ok(0)
     }
 
+    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+        let mut i = 0;
+        let scheme_path = b"memory:";
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+        Ok(i)
+    }
+
     /// Close the file `number`
     fn close(&self, _file: usize) -> Result<usize> {
         Ok(0)
diff --git a/src/scheme/null.rs b/src/scheme/null.rs
index 690c16c..c33377e 100644
--- a/src/scheme/null.rs
+++ b/src/scheme/null.rs
@@ -26,6 +26,16 @@ impl Scheme for NullScheme {
         Ok(buffer.len())
     }
 
+    fn fpath(&self, _id: usize, buf: &mut [u8]) -> Result<usize> {
+        let mut i = 0;
+        let scheme_path = b"null:";
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+        Ok(i)
+    }
+
     fn fsync(&self, _file: usize) -> Result<usize> {
         Ok(0)
     }
diff --git a/src/scheme/pipe.rs b/src/scheme/pipe.rs
index 5e64350..e03312c 100644
--- a/src/scheme/pipe.rs
+++ b/src/scheme/pipe.rs
@@ -112,6 +112,16 @@ impl Scheme for PipeScheme {
         Err(Error::new(EBADF))
     }
 
+    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+        let mut i = 0;
+        let scheme_path = b"pipe:";
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+        Ok(i)
+    }
+
     fn fsync(&self, _id: usize) -> Result<usize> {
         Ok(0)
     }
diff --git a/src/scheme/root.rs b/src/scheme/root.rs
index 1860998..cd08fd3 100644
--- a/src/scheme/root.rs
+++ b/src/scheme/root.rs
@@ -40,9 +40,10 @@ impl Scheme for RootScheme {
             let id = self.next_id.fetch_add(1, Ordering::SeqCst);
 
             let inner = {
+                let path_box = path.to_vec().into_boxed_slice();
                 let mut schemes = scheme::schemes_mut();
-                let inner = Arc::new(UserInner::new(self.scheme_id, id, flags, context));
-                schemes.insert(self.scheme_ns, path.to_vec().into_boxed_slice(), |scheme_id| {
+                let inner = Arc::new(UserInner::new(self.scheme_id, id, path_box.clone(), flags, context));
+                schemes.insert(self.scheme_ns, path_box, |scheme_id| {
                     inner.scheme_id.store(scheme_id, Ordering::SeqCst);
                     Arc::new(Box::new(UserScheme::new(Arc::downgrade(&inner))))
                 })?;
@@ -100,6 +101,30 @@ impl Scheme for RootScheme {
         inner.fevent(flags)
     }
 
+    fn fpath(&self, file: usize, buf: &mut [u8]) -> Result<usize> {
+        let inner = {
+            let handles = self.handles.read();
+            let inner = handles.get(&file).ok_or(Error::new(EBADF))?;
+            inner.clone()
+        };
+
+        let mut i = 0;
+        let scheme_path = b":";
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+
+        let mut j = 0;
+        while i < buf.len() && j < inner.name.len() {
+            buf[i] = inner.name[j];
+            i += 1;
+            j += 1;
+        }
+
+        Ok(i)
+    }
+
     fn fsync(&self, file: usize) -> Result<usize> {
         let inner = {
             let handles = self.handles.read();
diff --git a/src/scheme/time.rs b/src/scheme/time.rs
index 3a7fe1b..0ff0495 100644
--- a/src/scheme/time.rs
+++ b/src/scheme/time.rs
@@ -102,6 +102,21 @@ impl Scheme for TimeScheme {
         handles.get(&id).ok_or(Error::new(EBADF)).and(Ok(id))
     }
 
+    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+        let clock = {
+            let handles = self.handles.read();
+            *handles.get(&id).ok_or(Error::new(EBADF))?
+        };
+
+        let mut i = 0;
+        let scheme_path = format!("time:{}", clock).into_bytes();
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+        Ok(i)
+    }
+
     fn fsync(&self, id: usize) -> Result<usize> {
         let handles = self.handles.read();
         handles.get(&id).ok_or(Error::new(EBADF)).and(Ok(0))
diff --git a/src/scheme/user.rs b/src/scheme/user.rs
index 93f5124..cbfcac1 100644
--- a/src/scheme/user.rs
+++ b/src/scheme/user.rs
@@ -1,4 +1,5 @@
 use alloc::arc::{Arc, Weak};
+use alloc::boxed::Box;
 use collections::BTreeMap;
 use core::sync::atomic::{AtomicU64, Ordering};
 use core::{mem, slice, usize};
@@ -19,6 +20,7 @@ use syscall::scheme::Scheme;
 pub struct UserInner {
     root_id: SchemeId,
     handle_id: usize,
+    pub name: Box<[u8]>,
     flags: usize,
     pub scheme_id: AtomicSchemeId,
     next_id: AtomicU64,
@@ -29,10 +31,11 @@ pub struct UserInner {
 }
 
 impl UserInner {
-    pub fn new(root_id: SchemeId, handle_id: usize, flags: usize, context: Weak<RwLock<Context>>) -> UserInner {
+    pub fn new(root_id: SchemeId, handle_id: usize, name: Box<[u8]>, flags: usize, context: Weak<RwLock<Context>>) -> UserInner {
         UserInner {
             root_id: root_id,
             handle_id: handle_id,
+            name: name,
             flags: flags,
             scheme_id: ATOMIC_SCHEMEID_INIT,
             next_id: AtomicU64::new(1),
diff --git a/src/scheme/zero.rs b/src/scheme/zero.rs
index 90175cb..213cdbc 100644
--- a/src/scheme/zero.rs
+++ b/src/scheme/zero.rs
@@ -31,6 +31,16 @@ impl Scheme for ZeroScheme {
         Ok(buffer.len())
     }
 
+    fn fpath(&self, _id: usize, buf: &mut [u8]) -> Result<usize> {
+        let mut i = 0;
+        let scheme_path = b"zero:";
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+        Ok(i)
+    }
+
     fn fsync(&self, _file: usize) -> Result<usize> {
         Ok(0)
     }