eCos Reference Manual
Prev |  | Next

# Chapter 29. Writing a New Filesystem

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.

Prev | Home | Next
Devices | Up | PCI Library