eCos Reference Manual
Prev |  | Next

# Chapter 20. Initialization and Mounting

As mentioned previously, mount table entries can be sourced from two places. Static entries may be defined by using the MTAB_ENTRY() macro. Such entries will be automatically mounted on system startup. For each entry in the mount table that has a non-null `name` field the filesystem table is searched for a match with the `fsname` field. If a match is found the filesystem's `mount` entry is called and if successful the mount table entry marked valid and the `fs` field initialized. The `mount()` function is responsible for initializing the `root` field.

The size of the mount table is defined by the configuration value CYGNUM_FILEIO_MTAB_MAX. Any entries that have not been statically defined are available for use by dynamic mounts.

A filesystem may be mounted dynamically by calling `mount()`. This function has the following prototype:

    int mount( const char *devname,
               const char *dir,
    	   const char *fsname);

The devname argument identifies a device that will be used by this filesystem and will be assigned to the `devname` field of the mount table entry.

The dir argument is the mount point name, it will be assigned to the `name` field of the mount table entry.

The fsname argument is the name of the implementing filesystem, it will be assigned to the `fsname` entry of the mount table entry. This argument may also contain options that control the mode in which the filesystem is mounted.

Since these three arguments are assigned directly to the mount table entry, the memory pointed to by these arguments must not change for the duration of the mount. This means they must be allocated from memory that will persist unchanged until unmounting, such as constant strings, dynamically allocated memory, or static or automatic variables that do not pass out of scope or get their values changed before unmounting.

The options attached to the fsname argument consist of a comma separated list of single keywords or keyword=value pairs separated from the filesystem name by a colon. For example, to mount the FAT filesystem with write-through cache synchronization the string would be: "fatfs:sync=write" and to mount it read-only: "fatfs:readonly".

The process of mounting a filesystem dynamically is as follows. First a search is made of the mount table for an entry with a NULL `name` field to be used for the new mount point. The filesystem table is then searched for an entry whose name matches `fsname`. If this is successful then the mount table entry is initialized and the filesystem's `mount()` operation called. If this is successful, the mount table entry is marked valid and the `fs` field initialized.

Mounting a filesystem dynamically at the current working directory name, does not in fact change the current directory to one on the newly mounted filesystem. Instead the current working directory remains on the previous filesystem (or no filesystem in the case of '/' with no filesystems previously mounted). This is in line with usual POSIX/UNIX behaviour. To change to the new filesystem, a `chdir()` call must be made, even if it is to the current directory name as given by `getcwd()`. This is especially relevant when mounting a filesystem on '/' as the current working directory is usually also '/' .

It should also be noted that there is no requirement for there to be a directory entry for a filesystem mount point if mounted within another filesystem. So for example, there need not be a directory named “`/dev`” in the directory list of “`/`” even though there is a filesystem mounted on “`/dev`”.

Unmounting a filesystem is done by the `umount()` function. This can unmount filesystems whether they were mounted statically or dynamically.

The `umount()` function has the following prototype:

    int umount( const char *name );

The mount table is searched for a match between the name argument and the entry `name` field. When a match is found the filesystem's `umount()` operation, with the force argument set to false is called and if successful, the mount table entry is invalidated by setting its `valid` field false and the `name` field to NULL.

There is also an `umount_force()` function with the following prototype:

    int umount( const char *name );

The main difference between this and the standard `umount()` function is that it forces the filesystem to be unmounted. In the FILEIO package this means that all open files will be forced to close, the current directory will be moved away from the filesystem if it points to it and any threads waiting for access to the filesystem will be forced to return. When the filesystem's `umount()` function is called, the force argument will be set true, and the filesystem should take steps to free all resources and detach from the underlying device.

Care must be taken if mounting a filesystem on “`/`” as it will not be possible to unmount the filesystem later if it is in use as the current working directory. Instead it will be necessary to change directory to a different filesystem before unmounting.

Prev | Home | Next
Synchronization | Up | Automounter