os::posix::file_system Class Reference

File system class. More...

#include <cmsis-plus/posix-io/file-system.h>

Inheritance diagram for os::posix::file_system:

Public Member Functions
Constructors & Destructor
	file_system (file_system_impl &impl, const char *name)
virtual	~file_system ()

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 >
T *	allocate_directory (void)
template<typename T , typename L >
T *	allocate_file (L &locker)
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
file_system_impl &	impl (void) const
static file_system *	identify_mounted (const char **path1, const char **path2=nullptr)

Detailed Description

Definition at line 127 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_>

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_>

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

Constructor & Destructor Documentation

file_system()

os::posix::file_system::file_system	(	file_system_impl &	impl,
		const char *	name
	)

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

        : name_ (name), //
          impl_ (impl)
    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%s(\"%s\")=%p\n", __func__, name_, this);
#endif
      deferred_files_list_.clear ();
      deferred_directories_list_.clear ();
    }

References os::trace::printf().

~file_system()

os::posix::file_system::~file_system ( )

virtual

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("file_system::%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 )

inline

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 )

inline

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

)

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

)

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

)

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

)

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  )

virtual

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(), 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

)

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

)

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  )

inline

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  )

inline

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

    {
      return deferred_files_list_;
    }

device()

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

inline

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

    {
      return impl ().device ();
    }

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

identify_mounted()

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

static

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()

file_system_impl & os::posix::file_system::impl ( void  ) const

inline

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

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

Referenced by chmod(), device(), mkdir(), opendir(), rename(), rmdir(), stat(), statvfs(), sync(), truncate(), umount(), unlink(), utime(), vmkfs(), vmount(), and vopen().

mkdir()

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

virtual

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(), impl(), and os::trace::printf().

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

mkfs()

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

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 vmkfs().

mount()

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

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 vmount().

mounted_path()

const char * os::posix::file_system::mounted_path

(

void

)

name()

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

inline

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,
			...
	)

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 vopen().

opendir()

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

virtual

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(), 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  )

virtual

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(), 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 )

virtual

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(), 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  )

virtual

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(), 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 )

virtual

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(), 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  )

virtual

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(), 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  )

virtual

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(), 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 )

virtual

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(), 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 )

virtual

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(), 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  )

virtual

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(), 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  )

virtual

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(), impl(), and os::trace::printf().

Referenced by mkfs().

vmount()

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

virtual

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(), impl(), and os::trace::printf().

Referenced by 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  )

virtual

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(), impl(), and os::trace::printf().

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

---

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

• file-system.h
• file-system.cpp