src/basic/mount-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <errno.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <sys/mount.h>
  24 #include <sys/stat.h>
  25 #include <sys/statvfs.h>
  26 #include <unistd.h>
  27
  28 #include "alloc-util.h"
  29 #include "escape.h"
  30 #include "fd-util.h"
  31 #include "fileio.h"
  32 #include "hashmap.h"
  33 #include "mount-util.h"
  34 #include "parse-util.h"
  35 #include "path-util.h"
  36 #include "set.h"
  37 #include "stdio-util.h"
  38 #include "string-util.h"
  39
  40 static int fd_fdinfo_mnt_id(int fd, const char *filename, int flags, int *mnt_id) {
  41         char path[strlen("/proc/self/fdinfo/") + DECIMAL_STR_MAX(int)];
  42         _cleanup_free_ char *fdinfo = NULL;
  43         _cleanup_close_ int subfd = -1;
  44         char *p;
  45         int r;
  46
  47         if ((flags & AT_EMPTY_PATH) && isempty(filename))
  48                 xsprintf(path, "/proc/self/fdinfo/%i", fd);
  49         else {
  50                 subfd = openat(fd, filename, O_CLOEXEC|O_PATH);
  51                 if (subfd < 0)
  52                         return -errno;
  53
  54                 xsprintf(path, "/proc/self/fdinfo/%i", subfd);
  55         }
  56
  57         r = read_full_file(path, &fdinfo, NULL);
  58         if (r == -ENOENT) /* The fdinfo directory is a relatively new addition */
  59                 return -EOPNOTSUPP;
  60         if (r < 0)
  61                 return -errno;
  62
  63         p = startswith(fdinfo, "mnt_id:");
  64         if (!p) {
  65                 p = strstr(fdinfo, "\nmnt_id:");
  66                 if (!p) /* The mnt_id field is a relatively new addition */
  67                         return -EOPNOTSUPP;
  68
  69                 p += 8;
  70         }
  71
  72         p += strspn(p, WHITESPACE);
  73         p[strcspn(p, WHITESPACE)] = 0;
  74
  75         return safe_atoi(p, mnt_id);
  76 }
  77
  78 int fd_is_mount_point(int fd, const char *filename, int flags) {
  79         union file_handle_union h = FILE_HANDLE_INIT, h_parent = FILE_HANDLE_INIT;
  80         int mount_id = -1, mount_id_parent = -1;
  81         bool nosupp = false, check_st_dev = true;
  82         struct stat a, b;
  83         int r;
  84
  85         assert(fd >= 0);
  86         assert(filename);
  87
  88         /* First we will try the name_to_handle_at() syscall, which
  89          * tells us the mount id and an opaque file "handle". It is
  90          * not supported everywhere though (kernel compile-time
  91          * option, not all file systems are hooked up). If it works
  92          * the mount id is usually good enough to tell us whether
  93          * something is a mount point.
  94          *
  95          * If that didn't work we will try to read the mount id from
  96          * /proc/self/fdinfo/<fd>. This is almost as good as
  97          * name_to_handle_at(), however, does not return the
  98          * opaque file handle. The opaque file handle is pretty useful
  99          * to detect the root directory, which we should always
 100          * consider a mount point. Hence we use this only as
 101          * fallback. Exporting the mnt_id in fdinfo is a pretty recent
 102          * kernel addition.
 103          *
 104          * As last fallback we do traditional fstat() based st_dev
 105          * comparisons. This is how things were traditionally done,
 106          * but unionfs breaks this since it exposes file
 107          * systems with a variety of st_dev reported. Also, btrfs
 108          * subvolumes have different st_dev, even though they aren't
 109          * real mounts of their own. */
 110
 111         r = name_to_handle_at(fd, filename, &h.handle, &mount_id, flags);
 112         if (r < 0) {
 113                 if (IN_SET(errno, ENOSYS, EACCES, EPERM))
 114                         /* This kernel does not support name_to_handle_at() at all, or the syscall was blocked (maybe
 115                          * through seccomp, because we are running inside of a container?): fall back to simpler
 116                          * logic. */
 117                         goto fallback_fdinfo;
 118                 else if (errno == EOPNOTSUPP)
 119                         /* This kernel or file system does not support
 120                          * name_to_handle_at(), hence let's see if the
 121                          * upper fs supports it (in which case it is a
 122                          * mount point), otherwise fallback to the
 123                          * traditional stat() logic */
 124                         nosupp = true;
 125                 else
 126                         return -errno;
 127         }
 128
 129         r = name_to_handle_at(fd, "", &h_parent.handle, &mount_id_parent, AT_EMPTY_PATH);
 130         if (r < 0) {
 131                 if (errno == EOPNOTSUPP) {
 132                         if (nosupp)
 133                                 /* Neither parent nor child do name_to_handle_at()?
 134                                    We have no choice but to fall back. */
 135                                 goto fallback_fdinfo;
 136                         else
 137                                 /* The parent can't do name_to_handle_at() but the
 138                                  * directory we are interested in can?
 139                                  * If so, it must be a mount point. */
 140                                 return 1;
 141                 } else
 142                         return -errno;
 143         }
 144
 145         /* The parent can do name_to_handle_at() but the
 146          * directory we are interested in can't? If so, it
 147          * must be a mount point. */
 148         if (nosupp)
 149                 return 1;
 150
 151         /* If the file handle for the directory we are
 152          * interested in and its parent are identical, we
 153          * assume this is the root directory, which is a mount
 154          * point. */
 155
 156         if (h.handle.handle_bytes == h_parent.handle.handle_bytes &&
 157             h.handle.handle_type == h_parent.handle.handle_type &&
 158             memcmp(h.handle.f_handle, h_parent.handle.f_handle, h.handle.handle_bytes) == 0)
 159                 return 1;
 160
 161         return mount_id != mount_id_parent;
 162
 163 fallback_fdinfo:
 164         r = fd_fdinfo_mnt_id(fd, filename, flags, &mount_id);
 165         if (IN_SET(r, -EOPNOTSUPP, -EACCES, -EPERM))
 166                 goto fallback_fstat;
 167         if (r < 0)
 168                 return r;
 169
 170         r = fd_fdinfo_mnt_id(fd, "", AT_EMPTY_PATH, &mount_id_parent);
 171         if (r < 0)
 172                 return r;
 173
 174         if (mount_id != mount_id_parent)
 175                 return 1;
 176
 177         /* Hmm, so, the mount ids are the same. This leaves one
 178          * special case though for the root file system. For that,
 179          * let's see if the parent directory has the same inode as we
 180          * are interested in. Hence, let's also do fstat() checks now,
 181          * too, but avoid the st_dev comparisons, since they aren't
 182          * that useful on unionfs mounts. */
 183         check_st_dev = false;
 184
 185 fallback_fstat:
 186         /* yay for fstatat() taking a different set of flags than the other
 187          * _at() above */
 188         if (flags & AT_SYMLINK_FOLLOW)
 189                 flags &= ~AT_SYMLINK_FOLLOW;
 190         else
 191                 flags |= AT_SYMLINK_NOFOLLOW;
 192         if (fstatat(fd, filename, &a, flags) < 0)
 193                 return -errno;
 194
 195         if (fstatat(fd, "", &b, AT_EMPTY_PATH) < 0)
 196                 return -errno;
 197
 198         /* A directory with same device and inode as its parent? Must
 199          * be the root directory */
 200         if (a.st_dev == b.st_dev &&
 201             a.st_ino == b.st_ino)
 202                 return 1;
 203
 204         return check_st_dev && (a.st_dev != b.st_dev);
 205 }
 206
 207 /* flags can be AT_SYMLINK_FOLLOW or 0 */
 208 int path_is_mount_point(const char *t, const char *root, int flags) {
 209         _cleanup_free_ char *canonical = NULL, *parent = NULL;
 210         _cleanup_close_ int fd = -1;
 211         int r;
 212
 213         assert(t);
 214
 215         if (path_equal(t, "/"))
 216                 return 1;
 217
 218         /* we need to resolve symlinks manually, we can't just rely on
 219          * fd_is_mount_point() to do that for us; if we have a structure like
 220          * /bin -> /usr/bin/ and /usr is a mount point, then the parent that we
 221          * look at needs to be /usr, not /. */
 222         if (flags & AT_SYMLINK_FOLLOW) {
 223                 r = chase_symlinks(t, root, 0, &canonical);
 224                 if (r < 0)
 225                         return r;
 226
 227                 t = canonical;
 228         }
 229
 230         parent = dirname_malloc(t);
 231         if (!parent)
 232                 return -ENOMEM;
 233
 234         fd = openat(AT_FDCWD, parent, O_DIRECTORY|O_CLOEXEC|O_PATH);
 235         if (fd < 0)
 236                 return -errno;
 237
 238         return fd_is_mount_point(fd, basename(t), flags);
 239 }
 240
 241 #if 0 /// UNNEEDED by elogind
 242 int umount_recursive(const char *prefix, int flags) {
 243         bool again;
 244         int n = 0, r;
 245
 246         /* Try to umount everything recursively below a
 247          * directory. Also, take care of stacked mounts, and keep
 248          * unmounting them until they are gone. */
 249
 250         do {
 251                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
 252
 253                 again = false;
 254                 r = 0;
 255
 256                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
 257                 if (!proc_self_mountinfo)
 258                         return -errno;
 259
 260                 for (;;) {
 261                         _cleanup_free_ char *path = NULL, *p = NULL;
 262                         int k;
 263
 264                         k = fscanf(proc_self_mountinfo,
 265                                    "%*s "       /* (1) mount id */
 266                                    "%*s "       /* (2) parent id */
 267                                    "%*s "       /* (3) major:minor */
 268                                    "%*s "       /* (4) root */
 269                                    "%ms "       /* (5) mount point */
 270                                    "%*s"        /* (6) mount options */
 271                                    "%*[^-]"     /* (7) optional fields */
 272                                    "- "         /* (8) separator */
 273                                    "%*s "       /* (9) file system type */
 274                                    "%*s"        /* (10) mount source */
 275                                    "%*s"        /* (11) mount options 2 */
 276                                    "%*[^\n]",   /* some rubbish at the end */
 277                                    &path);
 278                         if (k != 1) {
 279                                 if (k == EOF)
 280                                         break;
 281
 282                                 continue;
 283                         }
 284
 285                         r = cunescape(path, UNESCAPE_RELAX, &p);
 286                         if (r < 0)
 287                                 return r;
 288
 289                         if (!path_startswith(p, prefix))
 290                                 continue;
 291
 292                         if (umount2(p, flags) < 0) {
 293                                 r = log_debug_errno(errno, "Failed to umount %s: %m", p);
 294                                 continue;
 295                         }
 296
 297                         log_debug("Successfully unmounted %s", p);
 298
 299                         again = true;
 300                         n++;
 301
 302                         break;
 303                 }
 304
 305         } while (again);
 306
 307         return r ? r : n;
 308 }
 309
 310 static int get_mount_flags(const char *path, unsigned long *flags) {
 311         struct statvfs buf;
 312
 313         if (statvfs(path, &buf) < 0)
 314                 return -errno;
 315         *flags = buf.f_flag;
 316         return 0;
 317 }
 318
 319 int bind_remount_recursive(const char *prefix, bool ro, char **blacklist) {
 320         _cleanup_set_free_free_ Set *done = NULL;
 321         _cleanup_free_ char *cleaned = NULL;
 322         int r;
 323
 324         /* Recursively remount a directory (and all its submounts) read-only or read-write. If the directory is already
 325          * mounted, we reuse the mount and simply mark it MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
 326          * operation). If it isn't we first make it one. Afterwards we apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to
 327          * all submounts we can access, too. When mounts are stacked on the same mount point we only care for each
 328          * individual "top-level" mount on each point, as we cannot influence/access the underlying mounts anyway. We
 329          * do not have any effect on future submounts that might get propagated, they migt be writable. This includes
 330          * future submounts that have been triggered via autofs.
 331          *
 332          * If the "blacklist" parameter is specified it may contain a list of subtrees to exclude from the
 333          * remount operation. Note that we'll ignore the blacklist for the top-level path. */
 334
 335         cleaned = strdup(prefix);
 336         if (!cleaned)
 337                 return -ENOMEM;
 338
 339         path_kill_slashes(cleaned);
 340
 341         done = set_new(&string_hash_ops);
 342         if (!done)
 343                 return -ENOMEM;
 344
 345         for (;;) {
 346                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
 347                 _cleanup_set_free_free_ Set *todo = NULL;
 348                 bool top_autofs = false;
 349                 char *x;
 350                 unsigned long orig_flags;
 351
 352                 todo = set_new(&string_hash_ops);
 353                 if (!todo)
 354                         return -ENOMEM;
 355
 356                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
 357                 if (!proc_self_mountinfo)
 358                         return -errno;
 359
 360                 for (;;) {
 361                         _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
 362                         int k;
 363
 364                         k = fscanf(proc_self_mountinfo,
 365                                    "%*s "       /* (1) mount id */
 366                                    "%*s "       /* (2) parent id */
 367                                    "%*s "       /* (3) major:minor */
 368                                    "%*s "       /* (4) root */
 369                                    "%ms "       /* (5) mount point */
 370                                    "%*s"        /* (6) mount options (superblock) */
 371                                    "%*[^-]"     /* (7) optional fields */
 372                                    "- "         /* (8) separator */
 373                                    "%ms "       /* (9) file system type */
 374                                    "%*s"        /* (10) mount source */
 375                                    "%*s"        /* (11) mount options (bind mount) */
 376                                    "%*[^\n]",   /* some rubbish at the end */
 377                                    &path,
 378                                    &type);
 379                         if (k != 2) {
 380                                 if (k == EOF)
 381                                         break;
 382
 383                                 continue;
 384                         }
 385
 386                         r = cunescape(path, UNESCAPE_RELAX, &p);
 387                         if (r < 0)
 388                                 return r;
 389
 390                         if (!path_startswith(p, cleaned))
 391                                 continue;
 392
 393                         /* Ignore this mount if it is blacklisted, but only if it isn't the top-level mount we shall
 394                          * operate on. */
 395                         if (!path_equal(cleaned, p)) {
 396                                 bool blacklisted = false;
 397                                 char **i;
 398
 399                                 STRV_FOREACH(i, blacklist) {
 400
 401                                         if (path_equal(*i, cleaned))
 402                                                 continue;
 403
 404                                         if (!path_startswith(*i, cleaned))
 405                                                 continue;
 406
 407                                         if (path_startswith(p, *i)) {
 408                                                 blacklisted = true;
 409                                                 log_debug("Not remounting %s, because blacklisted by %s, called for %s", p, *i, cleaned);
 410                                                 break;
 411                                         }
 412                                 }
 413                                 if (blacklisted)
 414                                         continue;
 415                         }
 416
 417                         /* Let's ignore autofs mounts.  If they aren't
 418                          * triggered yet, we want to avoid triggering
 419                          * them, as we don't make any guarantees for
 420                          * future submounts anyway.  If they are
 421                          * already triggered, then we will find
 422                          * another entry for this. */
 423                         if (streq(type, "autofs")) {
 424                                 top_autofs = top_autofs || path_equal(cleaned, p);
 425                                 continue;
 426                         }
 427
 428                         if (!set_contains(done, p)) {
 429                                 r = set_consume(todo, p);
 430                                 p = NULL;
 431                                 if (r == -EEXIST)
 432                                         continue;
 433                                 if (r < 0)
 434                                         return r;
 435                         }
 436                 }
 437
 438                 /* If we have no submounts to process anymore and if
 439                  * the root is either already done, or an autofs, we
 440                  * are done */
 441                 if (set_isempty(todo) &&
 442                     (top_autofs || set_contains(done, cleaned)))
 443                         return 0;
 444
 445                 if (!set_contains(done, cleaned) &&
 446                     !set_contains(todo, cleaned)) {
 447                         /* The prefix directory itself is not yet a mount, make it one. */
 448                         if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
 449                                 return -errno;
 450
 451                         orig_flags = 0;
 452                         (void) get_mount_flags(cleaned, &orig_flags);
 453                         orig_flags &= ~MS_RDONLY;
 454
 455                         if (mount(NULL, prefix, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
 456                                 return -errno;
 457
 458                         log_debug("Made top-level directory %s a mount point.", prefix);
 459
 460                         x = strdup(cleaned);
 461                         if (!x)
 462                                 return -ENOMEM;
 463
 464                         r = set_consume(done, x);
 465                         if (r < 0)
 466                                 return r;
 467                 }
 468
 469                 while ((x = set_steal_first(todo))) {
 470
 471                         r = set_consume(done, x);
 472                         if (r == -EEXIST || r == 0)
 473                                 continue;
 474                         if (r < 0)
 475                                 return r;
 476
 477                         /* Deal with mount points that are obstructed by a later mount */
 478                         r = path_is_mount_point(x, NULL, 0);
 479                         if (r == -ENOENT || r == 0)
 480                                 continue;
 481                         if (r < 0)
 482                                 return r;
 483
 484                         /* Try to reuse the original flag set */
 485                         orig_flags = 0;
 486                         (void) get_mount_flags(x, &orig_flags);
 487                         orig_flags &= ~MS_RDONLY;
 488
 489                         if (mount(NULL, x, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
 490                                 return -errno;
 491
 492                         log_debug("Remounted %s read-only.", x);
 493                 }
 494         }
 495 }
 496
 497 int mount_move_root(const char *path) {
 498         assert(path);
 499
 500         if (chdir(path) < 0)
 501                 return -errno;
 502
 503         if (mount(path, "/", NULL, MS_MOVE, NULL) < 0)
 504                 return -errno;
 505
 506         if (chroot(".") < 0)
 507                 return -errno;
 508
 509         if (chdir("/") < 0)
 510                 return -errno;
 511
 512         return 0;
 513 }
 514
 515 bool fstype_is_network(const char *fstype) {
 516         static const char table[] =
 517                 "afs\0"
 518                 "cifs\0"
 519                 "smbfs\0"
 520                 "sshfs\0"
 521                 "ncpfs\0"
 522                 "ncp\0"
 523                 "nfs\0"
 524                 "nfs4\0"
 525                 "gfs\0"
 526                 "gfs2\0"
 527                 "glusterfs\0"
 528                 "pvfs2\0" /* OrangeFS */
 529                 "ocfs2\0"
 530                 "lustre\0"
 531                 ;
 532
 533         const char *x;
 534
 535         x = startswith(fstype, "fuse.");
 536         if (x)
 537                 fstype = x;
 538
 539         return nulstr_contains(table, fstype);
 540 }
 541
 542 int repeat_unmount(const char *path, int flags) {
 543         bool done = false;
 544
 545         assert(path);
 546
 547         /* If there are multiple mounts on a mount point, this
 548          * removes them all */
 549
 550         for (;;) {
 551                 if (umount2(path, flags) < 0) {
 552
 553                         if (errno == EINVAL)
 554                                 return done;
 555
 556                         return -errno;
 557                 }
 558
 559                 done = true;
 560         }
 561 }
 562 #endif // 0
 563
 564 const char* mode_to_inaccessible_node(mode_t mode) {
 565         /* This function maps a node type to the correspondent inaccessible node type.
 566          * Character and block inaccessible devices may not be created (because major=0 and minor=0),
 567          * in such case we map character and block devices to the inaccessible node type socket. */
 568         switch(mode & S_IFMT) {
 569                 case S_IFREG:
 570                         return "/run/systemd/inaccessible/reg";
 571                 case S_IFDIR:
 572                         return "/run/systemd/inaccessible/dir";
 573                 case S_IFCHR:
 574                         if (access("/run/systemd/inaccessible/chr", F_OK) == 0)
 575                                 return "/run/systemd/inaccessible/chr";
 576                         return "/run/systemd/inaccessible/sock";
 577                 case S_IFBLK:
 578                         if (access("/run/systemd/inaccessible/blk", F_OK) == 0)
 579                                 return "/run/systemd/inaccessible/blk";
 580                         return "/run/systemd/inaccessible/sock";
 581                 case S_IFIFO:
 582                         return "/run/systemd/inaccessible/fifo";
 583                 case S_IFSOCK:
 584                         return "/run/systemd/inaccessible/sock";
 585         }
 586         return NULL;
 587 }
 588
 589 #if 0 /// UNNEEDED by elogind
 590 #define FLAG(name) (flags & name ? STRINGIFY(name) "|" : "")
 591 static char* mount_flags_to_string(long unsigned flags) {
 592         char *x;
 593         _cleanup_free_ char *y = NULL;
 594         long unsigned overflow;
 595
 596         overflow = flags & ~(MS_RDONLY |
 597                              MS_NOSUID |
 598                              MS_NODEV |
 599                              MS_NOEXEC |
 600                              MS_SYNCHRONOUS |
 601                              MS_REMOUNT |
 602                              MS_MANDLOCK |
 603                              MS_DIRSYNC |
 604                              MS_NOATIME |
 605                              MS_NODIRATIME |
 606                              MS_BIND |
 607                              MS_MOVE |
 608                              MS_REC |
 609                              MS_SILENT |
 610                              MS_POSIXACL |
 611                              MS_UNBINDABLE |
 612                              MS_PRIVATE |
 613                              MS_SLAVE |
 614                              MS_SHARED |
 615                              MS_RELATIME |
 616                              MS_KERNMOUNT |
 617                              MS_I_VERSION |
 618                              MS_STRICTATIME |
 619                              MS_LAZYTIME);
 620
 621         if (flags == 0 || overflow != 0)
 622                 if (asprintf(&y, "%lx", overflow) < 0)
 623                         return NULL;
 624
 625         x = strjoin(FLAG(MS_RDONLY),
 626                     FLAG(MS_NOSUID),
 627                     FLAG(MS_NODEV),
 628                     FLAG(MS_NOEXEC),
 629                     FLAG(MS_SYNCHRONOUS),
 630                     FLAG(MS_REMOUNT),
 631                     FLAG(MS_MANDLOCK),
 632                     FLAG(MS_DIRSYNC),
 633                     FLAG(MS_NOATIME),
 634                     FLAG(MS_NODIRATIME),
 635                     FLAG(MS_BIND),
 636                     FLAG(MS_MOVE),
 637                     FLAG(MS_REC),
 638                     FLAG(MS_SILENT),
 639                     FLAG(MS_POSIXACL),
 640                     FLAG(MS_UNBINDABLE),
 641                     FLAG(MS_PRIVATE),
 642                     FLAG(MS_SLAVE),
 643                     FLAG(MS_SHARED),
 644                     FLAG(MS_RELATIME),
 645                     FLAG(MS_KERNMOUNT),
 646                     FLAG(MS_I_VERSION),
 647                     FLAG(MS_STRICTATIME),
 648                     FLAG(MS_LAZYTIME),
 649                     y);
 650         if (!x)
 651                 return NULL;
 652         if (!y)
 653                 x[strlen(x) - 1] = '\0'; /* truncate the last | */
 654         return x;
 655 }
 656
 657 int mount_verbose(
 658                 int error_log_level,
 659                 const char *what,
 660                 const char *where,
 661                 const char *type,
 662                 unsigned long flags,
 663                 const char *options) {
 664
 665         _cleanup_free_ char *fl = NULL;
 666
 667         fl = mount_flags_to_string(flags);
 668
 669         if ((flags & MS_REMOUNT) && !what && !type)
 670                 log_debug("Remounting %s (%s \"%s\")...",
 671                           where, strnull(fl), strempty(options));
 672         else if (!what && !type)
 673                 log_debug("Mounting %s (%s \"%s\")...",
 674                           where, strnull(fl), strempty(options));
 675         else if ((flags & MS_BIND) && !type)
 676                 log_debug("Bind-mounting %s on %s (%s \"%s\")...",
 677                           what, where, strnull(fl), strempty(options));
 678         else if (flags & MS_MOVE)
 679                 log_debug("Moving mount %s → %s (%s \"%s\")...",
 680                           what, where, strnull(fl), strempty(options));
 681         else
 682                 log_debug("Mounting %s on %s (%s \"%s\")...",
 683                           strna(type), where, strnull(fl), strempty(options));
 684         if (mount(what, where, type, flags, options) < 0)
 685                 return log_full_errno(error_log_level, errno,
 686                                       "Failed to mount %s on %s (%s \"%s\"): %m",
 687                                       strna(type), where, strnull(fl), strempty(options));
 688         return 0;
 689 }
 690
 691 int umount_verbose(const char *what) {
 692         log_debug("Umounting %s...", what);
 693         if (umount(what) < 0)
 694                 return log_error_errno(errno, "Failed to unmount %s: %m", what);
 695         return 0;
 696 }
 697 #endif // 0
 698
 699 const char *mount_propagation_flags_to_string(unsigned long flags) {
 700
 701         switch (flags & (MS_SHARED|MS_SLAVE|MS_PRIVATE)) {
 702         case 0:
 703                 return "";
 704         case MS_SHARED:
 705                 return "shared";
 706         case MS_SLAVE:
 707                 return "slave";
 708         case MS_PRIVATE:
 709                 return "private";
 710         }
 711
 712         return NULL;
 713 }
 714
 715
 716 int mount_propagation_flags_from_string(const char *name, unsigned long *ret) {
 717
 718         if (isempty(name))
 719                 *ret = 0;
 720         else if (streq(name, "shared"))
 721                 *ret = MS_SHARED;
 722         else if (streq(name, "slave"))
 723                 *ret = MS_SLAVE;
 724         else if (streq(name, "private"))
 725                 *ret = MS_PRIVATE;
 726         else
 727                 return -EINVAL;
 728         return 0;
 729 }