struct libmnt_table

struct libmnt_table;

List of struct libmnt_fs entries (parsed fstab/mtab/mountinfo)

mnt_free_table ()

void                mnt_free_table                      (struct libmnt_table *tb);

Deallocates tab struct and all entries.

mnt_new_table ()

struct libmnt_table * mnt_new_table                     (void);

The tab is a container for struct libmnt_fs entries that usually represents a fstab, mtab or mountinfo file from your system.

See also mnt_table_parse_file().

mnt_reset_table ()

int                 mnt_reset_table                     (struct libmnt_table *tb);

Dealocates all entries (filesystems) from the table

mnt_new_table_from_dir ()

struct libmnt_table * mnt_new_table_from_dir            (const char *dirname);

mnt_new_table_from_file ()

struct libmnt_table * mnt_new_table_from_file           (const char *filename);

Same as mnt_new_table() + mnt_table_parse_file(). Use this function for private files only. This function does not allow to use error callback, so you cannot provide any feedback to end-users about broken records in files (e.g. fstab).

mnt_table_add_fs ()

int                 mnt_table_add_fs                    (struct libmnt_table *tb,
                                                         struct libmnt_fs *fs);

Adds a new entry to tab.

mnt_table_find_devno ()

struct libmnt_fs *  mnt_table_find_devno                (struct libmnt_table *tb,
                                                         dev_t devno,
                                                         int direction);

Note that zero could be valid device number for root pseudo filesystem (e.g. tmpfs).

mnt_table_find_next_fs ()

int                 mnt_table_find_next_fs              (struct libmnt_table *tb,
                                                         struct libmnt_iter *itr,
                                                         int (*match_func) (struct libmnt_fs *, void *),
                                                         void *userdata,
                                                         struct libmnt_fs **fs);

This function allows search in tb.

mnt_table_find_pair ()

struct libmnt_fs *  mnt_table_find_pair                 (struct libmnt_table *tb,
                                                         const char *source,
                                                         const char *target,
                                                         int direction);

This function is implemented by mnt_fs_match_source() and mnt_fs_match_target() functions. It means that this is more expensive that others mnt_table_find_* function, because every tab entry is fully evaluated.

mnt_table_find_source ()

struct libmnt_fs *  mnt_table_find_source               (struct libmnt_table *tb,
                                                         const char *source,
                                                         int direction);

This is high-level API for mnt_table_find_{srcpath,tag}. You needn't to care about source format (device, LABEL, UUID, ...). This function parses source and calls mnt_table_find_tag() or mnt_table_find_srcpath().

mnt_table_find_srcpath ()

struct libmnt_fs *  mnt_table_find_srcpath              (struct libmnt_table *tb,
                                                         const char *path,
                                                         int direction);

Try to lookup an entry in given tab, possible are four iterations, first with path, second with realpath(path), third with tags (LABEL, UUID, ..) from path and fourth with realpath(path) against realpath(entry->srcpath).

The 2nd, 3rd and 4th iterations are not performed when tb cache is not set (see mnt_table_set_cache()).

Note that NULL is a valid source path; it will be replaced with "none". The "none" is used in /proc/{mounts,self/mountinfo} for pseudo filesystems.

mnt_table_find_tag ()

struct libmnt_fs *  mnt_table_find_tag                  (struct libmnt_table *tb,
                                                         const char *tag,
                                                         const char *val,
                                                         int direction);

Try to lookup an entry in given tab, first attempt is lookup by tag and val, for the second attempt the tag is evaluated (converted to the device name) and mnt_table_find_srcpath() is preformed. The second attempt is not performed when tb cache is not set (see mnt_table_set_cache()).

mnt_table_find_target ()

struct libmnt_fs *  mnt_table_find_target               (struct libmnt_table *tb,
                                                         const char *path,
                                                         int direction);

Try to lookup an entry in given tab, possible are three iterations, first with path, second with realpath(path) and third with realpath(path) against realpath(fs->target). The 2nd and 3rd iterations are not performed when tb cache is not set (see mnt_table_set_cache()).

mnt_table_get_cache ()

struct libmnt_cache * mnt_table_get_cache               (struct libmnt_table *tb);

mnt_table_get_nents ()

int                 mnt_table_get_nents                 (struct libmnt_table *tb);

mnt_table_get_root_fs ()

int                 mnt_table_get_root_fs               (struct libmnt_table *tb,
                                                         struct libmnt_fs **root);

The function uses parent ID from mountinfo file to determine root filesystem (the filesystem with the smallest ID). The function is designed mostly for applications where is necessary to sort mountpoints by IDs to get the tree of the mountpoints (e.g. findmnt default output).

If you're not sure than use

mnt_table_find_target(tb, "/", MNT_ITER_BACKWARD);

this is more robust and usable for arbitrary tab file (including fstab).

mnt_table_is_fs_mounted ()

int                 mnt_table_is_fs_mounted             (struct libmnt_table *tb,
                                                         struct libmnt_fs *fstab_fs);

mnt_table_next_child_fs ()

int                 mnt_table_next_child_fs             (struct libmnt_table *tb,
                                                         struct libmnt_iter *itr,
                                                         struct libmnt_fs *parent,
                                                         struct libmnt_fs **chld);

Note that filesystems are returned in the order how was mounted (according to IDs in /proc/self/mountinfo).

mnt_table_next_fs ()

int                 mnt_table_next_fs                   (struct libmnt_table *tb,
                                                         struct libmnt_iter *itr,
                                                         struct libmnt_fs **fs);

1
2
3
4
5

while(mnt_table_next_fs(tb, itr, &fs) == 0) {
const char *dir = mnt_fs_get_target(fs);
printf("mount point: %s\n", dir);
}
mnt_free_table(fi);

mnt_table_parse_dir ()

int                 mnt_table_parse_dir                 (struct libmnt_table *tb,
                                                         const char *dirname);

The directory:

mnt_table_parse_file ()

int                 mnt_table_parse_file                (struct libmnt_table *tb,
                                                         const char *filename);

Parses whole table (e.g. /etc/mtab) and appends new records to the tab.

The libmount parser ignores broken (syntax error) lines, these lines are reported to caller by errcb() function (see mnt_table_set_parser_errcb()).

mnt_table_parse_fstab ()

int                 mnt_table_parse_fstab               (struct libmnt_table *tb,
                                                         const char *filename);

This function parses /etc/fstab and appends new lines to the tab. If the filename is a directory then mnt_table_parse_dir() is called.

See also mnt_table_set_parser_errcb().

mnt_table_parse_mtab ()

int                 mnt_table_parse_mtab                (struct libmnt_table *tb,
                                                         const char *filename);

This function parses /etc/mtab or /proc/self/mountinfo + /run/mount/utabs or /proc/mounts.

See also mnt_table_set_parser_errcb().

mnt_table_parse_stream ()

int                 mnt_table_parse_stream              (struct libmnt_table *tb,
                                                         FILE *f,
                                                         const char *filename);

mnt_table_parse_swaps ()

int                 mnt_table_parse_swaps               (struct libmnt_table *tb,
                                                         const char *filename);

This function parses /proc/swaps and appends new lines to the tab.

See also mnt_table_set_parser_errcb().

mnt_table_remove_fs ()

int                 mnt_table_remove_fs                 (struct libmnt_table *tb,
                                                         struct libmnt_fs *fs);

mnt_table_set_cache ()

int                 mnt_table_set_cache                 (struct libmnt_table *tb,
                                                         struct libmnt_cache *mpc);

Setups a cache for canonicalized paths and evaluated tags (LABEL/UUID). The cache is recommended for mnt_table_find_*() functions.

The cache could be shared between more tabs. Be careful when you share the same cache between more threads -- currently the cache does not provide any locking method.

See also mnt_new_cache().

mnt_table_set_iter ()

int                 mnt_table_set_iter                  (struct libmnt_table *tb,
                                                         struct libmnt_iter *itr,
                                                         struct libmnt_fs *fs);

Sets iter to the position of fs in the file tb.

mnt_table_set_parser_errcb ()

int                 mnt_table_set_parser_errcb          (struct libmnt_table *tb,
                                                         int (*cb) (struct libmnt_table *tb, const char *filename, int line));

The error callback function is called by table parser (mnt_table_parse_file()) in case of syntax error. The callback function could be used for errors evaluation, libmount will continue/stop parsing according to callback return codes:

<0 : fatal error (abort parsing) 0 : success (parsing continue) >0 : recoverable error (the line is ignored, parsing continue).