style changes

Author: Daksh14

tokio/src/fs/read_uring.rs

@@ -47,15 +47,15 @@ async fn read_to_end_uring(
 
     // if buffer has no room and no size_hint, start with a small probe_read from 0 offset
     if (size_hint.is_none() || size_hint == Some(0)) && buf.capacity() - buf.len() < (PROBE_SIZE) {
-        let (_size_read, _fd, _buf) = small_probe_read(fd, buf, offset).await?;
+        let (size_read, r_fd, r_buf) = small_probe_read(fd, buf, offset).await?;
 
-        if _size_read == 0 {
+        if size_read == 0 {
             return Ok(_buf);
         }
 
-        buf = _buf;
-        fd = _fd;
-        offset += _size_read as u64;
+        buf = r_buf;
+        fd = f_fd;
+        offset += size_read as u64;
     }
 
     loop {
@@ -64,15 +64,15 @@ async fn read_to_end_uring(
             // and see if it returns `Ok(0)`. If so, we've avoided an
             // unnecessary increasing of the capacity. But if not, append the
             // probe buffer to the primary buffer and let its capacity grow.
-            let (_size_read, _fd, _buf) = small_probe_read(fd, buf, offset).await?;
+            let (size_read, r_fd, r_buf) = small_probe_read(fd, buf, offset).await?;
 
-            if _size_read == 0 {
-                return Ok(_buf);
+            if size_read == 0 {
+                return Ok(r_buf);
             }
 
-            buf = _buf;
-            fd = _fd;
-            offset += _size_read as u64;
+            buf = r_buf;
+            fd = r_fd;
+            offset += size_read as u64;
         }
 
         // buf is full, need more capacity
@@ -102,26 +102,26 @@ async fn read_to_end_uring(
 
         loop {
             // read into spare capacity
-            let (res, _fd, mut _buf) = Op::read(fd, buf, read_len, offset).await;
+            let (res, r_fd, mut r_buf) = Op::read(fd, buf, read_len, offset).await;
 
             match res {
-                Ok(_size_read) => {
-                    if _size_read == 0 {
-                        return Ok(_buf);
+                Ok(size_read) => {
+                    if size_read == 0 {
+                        return Ok(r_buf);
                     }
 
-                    let size_read_usize = _size_read as usize;
+                    let size_read_usize = r_size_read as usize;
 
                     let new_len = size_read_usize + _buf.len();
                     // SAFETY: We didn't read more than what as reserved
                     // as capacity, the _size_read was initialized by the kernel
                     // via a mutable pointer
-                    unsafe { _buf.set_len(new_len) }
+                    unsafe { r_buf.set_len(new_len) }
 
-                    fd = _fd;
-                    buf = _buf;
-                    offset += _size_read as u64;
-                    read_len -= _size_read;
+                    fd = r_fd;
+                    buf = r_buf;
+                    offset += size_read as u64;
+                    read_len -= size_read;
 
                     // 1. In case of no size_hint and a large file, if we keep reading
                     // PROBE_SIZE, we want to increment number of short reads in order to gradually
@@ -143,8 +143,8 @@ async fn read_to_end_uring(
                 }
                 Err(e) => {
                     if e.kind() == ErrorKind::Interrupted {
-                        buf = _buf;
-                        fd = _fd;
+                        buf = r_buf;
+                        fd = r_fd;
 
                         continue;
                     } else {
@@ -166,24 +166,24 @@ async fn small_probe_read(
     buf.reserve_exact(PROBE_SIZE);
 
     loop {
-        let (res, _fd, mut _buf) = Op::read(fd, buf, PROBE_SIZE_U32, offset).await;
+        let (res, r_fd, mut r_buf) = Op::read(fd, buf, PROBE_SIZE_U32, offset).await;
 
         match res {
-            Ok(_size_read) => {
-                let size_read_usize = _size_read as usize;
+            Ok(size_read) => {
+                let size_read_usize = size_read as usize;
 
-                let new_len = size_read_usize + _buf.len();
+                let new_len = size_read_usize + r_buf.len();
                 // SAFETY: We didn't read more than what as reserved
                 // as capacity, the _size_read was initialized by the kernel
                 // via a mutable pointer
-                unsafe { _buf.set_len(new_len) }
+                unsafe { r_buf.set_len(new_len) }
 
-                return Ok((_size_read, _fd, _buf));
+                return Ok((r_size_read, r_fd, r_buf));
             }
             Err(e) => {
                 if e.kind() == ErrorKind::Interrupted {
-                    buf = _buf;
-                    fd = _fd;
+                    buf = r_buf;
+                    fd = r_fd;
 
                     continue;
                 } else {