libsparse: Add .clang-format and reformat to google3 style
Bug: 78793464
Test: compiles
Change-Id: I8e44ba77195a12fc2bac7d4276bbc4aa95149b31
diff --git a/libsparse/sparse.cpp b/libsparse/sparse.cpp
index 992945f..6ff97b6 100644
--- a/libsparse/sparse.cpp
+++ b/libsparse/sparse.cpp
@@ -22,374 +22,327 @@
#include "defs.h"
#include "sparse_file.h"
-#include "output_file.h"
#include "backed_block.h"
+#include "output_file.h"
#include "sparse_defs.h"
#include "sparse_format.h"
-struct sparse_file *sparse_file_new(unsigned int block_size, int64_t len)
-{
- struct sparse_file *s = reinterpret_cast<sparse_file*>(calloc(sizeof(struct sparse_file), 1));
- if (!s) {
- return NULL;
- }
+struct sparse_file* sparse_file_new(unsigned int block_size, int64_t len) {
+ struct sparse_file* s = reinterpret_cast<sparse_file*>(calloc(sizeof(struct sparse_file), 1));
+ if (!s) {
+ return NULL;
+ }
- s->backed_block_list = backed_block_list_new(block_size);
- if (!s->backed_block_list) {
- free(s);
- return NULL;
- }
+ s->backed_block_list = backed_block_list_new(block_size);
+ if (!s->backed_block_list) {
+ free(s);
+ return NULL;
+ }
- s->block_size = block_size;
- s->len = len;
+ s->block_size = block_size;
+ s->len = len;
- return s;
+ return s;
}
-void sparse_file_destroy(struct sparse_file *s)
-{
- backed_block_list_destroy(s->backed_block_list);
- free(s);
+void sparse_file_destroy(struct sparse_file* s) {
+ backed_block_list_destroy(s->backed_block_list);
+ free(s);
}
-int sparse_file_add_data(struct sparse_file *s,
- void *data, unsigned int len, unsigned int block)
-{
- return backed_block_add_data(s->backed_block_list, data, len, block);
+int sparse_file_add_data(struct sparse_file* s, void* data, unsigned int len, unsigned int block) {
+ return backed_block_add_data(s->backed_block_list, data, len, block);
}
-int sparse_file_add_fill(struct sparse_file *s,
- uint32_t fill_val, unsigned int len, unsigned int block)
-{
- return backed_block_add_fill(s->backed_block_list, fill_val, len, block);
+int sparse_file_add_fill(struct sparse_file* s, uint32_t fill_val, unsigned int len,
+ unsigned int block) {
+ return backed_block_add_fill(s->backed_block_list, fill_val, len, block);
}
-int sparse_file_add_file(struct sparse_file *s,
- const char *filename, int64_t file_offset, unsigned int len,
- unsigned int block)
-{
- return backed_block_add_file(s->backed_block_list, filename, file_offset,
- len, block);
+int sparse_file_add_file(struct sparse_file* s, const char* filename, int64_t file_offset,
+ unsigned int len, unsigned int block) {
+ return backed_block_add_file(s->backed_block_list, filename, file_offset, len, block);
}
-int sparse_file_add_fd(struct sparse_file *s,
- int fd, int64_t file_offset, unsigned int len, unsigned int block)
-{
- return backed_block_add_fd(s->backed_block_list, fd, file_offset,
- len, block);
+int sparse_file_add_fd(struct sparse_file* s, int fd, int64_t file_offset, unsigned int len,
+ unsigned int block) {
+ return backed_block_add_fd(s->backed_block_list, fd, file_offset, len, block);
}
-unsigned int sparse_count_chunks(struct sparse_file *s)
-{
- struct backed_block *bb;
- unsigned int last_block = 0;
- unsigned int chunks = 0;
+unsigned int sparse_count_chunks(struct sparse_file* s) {
+ struct backed_block* bb;
+ unsigned int last_block = 0;
+ unsigned int chunks = 0;
- for (bb = backed_block_iter_new(s->backed_block_list); bb;
- bb = backed_block_iter_next(bb)) {
- if (backed_block_block(bb) > last_block) {
- /* If there is a gap between chunks, add a skip chunk */
- chunks++;
- }
- chunks++;
- last_block = backed_block_block(bb) +
- DIV_ROUND_UP(backed_block_len(bb), s->block_size);
- }
- if (last_block < DIV_ROUND_UP(s->len, s->block_size)) {
- chunks++;
- }
+ for (bb = backed_block_iter_new(s->backed_block_list); bb; bb = backed_block_iter_next(bb)) {
+ if (backed_block_block(bb) > last_block) {
+ /* If there is a gap between chunks, add a skip chunk */
+ chunks++;
+ }
+ chunks++;
+ last_block = backed_block_block(bb) + DIV_ROUND_UP(backed_block_len(bb), s->block_size);
+ }
+ if (last_block < DIV_ROUND_UP(s->len, s->block_size)) {
+ chunks++;
+ }
- return chunks;
+ return chunks;
}
-static int sparse_file_write_block(struct output_file *out,
- struct backed_block *bb)
-{
- int ret = -EINVAL;
+static int sparse_file_write_block(struct output_file* out, struct backed_block* bb) {
+ int ret = -EINVAL;
- switch (backed_block_type(bb)) {
- case BACKED_BLOCK_DATA:
- ret = write_data_chunk(out, backed_block_len(bb), backed_block_data(bb));
- break;
- case BACKED_BLOCK_FILE:
- ret = write_file_chunk(out, backed_block_len(bb),
- backed_block_filename(bb),
- backed_block_file_offset(bb));
- break;
- case BACKED_BLOCK_FD:
- ret = write_fd_chunk(out, backed_block_len(bb),
- backed_block_fd(bb),
- backed_block_file_offset(bb));
- break;
- case BACKED_BLOCK_FILL:
- ret = write_fill_chunk(out, backed_block_len(bb),
- backed_block_fill_val(bb));
- break;
- }
+ switch (backed_block_type(bb)) {
+ case BACKED_BLOCK_DATA:
+ ret = write_data_chunk(out, backed_block_len(bb), backed_block_data(bb));
+ break;
+ case BACKED_BLOCK_FILE:
+ ret = write_file_chunk(out, backed_block_len(bb), backed_block_filename(bb),
+ backed_block_file_offset(bb));
+ break;
+ case BACKED_BLOCK_FD:
+ ret = write_fd_chunk(out, backed_block_len(bb), backed_block_fd(bb),
+ backed_block_file_offset(bb));
+ break;
+ case BACKED_BLOCK_FILL:
+ ret = write_fill_chunk(out, backed_block_len(bb), backed_block_fill_val(bb));
+ break;
+ }
- return ret;
+ return ret;
}
-static int write_all_blocks(struct sparse_file *s, struct output_file *out)
-{
- struct backed_block *bb;
- unsigned int last_block = 0;
- int64_t pad;
- int ret = 0;
+static int write_all_blocks(struct sparse_file* s, struct output_file* out) {
+ struct backed_block* bb;
+ unsigned int last_block = 0;
+ int64_t pad;
+ int ret = 0;
- for (bb = backed_block_iter_new(s->backed_block_list); bb;
- bb = backed_block_iter_next(bb)) {
- if (backed_block_block(bb) > last_block) {
- unsigned int blocks = backed_block_block(bb) - last_block;
- write_skip_chunk(out, (int64_t)blocks * s->block_size);
- }
- ret = sparse_file_write_block(out, bb);
- if (ret)
- return ret;
- last_block = backed_block_block(bb) +
- DIV_ROUND_UP(backed_block_len(bb), s->block_size);
- }
+ for (bb = backed_block_iter_new(s->backed_block_list); bb; bb = backed_block_iter_next(bb)) {
+ if (backed_block_block(bb) > last_block) {
+ unsigned int blocks = backed_block_block(bb) - last_block;
+ write_skip_chunk(out, (int64_t)blocks * s->block_size);
+ }
+ ret = sparse_file_write_block(out, bb);
+ if (ret) return ret;
+ last_block = backed_block_block(bb) + DIV_ROUND_UP(backed_block_len(bb), s->block_size);
+ }
- pad = s->len - (int64_t)last_block * s->block_size;
- assert(pad >= 0);
- if (pad > 0) {
- write_skip_chunk(out, pad);
- }
+ pad = s->len - (int64_t)last_block * s->block_size;
+ assert(pad >= 0);
+ if (pad > 0) {
+ write_skip_chunk(out, pad);
+ }
- return 0;
+ return 0;
}
-int sparse_file_write(struct sparse_file *s, int fd, bool gz, bool sparse,
- bool crc)
-{
- int ret;
- int chunks;
- struct output_file *out;
+int sparse_file_write(struct sparse_file* s, int fd, bool gz, bool sparse, bool crc) {
+ int ret;
+ int chunks;
+ struct output_file* out;
- chunks = sparse_count_chunks(s);
- out = output_file_open_fd(fd, s->block_size, s->len, gz, sparse, chunks, crc);
+ chunks = sparse_count_chunks(s);
+ out = output_file_open_fd(fd, s->block_size, s->len, gz, sparse, chunks, crc);
- if (!out)
- return -ENOMEM;
+ if (!out) return -ENOMEM;
- ret = write_all_blocks(s, out);
+ ret = write_all_blocks(s, out);
- output_file_close(out);
+ output_file_close(out);
- return ret;
+ return ret;
}
-int sparse_file_callback(struct sparse_file *s, bool sparse, bool crc,
- int (*write)(void *priv, const void *data, size_t len), void *priv)
-{
- int ret;
- int chunks;
- struct output_file *out;
+int sparse_file_callback(struct sparse_file* s, bool sparse, bool crc,
+ int (*write)(void* priv, const void* data, size_t len), void* priv) {
+ int ret;
+ int chunks;
+ struct output_file* out;
- chunks = sparse_count_chunks(s);
- out = output_file_open_callback(write, priv, s->block_size, s->len, false,
- sparse, chunks, crc);
+ chunks = sparse_count_chunks(s);
+ out = output_file_open_callback(write, priv, s->block_size, s->len, false, sparse, chunks, crc);
- if (!out)
- return -ENOMEM;
+ if (!out) return -ENOMEM;
- ret = write_all_blocks(s, out);
+ ret = write_all_blocks(s, out);
- output_file_close(out);
+ output_file_close(out);
- return ret;
+ return ret;
}
struct chunk_data {
- void *priv;
- unsigned int block;
- unsigned int nr_blocks;
- int (*write)(void *priv, const void *data, size_t len,
- unsigned int block, unsigned int nr_blocks);
+ void* priv;
+ unsigned int block;
+ unsigned int nr_blocks;
+ int (*write)(void* priv, const void* data, size_t len, unsigned int block, unsigned int nr_blocks);
};
-static int foreach_chunk_write(void *priv, const void *data, size_t len)
-{
- struct chunk_data *chk = reinterpret_cast<chunk_data*>(priv);
+static int foreach_chunk_write(void* priv, const void* data, size_t len) {
+ struct chunk_data* chk = reinterpret_cast<chunk_data*>(priv);
- return chk->write(chk->priv, data, len, chk->block, chk->nr_blocks);
+ return chk->write(chk->priv, data, len, chk->block, chk->nr_blocks);
}
-int sparse_file_foreach_chunk(struct sparse_file *s, bool sparse, bool crc,
- int (*write)(void *priv, const void *data, size_t len, unsigned int block,
- unsigned int nr_blocks),
- void *priv)
-{
- int ret;
- int chunks;
- struct chunk_data chk;
- struct output_file *out;
- struct backed_block *bb;
+int sparse_file_foreach_chunk(struct sparse_file* s, bool sparse, bool crc,
+ int (*write)(void* priv, const void* data, size_t len,
+ unsigned int block, unsigned int nr_blocks),
+ void* priv) {
+ int ret;
+ int chunks;
+ struct chunk_data chk;
+ struct output_file* out;
+ struct backed_block* bb;
- chk.priv = priv;
- chk.write = write;
- chk.block = chk.nr_blocks = 0;
- chunks = sparse_count_chunks(s);
- out = output_file_open_callback(foreach_chunk_write, &chk,
- s->block_size, s->len, false, sparse,
- chunks, crc);
+ chk.priv = priv;
+ chk.write = write;
+ chk.block = chk.nr_blocks = 0;
+ chunks = sparse_count_chunks(s);
+ out = output_file_open_callback(foreach_chunk_write, &chk, s->block_size, s->len, false, sparse,
+ chunks, crc);
- if (!out)
- return -ENOMEM;
+ if (!out) return -ENOMEM;
- for (bb = backed_block_iter_new(s->backed_block_list); bb;
- bb = backed_block_iter_next(bb)) {
- chk.block = backed_block_block(bb);
- chk.nr_blocks = (backed_block_len(bb) - 1) / s->block_size + 1;
- ret = sparse_file_write_block(out, bb);
- if (ret)
- return ret;
- }
+ for (bb = backed_block_iter_new(s->backed_block_list); bb; bb = backed_block_iter_next(bb)) {
+ chk.block = backed_block_block(bb);
+ chk.nr_blocks = (backed_block_len(bb) - 1) / s->block_size + 1;
+ ret = sparse_file_write_block(out, bb);
+ if (ret) return ret;
+ }
- output_file_close(out);
+ output_file_close(out);
- return ret;
+ return ret;
}
-static int out_counter_write(void *priv, const void *data __unused, size_t len)
-{
- int64_t *count = reinterpret_cast<int64_t*>(priv);
- *count += len;
- return 0;
+static int out_counter_write(void* priv, const void* data __unused, size_t len) {
+ int64_t* count = reinterpret_cast<int64_t*>(priv);
+ *count += len;
+ return 0;
}
-int64_t sparse_file_len(struct sparse_file *s, bool sparse, bool crc)
-{
- int ret;
- int chunks = sparse_count_chunks(s);
- int64_t count = 0;
- struct output_file *out;
+int64_t sparse_file_len(struct sparse_file* s, bool sparse, bool crc) {
+ int ret;
+ int chunks = sparse_count_chunks(s);
+ int64_t count = 0;
+ struct output_file* out;
- out = output_file_open_callback(out_counter_write, &count,
- s->block_size, s->len, false, sparse, chunks, crc);
- if (!out) {
- return -1;
- }
+ out = output_file_open_callback(out_counter_write, &count, s->block_size, s->len, false, sparse,
+ chunks, crc);
+ if (!out) {
+ return -1;
+ }
- ret = write_all_blocks(s, out);
+ ret = write_all_blocks(s, out);
- output_file_close(out);
+ output_file_close(out);
- if (ret < 0) {
- return -1;
- }
+ if (ret < 0) {
+ return -1;
+ }
- return count;
+ return count;
}
-unsigned int sparse_file_block_size(struct sparse_file *s)
-{
- return s->block_size;
+unsigned int sparse_file_block_size(struct sparse_file* s) {
+ return s->block_size;
}
-static struct backed_block *move_chunks_up_to_len(struct sparse_file *from,
- struct sparse_file *to, unsigned int len)
-{
- int64_t count = 0;
- struct output_file *out_counter;
- struct backed_block *last_bb = NULL;
- struct backed_block *bb;
- struct backed_block *start;
- unsigned int last_block = 0;
- int64_t file_len = 0;
- int ret;
+static struct backed_block* move_chunks_up_to_len(struct sparse_file* from, struct sparse_file* to,
+ unsigned int len) {
+ int64_t count = 0;
+ struct output_file* out_counter;
+ struct backed_block* last_bb = NULL;
+ struct backed_block* bb;
+ struct backed_block* start;
+ unsigned int last_block = 0;
+ int64_t file_len = 0;
+ int ret;
- /*
- * overhead is sparse file header, the potential end skip
- * chunk and crc chunk.
- */
- int overhead = sizeof(sparse_header_t) + 2 * sizeof(chunk_header_t) +
- sizeof(uint32_t);
- len -= overhead;
+ /*
+ * overhead is sparse file header, the potential end skip
+ * chunk and crc chunk.
+ */
+ int overhead = sizeof(sparse_header_t) + 2 * sizeof(chunk_header_t) + sizeof(uint32_t);
+ len -= overhead;
- start = backed_block_iter_new(from->backed_block_list);
- out_counter = output_file_open_callback(out_counter_write, &count,
- to->block_size, to->len, false, true, 0, false);
- if (!out_counter) {
- return NULL;
- }
+ start = backed_block_iter_new(from->backed_block_list);
+ out_counter = output_file_open_callback(out_counter_write, &count, to->block_size, to->len, false,
+ true, 0, false);
+ if (!out_counter) {
+ return NULL;
+ }
- for (bb = start; bb; bb = backed_block_iter_next(bb)) {
- count = 0;
- if (backed_block_block(bb) > last_block)
- count += sizeof(chunk_header_t);
- last_block = backed_block_block(bb) +
- DIV_ROUND_UP(backed_block_len(bb), to->block_size);
+ for (bb = start; bb; bb = backed_block_iter_next(bb)) {
+ count = 0;
+ if (backed_block_block(bb) > last_block) count += sizeof(chunk_header_t);
+ last_block = backed_block_block(bb) + DIV_ROUND_UP(backed_block_len(bb), to->block_size);
- /* will call out_counter_write to update count */
- ret = sparse_file_write_block(out_counter, bb);
- if (ret) {
- bb = NULL;
- goto out;
- }
- if (file_len + count > len) {
- /*
- * If the remaining available size is more than 1/8th of the
- * requested size, split the chunk. Results in sparse files that
- * are at least 7/8ths of the requested size
- */
- file_len += sizeof(chunk_header_t);
- if (!last_bb || (len - file_len > (len / 8))) {
- backed_block_split(from->backed_block_list, bb, len - file_len);
- last_bb = bb;
- }
- goto move;
- }
- file_len += count;
- last_bb = bb;
- }
+ /* will call out_counter_write to update count */
+ ret = sparse_file_write_block(out_counter, bb);
+ if (ret) {
+ bb = NULL;
+ goto out;
+ }
+ if (file_len + count > len) {
+ /*
+ * If the remaining available size is more than 1/8th of the
+ * requested size, split the chunk. Results in sparse files that
+ * are at least 7/8ths of the requested size
+ */
+ file_len += sizeof(chunk_header_t);
+ if (!last_bb || (len - file_len > (len / 8))) {
+ backed_block_split(from->backed_block_list, bb, len - file_len);
+ last_bb = bb;
+ }
+ goto move;
+ }
+ file_len += count;
+ last_bb = bb;
+ }
move:
- backed_block_list_move(from->backed_block_list,
- to->backed_block_list, start, last_bb);
+ backed_block_list_move(from->backed_block_list, to->backed_block_list, start, last_bb);
out:
- output_file_close(out_counter);
+ output_file_close(out_counter);
- return bb;
+ return bb;
}
-int sparse_file_resparse(struct sparse_file *in_s, unsigned int max_len,
- struct sparse_file **out_s, int out_s_count)
-{
- struct backed_block *bb;
- struct sparse_file *s;
- struct sparse_file *tmp;
- int c = 0;
+int sparse_file_resparse(struct sparse_file* in_s, unsigned int max_len, struct sparse_file** out_s,
+ int out_s_count) {
+ struct backed_block* bb;
+ struct sparse_file* s;
+ struct sparse_file* tmp;
+ int c = 0;
- tmp = sparse_file_new(in_s->block_size, in_s->len);
- if (!tmp) {
- return -ENOMEM;
- }
+ tmp = sparse_file_new(in_s->block_size, in_s->len);
+ if (!tmp) {
+ return -ENOMEM;
+ }
- do {
- s = sparse_file_new(in_s->block_size, in_s->len);
+ do {
+ s = sparse_file_new(in_s->block_size, in_s->len);
- bb = move_chunks_up_to_len(in_s, s, max_len);
+ bb = move_chunks_up_to_len(in_s, s, max_len);
- if (c < out_s_count) {
- out_s[c] = s;
- } else {
- backed_block_list_move(s->backed_block_list, tmp->backed_block_list,
- NULL, NULL);
- sparse_file_destroy(s);
- }
- c++;
- } while (bb);
+ if (c < out_s_count) {
+ out_s[c] = s;
+ } else {
+ backed_block_list_move(s->backed_block_list, tmp->backed_block_list, NULL, NULL);
+ sparse_file_destroy(s);
+ }
+ c++;
+ } while (bb);
- backed_block_list_move(tmp->backed_block_list, in_s->backed_block_list,
- NULL, NULL);
+ backed_block_list_move(tmp->backed_block_list, in_s->backed_block_list, NULL, NULL);
- sparse_file_destroy(tmp);
+ sparse_file_destroy(tmp);
- return c;
+ return c;
}
-void sparse_file_verbose(struct sparse_file *s)
-{
- s->verbose = true;
+void sparse_file_verbose(struct sparse_file* s) {
+ s->verbose = true;
}