some current process/handle cleanup, use lazy statics for a number of variables

Author: vvuk

src/platform/windows/mod.rs

@@ -32,6 +32,9 @@ use winapi::{HANDLE, INVALID_HANDLE_VALUE, LPVOID};
 use kernel32;
 
 lazy_static! {
+    static ref CURRENT_PROCESS_ID: winapi::ULONG = unsafe { kernel32::GetCurrentProcessId() };
+    static ref CURRENT_PROCESS_HANDLE: intptr_t = unsafe { kernel32::GetCurrentProcess() as intptr_t };
+
     static ref DD_ENABLED: bool = match env::var_os("DD") {
         Some(_) => true,
         None => false,
@@ -181,7 +184,7 @@ fn dup_handle_to_process_with_flags(handle: HANDLE, other_process: HANDLE, flags
 
     unsafe {
         let mut new_handle: HANDLE = INVALID_HANDLE_VALUE;
-        let ok = kernel32::DuplicateHandle(kernel32::GetCurrentProcess(), handle,
+        let ok = kernel32::DuplicateHandle(*CURRENT_PROCESS_HANDLE as HANDLE, handle,
                                            other_process, &mut new_handle,
                                            0, winapi::FALSE, flags);
         if ok == winapi::FALSE {
@@ -276,6 +279,7 @@ impl WinHandle {
         WinHandle { h: h }
     }
 
+    #[allow(dead_code)]
     fn invalid() -> WinHandle {
         WinHandle { h: INVALID_HANDLE_VALUE }
     }
@@ -436,7 +440,7 @@ impl MessageReader {
                     return Ok(());
                 }
 
-                Err(WinError::last("ReadFile"))
+                Err(WinError::from_system(err, "ReadFile"))
             } else {
                 self.read_in_progress = true;
                 Ok(())
@@ -498,6 +502,11 @@ impl MessageReader {
             assert!(msg.channel_is_sender.len() == msg.channel_handles.len());
             assert!(msg.shmem_sizes.len() == msg.shmem_handles.len());
 
+            dd2!("[$ {:?}:{:?}] msg with total {} bytes, {} channels, {} shmems, big data handle 0x{:x}",
+                 self.iocp, self.handle, data_bytes,
+                 msg.channel_handles.len(), msg.shmem_handles.len(),
+                 msg.big_data_receiver_handle);
+
             for (handle, is_sender) in msg.channel_handles.iter().zip(msg.channel_is_sender.iter()) {
                 channels.push(OsOpaqueIpcChannel::new(*is_sender, *handle as HANDLE));
             }
@@ -507,8 +516,9 @@ impl MessageReader {
             }
 
             if msg.big_data_receiver_handle != 0 {
+                dd2!("[$ {:?}:{:?}] read msg with big data, rec handle {:?}", self.iocp, self.handle, msg.big_data_receiver_handle as HANDLE);
                 let receiver = OsIpcReceiver::from_handle(msg.big_data_receiver_handle as HANDLE);
-                let big_msg = try!(receiver.recv().map_err(|_| panic!("Failed to receive subchannel big data")));
+                let big_msg = try!(receiver.recv().map_err(|err| panic!("Failed to receive subchannel big data: {:?}", err)));
                 buf_data = big_msg.0;
             }
         }
@@ -561,6 +571,8 @@ impl Drop for OsIpcReceiver {
 }
 
 impl OsIpcReceiver {
+    // We can't just use an anonymous pipe via CreatePipe(), even though
+    // that creation is faster -- we a pipe created with FILE_FLAG_OVERLAPPED.
     fn new() -> Result<OsIpcReceiver,WinError> {
         let mut r = try!(OsIpcReceiver::new_named());
         let pipe_id = mem::replace(&mut r.pipe_id, None).unwrap();
@@ -580,6 +592,8 @@ impl OsIpcReceiver {
 
     fn new_named() -> Result<OsIpcReceiver,WinError> {
         unsafe {
+            // FIXME make_pipe_id is a big performance cost.  We need
+            // a more efficient way of generating pipe IDs.
             let pipe_id = make_pipe_id();
             let pipe_name = make_pipe_name(&pipe_id);
 
@@ -871,12 +885,26 @@ impl OsIpcSender {
         }
     }
 
-    fn get_pipe_server_process_handle(&self) -> Result<WinHandle,WinError> {
+    fn get_pipe_server_process_id(&self) -> Result<winapi::ULONG,WinError> {
         unsafe {
             let mut server_pid: winapi::ULONG = 0;
             if kernel32::GetNamedPipeServerProcessId(*self.handle, &mut server_pid) == winapi::FALSE {
                 return Err(WinError::last("GetNamedPipeServerProcessId"));
             }
+            Ok(server_pid)
+        }
+    }
+
+    // TODO(vlad): if we could guarantee that a server handle can't be passed
+    // after it's already been used to start receiving data, we could
+    // store the server handle instead of needing to look it up each time.
+    fn get_pipe_server_process_handle(&self) -> Result<WinHandle,WinError> {
+        unsafe {
+            let server_pid = try!(self.get_pipe_server_process_id());
+            if server_pid == *CURRENT_PROCESS_ID {
+                return Ok(WinHandle::new(*CURRENT_PROCESS_HANDLE as HANDLE));
+            }
+
             let raw_handle = kernel32::OpenProcess(winapi::PROCESS_DUP_HANDLE,
                                                    winapi::FALSE,
                                                    server_pid as winapi::DWORD);
@@ -903,12 +931,17 @@ impl OsIpcSender {
     // creates.
     fn send_unfragmented(&self, data: &[u8]) -> Result<(),WinError> {
         assert!(data.len() < INVALID_HEADER_DATA_SIZE as usize);
+
+        dd2!("[c {:?}] writing unfragmented to (pid {}->{})", *self.handle, *CURRENT_PROCESS_ID,
+             try!(self.get_pipe_server_process_id()));
+
         unsafe {
             let header: [u32; 2] = [ data.len() as u32, 0 ];
             let header_bytes: &[u8] = slice::from_raw_parts(header.as_ptr() as *const u8, HEADER_SIZE);
             try!(write_buf(*self.handle, &header_bytes));
             try!(write_buf(*self.handle, data));
         }
+        dd2!("[c {:?}] sent unfragmented: {} bytes", *self.handle, data.len());
         Ok(())
     }
 
@@ -976,7 +1009,10 @@ impl OsIpcSender {
         unsafe {
             // if we need to use the fragment channel, then we send a 0 as the data size;
             // the receiver will see that there's a big data receiver in the OOB portion
-            let header: [u32; 2] = [ if big_data_sender.is_some() { 0 } else { data.len() } as u32, oob_data.len() as u32];
+            let header: [u32; 2] = [
+                if big_data_sender.is_some() { 0 } else { data.len() } as u32,
+                oob_data.len() as u32
+            ];
             let header_bytes: &[u8] = slice::from_raw_parts(header.as_ptr() as *const u8, HEADER_SIZE);
 
             // We need to write the main message first, which will indicate to the receiver
@@ -988,6 +1024,8 @@ impl OsIpcSender {
             }
             try!(write_buf(*self.handle, &oob_data));
             if big_data_sender.is_some() {
+                dd2!("[c {:?}] sending unfragmented to big-data channel: {} bytes",
+                     *self.handle, data.len());
                 try!(big_data_sender.unwrap().send_unfragmented(data));
             }
         }
@@ -1435,7 +1473,6 @@ impl From<WinError> for DeserializeError {
 
 impl From<WinError> for Error {
     fn from(mpsc_error: WinError) -> Error {
-        //Error::new(ErrorKind::Other, format!("Win channel error ({} from {})", mpsc_error.0, mpsc_error.1))
-        Error::new(ErrorKind::Other, format!("Win channel error ({})", mpsc_error.0))
+        Error::new(ErrorKind::Other, format!("Win channel error ({}=0x{:x})", mpsc_error.0, mpsc_error.0))
     }
 }