Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <sys/sendfile.h>
4 : :
5 : : /* When we include libgen.h because we need dirname() we immediately
6 : : * undefine basename() since libgen.h defines it as a macro to the POSIX
7 : : * version which is really broken. We prefer GNU basename(). */
8 : : #include <libgen.h>
9 : : #undef basename
10 : :
11 : : #include "sd-daemon.h"
12 : :
13 : : #include "alloc-util.h"
14 : : #include "btrfs-util.h"
15 : : #include "copy.h"
16 : : #include "export-raw.h"
17 : : #include "fd-util.h"
18 : : #include "fs-util.h"
19 : : #include "import-common.h"
20 : : #include "missing.h"
21 : : #include "ratelimit.h"
22 : : #include "stat-util.h"
23 : : #include "string-util.h"
24 : : #include "tmpfile-util.h"
25 : : #include "util.h"
26 : :
27 : : #define COPY_BUFFER_SIZE (16*1024)
28 : :
29 : : struct RawExport {
30 : : sd_event *event;
31 : :
32 : : RawExportFinished on_finished;
33 : : void *userdata;
34 : :
35 : : char *path;
36 : :
37 : : int input_fd;
38 : : int output_fd;
39 : :
40 : : ImportCompress compress;
41 : :
42 : : sd_event_source *output_event_source;
43 : :
44 : : void *buffer;
45 : : size_t buffer_size;
46 : : size_t buffer_allocated;
47 : :
48 : : uint64_t written_compressed;
49 : : uint64_t written_uncompressed;
50 : :
51 : : unsigned last_percent;
52 : : RateLimit progress_rate_limit;
53 : :
54 : : struct stat st;
55 : :
56 : : bool eof;
57 : : bool tried_reflink;
58 : : bool tried_sendfile;
59 : : };
60 : :
61 : 0 : RawExport *raw_export_unref(RawExport *e) {
62 [ # # ]: 0 : if (!e)
63 : 0 : return NULL;
64 : :
65 : 0 : sd_event_source_unref(e->output_event_source);
66 : :
67 : 0 : import_compress_free(&e->compress);
68 : :
69 : 0 : sd_event_unref(e->event);
70 : :
71 : 0 : safe_close(e->input_fd);
72 : :
73 : 0 : free(e->buffer);
74 : 0 : free(e->path);
75 : 0 : return mfree(e);
76 : : }
77 : :
78 : 0 : int raw_export_new(
79 : : RawExport **ret,
80 : : sd_event *event,
81 : : RawExportFinished on_finished,
82 : : void *userdata) {
83 : :
84 : 0 : _cleanup_(raw_export_unrefp) RawExport *e = NULL;
85 : : int r;
86 : :
87 [ # # ]: 0 : assert(ret);
88 : :
89 : 0 : e = new(RawExport, 1);
90 [ # # ]: 0 : if (!e)
91 : 0 : return -ENOMEM;
92 : :
93 : 0 : *e = (RawExport) {
94 : : .output_fd = -1,
95 : : .input_fd = -1,
96 : : .on_finished = on_finished,
97 : : .userdata = userdata,
98 : : .last_percent = (unsigned) -1,
99 : : };
100 : :
101 : 0 : RATELIMIT_INIT(e->progress_rate_limit, 100 * USEC_PER_MSEC, 1);
102 : :
103 [ # # ]: 0 : if (event)
104 : 0 : e->event = sd_event_ref(event);
105 : : else {
106 : 0 : r = sd_event_default(&e->event);
107 [ # # ]: 0 : if (r < 0)
108 : 0 : return r;
109 : : }
110 : :
111 : 0 : *ret = TAKE_PTR(e);
112 : :
113 : 0 : return 0;
114 : : }
115 : :
116 : 0 : static void raw_export_report_progress(RawExport *e) {
117 : : unsigned percent;
118 [ # # ]: 0 : assert(e);
119 : :
120 [ # # ]: 0 : if (e->written_uncompressed >= (uint64_t) e->st.st_size)
121 : 0 : percent = 100;
122 : : else
123 : 0 : percent = (unsigned) ((e->written_uncompressed * UINT64_C(100)) / (uint64_t) e->st.st_size);
124 : :
125 [ # # ]: 0 : if (percent == e->last_percent)
126 : 0 : return;
127 : :
128 [ # # ]: 0 : if (!ratelimit_below(&e->progress_rate_limit))
129 : 0 : return;
130 : :
131 : 0 : sd_notifyf(false, "X_IMPORT_PROGRESS=%u", percent);
132 [ # # ]: 0 : log_info("Exported %u%%.", percent);
133 : :
134 : 0 : e->last_percent = percent;
135 : : }
136 : :
137 : 0 : static int raw_export_process(RawExport *e) {
138 : : ssize_t l;
139 : : int r;
140 : :
141 [ # # ]: 0 : assert(e);
142 : :
143 [ # # # # ]: 0 : if (!e->tried_reflink && e->compress.type == IMPORT_COMPRESS_UNCOMPRESSED) {
144 : :
145 : : /* If we shall take an uncompressed snapshot we can
146 : : * reflink source to destination directly. Let's see
147 : : * if this works. */
148 : :
149 : 0 : r = btrfs_reflink(e->input_fd, e->output_fd);
150 [ # # ]: 0 : if (r >= 0) {
151 : 0 : r = 0;
152 : 0 : goto finish;
153 : : }
154 : :
155 : 0 : e->tried_reflink = true;
156 : : }
157 : :
158 [ # # # # ]: 0 : if (!e->tried_sendfile && e->compress.type == IMPORT_COMPRESS_UNCOMPRESSED) {
159 : :
160 : 0 : l = sendfile(e->output_fd, e->input_fd, NULL, COPY_BUFFER_SIZE);
161 [ # # ]: 0 : if (l < 0) {
162 [ # # ]: 0 : if (errno == EAGAIN)
163 : 0 : return 0;
164 : :
165 : 0 : e->tried_sendfile = true;
166 [ # # ]: 0 : } else if (l == 0) {
167 : 0 : r = 0;
168 : 0 : goto finish;
169 : : } else {
170 : 0 : e->written_uncompressed += l;
171 : 0 : e->written_compressed += l;
172 : :
173 : 0 : raw_export_report_progress(e);
174 : :
175 : 0 : return 0;
176 : : }
177 : : }
178 : :
179 [ # # ]: 0 : while (e->buffer_size <= 0) {
180 : : uint8_t input[COPY_BUFFER_SIZE];
181 : :
182 [ # # ]: 0 : if (e->eof) {
183 : 0 : r = 0;
184 : 0 : goto finish;
185 : : }
186 : :
187 : 0 : l = read(e->input_fd, input, sizeof(input));
188 [ # # ]: 0 : if (l < 0) {
189 [ # # ]: 0 : r = log_error_errno(errno, "Failed to read raw file: %m");
190 : 0 : goto finish;
191 : : }
192 : :
193 [ # # ]: 0 : if (l == 0) {
194 : 0 : e->eof = true;
195 : 0 : r = import_compress_finish(&e->compress, &e->buffer, &e->buffer_size, &e->buffer_allocated);
196 : : } else {
197 : 0 : e->written_uncompressed += l;
198 : 0 : r = import_compress(&e->compress, input, l, &e->buffer, &e->buffer_size, &e->buffer_allocated);
199 : : }
200 [ # # ]: 0 : if (r < 0) {
201 [ # # ]: 0 : r = log_error_errno(r, "Failed to encode: %m");
202 : 0 : goto finish;
203 : : }
204 : : }
205 : :
206 : 0 : l = write(e->output_fd, e->buffer, e->buffer_size);
207 [ # # ]: 0 : if (l < 0) {
208 [ # # ]: 0 : if (errno == EAGAIN)
209 : 0 : return 0;
210 : :
211 [ # # ]: 0 : r = log_error_errno(errno, "Failed to write output file: %m");
212 : 0 : goto finish;
213 : : }
214 : :
215 [ # # ]: 0 : assert((size_t) l <= e->buffer_size);
216 : 0 : memmove(e->buffer, (uint8_t*) e->buffer + l, e->buffer_size - l);
217 : 0 : e->buffer_size -= l;
218 : 0 : e->written_compressed += l;
219 : :
220 : 0 : raw_export_report_progress(e);
221 : :
222 : 0 : return 0;
223 : :
224 : 0 : finish:
225 [ # # ]: 0 : if (r >= 0) {
226 : 0 : (void) copy_times(e->input_fd, e->output_fd, COPY_CRTIME);
227 : 0 : (void) copy_xattr(e->input_fd, e->output_fd);
228 : : }
229 : :
230 [ # # ]: 0 : if (e->on_finished)
231 : 0 : e->on_finished(e, r, e->userdata);
232 : : else
233 : 0 : sd_event_exit(e->event, r);
234 : :
235 : 0 : return 0;
236 : : }
237 : :
238 : 0 : static int raw_export_on_output(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
239 : 0 : RawExport *i = userdata;
240 : :
241 : 0 : return raw_export_process(i);
242 : : }
243 : :
244 : 0 : static int raw_export_on_defer(sd_event_source *s, void *userdata) {
245 : 0 : RawExport *i = userdata;
246 : :
247 : 0 : return raw_export_process(i);
248 : : }
249 : :
250 : 0 : static int reflink_snapshot(int fd, const char *path) {
251 : : int new_fd, r;
252 : :
253 : 0 : new_fd = open_parent(path, O_TMPFILE|O_CLOEXEC|O_RDWR, 0600);
254 [ # # ]: 0 : if (new_fd < 0) {
255 [ # # ]: 0 : _cleanup_free_ char *t = NULL;
256 : :
257 : 0 : r = tempfn_random(path, NULL, &t);
258 [ # # ]: 0 : if (r < 0)
259 : 0 : return r;
260 : :
261 : 0 : new_fd = open(t, O_CLOEXEC|O_CREAT|O_NOCTTY|O_RDWR, 0600);
262 [ # # ]: 0 : if (new_fd < 0)
263 : 0 : return -errno;
264 : :
265 : 0 : (void) unlink(t);
266 : : }
267 : :
268 : 0 : r = btrfs_reflink(fd, new_fd);
269 [ # # ]: 0 : if (r < 0) {
270 : 0 : safe_close(new_fd);
271 : 0 : return r;
272 : : }
273 : :
274 : 0 : return new_fd;
275 : : }
276 : :
277 : 0 : int raw_export_start(RawExport *e, const char *path, int fd, ImportCompressType compress) {
278 : 0 : _cleanup_close_ int sfd = -1, tfd = -1;
279 : : int r;
280 : :
281 [ # # ]: 0 : assert(e);
282 [ # # ]: 0 : assert(path);
283 [ # # ]: 0 : assert(fd >= 0);
284 [ # # ]: 0 : assert(compress < _IMPORT_COMPRESS_TYPE_MAX);
285 [ # # ]: 0 : assert(compress != IMPORT_COMPRESS_UNKNOWN);
286 : :
287 [ # # ]: 0 : if (e->output_fd >= 0)
288 : 0 : return -EBUSY;
289 : :
290 : 0 : r = fd_nonblock(fd, true);
291 [ # # ]: 0 : if (r < 0)
292 : 0 : return r;
293 : :
294 : 0 : r = free_and_strdup(&e->path, path);
295 [ # # ]: 0 : if (r < 0)
296 : 0 : return r;
297 : :
298 : 0 : sfd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY);
299 [ # # ]: 0 : if (sfd < 0)
300 : 0 : return -errno;
301 : :
302 [ # # ]: 0 : if (fstat(sfd, &e->st) < 0)
303 : 0 : return -errno;
304 : 0 : r = stat_verify_regular(&e->st);
305 [ # # ]: 0 : if (r < 0)
306 : 0 : return r;
307 : :
308 : : /* Try to take a reflink snapshot of the file, if we can t make the export atomic */
309 : 0 : tfd = reflink_snapshot(sfd, path);
310 [ # # ]: 0 : if (tfd >= 0)
311 : 0 : e->input_fd = TAKE_FD(tfd);
312 : : else
313 : 0 : e->input_fd = TAKE_FD(sfd);
314 : :
315 : 0 : r = import_compress_init(&e->compress, compress);
316 [ # # ]: 0 : if (r < 0)
317 : 0 : return r;
318 : :
319 : 0 : r = sd_event_add_io(e->event, &e->output_event_source, fd, EPOLLOUT, raw_export_on_output, e);
320 [ # # ]: 0 : if (r == -EPERM) {
321 : 0 : r = sd_event_add_defer(e->event, &e->output_event_source, raw_export_on_defer, e);
322 [ # # ]: 0 : if (r < 0)
323 : 0 : return r;
324 : :
325 : 0 : r = sd_event_source_set_enabled(e->output_event_source, SD_EVENT_ON);
326 : : }
327 [ # # ]: 0 : if (r < 0)
328 : 0 : return r;
329 : :
330 : 0 : e->output_fd = fd;
331 : 0 : return r;
332 : : }
|
