To create a new filesystem it is necessary to define the fstab entry +and the file IO operations. The easiest way to do this is to copy an +existing filesystem: either the test filesystem in the FILEIO package, +or the RAM or ROM filesystem packages.
To make this clearer, the following is a brief tour of the FILEIO +relevant parts of the RAM filesystem.
First, it is necessary to provide forward definitions of the functions +that constitute the filesystem interface:
//========================================================================== +// Forward definitions + +// Filesystem operations +static int ramfs_mount ( cyg_fstab_entry *fste, cyg_mtab_entry *mte ); +static int ramfs_umount ( cyg_mtab_entry *mte ); +static int ramfs_open ( cyg_mtab_entry *mte, cyg_dir dir, const char *name, + int mode, cyg_file *fte ); +static int ramfs_unlink ( cyg_mtab_entry *mte, cyg_dir dir, const char *name ); +static int ramfs_mkdir ( cyg_mtab_entry *mte, cyg_dir dir, const char *name ); +static int ramfs_rmdir ( cyg_mtab_entry *mte, cyg_dir dir, const char *name ); +static int ramfs_rename ( cyg_mtab_entry *mte, cyg_dir dir1, const char *name1, + cyg_dir dir2, const char *name2 ); +static int ramfs_link ( cyg_mtab_entry *mte, cyg_dir dir1, const char *name1, + cyg_dir dir2, const char *name2, int type ); +static int ramfs_opendir ( cyg_mtab_entry *mte, cyg_dir dir, const char *name, + cyg_file *fte ); +static int ramfs_chdir ( cyg_mtab_entry *mte, cyg_dir dir, const char *name, + cyg_dir *dir_out ); +static int ramfs_stat ( cyg_mtab_entry *mte, cyg_dir dir, const char *name, + struct stat *buf); +static int ramfs_getinfo ( cyg_mtab_entry *mte, cyg_dir dir, const char *name, + int key, void *buf, int len ); +static int ramfs_setinfo ( cyg_mtab_entry *mte, cyg_dir dir, const char *name, + int key, void *buf, int len ); + +// File operations +static int ramfs_fo_read (struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio); +static int ramfs_fo_write (struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio); +static int ramfs_fo_lseek (struct CYG_FILE_TAG *fp, off_t *pos, int whence ); +static int ramfs_fo_ioctl (struct CYG_FILE_TAG *fp, CYG_ADDRWORD com, + CYG_ADDRWORD data); +static int ramfs_fo_fsync (struct CYG_FILE_TAG *fp, int mode ); +static int ramfs_fo_close (struct CYG_FILE_TAG *fp); +static int ramfs_fo_fstat (struct CYG_FILE_TAG *fp, struct stat *buf ); +static int ramfs_fo_getinfo (struct CYG_FILE_TAG *fp, int key, void *buf, int len ); +static int ramfs_fo_setinfo (struct CYG_FILE_TAG *fp, int key, void *buf, int len ); + +// Directory operations +static int ramfs_fo_dirread (struct CYG_FILE_TAG *fp, struct CYG_UIO_TAG *uio); +static int ramfs_fo_dirlseek (struct CYG_FILE_TAG *fp, off_t *pos, int whence ); |
We define all of the fstab entries and all of the file IO +operations. We also define alternatives for the +fo_read and +fo_lseek file IO operations.
We can now define the filesystem table entry. There is a macro, +FSTAB_ENTRY to do this:
//========================================================================== +// Filesystem table entries + +// ------------------------------------------------------------------------- +// Fstab entry. +// This defines the entry in the filesystem table. +// For simplicity we use _FILESYSTEM synchronization for all accesses since +// we should never block in any filesystem operations. + +FSTAB_ENTRY( ramfs_fste, "ramfs", 0, + CYG_SYNCMODE_FILE_FILESYSTEM|CYG_SYNCMODE_IO_FILESYSTEM, + ramfs_mount, + ramfs_umount, + ramfs_open, + ramfs_unlink, + ramfs_mkdir, + ramfs_rmdir, + ramfs_rename, + ramfs_link, + ramfs_opendir, + ramfs_chdir, + ramfs_stat, + ramfs_getinfo, + ramfs_setinfo); |
The first argument to this macro gives the fstab entry a name, the +remainder are initializers for the field of the structure.
We must also define the file operations table that is installed in all +open file table entries:
// -------------------------------------------------------------------------
+// File operations.
+// This set of file operations are used for normal open files.
+
+static cyg_fileops ramfs_fileops =
+{
+ ramfs_fo_read,
+ ramfs_fo_write,
+ ramfs_fo_lseek,
+ ramfs_fo_ioctl,
+ cyg_fileio_seltrue,
+ ramfs_fo_fsync,
+ ramfs_fo_close,
+ ramfs_fo_fstat,
+ ramfs_fo_getinfo,
+ ramfs_fo_setinfo
+}; |
These all point to functions supplied by the filesystem except the +fo_select field which is filled with a +pointer to cyg_fileio_seltrue(). This is provided +by the FILEIO package and is a select function that always returns +true to all operations.
Finally, we need to define a set of file operations for use when +reading directories. This table only defines the +fo_read and +fo_lseek operations. The rest are filled +with stub functions supplied by the FILEIO package that just return an +error code.
// -------------------------------------------------------------------------
+// Directory file operations.
+// This set of operations are used for open directories. Most entries
+// point to error-returning stub functions. Only the read, lseek and
+// close entries are functional.
+
+static cyg_fileops ramfs_dirops =
+{
+ ramfs_fo_dirread,
+ (cyg_fileop_write *)cyg_fileio_enosys,
+ ramfs_fo_dirlseek,
+ (cyg_fileop_ioctl *)cyg_fileio_enosys,
+ cyg_fileio_seltrue,
+ (cyg_fileop_fsync *)cyg_fileio_enosys,
+ ramfs_fo_close,
+ (cyg_fileop_fstat *)cyg_fileio_enosys,
+ (cyg_fileop_getinfo *)cyg_fileio_enosys,
+ (cyg_fileop_setinfo *)cyg_fileio_enosys
+}; |
If the filesystem wants to have an instance automatically mounted on +system startup, it must also define a mount table entry. This is done +with the MTAB_ENTRY macro. This is an example from +the test filesystem of how this is used:
MTAB_ENTRY( testfs_mte1, + "/", + "testfs", + "", + 0); |
The first argument provides a name for the table entry. The following +arguments provide initialization for the +name, fsname, +devname and data +fields respectively.
These definitions are adequate to let the new filesystem interact +with the FILEIO package. The new filesystem now needs to be fleshed +out with implementations of the functions defined above. Obviously, +the exact form this takes will depend on what the filesystem is +intended to do. Take a look at the RAM and ROM filesystems for +examples of how this has been done.