1 //
2 // Copyright (C) 2015 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #include "update_engine/payload_consumer/xz_extent_writer.h"
18 
19 using google::protobuf::RepeatedPtrField;
20 
21 namespace chromeos_update_engine {
22 
23 namespace {
24 const brillo::Blob::size_type kOutputBufferLength = 16 * 1024;
25 
26 // xz uses a variable dictionary size which impacts on the compression ratio
27 // and is required to be reconstructed in RAM during decompression. While we
28 // control the required memory from the compressor side, the decompressor allows
29 // to set a limit on this dictionary size, rejecting compressed streams that
30 // require more than that. "xz -9" requires up to 64 MiB, so a 64 MiB limit
31 // will allow compressed streams up to -9, the maximum compression setting.
32 const uint32_t kXzMaxDictSize = 64 * 1024 * 1024;
33 
34 const char* XzErrorString(enum xz_ret error) {
35 #define __XZ_ERROR_STRING_CASE(code) \
36   case code:                         \
37     return #code;
38   switch (error) {
39     __XZ_ERROR_STRING_CASE(XZ_OK)
40     __XZ_ERROR_STRING_CASE(XZ_STREAM_END)
41     __XZ_ERROR_STRING_CASE(XZ_UNSUPPORTED_CHECK)
42     __XZ_ERROR_STRING_CASE(XZ_MEM_ERROR)
43     __XZ_ERROR_STRING_CASE(XZ_MEMLIMIT_ERROR)
44     __XZ_ERROR_STRING_CASE(XZ_FORMAT_ERROR)
45     __XZ_ERROR_STRING_CASE(XZ_OPTIONS_ERROR)
46     __XZ_ERROR_STRING_CASE(XZ_DATA_ERROR)
47     __XZ_ERROR_STRING_CASE(XZ_BUF_ERROR)
48     default:
49       return "<unknown xz error>";
50   }
51 #undef __XZ_ERROR_STRING_CASE
52 }
53 }  // namespace
54 
55 XzExtentWriter::~XzExtentWriter() {
56   xz_dec_end(stream_);
57   TEST_AND_RETURN(input_buffer_.empty());
58 }
59 
60 bool XzExtentWriter::Init(FileDescriptorPtr fd,
61                           const RepeatedPtrField<Extent>& extents,
62                           uint32_t block_size) {
63   stream_ = xz_dec_init(XZ_DYNALLOC, kXzMaxDictSize);
64   TEST_AND_RETURN_FALSE(stream_ != nullptr);
65   return underlying_writer_->Init(fd, extents, block_size);
66 }
67 
68 bool XzExtentWriter::Write(const void* bytes, size_t count) {
69   // Copy the input data into |input_buffer_| only if |input_buffer_| already
70   // contains unconsumed data. Otherwise, process the data directly from the
71   // source.
72   const uint8_t* input = reinterpret_cast<const uint8_t*>(bytes);
73   if (!input_buffer_.empty()) {
74     input_buffer_.insert(input_buffer_.end(), input, input + count);
75     input = input_buffer_.data();
76     count = input_buffer_.size();
77   }
78 
79   xz_buf request;
80   request.in = input;
81   request.in_pos = 0;
82   request.in_size = count;
83 
84   brillo::Blob output_buffer(kOutputBufferLength);
85   request.out = output_buffer.data();
86   request.out_size = output_buffer.size();
87   for (;;) {
88     request.out_pos = 0;
89 
90     xz_ret ret = xz_dec_run(stream_, &request);
91     if (ret != XZ_OK && ret != XZ_STREAM_END) {
92       LOG(ERROR) << "xz_dec_run returned " << XzErrorString(ret);
93       return false;
94     }
95 
96     if (request.out_pos == 0)
97       break;
98 
99     TEST_AND_RETURN_FALSE(
100         underlying_writer_->Write(output_buffer.data(), request.out_pos));
101     if (ret == XZ_STREAM_END)
102       CHECK_EQ(request.in_size, request.in_pos);
103     if (request.in_size == request.in_pos)
104       break;  // No more input to process.
105   }
106   output_buffer.clear();
107 
108   // Store unconsumed data (if any) in |input_buffer_|. Since |input| can point
109   // to the existing |input_buffer_| we create a new one before assigning it.
110   brillo::Blob new_input_buffer(request.in + request.in_pos,
111                                 request.in + request.in_size);
112   input_buffer_ = std::move(new_input_buffer);
113   return true;
114 }
115 
116 }  // namespace chromeos_update_engine
117