src/import/import-tar.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2015 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <linux/fs.h>
  23
  24 #include "sd-daemon.h"
  25 #include "sd-event.h"
  26 #include "util.h"
  27 #include "path-util.h"
  28 #include "btrfs-util.h"
  29 #include "copy.h"
  30 #include "mkdir.h"
  31 #include "rm-rf.h"
  32 #include "ratelimit.h"
  33 #include "machine-pool.h"
  34 #include "qcow2-util.h"
  35 #include "import-compress.h"
  36 #include "import-common.h"
  37 #include "import-tar.h"
  38
  39 struct TarImport {
  40         sd_event *event;
  41
  42         char *image_root;
  43
  44         TarImportFinished on_finished;
  45         void *userdata;
  46
  47         char *local;
  48         bool force_local;
  49         bool read_only;
  50         bool grow_machine_directory;
  51
  52         char *temp_path;
  53         char *final_path;
  54
  55         int input_fd;
  56         int tar_fd;
  57
  58         ImportCompress compress;
  59
  60         uint64_t written_since_last_grow;
  61
  62         sd_event_source *input_event_source;
  63
  64         uint8_t buffer[16*1024];
  65         size_t buffer_size;
  66
  67         uint64_t written_compressed;
  68         uint64_t written_uncompressed;
  69
  70         struct stat st;
  71
  72         pid_t tar_pid;
  73
  74         unsigned last_percent;
  75         RateLimit progress_rate_limit;
  76 };
  77
  78 TarImport* tar_import_unref(TarImport *i) {
  79         if (!i)
  80                 return NULL;
  81
  82         sd_event_source_unref(i->input_event_source);
  83
  84         if (i->tar_pid > 1) {
  85                 (void) kill_and_sigcont(i->tar_pid, SIGKILL);
  86                 (void) wait_for_terminate(i->tar_pid, NULL);
  87         }
  88
  89         if (i->temp_path) {
  90                 (void) btrfs_subvol_remove(i->temp_path);
  91                 (void) rm_rf(i->temp_path, REMOVE_ROOT|REMOVE_PHYSICAL);
  92                 free(i->temp_path);
  93         }
  94
  95         import_compress_free(&i->compress);
  96
  97         sd_event_unref(i->event);
  98
  99         safe_close(i->tar_fd);
 100
 101         free(i->final_path);
 102         free(i->image_root);
 103         free(i->local);
 104         free(i);
 105
 106         return NULL;
 107 }
 108
 109 int tar_import_new(
 110                 TarImport **ret,
 111                 sd_event *event,
 112                 const char *image_root,
 113                 TarImportFinished on_finished,
 114                 void *userdata) {
 115
 116         _cleanup_(tar_import_unrefp) TarImport *i = NULL;
 117         int r;
 118
 119         assert(ret);
 120
 121         i = new0(TarImport, 1);
 122         if (!i)
 123                 return -ENOMEM;
 124
 125         i->input_fd = i->tar_fd = -1;
 126         i->on_finished = on_finished;
 127         i->userdata = userdata;
 128
 129         RATELIMIT_INIT(i->progress_rate_limit, 100 * USEC_PER_MSEC, 1);
 130         i->last_percent = (unsigned) -1;
 131
 132         i->image_root = strdup(image_root ?: "/var/lib/machines");
 133         if (!i->image_root)
 134                 return -ENOMEM;
 135
 136         i->grow_machine_directory = path_startswith(i->image_root, "/var/lib/machines");
 137
 138         if (event)
 139                 i->event = sd_event_ref(event);
 140         else {
 141                 r = sd_event_default(&i->event);
 142                 if (r < 0)
 143                         return r;
 144         }
 145
 146         *ret = i;
 147         i = NULL;
 148
 149         return 0;
 150 }
 151
 152 static void tar_import_report_progress(TarImport *i) {
 153         unsigned percent;
 154         assert(i);
 155
 156         /* We have no size information, unless the source is a regular file */
 157         if (!S_ISREG(i->st.st_mode))
 158                 return;
 159
 160         if (i->written_compressed >= (uint64_t) i->st.st_size)
 161                 percent = 100;
 162         else
 163                 percent = (unsigned) ((i->written_compressed * UINT64_C(100)) / (uint64_t) i->st.st_size);
 164
 165         if (percent == i->last_percent)
 166                 return;
 167
 168         if (!ratelimit_test(&i->progress_rate_limit))
 169                 return;
 170
 171         sd_notifyf(false, "X_IMPORT_PROGRESS=%u", percent);
 172         log_info("Imported %u%%.", percent);
 173
 174         i->last_percent = percent;
 175 }
 176
 177 static int tar_import_finish(TarImport *i) {
 178         int r;
 179
 180         assert(i);
 181         assert(i->tar_fd >= 0);
 182         assert(i->temp_path);
 183         assert(i->final_path);
 184
 185         i->tar_fd = safe_close(i->tar_fd);
 186
 187         if (i->tar_pid > 0) {
 188                 r = wait_for_terminate_and_warn("tar", i->tar_pid, true);
 189                 i->tar_pid = 0;
 190                 if (r < 0)
 191                         return r;
 192         }
 193
 194         if (i->read_only) {
 195                 r = import_make_read_only(i->temp_path);
 196                 if (r < 0)
 197                         return r;
 198         }
 199
 200         if (i->force_local) {
 201                 (void) btrfs_subvol_remove(i->final_path);
 202                 (void) rm_rf(i->final_path, REMOVE_ROOT|REMOVE_PHYSICAL);
 203         }
 204
 205         r = rename_noreplace(AT_FDCWD, i->temp_path, AT_FDCWD, i->final_path);
 206         if (r < 0)
 207                 return log_error_errno(r, "Failed to move image into place: %m");
 208
 209         free(i->temp_path);
 210         i->temp_path = NULL;
 211
 212         return 0;
 213 }
 214
 215 static int tar_import_fork_tar(TarImport *i) {
 216         int r;
 217
 218         assert(i);
 219
 220         assert(!i->final_path);
 221         assert(!i->temp_path);
 222         assert(i->tar_fd < 0);
 223
 224         i->final_path = strjoin(i->image_root, "/", i->local, NULL);
 225         if (!i->final_path)
 226                 return log_oom();
 227
 228         r = tempfn_random(i->final_path, &i->temp_path);
 229         if (r < 0)
 230                 return log_oom();
 231
 232         (void) mkdir_parents_label(i->temp_path, 0700);
 233
 234         r = btrfs_subvol_make(i->temp_path);
 235         if (r == -ENOTTY) {
 236                 if (mkdir(i->temp_path, 0755) < 0)
 237                         return log_error_errno(errno, "Failed to create directory %s: %m", i->temp_path);
 238         } else if (r < 0)
 239                 return log_error_errno(errno, "Failed to create subvolume %s: %m", i->temp_path);
 240
 241         i->tar_fd = import_fork_tar_x(i->temp_path, &i->tar_pid);
 242         if (i->tar_fd < 0)
 243                 return i->tar_fd;
 244
 245         return 0;
 246 }
 247
 248 static int tar_import_write(const void *p, size_t sz, void *userdata) {
 249         TarImport *i = userdata;
 250         int r;
 251
 252         if (i->grow_machine_directory && i->written_since_last_grow >= GROW_INTERVAL_BYTES) {
 253                 i->written_since_last_grow = 0;
 254                 grow_machine_directory();
 255         }
 256
 257         r = loop_write(i->tar_fd, p, sz, false);
 258         if (r < 0)
 259                 return r;
 260
 261         i->written_uncompressed += sz;
 262         i->written_since_last_grow += sz;
 263
 264         return 0;
 265 }
 266
 267 static int tar_import_process(TarImport *i) {
 268         ssize_t l;
 269         int r;
 270
 271         assert(i);
 272         assert(i->buffer_size < sizeof(i->buffer));
 273
 274         l = read(i->input_fd, i->buffer + i->buffer_size, sizeof(i->buffer) - i->buffer_size);
 275         if (l < 0) {
 276                 if (errno == EAGAIN)
 277                         return 0;
 278
 279                 r = log_error_errno(errno, "Failed to read input file: %m");
 280                 goto finish;
 281         }
 282         if (l == 0) {
 283                 if (i->compress.type == IMPORT_COMPRESS_UNKNOWN) {
 284                         log_error("Premature end of file: %m");
 285                         r = -EIO;
 286                         goto finish;
 287                 }
 288
 289                 r = tar_import_finish(i);
 290                 goto finish;
 291         }
 292
 293         i->buffer_size += l;
 294
 295         if (i->compress.type == IMPORT_COMPRESS_UNKNOWN) {
 296                 r = import_uncompress_detect(&i->compress, i->buffer, i->buffer_size);
 297                 if (r < 0) {
 298                         log_error("Failed to detect file compression: %m");
 299                         goto finish;
 300                 }
 301                 if (r == 0) /* Need more data */
 302                         return 0;
 303
 304                 r = tar_import_fork_tar(i);
 305                 if (r < 0)
 306                         goto finish;
 307         }
 308
 309         r = import_uncompress(&i->compress, i->buffer, i->buffer_size, tar_import_write, i);
 310         if (r < 0) {
 311                 log_error_errno(r, "Failed to decode and write: %m");
 312                 goto finish;
 313         }
 314
 315         i->written_compressed += i->buffer_size;
 316         i->buffer_size = 0;
 317
 318         tar_import_report_progress(i);
 319
 320         return 0;
 321
 322 finish:
 323         if (i->on_finished)
 324                 i->on_finished(i, r, i->userdata);
 325         else
 326                 sd_event_exit(i->event, r);
 327
 328         return 0;
 329 }
 330
 331 static int tar_import_on_input(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 332         TarImport *i = userdata;
 333
 334         return tar_import_process(i);
 335 }
 336
 337 static int tar_import_on_defer(sd_event_source *s, void *userdata) {
 338         TarImport *i = userdata;
 339
 340         return tar_import_process(i);
 341 }
 342
 343 int tar_import_start(TarImport *i, int fd, const char *local, bool force_local, bool read_only) {
 344         int r;
 345
 346         assert(i);
 347         assert(fd >= 0);
 348         assert(local);
 349
 350         if (!machine_name_is_valid(local))
 351                 return -EINVAL;
 352
 353         if (i->input_fd >= 0)
 354                 return -EBUSY;
 355
 356         r = fd_nonblock(fd, true);
 357         if (r < 0)
 358                 return r;
 359
 360         r = free_and_strdup(&i->local, local);
 361         if (r < 0)
 362                 return r;
 363         i->force_local = force_local;
 364         i->read_only = read_only;
 365
 366         if (fstat(fd, &i->st) < 0)
 367                 return -errno;
 368
 369         r = sd_event_add_io(i->event, &i->input_event_source, fd, EPOLLIN, tar_import_on_input, i);
 370         if (r == -EPERM) {
 371                 /* This fd does not support epoll, for example because it is a regular file. Busy read in that case */
 372                 r = sd_event_add_defer(i->event, &i->input_event_source, tar_import_on_defer, i);
 373                 if (r < 0)
 374                         return r;
 375
 376                 r = sd_event_source_set_enabled(i->input_event_source, SD_EVENT_ON);
 377         }
 378         if (r < 0)
 379                 return r;
 380
 381         i->input_fd = fd;
 382         return r;
 383 }