imfs.h

Go to the documentation of this file.

 
/*
 *  COPYRIGHT (c) 1989-2011.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.rtems.org/license/LICENSE.
 */
 
#ifndef _RTEMS_IMFS_H
#define _RTEMS_IMFS_H
 
#include <sys/time.h>
#include <limits.h>
 
#include <rtems/libio_.h>
#include <rtems/pipe.h>
#include <rtems/score/timecounter.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*
 *  Data types
 */
 
struct IMFS_jnode_tt;
typedef struct IMFS_jnode_tt IMFS_jnode_t;
 
#define IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK     128
  extern const int imfs_memfile_bytes_per_block;
 
#define IMFS_MEMFILE_BYTES_PER_BLOCK imfs_memfile_bytes_per_block
#define IMFS_MEMFILE_BLOCK_SLOTS \
  (IMFS_MEMFILE_BYTES_PER_BLOCK / sizeof(void *))
 
typedef uint8_t *block_p;
typedef block_p *block_ptr;
 
/*
 *  Important block numbers for "memfiles"
 */
#define FIRST_INDIRECT           (0)
#define LAST_INDIRECT            (IMFS_MEMFILE_BLOCK_SLOTS - 1)
 
#define FIRST_DOUBLY_INDIRECT    (LAST_INDIRECT + 1)
#define LAST_DOUBLY_INDIRECT     \
   (LAST_INDIRECT + \
     (IMFS_MEMFILE_BLOCK_SLOTS * IMFS_MEMFILE_BLOCK_SLOTS))
 
#define FIRST_TRIPLY_INDIRECT    (LAST_DOUBLY_INDIRECT + 1)
#define LAST_TRIPLY_INDIRECT \
   (LAST_DOUBLY_INDIRECT +\
     (IMFS_MEMFILE_BLOCK_SLOTS * \
        IMFS_MEMFILE_BLOCK_SLOTS * IMFS_MEMFILE_BLOCK_SLOTS))
 
#define IMFS_MEMFILE_MAXIMUM_SIZE \
  (LAST_TRIPLY_INDIRECT * IMFS_MEMFILE_BYTES_PER_BLOCK)
 
typedef IMFS_jnode_t *(*IMFS_node_control_initialize)(
  IMFS_jnode_t *node,
  void *arg
);
 
IMFS_jnode_t *IMFS_node_initialize_default(
  IMFS_jnode_t *node,
  void *arg
);
 
IMFS_jnode_t *IMFS_node_initialize_directory(
  IMFS_jnode_t *node,
  void *arg
);
 
IMFS_jnode_t *IMFS_node_initialize_generic(
  IMFS_jnode_t *node,
  void *arg
);
 
typedef IMFS_jnode_t *(*IMFS_node_control_remove)(
  IMFS_jnode_t *node
);
 
IMFS_jnode_t *IMFS_node_remove_default(
  IMFS_jnode_t *node
);
 
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node );
 
typedef void (*IMFS_node_control_destroy)( IMFS_jnode_t *node );
 
void IMFS_node_destroy_default( IMFS_jnode_t *node );
 
void IMFS_do_nothing_destroy( IMFS_jnode_t *node );
 
typedef struct {
  const rtems_filesystem_file_handlers_r *handlers;
  IMFS_node_control_initialize node_initialize;
  IMFS_node_control_remove node_remove;
  IMFS_node_control_destroy node_destroy;
} IMFS_node_control;
 
typedef struct {
  IMFS_node_control node_control;
  size_t node_size;
} IMFS_mknod_control;
 
/*
 *  Maximum length of a "basename" of an IMFS file/node.
 */
 
#define IMFS_NAME_MAX _POSIX_NAME_MAX
 
/*
 
 *  The control structure for an IMFS jnode.
 */
 
struct IMFS_jnode_tt {
  rtems_chain_node    Node;                  /* for chaining them together */
  IMFS_jnode_t       *Parent;                /* Parent node */
  const char         *name;                  /* "basename" (not \0 terminated) */
  uint16_t            namelen;               /* Length of "basename" */
  mode_t              st_mode;               /* File mode */
  unsigned short      reference_count;
  nlink_t             st_nlink;              /* Link count */
 
  uid_t               st_uid;                /* User ID of owner */
  gid_t               st_gid;                /* Group ID of owner */
 
  time_t              stat_atime;            /* Time of last access */
  time_t              stat_mtime;            /* Time of last modification */
  time_t              stat_ctime;            /* Time of last status change */
  const IMFS_node_control *control;
};
 
typedef struct {
  IMFS_jnode_t                          Node;
  rtems_chain_control                   Entries;
  rtems_filesystem_mount_table_entry_t *mt_fs;
} IMFS_directory_t;
 
typedef struct {
  IMFS_jnode_t              Node;
  rtems_device_major_number major;
  rtems_device_minor_number minor;
} IMFS_device_t;
 
typedef struct {
  IMFS_jnode_t  Node;
  IMFS_jnode_t *link_node;
} IMFS_link_t;
 
typedef struct {
  IMFS_jnode_t  Node;
  char         *name;
} IMFS_sym_link_t;
 
typedef struct {
  IMFS_jnode_t Node;
  size_t       size;             /* size of file in bytes */
} IMFS_filebase_t;
 
typedef struct {
  IMFS_filebase_t File;
  block_ptr       indirect;         /* array of 128 data blocks pointers */
  block_ptr       doubly_indirect;  /* 128 indirect blocks */
  block_ptr       triply_indirect;  /* 128 doubly indirect blocks */
} IMFS_memfile_t;
 
typedef struct {
  IMFS_filebase_t File;
  block_p         direct;           /* pointer to file image */
} IMFS_linearfile_t;
 
/* Support copy on write for linear files */
typedef union {
  IMFS_jnode_t      Node;
  IMFS_filebase_t   File;
  IMFS_memfile_t    Memfile;
  IMFS_linearfile_t Linearfile;
} IMFS_file_t;
 
typedef struct {
  IMFS_jnode_t    Node;
  pipe_control_t *pipe;
} IMFS_fifo_t;
 
typedef struct {
  IMFS_jnode_t  Node;
  void         *context;
} IMFS_generic_t;
 
typedef struct {
  const void *data;
  size_t      size;
} IMFS_linearfile_context;
 
static inline IMFS_jnode_t *IMFS_iop_to_node( const rtems_libio_t *iop )
{
  return (IMFS_jnode_t *) iop->pathinfo.node_access;
}
 
static inline IMFS_directory_t *IMFS_iop_to_directory(
  const rtems_libio_t *iop
)
{
  return (IMFS_directory_t *) iop->pathinfo.node_access;
}
 
static inline IMFS_device_t *IMFS_iop_to_device( const rtems_libio_t *iop )
{
  return (IMFS_device_t *) iop->pathinfo.node_access;
}
 
static inline IMFS_file_t *IMFS_iop_to_file( const rtems_libio_t *iop )
{
  return (IMFS_file_t *) iop->pathinfo.node_access;
}
 
static inline IMFS_memfile_t *IMFS_iop_to_memfile( const rtems_libio_t *iop )
{
  return (IMFS_memfile_t *) iop->pathinfo.node_access;
}
 
static inline time_t _IMFS_get_time( void )
{
  struct bintime now;
 
  /* Use most efficient way to get the time in seconds (CLOCK_REALTIME) */
  _Timecounter_Getbintime( &now );
 
  return now.sec;
}
 
static inline void IMFS_update_atime( IMFS_jnode_t *jnode )
{
  jnode->stat_atime = _IMFS_get_time();
}
 
static inline void IMFS_update_mtime( IMFS_jnode_t *jnode )
{
  jnode->stat_mtime = _IMFS_get_time();
}
 
static inline void IMFS_update_ctime( IMFS_jnode_t *jnode )
{
  jnode->stat_ctime = _IMFS_get_time();
}
 
static inline void IMFS_mtime_ctime_update( IMFS_jnode_t *jnode )
{
  time_t now;
 
  now = _IMFS_get_time();
 
  jnode->stat_mtime = now;
  jnode->stat_ctime = now;
}
 
typedef struct {
  const IMFS_mknod_control *directory;
  const IMFS_mknod_control *device;
  const IMFS_mknod_control *file;
  const IMFS_mknod_control *fifo;
} IMFS_mknod_controls;
 
typedef struct {
  IMFS_directory_t Root_directory;
  const IMFS_mknod_controls *mknod_controls;
} IMFS_fs_info_t;
 
typedef struct {
  IMFS_fs_info_t *fs_info;
  const rtems_filesystem_operations_table *ops;
  const IMFS_mknod_controls *mknod_controls;
} IMFS_mount_data;
 
/*
 *  Shared Data
 */
 
extern const IMFS_mknod_control IMFS_mknod_control_dir_default;
extern const IMFS_mknod_control IMFS_mknod_control_dir_minimal;
extern const IMFS_mknod_control IMFS_mknod_control_device;
extern const IMFS_mknod_control IMFS_mknod_control_memfile;
extern const IMFS_node_control IMFS_node_control_linfile;
extern const IMFS_mknod_control IMFS_mknod_control_fifo;
extern const IMFS_mknod_control IMFS_mknod_control_enosys;
 
extern const rtems_filesystem_limits_and_options_t  IMFS_LIMITS_AND_OPTIONS;
 
/*
 *  Routines
 */
 
extern int IMFS_initialize(
   rtems_filesystem_mount_table_entry_t *mt_entry,
   const void                           *data
);
 
extern int IMFS_initialize_support(
  rtems_filesystem_mount_table_entry_t *mt_entry,
  const void                           *data
);
 
extern void IMFS_fsunmount(
   rtems_filesystem_mount_table_entry_t *mt_entry
);
 
extern int rtems_tarfs_load(
   const char *mountpoint,
   uint8_t *tar_image,
   size_t tar_size
);
 
extern void IMFS_node_destroy( IMFS_jnode_t *node );
 
extern int IMFS_node_clone( rtems_filesystem_location_info_t *loc );
 
extern void IMFS_node_free( const rtems_filesystem_location_info_t *loc );
 
extern int IMFS_stat(
  const rtems_filesystem_location_info_t *loc,
  struct stat *buf
);
 
extern int IMFS_stat_file(
  const rtems_filesystem_location_info_t *loc,
  struct stat *buf
);
 
extern void IMFS_eval_path(
  rtems_filesystem_eval_path_context_t *ctx
);
 
extern void IMFS_eval_path_devfs(
  rtems_filesystem_eval_path_context_t *ctx
);
 
extern int IMFS_link(
  const rtems_filesystem_location_info_t *parentloc,
  const rtems_filesystem_location_info_t *targetloc,
  const char *name,
  size_t namelen
);
 
extern int IMFS_chown(
  const rtems_filesystem_location_info_t *loc,
  uid_t owner,
  gid_t group
);
 
extern int IMFS_mknod(
  const rtems_filesystem_location_info_t *parentloc,
  const char *name,
  size_t namelen,
  mode_t mode,
  dev_t dev
);
 
extern IMFS_jnode_t *IMFS_initialize_node(
  IMFS_jnode_t *node,
  const IMFS_node_control *node_control,
  const char *name,
  size_t namelen,
  mode_t mode,
  void *arg
);
 
extern IMFS_jnode_t *IMFS_create_node(
  const rtems_filesystem_location_info_t *parentloc,
  const IMFS_node_control *node_control,
  size_t node_size,
  const char *name,
  size_t namelen,
  mode_t mode,
  void *arg
);
 
static inline bool IMFS_is_imfs_instance(
  const rtems_filesystem_location_info_t *loc
)
{
  return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
}
 
#define IMFS_NODE_CONTROL_INITIALIZER( handlers, init, destroy ) \
  { \
    ( handlers ), \
    ( init ), \
    IMFS_node_remove_default, \
    ( destroy ) \
  }
 
#define IMFS_NODE_INITIALIZER( node_control, name, namelen, mode ) \
  { \
    { NULL, NULL }, \
    NULL, \
    ( name ), \
    ( namelen ), \
    ( mode ), \
    0, \
    0, \
    0, \
    0, \
    0, \
    0, \
    0, \
    ( node_control ) \
  }
 
static inline void IMFS_node_preinitialize(
  IMFS_jnode_t            *node,
  const IMFS_node_control *node_control,
  const char              *name,
  size_t                   namelen,
  mode_t                   mode
)
{
  node->control = node_control;
  node->name = name;
  node->namelen = namelen;
  node->st_mode = mode;
}
 
int IMFS_add_node( const char *path, IMFS_jnode_t *node, void *arg );
 
extern int IMFS_make_node(
  const char              *path,
  mode_t                   mode,
  const IMFS_node_control *node_control,
  size_t                   node_size,
  void                    *context
);
 
extern int IMFS_make_linearfile(
  const char *path,
  mode_t      mode,
  const void *data,
  size_t      size
);
 
/* Provided for backward compatibility */
#define IMFS_GENERIC_INITIALIZER( handlers, init, destroy ) \
  IMFS_NODE_CONTROL_INITIALIZER( handlers, init, destroy )
 
#define IMFS_GENERIC_CONTROL_INITIALIZER( handlers, init, destroy ) \
  IMFS_NODE_CONTROL_INITIALIZER( handlers, init, destroy )
 
#define IMFS_GENERIC_NODE_INITIALIZER( node_control, name, namelen, mode ) \
  { IMFS_NODE_INITIALIZER( node_control, name, namelen, mode ), NULL }
 
static inline void IMFS_generic_node_preinitialize(
  IMFS_generic_t          *node,
  const IMFS_node_control *node_control,
  const char              *name,
  size_t                   namelen,
  mode_t                   mode
)
{
  IMFS_node_preinitialize( &node->Node, node_control, name, namelen, mode );
}
 
extern int IMFS_make_generic_node(
  const char *path,
  mode_t mode,
  const IMFS_node_control *node_control,
  void *context
);
 
extern int IMFS_mount(
  rtems_filesystem_mount_table_entry_t *mt_entry  /* IN */
);
 
extern int IMFS_unmount(
  rtems_filesystem_mount_table_entry_t *mt_entry  /* IN */
);
 
extern ssize_t IMFS_memfile_write(
  IMFS_memfile_t      *memfile,
  off_t                start,
  const unsigned char *source,
  unsigned int         length
);
 
extern int device_open(
  rtems_libio_t *iop,            /* IN  */
  const char    *pathname,       /* IN  */
  int            oflag,          /* IN  */
  mode_t         mode            /* IN  */
);
 
extern int device_close(
  rtems_libio_t *iop             /* IN  */
);
 
extern ssize_t device_read(
  rtems_libio_t *iop,            /* IN  */
  void          *buffer,         /* IN  */
  size_t         count           /* IN  */
);
 
extern ssize_t device_write(
  rtems_libio_t *iop,               /* IN  */
  const void    *buffer,            /* IN  */
  size_t         count              /* IN  */
);
 
extern int device_ioctl(
  rtems_libio_t   *iop,
  ioctl_command_t  command,
  void            *buffer
);
 
extern int device_ftruncate(
  rtems_libio_t *iop,               /* IN  */
  off_t          length             /* IN  */
);
 
extern int IMFS_utime(
  const rtems_filesystem_location_info_t *loc,
  time_t actime,
  time_t modtime
);
 
extern int IMFS_fchmod(
  const rtems_filesystem_location_info_t *loc,
  mode_t mode
);
 
extern int IMFS_symlink(
  const rtems_filesystem_location_info_t *parentloc,
  const char *name,
  size_t namelen,
  const char *target
);
 
extern ssize_t IMFS_readlink(
  const rtems_filesystem_location_info_t *loc,
  char *buf,
  size_t bufsize
);
 
extern int IMFS_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
);
extern int IMFS_rmnod(
  const rtems_filesystem_location_info_t *parentloc,
  const rtems_filesystem_location_info_t *loc
);
 
/*
 *  Turn on IMFS assertions when RTEMS_DEBUG is defined.
 */
#ifdef RTEMS_DEBUG
  #include <assert.h>
 
  #define IMFS_assert(_x) assert(_x)
#else
  #define IMFS_assert(_x)
#endif
 
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
  IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
 
  loc->handlers = node->control->handlers;
}
 
static inline void IMFS_add_to_directory(
  IMFS_jnode_t *dir_node,
  IMFS_jnode_t *entry_node
)
{
  IMFS_directory_t *dir = (IMFS_directory_t *) dir_node;
 
  entry_node->Parent = dir_node;
  rtems_chain_append_unprotected( &dir->Entries, &entry_node->Node );
}
 
static inline void IMFS_remove_from_directory( IMFS_jnode_t *node )
{
  IMFS_assert( node->Parent != NULL );
  node->Parent = NULL;
  rtems_chain_extract_unprotected( &node->Node );
}
 
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
  return S_ISDIR( node->st_mode );
}
 
#define IMFS_STAT_FMT_HARD_LINK 0
 
static inline bool IMFS_is_hard_link( mode_t mode )
{
  return ( mode & S_IFMT ) == IMFS_STAT_FMT_HARD_LINK;
}
 
static inline ino_t IMFS_node_to_ino( const IMFS_jnode_t *node )
{
  return (ino_t) ((uintptr_t) node);
}
 
static inline void *IMFS_generic_get_context_by_node(
  const IMFS_jnode_t *node
)
{
  const IMFS_generic_t *generic = (const IMFS_generic_t *) node;
 
  return generic->context;
}
 
static inline void *IMFS_generic_get_context_by_location(
  const rtems_filesystem_location_info_t *loc
)
{
  return loc->node_access_2;
}
 
static inline void *IMFS_generic_get_context_by_iop(
  const rtems_libio_t *iop
)
{
  return IMFS_generic_get_context_by_location( &iop->pathinfo );
}
 
static inline dev_t IMFS_generic_get_device_identifier_by_node(
  const IMFS_jnode_t *node
)
{
  return rtems_filesystem_make_dev_t_from_pointer( node );
}
 
#ifdef __cplusplus
}
#endif
#endif
/* end of include file */