1 /* 2 * Copyright (C) 2012 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 <assert.h> 18 #include <stdlib.h> 19 20 #include <sparse/sparse.h> 21 22 #include "defs.h" 23 #include "sparse_file.h" 24 25 #include "output_file.h" 26 #include "backed_block.h" 27 #include "sparse_defs.h" 28 #include "sparse_format.h" 29 30 struct sparse_file *sparse_file_new(unsigned int block_size, int64_t len) 31 { 32 struct sparse_file *s = calloc(sizeof(struct sparse_file), 1); 33 if (!s) { 34 return NULL; 35 } 36 37 s->backed_block_list = backed_block_list_new(block_size); 38 if (!s->backed_block_list) { 39 free(s); 40 return NULL; 41 } 42 43 s->block_size = block_size; 44 s->len = len; 45 46 return s; 47 } 48 49 void sparse_file_destroy(struct sparse_file *s) 50 { 51 backed_block_list_destroy(s->backed_block_list); 52 free(s); 53 } 54 55 int sparse_file_add_data(struct sparse_file *s, 56 void *data, unsigned int len, unsigned int block) 57 { 58 return backed_block_add_data(s->backed_block_list, data, len, block); 59 } 60 61 int sparse_file_add_fill(struct sparse_file *s, 62 uint32_t fill_val, unsigned int len, unsigned int block) 63 { 64 return backed_block_add_fill(s->backed_block_list, fill_val, len, block); 65 } 66 67 int sparse_file_add_file(struct sparse_file *s, 68 const char *filename, int64_t file_offset, unsigned int len, 69 unsigned int block) 70 { 71 return backed_block_add_file(s->backed_block_list, filename, file_offset, 72 len, block); 73 } 74 75 int sparse_file_add_fd(struct sparse_file *s, 76 int fd, int64_t file_offset, unsigned int len, unsigned int block) 77 { 78 return backed_block_add_fd(s->backed_block_list, fd, file_offset, 79 len, block); 80 } 81 unsigned int sparse_count_chunks(struct sparse_file *s) 82 { 83 struct backed_block *bb; 84 unsigned int last_block = 0; 85 unsigned int chunks = 0; 86 87 for (bb = backed_block_iter_new(s->backed_block_list); bb; 88 bb = backed_block_iter_next(bb)) { 89 if (backed_block_block(bb) > last_block) { 90 /* If there is a gap between chunks, add a skip chunk */ 91 chunks++; 92 } 93 chunks++; 94 last_block = backed_block_block(bb) + 95 DIV_ROUND_UP(backed_block_len(bb), s->block_size); 96 } 97 if (last_block < DIV_ROUND_UP(s->len, s->block_size)) { 98 chunks++; 99 } 100 101 return chunks; 102 } 103 104 static int sparse_file_write_block(struct output_file *out, 105 struct backed_block *bb) 106 { 107 int ret = -EINVAL; 108 109 switch (backed_block_type(bb)) { 110 case BACKED_BLOCK_DATA: 111 ret = write_data_chunk(out, backed_block_len(bb), backed_block_data(bb)); 112 break; 113 case BACKED_BLOCK_FILE: 114 ret = write_file_chunk(out, backed_block_len(bb), 115 backed_block_filename(bb), 116 backed_block_file_offset(bb)); 117 break; 118 case BACKED_BLOCK_FD: 119 ret = write_fd_chunk(out, backed_block_len(bb), 120 backed_block_fd(bb), 121 backed_block_file_offset(bb)); 122 break; 123 case BACKED_BLOCK_FILL: 124 ret = write_fill_chunk(out, backed_block_len(bb), 125 backed_block_fill_val(bb)); 126 break; 127 } 128 129 return ret; 130 } 131 132 static int write_all_blocks(struct sparse_file *s, struct output_file *out) 133 { 134 struct backed_block *bb; 135 unsigned int last_block = 0; 136 int64_t pad; 137 int ret = 0; 138 139 for (bb = backed_block_iter_new(s->backed_block_list); bb; 140 bb = backed_block_iter_next(bb)) { 141 if (backed_block_block(bb) > last_block) { 142 unsigned int blocks = backed_block_block(bb) - last_block; 143 write_skip_chunk(out, (int64_t)blocks * s->block_size); 144 } 145 ret = sparse_file_write_block(out, bb); 146 if (ret) 147 return ret; 148 last_block = backed_block_block(bb) + 149 DIV_ROUND_UP(backed_block_len(bb), s->block_size); 150 } 151 152 pad = s->len - (int64_t)last_block * s->block_size; 153 assert(pad >= 0); 154 if (pad > 0) { 155 write_skip_chunk(out, pad); 156 } 157 158 return 0; 159 } 160 161 int sparse_file_write(struct sparse_file *s, int fd, bool gz, bool sparse, 162 bool crc) 163 { 164 int ret; 165 int chunks; 166 struct output_file *out; 167 168 chunks = sparse_count_chunks(s); 169 out = output_file_open_fd(fd, s->block_size, s->len, gz, sparse, chunks, crc); 170 171 if (!out) 172 return -ENOMEM; 173 174 ret = write_all_blocks(s, out); 175 176 output_file_close(out); 177 178 return ret; 179 } 180 181 int sparse_file_callback(struct sparse_file *s, bool sparse, bool crc, 182 int (*write)(void *priv, const void *data, int len), void *priv) 183 { 184 int ret; 185 int chunks; 186 struct output_file *out; 187 188 chunks = sparse_count_chunks(s); 189 out = output_file_open_callback(write, priv, s->block_size, s->len, false, 190 sparse, chunks, crc); 191 192 if (!out) 193 return -ENOMEM; 194 195 ret = write_all_blocks(s, out); 196 197 output_file_close(out); 198 199 return ret; 200 } 201 202 static int out_counter_write(void *priv, const void *data __unused, int len) 203 { 204 int64_t *count = priv; 205 *count += len; 206 return 0; 207 } 208 209 int64_t sparse_file_len(struct sparse_file *s, bool sparse, bool crc) 210 { 211 int ret; 212 int chunks = sparse_count_chunks(s); 213 int64_t count = 0; 214 struct output_file *out; 215 216 out = output_file_open_callback(out_counter_write, &count, 217 s->block_size, s->len, false, sparse, chunks, crc); 218 if (!out) { 219 return -1; 220 } 221 222 ret = write_all_blocks(s, out); 223 224 output_file_close(out); 225 226 if (ret < 0) { 227 return -1; 228 } 229 230 return count; 231 } 232 233 static struct backed_block *move_chunks_up_to_len(struct sparse_file *from, 234 struct sparse_file *to, unsigned int len) 235 { 236 int64_t count = 0; 237 struct output_file *out_counter; 238 struct backed_block *last_bb = NULL; 239 struct backed_block *bb; 240 struct backed_block *start; 241 int64_t file_len = 0; 242 int ret; 243 244 /* 245 * overhead is sparse file header, initial skip chunk, split chunk, end 246 * skip chunk, and crc chunk. 247 */ 248 int overhead = sizeof(sparse_header_t) + 4 * sizeof(chunk_header_t) + 249 sizeof(uint32_t); 250 len -= overhead; 251 252 start = backed_block_iter_new(from->backed_block_list); 253 out_counter = output_file_open_callback(out_counter_write, &count, 254 to->block_size, to->len, false, true, 0, false); 255 if (!out_counter) { 256 return NULL; 257 } 258 259 for (bb = start; bb; bb = backed_block_iter_next(bb)) { 260 count = 0; 261 /* will call out_counter_write to update count */ 262 ret = sparse_file_write_block(out_counter, bb); 263 if (ret) { 264 bb = NULL; 265 goto out; 266 } 267 if (file_len + count > len) { 268 /* 269 * If the remaining available size is more than 1/8th of the 270 * requested size, split the chunk. Results in sparse files that 271 * are at least 7/8ths of the requested size 272 */ 273 if (!last_bb || (len - file_len > (len / 8))) { 274 backed_block_split(from->backed_block_list, bb, len - file_len); 275 last_bb = bb; 276 } 277 goto move; 278 } 279 file_len += count; 280 last_bb = bb; 281 } 282 283 move: 284 backed_block_list_move(from->backed_block_list, 285 to->backed_block_list, start, last_bb); 286 287 out: 288 output_file_close(out_counter); 289 290 return bb; 291 } 292 293 int sparse_file_resparse(struct sparse_file *in_s, unsigned int max_len, 294 struct sparse_file **out_s, int out_s_count) 295 { 296 struct backed_block *bb; 297 struct sparse_file *s; 298 struct sparse_file *tmp; 299 int c = 0; 300 301 tmp = sparse_file_new(in_s->block_size, in_s->len); 302 if (!tmp) { 303 return -ENOMEM; 304 } 305 306 do { 307 s = sparse_file_new(in_s->block_size, in_s->len); 308 309 bb = move_chunks_up_to_len(in_s, s, max_len); 310 311 if (c < out_s_count) { 312 out_s[c] = s; 313 } else { 314 backed_block_list_move(s->backed_block_list, tmp->backed_block_list, 315 NULL, NULL); 316 sparse_file_destroy(s); 317 } 318 c++; 319 } while (bb); 320 321 backed_block_list_move(tmp->backed_block_list, in_s->backed_block_list, 322 NULL, NULL); 323 324 sparse_file_destroy(tmp); 325 326 return c; 327 } 328 329 void sparse_file_verbose(struct sparse_file *s) 330 { 331 s->verbose = true; 332 } 333
This page was automatically generated by LXR 0.3.1. • OpenWrt