Warn on clippy::cast_possible_truncation

Fixes#3197 Signed-off-by: Jonathan Browne <12983479+JBYoshi@users.noreply.github.com>

Author: JBYoshi

.cargo/config

@@ -5,6 +5,7 @@ rustflags = [
  "-Dclippy::ptr_as_ptr",
  "-Dclippy::undocumented_unsafe_blocks",
  "-Dclippy::cast_lossless",
+ "-Dclippy::cast_possible_truncation",
  "-Dclippy::cast_sign_loss"
 ]
 

src/devices/src/bus.rs

@@ -167,13 +167,13 @@ mod tests {
 implBusDeviceforConstantDevice{
 fnread(&mutself,offset:u64,data:&mut[u8]){
 for(i, v)in data.iter_mut().enumerate(){
-*v = (offsetasu8) + (i asu8);
+*v = u8::try_from(offset).unwrap() + u8::try_from(i).unwrap();
 }
 }
 
 fnwrite(&mutself,offset:u64,data:&[u8]){
 for(i, v)in data.iter().enumerate(){
-assert_eq!(*v,(offsetasu8) + (i asu8))
+assert_eq!(*v,u8::try_from(offset).unwrap() + u8::try_from(i).unwrap())
 }
 }
 }

src/devices/src/legacy/i8042.rs

@@ -415,7 +415,7 @@ mod tests {
 
 // Test buffer full.
 for i in0..BUF_SIZE{
- i8042.push_byte(i asu8).unwrap();
+ i8042.push_byte(u8::try_from(i).unwrap()).unwrap();
 assert_eq!(i8042.buf_len(), i + 1);
 }
 assert_eq!(i8042.push_byte(0).unwrap_err(),Error::InternalBufferFull);

src/devices/src/legacy/rtc_pl031.rs

@@ -16,7 +16,7 @@ impl BusDevice for RTCDevice {
 if data.len() == 4{
 // read() function from RTC implementation expects a slice of
 // len 4, and we just validated that this is the data lengt
-self.read(offset asu16, data.try_into().unwrap())
+self.read(u16::try_from(offset).unwrap(), data.try_into().unwrap())
 }else{
 warn!(
 "Found invalid data length while trying to read from the RTC: {}",
@@ -30,7 +30,7 @@ impl BusDevice for RTCDevice {
 if data.len() == 4{
 // write() function from RTC implementation expects a slice of
 // len 4, and we just validated that this is the data length
-self.write(offset asu16, data.try_into().unwrap())
+self.write(u16::try_from(offset).unwrap(), data.try_into().unwrap())
 }else{
 warn!(
 "Found invalid data length while trying to write to the RTC: {}",

src/devices/src/legacy/serial.rs

@@ -272,15 +272,15 @@ impl<W: Write + Send + 'static> BusDevice
 self.serial.events().metrics.missed_read_count.inc();
 return;
 }
- data[0] = self.serial.read(offset asu8);
+ data[0] = self.serial.read(u8::try_from(offset).unwrap());
 }
 
 fnwrite(&mutself,offset:u64,data:&[u8]){
 if data.len() != 1{
 self.serial.events().metrics.missed_write_count.inc();
 return;
 }
-ifletErr(err) = self.serial.write(offset asu8, data[0]){
+ifletErr(err) = self.serial.write(u8::try_from(offset).unwrap(), data[0]){
 // Counter incremented for any handle_write() error.
 error!("Failed the write to serial: {:?}", err);
 self.serial.events().metrics.error_count.inc();

src/devices/src/virtio/balloon/device.rs

@@ -545,7 +545,8 @@ impl VirtioDevice for Balloon {
 ifletSome(end) = offset.checked_add(data.len()asu64){
 // This write can't fail, offset and end are checked against config_len.
  data.write_all(
-&config_space_bytes[offset asusize..cmp::min(end, config_len)asusize],
+&config_space_bytes[usize::try_from(offset).unwrap()
+ ..usize::try_from(cmp::min(end, config_len)).unwrap()],
 )
 .unwrap();
 }
@@ -559,7 +560,9 @@ impl VirtioDevice for Balloon {
 error!("Failed to write config space");
 return;
 }
- config_space_bytes[offset asusize..(offset + data_len)asusize].copy_from_slice(data);
+ config_space_bytes
+[usize::try_from(offset).unwrap()..usize::try_from(offset + data_len).unwrap()]
+.copy_from_slice(data);
 }
 
 fnactivate(&mutself,mem:GuestMemoryMmap) -> ActivateResult{
@@ -689,7 +692,10 @@ pub(crate) mod tests {
  | (u64::from(*deflate_on_oom) << VIRTIO_BALLOON_F_DEFLATE_ON_OOM)
  | ((u64::from(*stats_interval)) << VIRTIO_BALLOON_F_STATS_VQ);
 
-assert_eq!(balloon.avail_features_by_page(0), features asu32);
+assert_eq!(
+ balloon.avail_features_by_page(0),
+(features &0xffff_ffff)asu32
+);
 assert_eq!(balloon.avail_features_by_page(1),(features >> 32)asu32);
 for i in2..10{
 assert_eq!(balloon.avail_features_by_page(i),0u32);
@@ -780,7 +786,7 @@ pub(crate) mod tests {
 &infq,
 0,
  page_addr,
-SIZE_OF_U32asu32,
+ u32::try_from(SIZE_OF_U32).unwrap(),
 VIRTQ_DESC_F_NEXT | VIRTQ_DESC_F_WRITE,
 );
 
@@ -800,7 +806,7 @@ pub(crate) mod tests {
 &infq,
 1,
  page_addr,
-SIZE_OF_U32asu32 + 1,
+ u32::try_from(SIZE_OF_U32).unwrap() + 1,
 VIRTQ_DESC_F_NEXT,
 );
 
@@ -835,7 +841,13 @@ pub(crate) mod tests {
 // to trigger the inflate event queue.
 {
  mem.write_obj::<u32>(0x1,GuestAddress(page_addr)).unwrap();
-set_request(&infq,0, page_addr,SIZE_OF_U32asu32,VIRTQ_DESC_F_NEXT);
+set_request(
+&infq,
+0,
+ page_addr,
+ u32::try_from(SIZE_OF_U32).unwrap(),
+VIRTQ_DESC_F_NEXT,
+);
 
 check_metric_after_block!(
 METRICS.balloon.event_fails,
@@ -856,7 +868,13 @@ pub(crate) mod tests {
 // Test the happy case.
 {
  mem.write_obj::<u32>(0x1,GuestAddress(page_addr)).unwrap();
-set_request(&infq,0, page_addr,SIZE_OF_U32asu32,VIRTQ_DESC_F_NEXT);
+set_request(
+&infq,
+0,
+ page_addr,
+ u32::try_from(SIZE_OF_U32).unwrap(),
+VIRTQ_DESC_F_NEXT,
+);
 
 check_metric_after_block!(
 METRICS.balloon.inflate_count,
@@ -884,7 +902,13 @@ pub(crate) mod tests {
 
 // Error case: forgot to trigger deflate event queue.
 {
-set_request(&defq,0, page_addr,SIZE_OF_U32asu32,VIRTQ_DESC_F_NEXT);
+set_request(
+&defq,
+0,
+ page_addr,
+ u32::try_from(SIZE_OF_U32).unwrap(),
+VIRTQ_DESC_F_NEXT,
+);
 check_metric_after_block!(
 METRICS.balloon.event_fails,
 1,
@@ -898,7 +922,13 @@ pub(crate) mod tests {
 
 // Happy case.
 {
-set_request(&defq,1, page_addr,SIZE_OF_U32asu32,VIRTQ_DESC_F_NEXT);
+set_request(
+&defq,
+1,
+ page_addr,
+ u32::try_from(SIZE_OF_U32).unwrap(),
+VIRTQ_DESC_F_NEXT,
+);
 check_metric_after_block!(
 METRICS.balloon.deflate_count,
 1,
@@ -920,7 +950,13 @@ pub(crate) mod tests {
 
 // Error case: forgot to trigger stats event queue.
 {
-set_request(&statsq,0,0x1000,SIZE_OF_STATasu32,VIRTQ_DESC_F_NEXT);
+set_request(
+&statsq,
+0,
+0x1000,
+ u32::try_from(SIZE_OF_STAT).unwrap(),
+VIRTQ_DESC_F_NEXT,
+);
 check_metric_after_block!(
 METRICS.balloon.event_fails,
 1,
@@ -956,7 +992,7 @@ pub(crate) mod tests {
 &statsq,
 0,
  page_addr,
-2*SIZE_OF_STATasu32,
+u32::try_from(2*SIZE_OF_STAT).unwrap(),
 VIRTQ_DESC_F_NEXT,
 );
 check_metric_after_block!(METRICS.balloon.stats_updates_count,1,{

src/devices/src/virtio/balloon/test_utils.rs

@@ -29,18 +29,18 @@ pub fn invoke_handler_for_queue_event(b: &mut Balloon, queue_index: usize) {
 
 pubfnset_request(queue:&VirtQueue,idx:usize,addr:u64,len:u32,flags:u16){
 // Set the index of the next request.
- queue.avail.idx.set((idx + 1)asu16);
+ queue.avail.idx.set(u16::try_from(idx + 1).unwrap());
 // Set the current descriptor table entry index.
- queue.avail.ring[idx].set(idx asu16);
+ queue.avail.ring[idx].set(u16::try_from(idx).unwrap());
 // Set the current descriptor table entry.
  queue.dtable[idx].set(addr, len, flags,1);
 }
 
 pubfncheck_request_completion(queue:&VirtQueue,idx:usize){
 // Check that the next used will be idx + 1.
-assert_eq!(queue.used.idx.get(),(idx + 1)asu16);
+assert_eq!(usize::from(queue.used.idx.get()),idx + 1);
 // Check that the current used is idx.
-assert_eq!(queue.used.ring[idx].get().id, idxasu32);
+assert_eq!(usize::try_from(queue.used.ring[idx].get().id).unwrap(), idx);
 // The length of the completed request is 0.
 assert_eq!(queue.used.ring[idx].get().len,0);
 }

src/devices/src/virtio/balloon/utils.rs

@@ -88,7 +88,7 @@ pub(crate) fn remove_range(
 let ret = unsafe{
  libc::mmap(
  phys_address.cast(),
-range_len asusize,
+ usize::try_from(range_len).unwrap(),
  libc::PROT_READ | libc::PROT_WRITE,
  libc::MAP_FIXED | libc::MAP_ANONYMOUS | libc::MAP_PRIVATE,
  -1,
@@ -103,7 +103,7 @@ pub(crate) fn remove_range(
 // Madvise the region in order to mark it as not used.
 // SAFETY: The address and length are known to be valid.
 let ret = unsafe{
-let range_len = range_len asusize;
+let range_len = usize::try_from(range_len).unwrap();
  libc::madvise(phys_address.cast(), range_len, libc::MADV_DONTNEED)
 };
 if ret < 0{

src/devices/src/virtio/block/device.rs

@@ -175,6 +175,8 @@ impl DiskProperties {
 // The config space is little endian.
 letmut config = Vec::with_capacity(CONFIG_SPACE_SIZE);
 for i in0..CONFIG_SPACE_SIZE{
+// `as` truncates large integers into smaller integers, here this is intentional
+#[allow(clippy::cast_possible_truncation)]
  config.push((self.nsectors >> (8* i))asu8);
 }
  config
@@ -569,8 +571,11 @@ impl VirtioDevice for Block {
 }
 ifletSome(end) = offset.checked_add(data.len()asu64){
 // This write can't fail, offset and end are checked against config_len.
- data.write_all(&self.config_space[offset asusize..cmp::min(end, config_len)asusize])
-.unwrap();
+ data.write_all(
+&self.config_space[usize::try_from(offset).unwrap()
+ ..usize::try_from(cmp::min(end, config_len)).unwrap()],
+)
+.unwrap();
 }
 }
 
@@ -583,7 +588,9 @@ impl VirtioDevice for Block {
 return;
 }
 
-self.config_space[offset asusize..(offset + data_len)asusize].copy_from_slice(data);
+self.config_space
+[usize::try_from(offset).unwrap()..usize::try_from(offset + data_len).unwrap()]
+.copy_from_slice(data);
 }
 
 fnactivate(&mutself,mem:GuestMemoryMmap) -> ActivateResult{
@@ -666,7 +673,7 @@ pub(crate) mod tests {
 let cfg = disk_properties.virtio_block_config_space();
 assert_eq!(cfg.len(),CONFIG_SPACE_SIZE);
 for(i, byte)in cfg.iter().enumerate(){
-assert_eq!(*byte,(num_sectors >> (8* i))asu8);
+assert_eq!(*byte,((num_sectors >> (8* i))&0xff)asu8);
 }
 // Testing `backing_file.virtio_block_disk_image_id()` implies
 // duplicating that logic in tests, so skipping it.
@@ -688,7 +695,10 @@ pub(crate) mod tests {
 
 let features:u64 = (1u64 << VIRTIO_F_VERSION_1) | (1u64 << VIRTIO_RING_F_EVENT_IDX);
 
-assert_eq!(block.avail_features_by_page(0), features asu32);
+assert_eq!(
+ block.avail_features_by_page(0),
+(features &0xffff_ffff)asu32
+);
 assert_eq!(block.avail_features_by_page(1),(features >> 32)asu32);
 
 for i in2..10{
@@ -808,8 +818,8 @@ pub(crate) mod tests {
 let status_addr = GuestAddress(vq.dtable[2].addr.get());
 assert_eq!(used.len,1);
 assert_eq!(
- mem.read_obj::<u8>(status_addr).unwrap(),
-VIRTIO_BLK_S_IOERRasu8
+u32::from(mem.read_obj::<u8>(status_addr).unwrap()),
+VIRTIO_BLK_S_IOERR
 );
 }
 
@@ -833,8 +843,8 @@ pub(crate) mod tests {
 let status_addr = GuestAddress(vq.dtable[2].addr.get());
 assert_eq!(used.len,1);
 assert_eq!(
- mem.read_obj::<u8>(status_addr).unwrap(),
-VIRTIO_BLK_S_IOERRasu8
+u32::from(mem.read_obj::<u8>(status_addr).unwrap()),
+VIRTIO_BLK_S_IOERR
 );
 }
 }
@@ -1020,8 +1030,8 @@ pub(crate) mod tests {
 
 let status_addr = GuestAddress(vq.dtable[2].addr.get());
 assert_eq!(
- mem.read_obj::<u8>(status_addr).unwrap(),
-VIRTIO_BLK_S_IOERRasu8
+u32::from(mem.read_obj::<u8>(status_addr).unwrap()),
+VIRTIO_BLK_S_IOERR
 );
 }
 
@@ -1241,8 +1251,8 @@ pub(crate) mod tests {
 
 let status_addr = GuestAddress(vq.dtable[2].addr.get());
 assert_eq!(
- mem.read_obj::<u8>(status_addr).unwrap(),
-VIRTIO_BLK_S_IOERRasu8
+u32::from(mem.read_obj::<u8>(status_addr).unwrap()),
+VIRTIO_BLK_S_IOERR
 );
 }
 }
@@ -1402,10 +1412,12 @@ pub(crate) mod tests {
 let status_addr = vq.dtable[used.idasusize + 1].addr.get();
 assert_eq!(used.len,1);
 assert_eq!(
- vq.memory()
-.read_obj::<u8>(GuestAddress(status_addr))
-.unwrap(),
-VIRTIO_BLK_S_OKasu8
+u32::from(
+ vq.memory()
+.read_obj::<u8>(GuestAddress(status_addr))
+.unwrap()
+),
+VIRTIO_BLK_S_OK
 );
 }
 }

src/devices/src/virtio/block/io/mod.rs

@@ -241,14 +241,14 @@ pub mod tests {
 fncheck_dirty_mem(mem:&GuestMemoryMmap,addr:GuestAddress,len:u32){
 let bitmap = mem.find_region(addr).unwrap().bitmap().as_ref().unwrap();
 for offset in addr.0..addr.0 + u64::from(len){
-assert!(bitmap.dirty_at(offset asusize));
+assert!(bitmap.dirty_at(usize::try_from(offset).unwrap()));
 }
 }
 
 fncheck_clean_mem(mem:&GuestMemoryMmap,addr:GuestAddress,len:u32){
 let bitmap = mem.find_region(addr).unwrap().bitmap().as_ref().unwrap();
 for offset in addr.0..addr.0 + u64::from(len){
-assert!(!bitmap.dirty_at(offset asusize));
+assert!(!bitmap.dirty_at(usize::try_from(offset).unwrap()));
 }
 }
 
@@ -287,16 +287,13 @@ pub mod tests {
 .to_vec();
 
 // Partial write
-let partial_len = 50;
-let addr = GuestAddress(MEM_LENasu64- partial_len);
+let partial_len = 50u32;
+let addr = GuestAddress(u64::try_from(MEM_LEN - partial_lenasusize).unwrap());
  mem.write(&data, addr).unwrap();
-assert_sync_execution!(
- engine.write(0,&mem, addr,FILE_LEN,()),
- partial_len asu32
-);
+assert_sync_execution!(engine.write(0,&mem, addr,FILE_LEN,()), partial_len);
 // Partial read
 let mem = create_mem();
-assert_sync_execution!(engine.read(0,&mem, addr,FILE_LEN,()), partial_lenasu32);
+assert_sync_execution!(engine.read(0,&mem, addr,FILE_LEN,()), partial_len);
 // Check data
 letmut buf = vec![0u8; partial_len asusize];
  mem.read_slice(&mut buf, addr).unwrap();