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 "@LIBMOUNT_VERSION@" 44#define LIBMOUNT_MAJOR_VERSION @LIBMOUNT_MAJOR_VERSION@ 45#define LIBMOUNT_MINOR_VERSION @LIBMOUNT_MINOR_VERSION@ 46#define LIBMOUNT_PATCH_VERSION @LIBMOUNT_PATCH_VERSION@ 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); 474 475extern const char *mnt_fs_get_attributes(struct libmnt_fs *fs); 476extern int mnt_fs_set_attributes(struct libmnt_fs *fs, const char *optstr); 477extern int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name, 478 char **value, size_t *valsz); 479extern int mnt_fs_append_attributes(struct libmnt_fs *fs, const char *optstr); 480extern int mnt_fs_prepend_attributes(struct libmnt_fs *fs, const char *optstr); 481 482extern int mnt_fs_get_freq(struct libmnt_fs *fs); 483extern int mnt_fs_set_freq(struct libmnt_fs *fs, int freq); 484extern int mnt_fs_get_passno(struct libmnt_fs *fs); 485extern int mnt_fs_set_passno(struct libmnt_fs *fs, int passno); 486extern const char *mnt_fs_get_root(struct libmnt_fs *fs); 487extern int mnt_fs_set_root(struct libmnt_fs *fs, const char *path); 488extern const char *mnt_fs_get_bindsrc(struct libmnt_fs *fs); 489extern int mnt_fs_set_bindsrc(struct libmnt_fs *fs, const char *src); 490extern int mnt_fs_get_id(struct libmnt_fs *fs); 491extern int mnt_fs_get_parent_id(struct libmnt_fs *fs); 492extern dev_t mnt_fs_get_devno(struct libmnt_fs *fs); 493extern pid_t mnt_fs_get_tid(struct libmnt_fs *fs); 494 495extern const char *mnt_fs_get_swaptype(struct libmnt_fs *fs); 496extern off_t mnt_fs_get_size(struct libmnt_fs *fs); 497extern off_t mnt_fs_get_usedsize(struct libmnt_fs *fs); 498extern int mnt_fs_get_priority(struct libmnt_fs *fs); 499extern int mnt_fs_set_priority(struct libmnt_fs *fs, int prio); 500 501extern const char *mnt_fs_get_comment(struct libmnt_fs *fs); 502extern int mnt_fs_set_comment(struct libmnt_fs *fs, const char *comm); 503extern int mnt_fs_append_comment(struct libmnt_fs *fs, const char *comm); 504 505extern int mnt_fs_match_target(struct libmnt_fs *fs, const char *target, 506 struct libmnt_cache *cache); 507extern int mnt_fs_match_source(struct libmnt_fs *fs, const char *source, 508 struct libmnt_cache *cache); 509extern int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types); 510extern int mnt_fs_match_options(struct libmnt_fs *fs, const char *options); 511extern int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file); 512 513extern int mnt_fs_is_kernel(struct libmnt_fs *fs); 514extern int mnt_fs_is_swaparea(struct libmnt_fs *fs); 515extern int mnt_fs_is_netfs(struct libmnt_fs *fs); 516extern int mnt_fs_is_pseudofs(struct libmnt_fs *fs); 517 518extern void mnt_free_mntent(struct mntent *mnt); 519extern int mnt_fs_to_mntent(struct libmnt_fs *fs, struct mntent **mnt); 520 521/* tab-parse.c */ 522extern struct libmnt_table *mnt_new_table_from_file(const char *filename) 523 __ul_attribute__((warn_unused_result)); 524extern struct libmnt_table *mnt_new_table_from_dir(const char *dirname) 525 __ul_attribute__((warn_unused_result)); 526extern int mnt_table_parse_stream(struct libmnt_table *tb, FILE *f, 527 const char *filename); 528extern int mnt_table_parse_file(struct libmnt_table *tb, const char *filename); 529extern int mnt_table_parse_dir(struct libmnt_table *tb, const char *dirname); 530 531extern int mnt_table_parse_fstab(struct libmnt_table *tb, const char *filename); 532extern int mnt_table_parse_swaps(struct libmnt_table *tb, const char *filename); 533extern int mnt_table_parse_mtab(struct libmnt_table *tb, const char *filename); 534extern int mnt_table_set_parser_errcb(struct libmnt_table *tb, 535 int (*cb)(struct libmnt_table *tb, const char *filename, int line)); 536 537/* tab.c */ 538extern struct libmnt_table *mnt_new_table(void) 539 __ul_attribute__((warn_unused_result)); 540extern void mnt_free_table(struct libmnt_table *tb); 541 542extern void mnt_ref_table(struct libmnt_table *tb); 543extern void mnt_unref_table(struct libmnt_table *tb); 544 545extern int mnt_reset_table(struct libmnt_table *tb); 546extern int mnt_table_get_nents(struct libmnt_table *tb); 547extern int mnt_table_is_empty(struct libmnt_table *tb); 548 549extern int mnt_table_set_userdata(struct libmnt_table *tb, void *data); 550extern void *mnt_table_get_userdata(struct libmnt_table *tb); 551 552extern void mnt_table_enable_comments(struct libmnt_table *tb, int enable); 553extern int mnt_table_with_comments(struct libmnt_table *tb); 554extern const char *mnt_table_get_intro_comment(struct libmnt_table *tb); 555extern int mnt_table_set_intro_comment(struct libmnt_table *tb, const char *comm); 556extern int mnt_table_append_intro_comment(struct libmnt_table *tb, const char *comm); 557extern int mnt_table_set_trailing_comment(struct libmnt_table *tb, const char *comm); 558extern const char *mnt_table_get_trailing_comment(struct libmnt_table *tb); 559extern int mnt_table_append_trailing_comment(struct libmnt_table *tb, const char *comm); 560 561extern int mnt_table_set_cache(struct libmnt_table *tb, struct libmnt_cache *mpc); 562extern struct libmnt_cache *mnt_table_get_cache(struct libmnt_table *tb); 563extern int mnt_table_add_fs(struct libmnt_table *tb, struct libmnt_fs *fs); 564extern int mnt_table_find_fs(struct libmnt_table *tb, struct libmnt_fs *fs); 565extern int mnt_table_insert_fs(struct libmnt_table *tb, int before, 566 struct libmnt_fs *pos, struct libmnt_fs *fs); 567extern int mnt_table_move_fs(struct libmnt_table *src, struct libmnt_table *dst, 568 int before, struct libmnt_fs *pos, struct libmnt_fs *fs); 569extern int mnt_table_remove_fs(struct libmnt_table *tb, struct libmnt_fs *fs); 570extern int mnt_table_first_fs(struct libmnt_table *tb, struct libmnt_fs **fs); 571extern int mnt_table_last_fs(struct libmnt_table *tb, struct libmnt_fs **fs); 572extern int mnt_table_next_fs(struct libmnt_table *tb, struct libmnt_iter *itr, 573 struct libmnt_fs **fs); 574extern int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr, 575 struct libmnt_fs *parent, struct libmnt_fs **chld); 576extern int mnt_table_get_root_fs(struct libmnt_table *tb, struct libmnt_fs **root); 577extern int mnt_table_set_iter(struct libmnt_table *tb, struct libmnt_iter *itr, 578 struct libmnt_fs *fs); 579 580enum { 581 MNT_UNIQ_FORWARD = (1 << 1), /* default is backward */ 582 MNT_UNIQ_KEEPTREE = (1 << 2) 583}; 584extern int mnt_table_uniq_fs(struct libmnt_table *tb, int flags, 585 int (*cmp)(struct libmnt_table *, 586 struct libmnt_fs *, 587 struct libmnt_fs *)); 588 589extern struct libmnt_fs *mnt_table_find_mountpoint(struct libmnt_table *tb, 590 const char *path, int direction); 591extern struct libmnt_fs *mnt_table_find_target(struct libmnt_table *tb, 592 const char *path, int direction); 593extern struct libmnt_fs *mnt_table_find_srcpath(struct libmnt_table *tb, 594 const char *path, int direction); 595extern struct libmnt_fs *mnt_table_find_tag(struct libmnt_table *tb, const char *tag, 596 const char *val, int direction); 597extern struct libmnt_fs *mnt_table_find_target_with_option(struct libmnt_table *tb, const char *path, 598 const char *option, const char *val, int direction); 599extern struct libmnt_fs *mnt_table_find_source(struct libmnt_table *tb, 600 const char *source, int direction); 601extern struct libmnt_fs *mnt_table_find_pair(struct libmnt_table *tb, 602 const char *source, 603 const char *target, int direction); 604extern struct libmnt_fs *mnt_table_find_devno(struct libmnt_table *tb, 605 dev_t devno, int direction); 606 607extern int mnt_table_find_next_fs(struct libmnt_table *tb, 608 struct libmnt_iter *itr, 609 int (*match_func)(struct libmnt_fs *, void *), 610 void *userdata, 611 struct libmnt_fs **fs); 612 613extern int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs); 614 615/* tab_update.c */ 616extern struct libmnt_update *mnt_new_update(void) 617 __ul_attribute__((warn_unused_result)); 618extern void mnt_free_update(struct libmnt_update *upd); 619 620extern int mnt_table_replace_file(struct libmnt_table *tb, const char *filename); 621extern int mnt_table_write_file(struct libmnt_table *tb, FILE *file); 622 623extern int mnt_update_is_ready(struct libmnt_update *upd); 624extern int mnt_update_set_fs(struct libmnt_update *upd, unsigned long mountflags, 625 const char *target, struct libmnt_fs *fs); 626extern int mnt_update_table(struct libmnt_update *upd, struct libmnt_lock *lc); 627extern unsigned long mnt_update_get_mflags(struct libmnt_update *upd); 628extern int mnt_update_force_rdonly(struct libmnt_update *upd, int rdonly); 629extern const char *mnt_update_get_filename(struct libmnt_update *upd); 630extern struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd); 631 632/* tab_diff.c */ 633enum { 634 MNT_TABDIFF_MOUNT = 1, 635 MNT_TABDIFF_UMOUNT, 636 MNT_TABDIFF_MOVE, 637 MNT_TABDIFF_REMOUNT, 638 MNT_TABDIFF_PROPAGATION, /* not implemented yet (TODO) */ 639}; 640 641extern struct libmnt_tabdiff *mnt_new_tabdiff(void) 642 __ul_attribute__((warn_unused_result)); 643extern void mnt_free_tabdiff(struct libmnt_tabdiff *df); 644 645extern int mnt_diff_tables(struct libmnt_tabdiff *df, 646 struct libmnt_table *old_tab, 647 struct libmnt_table *new_tab); 648 649extern int mnt_tabdiff_next_change(struct libmnt_tabdiff *df, 650 struct libmnt_iter *itr, 651 struct libmnt_fs **old_fs, 652 struct libmnt_fs **new_fs, 653 int *oper); 654 655/* monitor.c */ 656enum { 657 MNT_MONITOR_TYPE_USERSPACE = 1, /* userspace mount options */ 658 MNT_MONITOR_TYPE_KERNEL /* kernel mount table */ 659}; 660 661extern struct libmnt_monitor *mnt_new_monitor(void); 662extern void mnt_ref_monitor(struct libmnt_monitor *mn); 663extern void mnt_unref_monitor(struct libmnt_monitor *mn); 664 665extern int mnt_monitor_enable_kernel(struct libmnt_monitor *mn, int enable); 666extern int mnt_monitor_enable_userspace(struct libmnt_monitor *mn, 667 int enable, const char *filename); 668 669extern int mnt_monitor_get_fd(struct libmnt_monitor *mn); 670extern int mnt_monitor_close_fd(struct libmnt_monitor *mn); 671extern int mnt_monitor_wait(struct libmnt_monitor *mn, int timeout); 672 673extern int mnt_monitor_next_change(struct libmnt_monitor *mn, 674 const char **filename, int *type); 675extern int mnt_monitor_event_cleanup(struct libmnt_monitor *mn); 676 677 678/* context.c */ 679 680/* 681 * Mode for mount options from fstab (or mtab), see mnt_context_set_optsmode(). 682 */ 683enum { 684 MNT_OMODE_IGNORE = (1 << 1), /* ignore mtab/fstab options */ 685 MNT_OMODE_APPEND = (1 << 2), /* append mtab/fstab options to existing options */ 686 MNT_OMODE_PREPEND = (1 << 3), /* prepend mtab/fstab options to existing options */ 687 MNT_OMODE_REPLACE = (1 << 4), /* replace existing options with options from mtab/fstab */ 688 689 MNT_OMODE_FORCE = (1 << 5), /* always read mtab/fstab options */ 690 691 MNT_OMODE_FSTAB = (1 << 10), /* read from fstab */ 692 MNT_OMODE_MTAB = (1 << 11), /* read from mtab if fstab not enabled or failed */ 693 MNT_OMODE_NOTAB = (1 << 12), /* do not read fstab/mtab at all */ 694 695 /* default */ 696 MNT_OMODE_AUTO = (MNT_OMODE_PREPEND | MNT_OMODE_FSTAB | MNT_OMODE_MTAB), 697 /* non-root users */ 698 MNT_OMODE_USER = (MNT_OMODE_REPLACE | MNT_OMODE_FORCE | MNT_OMODE_FSTAB) 699}; 700 701extern struct libmnt_context *mnt_new_context(void) 702 __ul_attribute__((warn_unused_result)); 703extern void mnt_free_context(struct libmnt_context *cxt); 704 705extern int mnt_reset_context(struct libmnt_context *cxt); 706extern int mnt_context_is_restricted(struct libmnt_context *cxt) 707 __ul_attribute__((nonnull)); 708extern int mnt_context_force_unrestricted(struct libmnt_context *cxt); 709 710extern int mnt_context_init_helper(struct libmnt_context *cxt, 711 int action, int flags); 712extern int mnt_context_helper_setopt(struct libmnt_context *cxt, int c, char *arg); 713 714extern int mnt_context_set_optsmode(struct libmnt_context *cxt, int mode); 715extern int mnt_context_disable_canonicalize(struct libmnt_context *cxt, int disable); 716extern int mnt_context_enable_lazy(struct libmnt_context *cxt, int enable); 717extern int mnt_context_enable_rdonly_umount(struct libmnt_context *cxt, int enable); 718extern int mnt_context_enable_rwonly_mount(struct libmnt_context *cxt, int enable); 719extern int mnt_context_disable_helpers(struct libmnt_context *cxt, int disable); 720extern int mnt_context_enable_sloppy(struct libmnt_context *cxt, int enable); 721extern int mnt_context_enable_fake(struct libmnt_context *cxt, int enable); 722extern int mnt_context_disable_mtab(struct libmnt_context *cxt, int disable); 723extern int mnt_context_enable_force(struct libmnt_context *cxt, int enable); 724extern int mnt_context_enable_verbose(struct libmnt_context *cxt, int enable); 725extern int mnt_context_enable_loopdel(struct libmnt_context *cxt, int enable); 726extern int mnt_context_enable_fork(struct libmnt_context *cxt, int enable); 727extern int mnt_context_disable_swapmatch(struct libmnt_context *cxt, int disable); 728 729extern int mnt_context_get_optsmode(struct libmnt_context *cxt); 730 731extern int mnt_context_is_lazy(struct libmnt_context *cxt) 732 __ul_attribute__((nonnull)); 733extern int mnt_context_is_rdonly_umount(struct libmnt_context *cxt) 734 __ul_attribute__((nonnull)); 735extern int mnt_context_is_rwonly_mount(struct libmnt_context *cxt) 736 __ul_attribute__((nonnull)); 737extern int mnt_context_is_sloppy(struct libmnt_context *cxt) 738 __ul_attribute__((nonnull)); 739extern int mnt_context_is_fake(struct libmnt_context *cxt) 740 __ul_attribute__((nonnull)); 741extern int mnt_context_is_nomtab(struct libmnt_context *cxt) 742 __ul_attribute__((nonnull)); 743extern int mnt_context_is_force(struct libmnt_context *cxt) 744 __ul_attribute__((nonnull)); 745extern int mnt_context_is_verbose(struct libmnt_context *cxt) 746 __ul_attribute__((nonnull)); 747extern int mnt_context_is_loopdel(struct libmnt_context *cxt) 748 __ul_attribute__((nonnull)); 749extern int mnt_context_is_nohelpers(struct libmnt_context *cxt) 750 __ul_attribute__((nonnull)); 751extern int mnt_context_is_nocanonicalize(struct libmnt_context *cxt) 752 __ul_attribute__((nonnull)); 753extern int mnt_context_is_swapmatch(struct libmnt_context *cxt) 754 __ul_attribute__((nonnull)); 755extern int mnt_context_forced_rdonly(struct libmnt_context *cxt) 756 __ul_attribute__((nonnull)); 757 758extern int mnt_context_is_fork(struct libmnt_context *cxt) 759 __ul_attribute__((nonnull)); 760extern int mnt_context_is_parent(struct libmnt_context *cxt) 761 __ul_attribute__((nonnull)); 762extern int mnt_context_is_child(struct libmnt_context *cxt) 763 __ul_attribute__((nonnull)); 764 765extern int mnt_context_wait_for_children(struct libmnt_context *cxt, 766 int *nchildren, int *nerrs); 767 768extern int mnt_context_is_fs_mounted(struct libmnt_context *cxt, 769 struct libmnt_fs *fs, int *mounted); 770extern int mnt_context_set_fs(struct libmnt_context *cxt, struct libmnt_fs *fs); 771extern struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt); 772 773extern int mnt_context_set_source(struct libmnt_context *cxt, const char *source); 774extern int mnt_context_set_target(struct libmnt_context *cxt, const char *target); 775extern int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype); 776extern int mnt_context_set_target_prefix(struct libmnt_context *cxt, const char *path); 777 778extern const char *mnt_context_get_source(struct libmnt_context *cxt); 779extern const char *mnt_context_get_target(struct libmnt_context *cxt); 780extern const char *mnt_context_get_fstype(struct libmnt_context *cxt); 781extern const char *mnt_context_get_target_prefix(struct libmnt_context *cxt); 782 783extern void *mnt_context_get_mtab_userdata(struct libmnt_context *cxt); 784extern void *mnt_context_get_fstab_userdata(struct libmnt_context *cxt); 785extern void *mnt_context_get_fs_userdata(struct libmnt_context *cxt); 786 787extern int mnt_context_set_options(struct libmnt_context *cxt, const char *optstr); 788extern int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr); 789 790extern const char *mnt_context_get_options(struct libmnt_context *cxt); 791 792extern int mnt_context_set_fstype_pattern(struct libmnt_context *cxt, const char *pattern); 793extern int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *pattern); 794 795extern int mnt_context_set_passwd_cb(struct libmnt_context *cxt, 796 char *(*get)(struct libmnt_context *), 797 void (*release)(struct libmnt_context *, char *)) 798 __ul_attribute__((deprecated)); 799 800extern int mnt_context_set_tables_errcb(struct libmnt_context *cxt, 801 int (*cb)(struct libmnt_table *tb, const char *filename, int line)); 802extern int mnt_context_set_fstab(struct libmnt_context *cxt, 803 struct libmnt_table *tb); 804extern int mnt_context_get_fstab(struct libmnt_context *cxt, 805 struct libmnt_table **tb); 806 807extern int mnt_context_get_mtab(struct libmnt_context *cxt, 808 struct libmnt_table **tb); 809extern int mnt_context_get_table(struct libmnt_context *cxt, 810 const char *filename, 811 struct libmnt_table **tb); 812extern int mnt_context_set_cache(struct libmnt_context *cxt, 813 struct libmnt_cache *cache); 814extern struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt); 815extern struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt); 816extern int mnt_context_set_mflags(struct libmnt_context *cxt, 817 unsigned long flags); 818extern int mnt_context_get_mflags(struct libmnt_context *cxt, 819 unsigned long *flags); 820extern int mnt_context_set_user_mflags(struct libmnt_context *cxt, 821 unsigned long flags); 822extern int mnt_context_get_user_mflags(struct libmnt_context *cxt, 823 unsigned long *flags); 824 825extern int mnt_context_set_mountdata(struct libmnt_context *cxt, void *data); 826extern int mnt_context_apply_fstab(struct libmnt_context *cxt); 827 828extern int mnt_context_reset_status(struct libmnt_context *cxt); 829extern int mnt_context_get_status(struct libmnt_context *cxt); 830 831extern int mnt_context_helper_executed(struct libmnt_context *cxt); 832extern int mnt_context_get_helper_status(struct libmnt_context *cxt); 833 834extern int mnt_context_syscall_called(struct libmnt_context *cxt); 835 836extern int mnt_context_get_syscall_errno(struct libmnt_context *cxt); 837 838extern int mnt_context_strerror(struct libmnt_context *cxt, char *buf, 839 size_t bufsiz) 840 __ul_attribute__((deprecated)); 841 842extern int mnt_context_get_excode(struct libmnt_context *cxt, 843 int rc, char *buf, size_t bufsz); 844 845extern int mnt_context_set_target_ns(struct libmnt_context *cxt, const char *path); 846extern struct libmnt_ns *mnt_context_get_target_ns(struct libmnt_context *cxt); 847extern struct libmnt_ns *mnt_context_get_origin_ns(struct libmnt_context *cxt); 848extern struct libmnt_ns *mnt_context_switch_ns(struct libmnt_context *cxt, struct libmnt_ns *ns); 849extern struct libmnt_ns *mnt_context_switch_origin_ns(struct libmnt_context *cxt); 850extern struct libmnt_ns *mnt_context_switch_target_ns(struct libmnt_context *cxt); 851 852 853/* context_mount.c */ 854extern int mnt_context_mount(struct libmnt_context *cxt); 855extern int mnt_context_umount(struct libmnt_context *cxt); 856extern int mnt_context_next_mount(struct libmnt_context *cxt, 857 struct libmnt_iter *itr, 858 struct libmnt_fs **fs, 859 int *mntrc, int *ignored); 860 861extern int mnt_context_next_remount(struct libmnt_context *cxt, 862 struct libmnt_iter *itr, 863 struct libmnt_fs **fs, 864 int *mntrc, 865 int *ignored); 866 867extern int mnt_context_prepare_mount(struct libmnt_context *cxt) 868 __ul_attribute__((warn_unused_result)); 869extern int mnt_context_do_mount(struct libmnt_context *cxt); 870extern int mnt_context_finalize_mount(struct libmnt_context *cxt); 871 872/* context_umount.c */ 873extern int mnt_context_find_umount_fs(struct libmnt_context *cxt, 874 const char *tgt, 875 struct libmnt_fs **pfs); 876extern int mnt_context_next_umount(struct libmnt_context *cxt, 877 struct libmnt_iter *itr, 878 struct libmnt_fs **fs, 879 int *mntrc, int *ignored); 880 881extern int mnt_context_prepare_umount(struct libmnt_context *cxt) 882 __ul_attribute__((warn_unused_result)); 883extern int mnt_context_do_umount(struct libmnt_context *cxt); 884extern int mnt_context_finalize_umount(struct libmnt_context *cxt); 885 886extern int mnt_context_tab_applied(struct libmnt_context *cxt); 887extern int mnt_context_set_syscall_status(struct libmnt_context *cxt, int status); 888 889/* 890 * mount(8) userspace options masks (MNT_MAP_USERSPACE map) 891 */ 892#define MNT_MS_NOAUTO (1 << 2) 893#define MNT_MS_USER (1 << 3) 894#define MNT_MS_USERS (1 << 4) 895#define MNT_MS_OWNER (1 << 5) 896#define MNT_MS_GROUP (1 << 6) 897#define MNT_MS_NETDEV (1 << 7) 898#define MNT_MS_COMMENT (1 << 8) 899#define MNT_MS_LOOP (1 << 9) 900#define MNT_MS_NOFAIL (1 << 10) 901#define MNT_MS_UHELPER (1 << 11) 902#define MNT_MS_HELPER (1 << 12) 903#define MNT_MS_XCOMMENT (1 << 13) 904#define MNT_MS_OFFSET (1 << 14) 905#define MNT_MS_SIZELIMIT (1 << 15) 906#define MNT_MS_ENCRYPTION (1 << 16) 907#define MNT_MS_XFSTABCOMM (1 << 17) 908#define MNT_MS_HASH_DEVICE (1 << 18) 909#define MNT_MS_ROOT_HASH (1 << 19) 910#define MNT_MS_HASH_OFFSET (1 << 20) 911#define MNT_MS_ROOT_HASH_FILE (1 << 21) 912#define MNT_MS_FEC_DEVICE (1 << 22) 913#define MNT_MS_FEC_OFFSET (1 << 23) 914#define MNT_MS_FEC_ROOTS (1 << 24) 915#define MNT_MS_ROOT_HASH_SIG (1 << 25) 916 917/* 918 * mount(2) MS_* masks (MNT_MAP_LINUX map) 919 */ 920#ifndef MS_RDONLY 921#define MS_RDONLY 1 /* Mount read-only */ 922#endif 923#ifndef MS_NOSUID 924#define MS_NOSUID 2 /* Ignore suid and sgid bits */ 925#endif 926#ifndef MS_NODEV 927#define MS_NODEV 4 /* Disallow access to device special files */ 928#endif 929#ifndef MS_NOEXEC 930#define MS_NOEXEC 8 /* Disallow program execution */ 931#endif 932#ifndef MS_SYNCHRONOUS 933#define MS_SYNCHRONOUS 16 /* Writes are synced at once */ 934#endif 935#ifndef MS_REMOUNT 936#define MS_REMOUNT 32 /* Alter flags of a mounted FS */ 937#endif 938#ifndef MS_MANDLOCK 939#define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */ 940#endif 941#ifndef MS_DIRSYNC 942#define MS_DIRSYNC 128 /* Directory modifications are synchronous */ 943#endif 944#ifndef MS_NOATIME 945#define MS_NOATIME 0x400 /* 1024: Do not update access times. */ 946#endif 947#ifndef MS_NODIRATIME 948#define MS_NODIRATIME 0x800 /* 2048: Don't update directory access times */ 949#endif 950#ifndef MS_BIND 951#define MS_BIND 0x1000 /* 4096: Mount existing tree elsewhere as well */ 952#endif 953#ifndef MS_MOVE 954#define MS_MOVE 0x2000 /* 8192: Atomically move the tree */ 955#endif 956#ifndef MS_REC 957#define MS_REC 0x4000 /* 16384: Recursive loopback */ 958#endif 959#ifndef MS_SILENT 960#define MS_SILENT 0x8000 /* 32768: Don't emit certain kernel messages */ 961#endif 962#ifndef MS_UNBINDABLE 963#define MS_UNBINDABLE (1<<17) /* 131072: Make unbindable */ 964#endif 965#ifndef MS_PRIVATE 966#define MS_PRIVATE (1<<18) /* 262144: Make private */ 967#endif 968#ifndef MS_SLAVE 969#define MS_SLAVE (1<<19) /* 524288: Make slave */ 970#endif 971#ifndef MS_SHARED 972#define MS_SHARED (1<<20) /* 1048576: Make shared */ 973#endif 974#ifndef MS_RELATIME 975#define MS_RELATIME (1<<21) /* 2097152: Update atime relative to mtime/ctime */ 976#endif 977#ifndef MS_I_VERSION 978#define MS_I_VERSION (1<<23) /* Update the inode I_version field */ 979#endif 980#ifndef MS_STRICTATIME 981#define MS_STRICTATIME (1<<24) /* Always perform atime updates */ 982#endif 983#ifndef MS_LAZYTIME 984#define MS_LAZYTIME (1<<25) /* Update the on-disk [acm]times lazily */ 985#endif 986 987 988/* 989 * Magic mount flag number. Had to be or-ed to the flag values. Deprecated and 990 * no more used since libmount v2.33; required for Linux <= 2.4. 991 */ 992#ifndef MS_MGC_VAL 993#define MS_MGC_VAL 0xC0ED0000 /* magic flag number to indicate "new" flags */ 994#endif 995#ifndef MS_MGC_MSK 996#define MS_MGC_MSK 0xffff0000 /* magic flag number mask */ 997#endif 998 999 1000/* Shared-subtree options */ 1001#define MS_PROPAGATION (MS_SHARED|MS_SLAVE|MS_UNBINDABLE|MS_PRIVATE) 1002 1003/* Options that we make ordinary users have by default. */ 1004#define MS_SECURE (MS_NOEXEC|MS_NOSUID|MS_NODEV) 1005 1006/* Options that we make owner-mounted devices have by default */ 1007#define MS_OWNERSECURE (MS_NOSUID|MS_NODEV) 1008 1009#ifdef __cplusplus 1010} 1011#endif 1012 1013#endif /* _LIBMOUNT_MOUNT_H */ 1014