src/core/umount.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 ProFUSION embedded systems
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <linux/loop.h>
  24 #include <string.h>
  25 #include <sys/mount.h>
  26 #include <sys/swap.h>
  27
  28 #include "libudev.h"
  29
  30 #include "alloc-util.h"
  31 #include "blockdev-util.h"
  32 #include "def.h"
  33 #include "escape.h"
  34 #include "fd-util.h"
  35 #include "fstab-util.h"
  36 #include "linux-3.13/dm-ioctl.h"
  37 #include "list.h"
  38 #include "mount-setup.h"
  39 #include "mount-util.h"
  40 #include "path-util.h"
  41 #include "process-util.h"
  42 #include "signal-util.h"
  43 #include "string-util.h"
  44 #include "udev-util.h"
  45 #include "umount.h"
  46 #include "util.h"
  47 #include "virt.h"
  48
  49 typedef struct MountPoint {
  50         char *path;
  51         char *options;
  52         char *type;
  53         dev_t devnum;
  54         LIST_FIELDS(struct MountPoint, mount_point);
  55 } MountPoint;
  56
  57 static void mount_point_free(MountPoint **head, MountPoint *m) {
  58         assert(head);
  59         assert(m);
  60
  61         LIST_REMOVE(mount_point, *head, m);
  62
  63         free(m->path);
  64         free(m);
  65 }
  66
  67 static void mount_points_list_free(MountPoint **head) {
  68         assert(head);
  69
  70         while (*head)
  71                 mount_point_free(head, *head);
  72 }
  73
  74 static int mount_points_list_get(MountPoint **head) {
  75         _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
  76         unsigned int i;
  77         int r;
  78
  79         assert(head);
  80
  81         proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
  82         if (!proc_self_mountinfo)
  83                 return -errno;
  84
  85         for (i = 1;; i++) {
  86                 _cleanup_free_ char *path = NULL, *options = NULL, *type = NULL;
  87                 char *p = NULL;
  88                 MountPoint *m;
  89                 int k;
  90
  91                 k = fscanf(proc_self_mountinfo,
  92                            "%*s "       /* (1) mount id */
  93                            "%*s "       /* (2) parent id */
  94                            "%*s "       /* (3) major:minor */
  95                            "%*s "       /* (4) root */
  96                            "%ms "       /* (5) mount point */
  97                            "%*s"        /* (6) mount flags */
  98                            "%*[^-]"     /* (7) optional fields */
  99                            "- "         /* (8) separator */
 100                            "%ms "       /* (9) file system type */
 101                            "%*s"        /* (10) mount source */
 102                            "%ms"        /* (11) mount options */
 103                            "%*[^\n]",   /* some rubbish at the end */
 104                            &path, &type, &options);
 105                 if (k != 3) {
 106                         if (k == EOF)
 107                                 break;
 108
 109                         log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
 110                         continue;
 111                 }
 112
 113                 r = cunescape(path, UNESCAPE_RELAX, &p);
 114                 if (r < 0)
 115                         return r;
 116
 117                 /* Ignore mount points we can't unmount because they
 118                  * are API or because we are keeping them open (like
 119                  * /dev/console). Also, ignore all mounts below API
 120                  * file systems, since they are likely virtual too,
 121                  * and hence not worth spending time on. Also, in
 122                  * unprivileged containers we might lack the rights to
 123                  * unmount these things, hence don't bother. */
 124                 if (mount_point_is_api(p) ||
 125                     mount_point_ignore(p) ||
 126                     path_startswith(p, "/dev") ||
 127                     path_startswith(p, "/sys") ||
 128                     path_startswith(p, "/proc")) {
 129                         free(p);
 130                         continue;
 131                 }
 132
 133                 m = new0(MountPoint, 1);
 134                 if (!m) {
 135                         free(p);
 136                         return -ENOMEM;
 137                 }
 138
 139                 m->path = p;
 140                 m->options = options;
 141                 options = NULL;
 142                 m->type = type;
 143                 type = NULL;
 144
 145                 LIST_PREPEND(mount_point, *head, m);
 146         }
 147
 148         return 0;
 149 }
 150
 151 static int swap_list_get(MountPoint **head) {
 152         _cleanup_fclose_ FILE *proc_swaps = NULL;
 153         unsigned int i;
 154         int r;
 155
 156         assert(head);
 157
 158         proc_swaps = fopen("/proc/swaps", "re");
 159         if (!proc_swaps)
 160                 return (errno == ENOENT) ? 0 : -errno;
 161
 162         (void) fscanf(proc_swaps, "%*s %*s %*s %*s %*s\n");
 163
 164         for (i = 2;; i++) {
 165                 MountPoint *swap;
 166                 _cleanup_free_ char *dev = NULL, *d = NULL;
 167                 int k;
 168
 169                 k = fscanf(proc_swaps,
 170                            "%ms " /* device/file */
 171                            "%*s " /* type of swap */
 172                            "%*s " /* swap size */
 173                            "%*s " /* used */
 174                            "%*s\n", /* priority */
 175                            &dev);
 176
 177                 if (k != 1) {
 178                         if (k == EOF)
 179                                 break;
 180
 181                         log_warning("Failed to parse /proc/swaps:%u.", i);
 182                         continue;
 183                 }
 184
 185                 if (endswith(dev, " (deleted)"))
 186                         continue;
 187
 188                 r = cunescape(dev, UNESCAPE_RELAX, &d);
 189                 if (r < 0)
 190                         return r;
 191
 192                 swap = new0(MountPoint, 1);
 193                 if (!swap)
 194                         return -ENOMEM;
 195
 196                 free_and_replace(swap->path, d);
 197                 LIST_PREPEND(mount_point, *head, swap);
 198         }
 199
 200         return 0;
 201 }
 202
 203 static int loopback_list_get(MountPoint **head) {
 204         _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
 205         struct udev_list_entry *item = NULL, *first = NULL;
 206         _cleanup_udev_unref_ struct udev *udev = NULL;
 207         int r;
 208
 209         assert(head);
 210
 211         udev = udev_new();
 212         if (!udev)
 213                 return -ENOMEM;
 214
 215         e = udev_enumerate_new(udev);
 216         if (!e)
 217                 return -ENOMEM;
 218
 219         r = udev_enumerate_add_match_subsystem(e, "block");
 220         if (r < 0)
 221                 return r;
 222
 223         r = udev_enumerate_add_match_sysname(e, "loop*");
 224         if (r < 0)
 225                 return r;
 226
 227         r = udev_enumerate_add_match_sysattr(e, "loop/backing_file", NULL);
 228         if (r < 0)
 229                 return r;
 230
 231         r = udev_enumerate_scan_devices(e);
 232         if (r < 0)
 233                 return r;
 234
 235         first = udev_enumerate_get_list_entry(e);
 236         udev_list_entry_foreach(item, first) {
 237                 MountPoint *lb;
 238                 _cleanup_udev_device_unref_ struct udev_device *d;
 239                 char *loop;
 240                 const char *dn;
 241
 242                 d = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
 243                 if (!d)
 244                         return -ENOMEM;
 245
 246                 dn = udev_device_get_devnode(d);
 247                 if (!dn)
 248                         continue;
 249
 250                 loop = strdup(dn);
 251                 if (!loop)
 252                         return -ENOMEM;
 253
 254                 lb = new0(MountPoint, 1);
 255                 if (!lb) {
 256                         free(loop);
 257                         return -ENOMEM;
 258                 }
 259
 260                 lb->path = loop;
 261                 LIST_PREPEND(mount_point, *head, lb);
 262         }
 263
 264         return 0;
 265 }
 266
 267 static int dm_list_get(MountPoint **head) {
 268         _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
 269         struct udev_list_entry *item = NULL, *first = NULL;
 270         _cleanup_udev_unref_ struct udev *udev = NULL;
 271         int r;
 272
 273         assert(head);
 274
 275         udev = udev_new();
 276         if (!udev)
 277                 return -ENOMEM;
 278
 279         e = udev_enumerate_new(udev);
 280         if (!e)
 281                 return -ENOMEM;
 282
 283         r = udev_enumerate_add_match_subsystem(e, "block");
 284         if (r < 0)
 285                 return r;
 286
 287         r = udev_enumerate_add_match_sysname(e, "dm-*");
 288         if (r < 0)
 289                 return r;
 290
 291         r = udev_enumerate_scan_devices(e);
 292         if (r < 0)
 293                 return r;
 294
 295         first = udev_enumerate_get_list_entry(e);
 296         udev_list_entry_foreach(item, first) {
 297                 MountPoint *m;
 298                 _cleanup_udev_device_unref_ struct udev_device *d;
 299                 dev_t devnum;
 300                 char *node;
 301                 const char *dn;
 302
 303                 d = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
 304                 if (!d)
 305                         return -ENOMEM;
 306
 307                 devnum = udev_device_get_devnum(d);
 308                 dn = udev_device_get_devnode(d);
 309                 if (major(devnum) == 0 || !dn)
 310                         continue;
 311
 312                 node = strdup(dn);
 313                 if (!node)
 314                         return -ENOMEM;
 315
 316                 m = new(MountPoint, 1);
 317                 if (!m) {
 318                         free(node);
 319                         return -ENOMEM;
 320                 }
 321
 322                 m->path = node;
 323                 m->devnum = devnum;
 324                 LIST_PREPEND(mount_point, *head, m);
 325         }
 326
 327         return 0;
 328 }
 329
 330 static int delete_loopback(const char *device) {
 331         _cleanup_close_ int fd = -1;
 332         int r;
 333
 334         fd = open(device, O_RDONLY|O_CLOEXEC);
 335         if (fd < 0)
 336                 return errno == ENOENT ? 0 : -errno;
 337
 338         r = ioctl(fd, LOOP_CLR_FD, 0);
 339         if (r >= 0)
 340                 return 1;
 341
 342         /* ENXIO: not bound, so no error */
 343         if (errno == ENXIO)
 344                 return 0;
 345
 346         return -errno;
 347 }
 348
 349 static int delete_dm(dev_t devnum) {
 350
 351         struct dm_ioctl dm = {
 352                 .version = {
 353                         DM_VERSION_MAJOR,
 354                         DM_VERSION_MINOR,
 355                         DM_VERSION_PATCHLEVEL
 356                 },
 357                 .data_size = sizeof(dm),
 358                 .dev = devnum,
 359         };
 360
 361         _cleanup_close_ int fd = -1;
 362
 363         assert(major(devnum) != 0);
 364
 365         fd = open("/dev/mapper/control", O_RDWR|O_CLOEXEC);
 366         if (fd < 0)
 367                 return -errno;
 368
 369         if (ioctl(fd, DM_DEV_REMOVE, &dm) < 0)
 370                 return -errno;
 371
 372         return 0;
 373 }
 374
 375 static bool nonunmountable_path(const char *path) {
 376         return path_equal(path, "/")
 377 #if ! HAVE_SPLIT_USR
 378                 || path_equal(path, "/usr")
 379 #endif
 380                 || path_startswith(path, "/run/initramfs");
 381 }
 382
 383 static int remount_with_timeout(MountPoint *m, char *options, int *n_failed) {
 384         pid_t pid;
 385         int r;
 386
 387         BLOCK_SIGNALS(SIGCHLD);
 388
 389         /* Due to the possiblity of a remount operation hanging, we
 390          * fork a child process and set a timeout. If the timeout
 391          * lapses, the assumption is that that particular remount
 392          * failed. */
 393         r = safe_fork("(sd-remount)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_LOG, &pid);
 394         if (r < 0)
 395                 return r;
 396         if (r == 0) {
 397                 log_info("Remounting '%s' read-only in with options '%s'.", m->path, options);
 398
 399                 /* Start the mount operation here in the child */
 400                 r = mount(NULL, m->path, NULL, MS_REMOUNT|MS_RDONLY, options);
 401                 if (r < 0)
 402                         log_error_errno(errno, "Failed to remount '%s' read-only: %m", m->path);
 403
 404                 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
 405         }
 406
 407         r = wait_for_terminate_with_timeout(pid, DEFAULT_TIMEOUT_USEC);
 408         if (r == -ETIMEDOUT) {
 409                 log_error_errno(errno, "Remounting '%s' - timed out, issuing SIGKILL to PID "PID_FMT".", m->path, pid);
 410                 (void) kill(pid, SIGKILL);
 411         } else if (r < 0)
 412                 log_error_errno(r, "Failed to wait for process: %m");
 413
 414         return r;
 415 }
 416
 417 static int umount_with_timeout(MountPoint *m, bool *changed) {
 418         pid_t pid;
 419         int r;
 420
 421         BLOCK_SIGNALS(SIGCHLD);
 422
 423         /* Due to the possiblity of a umount operation hanging, we
 424          * fork a child process and set a timeout. If the timeout
 425          * lapses, the assumption is that that particular umount
 426          * failed. */
 427         r = safe_fork("(sd-umount)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_LOG, &pid);
 428         if (r < 0)
 429                 return r;
 430         if (r == 0) {
 431                 log_info("Unmounting '%s'.", m->path);
 432
 433                 /* Start the mount operation here in the child Using MNT_FORCE
 434                  * causes some filesystems (e.g. FUSE and NFS and other network
 435                  * filesystems) to abort any pending requests and return -EIO
 436                  * rather than blocking indefinitely. If the filesysten is
 437                  * "busy", this may allow processes to die, thus making the
 438                  * filesystem less busy so the unmount might succeed (rather
 439                  * then return EBUSY).*/
 440                 r = umount2(m->path, MNT_FORCE);
 441                 if (r < 0)
 442                         log_error_errno(errno, "Failed to unmount %s: %m", m->path);
 443
 444                 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
 445         }
 446
 447         r = wait_for_terminate_with_timeout(pid, DEFAULT_TIMEOUT_USEC);
 448         if (r == -ETIMEDOUT) {
 449                 log_error_errno(errno, "Unmounting '%s' - timed out, issuing SIGKILL to PID "PID_FMT".", m->path, pid);
 450                 (void) kill(pid, SIGKILL);
 451         } else if (r < 0)
 452                 log_error_errno(r, "Failed to wait for process: %m");
 453
 454         return r;
 455 }
 456
 457 /* This includes remounting readonly, which changes the kernel mount options.
 458  * Therefore the list passed to this function is invalidated, and should not be reused. */
 459
 460 static int mount_points_list_umount(MountPoint **head, bool *changed) {
 461         MountPoint *m;
 462         int n_failed = 0;
 463
 464         assert(head);
 465
 466         LIST_FOREACH(mount_point, m, *head) {
 467                 bool mount_is_readonly;
 468
 469                 mount_is_readonly = fstab_test_yes_no_option(m->options, "ro\0rw\0");
 470
 471                 /* If we are in a container, don't attempt to
 472                    read-only mount anything as that brings no real
 473                    benefits, but might confuse the host, as we remount
 474                    the superblock here, not the bind mount.
 475                    If the filesystem is a network fs, also skip the
 476                    remount.  It brings no value (we cannot leave
 477                    a "dirty fs") and could hang if the network is down.
 478                    Note that umount2() is more careful and will not
 479                    hang because of the network being down. */
 480                 if (detect_container() <= 0 &&
 481                     !fstype_is_network(m->type) &&
 482                     !mount_is_readonly) {
 483                         _cleanup_free_ char *options = NULL;
 484                         /* MS_REMOUNT requires that the data parameter
 485                          * should be the same from the original mount
 486                          * except for the desired changes. Since we want
 487                          * to remount read-only, we should filter out
 488                          * rw (and ro too, because it confuses the kernel) */
 489                         (void) fstab_filter_options(m->options, "rw\0ro\0", NULL, NULL, &options);
 490
 491                         /* We always try to remount directories
 492                          * read-only first, before we go on and umount
 493                          * them.
 494                          *
 495                          * Mount points can be stacked. If a mount
 496                          * point is stacked below / or /usr, we
 497                          * cannot umount or remount it directly,
 498                          * since there is no way to refer to the
 499                          * underlying mount. There's nothing we can do
 500                          * about it for the general case, but we can
 501                          * do something about it if it is aliased
 502                          * somehwere else via a bind mount. If we
 503                          * explicitly remount the super block of that
 504                          * alias read-only we hence should be
 505                          * relatively safe regarding keeping dirty an fs
 506                          * we cannot otherwise see.
 507                          *
 508                          * Since the remount can hang in the instance of
 509                          * remote filesystems, we remount asynchronously
 510                          * and skip the subsequent umount if it fails */
 511                         if (remount_with_timeout(m, options, &n_failed) < 0) {
 512                                 if (nonunmountable_path(m->path))
 513                                         n_failed++;
 514                                 continue;
 515                         }
 516                 }
 517
 518                 /* Skip / and /usr since we cannot unmount that
 519                  * anyway, since we are running from it. They have
 520                  * already been remounted ro. */
 521                 if (nonunmountable_path(m->path))
 522                         continue;
 523
 524                 /* Trying to umount */
 525                 if (umount_with_timeout(m, changed) < 0)
 526                         n_failed++;
 527                 else {
 528                         if (changed)
 529                                 *changed = true;
 530                 }
 531         }
 532
 533         return n_failed;
 534 }
 535
 536 static int swap_points_list_off(MountPoint **head, bool *changed) {
 537         MountPoint *m, *n;
 538         int n_failed = 0;
 539
 540         assert(head);
 541
 542         LIST_FOREACH_SAFE(mount_point, m, n, *head) {
 543                 log_info("Deactivating swap %s.", m->path);
 544                 if (swapoff(m->path) == 0) {
 545                         if (changed)
 546                                 *changed = true;
 547
 548                         mount_point_free(head, m);
 549                 } else {
 550                         log_warning_errno(errno, "Could not deactivate swap %s: %m", m->path);
 551                         n_failed++;
 552                 }
 553         }
 554
 555         return n_failed;
 556 }
 557
 558 static int loopback_points_list_detach(MountPoint **head, bool *changed) {
 559         MountPoint *m, *n;
 560         int n_failed = 0, k;
 561         struct stat root_st;
 562
 563         assert(head);
 564
 565         k = lstat("/", &root_st);
 566
 567         LIST_FOREACH_SAFE(mount_point, m, n, *head) {
 568                 int r;
 569                 struct stat loopback_st;
 570
 571                 if (k >= 0 &&
 572                     major(root_st.st_dev) != 0 &&
 573                     lstat(m->path, &loopback_st) >= 0 &&
 574                     root_st.st_dev == loopback_st.st_rdev) {
 575                         n_failed++;
 576                         continue;
 577                 }
 578
 579                 log_info("Detaching loopback %s.", m->path);
 580                 r = delete_loopback(m->path);
 581                 if (r >= 0) {
 582                         if (r > 0 && changed)
 583                                 *changed = true;
 584
 585                         mount_point_free(head, m);
 586                 } else {
 587                         log_warning_errno(errno, "Could not detach loopback %s: %m", m->path);
 588                         n_failed++;
 589                 }
 590         }
 591
 592         return n_failed;
 593 }
 594
 595 static int dm_points_list_detach(MountPoint **head, bool *changed) {
 596         MountPoint *m, *n;
 597         int n_failed = 0, r;
 598         dev_t rootdev;
 599
 600         assert(head);
 601
 602         r = get_block_device("/", &rootdev);
 603         if (r <= 0)
 604                 rootdev = 0;
 605
 606         LIST_FOREACH_SAFE(mount_point, m, n, *head) {
 607
 608                 if (major(rootdev) != 0)
 609                         if (rootdev == m->devnum) {
 610                                 n_failed ++;
 611                                 continue;
 612                         }
 613
 614                 log_info("Detaching DM %u:%u.", major(m->devnum), minor(m->devnum));
 615                 r = delete_dm(m->devnum);
 616                 if (r >= 0) {
 617                         if (changed)
 618                                 *changed = true;
 619
 620                         mount_point_free(head, m);
 621                 } else {
 622                         log_warning_errno(errno, "Could not detach DM %s: %m", m->path);
 623                         n_failed++;
 624                 }
 625         }
 626
 627         return n_failed;
 628 }
 629
 630 static int umount_all_once(bool *changed) {
 631         int r;
 632         LIST_HEAD(MountPoint, mp_list_head);
 633
 634         LIST_HEAD_INIT(mp_list_head);
 635         r = mount_points_list_get(&mp_list_head);
 636         if (r < 0)
 637                 goto end;
 638
 639         r = mount_points_list_umount(&mp_list_head, changed);
 640
 641   end:
 642         mount_points_list_free(&mp_list_head);
 643
 644         return r;
 645 }
 646
 647 int umount_all(bool *changed) {
 648         bool umount_changed;
 649         int r;
 650
 651         /* Retry umount, until nothing can be umounted anymore. Mounts are
 652          * processed in order, newest first. The retries are needed when
 653          * an old mount has been moved, to a path inside a newer mount. */
 654         do {
 655                 umount_changed = false;
 656
 657                 r = umount_all_once(&umount_changed);
 658                 if (umount_changed)
 659                         *changed = true;
 660         } while (umount_changed);
 661
 662         return r;
 663 }
 664
 665 int swapoff_all(bool *changed) {
 666         int r;
 667         LIST_HEAD(MountPoint, swap_list_head);
 668
 669         LIST_HEAD_INIT(swap_list_head);
 670
 671         r = swap_list_get(&swap_list_head);
 672         if (r < 0)
 673                 goto end;
 674
 675         r = swap_points_list_off(&swap_list_head, changed);
 676
 677   end:
 678         mount_points_list_free(&swap_list_head);
 679
 680         return r;
 681 }
 682
 683 int loopback_detach_all(bool *changed) {
 684         int r;
 685         LIST_HEAD(MountPoint, loopback_list_head);
 686
 687         LIST_HEAD_INIT(loopback_list_head);
 688
 689         r = loopback_list_get(&loopback_list_head);
 690         if (r < 0)
 691                 goto end;
 692
 693         r = loopback_points_list_detach(&loopback_list_head, changed);
 694
 695   end:
 696         mount_points_list_free(&loopback_list_head);
 697
 698         return r;
 699 }
 700
 701 int dm_detach_all(bool *changed) {
 702         int r;
 703         LIST_HEAD(MountPoint, dm_list_head);
 704
 705         LIST_HEAD_INIT(dm_list_head);
 706
 707         r = dm_list_get(&dm_list_head);
 708         if (r < 0)
 709                 goto end;
 710
 711         r = dm_points_list_detach(&dm_list_head, changed);
 712
 713   end:
 714         mount_points_list_free(&dm_list_head);
 715
 716         return r;
 717 }