src/xz/process.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       process.c
   4 /// \brief      Compresses or uncompresses a file
   5 //
   6 //  Copyright (C) 2007 Lasse Collin
   7 //
   8 //  This program is free software; you can redistribute it and/or
   9 //  modify it under the terms of the GNU Lesser General Public
  10 //  License as published by the Free Software Foundation; either
  11 //  version 2.1 of the License, or (at your option) any later version.
  12 //
  13 //  This program is distributed in the hope that it will be useful,
  14 //  but 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 ///////////////////////////////////////////////////////////////////////////////
  19
  20 #include "private.h"
  21
  22
  23 enum operation_mode opt_mode = MODE_COMPRESS;
  24
  25 enum format_type opt_format = FORMAT_AUTO;
  26
  27
  28 /// Stream used to communicate with liblzma
  29 static lzma_stream strm = LZMA_STREAM_INIT;
  30
  31 /// Filters needed for all encoding all formats, and also decoding in raw data
  32 static lzma_filter filters[LZMA_FILTERS_MAX + 1];
  33
  34 /// Number of filters. Zero indicates that we are using a preset.
  35 static size_t filters_count = 0;
  36
  37 /// Number of the preset (0-9)
  38 static size_t preset_number = 6;
  39
  40 /// True if we should auto-adjust the compression settings to use less memory
  41 /// if memory usage limit is too low for the original settings.
  42 static bool auto_adjust = true;
  43
  44 /// Indicate if no preset has been explicitly given. In that case, if we need
  45 /// to auto-adjust for lower memory usage, we won't print a warning.
  46 static bool preset_default = true;
  47
  48 /// If a preset is used (no custom filter chain) and preset_extreme is true,
  49 /// a significantly slower compression is used to achieve slightly better
  50 /// compression ratio.
  51 static bool preset_extreme = false;
  52
  53 /// Integrity check type
  54 #ifdef HAVE_CHECK_CRC64
  55 static lzma_check check = LZMA_CHECK_CRC64;
  56 #else
  57 static lzma_check check = LZMA_CHECK_CRC32;
  58 #endif
  59
  60
  61 extern void
  62 coder_set_check(lzma_check new_check)
  63 {
  64         check = new_check;
  65         return;
  66 }
  67
  68
  69 extern void
  70 coder_set_preset(size_t new_preset)
  71 {
  72         preset_number = new_preset;
  73         preset_default = false;
  74         return;
  75 }
  76
  77
  78 extern void
  79 coder_set_extreme(void)
  80 {
  81         preset_extreme = true;
  82         return;
  83 }
  84
  85
  86 extern void
  87 coder_add_filter(lzma_vli id, void *options)
  88 {
  89         if (filters_count == LZMA_FILTERS_MAX)
  90                 message_fatal(_("Maximum number of filters is four"));
  91
  92         filters[filters_count].id = id;
  93         filters[filters_count].options = options;
  94         ++filters_count;
  95
  96         return;
  97 }
  98
  99
 100 static void lzma_attribute((noreturn))
 101 memlimit_too_small(uint64_t memory_usage, uint64_t memory_limit)
 102 {
 103         message_fatal(_("Memory usage limit (%" PRIu64 " MiB) is too small "
 104                         "for the given filter setup (%" PRIu64 " MiB)"),
 105                         memory_limit >> 20, memory_usage >> 20);
 106 }
 107
 108
 109 extern void
 110 coder_set_compression_settings(void)
 111 {
 112         // Options for LZMA1 or LZMA2 in case we are using a preset.
 113         static lzma_options_lzma opt_lzma;
 114
 115         if (filters_count == 0) {
 116                 // We are using a preset. This is not a good idea in raw mode
 117                 // except when playing around with things. Different versions
 118                 // of this software may use different options in presets, and
 119                 // thus make uncompressing the raw data difficult.
 120                 if (opt_format == FORMAT_RAW) {
 121                         // The message is shown only if warnings are allowed
 122                         // but the exit status isn't changed.
 123                         message(V_WARNING, _("Using a preset in raw mode "
 124                                         "is discouraged."));
 125                         message(V_WARNING, _("The exact options of the "
 126                                         "presets may vary between software "
 127                                         "versions."));
 128                 }
 129
 130                 // Get the preset for LZMA1 or LZMA2.
 131                 if (preset_extreme)
 132                         preset_number |= LZMA_PRESET_EXTREME;
 133
 134                 if (lzma_lzma_preset(&opt_lzma, preset_number))
 135                         message_bug();
 136
 137                 // Use LZMA2 except with --format=lzma we use LZMA1.
 138                 filters[0].id = opt_format == FORMAT_LZMA
 139                                 ? LZMA_FILTER_LZMA1 : LZMA_FILTER_LZMA2;
 140                 filters[0].options = &opt_lzma;
 141                 filters_count = 1;
 142         } else {
 143                 preset_default = false;
 144         }
 145
 146         // Terminate the filter options array.
 147         filters[filters_count].id = LZMA_VLI_UNKNOWN;
 148
 149         // If we are using the LZMA_Alone format, allow exactly one filter
 150         // which has to be LZMA.
 151         if (opt_format == FORMAT_LZMA && (filters_count != 1
 152                         || filters[0].id != LZMA_FILTER_LZMA1))
 153                 message_fatal(_("With --format=lzma only the LZMA1 filter "
 154                                 "is supported"));
 155
 156         // Print the selected filter chain.
 157         message_filters(V_DEBUG, filters);
 158
 159         // If using --format=raw, we can be decoding. The memusage function
 160         // also validates the filter chain and the options used for the
 161         // filters.
 162         uint64_t memory_usage;
 163         uint64_t memory_limit;
 164         if (opt_mode == MODE_COMPRESS) {
 165                 memory_usage = lzma_raw_encoder_memusage(filters);
 166                 memory_limit = hardware_memlimit_encoder();
 167         } else {
 168                 memory_usage = lzma_raw_decoder_memusage(filters);
 169                 memory_limit = hardware_memlimit_decoder();
 170         }
 171
 172         if (memory_usage == UINT64_MAX)
 173                 message_fatal("Unsupported filter chain or filter options");
 174
 175         // Print memory usage info.
 176         message(V_DEBUG, _("%'" PRIu64 " MiB (%'" PRIu64 " B) of memory is "
 177                         "required per thread, "
 178                         "limit is %'" PRIu64 " MiB (%'" PRIu64 " B)"),
 179                         memory_usage >> 20, memory_usage,
 180                         memory_limit >> 20, memory_limit);
 181
 182         if (memory_usage > memory_limit) {
 183                 // If --no-auto-adjust was used or we didn't find LZMA1 or
 184                 // LZMA2 as the last filter, give an error immediatelly.
 185                 // --format=raw implies --no-auto-adjust.
 186                 if (!auto_adjust || opt_format == FORMAT_RAW)
 187                         memlimit_too_small(memory_usage, memory_limit);
 188
 189                 assert(opt_mode == MODE_COMPRESS);
 190
 191                 // Look for the last filter if it is LZMA2 or LZMA1, so
 192                 // we can make it use less RAM. With other filters we don't
 193                 // know what to do.
 194                 size_t i = 0;
 195                 while (filters[i].id != LZMA_FILTER_LZMA2
 196                                 && filters[i].id != LZMA_FILTER_LZMA1) {
 197                         if (filters[i].id == LZMA_VLI_UNKNOWN)
 198                                 memlimit_too_small(memory_usage, memory_limit);
 199
 200                         ++i;
 201                 }
 202
 203                 // Decrease the dictionary size until we meet the memory
 204                 // usage limit. First round down to full mebibytes.
 205                 lzma_options_lzma *opt = filters[i].options;
 206                 const uint32_t orig_dict_size = opt->dict_size;
 207                 opt->dict_size &= ~((UINT32_C(1) << 20) - 1);
 208                 while (true) {
 209                         // If it is below 1 MiB, auto-adjusting failed. We
 210                         // could be more sophisticated and scale it down even
 211                         // more, but let's see if many complain about this
 212                         // version.
 213                         //
 214                         // FIXME: Displays the scaled memory usage instead
 215                         // of the original.
 216                         if (opt->dict_size < (UINT32_C(1) << 20))
 217                                 memlimit_too_small(memory_usage, memory_limit);
 218
 219                         memory_usage = lzma_raw_encoder_memusage(filters);
 220                         if (memory_usage == UINT64_MAX)
 221                                 message_bug();
 222
 223                         // Accept it if it is low enough.
 224                         if (memory_usage <= memory_limit)
 225                                 break;
 226
 227                         // Otherwise 1 MiB down and try again. I hope this
 228                         // isn't too slow method for cases where the original
 229                         // dict_size is very big.
 230                         opt->dict_size -= UINT32_C(1) << 20;
 231                 }
 232
 233                 // Tell the user that we decreased the dictionary size.
 234                 // However, omit the message if no preset or custom chain
 235                 // was given. FIXME: Always warn?
 236                 if (!preset_default)
 237                         message(V_WARNING, "Adjusted LZMA%c dictionary size "
 238                                         "from %'" PRIu32 " MiB to "
 239                                         "%'" PRIu32 " MiB to not exceed "
 240                                         "the memory usage limit of "
 241                                         "%'" PRIu64 " MiB",
 242                                         filters[i].id == LZMA_FILTER_LZMA2
 243                                                 ? '2' : '1',
 244                                         orig_dict_size >> 20,
 245                                         opt->dict_size >> 20,
 246                                         memory_limit >> 20);
 247         }
 248
 249         // Limit the number of worker threads so that memory usage
 250         // limit isn't exceeded.
 251         assert(memory_usage > 0);
 252         size_t thread_limit = memory_limit / memory_usage;
 253         if (thread_limit == 0)
 254                 thread_limit = 1;
 255
 256         if (opt_threads > thread_limit)
 257                 opt_threads = thread_limit;
 258
 259         return;
 260 }
 261
 262
 263 static bool
 264 coder_init(void)
 265 {
 266         lzma_ret ret = LZMA_PROG_ERROR;
 267
 268         if (opt_mode == MODE_COMPRESS) {
 269                 switch (opt_format) {
 270                 case FORMAT_AUTO:
 271                         // args.c ensures this.
 272                         assert(0);
 273                         break;
 274
 275                 case FORMAT_XZ:
 276                         ret = lzma_stream_encoder(&strm, filters, check);
 277                         break;
 278
 279                 case FORMAT_LZMA:
 280                         ret = lzma_alone_encoder(&strm, filters[0].options);
 281                         break;
 282
 283                 case FORMAT_RAW:
 284                         ret = lzma_raw_encoder(&strm, filters);
 285                         break;
 286                 }
 287         } else {
 288                 const uint32_t flags = LZMA_TELL_UNSUPPORTED_CHECK
 289                                 | LZMA_CONCATENATED;
 290
 291                 switch (opt_format) {
 292                 case FORMAT_AUTO:
 293                         ret = lzma_auto_decoder(&strm,
 294                                         hardware_memlimit_decoder(), flags);
 295                         break;
 296
 297                 case FORMAT_XZ:
 298                         ret = lzma_stream_decoder(&strm,
 299                                         hardware_memlimit_decoder(), flags);
 300                         break;
 301
 302                 case FORMAT_LZMA:
 303                         ret = lzma_alone_decoder(&strm,
 304                                         hardware_memlimit_decoder());
 305                         break;
 306
 307                 case FORMAT_RAW:
 308                         // Memory usage has already been checked in
 309                         // coder_set_compression_settings().
 310                         ret = lzma_raw_decoder(&strm, filters);
 311                         break;
 312                 }
 313         }
 314
 315         if (ret != LZMA_OK) {
 316                 if (ret == LZMA_MEM_ERROR)
 317                         message_error("%s", message_strm(LZMA_MEM_ERROR));
 318                 else
 319                         message_bug();
 320
 321                 return true;
 322         }
 323
 324         return false;
 325 }
 326
 327
 328 static bool
 329 coder_run(file_pair *pair)
 330 {
 331         // Buffers to hold input and output data.
 332         uint8_t in_buf[IO_BUFFER_SIZE];
 333         uint8_t out_buf[IO_BUFFER_SIZE];
 334
 335         // Initialize the progress indicator.
 336         const uint64_t in_size = pair->src_st.st_size <= (off_t)(0)
 337                         ? 0 : (uint64_t)(pair->src_st.st_size);
 338         message_progress_start(pair->src_name, in_size);
 339
 340         lzma_action action = LZMA_RUN;
 341         lzma_ret ret;
 342
 343         strm.avail_in = 0;
 344         strm.next_out = out_buf;
 345         strm.avail_out = IO_BUFFER_SIZE;
 346
 347         while (!user_abort) {
 348                 // Fill the input buffer if it is empty and we haven't reached
 349                 // end of file yet.
 350                 if (strm.avail_in == 0 && !pair->src_eof) {
 351                         strm.next_in = in_buf;
 352                         strm.avail_in = io_read(pair, in_buf, IO_BUFFER_SIZE);
 353
 354                         if (strm.avail_in == SIZE_MAX)
 355                                 break;
 356
 357                         // Encoder needs to know when we have given all the
 358                         // input to it. The decoders need to know it too when
 359                         // we are using LZMA_CONCATENATED.
 360                         if (pair->src_eof)
 361                                 action = LZMA_FINISH;
 362                 }
 363
 364                 // Let liblzma do the actual work.
 365                 ret = lzma_code(&strm, action);
 366
 367                 // Write out if the output buffer became full.
 368                 if (strm.avail_out == 0) {
 369                         if (opt_mode != MODE_TEST && io_write(pair, out_buf,
 370                                         IO_BUFFER_SIZE - strm.avail_out))
 371                                 return false;
 372
 373                         strm.next_out = out_buf;
 374                         strm.avail_out = IO_BUFFER_SIZE;
 375                 }
 376
 377                 if (ret != LZMA_OK) {
 378                         // Determine if the return value indicates that we
 379                         // won't continue coding.
 380                         const bool stop = ret != LZMA_NO_CHECK
 381                                         && ret != LZMA_UNSUPPORTED_CHECK;
 382
 383                         if (stop) {
 384                                 // First print the final progress info.
 385                                 // This way the user sees more accurately
 386                                 // where the error occurred. Note that we
 387                                 // print this *before* the possible error
 388                                 // message.
 389                                 //
 390                                 // FIXME: What if something goes wrong
 391                                 // after this?
 392                                 message_progress_end(strm.total_in,
 393                                                 strm.total_out,
 394                                                 ret == LZMA_STREAM_END);
 395
 396                                 // Write the remaining bytes even if something
 397                                 // went wrong, because that way the user gets
 398                                 // as much data as possible, which can be good
 399                                 // when trying to get at least some useful
 400                                 // data out of damaged files.
 401                                 if (opt_mode != MODE_TEST && io_write(pair,
 402                                                 out_buf, IO_BUFFER_SIZE
 403                                                         - strm.avail_out))
 404                                         return false;
 405                         }
 406
 407                         if (ret == LZMA_STREAM_END) {
 408                                 // Check that there is no trailing garbage.
 409                                 // This is needed for LZMA_Alone and raw
 410                                 // streams.
 411                                 if (strm.avail_in == 0 && (pair->src_eof
 412                                                 || io_read(pair, in_buf, 1)
 413                                                         == 0)) {
 414                                         assert(pair->src_eof);
 415                                         return true;
 416                                 }
 417
 418                                 // FIXME: What about io_read() failing?
 419
 420                                 // We hadn't reached the end of the file.
 421                                 ret = LZMA_DATA_ERROR;
 422                                 assert(stop);
 423                         }
 424
 425                         // If we get here and stop is true, something went
 426                         // wrong and we print an error. Otherwise it's just
 427                         // a warning and coding can continue.
 428                         if (stop) {
 429                                 message_error("%s: %s", pair->src_name,
 430                                                 message_strm(ret));
 431                         } else {
 432                                 message_warning("%s: %s", pair->src_name,
 433                                                 message_strm(ret));
 434
 435                                 // When compressing, all possible errors set
 436                                 // stop to true.
 437                                 assert(opt_mode != MODE_COMPRESS);
 438                         }
 439
 440                         if (ret == LZMA_MEMLIMIT_ERROR) {
 441                                 // Figure out how much memory it would have
 442                                 // actually needed.
 443                                 uint64_t memusage = lzma_memusage(&strm);
 444                                 uint64_t memlimit
 445                                                 = hardware_memlimit_decoder();
 446
 447                                 // Round the memory limit down and usage up.
 448                                 // This way we don't display a ridiculous
 449                                 // message like "Limit was 9 MiB, but 9 MiB
 450                                 // would have been needed".
 451                                 memusage = (memusage + 1024 * 1024 - 1)
 452                                                 / (1024 * 1024);
 453                                 memlimit /= 1024 * 1024;
 454
 455                                 message_error(_("Limit was %'" PRIu64 " MiB, "
 456                                                 "but %'" PRIu64 " MiB would "
 457                                                 "have been needed"),
 458                                                 memlimit, memusage);
 459                         }
 460
 461                         if (stop)
 462                                 return false;
 463                 }
 464
 465                 // Show progress information if --verbose was specified and
 466                 // stderr is a terminal.
 467                 message_progress_update(strm.total_in, strm.total_out);
 468         }
 469
 470         return false;
 471 }
 472
 473
 474 extern void
 475 process_file(const char *filename)
 476 {
 477         // First try initializing the coder. If it fails, it's useless to try
 478         // opening the file. Check also for user_abort just in case if we had
 479         // got a signal while initializing the coder.
 480         if (coder_init() || user_abort)
 481                 return;
 482
 483         // Try to open the input and output files.
 484         file_pair *pair = io_open(filename);
 485         if (pair == NULL)
 486                 return;
 487
 488         // Do the actual coding.
 489         const bool success = coder_run(pair);
 490
 491         // Close the file pair. It needs to know if coding was successful to
 492         // know if the source or target file should be unlinked.
 493         io_close(pair, success);
 494
 495         return;
 496 }