Merge pull request #54 from andrewdavidmackenzie/fix_kmesg

Fix kmesg_buffer on macos - Fixes #39

Author: andrewdavidmackenzie

README.md

@@ -64,25 +64,15 @@ pub fn pidfdinfo<T: PIDFDInfo>(pid : i32, fd: i32) -> Result<T, String> (macos)
 pub fn pidrusage<T: PIDRUsage>(pid : i32) -> Result<T, String> (macos)
 ```
 
-## kmsgbuf
-I have also implemented this method - but the MAGIC_NUMBER returned is not correct, 
-and upon investigation it seems that Apple/Darwin/Mach have changed totally how dmessage works in 
-latest versions, moving away from using libproc to use kvm - with a total rewrite of dmesg.
-
-I leave it in for now, but some serious revision of the library, with conditional compilation depending on
-which version of Mac OS X and/or Darwin will be required to get a version that works broadly :-(
-
-See [Github issue](https://github.com/andrewdavidmackenzie/libproc-rs/issues/39)
-
+## Kernel Message Buffer - kmsgbuf
 ```
 pub fn kmsgbuf() -> Result<String, String>
 ```
 
 # Binaries
 `cargo build` builds the following binaries:
 - `procinfo` that takes a PID as an optional argument (uses it's own pid if none supplied) and returns information about the process on stdout
-- `dmesg` is a version of dmesg implemented in rust that uses libproc-rs. This must be run as root. Currently fails (see above and
-[bug](https://github.com/andrewdavidmackenzie/libproc-rs/issues/39)).
+- `dmesg` is a version of dmesg implemented in rust that uses libproc-rs.
 
 # Platforms
 Mac OS X and work started on Linux.

src/dmesg.rs

@@ -12,7 +12,8 @@ extern crate libc;
 use crate::libproc::libproc::kmesg_buffer;
 
 fn main() {
-    if let Ok(message) = kmesg_buffer::kmsgbuf() {
-        println!("{}", message);
+    match kmesg_buffer::kmsgbuf() {
+        Ok(message) => print!("{}", message),
+        Err(e) => eprintln!("{}", e)
     }
 }

src/libproc/kmesg_buffer.rs

@@ -2,15 +2,10 @@ extern crate errno;
 extern crate libc;
 
 #[cfg(target_os = "macos")]
-use std::fmt;
-#[cfg(target_os = "macos")]
-use std::{mem, ptr};
-
-#[cfg(target_os = "macos")]
-use crate::libproc::helpers;
+use std::str;
 
 #[cfg(target_os = "macos")]
-use self::libc::c_int;
+use self::libc::{c_int, c_void};
 
 #[cfg(target_os = "linux")]
 use std::fs::File;
@@ -23,101 +18,45 @@ use std::sync::mpsc::Receiver;
 #[cfg(target_os = "linux")]
 use std::{thread, time};
 
-
 // See https://opensource.apple.com/source/xnu/xnu-1456.1.26/bsd/sys/msgbuf.h
 #[cfg(target_os = "macos")]
-const MAX_MSG_BSIZE: c_int = 1024 * 1024;
-#[cfg(target_os = "macos")]
-const MSG_MAGIC: c_int = 0x063_061;
-
-// See /usr/include/sys/msgbuf.h on your Mac.
-#[cfg(target_os = "macos")]
-#[repr(C)]
-struct MessageBuffer {
-    pub msg_magic: c_int,
-    pub msg_size: c_int,
-    pub msg_bufx: c_int,
-    // write pointer
-    pub msg_bufr: c_int,
-    // read pointer
-    pub msg_bufc: *mut u8,     // buffer
-}
-
-#[cfg(target_os = "macos")]
-impl Default for MessageBuffer {
-    fn default() -> MessageBuffer {
-        MessageBuffer {
-            msg_magic: 0,
-            msg_size: 0,
-            msg_bufx: 0,
-            msg_bufr: 0,
-            msg_bufc: ptr::null_mut() as *mut u8,
-        }
-    }
-}
-
-#[cfg(target_os = "macos")]
-impl fmt::Debug for MessageBuffer {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "MessageBuffer {{ magic: 0x{:x}, size: {}, bufx: {}}}", self.msg_magic, self.msg_size, self.msg_bufx)
-    }
-}
+const MAX_MSG_BSIZE: usize = 1024 * 1024;
 
 // this extern block links to the libproc library
 // Original signatures of functions can be found at http://opensource.apple.com/source/Libc/Libc-594.9.4/darwin/libproc.c
 #[cfg(target_os = "macos")]
 #[link(name = "proc", kind = "dylib")]
 extern {
-    fn proc_kmsgbuf(buffer: *mut MessageBuffer, buffersize: u32) -> c_int;
+    fn proc_kmsgbuf(buffer: *mut c_void, buffersize: u32) -> c_int;
 }
 
 /// Get the contents of the kernel message buffer
 ///
 /// Entries are in the format:
 /// faclev,seqnum,timestamp[optional, ...];message\n
 ///  TAGNAME=value (0 or more Tags)
-// See http://opensource.apple.com//source/system_cmds/system_cmds-336.6/dmesg.tproj/dmesg.c
+// See http://opensource.apple.com//source/system_cmds/system_cmds-336.6/dmesg.tproj/dmesg.c// See http://opensource.apple.com//source/system_cmds/system_cmds-336.6/dmesg.tproj/dmesg.c
 #[cfg(target_os = "macos")]
 pub fn kmsgbuf() -> Result<String, String> {
-    let mut message_buffer: MessageBuffer = Default::default();
+    let mut message_buffer: Vec<u8> = Vec::with_capacity(MAX_MSG_BSIZE);
+    let buffer_ptr = message_buffer.as_mut_ptr() as *mut c_void;
     let ret: i32;
 
     unsafe {
-        ret = proc_kmsgbuf(&mut message_buffer, mem::size_of::<MessageBuffer>() as u32);
+        ret = proc_kmsgbuf(buffer_ptr, message_buffer.capacity() as u32);
+        if ret > 0 {
+            message_buffer.set_len(ret as usize - 1);
+        }
     }
 
-    if ret <= 0 {
-        Err(helpers::get_errno_with_message(ret))
-    } else if message_buffer.msg_magic != MSG_MAGIC {
-        println!("Message buffer: {:?}", message_buffer);
-        Err(format!("The magic number 0x{:x} is incorrect", message_buffer.msg_magic))
-    } else {
-        // Avoid starting beyond the end of the buffer
-        if message_buffer.msg_bufx >= MAX_MSG_BSIZE {
-            message_buffer.msg_bufx = 0;
-        }
-        let mut output: Vec<u8> = Vec::new();
-
-        // The message buffer is circular; start at the read pointer, and go to the write pointer - 1.
-        unsafe {
-            let mut ch: u8;
-            let mut p: *mut u8 = message_buffer.msg_bufc.offset(message_buffer.msg_bufx as isize);
-            let ep: *mut u8 = message_buffer.msg_bufc.offset((message_buffer.msg_bufx - 1) as isize);
-
-            while p != ep {
-                // If at the end, then loop around to the start
-                // TODO should use actual size (from struct element) - not the max size??
-                if p == message_buffer.msg_bufc.offset(MAX_MSG_BSIZE as isize) {
-                    p = message_buffer.msg_bufc;
-                }
-
-                ch = *p;
-                output.push(ch);
-                p = p.offset(1);
-            }
+    if !message_buffer.is_empty() {
+        let msg = str::from_utf8(&message_buffer)
+            .map_err(|_| "Could not convert kernel message buffer from utf8".to_string())?
+            .parse().unwrap();
 
-            Ok(String::from_utf8(output).map_err(|_| "Could not convert to UTF-8")?)
-        }
+        Ok(msg)
+    } else {
+        Err("Could not read kernel message buffer".to_string())
     }
 }
 
@@ -132,7 +71,7 @@ pub fn kmsgbuf() -> Result<String, String> {
     let duration = time::Duration::from_millis(1);
     let mut buf = String::new();
     while let Ok(line) = kmsg_channel.recv_timeout(duration) {
-            buf.push_str(&line)
+        buf.push_str(&line)
     }
 
     Ok(buf)
@@ -148,8 +87,8 @@ fn spawn_kmsg_channel(file: File) -> Receiver<String> {
         let mut line = String::new();
         match reader.read_line(&mut line) {
             Ok(_) => {
-                if tx.send(line).is_err() { break }
-            },
+                if tx.send(line).is_err() { break; }
+            }
             _ => break
         }
     });
@@ -167,14 +106,10 @@ mod test {
     use super::kmsgbuf;
 
     #[test]
-    #[ignore]
-    // TODO fix on macos: an error message is returned - https://github.com/andrewdavidmackenzie/libproc-rs/issues/39
-    // Message buffer: MessageBuffer { magic: 0x3a657461, size: 1986947360, bufx: 1684630625}
-    // thread 'libproc::kmesg_buffer::test::kmessagebuffer_test' panicked at 'The magic number 0x3a657461 is incorrect', src/libproc/kmesg_buffer.rs:194:33
     fn kmessagebuffer_test() {
         if am_root() {
             match kmsgbuf() {
-                Ok(buffer) => println!("Buffer: {:?}", buffer),
+                Ok(_) => { },
                 Err(message) => panic!(message)
             }
         } else {