Merge pull request #608 from danobi/file_flags_type

rust: file: Add `FileFlags` type for `File` flags

Author: wedsonaf

drivers/android/process.rs

@@ -4,7 +4,7 @@ use core::{convert::TryFrom, mem::take, ops::Range};
 use kernel::{
     bindings,
     cred::Credential,
-    file::{self, File, IoctlCommand, IoctlHandler, PollTable},
+    file::{self, File, FileFlags, IoctlCommand, IoctlHandler, PollTable},
     io_buffer::{IoBufferReader, IoBufferWriter},
     linked_list::List,
     mm,
@@ -794,8 +794,9 @@ impl IoctlHandler for Process {
         data: UserSlicePtr,
     ) -> Result<i32> {
         let thread = this.get_thread(Task::current().pid())?;
+        let blocking = (file.flags() & FileFlags::O_NONBLOCK) == 0;
         match cmd {
-            bindings::BINDER_WRITE_READ => thread.write_read(data, file.is_blocking())?,
+            bindings::BINDER_WRITE_READ => thread.write_read(data, blocking)?,
             bindings::BINDER_GET_NODE_DEBUG_INFO => this.get_node_debug_info(data)?,
             bindings::BINDER_GET_NODE_INFO_FOR_REF => this.get_node_info_from_ref(data)?,
             bindings::BINDER_VERSION => this.version(data)?,

rust/kernel/file.rs

@@ -21,6 +21,94 @@ use core::convert::{TryFrom, TryInto};
 use core::{cell::UnsafeCell, marker, mem, ptr};
 use macros::vtable;
 
+/// Flags associated with a [`File`].
+///
+/// It is tagged with `non_exhaustive` to prevent users from instantiating it.
+#[non_exhaustive]
+pub struct FileFlags;
+
+impl FileFlags {
+    /// File is opened in append mode.
+    pub const O_APPEND: u32 = bindings::O_APPEND;
+
+    /// Signal-driven I/O is enabled.
+    pub const O_ASYNC: u32 = bindings::FASYNC;
+
+    /// Close-on-exec flag is set.
+    pub const O_CLOEXEC: u32 = bindings::O_CLOEXEC;
+
+    /// File was created if it didn't already exist.
+    pub const O_CREAT: u32 = bindings::O_CREAT;
+
+    /// Direct I/O is enabled for this file.
+    pub const O_DIRECT: u32 = bindings::O_DIRECT;
+
+    /// File must be a directory.
+    pub const O_DIRECTORY: u32 = bindings::O_DIRECTORY;
+
+    /// Like `Self::O_SYNC` except metadata is not synced.
+    pub const O_DSYNC: u32 = bindings::O_DSYNC;
+
+    /// Ensure that this file is created with the `open(2)` call.
+    pub const O_EXCL: u32 = bindings::O_EXCL;
+
+    /// Large file size enabled (`off64_t` over `off_t`)
+    pub const O_LARGEFILE: u32 = bindings::O_LARGEFILE;
+
+    /// Do not update the file last access time.
+    pub const O_NOATIME: u32 = bindings::O_NOATIME;
+
+    /// File should not be used as process's controlling terminal.
+    pub const O_NOCTTY: u32 = bindings::O_NOCTTY;
+
+    /// If basename of path is a symbolic link, fail open.
+    pub const O_NOFOLLOW: u32 = bindings::O_NOFOLLOW;
+
+    /// File is using nonblocking I/O.
+    pub const O_NONBLOCK: u32 = bindings::O_NONBLOCK;
+
+    /// Also known as `O_NDELAY`.
+    ///
+    /// This is effectively the same flag as [`Self::O_NONBLOCK`] on all architectures
+    /// except SPARC64.
+    pub const O_NDELAY: u32 = bindings::O_NDELAY;
+
+    /// Used to obtain a path file descriptor.
+    pub const O_PATH: u32 = bindings::O_PATH;
+
+    /// Write operations on this file will flush data and metadata.
+    pub const O_SYNC: u32 = bindings::O_SYNC;
+
+    /// This file is an unnamed temporary regular file.
+    pub const O_TMPFILE: u32 = bindings::O_TMPFILE;
+
+    /// File should be truncated to length 0.
+    pub const O_TRUNC: u32 = bindings::O_TRUNC;
+
+    /// Bitmask for access mode flags.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use kernel::file::FileFlags;
+    /// # fn do_something() {}
+    /// # let flags = 0;
+    /// if (flags & FileFlags::O_ACCMODE) == FileFlags::O_RDONLY {
+    ///     do_something();
+    /// }
+    /// ```
+    pub const O_ACCMODE: u32 = bindings::O_ACCMODE;
+
+    /// File is read only.
+    pub const O_RDONLY: u32 = bindings::O_RDONLY;
+
+    /// File is write only.
+    pub const O_WRONLY: u32 = bindings::O_WRONLY;
+
+    /// File can be both read and written.
+    pub const O_RDWR: u32 = bindings::O_RDWR;
+}
+
 /// Wraps the kernel's `struct file`.
 ///
 /// # Invariants
@@ -63,11 +151,6 @@ impl File {
         unsafe { core::ptr::addr_of!((*self.0.get()).f_pos).read() as _ }
     }
 
-    /// Returns whether the file is in blocking mode.
-    pub fn is_blocking(&self) -> bool {
-        self.flags() & bindings::O_NONBLOCK == 0
-    }
-
     /// Returns the credentials of the task that originally opened the file.
     pub fn cred(&self) -> &Credential {
         // SAFETY: The file is valid because the shared reference guarantees a nonzero refcount.
@@ -79,6 +162,8 @@ impl File {
     }
 
     /// Returns the flags associated with the file.
+    ///
+    /// The flags are a combination of the constants in [`FileFlags`].
     pub fn flags(&self) -> u32 {
         // SAFETY: The file is valid because the shared reference guarantees a nonzero refcount.
         unsafe { core::ptr::addr_of!((*self.0.get()).f_flags).read() }

samples/rust/rust_random.rs

@@ -6,7 +6,7 @@
 //! <https://github.com/alex/just-use/blob/master/src/lib.rs>.
 
 use kernel::{
-    file::{self, File},
+    file::{self, File, FileFlags},
     io_buffer::{IoBufferReader, IoBufferWriter},
     prelude::*,
 };
@@ -34,8 +34,9 @@ impl file::Operations for RandomFile {
         while !buf.is_empty() {
             let len = chunkbuf.len().min(buf.len());
             let chunk = &mut chunkbuf[0..len];
+            let blocking = (file.flags() & FileFlags::O_NONBLOCK) == 0;
 
-            if file.is_blocking() {
+            if blocking {
                 kernel::random::getrandom(chunk)?;
             } else {
                 kernel::random::getrandom_nonblock(chunk)?;