vendor/tikv-jemalloc-ctl/src/keys.rs - toolchain/rustc - Git at Google

 //! Key types to index the _MALLCTL NAMESPACE_.
 //!
 //! The [`Name`] and [`Mib`]/[`MibStr`] types are provided as safe indices into
 //! the _MALLCTL NAMESPACE_. These are constructed from null-terminated strings
 //! via the [`AsName`] trait. The [`Access`] trait provides provides safe access
 //! into the `_MALLCTL NAMESPACE_`.
 //!
 //! # Example
 //!
 //! ```
 //! #[global_allocator]
 //! static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 //!
 //! fn main() {
 //!     use tikv_jemalloc_ctl::{Access, AsName, Name, Mib};
 //!     use libc::{c_uint, c_char};
 //!     let name = b"arenas.nbins\0".name();
 //!     let nbins: c_uint = name.read().unwrap();
 //!     let mut mib: Mib<[usize; 4]> = b"arenas.bin.0.size\0".name().mib().unwrap();
 //!     for i in 0..4 {
 //!         mib[2] = i;
 //!         let bin_size: usize = mib.read().unwrap();
 //!         println!("arena bin {} has size {}", i, bin_size);
 //!     }
 //! }
 //! ```

 #![allow(clippy::uninlined_format_args)]

 use crate::error::Result;
 use crate::std::str;
 use crate::{fmt, ops, raw};

 /// A `Name` in the _MALLCTL NAMESPACE_.
 #[repr(transparent)]
 #[derive(PartialEq, Eq)]
 pub struct Name([u8]);

 /// Converts a null-terminated byte-string into a [`Name`].
 pub trait AsName {
     /// Converts a null-terminated byte-string into a [`Name`].
     fn name(&self) -> &Name;
 }

 impl AsName for [u8] {
     fn name(&self) -> &Name {
         assert!(
             !self.is_empty(),
             "cannot create Name from empty byte-string"
         );
         assert_eq!(
             *self.last().unwrap(),
             b'\0',
             "cannot create Name from non-null-terminated byte-string \"{}\"",
             str::from_utf8(self).unwrap()
         );
         unsafe { &*(self as *const Self as *const Name) }
     }
 }

 impl AsName for str {
     fn name(&self) -> &Name {
         self.as_bytes().name()
     }
 }

 impl Name {
     /// Returns the [`Mib`] of `self`.
     pub fn mib<T: MibArg>(&self) -> Result<Mib<T>> {
         let mut mib: Mib<T> = Mib::default();
         raw::name_to_mib(&self.0, mib.0.as_mut())?;
         Ok(mib)
     }

     /// Returns the [`MibStr`] of `self` which is a key whose value is a string.
     pub fn mib_str<T: MibArg>(&self) -> Result<MibStr<T>> {
         assert!(
             self.value_type_str(),
             "key \"{}\" does not refer to a string",
             self
         );
         let mut mib: MibStr<T> = MibStr::default();
         raw::name_to_mib(&self.0, mib.0.as_mut())?;
         Ok(mib)
     }

     /// Returns `true` if `self` is a key in the _MALLCTL NAMESPCE_ referring to
     /// a null-terminated string.
     pub fn value_type_str(&self) -> bool {
         // remove the null-terminator:
         let name = self.0.split_at(self.0.len() - 1).0;
         if name.is_empty() {
             return false;
         }
         debug_assert_ne!(*name.last().unwrap(), b'\0');

         match name {
             b"version"
             | b"config.malloc_conf"
             | b"opt.metadata_thp"
             | b"opt.dss"
             | b"opt.percpu_arena"
             | b"opt.stats_print_opts"
             | b"opt.junk"
             | b"opt.thp"
             | b"opt.prof_prefix"
             | b"thread.prof.name"
             | b"prof.dump" => true,
             v if v.starts_with(b"arena.") && v.ends_with(b".dss") => true,
             v if v.starts_with(b"stats.arenas.") && v.ends_with(b".dss") => {
                 true
             }
             _ => false,
         }
     }

     /// Returns the name as null-terminated byte-string.
     pub fn as_bytes(&self) -> &'static [u8] {
         unsafe { &*(self as *const Self as *const [u8]) }
     }
 }

 impl fmt::Debug for Name {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", str::from_utf8(&self.0).unwrap())
     }
 }

 impl fmt::Display for Name {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", str::from_utf8(&self.0).unwrap())
     }
 }

 /// Management Information Base of a non-string value.
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
 pub struct Mib<T: MibArg>(T);

 /// Management Information Base of a string value.
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
 pub struct MibStr<T: MibArg>(T);

 impl<T: MibArg> AsRef<[usize]> for Mib<T> {
     fn as_ref(&self) -> &[usize] {
         self.0.as_ref()
     }
 }

 impl<T: MibArg> AsMut<[usize]> for Mib<T> {
     fn as_mut(&mut self) -> &mut [usize] {
         self.0.as_mut()
     }
 }

 impl<T: MibArg> ops::Index<usize> for Mib<T> {
     type Output = usize;
     fn index(&self, idx: usize) -> &Self::Output {
         &self.0.as_ref()[idx]
     }
 }

 impl<T: MibArg> ops::IndexMut<usize> for Mib<T> {
     fn index_mut(&mut self, idx: usize) -> &mut Self::Output {
         &mut self.0.as_mut()[idx]
     }
 }

 impl<T: MibArg> ops::Index<usize> for MibStr<T> {
     type Output = usize;
     fn index(&self, idx: usize) -> &Self::Output {
         &self.0.as_ref()[idx]
     }
 }

 impl<T: MibArg> ops::IndexMut<usize> for MibStr<T> {
     fn index_mut(&mut self, idx: usize) -> &mut Self::Output {
         &mut self.0.as_mut()[idx]
     }
 }

 /// Safe read access to the _MALLCTL NAMESPACE_.
 pub trait Access<T> {
     /// Read the key at `self`.
     fn read(&self) -> Result<T>;
     /// Write `value` at the key `self`.
     fn write(&self, value: T) -> Result<()>;
     /// Write `value` at the key `self` returning its previous value.
     fn update(&self, value: T) -> Result<T>;
 }

 macro_rules! impl_access {
     ($id:ty) => {
         impl<T: MibArg> Access<$id> for Mib<T> {
             fn read(&self) -> Result<$id> {
                 unsafe { raw::read_mib(self.0.as_ref()) }
             }
             fn write(&self, value: $id) -> Result<()> {
                 unsafe { raw::write_mib(self.0.as_ref(), value) }
             }
             fn update(&self, value: $id) -> Result<$id> {
                 unsafe { raw::update_mib(self.0.as_ref(), value) }
             }
         }
         impl Access<$id> for Name {
             fn read(&self) -> Result<$id> {
                 unsafe { raw::read(&self.0) }
             }
             fn write(&self, value: $id) -> Result<()> {
                 unsafe { raw::write(&self.0, value) }
             }
             fn update(&self, value: $id) -> Result<$id> {
                 unsafe { raw::update(&self.0, value) }
             }
         }
     };
 }

 impl_access!(u32);
 impl_access!(u64);
 impl_access!(isize);
 impl_access!(usize);

 impl<T: MibArg> Access<bool> for Mib<T> {
     fn read(&self) -> Result<bool> {
         unsafe {
             let v: u8 = raw::read_mib(self.0.as_ref())?;
             assert!(v == 0 || v == 1);
             Ok(v == 1)
         }
     }
     fn write(&self, value: bool) -> Result<()> {
         unsafe { raw::write_mib(self.0.as_ref(), value) }
     }
     fn update(&self, value: bool) -> Result<bool> {
         unsafe {
             let v: u8 = raw::update_mib(self.0.as_ref(), value as u8)?;
             Ok(v == 1)
         }
     }
 }

 impl Access<bool> for Name {
     fn read(&self) -> Result<bool> {
         unsafe {
             let v: u8 = raw::read(&self.0)?;
             assert!(v == 0 || v == 1);
             Ok(v == 1)
         }
     }
     fn write(&self, value: bool) -> Result<()> {
         unsafe { raw::write(&self.0, value) }
     }
     fn update(&self, value: bool) -> Result<bool> {
         unsafe {
             let v: u8 = raw::update(&self.0, value as u8)?;
             Ok(v == 1)
         }
     }
 }

 impl<T: MibArg> Access<&'static [u8]> for MibStr<T> {
     fn read(&self) -> Result<&'static [u8]> {
         // this is safe because the only safe way to construct a `MibStr` is by
         // validating that the key refers to a byte-string value
         unsafe { raw::read_str_mib(self.0.as_ref()) }
     }
     fn write(&self, value: &'static [u8]) -> Result<()> {
         raw::write_str_mib(self.0.as_ref(), value)
     }
     fn update(&self, value: &'static [u8]) -> Result<&'static [u8]> {
         // this is safe because the only safe way to construct a `MibStr` is by
         // validating that the key refers to a byte-string value
         unsafe { raw::update_str_mib(self.0.as_ref(), value) }
     }
 }

 impl Access<&'static [u8]> for Name {
     fn read(&self) -> Result<&'static [u8]> {
         assert!(
             self.value_type_str(),
             "the name \"{:?}\" does not refer to a byte string",
             self
         );
         // this is safe because the key refers to a byte string:
         unsafe { raw::read_str(&self.0) }
     }
     fn write(&self, value: &'static [u8]) -> Result<()> {
         assert!(
             self.value_type_str(),
             "the name \"{:?}\" does not refer to a byte string",
             self
         );
         raw::write_str(&self.0, value)
     }
     fn update(&self, value: &'static [u8]) -> Result<&'static [u8]> {
         assert!(
             self.value_type_str(),
             "the name \"{:?}\" does not refer to a byte string",
             self
         );
         // this is safe because the key refers to a byte string:
         unsafe { raw::update_str(&self.0, value) }
     }
 }

 impl<T: MibArg> Access<&'static str> for MibStr<T> {
     fn read(&self) -> Result<&'static str> {
         // this is safe because the only safe way to construct a `MibStr` is by
         // validating that the key refers to a byte-string value
         let s = unsafe { raw::read_str_mib(self.0.as_ref())? };
         Ok(str::from_utf8(s).unwrap())
     }
     fn write(&self, value: &'static str) -> Result<()> {
         raw::write_str_mib(self.0.as_ref(), value.as_bytes())
     }
     fn update(&self, value: &'static str) -> Result<&'static str> {
         // this is safe because the only safe way to construct a `MibStr` is by
         // validating that the key refers to a byte-string value
         let s =
             unsafe { raw::update_str_mib(self.0.as_ref(), value.as_bytes())? };
         Ok(str::from_utf8(s).unwrap())
     }
 }

 impl Access<&'static str> for Name {
     fn read(&self) -> Result<&'static str> {
         assert!(
             self.value_type_str(),
             "the name \"{:?}\" does not refer to a byte string",
             self
         );
         // this is safe because the key refers to a byte string:
         let s = unsafe { raw::read_str(&self.0)? };
         Ok(str::from_utf8(s).unwrap())
     }
     fn write(&self, value: &'static str) -> Result<()> {
         assert!(
             self.value_type_str(),
             "the name \"{:?}\" does not refer to a byte string",
             self
         );
         raw::write_str(&self.0, value.as_bytes())
     }
     fn update(&self, value: &'static str) -> Result<&'static str> {
         assert!(
             self.value_type_str(),
             "the name \"{:?}\" does not refer to a byte string",
             self
         );
         // this is safe because the key refers to a byte string:
         let s = unsafe { raw::update_str(&self.0, value.as_bytes())? };
         Ok(str::from_utf8(s).unwrap())
     }
 }

 #[cfg(test)]
 mod tests {
     use super::{Access, AsName, Mib, MibStr};
     #[test]
     fn bool_rw() {
         let name = b"thread.tcache.enabled\0".name();
         let tcache: bool = name.read().unwrap();

         let new_tcache = !tcache;

         name.write(new_tcache).unwrap();

         let mib: Mib<[usize; 3]> = name.mib().unwrap();
         let r: bool = mib.read().unwrap();
         assert_eq!(r, new_tcache);
     }

     #[test]
     fn u32_r() {
         let name = b"arenas.bin.0.nregs\0".name();
         let v: u32 = name.read().unwrap();

         let mib: Mib<[usize; 4]> = name.mib().unwrap();
         let r: u32 = mib.read().unwrap();
         assert_eq!(r, v);
     }

     #[test]
     fn size_t_r() {
         let name = b"arenas.lextent.0.size\0".name();
         let v: libc::size_t = name.read().unwrap();

         let mib: Mib<[usize; 4]> = name.mib().unwrap();
         let r: libc::size_t = mib.read().unwrap();
         assert_eq!(r, v);
     }

     #[test]
     fn ssize_t_rw() {
         let name = b"arenas.dirty_decay_ms\0".name();
         let v: libc::ssize_t = name.read().unwrap();
         name.write(v).unwrap();

         let mib: Mib<[usize; 2]> = name.mib().unwrap();
         let r: libc::ssize_t = mib.read().unwrap();
         assert_eq!(r, v);
     }

     #[test]
     fn u64_rw() {
         let name = b"epoch\0".name();
         let epoch: u64 = name.read().unwrap();
         name.write(epoch).unwrap();

         let mib: Mib<[usize; 1]> = name.mib().unwrap();
         let epoch: u64 = mib.read().unwrap();
         mib.write(epoch).unwrap();
     }

     #[test]
     fn str_rw() {
         let name = b"arena.0.dss\0".name();
         let dss: &'static [u8] = name.read().unwrap();
         name.write(dss).unwrap();

         let mib: MibStr<[usize; 3]> = name.mib_str().unwrap();
         let dss2: &'static [u8] = mib.read().unwrap();
         mib.write(dss2).unwrap();

         assert_eq!(dss, dss2);
     }
 }

 pub trait MibArg:
     Copy
     + Clone
     + PartialEq
     + Default
     + fmt::Debug
     + AsRef<[usize]>
     + AsMut<[usize]>
 {
 }
 impl<T> MibArg for T where
     T: Copy
         + Clone
         + PartialEq
         + Default
         + fmt::Debug
         + AsRef<[usize]>
         + AsMut<[usize]>
 {
 }
	//! Key types to index the _MALLCTL NAMESPACE_.
	//!
	//! The [`Name`] and [`Mib`]/[`MibStr`] types are provided as safe indices into
	//! the _MALLCTL NAMESPACE_. These are constructed from null-terminated strings
	//! via the [`AsName`] trait. The [`Access`] trait provides provides safe access
	//! into the `_MALLCTL NAMESPACE_`.
	//!
	//! # Example
	//!
	//! ```
	//! #[global_allocator]
	//! static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
	//!
	//! fn main() {
	//! use tikv_jemalloc_ctl::{Access, AsName, Name, Mib};
	//! use libc::{c_uint, c_char};
	//! let name = b"arenas.nbins\0".name();
	//! let nbins: c_uint = name.read().unwrap();
	//! let mut mib: Mib<[usize; 4]> = b"arenas.bin.0.size\0".name().mib().unwrap();
	//! for i in 0..4 {
	//! mib[2] = i;
	//! let bin_size: usize = mib.read().unwrap();
	//! println!("arena bin {} has size {}", i, bin_size);
	//! }
	//! }
	//! ```

	#![allow(clippy::uninlined_format_args)]

	use crate::error::Result;
	use crate::std::str;
	use crate::{fmt, ops, raw};

	/// A `Name` in the _MALLCTL NAMESPACE_.
	#[repr(transparent)]
	#[derive(PartialEq, Eq)]
	pub struct Name([u8]);

	/// Converts a null-terminated byte-string into a [`Name`].
	pub trait AsName {
	/// Converts a null-terminated byte-string into a [`Name`].
	fn name(&self) -> &Name;
	}

	impl AsName for [u8] {
	fn name(&self) -> &Name {
	assert!(
	!self.is_empty(),
	"cannot create Name from empty byte-string"
	);
	assert_eq!(
	*self.last().unwrap(),
	b'\0',
	"cannot create Name from non-null-terminated byte-string \"{}\"",
	str::from_utf8(self).unwrap()
	);
	unsafe { &(self as const Self as *const Name) }
	}
	}

	impl AsName for str {
	fn name(&self) -> &Name {
	self.as_bytes().name()
	}
	}

	impl Name {
	/// Returns the [`Mib`] of `self`.
	pub fn mib<T: MibArg>(&self) -> Result<Mib<T>> {
	let mut mib: Mib<T> = Mib::default();
	raw::name_to_mib(&self.0, mib.0.as_mut())?;
	Ok(mib)
	}

	/// Returns the [`MibStr`] of `self` which is a key whose value is a string.
	pub fn mib_str<T: MibArg>(&self) -> Result<MibStr<T>> {
	assert!(
	self.value_type_str(),
	"key \"{}\" does not refer to a string",
	self
	);
	let mut mib: MibStr<T> = MibStr::default();
	raw::name_to_mib(&self.0, mib.0.as_mut())?;
	Ok(mib)
	}

	/// Returns `true` if `self` is a key in the _MALLCTL NAMESPCE_ referring to
	/// a null-terminated string.
	pub fn value_type_str(&self) -> bool {
	// remove the null-terminator:
	let name = self.0.split_at(self.0.len() - 1).0;
	if name.is_empty() {
	return false;
	}
	debug_assert_ne!(*name.last().unwrap(), b'\0');

	match name {
	b"version"
	\| b"config.malloc_conf"
	\| b"opt.metadata_thp"
	\| b"opt.dss"
	\| b"opt.percpu_arena"
	\| b"opt.stats_print_opts"
	\| b"opt.junk"
	\| b"opt.thp"
	\| b"opt.prof_prefix"
	\| b"thread.prof.name"
	\| b"prof.dump" => true,
	v if v.starts_with(b"arena.") && v.ends_with(b".dss") => true,
	v if v.starts_with(b"stats.arenas.") && v.ends_with(b".dss") => {
	true
	}
	_ => false,
	}
	}

	/// Returns the name as null-terminated byte-string.
	pub fn as_bytes(&self) -> &'static [u8] {
	unsafe { &(self as const Self as *const [u8]) }
	}
	}

	impl fmt::Debug for Name {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "{}", str::from_utf8(&self.0).unwrap())
	}
	}

	impl fmt::Display for Name {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "{}", str::from_utf8(&self.0).unwrap())
	}
	}

	/// Management Information Base of a non-string value.
	#[repr(transparent)]
	#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
	pub struct Mib<T: MibArg>(T);

	/// Management Information Base of a string value.
	#[repr(transparent)]
	#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
	pub struct MibStr<T: MibArg>(T);

	impl<T: MibArg> AsRef<[usize]> for Mib<T> {
	fn as_ref(&self) -> &[usize] {
	self.0.as_ref()
	}
	}

	impl<T: MibArg> AsMut<[usize]> for Mib<T> {
	fn as_mut(&mut self) -> &mut [usize] {
	self.0.as_mut()
	}
	}

	impl<T: MibArg> ops::Index<usize> for Mib<T> {
	type Output = usize;
	fn index(&self, idx: usize) -> &Self::Output {
	&self.0.as_ref()[idx]
	}
	}

	impl<T: MibArg> ops::IndexMut<usize> for Mib<T> {
	fn index_mut(&mut self, idx: usize) -> &mut Self::Output {
	&mut self.0.as_mut()[idx]
	}
	}

	impl<T: MibArg> ops::Index<usize> for MibStr<T> {
	type Output = usize;
	fn index(&self, idx: usize) -> &Self::Output {
	&self.0.as_ref()[idx]
	}
	}

	impl<T: MibArg> ops::IndexMut<usize> for MibStr<T> {
	fn index_mut(&mut self, idx: usize) -> &mut Self::Output {
	&mut self.0.as_mut()[idx]
	}
	}

	/// Safe read access to the _MALLCTL NAMESPACE_.
	pub trait Access<T> {
	/// Read the key at `self`.
	fn read(&self) -> Result<T>;
	/// Write `value` at the key `self`.
	fn write(&self, value: T) -> Result<()>;
	/// Write `value` at the key `self` returning its previous value.
	fn update(&self, value: T) -> Result<T>;
	}

	macro_rules! impl_access {
	($id:ty) => {
	impl<T: MibArg> Access<$id> for Mib<T> {
	fn read(&self) -> Result<$id> {
	unsafe { raw::read_mib(self.0.as_ref()) }
	}
	fn write(&self, value: $id) -> Result<()> {
	unsafe { raw::write_mib(self.0.as_ref(), value) }
	}
	fn update(&self, value: $id) -> Result<$id> {
	unsafe { raw::update_mib(self.0.as_ref(), value) }
	}
	}
	impl Access<$id> for Name {
	fn read(&self) -> Result<$id> {
	unsafe { raw::read(&self.0) }
	}
	fn write(&self, value: $id) -> Result<()> {
	unsafe { raw::write(&self.0, value) }
	}
	fn update(&self, value: $id) -> Result<$id> {
	unsafe { raw::update(&self.0, value) }
	}
	}
	};
	}

	impl_access!(u32);
	impl_access!(u64);
	impl_access!(isize);
	impl_access!(usize);

	impl<T: MibArg> Access<bool> for Mib<T> {
	fn read(&self) -> Result<bool> {
	unsafe {
	let v: u8 = raw::read_mib(self.0.as_ref())?;
	assert!(v == 0 \|\| v == 1);
	Ok(v == 1)
	}
	}
	fn write(&self, value: bool) -> Result<()> {
	unsafe { raw::write_mib(self.0.as_ref(), value) }
	}
	fn update(&self, value: bool) -> Result<bool> {
	unsafe {
	let v: u8 = raw::update_mib(self.0.as_ref(), value as u8)?;
	Ok(v == 1)
	}
	}
	}

	impl Access<bool> for Name {
	fn read(&self) -> Result<bool> {
	unsafe {
	let v: u8 = raw::read(&self.0)?;
	assert!(v == 0 \|\| v == 1);
	Ok(v == 1)
	}
	}
	fn write(&self, value: bool) -> Result<()> {
	unsafe { raw::write(&self.0, value) }
	}
	fn update(&self, value: bool) -> Result<bool> {
	unsafe {
	let v: u8 = raw::update(&self.0, value as u8)?;
	Ok(v == 1)
	}
	}
	}

	impl<T: MibArg> Access<&'static [u8]> for MibStr<T> {
	fn read(&self) -> Result<&'static [u8]> {
	// this is safe because the only safe way to construct a `MibStr` is by
	// validating that the key refers to a byte-string value
	unsafe { raw::read_str_mib(self.0.as_ref()) }
	}
	fn write(&self, value: &'static [u8]) -> Result<()> {
	raw::write_str_mib(self.0.as_ref(), value)
	}
	fn update(&self, value: &'static [u8]) -> Result<&'static [u8]> {
	// this is safe because the only safe way to construct a `MibStr` is by
	// validating that the key refers to a byte-string value
	unsafe { raw::update_str_mib(self.0.as_ref(), value) }
	}
	}

	impl Access<&'static [u8]> for Name {
	fn read(&self) -> Result<&'static [u8]> {
	assert!(
	self.value_type_str(),
	"the name \"{:?}\" does not refer to a byte string",
	self
	);
	// this is safe because the key refers to a byte string:
	unsafe { raw::read_str(&self.0) }
	}
	fn write(&self, value: &'static [u8]) -> Result<()> {
	assert!(
	self.value_type_str(),
	"the name \"{:?}\" does not refer to a byte string",
	self
	);
	raw::write_str(&self.0, value)
	}
	fn update(&self, value: &'static [u8]) -> Result<&'static [u8]> {
	assert!(
	self.value_type_str(),
	"the name \"{:?}\" does not refer to a byte string",
	self
	);
	// this is safe because the key refers to a byte string:
	unsafe { raw::update_str(&self.0, value) }
	}
	}

	impl<T: MibArg> Access<&'static str> for MibStr<T> {
	fn read(&self) -> Result<&'static str> {
	// this is safe because the only safe way to construct a `MibStr` is by
	// validating that the key refers to a byte-string value
	let s = unsafe { raw::read_str_mib(self.0.as_ref())? };
	Ok(str::from_utf8(s).unwrap())
	}
	fn write(&self, value: &'static str) -> Result<()> {
	raw::write_str_mib(self.0.as_ref(), value.as_bytes())
	}
	fn update(&self, value: &'static str) -> Result<&'static str> {
	// this is safe because the only safe way to construct a `MibStr` is by
	// validating that the key refers to a byte-string value
	let s =
	unsafe { raw::update_str_mib(self.0.as_ref(), value.as_bytes())? };
	Ok(str::from_utf8(s).unwrap())
	}
	}

	impl Access<&'static str> for Name {
	fn read(&self) -> Result<&'static str> {
	assert!(
	self.value_type_str(),
	"the name \"{:?}\" does not refer to a byte string",
	self
	);
	// this is safe because the key refers to a byte string:
	let s = unsafe { raw::read_str(&self.0)? };
	Ok(str::from_utf8(s).unwrap())
	}
	fn write(&self, value: &'static str) -> Result<()> {
	assert!(
	self.value_type_str(),
	"the name \"{:?}\" does not refer to a byte string",
	self
	);
	raw::write_str(&self.0, value.as_bytes())
	}
	fn update(&self, value: &'static str) -> Result<&'static str> {
	assert!(
	self.value_type_str(),
	"the name \"{:?}\" does not refer to a byte string",
	self
	);
	// this is safe because the key refers to a byte string:
	let s = unsafe { raw::update_str(&self.0, value.as_bytes())? };
	Ok(str::from_utf8(s).unwrap())
	}
	}

	#[cfg(test)]
	mod tests {
	use super::{Access, AsName, Mib, MibStr};
	#[test]
	fn bool_rw() {
	let name = b"thread.tcache.enabled\0".name();
	let tcache: bool = name.read().unwrap();

	let new_tcache = !tcache;

	name.write(new_tcache).unwrap();

	let mib: Mib<[usize; 3]> = name.mib().unwrap();
	let r: bool = mib.read().unwrap();
	assert_eq!(r, new_tcache);
	}

	#[test]
	fn u32_r() {
	let name = b"arenas.bin.0.nregs\0".name();
	let v: u32 = name.read().unwrap();

	let mib: Mib<[usize; 4]> = name.mib().unwrap();
	let r: u32 = mib.read().unwrap();
	assert_eq!(r, v);
	}

	#[test]
	fn size_t_r() {
	let name = b"arenas.lextent.0.size\0".name();
	let v: libc::size_t = name.read().unwrap();

	let mib: Mib<[usize; 4]> = name.mib().unwrap();
	let r: libc::size_t = mib.read().unwrap();
	assert_eq!(r, v);
	}

	#[test]
	fn ssize_t_rw() {
	let name = b"arenas.dirty_decay_ms\0".name();
	let v: libc::ssize_t = name.read().unwrap();
	name.write(v).unwrap();

	let mib: Mib<[usize; 2]> = name.mib().unwrap();
	let r: libc::ssize_t = mib.read().unwrap();
	assert_eq!(r, v);
	}

	#[test]
	fn u64_rw() {
	let name = b"epoch\0".name();
	let epoch: u64 = name.read().unwrap();
	name.write(epoch).unwrap();

	let mib: Mib<[usize; 1]> = name.mib().unwrap();
	let epoch: u64 = mib.read().unwrap();
	mib.write(epoch).unwrap();
	}

	#[test]
	fn str_rw() {
	let name = b"arena.0.dss\0".name();
	let dss: &'static [u8] = name.read().unwrap();
	name.write(dss).unwrap();

	let mib: MibStr<[usize; 3]> = name.mib_str().unwrap();
	let dss2: &'static [u8] = mib.read().unwrap();
	mib.write(dss2).unwrap();

	assert_eq!(dss, dss2);
	}
	}

	pub trait MibArg:
	Copy
	+ Clone
	+ PartialEq
	+ Default
	+ fmt::Debug
	+ AsRef<[usize]>
	+ AsMut<[usize]>
	{
	}
	impl<T> MibArg for T where
	T: Copy
	+ Clone
	+ PartialEq
	+ Default
	+ fmt::Debug
	+ AsRef<[usize]>
	+ AsMut<[usize]>
	{
	}