backend

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2010 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
 *          Alexander Warg <warg@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 */
#pragma once
 
#include <l4/l4re_vfs/vfs.h>
#include <l4/crtn/initpriorities.h>
 
namespace L4Re { namespace Vfs {
 
extern L4Re::Vfs::Ops *vfs_ops asm ("l4re_env_posix_vfs_ops");
 
class Mount_tree;
 
class Be_file : public File
{
public:
  void *operator new (size_t size) noexcept
  { return vfs_ops->malloc(size); }
 
  void *operator new (size_t, void *m) noexcept
  { return m; }
 
  void operator delete (void *m)
  { vfs_ops->free(m); }
 
  // used in close, to unlock all locks of a file (as POSIX says)
  int unlock_all_locks() noexcept override
  { return 0; }
 
  // for mmap
  L4::Cap<L4Re::Dataspace> data_space() const noexcept override
  { return L4::Cap<L4Re::Dataspace>::Invalid; }
 
  ssize_t readv(const struct iovec*, int) noexcept override
  { return -EINVAL; }
 
  ssize_t writev(const struct iovec*, int) noexcept override
  { return -EINVAL; }
 
  ssize_t pwritev(const struct iovec*, int, off64_t) noexcept override
  { return -EINVAL; }
 
  ssize_t preadv(const struct iovec*, int, off64_t) noexcept override
  { return -EINVAL; }
 
  off64_t lseek64(off64_t, int) noexcept override
  { return -ESPIPE; }
 
  int ftruncate64(off64_t) noexcept override
  { return -EINVAL; }
 
  int fsync() const noexcept override
  { return -EINVAL; }
 
  int fdatasync() const noexcept override
  { return -EINVAL; }
 
  int ioctl(unsigned long, va_list) noexcept override
  { return -EINVAL; }
 
  int fstat64(struct stat64 *) const noexcept override
  { return -EINVAL; }
 
  int fchmod(mode_t) noexcept override
  { return -EINVAL; }
 
  int get_status_flags() const noexcept override
  { return 0; }
 
  int set_status_flags(long) noexcept override
  { return 0; }
 
  int get_lock(struct flock64 *) noexcept override
  { return -ENOLCK; }
 
  int set_lock(struct flock64 *, bool) noexcept override
  { return -ENOLCK; }
 
  int faccessat(const char *, int, int) noexcept override
  { return -ENOTDIR; }
 
  int fchmodat(const char *, mode_t, int) noexcept override
  { return -ENOTDIR; }
 
  int utime(const struct utimbuf *) noexcept override
  { return -EROFS; }
 
  int utimes(const struct timeval [2]) noexcept override
  { return -EROFS; }
 
  int utimensat(const char *, const struct timespec [2], int) noexcept override
  { return -EROFS; }
 
  int mkdir(const char *, mode_t) noexcept override
  { return -ENOTDIR; }
 
  int unlink(const char *) noexcept override
  { return -ENOTDIR; }
 
  int rename(const char *, const char *) noexcept override
  { return -ENOTDIR; }
 
  int link(const char *, const char *) noexcept override
  { return -ENOTDIR; }
 
  int symlink(const char *, const char *) noexcept override
  { return -EPERM; }
 
  int rmdir(const char *) noexcept override
  { return -ENOTDIR; }
 
  ssize_t readlink(char *, size_t) override
  { return -EINVAL; }
 
  ssize_t getdents(char *, size_t) noexcept override
  { return -ENOTDIR; }
 
 
 
  // Socket interface
  int bind(sockaddr const *, socklen_t) noexcept override
  { return -ENOTSOCK; }
 
  int connect(sockaddr const *, socklen_t) noexcept override
  { return -ENOTSOCK; }
 
  ssize_t send(void const *, size_t, int) noexcept override
  { return -ENOTSOCK; }
 
  ssize_t recv(void *, size_t, int) noexcept override
  { return -ENOTSOCK; }
 
  ssize_t sendto(void const *, size_t, int, sockaddr const *, socklen_t) noexcept
    override
  { return -ENOTSOCK; }
 
  ssize_t recvfrom(void *, size_t, int, sockaddr *, socklen_t *) noexcept override
  { return -ENOTSOCK; }
 
  ssize_t sendmsg(msghdr const *, int) noexcept override
  { return -ENOTSOCK; }
 
  ssize_t recvmsg(msghdr *, int) noexcept override
  { return -ENOTSOCK; }
 
  int getsockopt(int, int, void *, socklen_t *) noexcept override
  { return -ENOTSOCK; }
 
  int setsockopt(int, int, void const *, socklen_t) noexcept override
  { return -ENOTSOCK; }
 
  int listen(int) noexcept override
  { return -ENOTSOCK; }
 
  int accept(sockaddr *, socklen_t *) noexcept override
  { return -ENOTSOCK; }
 
  int shutdown(int) noexcept override
  { return -ENOTSOCK; }
 
  int getsockname(sockaddr *, socklen_t *) noexcept override
  { return -ENOTSOCK; }
 
  int getpeername(sockaddr *, socklen_t *) noexcept override
  { return -ENOTSOCK; }
 
  ~Be_file() noexcept = 0;
 
private:
  int get_entry(const char *, int, mode_t, cxx::Ref_ptr<File> *) noexcept override
  { return -ENOTDIR; }
 
protected:
  const char *get_mount(const char *path, cxx::Ref_ptr<File> *dir) noexcept;
};
 
inline
Be_file::~Be_file() noexcept {}
 
class Be_file_pos : public Be_file
{
public:
  Be_file_pos() noexcept : Be_file(), _pos(0) {}
 
  virtual off64_t size() const noexcept = 0;
 
  ssize_t readv(const struct iovec *v, int iovcnt) noexcept override
  {
    ssize_t r = preadv(v, iovcnt, _pos);
    if (r > 0)
      _pos += r;
    return r;
  }
 
  ssize_t writev(const struct iovec *v, int iovcnt) noexcept override
  {
    ssize_t r = pwritev(v, iovcnt, _pos);
    if (r > 0)
      _pos += r;
    return r;
  }
 
  ssize_t preadv(const struct iovec *v, int iovcnt, off64_t offset) noexcept override = 0;
  ssize_t pwritev(const struct iovec *v, int iovcnt, off64_t offset) noexcept override = 0;
 
  off64_t lseek64(off64_t offset, int whence) noexcept override
  {
    off64_t r;
    switch (whence)
      {
      case SEEK_SET: r = offset; break;
      case SEEK_CUR: r = _pos + offset; break;
      case SEEK_END: r = size() + offset; break;
      default: return -EINVAL;
      };
 
    if (r < 0)
      return -EINVAL;
 
    _pos = r;
    return _pos;
  }
 
  ~Be_file_pos() noexcept = 0;
 
protected:
  off64_t pos() const noexcept { return _pos; }
 
private:
  off64_t _pos;
};
 
inline Be_file_pos::~Be_file_pos() noexcept {}
 
class Be_file_stream : public Be_file
{
public:
  ssize_t preadv(const struct iovec *v, int iovcnt, off64_t) noexcept override
  { return readv(v, iovcnt); }
 
  ssize_t pwritev(const struct iovec *v, int iovcnt, off64_t) noexcept override
  { return writev(v, iovcnt); }
 
  ~Be_file_stream() throw () = 0;
 
};
 
inline Be_file_stream::~Be_file_stream() noexcept {}
 
class Be_file_system : public File_system
{
private:
  char const *const _fstype;
 
public:
 
  explicit Be_file_system(char const *fstype) noexcept
  : File_system(), _fstype(fstype)
  {
    vfs_ops->register_file_system(this);
  }
 
  ~Be_file_system() noexcept
  {
    vfs_ops->unregister_file_system(this);
  }
 
  char const *type() const noexcept override { return _fstype; }
};
 
/* Make sure filesystems can register before the constructor of libmount
 * runs */
#define L4RE_VFS_FILE_SYSTEM_ATTRIBUTE \
     __attribute__((init_priority(INIT_PRIO_LATE)))
 
}}