1/* SPDX-License-Identifier: LGPL-2.1-or-later */
2/*
3 * libmount.h - libmount API
4 *
5 * This file is part of libmount from util-linux project.
6 *
7 * Copyright (C) 2008-2018 Karel Zak <kzak@redhat.com>
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 */
23
24#ifndef _LIBMOUNT_MOUNT_H
25#define _LIBMOUNT_MOUNT_H
26
27#ifdef __cplusplus
28extern "C" {
29#endif
30
31#include <stdio.h>
32#include <mntent.h>
33#include <sys/types.h>
34
35/* Make sure libc MS_* definitions are used by default. Note that MS_* flags
36 * may be already defined by linux/fs.h or another file -- in this case we
37 * don't want to include sys/mount.h at all to avoid collisions.
38 */
39#if defined(__linux__) && !defined(MS_RDONLY)
40# include <sys/mount.h>
41#endif
42
43#define LIBMOUNT_VERSION "2.37.2"
44#define LIBMOUNT_MAJOR_VERSION 2
45#define LIBMOUNT_MINOR_VERSION 37
46#define LIBMOUNT_PATCH_VERSION 2
47
48/**
49 * libmnt_cache:
50 *
51 * Stores canonicalized paths and evaluated tags
52 */
53struct libmnt_cache;
54
55/**
56 * libmnt_lock:
57 *
58 * Stores information about the locked file (e.g. /etc/mtab)
59 */
60struct libmnt_lock;
61
62/**
63 * libmnt_iter:
64 *
65 * Generic iterator (stores state about lists)
66 */
67struct libmnt_iter;
68
69/**
70 * libmnt_optmap:
71 * @name: option name[=type] where type is printf-like type specifier")
72 * @id: option ID or MS_* flags (e.g MS_RDONLY)
73 * @mask: MNT_{NOMTAB,INVERT,...} mask
74 *
75 * Mount options description (map)
76 */
77struct libmnt_optmap
78{
79 const char *name;
80 int id;
81 int mask;
82};
83
84/*
85 * mount options map masks
86 */
87#define MNT_INVERT (1 << 1) /* invert the mountflag */
88#define MNT_NOMTAB (1 << 2) /* skip in the mtab option string */
89#define MNT_PREFIX (1 << 3) /* prefix used for some options (e.g. "x-foo") */
90#define MNT_NOHLPS (1 << 4) /* don't add the option to mount.<type> helpers command line */
91
92/**
93 * libmnt_fs:
94 *
95 * Parsed fstab/mtab/mountinfo entry
96 */
97struct libmnt_fs;
98
99/**
100 * libmnt_table:
101 *
102 * List of struct libmnt_fs entries (parsed fstab/mtab/mountinfo)
103 */
104struct libmnt_table;
105
106/**
107 * libmnt_update
108 *
109 * /etc/mtab or utab update description
110 */
111struct libmnt_update;
112
113/**
114 * libmnt_context
115 *
116 * Mount/umount status
117 */
118struct libmnt_context;
119
120/**
121 * libmnt_monitor
122 *
123 * Mount tables monitor
124 */
125struct libmnt_monitor;
126
127/**
128 * libmnt_tabdiff:
129 *
130 * Stores mountinfo state
131 */
132struct libmnt_tabdiff;
133
134/**
135 * libmnt_ns:
136 *
137 * Describes mount namespace
138 */
139struct libmnt_ns;
140
141/*
142 * Actions
143 */
144enum {
145 MNT_ACT_MOUNT = 1,
146 MNT_ACT_UMOUNT
147};
148
149/*
150 * Errors -- by default libmount returns -errno for generic errors (ENOMEM,
151 * EINVAL, ...) and for mount(2) errors, but for some specific operations it
152 * returns private error codes. Note that maximum system errno value should be
153 * 4095 on UNIXes.
154 *
155 * See also mnt_context_get_syscall_errno() and mnt_context_get_helper_status().
156 */
157/**
158 * MNT_ERR_NOFSTAB:
159 *
160 * not found required entry in fstab
161 */
162#define MNT_ERR_NOFSTAB 5000
163/**
164 * MNT_ERR_NOFSTYPE:
165 *
166 * failed to detect filesystem type
167 */
168#define MNT_ERR_NOFSTYPE 5001
169/**
170 * MNT_ERR_NOSOURCE:
171 *
172 * required mount source undefined
173 */
174#define MNT_ERR_NOSOURCE 5002
175/**
176 * MNT_ERR_LOOPDEV:
177 *
178 * loopdev setup failed, errno set by libc
179 */
180#define MNT_ERR_LOOPDEV 5003
181/**
182 * MNT_ERR_MOUNTOPT:
183 *
184 * failed to parse/use userspace mount options
185 */
186#define MNT_ERR_MOUNTOPT 5004
187/**
188 * MNT_ERR_APPLYFLAGS:
189 *
190 * failed to apply MS_PROPAGATION flags
191 */
192#define MNT_ERR_APPLYFLAGS 5005
193/**
194 * MNT_ERR_AMBIFS:
195 *
196 * libblkid detected more filesystems on the device
197 */
198#define MNT_ERR_AMBIFS 5006
199/**
200 * MNT_ERR_LOOPOVERLAP:
201 *
202 * detected overlapping loop device that cannot be re-used
203 */
204#define MNT_ERR_LOOPOVERLAP 5007
205/**
206 * MNT_ERR_LOCK:
207 *
208 * failed to lock mtab/utab or so.
209 */
210#define MNT_ERR_LOCK 5008
211/**
212 * MNT_ERR_NAMESPACE:
213 *
214 * failed to switch namespace
215 */
216#define MNT_ERR_NAMESPACE 5009
217
218
219/*
220 * Overall return codes -- based on mount(8) and umount(8) return codes.
221 * See mnt_context_get_excode() for more details.
222 */
223
224/**
225 * MNT_EX_SUCCESS:
226 *
227 * [u]mount(8) exit code: no errors
228 */
229#define MNT_EX_SUCCESS 0
230
231/**
232 * MNT_EX_USAGE:
233 *
234 * [u]mount(8) exit code: incorrect invocation or permission
235 */
236#define MNT_EX_USAGE 1
237
238/**
239 * MNT_EX_SYSERR:
240 *
241 * [u]mount(8) exit code: out of memory, cannot fork, ...
242 */
243
244#define MNT_EX_SYSERR 2
245
246/**
247 * MNT_EX_SOFTWARE:
248 *
249 * [u]mount(8) exit code: internal mount bug or wrong version
250 */
251#define MNT_EX_SOFTWARE 4
252
253/**
254 * MNT_EX_USER:
255 *
256 * [u]mount(8) exit code: user interrupt
257 */
258#define MNT_EX_USER 8
259
260/**
261 * MNT_EX_FILEIO:
262 *
263 * [u]mount(8) exit code: problems writing, locking, ... mtab/utab
264 */
265#define MNT_EX_FILEIO 16
266
267/**
268 * MNT_EX_FAIL:
269 *
270 * [u]mount(8) exit code: mount failure
271 */
272#define MNT_EX_FAIL 32
273
274/**
275 * MNT_EX_SOMEOK:
276 *
277 * [u]mount(8) exit code: some mount succeeded; usually when executed with
278 * --all options. Never returned by libmount.
279 */
280#define MNT_EX_SOMEOK 64
281
282
283
284#ifndef __GNUC_PREREQ
285# if defined __GNUC__ && defined __GNUC_MINOR__
286# define __GNUC_PREREQ(maj, min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
287# else
288# define __GNUC_PREREQ(maj, min) 0
289# endif
290#endif
291
292#ifndef __ul_attribute__
293# if __GNUC_PREREQ (3, 4)
294# define __ul_attribute__(_a_) __attribute__(_a_)
295# else
296# define __ul_attribute__(_a_)
297# endif
298#endif
299
300
301/* init.c */
302extern void mnt_init_debug(int mask);
303
304/* version.c */
305extern int mnt_parse_version_string(const char *ver_string);
306extern int mnt_get_library_version(const char **ver_string);
307extern int mnt_get_library_features(const char ***features);
308
309/* utils.c */
310extern char *mnt_mangle(const char *str)
311 __ul_attribute__((warn_unused_result));
312extern char *mnt_unmangle(const char *str)
313 __ul_attribute__((warn_unused_result));
314
315extern int mnt_tag_is_valid(const char *tag);
316extern int mnt_fstype_is_netfs(const char *type);
317extern int mnt_fstype_is_pseudofs(const char *type);
318
319extern int mnt_match_fstype(const char *type, const char *pattern)
320 __ul_attribute__((warn_unused_result));
321extern int mnt_match_options(const char *optstr, const char *pattern)
322 __ul_attribute__((warn_unused_result));
323extern const char *mnt_get_fstab_path(void);
324extern const char *mnt_get_swaps_path(void);
325extern const char *mnt_get_mtab_path(void);
326extern int mnt_has_regular_mtab(const char **mtab, int *writable);
327extern char *mnt_get_mountpoint(const char *path)
328 __ul_attribute__((warn_unused_result));
329extern int mnt_guess_system_root(dev_t devno, struct libmnt_cache *cache, char **path)
330 __ul_attribute__((nonnull(3)));
331
332/* cache.c */
333extern struct libmnt_cache *mnt_new_cache(void)
334 __ul_attribute__((warn_unused_result));
335extern void mnt_free_cache(struct libmnt_cache *cache);
336
337extern void mnt_ref_cache(struct libmnt_cache *cache);
338extern void mnt_unref_cache(struct libmnt_cache *cache);
339
340extern int mnt_cache_set_targets(struct libmnt_cache *cache,
341 struct libmnt_table *mtab);
342extern int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname);
343
344extern int mnt_cache_device_has_tag(struct libmnt_cache *cache,
345 const char *devname,
346 const char *token,
347 const char *value);
348
349extern char *mnt_cache_find_tag_value(struct libmnt_cache *cache,
350 const char *devname, const char *token);
351
352extern char *mnt_get_fstype(const char *devname, int *ambi,
353 struct libmnt_cache *cache)
354 __ul_attribute__((warn_unused_result));
355extern char *mnt_resolve_path(const char *path, struct libmnt_cache *cache)
356 __ul_attribute__((warn_unused_result));
357extern char *mnt_resolve_target(const char *path, struct libmnt_cache *cache)
358 __ul_attribute__((warn_unused_result));
359extern char *mnt_resolve_tag(const char *token, const char *value,
360 struct libmnt_cache *cache)
361 __ul_attribute__((warn_unused_result));
362extern char *mnt_resolve_spec(const char *spec, struct libmnt_cache *cache)
363 __ul_attribute__((warn_unused_result));
364extern char *mnt_pretty_path(const char *path, struct libmnt_cache *cache)
365 __ul_attribute__((warn_unused_result));
366
367/* optstr.c */
368extern int mnt_optstr_next_option(char **optstr, char **name, size_t *namesz,
369 char **value, size_t *valuesz);
370extern int mnt_optstr_append_option(char **optstr, const char *name,
371 const char *value);
372extern int mnt_optstr_prepend_option(char **optstr, const char *name,
373 const char *value);
374
375extern int mnt_optstr_get_option(const char *optstr, const char *name,
376 char **value, size_t *valsz);
377extern int mnt_optstr_set_option(char **optstr, const char *name,
378 const char *value);
379extern int mnt_optstr_remove_option(char **optstr, const char *name);
380extern int mnt_optstr_deduplicate_option(char **optstr, const char *name);
381
382extern int mnt_split_optstr(const char *optstr,
383 char **user, char **vfs, char **fs,
384 int ignore_user, int ignore_vfs);
385
386extern int mnt_optstr_get_options(const char *optstr, char **subset,
387 const struct libmnt_optmap *map, int ignore);
388
389extern int mnt_optstr_get_flags(const char *optstr, unsigned long *flags,
390 const struct libmnt_optmap *map);
391
392extern int mnt_optstr_apply_flags(char **optstr, unsigned long flags,
393 const struct libmnt_optmap *map);
394
395/* iter.c */
396enum {
397
398 MNT_ITER_FORWARD = 0,
399 MNT_ITER_BACKWARD
400};
401extern struct libmnt_iter *mnt_new_iter(int direction)
402 __ul_attribute__((warn_unused_result));
403extern void mnt_free_iter(struct libmnt_iter *itr);
404
405extern void mnt_reset_iter(struct libmnt_iter *itr, int direction)
406 __ul_attribute__((nonnull));
407extern int mnt_iter_get_direction(struct libmnt_iter *itr)
408 __ul_attribute__((nonnull));
409
410/* optmap.c */
411enum {
412 MNT_LINUX_MAP = 1,
413 MNT_USERSPACE_MAP
414};
415extern const struct libmnt_optmap *mnt_get_builtin_optmap(int id);
416
417/* lock.c */
418extern struct libmnt_lock *mnt_new_lock(const char *datafile, pid_t id)
419 __ul_attribute__((warn_unused_result));
420extern void mnt_free_lock(struct libmnt_lock *ml);
421
422extern void mnt_unlock_file(struct libmnt_lock *ml);
423extern int mnt_lock_file(struct libmnt_lock *ml);
424extern int mnt_lock_block_signals(struct libmnt_lock *ml, int enable);
425
426/* fs.c */
427extern struct libmnt_fs *mnt_new_fs(void)
428 __ul_attribute__((warn_unused_result));
429extern void mnt_free_fs(struct libmnt_fs *fs);
430extern void mnt_ref_fs(struct libmnt_fs *fs);
431extern void mnt_unref_fs(struct libmnt_fs *fs);
432
433extern void mnt_reset_fs(struct libmnt_fs *fs);
434extern struct libmnt_fs *mnt_copy_fs(struct libmnt_fs *dest,
435 const struct libmnt_fs *src)
436 __ul_attribute__((warn_unused_result));
437extern void *mnt_fs_get_userdata(struct libmnt_fs *fs);
438extern int mnt_fs_set_userdata(struct libmnt_fs *fs, void *data);
439extern const char *mnt_fs_get_source(struct libmnt_fs *fs);
440extern int mnt_fs_set_source(struct libmnt_fs *fs, const char *source);
441extern const char *mnt_fs_get_srcpath(struct libmnt_fs *fs);
442extern int mnt_fs_get_table(struct libmnt_fs *fs, struct libmnt_table **tb);
443
444extern int mnt_fs_get_tag(struct libmnt_fs *fs, const char **name,
445 const char **value);
446extern const char *mnt_fs_get_target(struct libmnt_fs *fs);
447extern int mnt_fs_set_target(struct libmnt_fs *fs, const char *tgt);
448extern const char *mnt_fs_get_fstype(struct libmnt_fs *fs);
449extern int mnt_fs_set_fstype(struct libmnt_fs *fs, const char *fstype);
450
451extern int mnt_fs_streq_srcpath(struct libmnt_fs *fs, const char *path)
452 __ul_attribute__((warn_unused_result));
453extern int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
454 __ul_attribute__((warn_unused_result));
455
456extern char *mnt_fs_strdup_options(struct libmnt_fs *fs)
457 __ul_attribute__((warn_unused_result));
458extern const char *mnt_fs_get_options(struct libmnt_fs *fs)
459 __ul_attribute__((warn_unused_result));
460extern const char *mnt_fs_get_optional_fields(struct libmnt_fs *fs)
461 __ul_attribute__((warn_unused_result));
462extern int mnt_fs_get_propagation(struct libmnt_fs *fs, unsigned long *flags);
463
464extern int mnt_fs_set_options(struct libmnt_fs *fs, const char *optstr);
465extern int mnt_fs_append_options(struct libmnt_fs *fs, const char *optstr);
466extern int mnt_fs_prepend_options(struct libmnt_fs *fs, const char *optstr);
467
468extern int mnt_fs_get_option(struct libmnt_fs *fs, const char *name,
469 char **value, size_t *valsz);
470
471extern const char *mnt_fs_get_fs_options(struct libmnt_fs *fs);
472extern const char *mnt_fs_get_vfs_options(struct libmnt_fs *fs);
473extern const char *mnt_fs_get_user_options(struct libmnt_fs *fs);
474extern char *mnt_fs_get_vfs_options_all(struct libmnt_fs *fs);
475
476extern const char *mnt_fs_get_attributes(struct libmnt_fs *fs);
477extern int mnt_fs_set_attributes(struct libmnt_fs *fs, const char *optstr);
478extern int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name,
479 char **value, size_t *valsz);
480extern int mnt_fs_append_attributes(struct libmnt_fs *fs, const char *optstr);
481extern int mnt_fs_prepend_attributes(struct libmnt_fs *fs, const char *optstr);
482
483extern int mnt_fs_get_freq(struct libmnt_fs *fs);
484extern int mnt_fs_set_freq(struct libmnt_fs *fs, int freq);
485extern int mnt_fs_get_passno(struct libmnt_fs *fs);
486extern int mnt_fs_set_passno(struct libmnt_fs *fs, int passno);
487extern const char *mnt_fs_get_root(struct libmnt_fs *fs);
488extern int mnt_fs_set_root(struct libmnt_fs *fs, const char *path);
489extern const char *mnt_fs_get_bindsrc(struct libmnt_fs *fs);
490extern int mnt_fs_set_bindsrc(struct libmnt_fs *fs, const char *src);
491extern int mnt_fs_get_id(struct libmnt_fs *fs);
492extern int mnt_fs_get_parent_id(struct libmnt_fs *fs);
493extern dev_t mnt_fs_get_devno(struct libmnt_fs *fs);
494extern pid_t mnt_fs_get_tid(struct libmnt_fs *fs);
495
496extern const char *mnt_fs_get_swaptype(struct libmnt_fs *fs);
497extern off_t mnt_fs_get_size(struct libmnt_fs *fs);
498extern off_t mnt_fs_get_usedsize(struct libmnt_fs *fs);
499extern int mnt_fs_get_priority(struct libmnt_fs *fs);
500extern int mnt_fs_set_priority(struct libmnt_fs *fs, int prio);
501
502extern const char *mnt_fs_get_comment(struct libmnt_fs *fs);
503extern int mnt_fs_set_comment(struct libmnt_fs *fs, const char *comm);
504extern int mnt_fs_append_comment(struct libmnt_fs *fs, const char *comm);
505
506extern int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
507 struct libmnt_cache *cache);
508extern int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
509 struct libmnt_cache *cache);
510extern int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types);
511extern int mnt_fs_match_options(struct libmnt_fs *fs, const char *options);
512extern int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file);
513
514extern int mnt_fs_is_kernel(struct libmnt_fs *fs);
515extern int mnt_fs_is_swaparea(struct libmnt_fs *fs);
516extern int mnt_fs_is_netfs(struct libmnt_fs *fs);
517extern int mnt_fs_is_pseudofs(struct libmnt_fs *fs);
518
519extern void mnt_free_mntent(struct mntent *mnt);
520extern int mnt_fs_to_mntent(struct libmnt_fs *fs, struct mntent **mnt);
521
522/* tab-parse.c */
523extern struct libmnt_table *mnt_new_table_from_file(const char *filename)
524 __ul_attribute__((warn_unused_result));
525extern struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
526 __ul_attribute__((warn_unused_result));
527extern int mnt_table_parse_stream(struct libmnt_table *tb, FILE *f,
528 const char *filename);
529extern int mnt_table_parse_file(struct libmnt_table *tb, const char *filename);
530extern int mnt_table_parse_dir(struct libmnt_table *tb, const char *dirname);
531
532extern int mnt_table_parse_fstab(struct libmnt_table *tb, const char *filename);
533extern int mnt_table_parse_swaps(struct libmnt_table *tb, const char *filename);
534extern int mnt_table_parse_mtab(struct libmnt_table *tb, const char *filename);
535extern int mnt_table_set_parser_errcb(struct libmnt_table *tb,
536 int (*cb)(struct libmnt_table *tb, const char *filename, int line));
537
538/* tab.c */
539extern struct libmnt_table *mnt_new_table(void)
540 __ul_attribute__((warn_unused_result));
541extern void mnt_free_table(struct libmnt_table *tb);
542
543extern void mnt_ref_table(struct libmnt_table *tb);
544extern void mnt_unref_table(struct libmnt_table *tb);
545
546extern int mnt_reset_table(struct libmnt_table *tb);
547extern int mnt_table_get_nents(struct libmnt_table *tb);
548extern int mnt_table_is_empty(struct libmnt_table *tb);
549
550extern int mnt_table_set_userdata(struct libmnt_table *tb, void *data);
551extern void *mnt_table_get_userdata(struct libmnt_table *tb);
552
553extern void mnt_table_enable_comments(struct libmnt_table *tb, int enable);
554extern int mnt_table_with_comments(struct libmnt_table *tb);
555extern const char *mnt_table_get_intro_comment(struct libmnt_table *tb);
556extern int mnt_table_set_intro_comment(struct libmnt_table *tb, const char *comm);
557extern int mnt_table_append_intro_comment(struct libmnt_table *tb, const char *comm);
558extern int mnt_table_set_trailing_comment(struct libmnt_table *tb, const char *comm);
559extern const char *mnt_table_get_trailing_comment(struct libmnt_table *tb);
560extern int mnt_table_append_trailing_comment(struct libmnt_table *tb, const char *comm);
561
562extern int mnt_table_set_cache(struct libmnt_table *tb, struct libmnt_cache *mpc);
563extern struct libmnt_cache *mnt_table_get_cache(struct libmnt_table *tb);
564extern int mnt_table_add_fs(struct libmnt_table *tb, struct libmnt_fs *fs);
565extern int mnt_table_find_fs(struct libmnt_table *tb, struct libmnt_fs *fs);
566extern int mnt_table_insert_fs(struct libmnt_table *tb, int before,
567 struct libmnt_fs *pos, struct libmnt_fs *fs);
568extern int mnt_table_move_fs(struct libmnt_table *src, struct libmnt_table *dst,
569 int before, struct libmnt_fs *pos, struct libmnt_fs *fs);
570extern int mnt_table_remove_fs(struct libmnt_table *tb, struct libmnt_fs *fs);
571extern int mnt_table_first_fs(struct libmnt_table *tb, struct libmnt_fs **fs);
572extern int mnt_table_last_fs(struct libmnt_table *tb, struct libmnt_fs **fs);
573extern int mnt_table_over_fs(struct libmnt_table *tb, struct libmnt_fs *parent,
574 struct libmnt_fs **child);
575extern int mnt_table_next_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
576 struct libmnt_fs **fs);
577extern int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
578 struct libmnt_fs *parent, struct libmnt_fs **chld);
579extern int mnt_table_get_root_fs(struct libmnt_table *tb, struct libmnt_fs **root);
580extern int mnt_table_set_iter(struct libmnt_table *tb, struct libmnt_iter *itr,
581 struct libmnt_fs *fs);
582
583enum {
584 MNT_UNIQ_FORWARD = (1 << 1), /* default is backward */
585 MNT_UNIQ_KEEPTREE = (1 << 2)
586};
587extern int mnt_table_uniq_fs(struct libmnt_table *tb, int flags,
588 int (*cmp)(struct libmnt_table *,
589 struct libmnt_fs *,
590 struct libmnt_fs *));
591
592extern struct libmnt_fs *mnt_table_find_mountpoint(struct libmnt_table *tb,
593 const char *path, int direction);
594extern struct libmnt_fs *mnt_table_find_target(struct libmnt_table *tb,
595 const char *path, int direction);
596extern struct libmnt_fs *mnt_table_find_srcpath(struct libmnt_table *tb,
597 const char *path, int direction);
598extern struct libmnt_fs *mnt_table_find_tag(struct libmnt_table *tb, const char *tag,
599 const char *val, int direction);
600extern struct libmnt_fs *mnt_table_find_target_with_option(struct libmnt_table *tb, const char *path,
601 const char *option, const char *val, int direction);
602extern struct libmnt_fs *mnt_table_find_source(struct libmnt_table *tb,
603 const char *source, int direction);
604extern struct libmnt_fs *mnt_table_find_pair(struct libmnt_table *tb,
605 const char *source,
606 const char *target, int direction);
607extern struct libmnt_fs *mnt_table_find_devno(struct libmnt_table *tb,
608 dev_t devno, int direction);
609
610extern int mnt_table_find_next_fs(struct libmnt_table *tb,
611 struct libmnt_iter *itr,
612 int (*match_func)(struct libmnt_fs *, void *),
613 void *userdata,
614 struct libmnt_fs **fs);
615
616extern int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs);
617
618/* tab_update.c */
619extern struct libmnt_update *mnt_new_update(void)
620 __ul_attribute__((warn_unused_result));
621extern void mnt_free_update(struct libmnt_update *upd);
622
623extern int mnt_table_replace_file(struct libmnt_table *tb, const char *filename);
624extern int mnt_table_write_file(struct libmnt_table *tb, FILE *file);
625
626extern int mnt_update_is_ready(struct libmnt_update *upd);
627extern int mnt_update_set_fs(struct libmnt_update *upd, unsigned long mountflags,
628 const char *target, struct libmnt_fs *fs);
629extern int mnt_update_table(struct libmnt_update *upd, struct libmnt_lock *lc);
630extern unsigned long mnt_update_get_mflags(struct libmnt_update *upd);
631extern int mnt_update_force_rdonly(struct libmnt_update *upd, int rdonly);
632extern const char *mnt_update_get_filename(struct libmnt_update *upd);
633extern struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd);
634
635/* tab_diff.c */
636enum {
637 MNT_TABDIFF_MOUNT = 1,
638 MNT_TABDIFF_UMOUNT,
639 MNT_TABDIFF_MOVE,
640 MNT_TABDIFF_REMOUNT,
641 MNT_TABDIFF_PROPAGATION, /* not implemented yet (TODO) */
642};
643
644extern struct libmnt_tabdiff *mnt_new_tabdiff(void)
645 __ul_attribute__((warn_unused_result));
646extern void mnt_free_tabdiff(struct libmnt_tabdiff *df);
647
648extern int mnt_diff_tables(struct libmnt_tabdiff *df,
649 struct libmnt_table *old_tab,
650 struct libmnt_table *new_tab);
651
652extern int mnt_tabdiff_next_change(struct libmnt_tabdiff *df,
653 struct libmnt_iter *itr,
654 struct libmnt_fs **old_fs,
655 struct libmnt_fs **new_fs,
656 int *oper);
657
658/* monitor.c */
659enum {
660 MNT_MONITOR_TYPE_USERSPACE = 1, /* userspace mount options */
661 MNT_MONITOR_TYPE_KERNEL /* kernel mount table */
662};
663
664extern struct libmnt_monitor *mnt_new_monitor(void);
665extern void mnt_ref_monitor(struct libmnt_monitor *mn);
666extern void mnt_unref_monitor(struct libmnt_monitor *mn);
667
668extern int mnt_monitor_enable_kernel(struct libmnt_monitor *mn, int enable);
669extern int mnt_monitor_enable_userspace(struct libmnt_monitor *mn,
670 int enable, const char *filename);
671
672extern int mnt_monitor_get_fd(struct libmnt_monitor *mn);
673extern int mnt_monitor_close_fd(struct libmnt_monitor *mn);
674extern int mnt_monitor_wait(struct libmnt_monitor *mn, int timeout);
675
676extern int mnt_monitor_next_change(struct libmnt_monitor *mn,
677 const char **filename, int *type);
678extern int mnt_monitor_event_cleanup(struct libmnt_monitor *mn);
679
680
681/* context.c */
682
683/*
684 * Mode for mount options from fstab (or mtab), see mnt_context_set_optsmode().
685 */
686enum {
687 MNT_OMODE_IGNORE = (1 << 1), /* ignore mtab/fstab options */
688 MNT_OMODE_APPEND = (1 << 2), /* append mtab/fstab options to existing options */
689 MNT_OMODE_PREPEND = (1 << 3), /* prepend mtab/fstab options to existing options */
690 MNT_OMODE_REPLACE = (1 << 4), /* replace existing options with options from mtab/fstab */
691
692 MNT_OMODE_FORCE = (1 << 5), /* always read mtab/fstab options */
693
694 MNT_OMODE_FSTAB = (1 << 10), /* read from fstab */
695 MNT_OMODE_MTAB = (1 << 11), /* read from mtab if fstab not enabled or failed */
696 MNT_OMODE_NOTAB = (1 << 12), /* do not read fstab/mtab at all */
697
698 /* default */
699 MNT_OMODE_AUTO = (MNT_OMODE_PREPEND | MNT_OMODE_FSTAB | MNT_OMODE_MTAB),
700 /* non-root users */
701 MNT_OMODE_USER = (MNT_OMODE_REPLACE | MNT_OMODE_FORCE | MNT_OMODE_FSTAB)
702};
703
704extern struct libmnt_context *mnt_new_context(void)
705 __ul_attribute__((warn_unused_result));
706extern void mnt_free_context(struct libmnt_context *cxt);
707
708extern int mnt_reset_context(struct libmnt_context *cxt);
709extern int mnt_context_is_restricted(struct libmnt_context *cxt)
710 __ul_attribute__((nonnull));
711extern int mnt_context_force_unrestricted(struct libmnt_context *cxt);
712
713extern int mnt_context_init_helper(struct libmnt_context *cxt,
714 int action, int flags);
715extern int mnt_context_helper_setopt(struct libmnt_context *cxt, int c, char *arg);
716
717extern int mnt_context_set_optsmode(struct libmnt_context *cxt, int mode);
718extern int mnt_context_disable_canonicalize(struct libmnt_context *cxt, int disable);
719extern int mnt_context_enable_lazy(struct libmnt_context *cxt, int enable);
720extern int mnt_context_enable_rdonly_umount(struct libmnt_context *cxt, int enable);
721extern int mnt_context_enable_rwonly_mount(struct libmnt_context *cxt, int enable);
722extern int mnt_context_disable_helpers(struct libmnt_context *cxt, int disable);
723extern int mnt_context_enable_sloppy(struct libmnt_context *cxt, int enable);
724extern int mnt_context_enable_fake(struct libmnt_context *cxt, int enable);
725extern int mnt_context_disable_mtab(struct libmnt_context *cxt, int disable);
726extern int mnt_context_enable_force(struct libmnt_context *cxt, int enable);
727extern int mnt_context_enable_verbose(struct libmnt_context *cxt, int enable);
728extern int mnt_context_enable_loopdel(struct libmnt_context *cxt, int enable);
729extern int mnt_context_enable_fork(struct libmnt_context *cxt, int enable);
730extern int mnt_context_disable_swapmatch(struct libmnt_context *cxt, int disable);
731
732extern int mnt_context_get_optsmode(struct libmnt_context *cxt);
733
734extern int mnt_context_is_lazy(struct libmnt_context *cxt)
735 __ul_attribute__((nonnull));
736extern int mnt_context_is_rdonly_umount(struct libmnt_context *cxt)
737 __ul_attribute__((nonnull));
738extern int mnt_context_is_rwonly_mount(struct libmnt_context *cxt)
739 __ul_attribute__((nonnull));
740extern int mnt_context_is_sloppy(struct libmnt_context *cxt)
741 __ul_attribute__((nonnull));
742extern int mnt_context_is_fake(struct libmnt_context *cxt)
743 __ul_attribute__((nonnull));
744extern int mnt_context_is_nomtab(struct libmnt_context *cxt)
745 __ul_attribute__((nonnull));
746extern int mnt_context_is_force(struct libmnt_context *cxt)
747 __ul_attribute__((nonnull));
748extern int mnt_context_is_verbose(struct libmnt_context *cxt)
749 __ul_attribute__((nonnull));
750extern int mnt_context_is_loopdel(struct libmnt_context *cxt)
751 __ul_attribute__((nonnull));
752extern int mnt_context_is_nohelpers(struct libmnt_context *cxt)
753 __ul_attribute__((nonnull));
754extern int mnt_context_is_nocanonicalize(struct libmnt_context *cxt)
755 __ul_attribute__((nonnull));
756extern int mnt_context_is_swapmatch(struct libmnt_context *cxt)
757 __ul_attribute__((nonnull));
758extern int mnt_context_forced_rdonly(struct libmnt_context *cxt)
759 __ul_attribute__((nonnull));
760
761extern int mnt_context_is_fork(struct libmnt_context *cxt)
762 __ul_attribute__((nonnull));
763extern int mnt_context_is_parent(struct libmnt_context *cxt)
764 __ul_attribute__((nonnull));
765extern int mnt_context_is_child(struct libmnt_context *cxt)
766 __ul_attribute__((nonnull));
767
768extern int mnt_context_wait_for_children(struct libmnt_context *cxt,
769 int *nchildren, int *nerrs);
770
771extern int mnt_context_is_fs_mounted(struct libmnt_context *cxt,
772 struct libmnt_fs *fs, int *mounted);
773extern int mnt_context_set_fs(struct libmnt_context *cxt, struct libmnt_fs *fs);
774extern struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt);
775
776extern int mnt_context_set_source(struct libmnt_context *cxt, const char *source);
777extern int mnt_context_set_target(struct libmnt_context *cxt, const char *target);
778extern int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype);
779extern int mnt_context_set_target_prefix(struct libmnt_context *cxt, const char *path);
780
781extern const char *mnt_context_get_source(struct libmnt_context *cxt);
782extern const char *mnt_context_get_target(struct libmnt_context *cxt);
783extern const char *mnt_context_get_fstype(struct libmnt_context *cxt);
784extern const char *mnt_context_get_target_prefix(struct libmnt_context *cxt);
785
786extern void *mnt_context_get_mtab_userdata(struct libmnt_context *cxt);
787extern void *mnt_context_get_fstab_userdata(struct libmnt_context *cxt);
788extern void *mnt_context_get_fs_userdata(struct libmnt_context *cxt);
789
790extern int mnt_context_set_options(struct libmnt_context *cxt, const char *optstr);
791extern int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr);
792
793extern const char *mnt_context_get_options(struct libmnt_context *cxt);
794
795extern int mnt_context_set_fstype_pattern(struct libmnt_context *cxt, const char *pattern);
796extern int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *pattern);
797
798extern int mnt_context_set_passwd_cb(struct libmnt_context *cxt,
799 char *(*get)(struct libmnt_context *),
800 void (*release)(struct libmnt_context *, char *))
801 __ul_attribute__((deprecated));
802
803extern int mnt_context_set_tables_errcb(struct libmnt_context *cxt,
804 int (*cb)(struct libmnt_table *tb, const char *filename, int line));
805extern int mnt_context_set_fstab(struct libmnt_context *cxt,
806 struct libmnt_table *tb);
807extern int mnt_context_get_fstab(struct libmnt_context *cxt,
808 struct libmnt_table **tb);
809
810extern int mnt_context_get_mtab(struct libmnt_context *cxt,
811 struct libmnt_table **tb);
812extern int mnt_context_get_table(struct libmnt_context *cxt,
813 const char *filename,
814 struct libmnt_table **tb);
815extern int mnt_context_set_cache(struct libmnt_context *cxt,
816 struct libmnt_cache *cache);
817extern struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt);
818extern struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt);
819extern int mnt_context_set_mflags(struct libmnt_context *cxt,
820 unsigned long flags);
821extern int mnt_context_get_mflags(struct libmnt_context *cxt,
822 unsigned long *flags);
823extern int mnt_context_set_user_mflags(struct libmnt_context *cxt,
824 unsigned long flags);
825extern int mnt_context_get_user_mflags(struct libmnt_context *cxt,
826 unsigned long *flags);
827
828extern int mnt_context_set_mountdata(struct libmnt_context *cxt, void *data);
829extern int mnt_context_apply_fstab(struct libmnt_context *cxt);
830
831extern int mnt_context_reset_status(struct libmnt_context *cxt);
832extern int mnt_context_get_status(struct libmnt_context *cxt);
833
834extern int mnt_context_helper_executed(struct libmnt_context *cxt);
835extern int mnt_context_get_helper_status(struct libmnt_context *cxt);
836
837extern int mnt_context_syscall_called(struct libmnt_context *cxt);
838
839extern int mnt_context_get_syscall_errno(struct libmnt_context *cxt);
840
841extern int mnt_context_strerror(struct libmnt_context *cxt, char *buf,
842 size_t bufsiz)
843 __ul_attribute__((deprecated));
844
845extern int mnt_context_get_excode(struct libmnt_context *cxt,
846 int rc, char *buf, size_t bufsz);
847
848extern int mnt_context_set_target_ns(struct libmnt_context *cxt, const char *path);
849extern struct libmnt_ns *mnt_context_get_target_ns(struct libmnt_context *cxt);
850extern struct libmnt_ns *mnt_context_get_origin_ns(struct libmnt_context *cxt);
851extern struct libmnt_ns *mnt_context_switch_ns(struct libmnt_context *cxt, struct libmnt_ns *ns);
852extern struct libmnt_ns *mnt_context_switch_origin_ns(struct libmnt_context *cxt);
853extern struct libmnt_ns *mnt_context_switch_target_ns(struct libmnt_context *cxt);
854
855
856/* context_mount.c */
857extern int mnt_context_mount(struct libmnt_context *cxt);
858extern int mnt_context_umount(struct libmnt_context *cxt);
859extern int mnt_context_next_mount(struct libmnt_context *cxt,
860 struct libmnt_iter *itr,
861 struct libmnt_fs **fs,
862 int *mntrc, int *ignored);
863
864extern int mnt_context_next_remount(struct libmnt_context *cxt,
865 struct libmnt_iter *itr,
866 struct libmnt_fs **fs,
867 int *mntrc,
868 int *ignored);
869
870extern int mnt_context_prepare_mount(struct libmnt_context *cxt)
871 __ul_attribute__((warn_unused_result));
872extern int mnt_context_do_mount(struct libmnt_context *cxt);
873extern int mnt_context_finalize_mount(struct libmnt_context *cxt);
874
875/* context_umount.c */
876extern int mnt_context_find_umount_fs(struct libmnt_context *cxt,
877 const char *tgt,
878 struct libmnt_fs **pfs);
879extern int mnt_context_next_umount(struct libmnt_context *cxt,
880 struct libmnt_iter *itr,
881 struct libmnt_fs **fs,
882 int *mntrc, int *ignored);
883
884extern int mnt_context_prepare_umount(struct libmnt_context *cxt)
885 __ul_attribute__((warn_unused_result));
886extern int mnt_context_do_umount(struct libmnt_context *cxt);
887extern int mnt_context_finalize_umount(struct libmnt_context *cxt);
888
889extern int mnt_context_tab_applied(struct libmnt_context *cxt);
890extern int mnt_context_set_syscall_status(struct libmnt_context *cxt, int status);
891
892/*
893 * mount(8) userspace options masks (MNT_MAP_USERSPACE map)
894 */
895#define MNT_MS_NOAUTO (1 << 2)
896#define MNT_MS_USER (1 << 3)
897#define MNT_MS_USERS (1 << 4)
898#define MNT_MS_OWNER (1 << 5)
899#define MNT_MS_GROUP (1 << 6)
900#define MNT_MS_NETDEV (1 << 7)
901#define MNT_MS_COMMENT (1 << 8)
902#define MNT_MS_LOOP (1 << 9)
903#define MNT_MS_NOFAIL (1 << 10)
904#define MNT_MS_UHELPER (1 << 11)
905#define MNT_MS_HELPER (1 << 12)
906#define MNT_MS_XCOMMENT (1 << 13)
907#define MNT_MS_OFFSET (1 << 14)
908#define MNT_MS_SIZELIMIT (1 << 15)
909#define MNT_MS_ENCRYPTION (1 << 16)
910#define MNT_MS_XFSTABCOMM (1 << 17)
911#define MNT_MS_HASH_DEVICE (1 << 18)
912#define MNT_MS_ROOT_HASH (1 << 19)
913#define MNT_MS_HASH_OFFSET (1 << 20)
914#define MNT_MS_ROOT_HASH_FILE (1 << 21)
915#define MNT_MS_FEC_DEVICE (1 << 22)
916#define MNT_MS_FEC_OFFSET (1 << 23)
917#define MNT_MS_FEC_ROOTS (1 << 24)
918#define MNT_MS_ROOT_HASH_SIG (1 << 25)
919
920/*
921 * mount(2) MS_* masks (MNT_MAP_LINUX map)
922 */
923#ifndef MS_RDONLY
924#define MS_RDONLY 1 /* Mount read-only */
925#endif
926#ifndef MS_NOSUID
927#define MS_NOSUID 2 /* Ignore suid and sgid bits */
928#endif
929#ifndef MS_NODEV
930#define MS_NODEV 4 /* Disallow access to device special files */
931#endif
932#ifndef MS_NOEXEC
933#define MS_NOEXEC 8 /* Disallow program execution */
934#endif
935#ifndef MS_SYNCHRONOUS
936#define MS_SYNCHRONOUS 16 /* Writes are synced at once */
937#endif
938#ifndef MS_REMOUNT
939#define MS_REMOUNT 32 /* Alter flags of a mounted FS */
940#endif
941#ifndef MS_MANDLOCK
942#define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
943#endif
944#ifndef MS_DIRSYNC
945#define MS_DIRSYNC 128 /* Directory modifications are synchronous */
946#endif
947#ifndef MS_NOSYMFOLLOW
948#define MS_NOSYMFOLLOW 256 /* Don't follow symlinks */
949#endif
950#ifndef MS_NOATIME
951#define MS_NOATIME 0x400 /* 1024: Do not update access times. */
952#endif
953#ifndef MS_NODIRATIME
954#define MS_NODIRATIME 0x800 /* 2048: Don't update directory access times */
955#endif
956#ifndef MS_BIND
957#define MS_BIND 0x1000 /* 4096: Mount existing tree elsewhere as well */
958#endif
959#ifndef MS_MOVE
960#define MS_MOVE 0x2000 /* 8192: Atomically move the tree */
961#endif
962#ifndef MS_REC
963#define MS_REC 0x4000 /* 16384: Recursive loopback */
964#endif
965#ifndef MS_SILENT
966#define MS_SILENT 0x8000 /* 32768: Don't emit certain kernel messages */
967#endif
968#ifndef MS_UNBINDABLE
969#define MS_UNBINDABLE (1<<17) /* 131072: Make unbindable */
970#endif
971#ifndef MS_PRIVATE
972#define MS_PRIVATE (1<<18) /* 262144: Make private */
973#endif
974#ifndef MS_SLAVE
975#define MS_SLAVE (1<<19) /* 524288: Make slave */
976#endif
977#ifndef MS_SHARED
978#define MS_SHARED (1<<20) /* 1048576: Make shared */
979#endif
980#ifndef MS_RELATIME
981#define MS_RELATIME (1<<21) /* 2097152: Update atime relative to mtime/ctime */
982#endif
983#ifndef MS_I_VERSION
984#define MS_I_VERSION (1<<23) /* Update the inode I_version field */
985#endif
986#ifndef MS_STRICTATIME
987#define MS_STRICTATIME (1<<24) /* Always perform atime updates */
988#endif
989#ifndef MS_LAZYTIME
990#define MS_LAZYTIME (1<<25) /* Update the on-disk [acm]times lazily */
991#endif
992
993
994/*
995 * Magic mount flag number. Had to be or-ed to the flag values. Deprecated and
996 * no more used since libmount v2.33; required for Linux <= 2.4.
997 */
998#ifndef MS_MGC_VAL
999#define MS_MGC_VAL 0xC0ED0000 /* magic flag number to indicate "new" flags */
1000#endif
1001#ifndef MS_MGC_MSK
1002#define MS_MGC_MSK 0xffff0000 /* magic flag number mask */
1003#endif
1004
1005
1006/* Shared-subtree options */
1007#define MS_PROPAGATION (MS_SHARED|MS_SLAVE|MS_UNBINDABLE|MS_PRIVATE)
1008
1009/* Options that we make ordinary users have by default. */
1010#define MS_SECURE (MS_NOEXEC|MS_NOSUID|MS_NODEV)
1011
1012/* Options that we make owner-mounted devices have by default */
1013#define MS_OWNERSECURE (MS_NOSUID|MS_NODEV)
1014
1015#ifdef __cplusplus
1016}
1017#endif
1018
1019#endif /* _LIBMOUNT_MOUNT_H */
1020

source code of include/libmount/libmount.h