struct libmnt_fs

struct libmnt_fs;

Parsed fstab/mtab/mountinfo entry

mnt_copy_fs ()

struct libmnt_fs *  mnt_copy_fs                         (struct libmnt_fs *dest,
                                                         const struct libmnt_fs *src);

If dest is NULL, then a new FS is allocated, if any dest field is already set, then the field is NOT overwritten.

This function does not copy userdata (se mnt_fs_set_userdata()). A new copy is not linked with any existing mnt_tab.

mnt_free_fs ()

void                mnt_free_fs                         (struct libmnt_fs *fs);

Deallocates the fs. This function does not care about reference count. Don't use this function directly -- it's better to use use mnt_unref_fs().

The reference counting is supported since util-linux v2.24.

mnt_free_mntent ()

void                mnt_free_mntent                     (struct mntent *mnt);

Deallocates the "mntent.h" mount entry.

mnt_ref_fs ()

void                mnt_ref_fs                          (struct libmnt_fs *fs);

Increments reference counter.

mnt_unref_fs ()

void                mnt_unref_fs                        (struct libmnt_fs *fs);

De-increments reference counter, on zero the fs is automatically deallocated by mnt_free_fs().

mnt_fs_append_attributes ()

int                 mnt_fs_append_attributes            (struct libmnt_fs *fs,
                                                         const char *optstr);

Appends mount attributes. (See mnt_fs_set_attributes()).

mnt_fs_append_comment ()

int                 mnt_fs_append_comment               (struct libmnt_fs *fs,
                                                         const char *comm);

See also mnt_fs_set_comment().

mnt_fs_append_options ()

int                 mnt_fs_append_options               (struct libmnt_fs *fs,
                                                         const char *optstr);

Parses (splits) optstr and appends results to VFS, FS and userspace lists of options.

If optstr is NULL, then fs is not modified and 0 is returned.

mnt_fs_get_attribute ()

int                 mnt_fs_get_attribute                (struct libmnt_fs *fs,
                                                         const char *name,
                                                         char **value,
                                                         size_t *valsz);

mnt_fs_get_attributes ()

const char *        mnt_fs_get_attributes               (struct libmnt_fs *fs);

mnt_fs_get_bindsrc ()

const char *        mnt_fs_get_bindsrc                  (struct libmnt_fs *fs);

mnt_fs_get_comment ()

const char *        mnt_fs_get_comment                  (struct libmnt_fs *fs);

mnt_fs_get_devno ()

dev_t               mnt_fs_get_devno                    (struct libmnt_fs *fs);

mnt_fs_get_freq ()

int                 mnt_fs_get_freq                     (struct libmnt_fs *fs);

mnt_fs_get_fs_options ()

const char *        mnt_fs_get_fs_options               (struct libmnt_fs *fs);

mnt_fs_get_fstype ()

const char *        mnt_fs_get_fstype                   (struct libmnt_fs *fs);

mnt_fs_get_id ()

int                 mnt_fs_get_id                       (struct libmnt_fs *fs);

mnt_fs_get_option ()

int                 mnt_fs_get_option                   (struct libmnt_fs *fs,
                                                         const char *name,
                                                         char **value,
                                                         size_t *valsz);

mnt_fs_get_optional_fields ()

const char *        mnt_fs_get_optional_fields          (struct libmnt_fs *fs);

mnt_fs_get_options ()

const char *        mnt_fs_get_options                  (struct libmnt_fs *fs);

mnt_fs_get_parent_id ()

int                 mnt_fs_get_parent_id                (struct libmnt_fs *fs);

mnt_fs_get_passno ()

int                 mnt_fs_get_passno                   (struct libmnt_fs *fs);

mnt_fs_get_priority ()

int                 mnt_fs_get_priority                 (struct libmnt_fs *fs);

mnt_fs_get_propagation ()

int                 mnt_fs_get_propagation              (struct libmnt_fs *fs,
                                                         unsigned long *flags);

Note that this function sets flags to zero if no propagation flags are found in the mountinfo file. The kernel default is MS_PRIVATE, this flag is not stored in the mountinfo file.

mnt_fs_get_root ()

const char *        mnt_fs_get_root                     (struct libmnt_fs *fs);

mnt_fs_get_size ()

off_t               mnt_fs_get_size                     (struct libmnt_fs *fs);

mnt_fs_get_source ()

const char *        mnt_fs_get_source                   (struct libmnt_fs *fs);

mnt_fs_get_srcpath ()

const char *        mnt_fs_get_srcpath                  (struct libmnt_fs *fs);

The mount "source path" is:

See also mnt_fs_get_tag() and mnt_fs_get_source().

mnt_fs_get_swaptype ()

const char *        mnt_fs_get_swaptype                 (struct libmnt_fs *fs);

mnt_fs_get_tag ()

int                 mnt_fs_get_tag                      (struct libmnt_fs *fs,
                                                         const char **name,
                                                         const char **value);

"TAG" is NAME=VALUE (e.g. LABEL=foo)

The TAG is the first column in the fstab file. The TAG or "srcpath" always has to be set for all entries.

See also mnt_fs_get_source().

1
2
3
4
5
6
7
8
9
10
11
12
13

char *src;
struct libmnt_fs *fs = mnt_table_find_target(tb, "/home", MNT_ITER_FORWARD);

if (!fs)
    goto err;

src = mnt_fs_get_srcpath(fs);
if (!src) {
    char *tag, *val;
    if (mnt_fs_get_tag(fs, &tag, &val) == 0)
        printf("%s: %s\n", tag, val);   // LABEL or UUID
} else
    printf("device: %s\n", src);        // device or bind path

mnt_fs_get_target ()

const char *        mnt_fs_get_target                   (struct libmnt_fs *fs);

mnt_fs_get_tid ()

pid_t               mnt_fs_get_tid                      (struct libmnt_fs *fs);

mnt_fs_get_usedsize ()

off_t               mnt_fs_get_usedsize                 (struct libmnt_fs *fs);

mnt_fs_get_userdata ()

void *              mnt_fs_get_userdata                 (struct libmnt_fs *fs);

mnt_fs_get_user_options ()

const char *        mnt_fs_get_user_options             (struct libmnt_fs *fs);

mnt_fs_get_vfs_options ()

const char *        mnt_fs_get_vfs_options              (struct libmnt_fs *fs);

mnt_fs_is_kernel ()

int                 mnt_fs_is_kernel                    (struct libmnt_fs *fs);

mnt_fs_is_netfs ()

int                 mnt_fs_is_netfs                     (struct libmnt_fs *fs);

mnt_fs_is_pseudofs ()

int                 mnt_fs_is_pseudofs                  (struct libmnt_fs *fs);

mnt_fs_is_swaparea ()

int                 mnt_fs_is_swaparea                  (struct libmnt_fs *fs);

mnt_fs_match_fstype ()

int                 mnt_fs_match_fstype                 (struct libmnt_fs *fs,
                                                         const char *types);

For more details see mnt_match_fstype().

mnt_fs_match_options ()

int                 mnt_fs_match_options                (struct libmnt_fs *fs,
                                                         const char *options);

For more details see mnt_match_options().

mnt_fs_match_source ()

int                 mnt_fs_match_source                 (struct libmnt_fs *fs,
                                                         const char *source,
                                                         struct libmnt_cache *cache);

Four attempts are possible: 1) compare source with fs->source 2) compare realpath(source) with fs->source 3) compare realpath(source) with realpath(fs->source) 4) compare realpath(source) with evaluated tag from fs->source

The 2nd, 3rd and 4th attempts are not performed when cache is NULL. The 2nd and 3rd attempts are not performed if fs->source is tag.

mnt_fs_match_target ()

int                 mnt_fs_match_target                 (struct libmnt_fs *fs,
                                                         const char *target,
                                                         struct libmnt_cache *cache);

Possible are three attempts: 1) compare target with fs->target

2) realpath(target) with fs->target

3) realpath(target) with realpath(fs->target) if fs is not from /proc/self/mountinfo.

However, if mnt_cache_set_targets(cache, mtab) was called, and the path target or fs->target is found in the mtab, the canonicalization is is not performed (see mnt_resolve_target()).

The 2nd and 3rd attempts are not performed when cache is NULL.

mnt_fs_prepend_attributes ()

int                 mnt_fs_prepend_attributes           (struct libmnt_fs *fs,
                                                         const char *optstr);

Prepends mount attributes. (See mnt_fs_set_attributes()).

mnt_fs_prepend_options ()

int                 mnt_fs_prepend_options              (struct libmnt_fs *fs,
                                                         const char *optstr);

Parses (splits) optstr and prepends the results to VFS, FS and userspace lists of options.

If optstr is NULL, then fs is not modified and 0 is returned.

mnt_fs_print_debug ()

int                 mnt_fs_print_debug                  (struct libmnt_fs *fs,
                                                         FILE *file);

mnt_fs_set_attributes ()

int                 mnt_fs_set_attributes               (struct libmnt_fs *fs,
                                                         const char *optstr);

Sets mount attributes. The attributes are mount(2) and mount(8) independent options, these options are not sent to the kernel and are not interpreted by libmount. The attributes are stored in /run/mount/utab only.

The attributes are managed by libmount in userspace only. It's possible that information stored in userspace will not be available for libmount after CLONE_FS unshare. Be careful, and don't use attributes if possible.

mnt_fs_set_bindsrc ()

int                 mnt_fs_set_bindsrc                  (struct libmnt_fs *fs,
                                                         const char *src);

mnt_fs_set_comment ()

int                 mnt_fs_set_comment                  (struct libmnt_fs *fs,
                                                         const char *comm);

Note that the comment has to be terminated by '\n' (new line), otherwise the whole filesystem entry will be written as a comment to the tabfile (e.g. fstab).

mnt_fs_set_freq ()

int                 mnt_fs_set_freq                     (struct libmnt_fs *fs,
                                                         int freq);

mnt_fs_set_fstype ()

int                 mnt_fs_set_fstype                   (struct libmnt_fs *fs,
                                                         const char *fstype);

This function creates a private copy (strdup()) of fstype.

mnt_fs_set_options ()

int                 mnt_fs_set_options                  (struct libmnt_fs *fs,
                                                         const char *optstr);

Splits optstr to VFS, FS and userspace mount options and updates relevant parts of fs.

mnt_fs_set_passno ()

int                 mnt_fs_set_passno                   (struct libmnt_fs *fs,
                                                         int passno);

mnt_fs_set_root ()

int                 mnt_fs_set_root                     (struct libmnt_fs *fs,
                                                         const char *root);

mnt_fs_set_source ()

int                 mnt_fs_set_source                   (struct libmnt_fs *fs,
                                                         const char *source);

This function creates a private copy (strdup()) of source.

mnt_fs_set_target ()

int                 mnt_fs_set_target                   (struct libmnt_fs *fs,
                                                         const char *target);

This function creates a private copy (strdup()) of target.

mnt_fs_set_userdata ()

int                 mnt_fs_set_userdata                 (struct libmnt_fs *fs,
                                                         void *data);

The "userdata" are library independent data.

mnt_fs_strdup_options ()

char *              mnt_fs_strdup_options               (struct libmnt_fs *fs);

Merges all mount options (VFS, FS and userspace) to one options string and returns the result. This function does not modigy fs.

mnt_fs_streq_srcpath ()

int                 mnt_fs_streq_srcpath                (struct libmnt_fs *fs,
                                                         const char *path);

Compares fs source path with path. The trailing slash is ignored. See also mnt_fs_match_source().

mnt_fs_streq_target ()

int                 mnt_fs_streq_target                 (struct libmnt_fs *fs,
                                                         const char *path);

Compares fs target path with path. The trailing slash is ignored. See also mnt_fs_match_target().

mnt_fs_to_mntent ()

int                 mnt_fs_to_mntent                    (struct libmnt_fs *fs,
                                                         struct mntent **mnt);

Copies the information from fs to struct mntent mnt. If mnt is already set, then the struct mntent items are reallocated and updated. See also mnt_free_mntent().

mnt_new_fs ()

struct libmnt_fs *  mnt_new_fs                          (void);

The initial refcount is 1, and needs to be decremented to release the resources of the filesystem.

mnt_reset_fs ()

void                mnt_reset_fs                        (struct libmnt_fs *fs);

Resets (zeroize) fs.