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