A file only backed by memory, not by an actual file system. More...

#include <MemFile.hxx>

Inheritance diagram for cosmos::MemFile:

Public Types
enum class	OpenFlag : unsigned int { CLOEXEC = MFD_CLOEXEC , ALLOW_SEALING = MFD_ALLOW_SEALING , HUGETLB = MFD_HUGETLB }
	Available open settings for the MemFile type. More...

enum class	HugePageSize : unsigned int { DEFAULT = 0 , HUGE_2MB = 21 , HUGE_8MB = 23 , HUGE_16MB = 24 , HUGE_32MB = 25 , HUGE_256MB = 28 , HUGE_512MB = 29 , HUGE_1GB = 30 , HUGE_2GB = 31 , HUGE_16GB = 34 }
	PageSize specification if OpenFlag::HUGETLB is set. More...

using	OpenFlags = BitMask<OpenFlag>
	Collection of flags used when creating the MemFile type.

Public Types inherited from cosmos::StreamIO
enum class	SeekType : int { SET = SEEK_SET , CUR = SEEK_CUR , END = SEEK_END , DATA = SEEK_DATA , HOLE = SEEK_HOLE }
	Different methods for changing the file read/write position. More...

Public Member Functions
	MemFile (const SysString name, const OpenFlags flags=OpenFlags{OpenFlag::CLOEXEC}, const HugePageSize tlb_ps=HugePageSize::DEFAULT)

void	create (const SysString name, const OpenFlags flags=OpenFlags{OpenFlag::CLOEXEC}, const HugePageSize tlb_ps=HugePageSize::DEFAULT)
	Create a new MemFile using the given settings.

Public Member Functions inherited from cosmos::FileBase
	FileBase (const FileBase &)=delete

FileBase &	operator= (const FileBase &)=delete

virtual void	close ()
	Close the current file object.

bool	isOpen () const
	Returns whether currently a FileDescriptor is opened.

FileDescriptor	fd () const
	Allows access to the underlying fd with const semantics.

void	truncate (const off_t length)

Public Member Functions inherited from cosmos::StreamIO
	StreamIO (FileDescriptor &fd)

	StreamIO (const StreamIO &)=delete

StreamIO &	operator= (const StreamIO &)=delete

StreamIO &	operator= (StreamIO &&) noexcept

size_t	read (void *buf, size_t length)
	Read up to `length` bytes from the file into `buf`.

size_t	write (const void *buf, size_t length)
	Write up to `length` bytes from `buf` into the underlying file.

size_t	write (const std::string_view data)
	string_view wrapper around write(const void*, size_t).

void	readAll (void *buf, size_t length)
	Read all `length` bytes from the underlying file.

void	readAll (std::string &s, size_t length)
	Like readAll(void*, size_t) using an STL string.

void	writeAll (const void *buf, size_t length)
	Write all `length` bytes into the underlying file.

void	writeAll (const std::string_view data)
	string_view wrapper around writeAll(const void*, size_t).

bool	read (ReadIOVector &iovec)
	Read data from file into a vector of data regions.

bool	write (WriteIOVector &iovec)
	Write data to file from a vector of data regions.

void	readAll (ReadIOVector &iovec)
	Read into all data regions specified in `iovec`.

void	writeAll (WriteIOVector &iovec)
	Write all data regions specified in `iovec`.

off_t	seek (const SeekType type, off_t off)
	Seek to the given offset based on the given offset `type`.

off_t	seekFromStart (off_t off)
	Seek to the given offset relative to the start of the file.

off_t	seekFromCurrent (off_t off)
	Seek to the given offset relative to the current file position.

off_t	seekFromEnd (off_t off)
	Seek to the given offset relative to the end of the file.

Additional Inherited Members
Protected Member Functions inherited from cosmos::FileBase
	FileBase (const FileDescriptor fd=FileDescriptor{})

	FileBase (FileBase &&other) noexcept

FileBase &	operator= (FileBase &&other) noexcept

Protected Attributes inherited from cosmos::FileBase
FileDescriptor	m_fd

Protected Attributes inherited from cosmos::StreamIO
FileDescriptor &	m_stream_fd

Detailed Description

A file only backed by memory, not by an actual file system.

This type can create memory backed files that are not visible in the file system. As a speciality this type of file allows adding seals via FileDescriptor::addSeals().

Files created by this type are always opened in OpenMode::READ_WRITE.

Definition at line 22 of file MemFile.hxx.

Member Typedef Documentation

◆ OpenFlags

using cosmos::MemFile::OpenFlags = BitMask<OpenFlag>

Collection of flags used when creating the MemFile type.

Definition at line 34 of file MemFile.hxx.

Member Enumeration Documentation

◆ HugePageSize

enum class cosmos::MemFile::HugePageSize : unsigned int

strong

PageSize specification if OpenFlag::HUGETLB is set.

Definition at line 37 of file MemFile.hxx.

                                : unsigned int {
                // the values are the log-2 bit positions of the corresponding page sizes
                DEFAULT       = 0,
                HUGE_2MB      = 21,
                HUGE_8MB      = 23,
                HUGE_16MB     = 24,
                HUGE_32MB     = 25,
                HUGE_256MB    = 28,
                HUGE_512MB    = 29,
                HUGE_1GB      = 30,
                HUGE_2GB      = 31,
                HUGE_16GB     = 34
        };

◆ OpenFlag

enum class cosmos::MemFile::OpenFlag : unsigned int

strong

Available open settings for the MemFile type.

Enumerator
CLOEXEC	Apply close-on-exec semantics.
ALLOW_SEALING	Allow MemFD file sealing operations.
HUGETLB	Create the file in the HugeTLB file system.

Definition at line 27 of file MemFile.hxx.

                            : unsigned int {
                CLOEXEC       = MFD_CLOEXEC,       
                ALLOW_SEALING = MFD_ALLOW_SEALING, 
                HUGETLB       = MFD_HUGETLB        
        };

Constructor & Destructor Documentation

◆ MemFile()

cosmos::MemFile::MemFile	(	const SysString	name,
		const OpenFlags	flags = OpenFlags{OpenFlag::CLOEXEC},
		const HugePageSize	tlb_ps = HugePageSize::DEFAULT )

inlineexplicit

See also: create().

Definition at line 56 of file MemFile.hxx.

                                                         {OpenFlag::CLOEXEC},
                        const HugePageSize tlb_ps = HugePageSize::DEFAULT) {
                create(name, flags, tlb_ps);
        }

Member Function Documentation

◆ create()

void cosmos::MemFile::create	(	const SysString	name,
		const OpenFlags	flags = OpenFlags{OpenFlag::CLOEXEC},
		const HugePageSize	tlb_ps = HugePageSize::DEFAULT )

Create a new MemFile using the given settings.

Create a new memory file using the given flags and optional page size. The name is only for debugging purposes and is used as an identifier in the /proc file system.

Definition at line 10 of file MemFile.cxx.

                                                                                           {
 
        close();
 
        // see `man mmap` for an explanation about this.
        const auto page_size = to_integral(tlb_ps) << MAP_HUGE_SHIFT;
        auto fd = ::memfd_create(name.raw(), flags.raw() | page_size);
 
        if (fd == -1) {
                cosmos_throw (ApiError("memfd_create()"));
        }
 
        m_fd.setFD(FileNum{fd});
}

The documentation for this class was generated from the following files:

include/io/MemFile.hxx
src/io/MemFile.cxx

Public Types

Public Member Functions

Additional Inherited Members