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