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

#include <file-system.h>

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

Public Types
using	value_type = T

Public Member Functions
Constructors & Destructor
template<typename... Args>
	file_system_implementable (const char *name, block_device &device, Args &&... args)
virtual	~file_system_implementable () override
Public Member Functions
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,...)
virtual int	vmount (const char *path, unsigned int flags, std::va_list args)
	Mount file system.
virtual int	umount (int unsigned flags=0)
	Unmount file system.
file *	open (const char *path=nullptr, int oflag=0,...)
virtual file *	vopen (const char *path, int oflag, std::va_list args)
virtual directory *	opendir (const char *dirpath)
virtual int	mkdir (const char *path, mode_t mode)
virtual int	rmdir (const char *path)
virtual void	sync (void)
virtual int	chmod (const char *path, mode_t mode)
virtual int	stat (const char *path, struct stat *buf)
virtual int	truncate (const char *path, off_t length)
virtual int	rename (const char *existing, const char *_new)
virtual int	unlink (const char *path)
virtual int	utime (const char *path, const utimbuf *times)
virtual int	statvfs (struct statvfs *buf)
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>
class os::posix::file_system_implementable< T >

Definition at line 558 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.

value_type

template<typename T >

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

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

Constructor & Destructor Documentation

file_system_implementable()

template<typename T >

template<typename... Args>

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

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

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

References os::trace::printf().

~file_system_implementable()

template<typename T >

os::posix::file_system_implementable< T >::~file_system_implementable

overridevirtual

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system_implementable::%s() @%p %s\n", __func__,
                     this, name_);
#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()

int os::posix::file_system::chmod ( const char *  path, mode_t  mode  )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\", %u)\n", __func__, path, mode);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_chmod (path, mode);
    }

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

Referenced by os::posix::file_system_lockable< T, L >::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 >

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

(

void

)

const

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

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

mkdir()

int os::posix::file_system::mkdir ( const char *  path, mode_t  mode  )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\", %u)\n", __func__, path, mode);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      return impl ().do_mkdir (path, mode);
    }

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

Referenced by os::posix::file_system_lockable< T, L >::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()

directory * os::posix::file_system::opendir ( const char *  dirpath )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\")\n", __func__, dirpath);
#endif
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return nullptr;
        }
 
      errno = 0;
 
      // Execute the dir specific implementation code.
      // Allocation is done by the implementation, where
      // the size is known.
      directory* dir = impl ().do_opendir (*this, dirpath);
      if (dir == nullptr)
        {
          return nullptr;
        }
 
      return dir;
    }

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

Referenced by os::posix::file_system_lockable< T, L >::opendir().

rename()

int os::posix::file_system::rename ( const char *  existing, const char *  _new  )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\",\"%s\")\n", __func__, existing,
                     _new);
#endif
 
      if ((existing == nullptr) || (_new == nullptr))
        {
          errno = EFAULT;
          return -1;
        }
 
      if ((*existing == '\0') || (*_new == '\0'))
        {
          errno = ENOENT;
          return -1;
        }
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_rename (existing, _new);
    }

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

Referenced by os::posix::file_system_lockable< T, L >::rename().

rmdir()

int os::posix::file_system::rmdir ( const char *  path )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\")\n", __func__, path);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      return impl ().do_rmdir (path);
    }

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

Referenced by os::posix::file_system_lockable< T, L >::rmdir().

stat()

int os::posix::file_system::stat ( const char *  path, struct stat *  buf  )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\", %p)\n", __func__, path, buf);
#endif
 
      if ((path == nullptr) || (buf == nullptr))
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_stat (path, buf);
    }

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

Referenced by os::posix::file_system_lockable< T, L >::stat().

statvfs()

int os::posix::file_system::statvfs ( struct statvfs *  buf )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(%p)\n", __func__, buf);
#endif
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      return impl ().do_statvfs (buf);
    }

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

Referenced by os::posix::file::fstatvfs(), and os::posix::file_system_lockable< T, L >::statvfs().

sync()

void os::posix::file_system::sync ( void  )

virtualinherited

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

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

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

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

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

truncate()

int os::posix::file_system::truncate ( const char *  path, off_t  length  )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\", %u)\n", __func__, path, length);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_truncate (path, length);
    }

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

Referenced by os::posix::file_system_lockable< T, L >::truncate().

umount()

int os::posix::file_system::umount ( int unsigned  flags = 0 )

virtualinherited

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 in os::posix::file_system_lockable< T, L >.

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(%u) @%p\n", __func__, flags, this);
#endif
 
      mount_manager_links_.unlink ();
      mounted_path_ = nullptr;
 
      if (this == mounted_root__)
        {
          if (!mounted_list__.empty ())
            {
              errno = EBUSY;
              return -1;
            }
 
          mounted_root__ = nullptr;
        }
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      impl ().do_sync ();
      int ret = impl ().do_umount (flags);
      return ret;
    }

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

Referenced by os::posix::file_system_lockable< T, L >::umount().

unlink()

int os::posix::file_system::unlink ( const char *  path )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\")\n", __func__, path);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_unlink (path);
    }

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

Referenced by os::posix::file_system_lockable< T, L >::unlink().

utime()

int os::posix::file_system::utime ( const char *  path, const utimbuf *  times  )

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\", %p)\n", __func__, path, times);
#endif
 
      if ((path == nullptr) || (times == nullptr))
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      /* struct */ utimbuf tmp;
      if (times == nullptr)
        {
          // If times is a null pointer, the access and modification times
          // of the file shall be set to the current time.
          tmp.actime = time (nullptr);
          tmp.modtime = tmp.actime;
          return impl ().do_utime (path, &tmp);
        }
      else
        {
          // Execute the implementation specific code.
          return impl ().do_utime (path, times);
        }
    }

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

Referenced by os::posix::file_system_lockable< T, L >::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()

int os::posix::file_system::vmount ( const char *  path, unsigned int  flags, std::va_list  args  )

virtualinherited

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 in os::posix::file_system_lockable< T, L >.

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\", %u) @%p\n", __func__,
                     path ? path : "nullptr", flags, this);
#endif
 
      if (mounted_path_ != nullptr)
        {
          // File system already mounted.
          errno = EBUSY;
          return -1;
        }
 
      if (path != 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
            {
              // Validate the device name by checking duplicates.
              if (std::strcmp (path, fs.mounted_path_) == 0)
                {
                  trace::printf ("Path \"%s\" already mounted.", path);
 
                  errno = EBUSY;
                  return -1;
                }
            }
        }
 
      char* p = const_cast<char*> (path);
      if (p != nullptr)
        {
          if (strcmp ("/", path) == 0)
            {
              p = nullptr;
            }
        }
 
      errno = 0;
 
      int ret = impl ().do_vmount (flags, args);
      if (ret < 0)
        {
          return -1;
        }
 
      if (p == nullptr)
        {
          mounted_root__ = this;
          mounted_path_ = "/";
        }
      else
        {
          mounted_list__.link (*this);
          mounted_path_ = path;
        }
 
      return 0;
    }

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

Referenced by os::posix::file_system::mount(), and os::posix::file_system_lockable< T, L >::vmount().

vopen()

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

virtualinherited

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\", %u)\n", __func__, path, oflag);
#endif
 
      if (!device ().is_opened ())
        {
          errno = EBADF; // Not opened.
          return nullptr;
        }
 
      errno = 0;
 
      // Execute the file specific implementation code.
      // Allocation is done by the implementation, where
      // the size is known.
      file* fil = impl ().do_vopen (*this, path, oflag, args);
      if (fil == nullptr)
        {
          return nullptr;
        }
 
      // If successful, allocate a file descriptor.
      fil->alloc_file_descriptor ();
 
      return fil;
    }

References os::posix::io::alloc_file_descriptor(), os::posix::file_system_impl::do_vopen(), os::posix::file_system::impl(), and os::trace::printf().

Referenced by os::posix::file_system::open(), and os::posix::file_system_lockable< T, L >::vopen().

---

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

• file-system.h