chiark / gitweb /
nspawn: support ephemeral boots from images
[elogind.git] / src / basic / rm-rf.c
1 /***
2   This file is part of systemd.
3
4   Copyright 2015 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 <dirent.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <stdbool.h>
24 #include <stddef.h>
25 #include <sys/stat.h>
26 #include <sys/statfs.h>
27 #include <unistd.h>
28
29 //#include "btrfs-util.h"
30 #include "cgroup-util.h"
31 #include "fd-util.h"
32 #include "log.h"
33 #include "macro.h"
34 #include "mount-util.h"
35 #include "path-util.h"
36 #include "rm-rf.h"
37 #include "stat-util.h"
38 #include "string-util.h"
39
40 static bool is_physical_fs(const struct statfs *sfs) {
41         return !is_temporary_fs(sfs) && !is_cgroup_fs(sfs);
42 }
43
44 int rm_rf_children(int fd, RemoveFlags flags, struct stat *root_dev) {
45         _cleanup_closedir_ DIR *d = NULL;
46         int ret = 0, r;
47         struct statfs sfs;
48
49         assert(fd >= 0);
50
51         /* This returns the first error we run into, but nevertheless
52          * tries to go on. This closes the passed fd. */
53
54         if (!(flags & REMOVE_PHYSICAL)) {
55
56                 r = fstatfs(fd, &sfs);
57                 if (r < 0) {
58                         safe_close(fd);
59                         return -errno;
60                 }
61
62                 if (is_physical_fs(&sfs)) {
63                         /* We refuse to clean physical file systems
64                          * with this call, unless explicitly
65                          * requested. This is extra paranoia just to
66                          * be sure we never ever remove non-state
67                          * data */
68
69                         log_error("Attempted to remove disk file system, and we can't allow that.");
70                         safe_close(fd);
71                         return -EPERM;
72                 }
73         }
74
75         d = fdopendir(fd);
76         if (!d) {
77                 safe_close(fd);
78                 return errno == ENOENT ? 0 : -errno;
79         }
80
81         for (;;) {
82                 struct dirent *de;
83                 bool is_dir;
84                 struct stat st;
85
86                 errno = 0;
87                 de = readdir(d);
88                 if (!de) {
89                         if (errno > 0 && ret == 0)
90                                 ret = -errno;
91                         return ret;
92                 }
93
94                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
95                         continue;
96
97                 if (de->d_type == DT_UNKNOWN ||
98                     (de->d_type == DT_DIR && (root_dev || (flags & REMOVE_SUBVOLUME)))) {
99                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
100                                 if (ret == 0 && errno != ENOENT)
101                                         ret = -errno;
102                                 continue;
103                         }
104
105                         is_dir = S_ISDIR(st.st_mode);
106                 } else
107                         is_dir = de->d_type == DT_DIR;
108
109                 if (is_dir) {
110                         int subdir_fd;
111
112                         /* if root_dev is set, remove subdirectories only if device is same */
113                         if (root_dev && st.st_dev != root_dev->st_dev)
114                                 continue;
115
116                         subdir_fd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
117                         if (subdir_fd < 0) {
118                                 if (ret == 0 && errno != ENOENT)
119                                         ret = -errno;
120                                 continue;
121                         }
122
123                         /* Stop at mount points */
124                         r = fd_is_mount_point(fd, de->d_name, 0);
125                         if (r < 0) {
126                                 if (ret == 0 && r != -ENOENT)
127                                         ret = r;
128
129                                 safe_close(subdir_fd);
130                                 continue;
131                         }
132                         if (r) {
133                                 safe_close(subdir_fd);
134                                 continue;
135                         }
136
137 #if 0 /// elogind does not support BTRFS this directly
138                         if ((flags & REMOVE_SUBVOLUME) && st.st_ino == 256) {
139
140                                 /* This could be a subvolume, try to remove it */
141
142                                 r = btrfs_subvol_remove_fd(fd, de->d_name, BTRFS_REMOVE_RECURSIVE|BTRFS_REMOVE_QUOTA);
143                                 if (r < 0) {
144                                         if (r != -ENOTTY && r != -EINVAL) {
145                                                 if (ret == 0)
146                                                         ret = r;
147
148                                                 safe_close(subdir_fd);
149                                                 continue;
150                                         }
151
152                                         /* ENOTTY, then it wasn't a
153                                          * btrfs subvolume, continue
154                                          * below. */
155                                 } else {
156                                         /* It was a subvolume, continue. */
157                                         safe_close(subdir_fd);
158                                         continue;
159                                 }
160                         }
161 #endif // 0
162
163                         /* We pass REMOVE_PHYSICAL here, to avoid
164                          * doing the fstatfs() to check the file
165                          * system type again for each directory */
166                         r = rm_rf_children(subdir_fd, flags | REMOVE_PHYSICAL, root_dev);
167                         if (r < 0 && ret == 0)
168                                 ret = r;
169
170                         if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
171                                 if (ret == 0 && errno != ENOENT)
172                                         ret = -errno;
173                         }
174
175                 } else if (!(flags & REMOVE_ONLY_DIRECTORIES)) {
176
177                         if (unlinkat(fd, de->d_name, 0) < 0) {
178                                 if (ret == 0 && errno != ENOENT)
179                                         ret = -errno;
180                         }
181                 }
182         }
183 }
184
185 int rm_rf(const char *path, RemoveFlags flags) {
186         int fd, r;
187         struct statfs s;
188
189         assert(path);
190
191         /* We refuse to clean the root file system with this
192          * call. This is extra paranoia to never cause a really
193          * seriously broken system. */
194         if (path_equal(path, "/")) {
195                 log_error("Attempted to remove entire root file system, and we can't allow that.");
196                 return -EPERM;
197         }
198
199 #if 0 /// elogind does not support BTRFS this directly
200         if ((flags & (REMOVE_SUBVOLUME|REMOVE_ROOT|REMOVE_PHYSICAL)) == (REMOVE_SUBVOLUME|REMOVE_ROOT|REMOVE_PHYSICAL)) {
201                 /* Try to remove as subvolume first */
202                 r = btrfs_subvol_remove(path, BTRFS_REMOVE_RECURSIVE|BTRFS_REMOVE_QUOTA);
203                 if (r >= 0)
204                         return r;
205
206                 if (r != -ENOTTY && r != -EINVAL && r != -ENOTDIR)
207                         return r;
208
209                 /* Not btrfs or not a subvolume */
210         }
211 #endif // 0
212
213         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
214         if (fd < 0) {
215
216                 if (errno != ENOTDIR && errno != ELOOP)
217                         return -errno;
218
219                 if (!(flags & REMOVE_PHYSICAL)) {
220                         if (statfs(path, &s) < 0)
221                                 return -errno;
222
223                         if (is_physical_fs(&s)) {
224                                 log_error("Attempted to remove disk file system, and we can't allow that.");
225                                 return -EPERM;
226                         }
227                 }
228
229                 if ((flags & REMOVE_ROOT) && !(flags & REMOVE_ONLY_DIRECTORIES))
230                         if (unlink(path) < 0 && errno != ENOENT)
231                                 return -errno;
232
233                 return 0;
234         }
235
236         r = rm_rf_children(fd, flags, NULL);
237
238         if (flags & REMOVE_ROOT) {
239                 if (rmdir(path) < 0) {
240                         if (r == 0 && errno != ENOENT)
241                                 r = -errno;
242                 }
243         }
244
245         return r;
246 }