108 lines
3.0 KiB
Rust
108 lines
3.0 KiB
Rust
// Copyright 2020 The Chromium OS 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 crate::descriptor::{AsRawDescriptor, FromRawDescriptor, IntoRawDescriptor, SafeDescriptor};
|
|
use crate::{Error, MemfdSeals, RawDescriptor, Result};
|
|
#[cfg(unix)]
|
|
use std::os::unix::io::RawFd;
|
|
use std::{
|
|
ffi::CStr,
|
|
fs::File,
|
|
os::unix::io::{AsRawFd, IntoRawFd},
|
|
};
|
|
|
|
use crate::platform::SharedMemory as SysUtilSharedMemory;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
/// See [SharedMemory](crate::platform::SharedMemory) for struct- and method-level
|
|
/// documentation.
|
|
#[derive(Serialize, Deserialize)]
|
|
#[serde(transparent)]
|
|
pub struct SharedMemory(SysUtilSharedMemory);
|
|
impl SharedMemory {
|
|
pub fn named<T: Into<Vec<u8>>>(name: T, size: u64) -> Result<SharedMemory> {
|
|
SysUtilSharedMemory::named(name)
|
|
.and_then(|mut shm| shm.set_size(size).map(|_| shm))
|
|
.map(SharedMemory)
|
|
}
|
|
|
|
pub fn anon(size: u64) -> Result<SharedMemory> {
|
|
Self::new(None, size)
|
|
}
|
|
|
|
pub fn new(name: Option<&CStr>, size: u64) -> Result<SharedMemory> {
|
|
SysUtilSharedMemory::new(name)
|
|
.and_then(|mut shm| shm.set_size(size).map(|_| shm))
|
|
.map(SharedMemory)
|
|
}
|
|
|
|
pub fn size(&self) -> u64 {
|
|
self.0.size()
|
|
}
|
|
}
|
|
|
|
pub trait Unix {
|
|
/// Creates a SharedMemory instance from a SafeDescriptor owning a reference to a
|
|
/// shared memory descriptor. Ownership of the underlying descriptor is transferred to the
|
|
/// new SharedMemory object.
|
|
fn from_safe_descriptor(descriptor: SafeDescriptor) -> Result<SharedMemory> {
|
|
let file = unsafe { File::from_raw_descriptor(descriptor.into_raw_descriptor()) };
|
|
SysUtilSharedMemory::from_file(file).map(SharedMemory)
|
|
}
|
|
|
|
fn from_file(file: File) -> Result<SharedMemory> {
|
|
SysUtilSharedMemory::from_file(file).map(SharedMemory)
|
|
}
|
|
|
|
fn get_seals(&self) -> Result<MemfdSeals>;
|
|
|
|
fn add_seals(&mut self, seals: MemfdSeals) -> Result<()>;
|
|
}
|
|
|
|
impl Unix for SharedMemory {
|
|
fn get_seals(&self) -> Result<MemfdSeals> {
|
|
self.0.get_seals()
|
|
}
|
|
|
|
fn add_seals(&mut self, seals: MemfdSeals) -> Result<()> {
|
|
self.0.add_seals(seals)
|
|
}
|
|
}
|
|
|
|
impl AsRawDescriptor for SharedMemory {
|
|
fn as_raw_descriptor(&self) -> RawDescriptor {
|
|
self.0.as_raw_fd()
|
|
}
|
|
}
|
|
|
|
impl IntoRawDescriptor for SharedMemory {
|
|
fn into_raw_descriptor(self) -> RawDescriptor {
|
|
self.0.into_raw_fd()
|
|
}
|
|
}
|
|
|
|
impl From<SharedMemory> for SafeDescriptor {
|
|
fn from(sm: SharedMemory) -> SafeDescriptor {
|
|
// Safe because we own the SharedMemory at this point.
|
|
unsafe { SafeDescriptor::from_raw_descriptor(sm.into_raw_descriptor()) }
|
|
}
|
|
}
|
|
|
|
impl audio_streams::shm_streams::SharedMemory for SharedMemory {
|
|
type Error = Error;
|
|
|
|
fn anon(size: u64) -> Result<Self> {
|
|
SharedMemory::anon(size)
|
|
}
|
|
|
|
fn size(&self) -> u64 {
|
|
self.size()
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn as_raw_fd(&self) -> RawFd {
|
|
self.as_raw_descriptor()
|
|
}
|
|
}
|