X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fumount.c;h=4e036d82a30555988c18fea2c4dc8a8333f4b78c;hp=4842d403aeac8eea11b363c75eb185144f1d9c2c;hb=cd0504d0a13d8297b97c9238fd1b94b4141c5aa8;hpb=e3478379751fda30316204c68112b5a2b9ffd5a7 diff --git a/src/umount.c b/src/umount.c index 4842d403a..4e036d82a 100644 --- a/src/umount.c +++ b/src/umount.c @@ -26,6 +26,7 @@ #include #include #include +#include #include #include "list.h" @@ -35,46 +36,44 @@ typedef struct MountPoint { char *path; - bool read_only; + dev_t devnum; + bool skip_ro; LIST_FIELDS (struct MountPoint, mount_point); } MountPoint; -static MountPoint *mount_point_alloc(char *path) { - MountPoint *mp; +static void mount_point_free(MountPoint **head, MountPoint *m) { + assert(head); + assert(m); - if (!(mp = new(MountPoint, 1))) - return NULL; + LIST_REMOVE(MountPoint, mount_point, *head, m); - mp->path = path; - mp->read_only = false; - - return mp; + free(m->path); + free(m); } -static void mount_point_remove_and_free(MountPoint *mount_point, MountPoint **mount_point_list_head) { - LIST_REMOVE(MountPoint, mount_point, *mount_point_list_head, mount_point); - - free(mount_point->path); - free(mount_point); -} +static void mount_points_list_free(MountPoint **head) { + assert(head); -static void mount_points_list_free(MountPoint **mount_point_list_head) { - while (*mount_point_list_head) - mount_point_remove_and_free(*mount_point_list_head, mount_point_list_head); + while (*head) + mount_point_free(head, *head); } -static int mount_points_list_get(MountPoint **mount_point_list_head) { +static int mount_points_list_get(MountPoint **head) { FILE *proc_self_mountinfo; char *path, *p; unsigned int i; int r; + assert(head); + if (!(proc_self_mountinfo = fopen("/proc/self/mountinfo", "re"))) return -errno; for (i = 1;; i++) { int k; - MountPoint *mp; + MountPoint *m; + char *root; + bool skip_ro; path = p = NULL; @@ -82,7 +81,7 @@ static int mount_points_list_get(MountPoint **mount_point_list_head) { "%*s " /* (1) mount id */ "%*s " /* (2) parent id */ "%*s " /* (3) major:minor */ - "%*s " /* (4) root */ + "%ms " /* (4) root */ "%ms " /* (5) mount point */ "%*s" /* (6) mount options */ "%*[^-]" /* (7) optional fields */ @@ -91,7 +90,8 @@ static int mount_points_list_get(MountPoint **mount_point_list_head) { "%*s" /* (10) mount source */ "%*s" /* (11) mount options 2 */ "%*[^\n]", /* some rubbish at the end */ - &path)) != 1) { + &root, + &path)) != 2) { if (k == EOF) break; @@ -101,23 +101,33 @@ static int mount_points_list_get(MountPoint **mount_point_list_head) { continue; } - if (mount_point_is_api(path)) { - free(path); - continue; - } + /* If we encounter a bind mount, don't try to remount + * the source dir too early */ + skip_ro = !streq(root, "/"); + free(root); - if (!(p = cunescape(path))) { + p = cunescape(path); + free(path); + + if (!p) { r = -ENOMEM; goto finish; } - if (!(mp = mount_point_alloc(p))) { + if (mount_point_is_api(p) || mount_point_ignore(p)) { + free(p); + continue; + } + + if (!(m = new0(MountPoint, 1))) { + free(p); r = -ENOMEM; goto finish; } - LIST_PREPEND(MountPoint, mount_point, *mount_point_list_head, mp); - free(path); + m->path = p; + m->skip_ro = skip_ro; + LIST_PREPEND(MountPoint, mount_point, *head, m); } r = 0; @@ -125,18 +135,18 @@ static int mount_points_list_get(MountPoint **mount_point_list_head) { finish: fclose(proc_self_mountinfo); - free(path); - return r; } -static int swap_list_get(MountPoint **swap_list_head) { +static int swap_list_get(MountPoint **head) { FILE *proc_swaps; unsigned int i; int r; + assert(head); + if (!(proc_swaps = fopen("/proc/swaps", "re"))) - return -errno; + return (errno == ENOENT) ? 0 : -errno; (void) fscanf(proc_swaps, "%*s %*s %*s %*s %*s\n"); @@ -175,14 +185,14 @@ static int swap_list_get(MountPoint **swap_list_head) { goto finish; } - swap = mount_point_alloc(d); - if (!swap) { + if (!(swap = new0(MountPoint, 1))) { free(d); r = -ENOMEM; goto finish; } - LIST_PREPEND(MountPoint, mount_point, *swap_list_head, swap); + swap->path = d; + LIST_PREPEND(MountPoint, mount_point, *head, swap); } r = 0; @@ -193,12 +203,14 @@ finish: return r; } -static int loopback_list_get(MountPoint **loopback_list_head) { +static int loopback_list_get(MountPoint **head) { int r; struct udev *udev; struct udev_enumerate *e = NULL; struct udev_list_entry *item = NULL, *first = NULL; + assert(head); + if (!(udev = udev_new())) { r = -ENOMEM; goto finish; @@ -209,12 +221,84 @@ static int loopback_list_get(MountPoint **loopback_list_head) { goto finish; } - if (udev_enumerate_add_match_subsystem(e, "block") < 0) { + if (udev_enumerate_add_match_subsystem(e, "block") < 0 || + udev_enumerate_add_match_sysname(e, "loop*") < 0) { + r = -EIO; + goto finish; + } + + if (udev_enumerate_scan_devices(e) < 0) { r = -EIO; goto finish; } - if (udev_enumerate_add_match_sysname(e, "loop*") < 0) { + first = udev_enumerate_get_list_entry(e); + udev_list_entry_foreach(item, first) { + MountPoint *lb; + struct udev_device *d; + char *loop; + const char *dn; + + if (!(d = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item)))) { + r = -ENOMEM; + goto finish; + } + + if (!(dn = udev_device_get_devnode(d))) { + udev_device_unref(d); + continue; + } + + loop = strdup(dn); + udev_device_unref(d); + + if (!loop) { + r = -ENOMEM; + goto finish; + } + + if (!(lb = new0(MountPoint, 1))) { + free(loop); + r = -ENOMEM; + goto finish; + } + + lb->path = loop; + LIST_PREPEND(MountPoint, mount_point, *head, lb); + } + + r = 0; + +finish: + if (e) + udev_enumerate_unref(e); + + if (udev) + udev_unref(udev); + + return r; +} + +static int dm_list_get(MountPoint **head) { + int r; + struct udev *udev; + struct udev_enumerate *e = NULL; + struct udev_list_entry *item = NULL, *first = NULL; + + assert(head); + + if (!(udev = udev_new())) { + r = -ENOMEM; + goto finish; + } + + if (!(e = udev_enumerate_new(udev))) { + r = -ENOMEM; + goto finish; + } + + if (udev_enumerate_add_match_subsystem(e, "block") < 0 || + udev_enumerate_add_match_sysname(e, "dm-*") < 0) { r = -EIO; goto finish; } @@ -227,23 +311,42 @@ static int loopback_list_get(MountPoint **loopback_list_head) { first = udev_enumerate_get_list_entry(e); udev_list_entry_foreach(item, first) { - MountPoint *lb; - char *loop; + MountPoint *m; + struct udev_device *d; + dev_t devnum; + char *node; + const char *dn; - loop = cunescape(udev_list_entry_get_name(item)); - if (!loop) { + if (!(d = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item)))) { r = -ENOMEM; goto finish; } - lb = mount_point_alloc(loop); - if (!lb) { - free(loop); + devnum = udev_device_get_devnum(d); + dn = udev_device_get_devnode(d); + + if (major(devnum) == 0 || !dn) { + udev_device_unref(d); + continue; + } + + node = strdup(dn); + udev_device_unref(d); + + if (!node) { + r = -ENOMEM; + goto finish; + } + + if (!(m = new(MountPoint, 1))) { + free(node); r = -ENOMEM; goto finish; } - LIST_PREPEND(MountPoint, mount_point, *loopback_list_head, lb); + m->path = node; + m->devnum = devnum; + LIST_PREPEND(MountPoint, mount_point, *head, m); } r = 0; @@ -252,107 +355,205 @@ finish: if (e) udev_enumerate_unref(e); - free(udev); + if (udev) + udev_unref(udev); + return r; } static int delete_loopback(const char *device) { int fd, r; - if ((fd = open(device, O_RDONLY|O_CLOEXEC)) < 0) { - if (errno == ENOENT) { - log_debug("Loop device %s does not exist.", device); - errno = 0; - return 0; - } - return -errno; - } + if ((fd = open(device, O_RDONLY|O_CLOEXEC)) < 0) + return errno == ENOENT ? 0 : -errno; + + r = ioctl(fd, LOOP_CLR_FD, 0); + close_nointr_nofail(fd); - ioctl(fd, LOOP_CLR_FD, 0); - r = errno; - close_nointr(fd); + if (r >= 0) + return 1; + + /* ENXIO: not bound, so no error */ + if (errno == ENXIO) + return 0; - if (r == ENXIO) /* not bound, so no error */ - r = 0; - errno = r; return -errno; } -static int mount_points_list_umount(MountPoint **mount_point_list_head) { - MountPoint *mp, *mp_next; - int failed = 0; +static int delete_dm(dev_t devnum) { + int fd, r; + struct dm_ioctl dm; + + assert(major(devnum) != 0); + + if ((fd = open("/dev/mapper/control", O_RDWR|O_CLOEXEC)) < 0) + return -errno; + + zero(dm); + dm.version[0] = DM_VERSION_MAJOR; + dm.version[1] = DM_VERSION_MINOR; + dm.version[2] = DM_VERSION_PATCHLEVEL; + + dm.data_size = sizeof(dm); + dm.dev = devnum; + + r = ioctl(fd, DM_DEV_REMOVE, &dm); + close_nointr_nofail(fd); + + return r >= 0 ? 0 : -errno; +} + +static int mount_points_list_umount(MountPoint **head, bool *changed, bool log_error) { + MountPoint *m, *n; + int n_failed = 0; + + assert(head); - LIST_FOREACH_SAFE(mount_point, mp, mp_next, *mount_point_list_head) { - if (streq(mp->path, "/")) + LIST_FOREACH_SAFE(mount_point, m, n, *head) { + if (streq(m->path, "/")) { + n_failed++; continue; + } /* Trying to umount. Forcing to umount if busy (only for NFS mounts) */ - if (umount2(mp->path, MNT_FORCE) == 0) - mount_point_remove_and_free(mp, mount_point_list_head); - else { - log_debug("Could not unmount %s: %m", mp->path); - failed++; + if (umount2(m->path, MNT_FORCE) == 0) { + log_info("Unmounted %s.", m->path); + if (changed) + *changed = true; + + mount_point_free(head, m); + } else if (log_error) { + log_warning("Could not unmount %s: %m", m->path); + n_failed++; } } - return failed; + return n_failed; } -static int mount_points_list_remount_read_only(MountPoint **mount_point_list_head) { - MountPoint *mp, *mp_next; - int failed = 0; +static int mount_points_list_remount_read_only(MountPoint **head, bool *changed) { + MountPoint *m, *n; + int n_failed = 0; + + assert(head); - LIST_FOREACH_SAFE(mount_point, mp, mp_next, *mount_point_list_head) { - if (mp->read_only) + LIST_FOREACH_SAFE(mount_point, m, n, *head) { + + if (m->skip_ro) { + n_failed++; continue; + } /* Trying to remount read-only */ - if (mount(NULL, mp->path, NULL, MS_MGC_VAL|MS_REMOUNT|MS_RDONLY, NULL) == 0) { - mp->read_only = true; - mount_point_remove_and_free(mp, mount_point_list_head); + if (mount(NULL, m->path, NULL, MS_MGC_VAL|MS_REMOUNT|MS_RDONLY, NULL) == 0) { + if (changed) + *changed = true; + + mount_point_free(head, m); } else { - log_debug("Could not remount as read-only %s: %m", mp->path); - failed++; + log_warning("Could not remount as read-only %s: %m", m->path); + n_failed++; } } - return failed; + return n_failed; } -static int swap_points_list_off(MountPoint **swap_list_head) { - MountPoint *swap, *swap_next; - int failed = 0; +static int swap_points_list_off(MountPoint **head, bool *changed) { + MountPoint *m, *n; + int n_failed = 0; + + assert(head); + + LIST_FOREACH_SAFE(mount_point, m, n, *head) { + if (swapoff(m->path) == 0) { + if (changed) + *changed = true; - LIST_FOREACH_SAFE(mount_point, swap, swap_next, *swap_list_head) { - if (swapoff(swap->path) == 0) - mount_point_remove_and_free(swap, swap_list_head); - else { - log_debug("Could not swapoff %s: %m", swap->path); - failed++; + mount_point_free(head, m); + } else { + log_warning("Could not deactivate swap %s: %m", m->path); + n_failed++; } } - return failed; + return n_failed; } -static int loopback_points_list_detach(MountPoint **loopback_list_head) { - MountPoint *loopback, *loopback_next; - int failed = 0; +static int loopback_points_list_detach(MountPoint **head, bool *changed) { + MountPoint *m, *n; + int n_failed = 0, k; + struct stat root_st; + + assert(head); + + k = lstat("/", &root_st); + + LIST_FOREACH_SAFE(mount_point, m, n, *head) { + int r; + struct stat loopback_st; - LIST_FOREACH_SAFE(mount_point, loopback, loopback_next, *loopback_list_head) { - if (delete_loopback(loopback->path) == 0) - mount_point_remove_and_free(loopback, loopback_list_head); - else { - log_debug("Could not delete loopback %s: %m", loopback->path); - failed++; + if (k >= 0 && + major(root_st.st_dev) != 0 && + lstat(m->path, &loopback_st) >= 0 && + root_st.st_dev == loopback_st.st_rdev) { + n_failed ++; + continue; + } + + if ((r = delete_loopback(m->path)) >= 0) { + + if (r > 0 && changed) + *changed = true; + + mount_point_free(head, m); + } else { + log_warning("Could not delete loopback %s: %m", m->path); + n_failed++; } } - return failed; + return n_failed; } -int umount_all(void) { +static int dm_points_list_detach(MountPoint **head, bool *changed) { + MountPoint *m, *n; + int n_failed = 0, k; + struct stat root_st; + + assert(head); + + k = lstat("/", &root_st); + + LIST_FOREACH_SAFE(mount_point, m, n, *head) { + int r; + + if (k >= 0 && + major(root_st.st_dev) != 0 && + root_st.st_dev == m->devnum) { + n_failed ++; + continue; + } + + if ((r = delete_dm(m->devnum)) >= 0) { + + if (r > 0 && changed) + *changed = true; + + mount_point_free(head, m); + } else { + log_warning("Could not delete dm %s: %m", m->path); + n_failed++; + } + } + + return n_failed; +} + +int umount_all(bool *changed) { int r; + bool umount_changed; + LIST_HEAD(MountPoint, mp_list_head); LIST_HEAD_INIT(MountPoint, mp_list_head); @@ -361,11 +562,22 @@ int umount_all(void) { if (r < 0) goto end; - r = mount_points_list_umount(&mp_list_head); + /* retry umount, until nothing can be umounted anymore */ + do { + umount_changed = false; + + mount_points_list_umount(&mp_list_head, &umount_changed, false); + if (umount_changed) + *changed = true; + + } while (umount_changed); + + /* umount one more time with logging enabled */ + r = mount_points_list_umount(&mp_list_head, &umount_changed, true); if (r <= 0) goto end; - r = mount_points_list_remount_read_only(&mp_list_head); + r = mount_points_list_remount_read_only(&mp_list_head, changed); end: mount_points_list_free(&mp_list_head); @@ -373,7 +585,7 @@ int umount_all(void) { return r; } -int swapoff_all(void) { +int swapoff_all(bool *changed) { int r; LIST_HEAD(MountPoint, swap_list_head); @@ -383,7 +595,7 @@ int swapoff_all(void) { if (r < 0) goto end; - r = swap_points_list_off(&swap_list_head); + r = swap_points_list_off(&swap_list_head, changed); end: mount_points_list_free(&swap_list_head); @@ -391,7 +603,7 @@ int swapoff_all(void) { return r; } -int loopback_detach_all(void) { +int loopback_detach_all(bool *changed) { int r; LIST_HEAD(MountPoint, loopback_list_head); @@ -401,10 +613,28 @@ int loopback_detach_all(void) { if (r < 0) goto end; - r = loopback_points_list_detach(&loopback_list_head); + r = loopback_points_list_detach(&loopback_list_head, changed); end: mount_points_list_free(&loopback_list_head); return r; } + +int dm_detach_all(bool *changed) { + int r; + LIST_HEAD(MountPoint, dm_list_head); + + LIST_HEAD_INIT(MountPoint, dm_list_head); + + r = dm_list_get(&dm_list_head); + if (r < 0) + goto end; + + r = dm_points_list_detach(&dm_list_head, changed); + + end: + mount_points_list_free(&dm_list_head); + + return r; +}