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 /*
 250         // Limit the number of worker threads so that memory usage
 251         // limit isn't exceeded.
 252         assert(memory_usage > 0);
 253         size_t thread_limit = memory_limit / memory_usage;
 254         if (thread_limit == 0)
 255                 thread_limit = 1;
 256
 257         if (opt_threads > thread_limit)
 258                 opt_threads = thread_limit;
 259 */
 260
 261         return;
 262 }
 263
 264
 265 static bool
 266 coder_init(void)
 267 {
 268         lzma_ret ret = LZMA_PROG_ERROR;
 269
 270         if (opt_mode == MODE_COMPRESS) {
 271                 switch (opt_format) {
 272                 case FORMAT_AUTO:
 273                         // args.c ensures this.
 274                         assert(0);
 275                         break;
 276
 277                 case FORMAT_XZ:
 278                         ret = lzma_stream_encoder(&strm, filters, check);
 279                         break;
 280
 281                 case FORMAT_LZMA:
 282                         ret = lzma_alone_encoder(&strm, filters[0].options);
 283                         break;
 284
 285                 case FORMAT_RAW:
 286                         ret = lzma_raw_encoder(&strm, filters);
 287                         break;
 288                 }
 289         } else {
 290                 const uint32_t flags = LZMA_TELL_UNSUPPORTED_CHECK
 291                                 | LZMA_CONCATENATED;
 292
 293                 switch (opt_format) {
 294                 case FORMAT_AUTO:
 295                         ret = lzma_auto_decoder(&strm,
 296                                         hardware_memlimit_decoder(), flags);
 297                         break;
 298
 299                 case FORMAT_XZ:
 300                         ret = lzma_stream_decoder(&strm,
 301                                         hardware_memlimit_decoder(), flags);
 302                         break;
 303
 304                 case FORMAT_LZMA:
 305                         ret = lzma_alone_decoder(&strm,
 306                                         hardware_memlimit_decoder());
 307                         break;
 308
 309                 case FORMAT_RAW:
 310                         // Memory usage has already been checked in
 311                         // coder_set_compression_settings().
 312                         ret = lzma_raw_decoder(&strm, filters);
 313                         break;
 314                 }
 315         }
 316
 317         if (ret != LZMA_OK) {
 318                 if (ret == LZMA_MEM_ERROR)
 319                         message_error("%s", message_strm(LZMA_MEM_ERROR));
 320                 else
 321                         message_bug();
 322
 323                 return true;
 324         }
 325
 326         return false;
 327 }
 328
 329
 330 static bool
 331 coder_run(file_pair *pair)
 332 {
 333         // Buffers to hold input and output data.
 334         uint8_t in_buf[IO_BUFFER_SIZE];
 335         uint8_t out_buf[IO_BUFFER_SIZE];
 336
 337         // Initialize the progress indicator.
 338         const uint64_t in_size = pair->src_st.st_size <= (off_t)(0)
 339                         ? 0 : (uint64_t)(pair->src_st.st_size);
 340         message_progress_start(&strm, pair->src_name, in_size);
 341
 342         lzma_action action = LZMA_RUN;
 343         lzma_ret ret;
 344         bool success = false; // Assume that something goes wrong.
 345
 346         strm.avail_in = 0;
 347         strm.next_out = out_buf;
 348         strm.avail_out = IO_BUFFER_SIZE;
 349
 350         while (!user_abort) {
 351                 // Fill the input buffer if it is empty and we haven't reached
 352                 // end of file yet.
 353                 if (strm.avail_in == 0 && !pair->src_eof) {
 354                         strm.next_in = in_buf;
 355                         strm.avail_in = io_read(pair, in_buf, IO_BUFFER_SIZE);
 356
 357                         if (strm.avail_in == SIZE_MAX)
 358                                 break;
 359
 360                         // Encoder needs to know when we have given all the
 361                         // input to it. The decoders need to know it too when
 362                         // we are using LZMA_CONCATENATED.
 363                         if (pair->src_eof)
 364                                 action = LZMA_FINISH;
 365                 }
 366
 367                 // Let liblzma do the actual work.
 368                 ret = lzma_code(&strm, action);
 369
 370                 // Write out if the output buffer became full.
 371                 if (strm.avail_out == 0) {
 372                         if (opt_mode != MODE_TEST && io_write(pair, out_buf,
 373                                         IO_BUFFER_SIZE - strm.avail_out))
 374                                 break;
 375
 376                         strm.next_out = out_buf;
 377                         strm.avail_out = IO_BUFFER_SIZE;
 378                 }
 379
 380                 if (ret != LZMA_OK) {
 381                         // Determine if the return value indicates that we
 382                         // won't continue coding.
 383                         const bool stop = ret != LZMA_NO_CHECK
 384                                         && ret != LZMA_UNSUPPORTED_CHECK;
 385
 386                         if (stop) {
 387                                 // Write the remaining bytes even if something
 388                                 // went wrong, because that way the user gets
 389                                 // as much data as possible, which can be good
 390                                 // when trying to get at least some useful
 391                                 // data out of damaged files.
 392                                 if (opt_mode != MODE_TEST && io_write(pair,
 393                                                 out_buf, IO_BUFFER_SIZE
 394                                                         - strm.avail_out))
 395                                         break;
 396                         }
 397
 398                         if (ret == LZMA_STREAM_END) {
 399                                 // Check that there is no trailing garbage.
 400                                 // This is needed for LZMA_Alone and raw
 401                                 // streams.
 402                                 if (strm.avail_in == 0 && !pair->src_eof) {
 403                                         // Try reading one more byte.
 404                                         // Hopefully we don't get any more
 405                                         // input, and thus pair->src_eof
 406                                         // becomes true.
 407                                         strm.avail_in = io_read(
 408                                                         pair, in_buf, 1);
 409                                         if (strm.avail_in == SIZE_MAX)
 410                                                 break;
 411
 412                                         assert(strm.avail_in == 0
 413                                                         || strm.avail_in == 1);
 414                                 }
 415
 416                                 if (strm.avail_in == 0) {
 417                                         assert(pair->src_eof);
 418                                         success = true;
 419                                         break;
 420                                 }
 421
 422                                 // We hadn't reached the end of the file.
 423                                 ret = LZMA_DATA_ERROR;
 424                                 assert(stop);
 425                         }
 426
 427                         // If we get here and stop is true, something went
 428                         // wrong and we print an error. Otherwise it's just
 429                         // a warning and coding can continue.
 430                         if (stop) {
 431                                 message_error("%s: %s", pair->src_name,
 432                                                 message_strm(ret));
 433                         } else {
 434                                 message_warning("%s: %s", pair->src_name,
 435                                                 message_strm(ret));
 436
 437                                 // When compressing, all possible errors set
 438                                 // stop to true.
 439                                 assert(opt_mode != MODE_COMPRESS);
 440                         }
 441
 442                         if (ret == LZMA_MEMLIMIT_ERROR) {
 443                                 // Figure out how much memory it would have
 444                                 // actually needed.
 445                                 uint64_t memusage = lzma_memusage(&strm);
 446                                 uint64_t memlimit
 447                                                 = hardware_memlimit_decoder();
 448
 449                                 // Round the memory limit down and usage up.
 450                                 // This way we don't display a ridiculous
 451                                 // message like "Limit was 9 MiB, but 9 MiB
 452                                 // would have been needed".
 453                                 memusage = (memusage + 1024 * 1024 - 1)
 454                                                 / (1024 * 1024);
 455                                 memlimit /= 1024 * 1024;
 456
 457                                 message_error(_("Limit was %'" PRIu64 " MiB, "
 458                                                 "but %'" PRIu64 " MiB would "
 459                                                 "have been needed"),
 460                                                 memlimit, memusage);
 461                         }
 462
 463                         if (stop)
 464                                 break;
 465                 }
 466
 467                 // Show progress information under certain conditions.
 468                 message_progress_update();
 469         }
 470
 471         message_progress_end(success);
 472
 473         return success;
 474 }
 475
 476
 477 extern void
 478 process_file(const char *filename)
 479 {
 480         // First try initializing the coder. If it fails, it's useless to try
 481         // opening the file. Check also for user_abort just in case if we had
 482         // got a signal while initializing the coder.
 483         if (coder_init() || user_abort)
 484                 return;
 485
 486         // Try to open the input and output files.
 487         file_pair *pair = io_open(filename);
 488         if (pair == NULL)
 489                 return;
 490
 491         // Do the actual coding.
 492         const bool success = coder_run(pair);
 493
 494         // Close the file pair. It needs to know if coding was successful to
 495         // know if the source or target file should be unlinked.
 496         io_close(pair, success);
 497
 498         return;
 499 }