libio.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-2-Clause */
 
/*
 * COPYRIGHT (C) 1989, 2021 On-Line Applications Research Corporation (OAR).
 *
 * Modifications to support reference counting in the file system are
 * Copyright (C) 2012 embedded brains GmbH & Co. KG
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef _RTEMS_RTEMS_LIBIO_H
#define _RTEMS_RTEMS_LIBIO_H
 
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioccom.h>
#include <sys/statvfs.h>
#include <sys/uio.h>
 
#include <unistd.h>
#include <termios.h>
 
#include <rtems.h>
#include <rtems/fs.h>
#include <rtems/chain.h>
#include <rtems/score/atomic.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct knote;
 
typedef void (*rtems_filesystem_mt_entry_lock_t)(
  const rtems_filesystem_mount_table_entry_t *mt_entry
);
 
typedef void (*rtems_filesystem_mt_entry_unlock_t)(
  const rtems_filesystem_mount_table_entry_t *mt_entry
);
 
typedef struct {
  const char *path;
 
  size_t pathlen;
 
  const char *token;
 
  size_t tokenlen;
 
  int flags;
 
  int recursionlevel;
 
  rtems_filesystem_location_info_t currentloc;
 
  rtems_filesystem_global_location_t *rootloc;
 
  rtems_filesystem_global_location_t *startloc;
} rtems_filesystem_eval_path_context_t;
 
typedef void (*rtems_filesystem_eval_path_t)(
  rtems_filesystem_eval_path_context_t *ctx
);
 
typedef int (*rtems_filesystem_link_t)(
  const rtems_filesystem_location_info_t *parentloc,
  const rtems_filesystem_location_info_t *targetloc,
  const char *name,
  size_t namelen
);
 
typedef int (*rtems_filesystem_fchmod_t)(
  const rtems_filesystem_location_info_t *loc,
  mode_t mode
);
 
typedef int (*rtems_filesystem_chown_t)(
  const rtems_filesystem_location_info_t *loc,
  uid_t owner,
  gid_t group
);
 
typedef int (*rtems_filesystem_clonenode_t)(
  rtems_filesystem_location_info_t *loc
);
 
typedef void (*rtems_filesystem_freenode_t)(
  const rtems_filesystem_location_info_t *loc
);
 
typedef int (*rtems_filesystem_mount_t) (
  rtems_filesystem_mount_table_entry_t *mt_entry
);
 
typedef int (*rtems_filesystem_fsmount_me_t)(
  rtems_filesystem_mount_table_entry_t *mt_entry,
  const void *data
);
 
typedef int (*rtems_filesystem_unmount_t) (
  rtems_filesystem_mount_table_entry_t *mt_entry
);
 
typedef void (*rtems_filesystem_fsunmount_me_t)(
  rtems_filesystem_mount_table_entry_t *mt_entry
);
 
typedef bool (*rtems_filesystem_are_nodes_equal_t)(
  const rtems_filesystem_location_info_t *a,
  const rtems_filesystem_location_info_t *b
);
 
typedef int (*rtems_filesystem_mknod_t)(
  const rtems_filesystem_location_info_t *parentloc,
  const char *name,
  size_t namelen,
  mode_t mode,
  dev_t dev
);
 
typedef int (*rtems_filesystem_rmnod_t)(
  const rtems_filesystem_location_info_t *parentloc,
  const rtems_filesystem_location_info_t *loc
);
 
typedef int (*rtems_filesystem_utimens_t)(
  const rtems_filesystem_location_info_t *loc,
  struct timespec times[2]
);
 
typedef int (*rtems_filesystem_symlink_t)(
  const rtems_filesystem_location_info_t *parentloc,
  const char *name,
  size_t namelen,
  const char *target
);
 
typedef ssize_t (*rtems_filesystem_readlink_t)(
  const rtems_filesystem_location_info_t *loc,
  char *buf,
  size_t bufsize
);
 
typedef int (*rtems_filesystem_rename_t)(
  const rtems_filesystem_location_info_t *oldparentloc,
  const rtems_filesystem_location_info_t *oldloc,
  const rtems_filesystem_location_info_t *newparentloc,
  const char *name,
  size_t namelen
);
 
typedef int (*rtems_filesystem_statvfs_t)(
  const rtems_filesystem_location_info_t *loc,
  struct statvfs *buf
);
 
struct _rtems_filesystem_operations_table {
  rtems_filesystem_mt_entry_lock_t lock_h;
  rtems_filesystem_mt_entry_unlock_t unlock_h;
  rtems_filesystem_eval_path_t eval_path_h;
  rtems_filesystem_link_t link_h;
  rtems_filesystem_are_nodes_equal_t are_nodes_equal_h;
  rtems_filesystem_mknod_t mknod_h;
  rtems_filesystem_rmnod_t rmnod_h;
  rtems_filesystem_fchmod_t fchmod_h;
  rtems_filesystem_chown_t chown_h;
  rtems_filesystem_clonenode_t clonenod_h;
  rtems_filesystem_freenode_t freenod_h;
  rtems_filesystem_mount_t mount_h;
  rtems_filesystem_unmount_t unmount_h;
  rtems_filesystem_fsunmount_me_t fsunmount_me_h;
  rtems_filesystem_utimens_t utimens_h;
  rtems_filesystem_symlink_t symlink_h;
  rtems_filesystem_readlink_t readlink_h;
  rtems_filesystem_rename_t rename_h;
  rtems_filesystem_statvfs_t statvfs_h;
};
 
extern const rtems_filesystem_operations_table
  rtems_filesystem_operations_default;
 
void rtems_filesystem_default_lock(
  const rtems_filesystem_mount_table_entry_t *mt_entry
);
 
void rtems_filesystem_default_unlock(
  const rtems_filesystem_mount_table_entry_t *mt_entry
);
 
void rtems_filesystem_default_eval_path(
  rtems_filesystem_eval_path_context_t *ctx
);
 
int rtems_filesystem_default_link(
  const rtems_filesystem_location_info_t *parentloc,
  const rtems_filesystem_location_info_t *targetloc,
  const char *name,
  size_t namelen
);
 
bool rtems_filesystem_default_are_nodes_equal(
  const rtems_filesystem_location_info_t *a,
  const rtems_filesystem_location_info_t *b
);
 
int rtems_filesystem_default_mknod(
  const rtems_filesystem_location_info_t *parentloc,
  const char *name,
  size_t namelen,
  mode_t mode,
  dev_t dev
);
 
int rtems_filesystem_default_rmnod(
  const rtems_filesystem_location_info_t *parentloc,
  const rtems_filesystem_location_info_t *loc
);
 
int rtems_filesystem_default_fchmod(
  const rtems_filesystem_location_info_t *loc,
  mode_t mode
);
 
int rtems_filesystem_default_chown(
  const rtems_filesystem_location_info_t *loc,
  uid_t owner,
  gid_t group
);
 
int rtems_filesystem_default_clonenode(
  rtems_filesystem_location_info_t *loc
);
 
void rtems_filesystem_default_freenode(
  const rtems_filesystem_location_info_t *loc
);
 
int rtems_filesystem_default_mount (
   rtems_filesystem_mount_table_entry_t *mt_entry     /* IN */
);
 
int rtems_filesystem_default_unmount(
  rtems_filesystem_mount_table_entry_t *mt_entry     /* IN */
);
 
void rtems_filesystem_default_fsunmount(
   rtems_filesystem_mount_table_entry_t *mt_entry    /* IN */
);
 
int rtems_filesystem_default_utimens(
  const rtems_filesystem_location_info_t *loc,
  struct timespec times[2]
);
 
int rtems_filesystem_default_symlink(
  const rtems_filesystem_location_info_t *parentloc,
  const char *name,
  size_t namelen,
  const char *target
);
 
ssize_t rtems_filesystem_default_readlink(
  const rtems_filesystem_location_info_t *loc,
  char *buf,
  size_t bufsize
);
 
int rtems_filesystem_default_rename(
  const rtems_filesystem_location_info_t *oldparentloc,
  const rtems_filesystem_location_info_t *oldloc,
  const rtems_filesystem_location_info_t *newparentloc,
  const char *name,
  size_t namelen
);
 
int rtems_filesystem_default_statvfs(
  const rtems_filesystem_location_info_t *loc,
  struct statvfs *buf
);
 
typedef int (*rtems_filesystem_open_t)(
  rtems_libio_t *iop,
  const char    *path,
  int            oflag,
  mode_t         mode
);
 
typedef int (*rtems_filesystem_close_t)(
  rtems_libio_t *iop
);
 
typedef ssize_t (*rtems_filesystem_read_t)(
  rtems_libio_t *iop,
  void          *buffer,
  size_t         count
);
 
typedef ssize_t (*rtems_filesystem_readv_t)(
  rtems_libio_t      *iop,
  const struct iovec *iov,
  int                 iovcnt,
  ssize_t             total
);
 
typedef ssize_t (*rtems_filesystem_write_t)(
  rtems_libio_t *iop,
  const void    *buffer,
  size_t         count
);
 
typedef ssize_t (*rtems_filesystem_writev_t)(
  rtems_libio_t      *iop,
  const struct iovec *iov,
  int                 iovcnt,
  ssize_t             total
);
 
typedef int (*rtems_filesystem_ioctl_t)(
  rtems_libio_t   *iop,
  ioctl_command_t  request,
  void            *buffer
);
 
typedef off_t (*rtems_filesystem_lseek_t)(
  rtems_libio_t *iop,
  off_t          offset,
  int            whence
);
 
typedef int (*rtems_filesystem_fstat_t)(
  const rtems_filesystem_location_info_t *loc,
  struct stat *buf
);
 
typedef int (*rtems_filesystem_ftruncate_t)(
  rtems_libio_t *iop,
  off_t length
);
 
typedef int (*rtems_filesystem_fsync_t)(
  rtems_libio_t *iop
);
 
typedef int (*rtems_filesystem_fdatasync_t)(
  rtems_libio_t *iop
);
 
typedef int (*rtems_filesystem_fcntl_t)(
  rtems_libio_t *iop,
  int cmd
);
 
typedef int (*rtems_filesystem_poll_t)(
  rtems_libio_t *iop,
  int events
);
 
typedef int (*rtems_filesystem_kqfilter_t)(
  rtems_libio_t *iop,
  struct knote *kn
);
 
typedef int (*rtems_filesystem_mmap_t)(
  rtems_libio_t *iop,
  void **addr,
  size_t len,
  int prot,
  off_t off
);
 
struct _rtems_filesystem_file_handlers_r {
  rtems_filesystem_open_t open_h;
  rtems_filesystem_close_t close_h;
  rtems_filesystem_read_t read_h;
  rtems_filesystem_write_t write_h;
  rtems_filesystem_ioctl_t ioctl_h;
  rtems_filesystem_lseek_t lseek_h;
  rtems_filesystem_fstat_t fstat_h;
  rtems_filesystem_ftruncate_t ftruncate_h;
  rtems_filesystem_fsync_t fsync_h;
  rtems_filesystem_fdatasync_t fdatasync_h;
  rtems_filesystem_fcntl_t fcntl_h;
  rtems_filesystem_poll_t poll_h;
  rtems_filesystem_kqfilter_t kqfilter_h;
  rtems_filesystem_readv_t readv_h;
  rtems_filesystem_writev_t writev_h;
  rtems_filesystem_mmap_t mmap_h;
};
 
extern const rtems_filesystem_file_handlers_r
  rtems_filesystem_handlers_default;
 
int rtems_filesystem_default_open(
  rtems_libio_t *iop,
  const char    *path,
  int            oflag,
  mode_t         mode
);
 
int rtems_filesystem_default_close(
  rtems_libio_t *iop
);
 
ssize_t rtems_filesystem_default_read(
  rtems_libio_t *iop,
  void          *buffer,
  size_t         count
);
 
ssize_t rtems_filesystem_default_readv(
  rtems_libio_t      *iop,
  const struct iovec *iov,
  int                 iovcnt,
  ssize_t             total
);
 
ssize_t rtems_filesystem_default_write(
  rtems_libio_t *iop,
  const void    *buffer,
  size_t         count
);
 
ssize_t rtems_filesystem_default_writev(
  rtems_libio_t      *iop,
  const struct iovec *iov,
  int                 iovcnt,
  ssize_t             total
);
 
int rtems_filesystem_default_ioctl(
  rtems_libio_t   *iop,
  ioctl_command_t  request,
  void            *buffer
);
 
off_t rtems_filesystem_default_lseek(
  rtems_libio_t *iop,
  off_t          offset,
  int            whence
);
 
off_t rtems_filesystem_default_lseek_directory(
  rtems_libio_t *iop,
  off_t offset,
  int whence
);
 
off_t rtems_filesystem_default_lseek_file(
  rtems_libio_t *iop,
  off_t offset,
  int whence
);
 
int rtems_filesystem_default_fstat(
  const rtems_filesystem_location_info_t *loc,
  struct stat *buf
);
 
int rtems_filesystem_default_ftruncate(
  rtems_libio_t *iop,
  off_t length
);
 
int rtems_filesystem_default_ftruncate_directory(
  rtems_libio_t *iop,
  off_t length
);
 
int rtems_filesystem_default_fsync_or_fdatasync(
  rtems_libio_t *iop
);
 
int rtems_filesystem_default_fsync_or_fdatasync_success(
  rtems_libio_t *iop
);
 
int rtems_filesystem_default_fcntl(
  rtems_libio_t *iop,
  int cmd
);
 
int rtems_filesystem_default_poll(
  rtems_libio_t *iop,
  int events
);
 
int rtems_filesystem_default_kqfilter(
  rtems_libio_t *iop,
  struct knote *kn
);
 
int rtems_filesystem_default_mmap(
  rtems_libio_t *iop,
  void **addr,
  size_t len,
  int prot,
  off_t off
);
 
typedef off_t rtems_off64_t __attribute__((deprecated));
 
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
  const char *type
);
 
typedef struct {
  int    link_max;                 /* count */
  int    max_canon;                /* max formatted input line size */
  int    max_input;                /* max input line size */
  int    name_max;                 /* max name length */
  int    path_max;                 /* max path */
  int    pipe_buf;                 /* pipe buffer size */
  int    posix_async_io;           /* async IO supported on fs, 0=no, 1=yes */
  int    posix_chown_restrictions; /* can chown: 0=no, 1=yes */
  int    posix_no_trunc;           /* error on names > max name, 0=no, 1=yes */
  int    posix_prio_io;            /* priority IO, 0=no, 1=yes */
  int    posix_sync_io;            /* file can be sync'ed, 0=no, 1=yes */
  int    posix_vdisable;           /* special char processing, 0=no, 1=yes */
} rtems_filesystem_limits_and_options_t;
 
extern const rtems_filesystem_limits_and_options_t
  rtems_filesystem_default_pathconf;
 
struct rtems_libio_tt {
  Atomic_Uint                             flags;
  off_t                                   offset;    /* current offset into file */
  rtems_filesystem_location_info_t        pathinfo;
  uint32_t                                data0;     /* private to "driver" */
  void                                   *data1;     /* ... */
};
 
typedef struct {
  rtems_libio_t          *iop;
  off_t                   offset;
  char                   *buffer;
  uint32_t                count;
  uint32_t                flags;
  uint32_t                bytes_moved;
} rtems_libio_rw_args_t;
 
typedef struct rtems_libio_open_close_args {
  rtems_libio_t          *iop;
  uint32_t                flags;
  uint32_t                mode;
} rtems_libio_open_close_args_t;
 
typedef struct {
  rtems_libio_t          *iop;
  ioctl_command_t         command;
  void                   *buffer;
  int                     ioctl_return;
} rtems_libio_ioctl_args_t;
 
#define LIBIO_FLAGS_NO_DELAY      0x0001U  /* return immediately if no data */
#define LIBIO_FLAGS_READ          0x0002U  /* reading */
#define LIBIO_FLAGS_WRITE         0x0004U  /* writing */
#define LIBIO_FLAGS_OPEN          0x0100U  /* device is open */
#define LIBIO_FLAGS_APPEND        0x0200U  /* all writes append */
#define LIBIO_FLAGS_CLOSE_ON_EXEC 0x0800U  /* close on process exec() */
#define LIBIO_FLAGS_READ_WRITE    (LIBIO_FLAGS_READ | LIBIO_FLAGS_WRITE)
#define LIBIO_FLAGS_REFERENCE_INC 0x1000U
 
static inline unsigned int rtems_libio_iop_flags( const rtems_libio_t *iop )
{
  return _Atomic_Load_uint( &iop->flags, ATOMIC_ORDER_RELAXED );
}
 
static inline bool rtems_libio_iop_is_no_delay( const rtems_libio_t *iop )
{
  return ( rtems_libio_iop_flags( iop ) & LIBIO_FLAGS_NO_DELAY ) != 0;
}
 
static inline bool rtems_libio_iop_is_readable( const rtems_libio_t *iop )
{
  return ( rtems_libio_iop_flags( iop ) & LIBIO_FLAGS_READ ) != 0;
}
 
static inline bool rtems_libio_iop_is_writeable( const rtems_libio_t *iop )
{
  return ( rtems_libio_iop_flags( iop ) & LIBIO_FLAGS_WRITE ) != 0;
}
 
static inline bool rtems_libio_iop_is_append( const rtems_libio_t *iop )
{
  return ( rtems_libio_iop_flags( iop ) & LIBIO_FLAGS_APPEND ) != 0;
}
 
typedef int (*rtems_libio_open_t)(
  const char  *pathname,
  uint32_t    flag,
  uint32_t    mode
);
 
typedef int (*rtems_libio_close_t)(
  int  fd
);
 
typedef ssize_t (*rtems_libio_read_t)(
  int         fd,
  void       *buffer,
  size_t    count
);
 
typedef ssize_t (*rtems_libio_write_t)(
  int         fd,
  const void *buffer,
  size_t      count
);
 
typedef int (*rtems_libio_ioctl_t)(
  int         fd,
  uint32_t    command,
  void       *buffer
);
 
typedef off_t (*rtems_libio_lseek_t)(
  int           fd,
  off_t         offset,
  int           whence
);
 
/*
 *  The following macros are used to build up the permissions sets
 *  used to check permissions.  These are similar in style to the
 *  mode_t bits and should stay compatible with them.
 */
#define RTEMS_FS_PERMS_READ 0x4
#define RTEMS_FS_PERMS_WRITE 0x2
#define RTEMS_FS_PERMS_EXEC 0x1
#define RTEMS_FS_PERMS_RWX \
  (RTEMS_FS_PERMS_READ | RTEMS_FS_PERMS_WRITE | RTEMS_FS_PERMS_EXEC)
#define RTEMS_FS_FOLLOW_HARD_LINK 0x8
#define RTEMS_FS_FOLLOW_SYM_LINK 0x10
#define RTEMS_FS_FOLLOW_LINK \
  (RTEMS_FS_FOLLOW_HARD_LINK | RTEMS_FS_FOLLOW_SYM_LINK)
#define RTEMS_FS_MAKE 0x20
#define RTEMS_FS_EXCLUSIVE 0x40
#define RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS 0x80
#define RTEMS_FS_REJECT_TERMINAL_DOT 0x100
 
union __rtems_dev_t {
  dev_t device;
  struct {
     rtems_device_major_number major;
     rtems_device_minor_number minor;
  } __overlay;
};
 
static inline dev_t rtems_filesystem_make_dev_t(
  rtems_device_major_number _major,
  rtems_device_minor_number _minor
)
{
  union __rtems_dev_t temp;
 
  temp.__overlay.major = _major;
  temp.__overlay.minor = _minor;
  return temp.device;
}
 
static inline dev_t rtems_filesystem_make_dev_t_from_pointer(
  const void *pointer
)
{
  uint64_t temp = (((uint64_t) 1) << 63) | (((uintptr_t) pointer) >> 1);
 
  return rtems_filesystem_make_dev_t((uint32_t) (temp >> 32), (uint32_t) temp);
}
 
static inline rtems_device_major_number rtems_filesystem_dev_major_t(
  dev_t device
)
{
  union __rtems_dev_t temp;
 
  temp.device = device;
  return temp.__overlay.major;
}
 
 
static inline rtems_device_minor_number rtems_filesystem_dev_minor_t(
  dev_t device
)
{
  union __rtems_dev_t temp;
 
  temp.device = device;
  return temp.__overlay.minor;
}
 
#define rtems_filesystem_split_dev_t( _dev, _major, _minor ) \
  do { \
    (_major) = rtems_filesystem_dev_major_t ( _dev ); \
    (_minor) = rtems_filesystem_dev_minor_t( _dev ); \
  } while(0)
 
/*
 *  Prototypes for filesystem
 */
 
void rtems_filesystem_initialize( void );
 
void rtems_libio_post_driver(void);
 
void rtems_libio_exit(void);
 
extern int rtems_mkdir(const char *path, mode_t mode);
 
#define RTEMS_FILESYSTEM_TYPE_IMFS "imfs"
#define RTEMS_FILESYSTEM_TYPE_FTPFS "ftpfs"
#define RTEMS_FILESYSTEM_TYPE_TFTPFS "tftpfs"
#define RTEMS_FILESYSTEM_TYPE_NFS "nfs"
#define RTEMS_FILESYSTEM_TYPE_DOSFS "dosfs"
#define RTEMS_FILESYSTEM_TYPE_RFS "rfs"
#define RTEMS_FILESYSTEM_TYPE_JFFS2 "jffs2"
 
struct rtems_filesystem_mount_table_entry_tt {
  rtems_chain_node                       mt_node;
  void                                  *fs_info;
  const rtems_filesystem_operations_table *ops;
  const void                            *immutable_fs_info;
  rtems_chain_control                    location_chain;
  rtems_filesystem_global_location_t    *mt_point_node;
  rtems_filesystem_global_location_t    *mt_fs_root;
  bool                                   mounted;
  bool                                   writeable;
  bool                                   no_regular_file_mknod;
  const rtems_filesystem_limits_and_options_t *pathconf_limits_and_options;
 
  /*
   * The target or mount point of the file system.
   */
  const char                            *target;
 
  /*
   * The type of filesystem or the name of the filesystem.
   */
  const char                            *type;
 
  /*
   *  When someone adds a mounted filesystem on a real device,
   *  this will need to be used.
   *
   *  The lower layers can manage how this is managed. Leave as a
   *  string.
   */
  char                                  *dev;
 
  rtems_id                               unmount_task;
};
 
typedef enum {
  RTEMS_FILESYSTEM_READ_ONLY,
  RTEMS_FILESYSTEM_READ_WRITE,
  RTEMS_FILESYSTEM_BAD_OPTIONS
} rtems_filesystem_options_t;
 
typedef struct rtems_filesystem_table_t {
  const char                    *type;
  rtems_filesystem_fsmount_me_t  mount_h;
} rtems_filesystem_table_t;
 
extern const rtems_filesystem_table_t rtems_filesystem_table [];
 
extern rtems_chain_control rtems_filesystem_mount_table;
 
int rtems_filesystem_register(
  const char                    *type,
  rtems_filesystem_fsmount_me_t  mount_h
);
 
int rtems_filesystem_unregister(
  const char *type
);
 
int unmount(
  const char *mount_path
);
 
int mount(
  const char                 *source,
  const char                 *target,
  const char                 *filesystemtype,
  rtems_filesystem_options_t options,
  const void                 *data
);
 
int mount_and_make_target_path(
  const char                 *source,
  const char                 *target,
  const char                 *filesystemtype,
  rtems_filesystem_options_t options,
  const void                 *data
);
 
typedef bool (*rtems_per_filesystem_routine)(
  const rtems_filesystem_table_t *fs_entry,
  void *arg
);
 
bool rtems_filesystem_iterate(
  rtems_per_filesystem_routine routine,
  void *routine_arg
);
 
typedef bool (*rtems_filesystem_mt_entry_visitor)(
  const rtems_filesystem_mount_table_entry_t *mt_entry,
  void *arg
);
 
bool rtems_filesystem_mount_iterate(
  rtems_filesystem_mt_entry_visitor visitor,
  void *visitor_arg
);
 
typedef struct {
  const char *source;
  const char *target;
  const char *filesystemtype;
  rtems_filesystem_options_t options;
  const void *data;
} rtems_filesystem_mount_configuration;
 
extern const rtems_filesystem_mount_configuration
  rtems_filesystem_root_configuration;
 
struct rtems_termios_tty;
 
typedef struct rtems_termios_callbacks {
  int    (*firstOpen)(int major, int minor, void *arg);
  int    (*lastClose)(int major, int minor, void *arg);
  int    (*pollRead)(int minor);
  ssize_t (*write)(int minor, const char *buf, size_t len);
  int    (*setAttributes)(int minor, const struct termios *t);
  int    (*stopRemoteTx)(int minor);
  int    (*startRemoteTx)(int minor);
  int    outputUsesInterrupts;
} rtems_termios_callbacks;
 
static inline void rtems_termios_initialize( void )
{
  /* Nothing to do, provided for backward compatibility */
}
 
/*
 * CCJ: Change before opening a tty. Newer code from Eric is coming
 * so extra work to handle an open tty is not worth it. If the tty
 * is open, close then open it again.
 */
rtems_status_code rtems_termios_bufsize (
  size_t cbufsize,     /* cooked buffer size */
  size_t raw_input,    /* raw input buffer size */
  size_t raw_output    /* raw output buffer size */
);
 
typedef enum {
  RTEMS_TERMIOS_IPROC_CONTINUE,
 
  RTEMS_TERMIOS_IPROC_INTERRUPT,
 
  RTEMS_TERMIOS_IPROC_DONE
} rtems_termios_iproc_status_code;
 
typedef rtems_termios_iproc_status_code (*rtems_termios_isig_handler)(
  unsigned char             c,
  struct rtems_termios_tty *tty
);
 
rtems_termios_iproc_status_code rtems_termios_default_isig_handler(
  unsigned char             c,
  struct rtems_termios_tty *tty
);
 
rtems_termios_iproc_status_code rtems_termios_posix_isig_handler(
  unsigned char             c,
  struct rtems_termios_tty *tty
);
 
rtems_status_code rtems_termios_register_isig_handler(
  rtems_termios_isig_handler handler
);
 
int rtems_termios_enqueue_raw_characters(
  void *ttyp,
  const char *buf,
  int   len
);
 
rtems_status_code rtems_termios_open (
  rtems_device_major_number      major,
  rtems_device_minor_number      minor,
  void                          *arg,
  const rtems_termios_callbacks *callbacks
);
 
rtems_status_code rtems_termios_close(
  void *arg
);
 
rtems_status_code rtems_termios_read(
  void *arg
);
 
rtems_status_code rtems_termios_write(
  void *arg
);
 
rtems_status_code rtems_termios_ioctl(
  void *arg
);
 
int rtems_termios_dequeue_characters(
  void *ttyp,
  int   len
);
 
#define rtems_filesystem_pathconf(_mte) ((_mte)->pathconf_limits_and_options)
 
#define rtems_filesystem_type(_mte) ((_mte)->type)
 
#define rtems_filesystem_mount_point(_mte) ((_mte)->target)
 
#define rtems_filesystem_mount_device(_mte) ((_mte)->dev)
 
#ifdef __cplusplus
}
#endif
 
#endif /* _RTEMS_LIBIO_H */