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 #ifndef UPDATE_ENGINE_PAYLOAD_GENERATOR_DELTA_DIFF_UTILS_H_
18 #define UPDATE_ENGINE_PAYLOAD_GENERATOR_DELTA_DIFF_UTILS_H_
19 
20 #include <string>
21 #include <vector>
22 
23 #include <brillo/secure_blob.h>
24 
25 #include "update_engine/payload_generator/annotated_operation.h"
26 #include "update_engine/payload_generator/extent_ranges.h"
27 #include "update_engine/payload_generator/payload_generation_config.h"
28 #include "update_engine/update_metadata.pb.h"
29 
30 namespace chromeos_update_engine {
31 
32 namespace diff_utils {
33 
34 // Create operations in |aops| to produce all the blocks in the |new_part|
35 // partition using the filesystem opened in that PartitionConfig.
36 // It uses the files reported by the filesystem in |old_part| and the data
37 // blocks in that partition (if available) to determine the best way to compress
38 // the new files (REPLACE, REPLACE_BZ, COPY, BSDIFF) and writes any necessary
39 // data to |blob_file|. |hard_chunk_blocks| and |soft_chunk_blocks| are the hard
40 // and soft chunk limits in number of blocks respectively. The soft chunk limit
41 // is used to split MOVE and SOURCE_COPY operations and REPLACE_BZ of zeroed
42 // blocks, while the hard limit is used to split a file when generating other
43 // operations. A value of -1 in |hard_chunk_blocks| means whole files.
44 bool DeltaReadPartition(std::vector<AnnotatedOperation>* aops,
45                         const PartitionConfig& old_part,
46                         const PartitionConfig& new_part,
47                         ssize_t hard_chunk_blocks,
48                         size_t soft_chunk_blocks,
49                         const PayloadVersion& version,
50                         BlobFileWriter* blob_file);
51 
52 // Create operations in |aops| for identical blocks that moved around in the old
53 // and new partition and also handle zeroed blocks. The old and new partition
54 // are stored in the |old_part| and |new_part| files and have |old_num_blocks|
55 // and |new_num_blocks| respectively. The maximum operation size is
56 // |chunk_blocks| blocks, or unlimited if |chunk_blocks| is -1. The blobs of the
57 // produced operations are stored in the |blob_file|.
58 // The collections |old_visited_blocks| and |new_visited_blocks| state what
59 // blocks already have operations reading or writing them and only operations
60 // for unvisited blocks are produced by this function updating both collections
61 // with the used blocks.
62 bool DeltaMovedAndZeroBlocks(std::vector<AnnotatedOperation>* aops,
63                              const std::string& old_part,
64                              const std::string& new_part,
65                              size_t old_num_blocks,
66                              size_t new_num_blocks,
67                              ssize_t chunk_blocks,
68                              const PayloadVersion& version,
69                              BlobFileWriter* blob_file,
70                              ExtentRanges* old_visited_blocks,
71                              ExtentRanges* new_visited_blocks);
72 
73 // For a given file |name| append operations to |aops| to produce it in the
74 // |new_part|. The file will be split in chunks of |chunk_blocks| blocks each
75 // or treated as a single chunk if |chunk_blocks| is -1. The file data is
76 // stored in |new_part| in the blocks described by |new_extents| and, if it
77 // exists, the old version exists in |old_part| in the blocks described by
78 // |old_extents|. The operations added to |aops| reference the data blob
79 // in the |blob_file|. Returns true on success.
80 bool DeltaReadFile(std::vector<AnnotatedOperation>* aops,
81                    const std::string& old_part,
82                    const std::string& new_part,
83                    const std::vector<Extent>& old_extents,
84                    const std::vector<Extent>& new_extents,
85                    const std::string& name,
86                    ssize_t chunk_blocks,
87                    const PayloadVersion& version,
88                    BlobFileWriter* blob_file);
89 
90 // Reads the blocks |old_extents| from |old_part| (if it exists) and the
91 // |new_extents| from |new_part| and determines the smallest way to encode
92 // this |new_extents| for the diff. It stores necessary data in |out_data| and
93 // fills in |out_op|. If there's no change in old and new files, it creates a
94 // MOVE or SOURCE_COPY operation. If there is a change, the smallest of the
95 // operations allowed in the given |version| (REPLACE, REPLACE_BZ, BSDIFF,
96 // SOURCE_BSDIFF or IMGDIFF) wins.
97 // |new_extents| must not be empty. Returns true on success.
98 bool ReadExtentsToDiff(const std::string& old_part,
99                        const std::string& new_part,
100                        const std::vector<Extent>& old_extents,
101                        const std::vector<Extent>& new_extents,
102                        const PayloadVersion& version,
103                        brillo::Blob* out_data,
104                        InstallOperation* out_op);
105 
106 // Runs the bsdiff or imgdiff tool in |diff_path| on two files and returns the
107 // resulting delta in |out|. Returns true on success.
108 bool DiffFiles(const std::string& diff_path,
109                const std::string& old_file,
110                const std::string& new_file,
111                brillo::Blob* out);
112 
113 // Generates the best allowed full operation to produce |new_data|. The allowed
114 // operations are based on |payload_version|. The operation blob will be stored
115 // in |out_blob| and the resulting operation type in |out_type|. Returns whether
116 // a valid full operation was generated.
117 bool GenerateBestFullOperation(const brillo::Blob& new_data,
118                                const PayloadVersion& version,
119                                brillo::Blob* out_blob,
120                                InstallOperation_Type* out_type);
121 
122 // Returns whether op_type is one of the REPLACE full operations.
123 bool IsAReplaceOperation(InstallOperation_Type op_type);
124 
125 // Returns true if |op| is a no-op operation that doesn't do any useful work
126 // (e.g., a move operation that copies blocks onto themselves).
127 bool IsNoopOperation(const InstallOperation& op);
128 
129 // Filters all the operations that are no-op, maintaining the relative order
130 // of the rest of the operations.
131 void FilterNoopOperations(std::vector<AnnotatedOperation>* ops);
132 
133 bool InitializePartitionInfo(const PartitionConfig& partition,
134                              PartitionInfo* info);
135 
136 // Compare two AnnotatedOperations by the start block of the first Extent in
137 // their destination extents.
138 bool CompareAopsByDestination(AnnotatedOperation first_aop,
139                               AnnotatedOperation second_aop);
140 
141 // Returns whether the filesystem is an ext[234] filesystem. In case of failure,
142 // such as if the file |device| doesn't exists or can't be read, it returns
143 // false.
144 bool IsExtFilesystem(const std::string& device);
145 
146 }  // namespace diff_utils
147 
148 }  // namespace chromeos_update_engine
149 
150 #endif  // UPDATE_ENGINE_PAYLOAD_GENERATOR_DELTA_DIFF_UTILS_H_
151