Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(849)

Unified Diff: mojo/public/rust/src/system/shared_buffer.rs

Issue 2250183003: Make the fuchsia mojo/public repo the source of truth. (Closed) Base URL: https://github.com/domokit/mojo.git@master
Patch Set: Created 4 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « mojo/public/rust/src/system/mojo_types.rs ('k') | mojo/public/rust/src/system/wait_set.rs » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: mojo/public/rust/src/system/shared_buffer.rs
diff --git a/mojo/public/rust/src/system/shared_buffer.rs b/mojo/public/rust/src/system/shared_buffer.rs
deleted file mode 100644
index 399b515c3557159e32c3ca2f135ac4bceeff4626..0000000000000000000000000000000000000000
--- a/mojo/public/rust/src/system/shared_buffer.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-use std::mem;
-use std::slice;
-use std::ptr;
-
-use system::ffi;
-// This full import is intentional; nearly every type in mojo_types needs to be used.
-use system::mojo_types::*;
-use system::handle;
-use system::handle::{CastHandle, Handle};
-
-#[repr(u32)]
-/// Create flags for shared buffers
-pub enum Create {
- None = 0,
-}
-
-#[repr(u32)]
-/// Duplicate flags for shared buffers
-pub enum Duplicate {
- None = 0,
-}
-
-#[repr(u32)]
-/// Map flags for shared buffers
-pub enum Map {
- None = 0,
-}
-
-#[repr(u32)]
-/// Map flags for shared buffers
-pub enum Info {
- None = 0,
-}
-
-/// A MappedBuffer represents the result of
-/// calling map_buffer on a shared buffer handle.
-///
-/// The C API allocates a buffer which can then be
-/// read or written to through this data structure.
-///
-/// The importance of this data structure is that
-/// we bind the lifetime of the slice given to us
-/// from the C API to this structure. Additionally,
-/// reads and writes to this data structure are guaranteed
-/// to be able to propagate through Mojo as they are
-/// volatile. Language optimization backends are generally
-/// unaware of other address spaces, and since this structure
-/// represents some buffer from another address space, we
-/// need to make sure loads and stores are volatile.
-///
-/// Changes to this data structure are propagated through Mojo
-/// on the next Mojo operation (that is, Mojo operations are
-/// considered barriers). So, unmapping the buffer, sending a
-/// message across a pipe, duplicating a shared buffer handle,
-/// etc. are all valid ways of propagating changes. The read
-/// and write methods do NOT guarantee changes to propagate.
-///
-/// This structure also prevents resource leaks by
-/// unmapping the buffer it contains on destruction.
-pub struct MappedBuffer<'a> {
- buffer: &'a mut [u8],
-}
-
-impl<'a> MappedBuffer<'a> {
- /// Returns the length of the wrapped buffer.
- ///
- /// Part of reimplementing the array interface to be
- /// able to use the structure naturally.
- pub fn len(&self) -> usize {
- self.buffer.len()
- }
-
- /// Read safely from the shared buffer. Makes sure a real load
- /// is performed by marking the read as volatile.
- pub fn read(&self, index: usize) -> u8 {
- unsafe { ptr::read_volatile((&self.buffer[index]) as *const u8) }
- }
-
- /// Write safely to the shared buffer. Makes sure a real store
- /// is performed by marking the store as volatile.
- pub fn write(&mut self, index: usize, value: u8) {
- unsafe {
- ptr::write_volatile((&mut self.buffer[index]) as *mut u8, value);
- }
- }
-
- /// Returns the slice this buffer wraps.
- ///
- /// The reason this method is unsafe is because the way Rust maps
- /// reads and writes down to loads and stores may not be to real
- /// loads and stores which are required to allow changes to propagate
- /// through Mojo. If you are not careful, some writes and reads may be
- /// to incorrect data! Use at your own risk.
- pub unsafe fn as_slice(&'a mut self) -> &'a mut [u8] {
- self.buffer
- }
-}
-
-impl<'a> Drop for MappedBuffer<'a> {
- /// The destructor for MappedBuffer. Unmaps the buffer it
- /// encloses by using the original, raw pointer to the mapped
- /// memory region.
- fn drop(&mut self) {
- let r = MojoResult::from_code(unsafe {
- ffi::MojoUnmapBuffer(self.buffer.as_ptr() as *const ffi::c_void)
- });
- if r != MojoResult::Okay {
- panic!("Failed to unmap buffer. Mojo Error: {}", r);
- }
- }
-}
-
-/// Creates a shared buffer in Mojo and returns a SharedBuffer
-/// structure which represents a handle to the shared buffer.
-pub fn create(flags: CreateFlags, num_bytes: u64) -> Result<SharedBuffer, MojoResult> {
- let opts = ffi::MojoCreateSharedBufferOptions {
- struct_size: mem::size_of::<ffi::MojoCreateSharedBufferOptions>() as u32,
- flags: flags,
- _align: [],
- };
- let raw_opts = &opts as *const ffi::MojoCreateSharedBufferOptions;
- let mut h: MojoHandle = 0;
- let r = MojoResult::from_code(unsafe {
- ffi::MojoCreateSharedBuffer(raw_opts, num_bytes, &mut h as *mut MojoHandle)
- });
- if r != MojoResult::Okay {
- Err(r)
- } else {
- Ok(SharedBuffer { handle: unsafe { handle::acquire(h) } })
- }
-}
-
-/// Represents a handle to a shared buffer in Mojo.
-/// This data structure wraps a handle and acts
-/// effectively as a typed handle.
-pub struct SharedBuffer {
- handle: handle::UntypedHandle,
-}
-
-impl SharedBuffer {
- /// Duplicates the shared buffer handle. This is NOT the same
- /// as cloning the structure which is illegal since cloning could
- /// lead to resource leaks. Instead this uses Mojo to duplicate the
- /// buffer handle (though the handle itself may not be represented by
- /// the same number) that maps to the same shared buffer as the original.
- pub fn duplicate(&self, flags: DuplicateFlags) -> Result<SharedBuffer, MojoResult> {
- let opts = ffi::MojoDuplicateBufferHandleOptions {
- struct_size: mem::size_of::<ffi::MojoDuplicateBufferHandleOptions>() as u32,
- flags: flags,
- _align: [],
- };
- let raw_opts = &opts as *const ffi::MojoDuplicateBufferHandleOptions;
- let mut dup_h: MojoHandle = 0;
- let r = MojoResult::from_code(unsafe {
- ffi::MojoDuplicateBufferHandle(self.handle.get_native_handle(),
- raw_opts,
- &mut dup_h as *mut MojoHandle)
- });
- if r != MojoResult::Okay {
- Err(r)
- } else {
- Ok(SharedBuffer { handle: unsafe { handle::acquire(dup_h) } })
- }
- }
-
- /// Map the shared buffer into local memory. Generates a MappedBuffer
- /// structure. See MappedBuffer for more information on how to use it.
- pub fn map<'a>(&self,
- offset: u64,
- num_bytes: u64,
- flags: MapFlags)
- -> Result<MappedBuffer<'a>, MojoResult> {
- unsafe {
- let mut ptr: *mut ffi::c_void = mem::uninitialized();
- let r = MojoResult::from_code(ffi::MojoMapBuffer(self.handle.get_native_handle(),
- offset,
- num_bytes,
- &mut ptr,
- flags));
- if r != MojoResult::Okay {
- Err(r)
- } else {
- let mut buf = slice::from_raw_parts_mut(ptr as *mut u8, num_bytes as usize);
- Ok(MappedBuffer { buffer: buf })
- }
- }
- }
-
- /// Retrieves information about a shared buffer the this handle. The return
- /// value is a set of flags (a bit vector in a u32) representing different
- /// aspects of the shared buffer and the size of the shared buffer.
- pub fn get_info(&self) -> Result<(InfoFlags, u64), MojoResult> {
- let info_size = mem::size_of::<ffi::MojoBufferInformation>() as u32;
- let mut info = ffi::MojoBufferInformation {
- struct_size: info_size,
- flags: 0,
- num_bytes: 0,
- _align: [],
- };
- let r = MojoResult::from_code(unsafe {
- ffi::MojoGetBufferInformation(self.handle.get_native_handle(),
- &mut info as *mut ffi::MojoBufferInformation,
- info_size)
- });
- if r != MojoResult::Okay {
- Err(r)
- } else {
- Ok((info.flags, info.num_bytes))
- }
- }
-}
-
-impl CastHandle for SharedBuffer {
- /// Generates a SharedBuffer from an untyped handle wrapper
- /// See mojo::system::handle for information on untyped vs. typed
- unsafe fn from_untyped(handle: handle::UntypedHandle) -> Self {
- SharedBuffer { handle: handle }
- }
-
- /// Consumes this object and produces a plain handle wrapper
- /// See mojo::system::handle for information on untyped vs. typed
- fn as_untyped(self) -> handle::UntypedHandle {
- self.handle
- }
-}
-
-impl Handle for SharedBuffer {
- /// Returns the native handle wrapped by this structure.
- ///
- /// See mojo::system::handle for information on handle wrappers
- fn get_native_handle(&self) -> MojoHandle {
- self.handle.get_native_handle()
- }
-}
« no previous file with comments | « mojo/public/rust/src/system/mojo_types.rs ('k') | mojo/public/rust/src/system/wait_set.rs » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698