blob: 12de8a9a24e1784d2e2e6e5ad20dad154165116c [file] [log] [blame]
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001// Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <sys/mount.h>
6#include <inttypes.h>
7
8#include <algorithm>
9#include <string>
10#include <vector>
11
Darin Petkov73058b42010-10-06 16:32:19 -070012#include <base/scoped_ptr.h>
13#include <base/string_util.h>
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070014#include <google/protobuf/repeated_field.h>
15#include <gtest/gtest.h>
16
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070017#include "update_engine/delta_diff_generator.h"
18#include "update_engine/delta_performer.h"
19#include "update_engine/graph_types.h"
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -070020#include "update_engine/payload_signer.h"
Darin Petkov73058b42010-10-06 16:32:19 -070021#include "update_engine/prefs_mock.h"
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070022#include "update_engine/test_utils.h"
23#include "update_engine/update_metadata.pb.h"
24#include "update_engine/utils.h"
25
26namespace chromeos_update_engine {
27
28using std::min;
29using std::string;
30using std::vector;
Darin Petkov73058b42010-10-06 16:32:19 -070031using testing::_;
32using testing::Return;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070033
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -070034extern const char* kUnittestPrivateKeyPath;
Darin Petkovd7061ab2010-10-06 14:37:09 -070035extern const char* kUnittestPublicKeyPath;
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -070036
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070037class DeltaPerformerTest : public ::testing::Test { };
38
39TEST(DeltaPerformerTest, ExtentsToByteStringTest) {
40 uint64_t test[] = {1, 1, 4, 2, kSparseHole, 1, 0, 1};
41 COMPILE_ASSERT(arraysize(test) % 2 == 0, array_size_uneven);
42 const uint64_t block_size = 4096;
43 const uint64_t file_length = 5 * block_size - 13;
44
45 google::protobuf::RepeatedPtrField<Extent> extents;
46 for (size_t i = 0; i < arraysize(test); i += 2) {
47 Extent* extent = extents.Add();
48 extent->set_start_block(test[i]);
49 extent->set_num_blocks(test[i + 1]);
50 }
51
52 string expected_output = "4096:4096,16384:8192,-1:4096,0:4083";
53 string actual_output;
54 EXPECT_TRUE(DeltaPerformer::ExtentsToBsdiffPositionsString(extents,
55 block_size,
56 file_length,
57 &actual_output));
58 EXPECT_EQ(expected_output, actual_output);
59}
60
61class ScopedLoopMounter {
62 public:
63 explicit ScopedLoopMounter(const string& file_path, string* mnt_path,
64 unsigned long flags) {
65 EXPECT_TRUE(utils::MakeTempDirectory("/tmp/mnt.XXXXXX", mnt_path));
66 dir_remover_.reset(new ScopedDirRemover(*mnt_path));
67
68 string loop_dev = GetUnusedLoopDevice();
69 EXPECT_EQ(0, system(StringPrintf("losetup %s %s", loop_dev.c_str(),
70 file_path.c_str()).c_str()));
71 loop_releaser_.reset(new ScopedLoopbackDeviceReleaser(loop_dev));
72
73 EXPECT_TRUE(utils::MountFilesystem(loop_dev, *mnt_path, flags));
74 unmounter_.reset(new ScopedFilesystemUnmounter(*mnt_path));
75 }
76 private:
77 scoped_ptr<ScopedDirRemover> dir_remover_;
78 scoped_ptr<ScopedLoopbackDeviceReleaser> loop_releaser_;
79 scoped_ptr<ScopedFilesystemUnmounter> unmounter_;
80};
81
82void CompareFilesByBlock(const string& a_file, const string& b_file) {
83 vector<char> a_data, b_data;
Andrew de los Reyes3270f742010-07-15 22:28:14 -070084 EXPECT_TRUE(utils::ReadFile(a_file, &a_data)) << "file failed: " << a_file;
85 EXPECT_TRUE(utils::ReadFile(b_file, &b_data)) << "file failed: " << b_file;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070086
87 EXPECT_EQ(a_data.size(), b_data.size());
88 size_t kBlockSize = 4096;
89 EXPECT_EQ(0, a_data.size() % kBlockSize);
90 for (size_t i = 0; i < a_data.size(); i += kBlockSize) {
91 EXPECT_EQ(0, i % kBlockSize);
92 vector<char> a_sub(&a_data[i], &a_data[i + kBlockSize]);
93 vector<char> b_sub(&b_data[i], &b_data[i + kBlockSize]);
94 EXPECT_TRUE(a_sub == b_sub) << "Block " << (i/kBlockSize) << " differs";
95 }
96}
97
98namespace {
99bool WriteSparseFile(const string& path, off_t size) {
100 int fd = open(path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0644);
101 TEST_AND_RETURN_FALSE_ERRNO(fd >= 0);
102 ScopedFdCloser fd_closer(&fd);
103 off_t rc = lseek(fd, size + 1, SEEK_SET);
104 TEST_AND_RETURN_FALSE_ERRNO(rc != static_cast<off_t>(-1));
105 int return_code = ftruncate(fd, size);
106 TEST_AND_RETURN_FALSE_ERRNO(return_code == 0);
107 return true;
108}
109}
110
111TEST(DeltaPerformerTest, RunAsRootSmallImageTest) {
112 string a_img, b_img;
113 EXPECT_TRUE(utils::MakeTempFile("/tmp/a_img.XXXXXX", &a_img, NULL));
114 ScopedPathUnlinker a_img_unlinker(a_img);
115 EXPECT_TRUE(utils::MakeTempFile("/tmp/b_img.XXXXXX", &b_img, NULL));
116 ScopedPathUnlinker b_img_unlinker(b_img);
117
118 CreateExtImageAtPath(a_img, NULL);
119 CreateExtImageAtPath(b_img, NULL);
120
121 // Make some changes to the A image.
122 {
123 string a_mnt;
124 ScopedLoopMounter b_mounter(a_img, &a_mnt, 0);
125
126 EXPECT_TRUE(utils::WriteFile(StringPrintf("%s/hardtocompress",
127 a_mnt.c_str()).c_str(),
128 reinterpret_cast<const char*>(kRandomString),
129 sizeof(kRandomString) - 1));
130 // Write 1 MiB of 0xff to try to catch the case where writing a bsdiff
131 // patch fails to zero out the final block.
132 vector<char> ones(1024 * 1024, 0xff);
133 EXPECT_TRUE(utils::WriteFile(StringPrintf("%s/ones",
134 a_mnt.c_str()).c_str(),
135 &ones[0],
136 ones.size()));
137 }
138
139 // Make some changes to the B image.
140 {
141 string b_mnt;
142 ScopedLoopMounter b_mounter(b_img, &b_mnt, 0);
143
144 EXPECT_EQ(0, system(StringPrintf("cp %s/hello %s/hello2", b_mnt.c_str(),
145 b_mnt.c_str()).c_str()));
146 EXPECT_EQ(0, system(StringPrintf("rm %s/hello", b_mnt.c_str()).c_str()));
147 EXPECT_EQ(0, system(StringPrintf("mv %s/hello2 %s/hello", b_mnt.c_str(),
148 b_mnt.c_str()).c_str()));
149 EXPECT_EQ(0, system(StringPrintf("echo foo > %s/foo",
150 b_mnt.c_str()).c_str()));
151 EXPECT_EQ(0, system(StringPrintf("touch %s/emptyfile",
152 b_mnt.c_str()).c_str()));
153 EXPECT_TRUE(WriteSparseFile(StringPrintf("%s/fullsparse", b_mnt.c_str()),
154 1024 * 1024));
155 EXPECT_EQ(0, system(StringPrintf("dd if=/dev/zero of=%s/partsparese bs=1 "
156 "seek=4096 count=1",
157 b_mnt.c_str()).c_str()));
158 EXPECT_TRUE(utils::WriteFile(StringPrintf("%s/hardtocompress",
159 b_mnt.c_str()).c_str(),
160 reinterpret_cast<const char*>(kRandomString),
161 sizeof(kRandomString)));
162 }
163
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -0700164 string old_kernel;
165 EXPECT_TRUE(utils::MakeTempFile("/tmp/old_kernel.XXXXXX", &old_kernel, NULL));
166 ScopedPathUnlinker old_kernel_unlinker(old_kernel);
167
168 string new_kernel;
169 EXPECT_TRUE(utils::MakeTempFile("/tmp/new_kernel.XXXXXX", &new_kernel, NULL));
170 ScopedPathUnlinker new_kernel_unlinker(new_kernel);
171
172 vector<char> old_kernel_data(4096); // Something small for a test
173 vector<char> new_kernel_data(old_kernel_data.size());
174 FillWithData(&old_kernel_data);
175 FillWithData(&new_kernel_data);
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -0700176
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -0700177 // change the new kernel data
178 const char* new_data_string = "This is new data.";
179 strcpy(&new_kernel_data[0], new_data_string);
180
181 // Write kernels to disk
182 EXPECT_TRUE(utils::WriteFile(
183 old_kernel.c_str(), &old_kernel_data[0], old_kernel_data.size()));
184 EXPECT_TRUE(utils::WriteFile(
185 new_kernel.c_str(), &new_kernel_data[0], new_kernel_data.size()));
186
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700187 string delta_path;
188 EXPECT_TRUE(utils::MakeTempFile("/tmp/delta.XXXXXX", &delta_path, NULL));
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -0700189 LOG(INFO) << "delta path: " << delta_path;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700190 ScopedPathUnlinker delta_path_unlinker(delta_path);
191 {
192 string a_mnt, b_mnt;
193 ScopedLoopMounter a_mounter(a_img, &a_mnt, MS_RDONLY);
194 ScopedLoopMounter b_mounter(b_img, &b_mnt, MS_RDONLY);
195
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -0700196 EXPECT_TRUE(
197 DeltaDiffGenerator::GenerateDeltaUpdateFile(a_mnt,
198 a_img,
199 b_mnt,
200 b_img,
201 old_kernel,
202 new_kernel,
203 delta_path,
204 kUnittestPrivateKeyPath));
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700205 }
206
207 // Read delta into memory.
208 vector<char> delta;
209 EXPECT_TRUE(utils::ReadFile(delta_path, &delta));
210
Darin Petkov73058b42010-10-06 16:32:19 -0700211 uint64_t manifest_metadata_size;
212
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -0700213 // Check that the null signature blob exists
214 {
215 LOG(INFO) << "delta size: " << delta.size();
216 DeltaArchiveManifest manifest;
217 const int kManifestSizeOffset = 12;
218 const int kManifestOffset = 20;
219 uint64_t manifest_size = 0;
220 memcpy(&manifest_size, &delta[kManifestSizeOffset], sizeof(manifest_size));
221 manifest_size = be64toh(manifest_size);
222 LOG(INFO) << "manifest size: " << manifest_size;
223 EXPECT_TRUE(manifest.ParseFromArray(&delta[kManifestOffset],
224 manifest_size));
225 EXPECT_TRUE(manifest.has_signatures_offset());
Darin Petkov73058b42010-10-06 16:32:19 -0700226 manifest_metadata_size = kManifestOffset + manifest_size;
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -0700227
228 Signatures sigs_message;
229 EXPECT_TRUE(sigs_message.ParseFromArray(
Darin Petkov73058b42010-10-06 16:32:19 -0700230 &delta[manifest_metadata_size + manifest.signatures_offset()],
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -0700231 manifest.signatures_size()));
232 EXPECT_EQ(1, sigs_message.signatures_size());
233 const Signatures_Signature& signature = sigs_message.signatures(0);
234 EXPECT_EQ(1, signature.version());
235
236 uint64_t expected_sig_data_length = 0;
237 EXPECT_TRUE(PayloadSigner::SignatureBlobLength(kUnittestPrivateKeyPath,
238 &expected_sig_data_length));
239 EXPECT_EQ(expected_sig_data_length, manifest.signatures_size());
240 EXPECT_FALSE(signature.data().empty());
241 }
242
Darin Petkov73058b42010-10-06 16:32:19 -0700243 PrefsMock prefs;
244 EXPECT_CALL(prefs, SetInt64(kPrefsManifestMetadataSize,
245 manifest_metadata_size)).WillOnce(Return(true));
246 EXPECT_CALL(prefs, SetInt64(kPrefsUpdateStateNextOperation, _))
247 .WillRepeatedly(Return(true));
248 EXPECT_CALL(prefs, SetInt64(kPrefsUpdateStateNextDataOffset, _))
249 .WillRepeatedly(Return(true));
250 EXPECT_CALL(prefs, SetString(kPrefsUpdateStateSignedSHA256Context, _))
251 .WillRepeatedly(Return(true));
252
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700253 // Update the A image in place.
Darin Petkov73058b42010-10-06 16:32:19 -0700254 DeltaPerformer performer(&prefs);
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700255
256 EXPECT_EQ(0, performer.Open(a_img.c_str(), 0, 0));
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -0700257 EXPECT_TRUE(performer.OpenKernel(old_kernel.c_str()));
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700258
259 // Write at some number of bytes per operation. Arbitrarily chose 5.
260 const size_t kBytesPerWrite = 5;
261 for (size_t i = 0; i < delta.size(); i += kBytesPerWrite) {
262 size_t count = min(delta.size() - i, kBytesPerWrite);
263 EXPECT_EQ(count, performer.Write(&delta[i], count));
264 }
265
266 // Wrapper around close. Returns 0 on success or -errno on error.
267 EXPECT_EQ(0, performer.Close());
268
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -0700269 CompareFilesByBlock(old_kernel, new_kernel);
Andrew de los Reyes932bc4c2010-08-23 18:14:09 -0700270
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -0700271 vector<char> updated_kernel_partition;
272 EXPECT_TRUE(utils::ReadFile(old_kernel, &updated_kernel_partition));
273 EXPECT_EQ(0, strncmp(&updated_kernel_partition[0], new_data_string,
274 strlen(new_data_string)));
Darin Petkovd7061ab2010-10-06 14:37:09 -0700275
276 EXPECT_TRUE(utils::FileExists(kUnittestPublicKeyPath));
277 EXPECT_TRUE(performer.VerifyPayload(kUnittestPublicKeyPath));
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700278}
279
280} // namespace chromeos_update_engine