Functions

µOS++ POSIX I/O C++ functions. More...

int	os::posix::mkdir (const char *path, mode_t mode)
int	os::posix::rmdir (const char *path)
void	os::posix::sync (void)
int	os::posix::chmod (const char *path, mode_t mode)
int	os::posix::stat (const char *path, struct stat *buf)
int	os::posix::truncate (const char *path, off_t length)
int	os::posix::rename (const char *existing, const char *_new)
int	os::posix::unlink (const char *path)
int	os::posix::utime (const char *path, const utimbuf *times)
int	os::posix::statvfs (const char *path, struct statvfs *buf)
directory *	os::posix::opendir (const char *dirname)
	Open directory.
io *	os::posix::open (const char *path, int oflag,...)
io *	os::posix::vopen (const char *path, int oflag, std::va_list args)
socket *	os::posix::socket (int domain, int type, int protocol)

Detailed Description

This page groups the functions providing support for standard POSIX I/O operations.x

TODO: add content

Function Documentation

chmod()

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\", %u)\n", __func__, path, mode);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      const char* adjusted_path = path;
      auto* const fs = file_system::identify_mounted (&adjusted_path);
 
      if (fs == nullptr)
        {
          errno = ENOENT;
          return -1;
        }
 
      return fs->chmod (adjusted_path, mode);
    }

References os::posix::file_system::identify_mounted(), and os::trace::printf().

Referenced by __posix_chmod().

mkdir()

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\", %u)\n", __func__, path, mode);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      auto adjusted_path = path;
      auto* const fs = file_system::identify_mounted (&adjusted_path);
 
      if (fs == nullptr)
        {
          errno = ENOENT;
          return -1;
        }
 
      // Execute the implementation specific code.
      return fs->mkdir (adjusted_path, mode);
    }

References os::posix::file_system::identify_mounted(), and os::trace::printf().

Referenced by __posix_mkdir().

open()

io * os::posix::open	(	const char *	path,
		int	oflag,
			...
	)

Definition at line 49 of file io.cpp.

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

References os::posix::vopen().

opendir()

directory * os::posix::opendir

(

const char *

dirname

)

Parameters

dirname

[in] Directory name.

Returns

Pointer to directory object.

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\")\n", __func__, dirpath);
#endif
 
      if (dirpath == nullptr)
        {
          errno = EFAULT;
          return nullptr;
        }
 
      if (*dirpath == '\0')
        {
          errno = ENOENT;
          return nullptr;
        }
 
      errno = 0;
 
      os::posix::directory* dir;
 
      while (true)
        {
          // Check if path is a device.
          os::posix::io* io;
          io = os::posix::device_registry<device>::identify_device (dirpath);
          if (io != nullptr)
            {
              // Cannot list devices (for now).
              return nullptr;
            }
 
          // Check if a regular folder.
          auto adjusted_path = dirpath;
          auto* const fs
              = os::posix::file_system::identify_mounted (&adjusted_path);
 
          // The manager will return null if there are no file systems
          // registered, no need to check this condition separately.
          if (fs == nullptr)
            {
              errno = EBADF;
              return nullptr;
            }
 
          // Use the file system implementation to open the directory, using
          // the adjusted path (mount point prefix removed).
          dir = fs->opendir (adjusted_path);
          if (dir == nullptr)
            {
              // Open failed.
              return nullptr;
            }
 
          break;
        }
 
        // Return a valid pointer to an object derived from directory, or
        // nullptr.
 
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\")=%p\n", __func__, dirpath, dir);
#endif
      return dir;
    }

References os::posix::device_registry< T >::identify_device(), os::posix::file_system::identify_mounted(), and os::trace::printf().

Referenced by __posix_opendir().

rename()

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%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;
        }
 
      auto adjusted_existing = existing;
      auto adjusted_new = _new;
      auto* const fs
          = file_system::identify_mounted (&adjusted_existing, &adjusted_new);
 
      if (fs == nullptr)
        {
          errno = ENOENT;
          return -1;
        }
 
      return fs->rename (adjusted_existing, adjusted_new);
    }

References os::posix::file_system::identify_mounted(), and os::trace::printf().

Referenced by __posix_rename().

rmdir()

int os::posix::rmdir

(

const char *

path

)

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\")\n", __func__, path);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      auto adjusted_path = path;
      auto* const fs = file_system::identify_mounted (&adjusted_path);
 
      if (fs == nullptr)
        {
          errno = ENOENT;
          return -1;
        }
 
      // Execute the implementation specific code.
      return fs->rmdir (adjusted_path);
    }

References os::posix::file_system::identify_mounted(), and os::trace::printf().

Referenced by __posix_rmdir().

socket()

class socket * os::posix::socket	(	int	domain,
		int	type,
		int	protocol
	)

Definition at line 62 of file net-stack.cpp.

    {
      errno = 0;
 
      // TODO: implement a way to identify the net stack.
      net_stack* ns = nullptr;
      class socket* sock = ns->socket (domain, type, protocol);
      if (sock == nullptr)
        {
          return nullptr;
        }
      sock->alloc_file_descriptor ();
      return sock;
    }

References os::posix::io::alloc_file_descriptor(), and os::posix::net_stack::socket().

stat()

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\", %p)\n", __func__, path, buf);
#endif
 
      if ((path == nullptr) || (buf == nullptr))
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      const char* adjusted_path = path;
      auto* const fs = file_system::identify_mounted (&adjusted_path);
 
      if (fs == nullptr)
        {
          errno = ENOENT;
          return -1;
        }
 
      return fs->stat (adjusted_path, buf);
    }

References os::posix::file_system::identify_mounted(), and os::trace::printf().

Referenced by __posix_stat().

statvfs()

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\", %p)\n", __func__, path, buf);
#endif
 
      if ((path == nullptr) || (buf == nullptr))
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      auto adjusted_path = path;
      auto* const fs = file_system::identify_mounted (&adjusted_path);
 
      if (fs == nullptr)
        {
          errno = ENOENT;
          return -1;
        }
 
      return fs->statvfs (buf);
    }

References os::posix::file_system::identify_mounted(), and os::trace::printf().

Referenced by __posix_statvfs().

sync()

void os::posix::sync

(

void

)

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s()\n", __func__);
#endif
 
      // Enumerate all mounted file systems and sync them.
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
      for (auto&& fs : file_system::mounted_list__)
#pragma GCC diagnostic pop
        {
          fs.sync ();
        }
 
      if (file_system::mounted_root__ != nullptr)
        {
          file_system::mounted_root__->sync ();
        }
    }

References os::trace::printf().

Referenced by __posix_sync().

truncate()

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\", %u)\n", __func__, path, length);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      const char* adjusted_path = path;
      auto* const fs = file_system::identify_mounted (&adjusted_path);
 
      if (fs == nullptr)
        {
          errno = ENOENT;
          return -1;
        }
 
      if (length < 0)
        {
          errno = EINVAL;
          return -1;
        }
 
      return fs->truncate (adjusted_path, length);
    }

References os::posix::file_system::identify_mounted(), and os::trace::printf().

Referenced by __posix_truncate().

unlink()

int os::posix::unlink

(

const char *

path

)

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\")\n", __func__, path);
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      auto adjusted_path = path;
      auto* const fs = file_system::identify_mounted (&adjusted_path);
 
      if (fs == nullptr)
        {
          errno = ENOENT;
          return -1;
        }
 
      return fs->unlink (adjusted_path);
    }

References os::posix::file_system::identify_mounted(), and os::trace::printf().

Referenced by __posix_unlink().

utime()

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

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

    {
#if defined(OS_TRACE_POSIX_IO_FILE_SYSTEM)
      trace::printf ("%s(\"%s\", %p)\n", __func__, path, times);
#endif
 
      if ((path == nullptr) || (times == nullptr))
        {
          errno = EFAULT;
          return -1;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return -1;
        }
 
      auto adjusted_path = path;
      auto* const fs = file_system::identify_mounted (&adjusted_path);
 
      if (fs == nullptr)
        {
          errno = ENOENT;
          return -1;
        }
 
      return fs->utime (adjusted_path, times);
    }

References os::posix::file_system::identify_mounted(), os::trace::printf(), and times().

Referenced by __posix_utime().

vopen()

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

The actual open workhorse. Using the path, try to identify the io object, then call the implementation. If successful, allocate a new POSIX file descriptor, to be used by C functions.

Definition at line 66 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(\"%s\")\n", __func__, path ? path : "");
#endif
 
      if (path == nullptr)
        {
          errno = EFAULT;
          return nullptr;
        }
 
      if (*path == '\0')
        {
          errno = ENOENT;
          return nullptr;
        }
 
      errno = 0;
 
      os::posix::io* io;
      while (true)
        {
          // Check if path is a device.
          io = os::posix::device_registry<device>::identify_device (path);
          if (io != nullptr)
            {
              // If so, use the implementation to open the device.
              int oret = static_cast<device*> (io)->vopen (path, oflag, args);
              if (oret < 0)
                {
                  // Open failed.
                  return nullptr;
                }
 
              // File descriptor already allocated by device.
              break;
            }
 
          // Check if a regular file.
          auto adjusted_path = path;
          auto* const fs
              = os::posix::file_system::identify_mounted (&adjusted_path);
 
          // The manager will return null if there are no file systems
          // registered, no need to check this condition separately.
          if (fs == nullptr)
            {
              errno = EBADF;
              return nullptr;
            }
 
          // Use the file system implementation to open the file, using
          // the adjusted path (mount point prefix removed).
          io = fs->vopen (adjusted_path, oflag, args);
          if (io == nullptr)
            {
              // Open failed.
              return nullptr;
            }
 
          break;
        }
 
        // Return a valid pointer to an object derived from io, or nullptr.
 
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(\"%s\")=%p fd=%d\n", __func__, path, io,
                     io->file_descriptor ());
#endif
      return io;
    }

References os::posix::io::file_descriptor(), os::posix::device_registry< T >::identify_device(), os::posix::file_system::identify_mounted(), os::trace::printf(), and os::posix::vopen().

Referenced by __posix_open(), os::posix::open(), and os::posix::vopen().