use macro to handle IO error

sefs-fuse/enclave/src/lib.rs

@@ -44,7 +44,6 @@ use std::io::{Read, Seek, SeekFrom, Write};
 use std::path::PathBuf;
 use std::sgxfs::{OpenOptions, SgxFile};
 use std::sync::{SgxMutex as Mutex, SgxRwLock as RwLock};
-use std::untrusted::path::PathEx;
 use std::vec::Vec;
 
 #[no_mangle]
@@ -59,13 +58,19 @@ pub extern "C" fn ecall_set_sefs_dir(path: *const u8, len: usize) -> i32 {
     }
 }
 
+/// Helper macro to reply error when IO fails
+macro_rules! try_io {
+    ($expr:expr) => (match $expr {
+        Ok(val) => val,
+        Err(err) => return err.raw_os_error().unwrap(),
+    });
+}
+
 #[no_mangle]
 pub extern "C" fn ecall_file_open(fd: usize) -> i32 {
     let path = get_path(fd);
-    let file = match OpenOptions::new().append(true).update(true).open(&path) {
-        Ok(f) => f,
-        Err(e) => { println!("open err {}", e); panic!() }
-    };
+    let file = try_io!(OpenOptions::new().append(true).update(true).binary(true).open(&path));
+    println!("open fd = {}", fd);
     let file = LockedFile(Mutex::new(file));
     let mut files = FILES.write().unwrap();
     files.insert(fd, file);
@@ -76,6 +81,7 @@ pub extern "C" fn ecall_file_open(fd: usize) -> i32 {
 pub extern "C" fn ecall_file_close(fd: usize) -> i32 {
     let mut files = FILES.write().unwrap();
     files.remove(&fd);
+    println!("close fd = {}", fd);
     0
 }
 
@@ -83,10 +89,9 @@ pub extern "C" fn ecall_file_close(fd: usize) -> i32 {
 pub extern "C" fn ecall_file_flush(fd: usize) -> i32 {
     let files = FILES.read().unwrap();
     let mut file = files[&fd].0.lock().unwrap();
-    match file.flush() {
-        Ok(_) => 0,
-        Err(_) => -1,
-    }
+    println!("flush fd = {}", fd);
+    try_io!(file.flush());
+    0
 }
 
 #[no_mangle]
@@ -94,17 +99,17 @@ pub extern "C" fn ecall_file_read_at(fd: usize, offset: usize, buf: *mut u8, len
     let files = FILES.read().unwrap();
     let mut file = files[&fd].0.lock().unwrap();
 
-    println!("read_at fd = {}, offset = {}, len = {}", fd, offset, len);
     let offset = offset as u64;
-    match file.seek(SeekFrom::Start(offset)) {
-        Ok(real_offset) if real_offset == offset => {},
-        _ => return -1,
-    }
+    println!("read_at fd = {}, offset = {}, len = {}", fd, offset, len);
+    try_io!(file.seek(SeekFrom::Start(offset)));
+    println!("pos = {}", try_io!(file.seek(SeekFrom::Current(0))));
+
     let buf = unsafe { std::slice::from_raw_parts_mut(buf, len) };
-    match file.read(buf) {
-        Ok(len) => len as i32,
-        Err(e) => {println!("read_at fail {}", e); -2},
-    }
+    let len = try_io!(file.read(buf)) as i32;
+    println!("{:?}", buf);
+    println!("end pos = {}", try_io!(file.seek(SeekFrom::Current(0))));
+
+    len
 }
 
 #[no_mangle]
@@ -114,15 +119,14 @@ pub extern "C" fn ecall_file_write_at(fd: usize, offset: usize, buf: *const u8,
 
     let offset = offset as u64;
     println!("write_at fd = {}, offset = {}, len = {}", fd, offset, len);
-    match file.seek(SeekFrom::Start(offset)) {
-        Ok(real_offset) if real_offset == offset => {},
-        _ => return -1,
-    }
+    try_io!(file.seek(SeekFrom::Start(offset)));
+    println!("pos = {}", try_io!(file.seek(SeekFrom::Current(0))));
     let buf = unsafe { std::slice::from_raw_parts(buf, len) };
-    match file.write(buf) {
-        Ok(len) => len as i32,
-        Err(_) => return -2,
-    }
+    let ret = try_io!(file.write(buf)) as i32;
+    println!("{:?}", buf);
+    println!("end pos = {}", try_io!(file.seek(SeekFrom::Current(0))));
+
+    ret
 }
 
 #[no_mangle]
@@ -131,17 +135,11 @@ pub extern "C" fn ecall_file_set_len(fd: usize, len: usize) -> i32 {
     let mut file = files[&fd].0.lock().unwrap();
 
     println!("set_len fd = {}, len = {}", fd, len);
-    let current_len = match file.seek(SeekFrom::End(0)) {
-        Ok(len) => len as usize,
-        Err(_) => return -1,
-    };
+    let current_len = try_io!(file.seek(SeekFrom::End(0))) as usize;
     if current_len < len {
         let mut zeros = Vec::<u8>::new();
         zeros.resize(len - current_len, 0);
-        match file.write(zeros.as_slice()) {
-            Ok(_) => {}
-            Err(_) => return -2,
-        }
+        try_io!(file.write(zeros.as_slice()));
     }
     // TODO: how to shrink a file?
     0