Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 837bf5a4 authored by Paul Lawrence's avatar Paul Lawrence
Browse files

ANDROID: Incremental fs: Add hash block counts to IOC_IOCTL_GET_BLOCK_COUNT 



Bug: 166638631
Test: incfs_test passes
Signed-off-by: default avatarPaul Lawrence <paullawrence@google.com>
Change-Id: I0061a855ec563de8df40ba0b35292e99be33c6c0
parent 1652f264

fs/incfs/data_mgmt.c

+19 −5
Original line number Diff line number Diff line
@@ -274,13 +274,16 @@ struct data_file *incfs_open_data_file(struct mount_info *mi, struct file *bf) 


void incfs_free_data_file(struct data_file *df)

{

	u32 blocks_written;

	u32 data_blocks_written, hash_blocks_written;



	if (!df)

		return;



	blocks_written = atomic_read(&df->df_data_blocks_written);

	if (blocks_written != df->df_initial_data_blocks_written) {

	data_blocks_written = atomic_read(&df->df_data_blocks_written);

	hash_blocks_written = atomic_read(&df->df_hash_blocks_written);



	if (data_blocks_written != df->df_initial_data_blocks_written ||

	    hash_blocks_written != df->df_initial_hash_blocks_written) {

		struct backing_file_context *bfc = df->df_backing_file_context;

		int error = -1;
@@ -288,7 +291,8 @@ void incfs_free_data_file(struct data_file *df) 
			error = incfs_write_status_to_backing_file(

						df->df_backing_file_context,

						df->df_status_offset,

						blocks_written);

						data_blocks_written,

						hash_blocks_written);

			mutex_unlock(&bfc->bc_mutex);

		}
@@ -1228,6 +1232,9 @@ int incfs_process_new_hash_block(struct data_file *df, 
			hash_area_base, df->df_blockmap_off, df->df_size);

		mutex_unlock(&bfc->bc_mutex);

	}

	if (!error)

		atomic_inc(&df->df_hash_blocks_written);



	return error;

}
@@ -1330,9 +1337,16 @@ static int process_status_md(struct incfs_status *is, 
{

	struct data_file *df = handler->context;



	df->df_initial_data_blocks_written = le32_to_cpu(is->is_blocks_written);

	df->df_initial_data_blocks_written =

		le32_to_cpu(is->is_data_blocks_written);

	atomic_set(&df->df_data_blocks_written,

		   df->df_initial_data_blocks_written);



	df->df_initial_hash_blocks_written =

		le32_to_cpu(is->is_hash_blocks_written);

	atomic_set(&df->df_hash_blocks_written,

		   df->df_initial_hash_blocks_written);



	df->df_status_offset = handler->md_record_offset;



	return 0;

fs/incfs/data_mgmt.h

+6 −0
Original line number Diff line number Diff line
@@ -255,6 +255,12 @@ struct data_file { 
	/* Number of data blocks in the status block */

	u32 df_initial_data_blocks_written;



	/* Number of hash blocks written to file */

	atomic_t df_hash_blocks_written;



	/* Number of hash blocks in the status block */

	u32 df_initial_hash_blocks_written;



	/* Offset to status metadata header */

	loff_t df_status_offset;

fs/incfs/format.c

+16 −11
Original line number Diff line number Diff line
@@ -317,23 +317,25 @@ int incfs_write_signature_to_backing_file(struct backing_file_context *bfc, 
}



static int write_new_status_to_backing_file(struct backing_file_context *bfc,

				       u32 blocks_written)

				       u32 data_blocks_written,

				       u32 hash_blocks_written)

{

	struct incfs_status is = {};

	int result;

	loff_t rollback_pos;

	struct incfs_status is = {

		.is_header = {

			.h_md_entry_type = INCFS_MD_STATUS,

			.h_record_size = cpu_to_le16(sizeof(is)),

		},

		.is_data_blocks_written = cpu_to_le32(data_blocks_written),

		.is_hash_blocks_written = cpu_to_le32(hash_blocks_written),

	};



	if (!bfc)

		return -EFAULT;



	LOCK_REQUIRED(bfc->bc_mutex);



	rollback_pos = incfs_get_end_offset(bfc->bc_file);



	is.is_header.h_md_entry_type = INCFS_MD_STATUS;

	is.is_header.h_record_size = cpu_to_le16(sizeof(is));

	is.is_blocks_written = cpu_to_le32(blocks_written);



	result = append_md_to_backing_file(bfc, &is.is_header);

	if (result)

		truncate_backing_file(bfc, rollback_pos);
@@ -343,19 +345,22 @@ static int write_new_status_to_backing_file(struct backing_file_context *bfc, 


int incfs_write_status_to_backing_file(struct backing_file_context *bfc,

				       loff_t status_offset,

				       u32 blocks_written)

				       u32 data_blocks_written,

				       u32 hash_blocks_written)

{

	struct incfs_status is;

	int result;



	if (status_offset == 0)

		return write_new_status_to_backing_file(bfc, blocks_written);

		return write_new_status_to_backing_file(bfc,

				data_blocks_written, hash_blocks_written);



	result = incfs_kread(bfc->bc_file, &is, sizeof(is), status_offset);

	if (result != sizeof(is))

		return -EIO;



	is.is_blocks_written = cpu_to_le32(blocks_written);

	is.is_data_blocks_written = cpu_to_le32(data_blocks_written);

	is.is_hash_blocks_written = cpu_to_le32(hash_blocks_written);

	result = incfs_kwrite(bfc->bc_file, &is, sizeof(is), status_offset);

	if (result != sizeof(is))

		return -EIO;

fs/incfs/format.h

+6 −3
Original line number Diff line number Diff line
@@ -249,9 +249,11 @@ struct incfs_df_signature { 
struct incfs_status {

	struct incfs_md_header is_header;



	__le32 is_blocks_written; /* Number of blocks written */

	__le32 is_data_blocks_written; /* Number of data blocks written */



	__le32 is_dummy[7]; /* Three spare fields */

	__le32 is_hash_blocks_written; /* Number of hash blocks written */



	__le32 is_dummy[6]; /* Spare fields */

};



/* State of the backing file. */
@@ -325,7 +327,8 @@ int incfs_write_signature_to_backing_file(struct backing_file_context *bfc, 


int incfs_write_status_to_backing_file(struct backing_file_context *bfc,

				       loff_t status_offset,

				       u32 blocks_written);

				       u32 data_blocks_written,

				       u32 hash_blocks_written);



int incfs_write_file_header_flags(struct backing_file_context *bfc, u32 flags);

fs/incfs/vfs.c

+5 −2
Original line number Diff line number Diff line
@@ -671,8 +671,11 @@ static long ioctl_get_block_count(struct file *f, void __user *arg) 
	if (!df)

		return -EINVAL;



	args.total_blocks_out = df->df_data_block_count;

	args.filled_blocks_out = atomic_read(&df->df_data_blocks_written);

	args.total_data_blocks_out = df->df_data_block_count;

	args.filled_data_blocks_out = atomic_read(&df->df_data_blocks_written);

	args.total_hash_blocks_out = df->df_total_block_count -

		df->df_data_block_count;

	args.filled_hash_blocks_out = atomic_read(&df->df_hash_blocks_written);



	if (copy_to_user(args_usr_ptr, &args, sizeof(args)))

		return -EFAULT;