1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
//
// Copyright (C) 2021 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "update_engine/payload_consumer/cow_writer_file_descriptor.h"
#include <cstring>
#include <memory>
#include <utility>
#include <vector>
#include <android-base/unique_fd.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <libsnapshot/snapshot_writer.h>
#include "update_engine/common/utils.h"
namespace chromeos_update_engine {
constexpr size_t BLOCK_SIZE = 4096;
constexpr size_t PARTITION_SIZE = BLOCK_SIZE * 10;
using android::base::unique_fd;
using android::snapshot::CompressedSnapshotWriter;
using android::snapshot::CowOptions;
using android::snapshot::ISnapshotWriter;
class CowWriterFileDescriptorUnittest : public ::testing::Test {
public:
void SetUp() override {
ASSERT_EQ(ftruncate64(cow_device_file_.fd(), PARTITION_SIZE), 0)
<< "Failed to truncate cow_device file to " << PARTITION_SIZE
<< strerror(errno);
ASSERT_EQ(ftruncate64(cow_source_file_.fd(), PARTITION_SIZE), 0)
<< "Failed to truncate cow_source file to " << PARTITION_SIZE
<< strerror(errno);
}
std::unique_ptr<CompressedSnapshotWriter> GetCowWriter() {
const CowOptions options{.block_size = BLOCK_SIZE, .compression = "gz"};
auto snapshot_writer = std::make_unique<CompressedSnapshotWriter>(options);
int fd = open(cow_device_file_.path().c_str(), O_RDWR);
EXPECT_NE(fd, -1);
EXPECT_TRUE(snapshot_writer->SetCowDevice(unique_fd{fd}));
snapshot_writer->SetSourceDevice(cow_source_file_.path());
return snapshot_writer;
}
CowWriterFileDescriptor GetCowFd() {
auto cow_writer = GetCowWriter();
return CowWriterFileDescriptor{std::move(cow_writer)};
}
ScopedTempFile cow_source_file_{"cow_source.XXXXXX", true};
ScopedTempFile cow_device_file_{"cow_device.XXXXXX", true};
};
TEST_F(CowWriterFileDescriptorUnittest, ReadAfterWrite) {
std::vector<unsigned char> buffer;
buffer.resize(BLOCK_SIZE);
std::fill(buffer.begin(), buffer.end(), 234);
std::vector<unsigned char> verity_data;
verity_data.resize(BLOCK_SIZE);
std::fill(verity_data.begin(), verity_data.end(), 0xAA);
auto cow_writer = GetCowWriter();
cow_writer->Initialize();
// Simulate Writing InstallOp data
ASSERT_TRUE(cow_writer->AddRawBlocks(0, buffer.data(), buffer.size()));
ASSERT_TRUE(cow_writer->AddZeroBlocks(1, 2));
ASSERT_TRUE(cow_writer->AddCopy(3, 1));
// Fake label to simulate "end of install"
ASSERT_TRUE(cow_writer->AddLabel(23));
ASSERT_TRUE(
cow_writer->AddRawBlocks(4, verity_data.data(), verity_data.size()));
ASSERT_TRUE(cow_writer->Finalize());
cow_writer = GetCowWriter();
ASSERT_NE(nullptr, cow_writer);
ASSERT_TRUE(cow_writer->InitializeAppend(23));
auto cow_fd =
std::make_unique<CowWriterFileDescriptor>(std::move(cow_writer));
ASSERT_EQ((ssize_t)BLOCK_SIZE * 4, cow_fd->Seek(BLOCK_SIZE * 4, SEEK_SET));
std::vector<unsigned char> read_back(4096);
ASSERT_EQ((ssize_t)read_back.size(),
cow_fd->Read(read_back.data(), read_back.size()));
ASSERT_EQ(verity_data, read_back);
// Since we didn't write anything to this instance of cow_fd, destructor
// should not call Finalize(). As finalize will drop ops after resume label,
// causing subsequent reads to fail.
cow_writer = GetCowWriter();
ASSERT_NE(nullptr, cow_writer);
ASSERT_TRUE(cow_writer->InitializeAppend(23));
cow_fd = std::make_unique<CowWriterFileDescriptor>(std::move(cow_writer));
ASSERT_EQ((ssize_t)BLOCK_SIZE * 4, cow_fd->Seek(BLOCK_SIZE * 4, SEEK_SET));
ASSERT_EQ((ssize_t)read_back.size(),
cow_fd->Read(read_back.data(), read_back.size()));
ASSERT_EQ(verity_data, read_back)
<< "Could not read verity data afeter InitializeAppend() => Read() => "
"InitializeAppend() sequence. If no writes happened while CowWriterFd "
"is open, Finalize() should not be called.";
}
} // namespace chromeos_update_engine
|
