GNU Info
(libc.info)mtab
The `mtab' file
...............
The following functions and data structure access the `mtab' file.
- Data Type: struct mntent
This structure is used with the `getmntent', `getmntent_t',
`addmntent', and `hasmntopt' functions.
`char *mnt_fsname'
This element contains a pointer to a string describing the
name of the special device from which the filesystem is
mounted. It corresponds to the `fs_spec' element in `struct
fstab'.
`char *mnt_dir'
This element points to a string describing the mount point of
the filesystem. It corresponds to the `fs_file' element in
`struct fstab'.
`char *mnt_type'
`mnt_type' describes the filesystem type and is therefore
equivalent to `fs_vfstype' in `struct fstab'. `mntent.h'
defines a few symbolic names for some of the values this
string can have. But since the kernel can support arbitrary
filesystems it does not make much sense to give them symbolic
names. If one knows the symbol name one also knows the
filesystem name. Nevertheless here follows the list of the
symbols provided in `mntent.h'.
`MNTTYPE_IGNORE'
This symbol expands to `"ignore"'. The value is
sometime used in `fstab' files to make sure entries are
not used without removing them.
`MNTTYPE_NFS'
Expands to `"nfs"'. Using this macro sometimes could
make sense since it names the default NFS
implementation, in case both version 2 and 3 are
supported.
`MNTTYPE_SWAP'
This symbol expands to `"swap"'. It names the special
`fstab' entry which names one of the possibly multiple
swap partitions.
`char *mnt_opts'
The element contains a string describing the options used
while mounting the filesystem. As for the equivalent element
`fs_mntops' of `struct fstab' it is best to use the function
`getsubopt' (Note: Suboptions) to access the parts of this
string.
The `mntent.h' file defines a number of macros with string
values which correspond to some of the options understood by
the kernel. There might be many more options which are
possible so it doesn't make much sense to rely on these
macros but to be consistent here is the list:
`MNTOPT_DEFAULTS'
Expands to `"defaults"'. This option should be used
alone since it indicates all values for the customizable
values are chosen to be the default.
`MNTOPT_RO'
Expands to `"ro"'. See the `FSTAB_RO' value, it means
the filesystem is mounted read-only.
`MNTOPT_RW'
Expand to `"rw"'. See the `FSTAB_RW' value, it means the
filesystem is mounted with read and write permissions.
`MNTOPT_SUID'
Expands to `"suid"'. This means that the SUID bit
(Note: How Change Persona) is respected when a program
from the filesystem is started.
`MNTOPT_NOSUID'
Expands to `"nosuid"'. This is the opposite of
`MNTOPT_SUID', the SUID bit for all files from the
filesystem is ignored.
`MNTOPT_NOAUTO'
Expands to `"noauto"'. At startup time the `mount'
program will ignore this entry if it is started with the
`-a' option to mount all filesystems mentioned in the
`fstab' file.
As for the `FSTAB_*' entries introduced above it is important
to use `strcmp' to check for equality.
`mnt_freq'
This elements corresponds to `fs_freq' and also specifies the
frequency in days in which dumps are made.
`mnt_passno'
This element is equivalent to `fs_passno' with the same
meaning which is uninteresting for all programs beside `dump'.
For accessing the `mtab' file there is again a set of three
functions to access all entries in a row. Unlike the functions to
handle `fstab' these functions do not access a fixed file and there is
even a thread safe variant of the get function. Beside this the GNU
libc contains functions to alter the file and test for specific options.
- Function: FILE * setmntent (const char *FILE, const char *MODE)
The `setmntent' function prepares the file named FILE which must
be in the format of a `fstab' and `mtab' file for the upcoming
processing through the other functions of the family. The MODE
parameter can be chosen in the way the OPENTYPE parameter for
`fopen' (Note: Opening Streams) can be chosen. If the file is
opened for writing the file is also allowed to be empty.
If the file was successfully opened `setmntent' returns a file
descriptor for future use. Otherwise the return value is `NULL'
and `errno' is set accordingly.
- Function: int endmntent (FILE *STREAM)
This function takes for the STREAM parameter a file handle which
previously was returned from the `setmntent' call. `endmntent'
closes the stream and frees all resources.
The return value is 1 unless an error occurred in which case it is
0.
- Function: struct mntent * getmntent (FILE *STREAM)
The `getmntent' function takes as the parameter a file handle
previously returned by successful call to `setmntent'. It returns
a pointer to a static variable of type `struct mntent' which is
filled with the information from the next entry from the file
currently read.
The file format used prescribes the use of spaces or tab
characters to separate the fields. This makes it harder to use
name containing one of these characters (e.g., mount points using
spaces). Therefore these characters are encoded in the files and
the `getmntent' function takes care of the decoding while reading
the entries back in. `'\040'' is used to encode a space
character, `'\012'' to encode a tab character and `'\\'' to encode
a backslash.
If there was an error or the end of the file is reached the return
value is `NULL'.
This function is not thread-safe since all calls to this function
return a pointer to the same static variable. `getmntent_r'
should be used in situations where multiple threads access the
file.
- Function: struct mntent * getmntent_r (FILE *STREAM, struct mentent
*RESULT, char *BUFFER, int BUFSIZE)
The `getmntent_r' function is the reentrant variant of
`getmntent'. It also returns the next entry from the file and
returns a pointer. The actual variable the values are stored in
is not static, though. Instead the function stores the values in
the variable pointed to by the RESULT parameter. Additional
information (e.g., the strings pointed to by the elements of the
result) are kept in the buffer of size BUFSIZE pointed to by
BUFFER.
Escaped characters (space, tab, backslash) are converted back in
the same way as it happens for `getmentent'.
The function returns a `NULL' pointer in error cases. Errors
could be:
* error while reading the file,
* end of file reached,
* BUFSIZE is too small for reading a complete new entry.
- Function: int addmntent (FILE *STREAM, const struct mntent *MNT)
The `addmntent' function allows adding a new entry to the file
previously opened with `setmntent'. The new entries are always
appended. I.e., even if the position of the file descriptor is
not at the end of the file this function does not overwrite an
existing entry following the current position.
The implication of this is that to remove an entry from a file one
has to create a new file while leaving out the entry to be removed
and after closing the file remove the old one and rename the new
file to the chosen name.
This function takes care of spaces and tab characters in the names
to be written to the file. It converts them and the backslash
character into the format describe in the `getmntent' description
above.
This function returns 0 in case the operation was successful.
Otherwise the return value is 1 and `errno' is set appropriately.
- Function: char * hasmntopt (const struct mntent *MNT, const char
*OPT)
This function can be used to check whether the string pointed to
by the `mnt_opts' element of the variable pointed to by MNT
contains the option OPT. If this is true a pointer to the
beginning of the option in the `mnt_opts' element is returned. If
no such option exists the function returns `NULL'.
This function is useful to test whether a specific option is
present but when all options have to be processed one is better
off with using the `getsubopt' function to iterate over all
options in the string.
automatically generated by info2www version 1.2.2.9