1 #include "config.h" 2 #include <sys/types.h> 3 #include <sys/stat.h> 4 #include <fcntl.h> 5 #include <unistd.h> 6 #include <stdint.h> 7 #include "ext2_fs.h" 8 #include "ext2fs.h" 9 10 #ifndef O_BINARY 11 #define O_BINARY 0 12 #endif 13 14 #if !defined(ENABLE_LIBSPARSE) 15 static errcode_t sparse_open(const char *name EXT2FS_ATTR((unused)), 16 int flags EXT2FS_ATTR((unused)), 17 io_channel *channel EXT2FS_ATTR((unused))) 18 { 19 return EXT2_ET_UNIMPLEMENTED; 20 } 21 static errcode_t sparse_close(io_channel channel EXT2FS_ATTR((unused))) 22 { 23 return EXT2_ET_UNIMPLEMENTED; 24 } 25 static struct struct_io_manager struct_sparse_manager = { 26 .magic = EXT2_ET_MAGIC_IO_MANAGER, 27 .name = "Android sparse I/O Manager", 28 .open = sparse_open, 29 .close = sparse_close, 30 }; 31 static struct struct_io_manager struct_sparsefd_manager = { 32 .magic = EXT2_ET_MAGIC_IO_MANAGER, 33 .name = "Android sparse fd I/O Manager", 34 .open = sparse_open, 35 .close = sparse_close, 36 }; 37 #else 38 #include <sparse/sparse.h> 39 40 struct sparse_map { 41 int fd; 42 char **blocks; 43 int block_size; 44 uint64_t blocks_count; 45 char *file; 46 struct sparse_file *sparse_file; 47 io_channel channel; 48 }; 49 50 struct sparse_io_params { 51 int fd; 52 char *file; 53 uint64_t blocks_count; 54 unsigned int block_size; 55 }; 56 57 static errcode_t sparse_write_blk(io_channel channel, unsigned long block, 58 int count, const void *buf); 59 60 static void free_sparse_blocks(struct sparse_map *sm) 61 { 62 uint64_t i; 63 64 for (i = 0; i < sm->blocks_count; ++i) 65 free(sm->blocks[i]); 66 free(sm->blocks); 67 sm->blocks = NULL; 68 } 69 70 static int sparse_import_segment(void *priv, const void *data, int len, 71 unsigned int block, unsigned int nr_blocks) 72 { 73 struct sparse_map *sm = priv; 74 75 /* Ignore chunk headers, only write the data */ 76 if (!nr_blocks || len % sm->block_size) 77 return 0; 78 79 return sparse_write_blk(sm->channel, block, nr_blocks, data); 80 } 81 82 static errcode_t io_manager_import_sparse(struct sparse_io_params *params, 83 struct sparse_map *sm, io_channel io) 84 { 85 int fd; 86 errcode_t retval; 87 struct sparse_file *sparse_file; 88 89 if (params->fd < 0) { 90 fd = open(params->file, O_RDONLY); 91 if (fd < 0) { 92 retval = -1; 93 goto err_open; 94 } 95 } else 96 fd = params->fd; 97 sparse_file = sparse_file_import(fd, false, false); 98 if (!sparse_file) { 99 retval = -1; 100 goto err_sparse; 101 } 102 103 sm->block_size = sparse_file_block_size(sparse_file); 104 sm->blocks_count = (sparse_file_len(sparse_file, 0, 0) - 1) 105 / sm->block_size + 1; 106 sm->blocks = calloc(sm->blocks_count, sizeof(char*)); 107 if (!sm->blocks) { 108 retval = -1; 109 goto err_alloc; 110 } 111 io->block_size = sm->block_size; 112 113 retval = sparse_file_foreach_chunk(sparse_file, true, false, 114 sparse_import_segment, sm); 115 116 if (retval) 117 free_sparse_blocks(sm); 118 err_alloc: 119 sparse_file_destroy(sparse_file); 120 err_sparse: 121 close(fd); 122 err_open: 123 return retval; 124 } 125 126 static errcode_t io_manager_configure(struct sparse_io_params *params, 127 int flags, io_channel io) 128 { 129 errcode_t retval; 130 uint64_t img_size; 131 struct sparse_map *sm = calloc(1, sizeof(*sm)); 132 if (!sm) 133 return EXT2_ET_NO_MEMORY; 134 135 sm->file = params->file; 136 sm->channel = io; 137 io->private_data = sm; 138 retval = io_manager_import_sparse(params, sm, io); 139 if (retval) { 140 if (!params->block_size || !params->blocks_count) { 141 retval = -EINVAL; 142 goto err_params; 143 } 144 sm->block_size = params->block_size; 145 sm->blocks_count = params->blocks_count; 146 sm->blocks = calloc(params->blocks_count, sizeof(void*)); 147 if (!sm->blocks) { 148 retval = EXT2_ET_NO_MEMORY; 149 goto err_alloc; 150 } 151 } 152 io->block_size = sm->block_size; 153 img_size = (uint64_t)sm->block_size * sm->blocks_count; 154 155 if (flags & IO_FLAG_RW) { 156 sm->sparse_file = sparse_file_new(sm->block_size, img_size); 157 if (!sm->sparse_file) { 158 retval = EXT2_ET_NO_MEMORY; 159 goto err_alloc; 160 } 161 if (params->fd < 0) { 162 sm->fd = open(params->file, O_CREAT | O_RDWR | O_TRUNC | O_BINARY, 163 0644); 164 if (sm->fd < 0) { 165 retval = errno; 166 goto err_open; 167 } 168 } else 169 sm->fd = params->fd; 170 } else { 171 sm->fd = -1; 172 sm->sparse_file = NULL; 173 } 174 return 0; 175 176 err_open: 177 sparse_file_destroy(sm->sparse_file); 178 err_alloc: 179 free_sparse_blocks(sm); 180 err_params: 181 free(sm); 182 return retval; 183 } 184 185 static errcode_t sparse_open_channel(struct sparse_io_params *sparse_params, 186 int flags, io_channel *channel) 187 { 188 io_channel io; 189 190 io = calloc(1, sizeof(struct struct_io_channel)); 191 io->magic = EXT2_ET_MAGIC_IO_CHANNEL; 192 io->block_size = 0; 193 io->refcount = 1; 194 *channel = io; 195 return io_manager_configure(sparse_params, flags, io); 196 } 197 198 static errcode_t read_sparse_argv(const char *name, bool is_fd, 199 struct sparse_io_params *sparse_params) 200 { 201 int ret; 202 sparse_params->fd = -1; 203 sparse_params->block_size = 0; 204 sparse_params->blocks_count = 0; 205 206 sparse_params->file = malloc(strlen(name) + 1); 207 if (!sparse_params->file) { 208 fprintf(stderr, "failed to alloc %zu\n", strlen(name) + 1); 209 return EXT2_ET_NO_MEMORY; 210 } 211 212 if (is_fd) { 213 ret = sscanf(name, "(%d):%llu:%u", &sparse_params->fd, 214 (unsigned long long *)&sparse_params->blocks_count, 215 &sparse_params->block_size); 216 } else { 217 ret = sscanf(name, "(%[^)])%*[:]%llu%*[:]%u", sparse_params->file, 218 (unsigned long long *)&sparse_params->blocks_count, 219 &sparse_params->block_size); 220 } 221 222 if (ret < 1) { 223 free(sparse_params->file); 224 return -EINVAL; 225 } 226 return 0; 227 } 228 229 static errcode_t sparse_open(const char *name, int flags, io_channel *channel) 230 { 231 errcode_t retval; 232 struct sparse_io_params sparse_params; 233 234 retval = read_sparse_argv(name, false, &sparse_params); 235 if (retval) 236 return EXT2_ET_BAD_DEVICE_NAME; 237 238 retval = sparse_open_channel(&sparse_params, flags, channel); 239 if (retval) 240 return retval; 241 (*channel)->manager = sparse_io_manager; 242 243 return retval; 244 } 245 246 static errcode_t sparsefd_open(const char *name, int flags, io_channel *channel) 247 { 248 errcode_t retval; 249 struct sparse_io_params sparse_params; 250 251 retval = read_sparse_argv(name, true, &sparse_params); 252 if (retval) 253 return EXT2_ET_BAD_DEVICE_NAME; 254 255 retval = sparse_open_channel(&sparse_params, flags, channel); 256 if (retval) 257 return retval; 258 (*channel)->manager = sparsefd_io_manager; 259 260 return retval; 261 } 262 263 static errcode_t sparse_merge_blocks(struct sparse_map *sm, uint64_t start, 264 uint64_t num) 265 { 266 char *buf; 267 uint64_t i; 268 unsigned int block_size = sm->block_size; 269 errcode_t retval = 0; 270 271 buf = calloc(num, block_size); 272 if (!buf) { 273 fprintf(stderr, "failed to alloc %llu\n", 274 (unsigned long long)num * block_size); 275 return EXT2_ET_NO_MEMORY; 276 } 277 278 for (i = 0; i < num; i++) { 279 memcpy(buf + i * block_size, sm->blocks[start + i] , block_size); 280 free(sm->blocks[start + i]); 281 sm->blocks[start + i] = NULL; 282 } 283 284 /* free_sparse_blocks will release this buf. */ 285 sm->blocks[start] = buf; 286 287 retval = sparse_file_add_data(sm->sparse_file, sm->blocks[start], 288 block_size * num, start); 289 290 return retval; 291 } 292 293 static errcode_t sparse_close_channel(io_channel channel) 294 { 295 uint64_t i; 296 errcode_t retval = 0; 297 struct sparse_map *sm = channel->private_data; 298 299 if (sm->sparse_file) { 300 int64_t chunk_start = (sm->blocks[0] == NULL) ? -1 : 0; 301 for (i = 0; i < sm->blocks_count; ++i) { 302 if (!sm->blocks[i] && chunk_start != -1) { 303 retval = sparse_merge_blocks(sm, chunk_start, i - chunk_start); 304 chunk_start = -1; 305 } else if (sm->blocks[i] && chunk_start == -1) { 306 chunk_start = i; 307 } 308 if (retval) 309 goto ret; 310 } 311 if (chunk_start != -1) { 312 retval = sparse_merge_blocks(sm, chunk_start, 313 sm->blocks_count - chunk_start); 314 if (retval) 315 goto ret; 316 } 317 retval = sparse_file_write(sm->sparse_file, sm->fd, 318 /*gzip*/0, /*sparse*/1, /*crc*/0); 319 } 320 321 ret: 322 if (sm->sparse_file) 323 sparse_file_destroy(sm->sparse_file); 324 free_sparse_blocks(sm); 325 free(sm->file); 326 free(sm); 327 free(channel); 328 return retval; 329 } 330 331 static errcode_t sparse_close(io_channel channel) 332 { 333 errcode_t retval; 334 struct sparse_map *sm = channel->private_data; 335 int fd = sm->fd; 336 337 retval = sparse_close_channel(channel); 338 if (fd >= 0) 339 close(fd); 340 341 return retval; 342 } 343 344 static errcode_t sparse_set_blksize(io_channel channel, int blksize) 345 { 346 channel->block_size = blksize; 347 return 0; 348 } 349 350 static blk64_t block_to_sparse_block(blk64_t block, blk64_t *offset, 351 io_channel channel, struct sparse_map *sm) 352 { 353 int ratio; 354 blk64_t ret = block; 355 356 ratio = sm->block_size / channel->block_size; 357 ret /= ratio; 358 *offset = (block % ratio) * channel->block_size; 359 360 return ret; 361 } 362 363 static errcode_t check_block_size(io_channel channel, struct sparse_map *sm) 364 { 365 if (sm->block_size >= channel->block_size) 366 return 0; 367 return EXT2_ET_UNEXPECTED_BLOCK_SIZE; 368 } 369 370 static errcode_t sparse_read_blk64(io_channel channel, blk64_t block, 371 int count, void *buf) 372 { 373 int i; 374 char *out = buf; 375 blk64_t offset = 0, cur_block; 376 struct sparse_map *sm = channel->private_data; 377 378 if (check_block_size(channel, sm)) 379 return EXT2_ET_UNEXPECTED_BLOCK_SIZE; 380 381 if (count < 0) { //partial read 382 count = -count; 383 cur_block = block_to_sparse_block(block, &offset, channel, sm); 384 if (sm->blocks[cur_block]) 385 memcpy(out, (sm->blocks[cur_block]) + offset, count); 386 else 387 memset(out, 0, count); 388 } else { 389 for (i = 0; i < count; ++i) { 390 cur_block = block_to_sparse_block(block + i, &offset, 391 channel, sm); 392 if (sm->blocks[cur_block]) 393 memcpy(out + (i * channel->block_size), 394 sm->blocks[cur_block] + offset, 395 channel->block_size); 396 else if (sm->blocks) 397 memset(out + (i * channel->block_size), 0, 398 channel->block_size); 399 } 400 } 401 return 0; 402 } 403 404 static errcode_t sparse_read_blk(io_channel channel, unsigned long block, 405 int count, void *buf) 406 { 407 return sparse_read_blk64(channel, block, count, buf); 408 } 409 410 static errcode_t sparse_write_blk64(io_channel channel, blk64_t block, 411 int count, const void *buf) 412 { 413 int i; 414 blk64_t offset = 0, cur_block; 415 const char *in = buf; 416 struct sparse_map *sm = channel->private_data; 417 418 if (check_block_size(channel, sm)) 419 return EXT2_ET_UNEXPECTED_BLOCK_SIZE; 420 421 if (count < 0) { //partial write 422 count = -count; 423 cur_block = block_to_sparse_block(block, &offset, channel, 424 sm); 425 if (!sm->blocks[cur_block]) { 426 sm->blocks[cur_block] = calloc(1, sm->block_size); 427 if (!sm->blocks[cur_block]) 428 return EXT2_ET_NO_MEMORY; 429 } 430 memcpy(sm->blocks[cur_block] + offset, in, count); 431 } else { 432 for (i = 0; i < count; ++i) { 433 if (block + i >= sm->blocks_count) 434 return 0; 435 cur_block = block_to_sparse_block(block + i, &offset, 436 channel, sm); 437 if (!sm->blocks[cur_block]) { 438 sm->blocks[cur_block] = 439 calloc(1, sm->block_size); 440 if (!sm->blocks[cur_block]) 441 return EXT2_ET_NO_MEMORY; 442 } 443 memcpy(sm->blocks[cur_block] + offset, 444 in + (i * channel->block_size), 445 channel->block_size); 446 } 447 } 448 return 0; 449 } 450 451 static errcode_t sparse_write_blk(io_channel channel, unsigned long block, 452 int count, const void *buf) 453 { 454 return sparse_write_blk64(channel, block, count, buf); 455 } 456 457 static errcode_t sparse_discard(io_channel channel __attribute__((unused)), 458 blk64_t blk, unsigned long long count) 459 { 460 blk64_t cur_block, offset; 461 struct sparse_map *sm = channel->private_data; 462 463 if (check_block_size(channel, sm)) 464 return EXT2_ET_UNEXPECTED_BLOCK_SIZE; 465 466 for (unsigned long long i = 0; i < count; ++i) { 467 if (blk + i >= sm->blocks_count) 468 return 0; 469 cur_block = block_to_sparse_block(blk + i, &offset, channel, 470 sm); 471 if (!sm->blocks[cur_block]) 472 continue; 473 free(sm->blocks[cur_block]); 474 sm->blocks[cur_block] = NULL; 475 } 476 return 0; 477 } 478 479 static errcode_t sparse_zeroout(io_channel channel, blk64_t blk, 480 unsigned long long count) 481 { 482 return sparse_discard(channel, blk, count); 483 } 484 485 static errcode_t sparse_flush(io_channel channel __attribute__((unused))) 486 { 487 return 0; 488 } 489 490 static errcode_t sparse_set_option(io_channel channel __attribute__((unused)), 491 const char *option __attribute__((unused)), 492 const char *arg __attribute__((unused))) 493 { 494 return 0; 495 } 496 497 static errcode_t sparse_cache_readahead( 498 io_channel channel __attribute__((unused)), 499 blk64_t blk __attribute__((unused)), 500 unsigned long long count __attribute__((unused))) 501 { 502 return 0; 503 } 504 505 static struct struct_io_manager struct_sparse_manager = { 506 .magic = EXT2_ET_MAGIC_IO_MANAGER, 507 .name = "Android sparse I/O Manager", 508 .open = sparse_open, 509 .close = sparse_close, 510 .set_blksize = sparse_set_blksize, 511 .read_blk = sparse_read_blk, 512 .write_blk = sparse_write_blk, 513 .flush = sparse_flush, 514 .write_byte = NULL, 515 .set_option = sparse_set_option, 516 .get_stats = NULL, 517 .read_blk64 = sparse_read_blk64, 518 .write_blk64 = sparse_write_blk64, 519 .discard = sparse_discard, 520 .cache_readahead = sparse_cache_readahead, 521 .zeroout = sparse_zeroout, 522 }; 523 524 static struct struct_io_manager struct_sparsefd_manager = { 525 .magic = EXT2_ET_MAGIC_IO_MANAGER, 526 .name = "Android sparse fd I/O Manager", 527 .open = sparsefd_open, 528 .close = sparse_close, 529 .set_blksize = sparse_set_blksize, 530 .read_blk = sparse_read_blk, 531 .write_blk = sparse_write_blk, 532 .flush = sparse_flush, 533 .write_byte = NULL, 534 .set_option = sparse_set_option, 535 .get_stats = NULL, 536 .read_blk64 = sparse_read_blk64, 537 .write_blk64 = sparse_write_blk64, 538 .discard = sparse_discard, 539 .cache_readahead = sparse_cache_readahead, 540 .zeroout = sparse_zeroout, 541 }; 542 543 #endif 544 545 io_manager sparse_io_manager = &struct_sparse_manager; 546 io_manager sparsefd_io_manager = &struct_sparsefd_manager; 547
