From 0ff5752e9a8fddb862392ce66587bc8ebe8e1402 Mon Sep 17 00:00:00 2001
From: joannejchen <chenjjoanne@gmail.com>
Date: Sat, 15 Apr 2023 14:50:46 -0500
Subject: [PATCH] Change alignment of virtiofs structs to maximum alignment of
 all fields.

Alignment of the virtiofs struct was previously based on the alignment
of only the first field. Changed to explicitly use the maximum alignment of all of
the fields and added assertions to ensure this manually-allocated layout
matches the compiler-generated layout.

Fixes #691

Signed-off-by: joannejchen <chenjjoanne@gmail.com>
---
 src/fs/fuse.rs | 198 ++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 162 insertions(+), 36 deletions(-)

diff --git a/src/fs/fuse.rs b/src/fs/fuse.rs
index 6c6df6c72f..c1a0b83002 100644
--- a/src/fs/fuse.rs
+++ b/src/fs/fuse.rs
@@ -331,9 +331,15 @@ where
 
 fn create_init() -> (Box<Cmd<fuse_init_in>>, Box<Rsp<fuse_init_out>>) {
 	let len = core::mem::size_of::<fuse_in_header>() + core::mem::size_of::<fuse_init_in>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_in_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_in_header>(),
+			core::mem::align_of::<fuse_init_in>(),
+		),
+	);
 	let cmd = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Cmd<fuse_init_in>;
 		(*raw).header = create_in_header::<fuse_init_in>(FUSE_ROOT_ID, Opcode::FUSE_INIT);
 		(*raw).header.len = len.try_into().unwrap();
@@ -346,11 +352,18 @@ fn create_init() -> (Box<Cmd<fuse_init_in>>, Box<Rsp<fuse_init_out>>) {
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*cmd));
 
 	let len = core::mem::size_of::<fuse_out_header>() + core::mem::size_of::<fuse_init_out>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_out_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_out_header>(),
+			core::mem::align_of::<fuse_init_out>(),
+		),
+	);
 	let rsp = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Rsp<fuse_init_out>;
 		(*raw).header = fuse_out_header {
 			len: len.try_into().unwrap(),
@@ -359,6 +372,7 @@ fn create_init() -> (Box<Cmd<fuse_init_in>>, Box<Rsp<fuse_init_out>>) {
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*rsp));
 
 	(cmd, rsp)
 }
@@ -369,9 +383,15 @@ fn create_lookup(name: &str) -> (Box<Cmd<fuse_lookup_in>>, Box<Rsp<fuse_entry_ou
 		+ core::mem::size_of::<fuse_lookup_in>()
 		+ slice.len()
 		+ 1;
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_in_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_in_header>(),
+			core::mem::align_of::<fuse_lookup_in>(),
+		),
+	);
 	let cmd = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw =
 			core::ptr::slice_from_raw_parts_mut(data, slice.len() + 1) as *mut Cmd<fuse_lookup_in>;
 		(*raw).header = create_in_header::<fuse_lookup_in>(FUSE_ROOT_ID, Opcode::FUSE_LOOKUP);
@@ -381,11 +401,18 @@ fn create_lookup(name: &str) -> (Box<Cmd<fuse_lookup_in>>, Box<Rsp<fuse_entry_ou
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*cmd));
 
 	let len = core::mem::size_of::<fuse_out_header>() + core::mem::size_of::<fuse_entry_out>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_out_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_out_header>(),
+			core::mem::align_of::<fuse_entry_out>(),
+		),
+	);
 	let rsp = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Rsp<fuse_entry_out>;
 		(*raw).header = fuse_out_header {
 			len: len.try_into().unwrap(),
@@ -394,6 +421,7 @@ fn create_lookup(name: &str) -> (Box<Cmd<fuse_lookup_in>>, Box<Rsp<fuse_entry_ou
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*rsp));
 
 	(cmd, rsp)
 }
@@ -471,9 +499,15 @@ fn create_read(
 	offset: u64,
 ) -> (Box<Cmd<fuse_read_in>>, Box<Rsp<fuse_read_out>>) {
 	let len = core::mem::size_of::<fuse_in_header>() + core::mem::size_of::<fuse_read_in>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_in_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_in_header>(),
+			core::mem::align_of::<fuse_read_in>(),
+		),
+	);
 	let cmd = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Cmd<fuse_read_in>;
 		(*raw).header = create_in_header::<fuse_read_in>(nid, Opcode::FUSE_READ);
 		(*raw).cmd = fuse_read_in {
@@ -485,13 +519,20 @@ fn create_read(
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*cmd));
 
 	let len = core::mem::size_of::<fuse_out_header>()
 		+ core::mem::size_of::<fuse_read_out>()
 		+ usize::try_from(size).unwrap();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_out_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_out_header>(),
+			core::mem::align_of::<fuse_read_out>(),
+		),
+	);
 	let rsp = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, size.try_into().unwrap())
 			as *mut Rsp<fuse_read_out>;
 		(*raw).header = fuse_out_header {
@@ -501,6 +542,7 @@ fn create_read(
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*rsp));
 
 	(cmd, rsp)
 }
@@ -529,9 +571,15 @@ fn create_lseek(
 	whence: SeekWhence,
 ) -> (Box<Cmd<fuse_lseek_in>>, Box<Rsp<fuse_lseek_out>>) {
 	let len = core::mem::size_of::<fuse_in_header>() + core::mem::size_of::<fuse_lseek_in>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_in_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_in_header>(),
+			core::mem::align_of::<fuse_lseek_in>(),
+		),
+	);
 	let cmd = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Cmd<fuse_lseek_in>;
 		(*raw).header = fuse_in_header {
 			len: len.try_into().unwrap(),
@@ -549,11 +597,18 @@ fn create_lseek(
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*cmd));
 
 	let len = core::mem::size_of::<fuse_out_header>() + core::mem::size_of::<fuse_lseek_out>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_out_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_out_header>(),
+			core::mem::align_of::<fuse_lseek_out>(),
+		),
+	);
 	let rsp = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Rsp<fuse_lseek_out>;
 		(*raw).header = fuse_out_header {
 			len: len.try_into().unwrap(),
@@ -562,6 +617,7 @@ fn create_lseek(
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*rsp));
 
 	(cmd, rsp)
 }
@@ -596,9 +652,15 @@ fn create_write(
 ) -> (Box<Cmd<fuse_write_in>>, Box<Rsp<fuse_write_out>>) {
 	let len =
 		core::mem::size_of::<fuse_in_header>() + core::mem::size_of::<fuse_write_in>() + buf.len();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_in_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_in_header>(),
+			core::mem::align_of::<fuse_write_in>(),
+		),
+	);
 	let cmd = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, buf.len()) as *mut Cmd<fuse_write_in>;
 		(*raw).header = fuse_in_header {
 			len: len.try_into().unwrap(),
@@ -617,11 +679,18 @@ fn create_write(
 
 		Box::from_raw(raw)
 	};
+	// assert_eq!(layout.unwrap(), Layout::for_value(&*cmd));
 
 	let len = core::mem::size_of::<fuse_out_header>() + core::mem::size_of::<fuse_write_out>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_out_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_out_header>(),
+			core::mem::align_of::<fuse_write_out>(),
+		),
+	);
 	let rsp = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Rsp<fuse_write_out>;
 		(*raw).header = fuse_out_header {
 			len: len.try_into().unwrap(),
@@ -630,6 +699,7 @@ fn create_write(
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*rsp));
 
 	(cmd, rsp)
 }
@@ -655,9 +725,15 @@ unsafe impl FuseOut for fuse_open_out {}
 
 fn create_open(nid: u64, flags: u32) -> (Box<Cmd<fuse_open_in>>, Box<Rsp<fuse_open_out>>) {
 	let len = core::mem::size_of::<fuse_in_header>() + core::mem::size_of::<fuse_open_in>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_in_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_in_header>(),
+			core::mem::align_of::<fuse_open_in>(),
+		),
+	);
 	let cmd = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Cmd<fuse_open_in>;
 		(*raw).header = create_in_header::<fuse_open_in>(nid, Opcode::FUSE_OPEN);
 		(*raw).cmd = fuse_open_in {
@@ -667,11 +743,18 @@ fn create_open(nid: u64, flags: u32) -> (Box<Cmd<fuse_open_in>>, Box<Rsp<fuse_op
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*cmd));
 
 	let len = core::mem::size_of::<fuse_out_header>() + core::mem::size_of::<fuse_open_out>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_out_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_out_header>(),
+			core::mem::align_of::<fuse_open_out>(),
+		),
+	);
 	let rsp = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Rsp<fuse_open_out>;
 		(*raw).header = fuse_out_header {
 			len: len.try_into().unwrap(),
@@ -680,6 +763,7 @@ fn create_open(nid: u64, flags: u32) -> (Box<Cmd<fuse_open_in>>, Box<Rsp<fuse_op
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*rsp));
 
 	(cmd, rsp)
 }
@@ -702,9 +786,15 @@ unsafe impl FuseOut for fuse_release_out {}
 
 fn create_release(nid: u64, fh: u64) -> (Box<Cmd<fuse_release_in>>, Box<Rsp<fuse_release_out>>) {
 	let len = core::mem::size_of::<fuse_in_header>() + core::mem::size_of::<fuse_release_in>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_in_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_in_header>(),
+			core::mem::align_of::<fuse_release_in>(),
+		),
+	);
 	let cmd = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Cmd<fuse_release_in>;
 		(*raw).header = create_in_header::<fuse_release_in>(nid, Opcode::FUSE_RELEASE);
 		(*raw).cmd = fuse_release_in {
@@ -714,11 +804,18 @@ fn create_release(nid: u64, fh: u64) -> (Box<Cmd<fuse_release_in>>, Box<Rsp<fuse
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*cmd));
 
 	let len = core::mem::size_of::<fuse_out_header>() + core::mem::size_of::<fuse_release_out>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_out_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_out_header>(),
+			core::mem::align_of::<fuse_release_out>(),
+		),
+	);
 	let rsp = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Rsp<fuse_release_out>;
 		(*raw).header = fuse_out_header {
 			len: len.try_into().unwrap(),
@@ -727,6 +824,7 @@ fn create_release(nid: u64, fh: u64) -> (Box<Cmd<fuse_release_in>>, Box<Rsp<fuse
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*rsp));
 
 	(cmd, rsp)
 }
@@ -787,9 +885,15 @@ fn create_unlink(name: &str) -> (Box<Cmd<fuse_unlink_in>>, Box<Rsp<fuse_unlink_o
 		+ core::mem::size_of::<fuse_unlink_in>()
 		+ slice.len()
 		+ 1;
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_in_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_in_header>(),
+			core::mem::align_of::<fuse_unlink_in>(),
+		),
+	);
 	let cmd = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw =
 			core::ptr::slice_from_raw_parts_mut(data, slice.len() + 1) as *mut Cmd<fuse_unlink_in>;
 		(*raw).header = create_in_header::<fuse_unlink_in>(FUSE_ROOT_ID, Opcode::FUSE_UNLINK);
@@ -799,11 +903,18 @@ fn create_unlink(name: &str) -> (Box<Cmd<fuse_unlink_in>>, Box<Rsp<fuse_unlink_o
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*cmd));
 
 	let len = core::mem::size_of::<fuse_out_header>() + core::mem::size_of::<fuse_unlink_out>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_out_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_out_header>(),
+			core::mem::align_of::<fuse_unlink_out>(),
+		),
+	);
 	let rsp = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Rsp<fuse_unlink_out>;
 		(*raw).header = fuse_out_header {
 			len: len.try_into().unwrap(),
@@ -812,6 +923,7 @@ fn create_unlink(name: &str) -> (Box<Cmd<fuse_unlink_in>>, Box<Rsp<fuse_unlink_o
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*rsp));
 
 	(cmd, rsp)
 }
@@ -845,9 +957,15 @@ fn create_create(
 		+ core::mem::size_of::<fuse_create_in>()
 		+ slice.len()
 		+ 1;
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_in_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_in_header>(),
+			core::mem::align_of::<fuse_create_in>(),
+		),
+	);
 	let cmd = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw =
 			core::ptr::slice_from_raw_parts_mut(data, slice.len() + 1) as *mut Cmd<fuse_create_in>;
 		(*raw).header = create_in_header::<fuse_create_in>(FUSE_ROOT_ID, Opcode::FUSE_CREATE);
@@ -862,11 +980,18 @@ fn create_create(
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*cmd));
 
 	let len = core::mem::size_of::<fuse_out_header>() + core::mem::size_of::<fuse_create_out>();
-	let layout = Layout::from_size_align(len, core::mem::align_of::<fuse_out_header>());
+	let layout = Layout::from_size_align(
+		len,
+		core::cmp::max(
+			core::mem::align_of::<fuse_out_header>(),
+			core::mem::align_of::<fuse_create_out>(),
+		),
+	);
 	let rsp = unsafe {
-		let data = alloc(layout.unwrap());
+		let data = alloc(*layout.as_ref().unwrap());
 		let raw = core::ptr::slice_from_raw_parts_mut(data, 0) as *mut Rsp<fuse_create_out>;
 		(*raw).header = fuse_out_header {
 			len: len.try_into().unwrap(),
@@ -875,6 +1000,7 @@ fn create_create(
 
 		Box::from_raw(raw)
 	};
+	assert_eq!(layout.unwrap(), Layout::for_value(&*rsp));
 
 	(cmd, rsp)
 }