dm: suppress endian warnings (283a8328) · Commits · jan.koester / Linux

drivers/md/dm-crypt.c

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -239,7 +239,7 @@ static int crypt_iv_plain_gen(struct crypt_config cc, u8 iv,
	struct dm_crypt_request *dmreq)		struct dm_crypt_request *dmreq)
	{		{
	memset(iv, 0, cc->iv_size);		memset(iv, 0, cc->iv_size);
	(u32 )iv = cpu_to_le32(dmreq->iv_sector & 0xffffffff);		(__le32 )iv = cpu_to_le32(dmreq->iv_sector & 0xffffffff);

	return 0;		return 0;
	}		}
	@@ -248,7 +248,7 @@ static int crypt_iv_plain64_gen(struct crypt_config cc, u8 iv,
	struct dm_crypt_request *dmreq)		struct dm_crypt_request *dmreq)
	{		{
	memset(iv, 0, cc->iv_size);		memset(iv, 0, cc->iv_size);
	(u64 )iv = cpu_to_le64(dmreq->iv_sector);		(__le64 )iv = cpu_to_le64(dmreq->iv_sector);

	return 0;		return 0;
	}		}
	@@ -415,7 +415,7 @@ static int crypt_iv_essiv_gen(struct crypt_config cc, u8 iv,
	struct crypto_cipher *essiv_tfm = this_crypt_config(cc)->iv_private;		struct crypto_cipher *essiv_tfm = this_crypt_config(cc)->iv_private;

	memset(iv, 0, cc->iv_size);		memset(iv, 0, cc->iv_size);
	(u64 )iv = cpu_to_le64(dmreq->iv_sector);		(__le64 )iv = cpu_to_le64(dmreq->iv_sector);
	crypto_cipher_encrypt_one(essiv_tfm, iv, iv);		crypto_cipher_encrypt_one(essiv_tfm, iv, iv);

	return 0;		return 0;

drivers/md/dm-log.c

+13 −7

Original line number	Original line	Diff line number	Diff line
	@@ -197,15 +197,21 @@ EXPORT_SYMBOL(dm_dirty_log_destroy);
	#define MIRROR_DISK_VERSION 2		#define MIRROR_DISK_VERSION 2
	#define LOG_OFFSET 2		#define LOG_OFFSET 2

	struct log_header {		struct log_header_disk {
	uint32_t magic;		__le32 magic;

	/*		/*
	* Simple, incrementing version. no backward		* Simple, incrementing version. no backward
	* compatibility.		* compatibility.
	*/		*/
			__le32 version;
			__le64 nr_regions;
			} __packed;

			struct log_header_core {
			uint32_t magic;
	uint32_t version;		uint32_t version;
	sector_t nr_regions;		uint64_t nr_regions;
	};		};

	struct log_c {		struct log_c {
	@@ -239,10 +245,10 @@ struct log_c {
	int log_dev_failed;		int log_dev_failed;
	int log_dev_flush_failed;		int log_dev_flush_failed;
	struct dm_dev *log_dev;		struct dm_dev *log_dev;
	struct log_header header;		struct log_header_core header;

	struct dm_io_region header_location;		struct dm_io_region header_location;
	struct log_header *disk_header;		struct log_header_disk *disk_header;
	};		};

	/*		/*
	@@ -271,14 +277,14 @@ static inline void log_clear_bit(struct log_c *l,
	/*----------------------------------------------------------------		/*----------------------------------------------------------------
	* Header IO		* Header IO
	--------------------------------------------------------------/		--------------------------------------------------------------/
	static void header_to_disk(struct log_header core, struct log_header disk)		static void header_to_disk(struct log_header_core core, struct log_header_disk disk)
	{		{
	disk->magic = cpu_to_le32(core->magic);		disk->magic = cpu_to_le32(core->magic);
	disk->version = cpu_to_le32(core->version);		disk->version = cpu_to_le32(core->version);
	disk->nr_regions = cpu_to_le64(core->nr_regions);		disk->nr_regions = cpu_to_le64(core->nr_regions);
	}		}

	static void header_from_disk(struct log_header core, struct log_header disk)		static void header_from_disk(struct log_header_core core, struct log_header_disk disk)
	{		{
	core->magic = le32_to_cpu(disk->magic);		core->magic = le32_to_cpu(disk->magic);
	core->version = le32_to_cpu(disk->version);		core->version = le32_to_cpu(disk->version);

drivers/md/dm-snap-persistent.c

+38 −33

Original line number	Original line	Diff line number	Diff line
	@@ -58,25 +58,30 @@
	#define NUM_SNAPSHOT_HDR_CHUNKS 1		#define NUM_SNAPSHOT_HDR_CHUNKS 1

	struct disk_header {		struct disk_header {
	uint32_t magic;		__le32 magic;

	/*		/*
	* Is this snapshot valid. There is no way of recovering		* Is this snapshot valid. There is no way of recovering
	* an invalid snapshot.		* an invalid snapshot.
	*/		*/
	uint32_t valid;		__le32 valid;

	/*		/*
	* Simple, incrementing version. no backward		* Simple, incrementing version. no backward
	* compatibility.		* compatibility.
	*/		*/
	uint32_t version;		__le32 version;

	/* In sectors */		/* In sectors */
	uint32_t chunk_size;		__le32 chunk_size;
	};		} __packed;

	struct disk_exception {		struct disk_exception {
			__le64 old_chunk;
			__le64 new_chunk;
			} __packed;

			struct core_exception {
	uint64_t old_chunk;		uint64_t old_chunk;
	uint64_t new_chunk;		uint64_t new_chunk;
	};		};
	@@ -396,32 +401,32 @@ static struct disk_exception get_exception(struct pstore ps, uint32_t index)
	}		}

	static void read_exception(struct pstore *ps,		static void read_exception(struct pstore *ps,
	uint32_t index, struct disk_exception *result)		uint32_t index, struct core_exception *result)
	{		{
	struct disk_exception *e = get_exception(ps, index);		struct disk_exception *de = get_exception(ps, index);

	/* copy it */		/* copy it */
	result->old_chunk = le64_to_cpu(e->old_chunk);		result->old_chunk = le64_to_cpu(de->old_chunk);
	result->new_chunk = le64_to_cpu(e->new_chunk);		result->new_chunk = le64_to_cpu(de->new_chunk);
	}		}

	static void write_exception(struct pstore *ps,		static void write_exception(struct pstore *ps,
	uint32_t index, struct disk_exception *de)		uint32_t index, struct core_exception *e)
	{		{
	struct disk_exception *e = get_exception(ps, index);		struct disk_exception *de = get_exception(ps, index);

	/* copy it */		/* copy it */
	e->old_chunk = cpu_to_le64(de->old_chunk);		de->old_chunk = cpu_to_le64(e->old_chunk);
	e->new_chunk = cpu_to_le64(de->new_chunk);		de->new_chunk = cpu_to_le64(e->new_chunk);
	}		}

	static void clear_exception(struct pstore *ps, uint32_t index)		static void clear_exception(struct pstore *ps, uint32_t index)
	{		{
	struct disk_exception *e = get_exception(ps, index);		struct disk_exception *de = get_exception(ps, index);

	/* clear it */		/* clear it */
	e->old_chunk = 0;		de->old_chunk = 0;
	e->new_chunk = 0;		de->new_chunk = 0;
	}		}

	/*		/*
	@@ -437,13 +442,13 @@ static int insert_exceptions(struct pstore *ps,
	{		{
	int r;		int r;
	unsigned int i;		unsigned int i;
	struct disk_exception de;		struct core_exception e;

	/* presume the area is full */		/* presume the area is full */
	*full = 1;		*full = 1;

	for (i = 0; i < ps->exceptions_per_area; i++) {		for (i = 0; i < ps->exceptions_per_area; i++) {
	read_exception(ps, i, &de);		read_exception(ps, i, &e);

	/*		/*
	* If the new_chunk is pointing at the start of		* If the new_chunk is pointing at the start of
	@@ -451,7 +456,7 @@ static int insert_exceptions(struct pstore *ps,
	* is we know that we've hit the end of the		* is we know that we've hit the end of the
	* exceptions. Therefore the area is not full.		* exceptions. Therefore the area is not full.
	*/		*/
	if (de.new_chunk == 0LL) {		if (e.new_chunk == 0LL) {
	ps->current_committed = i;		ps->current_committed = i;
	*full = 0;		*full = 0;
	break;		break;
	@@ -460,13 +465,13 @@ static int insert_exceptions(struct pstore *ps,
	/*		/*
	* Keep track of the start of the free chunks.		* Keep track of the start of the free chunks.
	*/		*/
	if (ps->next_free <= de.new_chunk)		if (ps->next_free <= e.new_chunk)
	ps->next_free = de.new_chunk + 1;		ps->next_free = e.new_chunk + 1;

	/*		/*
	* Otherwise we add the exception to the snapshot.		* Otherwise we add the exception to the snapshot.
	*/		*/
	r = callback(callback_context, de.old_chunk, de.new_chunk);		r = callback(callback_context, e.old_chunk, e.new_chunk);
	if (r)		if (r)
	return r;		return r;
	}		}
	@@ -641,12 +646,12 @@ static void persistent_commit_exception(struct dm_exception_store *store,
	{		{
	unsigned int i;		unsigned int i;
	struct pstore *ps = get_info(store);		struct pstore *ps = get_info(store);
	struct disk_exception de;		struct core_exception ce;
	struct commit_callback *cb;		struct commit_callback *cb;

	de.old_chunk = e->old_chunk;		ce.old_chunk = e->old_chunk;
	de.new_chunk = e->new_chunk;		ce.new_chunk = e->new_chunk;
	write_exception(ps, ps->current_committed++, &de);		write_exception(ps, ps->current_committed++, &ce);

	/*		/*
	* Add the callback to the back of the array. This code		* Add the callback to the back of the array. This code
	@@ -701,7 +706,7 @@ static int persistent_prepare_merge(struct dm_exception_store *store,
	chunk_t *last_new_chunk)		chunk_t *last_new_chunk)
	{		{
	struct pstore *ps = get_info(store);		struct pstore *ps = get_info(store);
	struct disk_exception de;		struct core_exception ce;
	int nr_consecutive;		int nr_consecutive;
	int r;		int r;

	@@ -722,9 +727,9 @@ static int persistent_prepare_merge(struct dm_exception_store *store,
	ps->current_committed = ps->exceptions_per_area;		ps->current_committed = ps->exceptions_per_area;
	}		}

	read_exception(ps, ps->current_committed - 1, &de);		read_exception(ps, ps->current_committed - 1, &ce);
	*last_old_chunk = de.old_chunk;		*last_old_chunk = ce.old_chunk;
	*last_new_chunk = de.new_chunk;		*last_new_chunk = ce.new_chunk;

	/*		/*
	* Find number of consecutive chunks within the current area,		* Find number of consecutive chunks within the current area,
	@@ -733,9 +738,9 @@ static int persistent_prepare_merge(struct dm_exception_store *store,
	for (nr_consecutive = 1; nr_consecutive < ps->current_committed;		for (nr_consecutive = 1; nr_consecutive < ps->current_committed;
	nr_consecutive++) {		nr_consecutive++) {
	read_exception(ps, ps->current_committed - 1 - nr_consecutive,		read_exception(ps, ps->current_committed - 1 - nr_consecutive,
	&de);		&ce);
	if (de.old_chunk != *last_old_chunk - nr_consecutive \|\|		if (ce.old_chunk != *last_old_chunk - nr_consecutive \|\|
	de.new_chunk != *last_new_chunk - nr_consecutive)		ce.new_chunk != *last_new_chunk - nr_consecutive)
	break;		break;
	}		}