os::posix::file_system_lockable< T, L > Class Template Reference

#include <file-system.h>

Inheritance diagram for os::posix::file_system_lockable< T, L >:

Public Types
using	lockable_type = L
using	value_type = T

Public Member Functions
Constructors & Destructor
template<typename... Args>
	file_system_lockable (const char *name, block_device &device, lockable_type &locker, Args &&... args)
virtual	~file_system_lockable () override
Public Member Functions
virtual int	vmount (const char *path, unsigned int flags, std::va_list args) override
	Mount file system.
virtual int	umount (int unsigned flags=0) override
	Unmount file system.
virtual file *	vopen (const char *path, int oflag, std::va_list args) override
virtual directory *	opendir (const char *dirpath) override
virtual int	mkdir (const char *path, mode_t mode) override
virtual int	rmdir (const char *path) override
virtual void	sync (void) override
virtual int	chmod (const char *path, mode_t mode) override
virtual int	stat (const char *path, struct stat *buf) override
virtual int	truncate (const char *path, off_t length) override
virtual int	rename (const char *existing, const char *_new) override
virtual int	unlink (const char *path) override
virtual int	utime (const char *path, const utimbuf *times) override
virtual int	statvfs (struct statvfs *buf) override
value_type &	impl (void) const

Public Member Functions
using	deferred_files_list_t = utils::intrusive_list< file, utils::double_list_links, &file::deferred_links_ >
using	deferred_directories_list_t = utils::intrusive_list< directory, utils::double_list_links, &directory::deferred_links_ >
int	mkfs (int options,...)
virtual int	vmkfs (int options, std::va_list args)
int	mount (const char *path=nullptr, unsigned int flags=0,...)
file *	open (const char *path=nullptr, int oflag=0,...)
const char *	mounted_path (void)
const char *	name (void) const
void	add_deferred_file (file *fil)
void	add_deferred_directory (directory *dir)
deferred_files_list_t &	deferred_files_list (void)
deferred_directories_list_t &	deferred_directories_list (void)
template<typename T >
T *	allocate_file (void)
template<typename T , typename L >
T *	allocate_file (L &locker)
template<typename T >
T *	allocate_directory (void)
template<typename T , typename L >
T *	allocate_directory (L &locker)
template<typename T >
void	deallocate_files (void)
template<typename T >
void	deallocate_directories (void)
block_device &	device (void) const
static file_system *	identify_mounted (const char **path1, const char **path2=nullptr)

Detailed Description

template<typename T, typename L>
class os::posix::file_system_lockable< T, L >

Definition at line 640 of file file-system.h.

Member Typedef Documentation

deferred_directories_list_t

using os::posix::file_system::deferred_directories_list_t = utils::intrusive_list<directory, utils::double_list_links, &directory::deferred_links_>

inherited

Definition at line 312 of file file-system.h.

deferred_files_list_t

using os::posix::file_system::deferred_files_list_t = utils::intrusive_list<file, utils::double_list_links, &file::deferred_links_>

inherited

Definition at line 308 of file file-system.h.

lockable_type

template<typename T , typename L >

using os::posix::file_system_lockable< T, L >::lockable_type = L

Definition at line 646 of file file-system.h.

value_type

template<typename T , typename L >

using os::posix::file_system_lockable< T, L >::value_type = T

Definition at line 645 of file file-system.h.

Constructor & Destructor Documentation

file_system_lockable()

template<typename T , typename L >

template<typename... Args>

os::posix::file_system_lockable< T, L >::file_system_lockable	(	const char *	name,
		block_device &	device,
		lockable_type &	locker,
		Args &&...	args
	)

Definition at line 1038 of file file-system.h.

        : file_system{ impl_instance_, name }, //
          impl_instance_{ device, locker, std::forward<Args> (args)... }
    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system_lockable::%s()=%p\n", __func__, this);
#endif
    }

References os::trace::printf().

~file_system_lockable()

template<typename T , typename L >

os::posix::file_system_lockable< T, L >::~file_system_lockable

overridevirtual

Definition at line 1056 of file file-system.h.

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

References os::trace::printf().

Member Function Documentation

add_deferred_directory()

void os::posix::file_system::add_deferred_directory ( directory *  dir )

inlineinherited

Definition at line 828 of file file-system.h.

    {
      deferred_directories_list_.link (*dir);
    }

Referenced by os::posix::directory::close().

add_deferred_file()

void os::posix::file_system::add_deferred_file ( file *  fil )

inlineinherited

Definition at line 822 of file file-system.h.

    {
      deferred_files_list_.link (*fil);
    }

Referenced by os::posix::file::close().

allocate_directory() [1/2]

template<typename T , typename L >

T * os::posix::file_system::allocate_directory ( L &  locker )

inherited

Definition at line 946 of file file-system.h.

    {
      using directory_type = T;
 
      directory_type* dir;
 
      if (deferred_directories_list_.empty ())
        {
          dir = new directory_type (*this, locker);
        }
      else
        {
          dir = static_cast<directory_type*> (
              deferred_directories_list_.unlink_head ());
 
          // Call the constructor before reusing the object,
          dir->~directory_type ();
 
          // Placement new, run only the constructor.
          new (dir) directory_type (*this, locker);
 
          deallocate_directories<directory_type> ();
        }
      return dir;
    }

allocate_directory() [2/2]

template<typename T >

T * os::posix::file_system::allocate_directory ( void  )

inherited

Definition at line 918 of file file-system.h.

    {
      using directory_type = T;
 
      directory_type* dir;
 
      if (deferred_directories_list_.empty ())
        {
          dir = new directory_type (*this);
        }
      else
        {
          dir = static_cast<directory_type*> (
              deferred_directories_list_.unlink_head ());
 
          // Call the constructor before reusing the object,
          dir->~directory_type ();
 
          // Placement new, run only the constructor.
          new (dir) directory_type (*this);
 
          deallocate_directories<directory_type> ();
        }
      return dir;
    }

allocate_file() [1/2]

template<typename T , typename L >

T * os::posix::file_system::allocate_file ( L &  locker )

inherited

Definition at line 874 of file file-system.h.

    {
      using file_type = T;
 
      file_type* fil;
 
      if (deferred_files_list_.empty ())
        {
          fil = new file_type (*this, locker);
        }
      else
        {
          fil = static_cast<file_type*> (deferred_files_list_.unlink_head ());
 
          // Call the constructor before reusing the object,
          fil->~file_type ();
 
          // Placement new, run only the constructor.
          new (fil) file_type (*this, locker);
 
          deallocate_files<file_type> ();
        }
      return fil;
    }

allocate_file() [2/2]

template<typename T >

T * os::posix::file_system::allocate_file ( void  )

inherited

Definition at line 847 of file file-system.h.

    {
      using file_type = T;
 
      file_type* fil;
 
      if (deferred_files_list_.empty ())
        {
          fil = new file_type (*this);
        }
      else
        {
          fil = static_cast<file_type*> (deferred_files_list_.unlink_head ());
 
          // Call the constructor before reusing the object,
          fil->~file_type ();
 
          // Placement new, run only the constructor.
          new (fil) file_type (*this);
 
          deallocate_files<file_type> ();
        }
      return fil;
    }

chmod()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::chmod ( const char *  path, mode_t  mode  )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1144 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::chmod (path, mode);
    }

References os::posix::file_system::chmod().

deallocate_directories()

template<typename T >

void os::posix::file_system::deallocate_directories ( void  )

inherited

Definition at line 974 of file file-system.h.

    {
      using directory_type = T;
 
      // Deallocate all remaining elements in the list.
      while (!deferred_directories_list_.empty ())
        {
          directory_type* d = static_cast<directory_type*> (
              deferred_directories_list_.unlink_head ());
 
          // Call the destructor and the deallocator.
          delete d;
        }
    }

deallocate_files()

template<typename T >

void os::posix::file_system::deallocate_files ( void  )

inherited

Definition at line 901 of file file-system.h.

    {
      using file_type = T;
 
      // Deallocate all remaining elements in the list.
      while (!deferred_files_list_.empty ())
        {
          file_type* f
              = static_cast<file_type*> (deferred_files_list_.unlink_head ());
 
          // Call the destructor and the deallocator.
          delete f;
        }
    }

deferred_directories_list()

file_system::deferred_directories_list_t & os::posix::file_system::deferred_directories_list ( void  )

inlineinherited

Definition at line 840 of file file-system.h.

    {
      return deferred_directories_list_;
    }

deferred_files_list()

file_system::deferred_files_list_t & os::posix::file_system::deferred_files_list ( void  )

inlineinherited

Definition at line 834 of file file-system.h.

    {
      return deferred_files_list_;
    }

device()

block_device & os::posix::file_system::device ( void  ) const

inlineinherited

Definition at line 816 of file file-system.h.

    {
      return impl ().device ();
    }

References os::posix::file_system_impl::device(), and os::posix::file_system::impl().

identify_mounted()

file_system * os::posix::file_system::identify_mounted ( const char **  path1, const char **  path2 = nullptr  )

staticinherited

Definition at line 621 of file file-system.cpp.

    {
      assert (path1 != nullptr);
      assert (*path1 != nullptr);
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
      for (auto&& fs : mounted_list__)
#pragma GCC diagnostic pop
        {
          auto len = std::strlen (fs.mounted_path_);
 
          // Check if path1 starts with the mounted path.
          if (std::strncmp (fs.mounted_path_, *path1, len) == 0)
            {
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
              // If so, adjust paths to skip over prefix, but keep '/'.
              *path1 = (*path1 + len - 1);
              while ((*path1)[1] == '/')
                {
                  *path1 = (*path1 + 1);
                }
 
              if ((path2 != nullptr) && (*path2 != nullptr))
                {
                  *path2 = (*path2 + len - 1);
                  while ((*path2)[1] == '/')
                    {
                      *path2 = (*path2 + 1);
                    }
                }
#pragma GCC diagnostic pop
 
              return &fs;
            }
        }
 
      // If root file system defined, return it.
      if (mounted_root__ != nullptr)
        {
          return mounted_root__;
        }
 
      // Not found.
      return nullptr;
    }

Referenced by os::posix::chmod(), os::posix::mkdir(), os::posix::opendir(), os::posix::rename(), os::posix::rmdir(), os::posix::stat(), os::posix::statvfs(), os::posix::truncate(), os::posix::unlink(), os::posix::utime(), and os::posix::vopen().

impl()

template<typename T , typename L >

file_system_lockable< T, L >::value_type & os::posix::file_system_lockable< T, L >::impl

(

void

)

const

Definition at line 1209 of file file-system.h.

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

mkdir()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::mkdir ( const char *  path, mode_t  mode  )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1115 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::mkdir (path, mode);
    }

References os::posix::file_system::mkdir().

mkfs()

int os::posix::file_system::mkfs ( int  options,   ...  )

inherited

Definition at line 470 of file file-system.cpp.

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

References os::posix::file_system::vmkfs().

mount()

int os::posix::file_system::mount ( const char *  path = nullptr, unsigned int  flags = 0,   ...  )

inherited

Definition at line 504 of file file-system.cpp.

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

References os::posix::file_system::vmount().

mounted_path()

const char * os::posix::file_system::mounted_path ( void  )

inherited

name()

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

inlineinherited

Definition at line 796 of file file-system.h.

    {
      return name_;
    }

open()

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

inherited

Definition at line 677 of file file-system.cpp.

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

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

opendir()

template<typename T , typename L >

directory * os::posix::file_system_lockable< T, L >::opendir ( const char *  dirpath )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1104 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::opendir (dirpath);
    }

References os::posix::file_system::opendir().

rename()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::rename ( const char *  existing, const char *  _new  )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1171 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::rename (existing, _new);
    }

References os::posix::file_system::rename().

rmdir()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::rmdir ( const char *  path )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1124 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::rmdir (path);
    }

References os::posix::file_system::rmdir().

stat()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::stat ( const char *  path, struct stat *  buf  )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1153 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::stat (path, buf);
    }

References os::posix::file_system::stat().

statvfs()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::statvfs ( struct statvfs *  buf )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1200 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::statvfs (buf);
    }

References os::posix::file_system::statvfs().

sync()

template<typename T , typename L >

void os::posix::file_system_lockable< T, L >::sync ( void  )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1133 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::sync ();
    }

References os::posix::file_system::sync().

truncate()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::truncate ( const char *  path, off_t  length  )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1162 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::truncate (path, length);
    }

References os::posix::file_system::truncate().

umount()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::umount ( int unsigned  flags = 0 )

overridevirtual

Parameters

flags

File system specific flags.

Return values

0	if successful,
-1	otherwise and the variable errno is set to indicate the error.

The root file system must be unmounted last, it cannot be unmounted if other mount points exists.

Reimplemented from os::posix::file_system.

Definition at line 1083 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::umount (flags);
    }

References os::posix::file_system::umount().

unlink()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::unlink ( const char *  path )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1180 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::unlink (path);
    }

References os::posix::file_system::unlink().

utime()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::utime ( const char *  path, const utimbuf *  times  )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1190 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::utime (path, times);
    }

References times(), and os::posix::file_system::utime().

vmkfs()

int os::posix::file_system::vmkfs ( int  options, std::va_list  args  )

virtualinherited

Definition at line 482 of file file-system.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(%u) @%p\n", __func__, options, this);
#endif
 
      if (mounted_path_ != nullptr)
        {
          // File system already mounted.
          errno = EBUSY;
          return -1;
        }
 
      errno = 0;
 
      int ret;
      ret = impl ().do_vmkfs (options, args);
 
      return ret;
    }

References os::posix::file_system_impl::do_vmkfs(), os::posix::file_system::impl(), and os::trace::printf().

Referenced by os::posix::file_system::mkfs().

vmount()

template<typename T , typename L >

int os::posix::file_system_lockable< T, L >::vmount ( const char *  path, unsigned int  flags, std::va_list  args  )

overridevirtual

Parameters

path	Path, terminated in /. If / or nullptr, the file system is mounted as root, i.e. the default if no other mount point matches.
flags	File system specific flags.
args	Optional arguments.

Return values

0	if successful,
-1	otherwise and the variable errno is set to indicate the error.

Reimplemented from os::posix::file_system.

Definition at line 1068 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::vmount (path, flags, args);
    }

References os::posix::file_system::vmount().

vopen()

template<typename T , typename L >

file * os::posix::file_system_lockable< T, L >::vopen ( const char *  path, int  oflag, std::va_list  args  )

overridevirtual

Reimplemented from os::posix::file_system.

Definition at line 1094 of file file-system.h.

    {
      std::lock_guard<L> lock{ impl_instance_.locker () };
 
      return file_system::vopen (path, oflag, args);
    }

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

---

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

• file-system.h