os::posix::block_device_implementable< T > Class Template Reference

#include <block-device.h>

Inheritance diagram for os::posix::block_device_implementable< T >:

Public Types
using	blknum_t = std::size_t
using	value_type = T
Types & Constants
enum class	type : type_t {   unknown = 0 ,   not_set = 1 << 0 ,   char_device = 1 << 1 ,   block_device = 1 << 2 ,   tty = 1 << 3 ,   file = 1 << 4 ,   socket = 1 << 5 }
using	type_t = unsigned int

Public Member Functions
Constructors & Destructor
template<typename... Args>
	block_device_implementable (const char *name, Args &&... args)
virtual	~block_device_implementable () override
Public Member Functions
value_type &	impl (void) const
Public Member Functions
virtual int	vioctl (int request, std::va_list args) override
virtual ssize_t	read_block (void *buf, blknum_t blknum, std::size_t nblocks=1)
virtual ssize_t	write_block (const void *buf, blknum_t blknum, std::size_t nblocks=1)
blknum_t	blocks (void)
std::size_t	block_logical_size_bytes (void)
std::size_t	block_physical_size_bytes (void)
Public Member Functions
virtual ssize_t	read (void *buf, std::size_t nbyte)
virtual ssize_t	write (const void *buf, std::size_t nbyte)
virtual ssize_t	writev (const iovec *iov, int iovcnt)
int	fcntl (int cmd,...)
virtual int	vfcntl (int cmd, std::va_list args)
int	isatty (void)
virtual int	fstat (struct stat *buf)
virtual off_t	lseek (off_t offset, int whence)
type_t	get_type (void) const
file_descriptor_t	file_descriptor (void) const
bool	is_opened (void)

Protected Member Functions
Private Member Functions
void	file_descriptor (file_descriptor_t fildes)
void	clear_file_descriptor (void)
io *	alloc_file_descriptor (void)

Public Member Functions
int	open (const char *path=nullptr, int oflag=0,...)
int	vopen (const char *path, int oflag, std::va_list args)
virtual int	close (void) override
int	ioctl (int request,...)
virtual void	sync (void)
virtual bool	match_name (const char *name) const
const char *	name (void) const
static const char *	device_prefix (void)

Detailed Description

template<typename T>
class os::posix::block_device_implementable< T >

Definition at line 258 of file block-device.h.

Member Typedef Documentation

blknum_t

using os::posix::block_device::blknum_t = std::size_t

inherited

Definition at line 65 of file block-device.h.

type_t

using os::posix::io::type_t = unsigned int

inherited

Definition at line 125 of file io.h.

value_type

template<typename T >

using os::posix::block_device_implementable< T >::value_type = T

Definition at line 263 of file block-device.h.

Member Enumeration Documentation

type

enum class os::posix::io::type : type_t

stronginherited

Enumerator
unknown
not_set
char_device
block_device
tty
file
socket

Definition at line 126 of file io.h.

      {
        unknown = 0,
        not_set = 1 << 0,
        char_device = 1 << 1,
        block_device = 1 << 2,
        tty = 1 << 3,
        file = 1 << 4,
        socket = 1 << 5
      };

Constructor & Destructor Documentation

block_device_implementable()

template<typename T >

template<typename... Args>

os::posix::block_device_implementable< T >::block_device_implementable	(	const char *	name,
		Args &&...	args
	)

Definition at line 482 of file block-device.h.

        : block_device{ impl_instance_, name }, //
          impl_instance_{ std::forward<Args> (args)... }
    {
#if defined(OS_TRACE_POSIX_IO_BLOCK_DEVICE)
      trace::printf ("block_device_implementable::%s(\"%s\")=@%p\n", __func__,
                     name_, this);
#endif
    }

References os::trace::printf().

~block_device_implementable()

template<typename T >

os::posix::block_device_implementable< T >::~block_device_implementable

overridevirtual

Definition at line 499 of file block-device.h.

    {
#if defined(OS_TRACE_POSIX_IO_BLOCK_DEVICE)
      trace::printf ("block_device_implementable::%s() @%p %s\n", __func__,
                     this, name_);
#endif
    }

References os::trace::printf().

Member Function Documentation

alloc_file_descriptor()

io * os::posix::io::alloc_file_descriptor ( void  )

protectedinherited

Definition at line 189 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s() @%p\n", __func__, this);
#endif
 
      int fd = file_descriptors_manager::allocate (this);
      if (fd < 0)
        {
          // If allocation failed, close this object.
          impl ().do_close ();
          clear_file_descriptor ();
          return nullptr;
        }
 
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s() @%p fd=%d\n", __func__, this, fd);
#endif
 
      // Return a valid pointer to an object derived from `io`.
      return this;
    }

References os::posix::file_descriptors_manager::allocate(), os::posix::io::clear_file_descriptor(), os::posix::io_impl::do_close(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::socket::accept(), os::posix::socket(), os::posix::device::vopen(), and os::posix::file_system::vopen().

block_logical_size_bytes()

std::size_t os::posix::block_device::block_logical_size_bytes ( void  )

inlineinherited

Returns

The number of bytes in a block.

Definition at line 461 of file block-device.h.

    {
      return impl ().block_logical_size_bytes_;
    }

References os::posix::block_device::impl().

block_physical_size_bytes()

std::size_t os::posix::block_device::block_physical_size_bytes ( void  )

inlineinherited

Definition at line 467 of file block-device.h.

    {
      return impl ().block_physical_size_bytes_;
    }

References os::posix::block_device::impl().

blocks()

block_device::blknum_t os::posix::block_device::blocks ( void  )

inlineinherited

Returns

The number of blocks.

Definition at line 455 of file block-device.h.

    {
      return impl ().num_blocks_;
    }

References os::posix::block_device::impl().

clear_file_descriptor()

void os::posix::io::clear_file_descriptor ( void  )

inlineprotectedinherited

Definition at line 446 of file io.h.

    {
      file_descriptor_ = no_file_descriptor;
    }

References os::posix::no_file_descriptor.

Referenced by os::posix::io::alloc_file_descriptor().

close()

int os::posix::device::close ( void  )

overridevirtualinherited

Reimplemented from os::posix::io.

Reimplemented in os::posix::block_device_lockable< T, L >.

Definition at line 111 of file device.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_DEVICE)
      trace::printf ("device::%s() @%p\n", __func__, this);
#endif
 
      errno = 0;
 
      int ret = 0;
      if (impl ().open_count_ == 1)
        {
          ret = io::close ();
        }
 
      if (impl ().open_count_ > 0)
        {
          // Must be after close(), to keep do_is_open() true.
          --(impl ().open_count_);
        }
 
      return ret;
    }

References os::posix::io::close(), os::posix::device::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::close().

device_prefix()

const char * os::posix::device::device_prefix ( void  )

inlinestaticinherited

Definition at line 316 of file device.h.

    {
      return OS_STRING_POSIX_DEVICE_PREFIX;
    }

References OS_STRING_POSIX_DEVICE_PREFIX.

fcntl()

int os::posix::io::fcntl ( int  cmd,   ...  )

inherited

Definition at line 363 of file io.cpp.

    {
      // Forward to the variadic version of the function.
      std::va_list args;
      va_start (args, cmd);
      int ret = vfcntl (cmd, args);
      va_end (args);
 
      return ret;
    }

References os::posix::io::vfcntl().

file_descriptor() [1/2]

void os::posix::io::file_descriptor ( file_descriptor_t  fildes )

inlineprotectedinherited

Definition at line 440 of file io.h.

    {
      file_descriptor_ = fildes;
    }

file_descriptor() [2/2]

file_descriptor_t os::posix::io::file_descriptor ( void  ) const

inlineinherited

Definition at line 452 of file io.h.

    {
      return file_descriptor_;
    }

Referenced by os::posix::file_descriptors_manager::allocate(), os::posix::file_descriptors_manager::assign(), os::posix::device::vopen(), and os::posix::vopen().

fstat()

int os::posix::io::fstat ( struct stat *  buf )

virtualinherited

Reimplemented in os::posix::file_lockable< T, L >.

Definition at line 416 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(%p) @%p\n", __func__, buf, this);
#endif
 
      if (buf == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_fstat (buf);
    }

References os::posix::io_impl::do_fstat(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::file_lockable< T, L >::fstat().

get_type()

io::type_t os::posix::io::get_type ( void  ) const

inlineinherited

Definition at line 434 of file io.h.

    {
      return type_;
    }

Referenced by os::posix::file_descriptors_manager::socket().

impl()

template<typename T >

block_device_implementable< T >::value_type & os::posix::block_device_implementable< T >::impl

(

void

)

const

Definition at line 510 of file block-device.h.

    {
      return static_cast<value_type&> (impl_);
    }

ioctl()

int os::posix::device::ioctl ( int  request,   ...  )

inherited

Definition at line 135 of file device.cpp.

    {
      // Forward to the variadic version of the function.
      std::va_list args;
      va_start (args, request);
      int ret = vioctl (request, args);
      va_end (args);
 
      return ret;
    }

References os::posix::device::vioctl().

is_opened()

bool os::posix::io::is_opened ( void  )

inlineinherited

Definition at line 458 of file io.h.

    {
      return impl ().do_is_opened ();
    }

References os::posix::io_impl::do_is_opened(), and os::posix::io::impl().

isatty()

int os::posix::io::isatty ( void  )

inherited

Definition at line 406 of file io.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_isatty ();
    }

References os::posix::io_impl::do_isatty(), and os::posix::io::impl().

lseek()

off_t os::posix::io::lseek ( off_t  offset, int  whence  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 447 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(%d, %d) @%p\n", __func__, offset, whence, this);
#endif
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_lseek (offset, whence);
    }

References os::posix::io_impl::do_lseek(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::lseek(), and os::posix::file_lockable< T, L >::lseek().

match_name()

bool os::posix::device::match_name ( const char *  name ) const

virtualinherited

Definition at line 189 of file device.cpp.

    {
      assert (name != nullptr);
      assert (name_ != nullptr);
 
      return (std::strcmp (name, name_) == 0);
    }

References os::posix::device::name().

name()

const char * os::posix::device::name ( void  ) const

inlineinherited

Definition at line 304 of file device.h.

    {
      return name_;
    }

Referenced by os::posix::device_registry< T >::link(), and os::posix::device::match_name().

open()

int os::posix::device::open ( const char *  path = nullptr, int  oflag = 0,   ...  )

inherited

Parameters

path	May be nullptr.
oflag	Output flags

Returns

non-negative file descriptor, -1 on failure

Definition at line 62 of file device.cpp.

    {
      // Forward to the variadic version of the function.
      std::va_list args;
      va_start (args, oflag);
      int ret = vopen (path, oflag, args);
      va_end (args);
 
      return ret;
    }

References os::posix::device::vopen().

read()

ssize_t os::posix::io::read ( void *  buf, std::size_t  nbyte  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 217 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %u) @%p\n", __func__, buf, nbyte, this);
#endif
 
      if (buf == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // http://pubs.opengroup.org/onlinepubs/9699919799/functions/read.html
      // Before any action described below is taken, and if nbyte is zero,
      // the read() function may detect and return errors as described below.
      // In the absence of errors, or if error detection is not performed,
      // the read() function shall return zero and have no other results.
      if (nbyte == 0)
        {
          return 0; // Nothing to do.
        }
 
      // Execute the implementation specific code.
      ssize_t ret = impl ().do_read (buf, nbyte);
      if (ret >= 0)
        {
          impl ().offset_ += ret;
        }
 
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %u) @%p n=%d\n", __func__, buf, nbyte,
                     this, ret);
#endif
      return ret;
    }

References os::posix::io_impl::do_read(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::read(), and os::posix::file_lockable< T, L >::read().

read_block()

ssize_t os::posix::block_device::read_block ( void *  buf, blknum_t  blknum, std::size_t  nblocks = 1  )

virtualinherited

Reimplemented in os::posix::block_device_partition_lockable< T, L >, and os::posix::block_device_lockable< T, L >.

Definition at line 64 of file block-device.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_BLOCK_DEVICE)
      trace::printf ("block_device::%s(%p, %u, %u) @%p\n", __func__, buf,
                     blknum, nblocks, this);
#endif
 
      if (blknum + nblocks > impl ().num_blocks_)
        {
          errno = EINVAL;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      return impl ().do_read_block (buf, blknum, nblocks);
    }

References os::posix::block_device_impl::do_read_block(), os::posix::block_device::impl(), and os::trace::printf().

Referenced by os::posix::block_device_partition_lockable< T, L >::read_block(), and os::posix::block_device_lockable< T, L >::read_block().

sync()

void os::posix::device::sync ( void  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >.

Definition at line 171 of file device.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_DEVICE)
      trace::printf ("device::%s() @%p\n", __func__, this);
#endif
 
      if (impl ().open_count_ == 0)
        {
          errno = EBADF; // Not opened.
          return;
        }
 
      impl ().do_sync ();
    }

References os::posix::device_impl::do_sync(), os::posix::device::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::sync().

vfcntl()

int os::posix::io::vfcntl ( int  cmd, std::va_list  args  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 380 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(%d) @%p\n", __func__, cmd, this);
#endif
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_vfcntl (cmd, args);
    }

References os::posix::io_impl::do_vfcntl(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::io::fcntl(), os::posix::block_device_lockable< T, L >::vfcntl(), and os::posix::file_lockable< T, L >::vfcntl().

vioctl()

int os::posix::block_device::vioctl ( int  request, std::va_list  args  )

overridevirtualinherited

Reimplemented from os::posix::device.

Reimplemented in os::posix::block_device_partition_lockable< T, L >, and os::posix::block_device_lockable< T, L >.

Definition at line 111 of file block-device.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_BLOCK_DEVICE)
      trace::printf ("block_device::%s(%d) @%p\n", __func__, request, this);
#endif
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      switch (static_cast<unsigned int> (request))
        {
        case BLKSSZGET:
          // Get logical device sector size (to be used for read/writes).
          {
            std::size_t* sz = va_arg (args, std::size_t*);
            if (sz == nullptr || impl ().block_logical_size_bytes_ != 0)
              {
                errno = EINVAL;
                return -1;
              }
 
            *sz = impl ().block_logical_size_bytes_;
            return 0;
          }
 
        case BLKPBSZGET:
          // Get physical device sector size (internally used for erase).
          {
            std::size_t* sz = va_arg (args, std::size_t*);
            if (sz == nullptr || impl ().block_physical_size_bytes_ != 0)
              {
                errno = EINVAL;
                return -1;
              }
 
            *sz = impl ().block_physical_size_bytes_;
            return 0;
          }
 
        case BLKGETSIZE64:
          // Get device size in bytes.
          {
            uint64_t* sz = va_arg (args, uint64_t*);
            if (sz == nullptr || impl ().num_blocks_ != 0)
              {
                errno = EINVAL;
                return -1;
              }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
            *sz = (static_cast<uint64_t> (
                impl ().num_blocks_ * impl ().block_logical_size_bytes_));
#pragma GCC diagnostic pop
 
            return 0;
          }
 
        default:
 
          // Execute the implementation specific code.
          return impl ().do_vioctl (request, args);
        }
    }

References BLKGETSIZE64, BLKPBSZGET, BLKSSZGET, os::posix::device_impl::do_vioctl(), os::posix::block_device::impl(), and os::trace::printf().

Referenced by os::posix::block_device_partition_lockable< T, L >::vioctl(), and os::posix::block_device_lockable< T, L >::vioctl().

vopen()

int os::posix::device::vopen ( const char *  path, int  oflag, std::va_list  args  )

inherited

Parameters

path	May be nullptr.
oflag	Output flags
args	Arguments

Returns

non-negative file descriptor, -1 on failure

Definition at line 74 of file device.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_DEVICE)
      trace::printf ("device::%s(\"%s\") @%p\n", __func__, path ? path : "",
                     this);
#endif
 
      errno = 0;
 
      int ret = 0;
      if (impl ().open_count_ == 0)
        {
          // If so, use the implementation to open the device.
          ret = impl ().do_vopen (path, oflag, args);
          if (ret < 0)
            {
              // Open failed.
              return -1;
            }
 
          auto iop = alloc_file_descriptor ();
          if (iop == nullptr)
            {
              return -1;
            }
        }
      ++(impl ().open_count_);
      ret = file_descriptor ();
#if defined(OS_TRACE_POSIX_IO_DEVICE)
      trace::printf ("device::%s(\"%s\")=%p fd=%d\n", __func__,
                     path ? path : "", this, ret);
#endif
 
      return ret;
    }

References os::posix::io::alloc_file_descriptor(), os::posix::device_impl::do_vopen(), os::posix::io::file_descriptor(), os::posix::device::impl(), and os::trace::printf().

Referenced by os::posix::device::open().

write()

ssize_t os::posix::io::write ( const void *  buf, std::size_t  nbyte  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 268 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %u) @%p\n", __func__, buf, nbyte, this);
#endif
 
      if (buf == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // http://pubs.opengroup.org/onlinepubs/9699919799/functions/pwrite.html
      // Before any action described below is taken, and if nbyte is zero
      // and the file is a regular file, the write() function may detect and
      // return errors as described below. In the absence of errors, or if
      // error detection is not performed, the write() function shall return
      // zero and have no other results. If nbyte is zero and the file is
      // not a regular file, the results are unspecified.
      if (nbyte == 0)
        {
          return 0; // Nothing to do.
        }
 
      // Execute the implementation specific code.
      ssize_t ret = impl ().do_write (buf, nbyte);
      if (ret >= 0)
        {
          impl ().offset_ += ret;
        }
 
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %u) @%p n=%d\n", __func__, buf, nbyte,
                     this, ret);
#endif
      return ret;
    }

References os::posix::io_impl::do_write(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::write(), and os::posix::file_lockable< T, L >::write().

write_block()

ssize_t os::posix::block_device::write_block ( const void *  buf, blknum_t  blknum, std::size_t  nblocks = 1  )

virtualinherited

Reimplemented in os::posix::block_device_partition_lockable< T, L >, and os::posix::block_device_lockable< T, L >.

Definition at line 87 of file block-device.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_BLOCK_DEVICE)
      trace::printf ("block_device::%s(%p, %u, %u) @%p\n", __func__, buf,
                     blknum, nblocks, this);
#endif
 
      if (blknum + nblocks > impl ().num_blocks_)
        {
          errno = EINVAL;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      return impl ().do_write_block (buf, blknum, nblocks);
    }

References os::posix::block_device_impl::do_write_block(), os::posix::block_device::impl(), and os::trace::printf().

Referenced by os::posix::block_device_partition_lockable< T, L >::write_block(), and os::posix::block_device_lockable< T, L >::write_block().

writev()

ssize_t os::posix::io::writev ( const iovec *  iov, int  iovcnt  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 321 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %d) @%p\n", __func__, iov, iovcnt, this);
#endif
 
      if (iov == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (iovcnt <= 0)
        {
          errno = EINVAL;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      ssize_t ret = impl ().do_writev (iov, iovcnt);
      if (ret >= 0)
        {
          impl ().offset_ += ret;
        }
      return ret;
    }

References os::posix::io_impl::do_writev(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::writev(), and os::posix::file_lockable< T, L >::writev().

---

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

• block-device.h