diff --git a/src/context/context.rs b/src/context/context.rs
index 51921216c1cada4c3aca99ac43991b23e8562050..b50773d4c9f5a447fc3c5daba69187ec8486a558 100644
--- a/src/context/context.rs
+++ b/src/context/context.rs
@@ -239,7 +239,7 @@ impl Context {
pub fn get_file(&self, i: FileHandle) -> Option<File> {
let files = self.files.lock();
if i.into() < files.len() {
- files[i.into()]
+ files[i.into()].clone()
} else {
None
}
diff --git a/src/context/file.rs b/src/context/file.rs
index e7519b63220d1c2f79503cf3e0bc7b2ba866bd21..4fea00fbbe6687e316b0a32e302bc2ee7cc17291 100644
--- a/src/context/file.rs
+++ b/src/context/file.rs
@@ -4,7 +4,7 @@ use scheme::SchemeId;
/// A file
//TODO: Close on exec
-#[derive(Copy, Clone, Debug)]
+#[derive(Clone, Debug)]
pub struct File {
/// The scheme that this file refers to
pub scheme: SchemeId,
diff --git a/src/scheme/debug.rs b/src/scheme/debug.rs
index a699aa8af0cc1c198bda4ca618652ffa72a16b51..23eb04900edfb52fc0e8cd4717cd9949f03f1171 100644
--- a/src/scheme/debug.rs
+++ b/src/scheme/debug.rs
@@ -5,7 +5,7 @@ use context;
use device::serial::COM1;
use scheme::*;
use sync::WaitQueue;
-use syscall::flag::EVENT_READ;
+use syscall::flag::{EVENT_READ, F_GETFL, F_SETFL, O_ACCMODE, O_NONBLOCK};
use syscall::scheme::Scheme;
pub static DEBUG_SCHEME_ID: AtomicSchemeId = ATOMIC_SCHEMEID_INIT;
@@ -24,62 +24,127 @@ pub fn debug_input(b: u8) {
context::event::trigger(DEBUG_SCHEME_ID.load(Ordering::SeqCst), 0, EVENT_READ, len);
}
-pub struct DebugScheme;
+pub struct DebugScheme {
+ next_id: AtomicUsize,
+ handles: RwLock<BTreeMap<usize, usize>>
+}
impl DebugScheme {
pub fn new(scheme_id: SchemeId) -> DebugScheme {
DEBUG_SCHEME_ID.store(scheme_id, Ordering::SeqCst);
- DebugScheme
+ DebugScheme {
+ next_id: AtomicUsize::new(0),
+ handles: RwLock::new(BTreeMap::new())
+ }
}
}
impl Scheme for DebugScheme {
- fn open(&self, _path: &[u8], _flags: usize, _uid: u32, _gid: u32) -> Result<usize> {
- Ok(0)
+ fn open(&self, _path: &[u8], flags: usize, _uid: u32, _gid: u32) -> Result<usize> {
+ let id = self.next_id.fetch_add(1, Ordering::SeqCst);
+ self.handles.write().insert(id, flags & ! O_ACCMODE);
+
+ Ok(id)
}
- fn dup(&self, _file: usize, _buf: &[u8]) -> Result<usize> {
- Ok(0)
+ fn dup(&self, id: usize, _buf: &[u8]) -> Result<usize> {
+ let flags = {
+ let handles = self.handles.read();
+ *handles.get(&id).ok_or(Error::new(EBADF))?
+ };
+
+ let new_id = self.next_id.fetch_add(1, Ordering::SeqCst);
+ self.handles.write().insert(new_id, flags);
+
+ Ok(new_id)
}
/// Read the file `number` into the `buffer`
///
/// Returns the number of bytes read
- fn read(&self, _file: usize, buf: &mut [u8]) -> Result<usize> {
- Ok(INPUT.call_once(init_input).receive_into(buf, true))
+ fn read(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+ let flags = {
+ let handles = self.handles.read();
+ *handles.get(&id).ok_or(Error::new(EBADF))?
+ };
+
+ Ok(INPUT.call_once(init_input).receive_into(buf, flags & O_NONBLOCK != O_NONBLOCK))
}
/// Write the `buffer` to the `file`
///
/// Returns the number of bytes written
- fn write(&self, _file: usize, buffer: &[u8]) -> Result<usize> {
+ fn write(&self, id: usize, buffer: &[u8]) -> Result<usize> {
+ let _flags = {
+ let handles = self.handles.read();
+ *handles.get(&id).ok_or(Error::new(EBADF))?
+ };
+
let mut com = COM1.lock();
for &byte in buffer.iter() {
com.send(byte);
}
+
Ok(buffer.len())
}
- fn fevent(&self, _file: usize, _flags: usize) -> Result<usize> {
+ fn fcntl(&self, id: usize, cmd: usize, arg: usize) -> Result<usize> {
+ let mut handles = self.handles.write();
+ if let Some(flags) = handles.get_mut(&id) {
+ match cmd {
+ F_GETFL => Ok(*flags),
+ F_SETFL => {
+ *flags = arg & ! O_ACCMODE;
+ Ok(0)
+ },
+ _ => Err(Error::new(EINVAL))
+ }
+ } else {
+ Err(Error::new(EBADF))
+ }
+ }
+
+ fn fevent(&self, id: usize, _flags: usize) -> Result<usize> {
+ let _flags = {
+ let handles = self.handles.read();
+ *handles.get(&id).ok_or(Error::new(EBADF))?
+ };
+
Ok(0)
}
- fn fpath(&self, _id: usize, buf: &mut [u8]) -> Result<usize> {
+ fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+ let _flags = {
+ let handles = self.handles.read();
+ *handles.get(&id).ok_or(Error::new(EBADF))?
+ };
+
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> {
+ fn fsync(&self, id: usize) -> Result<usize> {
+ let _flags = {
+ let handles = self.handles.read();
+ *handles.get(&id).ok_or(Error::new(EBADF))?
+ };
+
Ok(0)
}
/// Close the file `number`
- fn close(&self, _file: usize) -> Result<usize> {
+ fn close(&self, id: usize) -> Result<usize> {
+ let _flags = {
+ let mut handles = self.handles.write();
+ handles.remove(&id).ok_or(Error::new(EBADF))?
+ };
+
Ok(0)
}
}
diff --git a/src/scheme/env.rs b/src/scheme/env.rs
index 2e03be28fb5d362d05e4a0987d6d57546a26729d..d4a2973ad9468e23bc0df01aca72ceceb135d9a7 100644
--- a/src/scheme/env.rs
+++ b/src/scheme/env.rs
@@ -154,7 +154,17 @@ impl Scheme for EnvScheme {
Ok(handle.seek)
}
+ fn fcntl(&self, id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+ let handles = self.handles.read();
+ let _handle = handles.get(&id).ok_or(Error::new(EBADF))?;
+
+ Ok(0)
+ }
+
fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+ let handles = self.handles.read();
+ let _handle = handles.get(&id).ok_or(Error::new(EBADF))?;
+
let mut i = 0;
//TODO: Get env name
let scheme_path = b"env:";
diff --git a/src/scheme/event.rs b/src/scheme/event.rs
index 861a0d4ecdbfe77994944460438b1584356b1941..f68c2a3dcad551c8535b7784d859a60763ddf392 100644
--- a/src/scheme/event.rs
+++ b/src/scheme/event.rs
@@ -62,6 +62,12 @@ impl Scheme for EventScheme {
Ok(handle.receive_into(event_buf, true) * mem::size_of::<Event>())
}
+ fn fcntl(&self, id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+ let handles = self.handles.read();
+ let handle_weak = handles.get(&id).ok_or(Error::new(EBADF))?;
+ handle_weak.upgrade().ok_or(Error::new(EBADF)).and(Ok(0))
+ }
+
fn fpath(&self, _id: usize, buf: &mut [u8]) -> Result<usize> {
let mut i = 0;
let scheme_path = b"event:";
diff --git a/src/scheme/initfs.rs b/src/scheme/initfs.rs
index 827b0f992d062133959f421b92eebe1c27bb42f0..7c099aaf5e441c3c80b74d3d846d23c9e09822f8 100644
--- a/src/scheme/initfs.rs
+++ b/src/scheme/initfs.rs
@@ -5,7 +5,7 @@ use spin::RwLock;
use syscall::data::Stat;
use syscall::error::*;
-use syscall::flag::{O_CLOEXEC, MODE_DIR, MODE_FILE, SEEK_SET, SEEK_CUR, SEEK_END};
+use syscall::flag::{MODE_DIR, MODE_FILE, SEEK_SET, SEEK_CUR, SEEK_END};
use syscall::scheme::Scheme;
#[cfg(test)]
@@ -112,6 +112,13 @@ impl Scheme for InitFsScheme {
Ok(handle.seek)
}
+ fn fcntl(&self, id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+ let handles = self.handles.read();
+ let _handle = handles.get(&id).ok_or(Error::new(EBADF))?;
+
+ Ok(0)
+ }
+
fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
let handles = self.handles.read();
let handle = handles.get(&id).ok_or(Error::new(EBADF))?;
@@ -146,7 +153,9 @@ impl Scheme for InitFsScheme {
Ok(0)
}
- fn fsync(&self, _id: usize) -> Result<usize> {
+ fn fsync(&self, id: usize) -> Result<usize> {
+ let handles = self.handles.read();
+ let _handle = handles.get(&id).ok_or(Error::new(EBADF))?;
Ok(0)
}
diff --git a/src/scheme/irq.rs b/src/scheme/irq.rs
index a65367a4921a6ee0b5fa31ab00ef6934dd7de1bc..a5c0333c2dac298114cd012209a5ef8441416cf6 100644
--- a/src/scheme/irq.rs
+++ b/src/scheme/irq.rs
@@ -87,6 +87,10 @@ impl Scheme for IrqScheme {
}
}
+ fn fcntl(&self, _id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+ Ok(0)
+ }
+
fn fevent(&self, file: usize, _flags: usize) -> Result<usize> {
Ok(file)
}
diff --git a/src/scheme/live.rs b/src/scheme/live.rs
index c3f77ff28bc1ee789f4228ca61ce620fbeef17b3..e027564a605da86e6b41d66fb4ff7ab069fefa21 100644
--- a/src/scheme/live.rs
+++ b/src/scheme/live.rs
@@ -112,6 +112,13 @@ impl Scheme for DiskScheme {
Ok(handle.seek)
}
+ fn fcntl(&self, _id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+ let handles = self.handles.read();
+ let _handle = handles.get(&id).ok_or(Error::new(EBADF))?;
+
+ Ok(0)
+ }
+
fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
let handles = self.handles.read();
let handle = handles.get(&id).ok_or(Error::new(EBADF))?;
diff --git a/src/scheme/memory.rs b/src/scheme/memory.rs
index 0934b10eb6ca0aac736b5dcd92d020a2340581be..6d525c564e5f4a3d40a2756df4e04e6b34d14d16 100644
--- a/src/scheme/memory.rs
+++ b/src/scheme/memory.rs
@@ -23,7 +23,11 @@ impl Scheme for MemoryScheme {
Ok(0)
}
- fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+ fn fcntl(&self, _id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+ 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() {
diff --git a/src/scheme/null.rs b/src/scheme/null.rs
index c33377e8183e537315d0e8ee2bca70ee3cd4a66b..81b64549b2e8f9a991d7c081c285572e47548dbe 100644
--- a/src/scheme/null.rs
+++ b/src/scheme/null.rs
@@ -26,6 +26,10 @@ impl Scheme for NullScheme {
Ok(buffer.len())
}
+ fn fcntl(&self, _id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+ Ok(0)
+ }
+
fn fpath(&self, _id: usize, buf: &mut [u8]) -> Result<usize> {
let mut i = 0;
let scheme_path = b"null:";
diff --git a/src/scheme/pipe.rs b/src/scheme/pipe.rs
index 7de8636b0dc42d284fa5790162df9a06c8779e5e..802b748dfbd5f988095b6f96ce18123491c5df4b 100644
--- a/src/scheme/pipe.rs
+++ b/src/scheme/pipe.rs
@@ -112,7 +112,7 @@ impl Scheme for PipeScheme {
Err(Error::new(EBADF))
}
- fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+ 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() {
diff --git a/src/scheme/sys/iostat.rs b/src/scheme/sys/iostat.rs
index 9bb34e6c7f872fb5b15890d1309f9a6abf84487e..1f2610b18354004600b5c10fd43e0083d15ecaaf 100644
--- a/src/scheme/sys/iostat.rs
+++ b/src/scheme/sys/iostat.rs
@@ -28,7 +28,7 @@ pub fn resource() -> Result<Vec<u8>> {
for (fd, f) in row.2.iter().enumerate() {
let file = match *f {
None => continue,
- Some(file) => file
+ Some(ref file) => file.clone()
};
let scheme = {
diff --git a/src/scheme/sys/mod.rs b/src/scheme/sys/mod.rs
index ed09117d2c453d4967863759fe93bba162bac850..39b8953d8486136f9deb8375e16b7943f83e9e57 100644
--- a/src/scheme/sys/mod.rs
+++ b/src/scheme/sys/mod.rs
@@ -14,6 +14,7 @@ mod cpu;
mod exe;
mod iostat;
mod scheme;
+mod scheme_num;
//mod interrupt;
//mod log;
//mod test;
@@ -43,6 +44,7 @@ impl SysScheme {
files.insert(b"exe", Box::new(move || exe::resource()));
files.insert(b"iostat", Box::new(move || iostat::resource()));
files.insert(b"scheme", Box::new(move || scheme::resource()));
+ files.insert(b"scheme_num", Box::new(move || scheme_num::resource()));
//files.insert(b"interrupt", Box::new(move || interrupt::resource()));
//files.insert(b"log", Box::new(move || log::resource()));
//files.insert(b"test", Box::new(move || test::resource()));
diff --git a/src/scheme/sys/scheme.rs b/src/scheme/sys/scheme.rs
index b0f0c7d080f449e085bceb6db175bdac06c4866e..92f68833fd1ec3123fbba3b6b59785adc0fdf1a9 100644
--- a/src/scheme/sys/scheme.rs
+++ b/src/scheme/sys/scheme.rs
@@ -15,7 +15,7 @@ pub fn resource() -> Result<Vec<u8>> {
let mut data = Vec::new();
let schemes = scheme::schemes();
- for (name, _scheme_lock) in schemes.iter_name(scheme_ns) {
+ for (name, _scheme_id) in schemes.iter_name(scheme_ns) {
data.extend_from_slice(name);
data.push(b'\n');
}
diff --git a/src/scheme/sys/scheme_num.rs b/src/scheme/sys/scheme_num.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e3ae184b7c2f14a4731b3c4067bb0be34e8b5b64
--- /dev/null
+++ b/src/scheme/sys/scheme_num.rs
@@ -0,0 +1,25 @@
+use collections::Vec;
+
+use context;
+use scheme;
+use syscall::error::{Error, ESRCH, Result};
+
+pub fn resource() -> Result<Vec<u8>> {
+ let scheme_ns = {
+ let contexts = context::contexts();
+ let context_lock = contexts.current().ok_or(Error::new(ESRCH))?;
+ let context = context_lock.read();
+ context.ens
+ };
+
+ let mut data = Vec::new();
+
+ let schemes = scheme::schemes();
+ for (name, &scheme_id) in schemes.iter_name(scheme_ns) {
+ data.extend_from_slice(format!("{:>4}: ", scheme_id.into()).as_bytes());
+ data.extend_from_slice(name);
+ data.push(b'\n');
+ }
+
+ Ok(data)
+}
diff --git a/src/scheme/time.rs b/src/scheme/time.rs
index 0ff049521da7b71ccc1e95e6bb5a8603f806025c..faef3608e0ab7ecd4df53ff98d3949c1351aa605 100644
--- a/src/scheme/time.rs
+++ b/src/scheme/time.rs
@@ -97,6 +97,10 @@ impl Scheme for TimeScheme {
Ok(i * mem::size_of::<TimeSpec>())
}
+ fn fcntl(&self, _id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+ Ok(0)
+ }
+
fn fevent(&self, id: usize, _flags: usize) -> Result<usize> {
let handles = self.handles.read();
handles.get(&id).ok_or(Error::new(EBADF)).and(Ok(id))
diff --git a/src/scheme/zero.rs b/src/scheme/zero.rs
index 213cdbc15ef352b88e1fa135d48327bf31ae215f..194f2ecba969c33f58e8729559a66867dcf40368 100644
--- a/src/scheme/zero.rs
+++ b/src/scheme/zero.rs
@@ -31,6 +31,10 @@ impl Scheme for ZeroScheme {
Ok(buffer.len())
}
+ fn fcntl(&self, _id: usize, _cmd: usize, _arg: usize) -> Result<usize> {
+ Ok(0)
+ }
+
fn fpath(&self, _id: usize, buf: &mut [u8]) -> Result<usize> {
let mut i = 0;
let scheme_path = b"zero:";
diff --git a/src/syscall/fs.rs b/src/syscall/fs.rs
index 2b80c41d59d1906eeb76747c5a664d0e120052a4..f1f0e1703ea3e589c94fa01bd8d39891019bea2a 100644
--- a/src/syscall/fs.rs
+++ b/src/syscall/fs.rs
@@ -6,7 +6,7 @@ use scheme::{self, FileHandle};
use syscall;
use syscall::data::{Packet, Stat};
use syscall::error::*;
-use syscall::flag::{F_SETFL, O_ACCMODE, O_RDONLY, O_WRONLY, MODE_DIR, MODE_FILE};
+use syscall::flag::{F_GETFL, F_SETFL, O_ACCMODE, O_RDONLY, O_WRONLY, MODE_DIR, MODE_FILE};
pub fn file_op(a: usize, fd: FileHandle, c: usize, d: usize) -> Result<usize> {
let (file, pid, uid, gid) = {
@@ -303,7 +303,7 @@ pub fn dup2(fd: FileHandle, new_fd: FileHandle, buf: &[u8]) -> Result<FileHandle
}
}
-// File descriptor controls
+/// File descriptor controls
pub fn fcntl(fd: FileHandle, cmd: usize, arg: usize) -> Result<usize> {
let file = {
let contexts = context::contexts();
@@ -313,6 +313,7 @@ pub fn fcntl(fd: FileHandle, cmd: usize, arg: usize) -> Result<usize> {
file
};
+ // Communicate fcntl with scheme
let res = {
let scheme = {
let schemes = scheme::schemes();
@@ -322,17 +323,29 @@ pub fn fcntl(fd: FileHandle, cmd: usize, arg: usize) -> Result<usize> {
scheme.fcntl(file.number, cmd, arg)?
};
- if cmd == F_SETFL {
+ // Perform kernel operation if scheme agrees
+ {
let contexts = context::contexts();
let context_lock = contexts.current().ok_or(Error::new(ESRCH))?;
let context = context_lock.read();
let mut files = context.files.lock();
- let mut file = files.get_mut(fd.into()).ok_or(Error::new(EBADF))?.ok_or(Error::new(EBADF))?;
- let accmode = file.flags & O_ACCMODE;
- file.flags = accmode | arg & !O_ACCMODE;
+ match *files.get_mut(fd.into()).ok_or(Error::new(EBADF))? {
+ Some(ref mut file) => match cmd {
+ F_GETFL => {
+ Ok(file.flags)
+ },
+ F_SETFL => {
+ let new_flags = (file.flags & O_ACCMODE) | (arg & ! O_ACCMODE);
+ file.flags = new_flags;
+ Ok(0)
+ },
+ _ => {
+ Err(Error::new(EINVAL))
+ }
+ },
+ None => Err(Error::new(EBADF))
+ }
}
-
- Ok(res)
}
/// Register events for file
@@ -342,12 +355,16 @@ pub fn fevent(fd: FileHandle, flags: usize) -> Result<usize> {
let context_lock = contexts.current().ok_or(Error::new(ESRCH))?;
let context = context_lock.read();
let mut files = context.files.lock();
- let mut file = files.get_mut(fd.into()).ok_or(Error::new(EBADF))?.ok_or(Error::new(EBADF))?;
- if let Some(event_id) = file.event.take() {
- println!("{:?}: {:?}:{}: events already registered: {}", fd, file.scheme, file.number, event_id);
- context::event::unregister(fd, file.scheme, event_id);
+ match *files.get_mut(fd.into()).ok_or(Error::new(EBADF))? {
+ Some(ref mut file) => {
+ if let Some(event_id) = file.event.take() {
+ println!("{:?}: {:?}:{}: events already registered: {}", fd, file.scheme, file.number, event_id);
+ context::event::unregister(fd, file.scheme, event_id);
+ }
+ file.clone()
+ },
+ None => return Err(Error::new(EBADF))
}
- file.clone()
};
let scheme = {
@@ -361,8 +378,10 @@ pub fn fevent(fd: FileHandle, flags: usize) -> Result<usize> {
let context_lock = contexts.current().ok_or(Error::new(ESRCH))?;
let context = context_lock.read();
let mut files = context.files.lock();
- let mut file = files.get_mut(fd.into()).ok_or(Error::new(EBADF))?.ok_or(Error::new(EBADF))?;
- file.event = Some(event_id);
+ match *files.get_mut(fd.into()).ok_or(Error::new(EBADF))? {
+ Some(ref mut file) => file.event = Some(event_id),
+ None => return Err(Error::new(EBADF)),
+ }
}
context::event::register(fd, file.scheme, event_id);
Ok(0)
diff --git a/src/syscall/process.rs b/src/syscall/process.rs
index a302861276249a19cf8d41663ac34e1624d6421e..d202d46bcfca02cb8ee86889313c1bb2fcbcbe57 100644
--- a/src/syscall/process.rs
+++ b/src/syscall/process.rs
@@ -253,15 +253,14 @@ pub fn clone(flags: usize, stack_base: usize) -> Result<ContextId> {
// This has to be done outside the context lock to prevent deadlocks
if flags & CLONE_FILES == 0 {
for (_fd, mut file_option) in files.lock().iter_mut().enumerate() {
- let new_file_option = if let Some(file) = *file_option {
+ let new_file_option = if let Some(ref file) = *file_option {
let result = {
let scheme = {
let schemes = scheme::schemes();
let scheme = schemes.get(file.scheme).ok_or(Error::new(EBADF))?;
scheme.clone()
};
- let result = scheme.dup(file.number, b"clone");
- result
+ scheme.dup(file.number, b"clone")
};
match result {
Ok(new_number) => {
@@ -731,7 +730,7 @@ pub fn exec(path: &[u8], arg_ptrs: &[[usize; 2]]) -> Result<usize> {
// Duplicate current files using b"exec", close previous
for (fd, mut file_option) in files.lock().iter_mut().enumerate() {
- let new_file_option = if let Some(file) = *file_option {
+ let new_file_option = if let Some(ref file) = *file_option {
// Duplicate
let result = {
if file.flags & O_CLOEXEC == O_CLOEXEC {
@@ -742,8 +741,7 @@ pub fn exec(path: &[u8], arg_ptrs: &[[usize; 2]]) -> Result<usize> {
schemes.get(file.scheme).map(|scheme| scheme.clone())
};
if let Some(scheme) = scheme_option {
- let result = scheme.dup(file.number, b"exec");
- result
+ scheme.dup(file.number, b"exec")
} else {
Err(Error::new(EBADF))
}