libmount/src/libmount.h.in

   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
  28 extern "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  */
  53 struct libmnt_cache;
  54
  55 /**
  56  * libmnt_lock:
  57  *
  58  * Stores information about the locked file (e.g. /etc/mtab)
  59  */
  60 struct libmnt_lock;
  61
  62 /**
  63  * libmnt_iter:
  64  *
  65  * Generic iterator (stores state about lists)
  66  */
  67 struct 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  */
  77 struct 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  */
  97 struct libmnt_fs;
  98
  99 /**
 100  * libmnt_table:
 101  *
 102  * List of struct libmnt_fs entries (parsed fstab/mtab/mountinfo)
 103  */
 104 struct libmnt_table;
 105
 106 /**
 107  * libmnt_update
 108  *
 109  * /etc/mtab or utab update description
 110  */
 111 struct libmnt_update;
 112
 113 /**
 114  * libmnt_context
 115  *
 116  * Mount/umount status
 117  */
 118 struct libmnt_context;
 119
 120 /**
 121  * libmnt_monitor
 122  *
 123  * Mount tables monitor
 124  */
 125 struct libmnt_monitor;
 126
 127 /**
 128  * libmnt_tabdiff:
 129  *
 130  * Stores mountinfo state
 131  */
 132 struct libmnt_tabdiff;
 133
 134 /**
 135  * libmnt_ns:
 136  *
 137  * Describes mount namespace
 138  */
 139 struct libmnt_ns;
 140
 141 /*
 142  * Actions
 143  */
 144 enum {
 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 */
 302 extern void mnt_init_debug(int mask);
 303
 304 /* version.c */
 305 extern int mnt_parse_version_string(const char *ver_string);
 306 extern int mnt_get_library_version(const char **ver_string);
 307 extern int mnt_get_library_features(const char ***features);
 308
 309 /* utils.c */
 310 extern char *mnt_mangle(const char *str)
 311                         __ul_attribute__((warn_unused_result));
 312 extern char *mnt_unmangle(const char *str)
 313                         __ul_attribute__((warn_unused_result));
 314
 315 extern int mnt_tag_is_valid(const char *tag);
 316 extern int mnt_fstype_is_netfs(const char *type);
 317 extern int mnt_fstype_is_pseudofs(const char *type);
 318
 319 extern int mnt_match_fstype(const char *type, const char *pattern)
 320                         __ul_attribute__((warn_unused_result));
 321 extern int mnt_match_options(const char *optstr, const char *pattern)
 322                         __ul_attribute__((warn_unused_result));
 323 extern const char *mnt_get_fstab_path(void);
 324 extern const char *mnt_get_swaps_path(void);
 325 extern const char *mnt_get_mtab_path(void);
 326 extern int mnt_has_regular_mtab(const char **mtab, int *writable);
 327 extern char *mnt_get_mountpoint(const char *path)
 328                         __ul_attribute__((warn_unused_result));
 329 extern int mnt_guess_system_root(dev_t devno, struct libmnt_cache *cache, char **path)
 330                         __ul_attribute__((nonnull(3)));
 331
 332 /* cache.c */
 333 extern struct libmnt_cache *mnt_new_cache(void)
 334                         __ul_attribute__((warn_unused_result));
 335 extern void mnt_free_cache(struct libmnt_cache *cache);
 336
 337 extern void mnt_ref_cache(struct libmnt_cache *cache);
 338 extern void mnt_unref_cache(struct libmnt_cache *cache);
 339
 340 extern int mnt_cache_set_targets(struct libmnt_cache *cache,
 341                                 struct libmnt_table *mtab);
 342 extern int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname);
 343
 344 extern int mnt_cache_device_has_tag(struct libmnt_cache *cache,
 345                                 const char *devname,
 346                                 const char *token,
 347                                 const char *value);
 348
 349 extern char *mnt_cache_find_tag_value(struct libmnt_cache *cache,
 350                                 const char *devname, const char *token);
 351
 352 extern char *mnt_get_fstype(const char *devname, int *ambi,
 353                             struct libmnt_cache *cache)
 354                         __ul_attribute__((warn_unused_result));
 355 extern char *mnt_resolve_path(const char *path, struct libmnt_cache *cache)
 356                         __ul_attribute__((warn_unused_result));
 357 extern char *mnt_resolve_target(const char *path, struct libmnt_cache *cache)
 358                         __ul_attribute__((warn_unused_result));
 359 extern char *mnt_resolve_tag(const char *token, const char *value,
 360                              struct libmnt_cache *cache)
 361                         __ul_attribute__((warn_unused_result));
 362 extern char *mnt_resolve_spec(const char *spec, struct libmnt_cache *cache)
 363                         __ul_attribute__((warn_unused_result));
 364 extern char *mnt_pretty_path(const char *path, struct libmnt_cache *cache)
 365                         __ul_attribute__((warn_unused_result));
 366
 367 /* optstr.c */
 368 extern int mnt_optstr_next_option(char **optstr, char **name, size_t *namesz,
 369                                 char **value, size_t *valuesz);
 370 extern int mnt_optstr_append_option(char **optstr, const char *name,
 371                                 const char *value);
 372 extern int mnt_optstr_prepend_option(char **optstr, const char *name,
 373                                 const char *value);
 374
 375 extern int mnt_optstr_get_option(const char *optstr, const char *name,
 376                                 char **value, size_t *valsz);
 377 extern int mnt_optstr_set_option(char **optstr, const char *name,
 378                                 const char *value);
 379 extern int mnt_optstr_remove_option(char **optstr, const char *name);
 380 extern int mnt_optstr_deduplicate_option(char **optstr, const char *name);
 381
 382 extern int mnt_split_optstr(const char *optstr,
 383                             char **user, char **vfs, char **fs,
 384                             int ignore_user, int ignore_vfs);
 385
 386 extern int mnt_optstr_get_options(const char *optstr, char **subset,
 387                             const struct libmnt_optmap *map, int ignore);
 388
 389 extern int mnt_optstr_get_flags(const char *optstr, unsigned long *flags,
 390                                 const struct libmnt_optmap *map);
 391
 392 extern int mnt_optstr_apply_flags(char **optstr, unsigned long flags,
 393                                 const struct libmnt_optmap *map);
 394
 395 /* iter.c */
 396 enum {
 397
 398         MNT_ITER_FORWARD = 0,
 399         MNT_ITER_BACKWARD
 400 };
 401 extern struct libmnt_iter *mnt_new_iter(int direction)
 402                         __ul_attribute__((warn_unused_result));
 403 extern void mnt_free_iter(struct libmnt_iter *itr);
 404
 405 extern void mnt_reset_iter(struct libmnt_iter *itr, int direction)
 406                         __ul_attribute__((nonnull));
 407 extern int mnt_iter_get_direction(struct libmnt_iter *itr)
 408                         __ul_attribute__((nonnull));
 409
 410 /* optmap.c */
 411 enum {
 412         MNT_LINUX_MAP = 1,
 413         MNT_USERSPACE_MAP
 414 };
 415 extern const struct libmnt_optmap *mnt_get_builtin_optmap(int id);
 416
 417 /* lock.c */
 418 extern struct libmnt_lock *mnt_new_lock(const char *datafile, pid_t id)
 419                         __ul_attribute__((warn_unused_result));
 420 extern void mnt_free_lock(struct libmnt_lock *ml);
 421
 422 extern void mnt_unlock_file(struct libmnt_lock *ml);
 423 extern int mnt_lock_file(struct libmnt_lock *ml);
 424 extern int mnt_lock_block_signals(struct libmnt_lock *ml, int enable);
 425
 426 /* fs.c */
 427 extern struct libmnt_fs *mnt_new_fs(void)
 428                         __ul_attribute__((warn_unused_result));
 429 extern void mnt_free_fs(struct libmnt_fs *fs);
 430 extern void mnt_ref_fs(struct libmnt_fs *fs);
 431 extern void mnt_unref_fs(struct libmnt_fs *fs);
 432
 433 extern void mnt_reset_fs(struct libmnt_fs *fs);
 434 extern struct libmnt_fs *mnt_copy_fs(struct libmnt_fs *dest,
 435                                      const struct libmnt_fs *src)
 436                         __ul_attribute__((warn_unused_result));
 437 extern void *mnt_fs_get_userdata(struct libmnt_fs *fs);
 438 extern int mnt_fs_set_userdata(struct libmnt_fs *fs, void *data);
 439 extern const char *mnt_fs_get_source(struct libmnt_fs *fs);
 440 extern int mnt_fs_set_source(struct libmnt_fs *fs, const char *source);
 441 extern const char *mnt_fs_get_srcpath(struct libmnt_fs *fs);
 442 extern int mnt_fs_get_table(struct libmnt_fs *fs, struct libmnt_table **tb);
 443
 444 extern int mnt_fs_get_tag(struct libmnt_fs *fs, const char **name,
 445                           const char **value);
 446 extern const char *mnt_fs_get_target(struct libmnt_fs *fs);
 447 extern int mnt_fs_set_target(struct libmnt_fs *fs, const char *tgt);
 448 extern const char *mnt_fs_get_fstype(struct libmnt_fs *fs);
 449 extern int mnt_fs_set_fstype(struct libmnt_fs *fs, const char *fstype);
 450
 451 extern int mnt_fs_streq_srcpath(struct libmnt_fs *fs, const char *path)
 452                         __ul_attribute__((warn_unused_result));
 453 extern int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
 454                         __ul_attribute__((warn_unused_result));
 455
 456 extern char *mnt_fs_strdup_options(struct libmnt_fs *fs)
 457                         __ul_attribute__((warn_unused_result));
 458 extern const char *mnt_fs_get_options(struct libmnt_fs *fs)
 459                         __ul_attribute__((warn_unused_result));
 460 extern const char *mnt_fs_get_optional_fields(struct libmnt_fs *fs)
 461                         __ul_attribute__((warn_unused_result));
 462 extern int mnt_fs_get_propagation(struct libmnt_fs *fs, unsigned long *flags);
 463
 464 extern int mnt_fs_set_options(struct libmnt_fs *fs, const char *optstr);
 465 extern int mnt_fs_append_options(struct libmnt_fs *fs, const char *optstr);
 466 extern int mnt_fs_prepend_options(struct libmnt_fs *fs, const char *optstr);
 467
 468 extern int mnt_fs_get_option(struct libmnt_fs *fs, const char *name,
 469                                 char **value, size_t *valsz);
 470
 471 extern const char *mnt_fs_get_fs_options(struct libmnt_fs *fs);
 472 extern const char *mnt_fs_get_vfs_options(struct libmnt_fs *fs);
 473 extern const char *mnt_fs_get_user_options(struct libmnt_fs *fs);
 474
 475 extern const char *mnt_fs_get_attributes(struct libmnt_fs *fs);
 476 extern int mnt_fs_set_attributes(struct libmnt_fs *fs, const char *optstr);
 477 extern int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name,
 478                                 char **value, size_t *valsz);
 479 extern int mnt_fs_append_attributes(struct libmnt_fs *fs, const char *optstr);
 480 extern int mnt_fs_prepend_attributes(struct libmnt_fs *fs, const char *optstr);
 481
 482 extern int mnt_fs_get_freq(struct libmnt_fs *fs);
 483 extern int mnt_fs_set_freq(struct libmnt_fs *fs, int freq);
 484 extern int mnt_fs_get_passno(struct libmnt_fs *fs);
 485 extern int mnt_fs_set_passno(struct libmnt_fs *fs, int passno);
 486 extern const char *mnt_fs_get_root(struct libmnt_fs *fs);
 487 extern int mnt_fs_set_root(struct libmnt_fs *fs, const char *path);
 488 extern const char *mnt_fs_get_bindsrc(struct libmnt_fs *fs);
 489 extern int mnt_fs_set_bindsrc(struct libmnt_fs *fs, const char *src);
 490 extern int mnt_fs_get_id(struct libmnt_fs *fs);
 491 extern int mnt_fs_get_parent_id(struct libmnt_fs *fs);
 492 extern dev_t mnt_fs_get_devno(struct libmnt_fs *fs);
 493 extern pid_t mnt_fs_get_tid(struct libmnt_fs *fs);
 494
 495 extern const char *mnt_fs_get_swaptype(struct libmnt_fs *fs);
 496 extern off_t mnt_fs_get_size(struct libmnt_fs *fs);
 497 extern off_t mnt_fs_get_usedsize(struct libmnt_fs *fs);
 498 extern int mnt_fs_get_priority(struct libmnt_fs *fs);
 499 extern int mnt_fs_set_priority(struct libmnt_fs *fs, int prio);
 500
 501 extern const char *mnt_fs_get_comment(struct libmnt_fs *fs);
 502 extern int mnt_fs_set_comment(struct libmnt_fs *fs, const char *comm);
 503 extern int mnt_fs_append_comment(struct libmnt_fs *fs, const char *comm);
 504
 505 extern int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
 506                                struct libmnt_cache *cache);
 507 extern int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
 508                                struct libmnt_cache *cache);
 509 extern int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types);
 510 extern int mnt_fs_match_options(struct libmnt_fs *fs, const char *options);
 511 extern int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file);
 512
 513 extern int mnt_fs_is_kernel(struct libmnt_fs *fs);
 514 extern int mnt_fs_is_swaparea(struct libmnt_fs *fs);
 515 extern int mnt_fs_is_netfs(struct libmnt_fs *fs);
 516 extern int mnt_fs_is_pseudofs(struct libmnt_fs *fs);
 517
 518 extern void mnt_free_mntent(struct mntent *mnt);
 519 extern int mnt_fs_to_mntent(struct libmnt_fs *fs, struct mntent **mnt);
 520
 521 /* tab-parse.c */
 522 extern struct libmnt_table *mnt_new_table_from_file(const char *filename)
 523                         __ul_attribute__((warn_unused_result));
 524 extern struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
 525                         __ul_attribute__((warn_unused_result));
 526 extern int mnt_table_parse_stream(struct libmnt_table *tb, FILE *f,
 527                                   const char *filename);
 528 extern int mnt_table_parse_file(struct libmnt_table *tb, const char *filename);
 529 extern int mnt_table_parse_dir(struct libmnt_table *tb, const char *dirname);
 530
 531 extern int mnt_table_parse_fstab(struct libmnt_table *tb, const char *filename);
 532 extern int mnt_table_parse_swaps(struct libmnt_table *tb, const char *filename);
 533 extern int mnt_table_parse_mtab(struct libmnt_table *tb, const char *filename);
 534 extern 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 */
 538 extern struct libmnt_table *mnt_new_table(void)
 539                         __ul_attribute__((warn_unused_result));
 540 extern void mnt_free_table(struct libmnt_table *tb);
 541
 542 extern void mnt_ref_table(struct libmnt_table *tb);
 543 extern void mnt_unref_table(struct libmnt_table *tb);
 544
 545 extern int mnt_reset_table(struct libmnt_table *tb);
 546 extern int mnt_table_get_nents(struct libmnt_table *tb);
 547 extern int mnt_table_is_empty(struct libmnt_table *tb);
 548
 549 extern int mnt_table_set_userdata(struct libmnt_table *tb, void *data);
 550 extern void *mnt_table_get_userdata(struct libmnt_table *tb);
 551
 552 extern void mnt_table_enable_comments(struct libmnt_table *tb, int enable);
 553 extern int mnt_table_with_comments(struct libmnt_table *tb);
 554 extern const char *mnt_table_get_intro_comment(struct libmnt_table *tb);
 555 extern int mnt_table_set_intro_comment(struct libmnt_table *tb, const char *comm);
 556 extern int mnt_table_append_intro_comment(struct libmnt_table *tb, const char *comm);
 557 extern int mnt_table_set_trailing_comment(struct libmnt_table *tb, const char *comm);
 558 extern const char *mnt_table_get_trailing_comment(struct libmnt_table *tb);
 559 extern int mnt_table_append_trailing_comment(struct libmnt_table *tb, const char *comm);
 560
 561 extern int mnt_table_set_cache(struct libmnt_table *tb, struct libmnt_cache *mpc);
 562 extern struct libmnt_cache *mnt_table_get_cache(struct libmnt_table *tb);
 563 extern int mnt_table_add_fs(struct libmnt_table *tb, struct libmnt_fs *fs);
 564 extern int mnt_table_find_fs(struct libmnt_table *tb, struct libmnt_fs *fs);
 565 extern int mnt_table_insert_fs(struct libmnt_table *tb, int before,
 566                                 struct libmnt_fs *pos, struct libmnt_fs *fs);
 567 extern int mnt_table_move_fs(struct libmnt_table *src, struct libmnt_table *dst,
 568                       int before, struct libmnt_fs *pos, struct libmnt_fs *fs);
 569 extern int mnt_table_remove_fs(struct libmnt_table *tb, struct libmnt_fs *fs);
 570 extern int mnt_table_first_fs(struct libmnt_table *tb, struct libmnt_fs **fs);
 571 extern int mnt_table_last_fs(struct libmnt_table *tb, struct libmnt_fs **fs);
 572 extern int mnt_table_next_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
 573                              struct libmnt_fs **fs);
 574 extern int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
 575                                 struct libmnt_fs *parent, struct libmnt_fs **chld);
 576 extern int mnt_table_get_root_fs(struct libmnt_table *tb, struct libmnt_fs **root);
 577 extern int mnt_table_set_iter(struct libmnt_table *tb, struct libmnt_iter *itr,
 578                               struct libmnt_fs *fs);
 579
 580 enum {
 581         MNT_UNIQ_FORWARD  = (1 << 1),   /* default is backward */
 582         MNT_UNIQ_KEEPTREE = (1 << 2)
 583 };
 584 extern 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
 589 extern struct libmnt_fs *mnt_table_find_mountpoint(struct libmnt_table *tb,
 590                                 const char *path, int direction);
 591 extern struct libmnt_fs *mnt_table_find_target(struct libmnt_table *tb,
 592                                 const char *path, int direction);
 593 extern struct libmnt_fs *mnt_table_find_srcpath(struct libmnt_table *tb,
 594                                 const char *path, int direction);
 595 extern struct libmnt_fs *mnt_table_find_tag(struct libmnt_table *tb, const char *tag,
 596                                 const char *val, int direction);
 597 extern 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);
 599 extern struct libmnt_fs *mnt_table_find_source(struct libmnt_table *tb,
 600                                 const char *source, int direction);
 601 extern struct libmnt_fs *mnt_table_find_pair(struct libmnt_table *tb,
 602                                 const char *source,
 603                                 const char *target, int direction);
 604 extern struct libmnt_fs *mnt_table_find_devno(struct libmnt_table *tb,
 605                                 dev_t devno, int direction);
 606
 607 extern 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
 613 extern int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs);
 614
 615 /* tab_update.c */
 616 extern struct libmnt_update *mnt_new_update(void)
 617                         __ul_attribute__((warn_unused_result));
 618 extern void mnt_free_update(struct libmnt_update *upd);
 619
 620 extern int mnt_table_replace_file(struct libmnt_table *tb, const char *filename);
 621 extern int mnt_table_write_file(struct libmnt_table *tb, FILE *file);
 622
 623 extern int mnt_update_is_ready(struct libmnt_update *upd);
 624 extern int mnt_update_set_fs(struct libmnt_update *upd, unsigned long mountflags,
 625                               const char *target, struct libmnt_fs *fs);
 626 extern int mnt_update_table(struct libmnt_update *upd, struct libmnt_lock *lc);
 627 extern unsigned long mnt_update_get_mflags(struct libmnt_update *upd);
 628 extern int mnt_update_force_rdonly(struct libmnt_update *upd, int rdonly);
 629 extern const char *mnt_update_get_filename(struct libmnt_update *upd);
 630 extern struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd);
 631
 632 /* tab_diff.c */
 633 enum {
 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
 641 extern struct libmnt_tabdiff *mnt_new_tabdiff(void)
 642                         __ul_attribute__((warn_unused_result));
 643 extern void mnt_free_tabdiff(struct libmnt_tabdiff *df);
 644
 645 extern int mnt_diff_tables(struct libmnt_tabdiff *df,
 646                            struct libmnt_table *old_tab,
 647                            struct libmnt_table *new_tab);
 648
 649 extern 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 */
 656 enum {
 657         MNT_MONITOR_TYPE_USERSPACE = 1, /* userspace mount options */
 658         MNT_MONITOR_TYPE_KERNEL         /* kernel mount table */
 659 };
 660
 661 extern struct libmnt_monitor *mnt_new_monitor(void);
 662 extern void mnt_ref_monitor(struct libmnt_monitor *mn);
 663 extern void mnt_unref_monitor(struct libmnt_monitor *mn);
 664
 665 extern int mnt_monitor_enable_kernel(struct libmnt_monitor *mn, int enable);
 666 extern int mnt_monitor_enable_userspace(struct libmnt_monitor *mn,
 667                                 int enable, const char *filename);
 668
 669 extern int mnt_monitor_get_fd(struct libmnt_monitor *mn);
 670 extern int mnt_monitor_close_fd(struct libmnt_monitor *mn);
 671 extern int mnt_monitor_wait(struct libmnt_monitor *mn, int timeout);
 672
 673 extern int mnt_monitor_next_change(struct libmnt_monitor *mn,
 674                              const char **filename, int *type);
 675 extern 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  */
 683 enum {
 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
 701 extern struct libmnt_context *mnt_new_context(void)
 702                         __ul_attribute__((warn_unused_result));
 703 extern void mnt_free_context(struct libmnt_context *cxt);
 704
 705 extern int mnt_reset_context(struct libmnt_context *cxt);
 706 extern int mnt_context_is_restricted(struct libmnt_context *cxt)
 707                         __ul_attribute__((nonnull));
 708 extern int mnt_context_force_unrestricted(struct libmnt_context *cxt);
 709
 710 extern int mnt_context_init_helper(struct libmnt_context *cxt,
 711                                    int action, int flags);
 712 extern int mnt_context_helper_setopt(struct libmnt_context *cxt, int c, char *arg);
 713
 714 extern int mnt_context_set_optsmode(struct libmnt_context *cxt, int mode);
 715 extern int mnt_context_disable_canonicalize(struct libmnt_context *cxt, int disable);
 716 extern int mnt_context_enable_lazy(struct libmnt_context *cxt, int enable);
 717 extern int mnt_context_enable_rdonly_umount(struct libmnt_context *cxt, int enable);
 718 extern int mnt_context_enable_rwonly_mount(struct libmnt_context *cxt, int enable);
 719 extern int mnt_context_disable_helpers(struct libmnt_context *cxt, int disable);
 720 extern int mnt_context_enable_sloppy(struct libmnt_context *cxt, int enable);
 721 extern int mnt_context_enable_fake(struct libmnt_context *cxt, int enable);
 722 extern int mnt_context_disable_mtab(struct libmnt_context *cxt, int disable);
 723 extern int mnt_context_enable_force(struct libmnt_context *cxt, int enable);
 724 extern int mnt_context_enable_verbose(struct libmnt_context *cxt, int enable);
 725 extern int mnt_context_enable_loopdel(struct libmnt_context *cxt, int enable);
 726 extern int mnt_context_enable_fork(struct libmnt_context *cxt, int enable);
 727 extern int mnt_context_disable_swapmatch(struct libmnt_context *cxt, int disable);
 728
 729 extern int mnt_context_get_optsmode(struct libmnt_context *cxt);
 730
 731 extern int mnt_context_is_lazy(struct libmnt_context *cxt)
 732                         __ul_attribute__((nonnull));
 733 extern int mnt_context_is_rdonly_umount(struct libmnt_context *cxt)
 734                         __ul_attribute__((nonnull));
 735 extern int mnt_context_is_rwonly_mount(struct libmnt_context *cxt)
 736                         __ul_attribute__((nonnull));
 737 extern int mnt_context_is_sloppy(struct libmnt_context *cxt)
 738                         __ul_attribute__((nonnull));
 739 extern int mnt_context_is_fake(struct libmnt_context *cxt)
 740                         __ul_attribute__((nonnull));
 741 extern int mnt_context_is_nomtab(struct libmnt_context *cxt)
 742                         __ul_attribute__((nonnull));
 743 extern int mnt_context_is_force(struct libmnt_context *cxt)
 744                         __ul_attribute__((nonnull));
 745 extern int mnt_context_is_verbose(struct libmnt_context *cxt)
 746                         __ul_attribute__((nonnull));
 747 extern int mnt_context_is_loopdel(struct libmnt_context *cxt)
 748                         __ul_attribute__((nonnull));
 749 extern int mnt_context_is_nohelpers(struct libmnt_context *cxt)
 750                         __ul_attribute__((nonnull));
 751 extern int mnt_context_is_nocanonicalize(struct libmnt_context *cxt)
 752                         __ul_attribute__((nonnull));
 753 extern int mnt_context_is_swapmatch(struct libmnt_context *cxt)
 754                         __ul_attribute__((nonnull));
 755 extern int mnt_context_forced_rdonly(struct libmnt_context *cxt)
 756                         __ul_attribute__((nonnull));
 757
 758 extern int mnt_context_is_fork(struct libmnt_context *cxt)
 759                         __ul_attribute__((nonnull));
 760 extern int mnt_context_is_parent(struct libmnt_context *cxt)
 761                         __ul_attribute__((nonnull));
 762 extern int mnt_context_is_child(struct libmnt_context *cxt)
 763                         __ul_attribute__((nonnull));
 764
 765 extern int mnt_context_wait_for_children(struct libmnt_context *cxt,
 766                                   int *nchildren, int *nerrs);
 767
 768 extern int mnt_context_is_fs_mounted(struct libmnt_context *cxt,
 769                               struct libmnt_fs *fs, int *mounted);
 770 extern int mnt_context_set_fs(struct libmnt_context *cxt, struct libmnt_fs *fs);
 771 extern struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt);
 772
 773 extern int mnt_context_set_source(struct libmnt_context *cxt, const char *source);
 774 extern int mnt_context_set_target(struct libmnt_context *cxt, const char *target);
 775 extern int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype);
 776 extern int mnt_context_set_target_prefix(struct libmnt_context *cxt, const char *path);
 777
 778 extern const char *mnt_context_get_source(struct libmnt_context *cxt);
 779 extern const char *mnt_context_get_target(struct libmnt_context *cxt);
 780 extern const char *mnt_context_get_fstype(struct libmnt_context *cxt);
 781 extern const char *mnt_context_get_target_prefix(struct libmnt_context *cxt);
 782
 783 extern void *mnt_context_get_mtab_userdata(struct libmnt_context *cxt);
 784 extern void *mnt_context_get_fstab_userdata(struct libmnt_context *cxt);
 785 extern void *mnt_context_get_fs_userdata(struct libmnt_context *cxt);
 786
 787 extern int mnt_context_set_options(struct libmnt_context *cxt, const char *optstr);
 788 extern int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr);
 789
 790 extern const char *mnt_context_get_options(struct libmnt_context *cxt);
 791
 792 extern int mnt_context_set_fstype_pattern(struct libmnt_context *cxt, const char *pattern);
 793 extern int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *pattern);
 794
 795 extern 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
 800 extern int mnt_context_set_tables_errcb(struct libmnt_context *cxt,
 801         int (*cb)(struct libmnt_table *tb, const char *filename, int line));
 802 extern int mnt_context_set_fstab(struct libmnt_context *cxt,
 803                                  struct libmnt_table *tb);
 804 extern int mnt_context_get_fstab(struct libmnt_context *cxt,
 805                                  struct libmnt_table **tb);
 806
 807 extern int mnt_context_get_mtab(struct libmnt_context *cxt,
 808                                 struct libmnt_table **tb);
 809 extern int mnt_context_get_table(struct libmnt_context *cxt,
 810                                 const char *filename,
 811                                 struct libmnt_table **tb);
 812 extern int mnt_context_set_cache(struct libmnt_context *cxt,
 813                                  struct libmnt_cache *cache);
 814 extern struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt);
 815 extern struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt);
 816 extern int mnt_context_set_mflags(struct libmnt_context *cxt,
 817                                       unsigned long flags);
 818 extern int mnt_context_get_mflags(struct libmnt_context *cxt,
 819                                       unsigned long *flags);
 820 extern int mnt_context_set_user_mflags(struct libmnt_context *cxt,
 821                                                 unsigned long flags);
 822 extern int mnt_context_get_user_mflags(struct libmnt_context *cxt,
 823                                                 unsigned long *flags);
 824
 825 extern int mnt_context_set_mountdata(struct libmnt_context *cxt, void *data);
 826 extern int mnt_context_apply_fstab(struct libmnt_context *cxt);
 827
 828 extern int mnt_context_reset_status(struct libmnt_context *cxt);
 829 extern int mnt_context_get_status(struct libmnt_context *cxt);
 830
 831 extern int mnt_context_helper_executed(struct libmnt_context *cxt);
 832 extern int mnt_context_get_helper_status(struct libmnt_context *cxt);
 833
 834 extern int mnt_context_syscall_called(struct libmnt_context *cxt);
 835
 836 extern int mnt_context_get_syscall_errno(struct libmnt_context *cxt);
 837
 838 extern int mnt_context_strerror(struct libmnt_context *cxt, char *buf,
 839                                 size_t bufsiz)
 840                                 __ul_attribute__((deprecated));
 841
 842 extern int mnt_context_get_excode(struct libmnt_context *cxt,
 843                         int rc, char *buf, size_t bufsz);
 844
 845 extern int mnt_context_set_target_ns(struct libmnt_context *cxt, const char *path);
 846 extern struct libmnt_ns *mnt_context_get_target_ns(struct libmnt_context *cxt);
 847 extern struct libmnt_ns *mnt_context_get_origin_ns(struct libmnt_context *cxt);
 848 extern struct libmnt_ns *mnt_context_switch_ns(struct libmnt_context *cxt, struct libmnt_ns *ns);
 849 extern struct libmnt_ns *mnt_context_switch_origin_ns(struct libmnt_context *cxt);
 850 extern struct libmnt_ns *mnt_context_switch_target_ns(struct libmnt_context *cxt);
 851
 852
 853 /* context_mount.c */
 854 extern int mnt_context_mount(struct libmnt_context *cxt);
 855 extern int mnt_context_umount(struct libmnt_context *cxt);
 856 extern 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
 861 extern 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
 867 extern int mnt_context_prepare_mount(struct libmnt_context *cxt)
 868                         __ul_attribute__((warn_unused_result));
 869 extern int mnt_context_do_mount(struct libmnt_context *cxt);
 870 extern int mnt_context_finalize_mount(struct libmnt_context *cxt);
 871
 872 /* context_umount.c */
 873 extern int mnt_context_find_umount_fs(struct libmnt_context *cxt,
 874                                const char *tgt,
 875                                struct libmnt_fs **pfs);
 876 extern 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
 881 extern int mnt_context_prepare_umount(struct libmnt_context *cxt)
 882                         __ul_attribute__((warn_unused_result));
 883 extern int mnt_context_do_umount(struct libmnt_context *cxt);
 884 extern int mnt_context_finalize_umount(struct libmnt_context *cxt);
 885
 886 extern int mnt_context_tab_applied(struct libmnt_context *cxt);
 887 extern 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
 909 /*
 910  * mount(2) MS_* masks (MNT_MAP_LINUX map)
 911  */
 912 #ifndef MS_RDONLY
 913 #define MS_RDONLY        1      /* Mount read-only */
 914 #endif
 915 #ifndef MS_NOSUID
 916 #define MS_NOSUID        2      /* Ignore suid and sgid bits */
 917 #endif
 918 #ifndef MS_NODEV
 919 #define MS_NODEV         4      /* Disallow access to device special files */
 920 #endif
 921 #ifndef MS_NOEXEC
 922 #define MS_NOEXEC        8      /* Disallow program execution */
 923 #endif
 924 #ifndef MS_SYNCHRONOUS
 925 #define MS_SYNCHRONOUS  16      /* Writes are synced at once */
 926 #endif
 927 #ifndef MS_REMOUNT
 928 #define MS_REMOUNT      32      /* Alter flags of a mounted FS */
 929 #endif
 930 #ifndef MS_MANDLOCK
 931 #define MS_MANDLOCK     64      /* Allow mandatory locks on an FS */
 932 #endif
 933 #ifndef MS_DIRSYNC
 934 #define MS_DIRSYNC      128     /* Directory modifications are synchronous */
 935 #endif
 936 #ifndef MS_NOATIME
 937 #define MS_NOATIME      0x400   /* 1024: Do not update access times. */
 938 #endif
 939 #ifndef MS_NODIRATIME
 940 #define MS_NODIRATIME   0x800   /* 2048: Don't update directory access times */
 941 #endif
 942 #ifndef MS_BIND
 943 #define MS_BIND         0x1000  /* 4096: Mount existing tree elsewhere as well */
 944 #endif
 945 #ifndef MS_MOVE
 946 #define MS_MOVE         0x2000  /* 8192: Atomically move the tree */
 947 #endif
 948 #ifndef MS_REC
 949 #define MS_REC          0x4000  /* 16384: Recursive loopback */
 950 #endif
 951 #ifndef MS_SILENT
 952 #define MS_SILENT       0x8000  /* 32768: Don't emit certain kernel messages */
 953 #endif
 954 #ifndef MS_UNBINDABLE
 955 #define MS_UNBINDABLE   (1<<17) /* 131072: Make unbindable */
 956 #endif
 957 #ifndef MS_PRIVATE
 958 #define MS_PRIVATE      (1<<18) /* 262144: Make private */
 959 #endif
 960 #ifndef MS_SLAVE
 961 #define MS_SLAVE        (1<<19) /* 524288: Make slave */
 962 #endif
 963 #ifndef MS_SHARED
 964 #define MS_SHARED       (1<<20) /* 1048576: Make shared */
 965 #endif
 966 #ifndef MS_RELATIME
 967 #define MS_RELATIME     (1<<21) /* 2097152: Update atime relative to mtime/ctime */
 968 #endif
 969 #ifndef MS_I_VERSION
 970 #define MS_I_VERSION    (1<<23) /* Update the inode I_version field */
 971 #endif
 972 #ifndef MS_STRICTATIME
 973 #define MS_STRICTATIME  (1<<24) /* Always perform atime updates */
 974 #endif
 975 #ifndef MS_LAZYTIME
 976 #define MS_LAZYTIME     (1<<25) /* Update the on-disk [acm]times lazily */
 977 #endif
 978
 979
 980 /*
 981  * Magic mount flag number. Had to be or-ed to the flag values.  Deprecated and
 982  * no more used since libmount v2.33; required for Linux <= 2.4.
 983  */
 984 #ifndef MS_MGC_VAL
 985 #define MS_MGC_VAL 0xC0ED0000   /* magic flag number to indicate "new" flags */
 986 #endif
 987 #ifndef MS_MGC_MSK
 988 #define MS_MGC_MSK 0xffff0000   /* magic flag number mask */
 989 #endif
 990
 991
 992 /* Shared-subtree options */
 993 #define MS_PROPAGATION  (MS_SHARED|MS_SLAVE|MS_UNBINDABLE|MS_PRIVATE)
 994
 995 /* Options that we make ordinary users have by default.  */
 996 #define MS_SECURE       (MS_NOEXEC|MS_NOSUID|MS_NODEV)
 997
 998 /* Options that we make owner-mounted devices have by default */
 999 #define MS_OWNERSECURE  (MS_NOSUID|MS_NODEV)
1000
1001 #ifdef __cplusplus
1002 }
1003 #endif
1004
1005 #endif /* _LIBMOUNT_MOUNT_H */