+use dlog::{BufferId, Priority};
+use dlog_sys::{log_id_t, log_priority};
+use dlogutil_sys::*;
+use libc::timespec;
+use std::ffi::CStr;
+use std::io::{Error, ErrorKind, Result};
+use std::ptr::{null, null_mut};
+use std::time::Duration;
+
+/// Enumeration for timestamp-based log sorting orderings.
+///
+/// For more detailed information on the timestamp documentation,
+/// refer to the C library documentation.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
+pub enum SortingOrder {
+ /// Monotonic timestamp applied by the sender.
+ SentMono,
+ /// Real-time timestamp applied by the sender.
+ SentReal,
+ /// Monotonic timestamp applied by the receiver.
+ RecvMono,
+ /// Real-time timestamp applied by the receiver.
+ RecvReal,
+ /// The default timestamp of the buffer. See [`buffer_get_default_ts_type`].
+ Default,
+}
+
+impl From<dlogutil_sorting_order> for SortingOrder {
+ fn from(c_enum: dlogutil_sorting_order) -> Self {
+ match c_enum {
+ dlogutil_sorting_order::DLOGUTIL_SORT_SENT_MONO => SortingOrder::SentMono,
+ dlogutil_sorting_order::DLOGUTIL_SORT_SENT_REAL => SortingOrder::SentReal,
+ dlogutil_sorting_order::DLOGUTIL_SORT_RECV_MONO => SortingOrder::RecvMono,
+ dlogutil_sorting_order::DLOGUTIL_SORT_RECV_REAL => SortingOrder::RecvReal,
+ dlogutil_sorting_order::DLOGUTIL_SORT_DEFAULT => SortingOrder::Default,
+ }
+ }
+}
+
+impl From<SortingOrder> for dlogutil_sorting_order {
+ fn from(rust_enum: SortingOrder) -> Self {
+ match rust_enum {
+ SortingOrder::SentMono => dlogutil_sorting_order::DLOGUTIL_SORT_SENT_MONO,
+ SortingOrder::SentReal => dlogutil_sorting_order::DLOGUTIL_SORT_SENT_REAL,
+ SortingOrder::RecvMono => dlogutil_sorting_order::DLOGUTIL_SORT_RECV_MONO,
+ SortingOrder::RecvReal => dlogutil_sorting_order::DLOGUTIL_SORT_RECV_REAL,
+ SortingOrder::Default => dlogutil_sorting_order::DLOGUTIL_SORT_DEFAULT,
+ }
+ }
+}
+
+/// A struct containing libdlogutil initialisation configuration.
+pub struct DlogutilConfig {
+ config: *mut dlogutil_config,
+}
+
+// SAFETY: it is ok to use the this object from different threads if only one thread
+// is using the memory at the time.
+unsafe impl Send for DlogutilConfig {}
+
+// SAFETY: the operations that do not modify the memory at all are ok to be used from
+// different threads at once, and those who do are marked as &mut.
+unsafe impl Sync for DlogutilConfig {}
+
+/// A struct containing the state of a log handling request.
+pub struct DlogutilState {
+ state: *mut dlogutil_state,
+}
+
+// SAFETY: it is ok to use the this object from different threads if only one thread
+// is using the memory at the time.
+unsafe impl Send for DlogutilState {}
+
+// SAFETY: the operations that do not modify the memory at all are ok to be used from
+// different threads at once, and those who do are marked as &mut.
+unsafe impl Sync for DlogutilState {}
+
+/// A struct containing the metadata and contents for a single dlog entry.
+pub struct DlogutilEntry {
+ entry: *mut dlogutil_entry,
+}
+
+// SAFETY: it is ok to use the this object from different threads if only one thread
+// is using the memory at the time.
+unsafe impl Send for DlogutilEntry {}
+
+// SAFETY: the operations that do not modify the memory at all are ok to be used from
+// different threads at once, and those who do are marked as &mut.
+unsafe impl Sync for DlogutilEntry {}
+
+impl Drop for DlogutilConfig {
+ fn drop(&mut self) {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ unsafe {
+ dlogutil_config_destroy(self.config);
+ }
+ }
+}
+
+impl Drop for DlogutilState {
+ fn drop(&mut self) {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ unsafe {
+ dlogutil_state_destroy(self.state);
+ }
+ }
+}
+
+impl Drop for DlogutilEntry {
+ fn drop(&mut self) {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ unsafe {
+ dlogutil_entry_destroy(self.entry);
+ }
+ }
+}
+
+impl DlogutilConfig {
+ /// Creates a new [`DlogutilConfig`] struct to be filled with configuration.
+ ///
+ /// Useful for dumping the logs of a specific thread in a multithreaded process.
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(Self)` - A handle to the config struct.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::OutOfMemory`] - Out of memory.
+ pub fn create() -> Result<Self> {
+ // SAFETY: the function is safe by itself. It returns either a valid pointer,
+ // in which case we return Ok, or NULL, in which case we return Err, which
+ // means that if Self is created, the inner pointer is guaranteed to be correct.
+ let config = unsafe { dlogutil_config_create() };
+ if config.is_null() {
+ return Err(Error::from(ErrorKind::OutOfMemory));
+ }
+ Ok(DlogutilConfig { config })
+ }
+
+ /// Enables retrieving only those logs that are logged by the thread with
+ /// the given TID.
+ ///
+ /// Useful for dumping the logs of a specific thread in a multithreaded process.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ /// * [`std::io::ErrorKind::OutOfMemory`] - Out of memory.
+ pub fn filter_tid(&mut self, tid: i32) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_filter_tid(self.config, tid) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Enables retrieving only those logs that are logged by the process with
+ /// the given PID.
+ ///
+ /// Useful for dumping the logs of a specific process.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ /// * [`std::io::ErrorKind::OutOfMemory`] - Out of memory.
+ pub fn filter_pid(&mut self, pid: i32) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_filter_pid(self.config, pid) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Enables retrieving only those logs that match a given filter.
+ ///
+ /// # Arguments
+ ///
+ /// * `query` - The filter query. For syntax, see dlogutil's --help.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - Invalid syntax of the filterspec.
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ /// * [`std::io::ErrorKind::OutOfMemory`] - Out of memory.
+ pub fn filter_filterspec(&mut self, query: &str) -> Result<()> {
+ let query = format!("{}\0", query);
+ let query_c =
+ CStr::from_bytes_with_nul(query.as_bytes()).map_err(|_| ErrorKind::InvalidInput)?;
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // The string is defined in a verified way above.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_filter_filterspec(self.config, query_c.as_ptr()) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Disables log sorting for given log retrieval request.
+ ///
+ /// Logs are still received in some order that is usually largely sorted,
+ /// but if sorting is disabled logutil-side there may be cases where a log
+ /// with a later timestamp is in front of a log with an earlier one.
+ /// The use case here is performance, since the failure case above is rare.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ pub fn sorting_disable(&mut self) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_sorting_disable(self.config) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Enables log sorting for given log retrieval request.
+ ///
+ /// This is the default and generally makes sure that logs are in order,
+ /// but has a modest performance cost.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ pub fn sorting_enable(&mut self) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_sorting_enable(self.config) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Enables sorting, choosing the sort buffer size manually.
+ ///
+ /// The count parameter influences the quality of sorting, but also memory usage.
+ /// This version is a somewhat lower level version of [`sorting_enable`].
+ /// For more information on sorting quality, refer to the C library documentation.
+ ///
+ /// [`sorting_enable`]: DlogutilConfig::sorting_enable
+ ///
+ /// # Arguments
+ ///
+ /// * `entry_count` - How many logs to keep at a given time. At least 1.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - Zero size.
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ pub fn sorting_enable_with_size(&mut self, entry_count: u32) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_sorting_enable_with_size(self.config, entry_count) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Chooses a timestamp type by which returned logs are sorted by.
+ ///
+ /// If the chosen timestamp is missing in the logs, currently they will not
+ /// be sorted at all. This should, however, still become a reasonable order,
+ /// since logs are usually stored sorted by one of timestamps. If only some
+ /// logs are missing the chosen timestamp, ordering of the logs is undefined.
+ /// See [`buffer_get_default_ts_type`] for the default.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ pub fn order_set(&mut self, sort_by: SortingOrder) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_order_set(self.config, sort_by.into()) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Adds a buffer whence logs will be taken to a request.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ pub fn buffer_add(&mut self, buf: BufferId) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_buffer_add(self.config, buf.into()) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Set log retrieval mode to retrieving all the logs since the start of
+ /// the system without an end.
+ ///
+ /// This is similar to `dlogutil` in a default mode.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ pub fn mode_set_continuous(&mut self) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_mode_set_continuous(self.config) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Set log retrieval mode to retrieving all the logs since the call
+ /// without an end.
+ ///
+ /// This is similar to `dlogutil -m`.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ pub fn mode_set_monitor(&mut self) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_mode_set_monitor(self.config) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Set log retrieval mode to dumping all the logs since the start of the
+ /// system until the call (possibly a specified amount of the most recent
+ /// of them instead).
+ ///
+ /// This is similar to `dlogutil -d`. After dumping all the logs,
+ /// [`get_log`] will signal this by returning `TIZEN_ERROR_NO_DATA`.
+ ///
+ /// [`get_log`]: DlogutilState::get_log
+ ///
+ /// # Arguments
+ ///
+ /// * `entry_count` - Number of logs to be returned. It can be
+ /// `DLOGUTIL_MAX_DUMP_SIZE`, in which case all the logs will be dumped.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ pub fn mode_set_dump(&mut self, entry_count: u32) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_config_mode_set_dump(self.config, entry_count) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Set log retrieval mode to dumping compressed historical logs.
+ ///
+ /// This is similar to `cat /var/log/dlog/xyz`. After dumping all the logs,
+ /// [`get_log`] will signal this by returning `TIZEN_ERROR_NO_DATA`.
+ ///
+ /// [`get_log`]: DlogutilState::get_log
+ ///
+ /// # Arguments
+ ///
+ /// * `compress_buffer` - The name of the compression storage entry.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::OutOfMemory`] - Not enough memory. Parameters left unchanged.
+ /// * [`std::io::ErrorKind::InvalidInput`] - The pointer was NULL.
+ pub fn mode_set_compressed_memory_dump(&mut self, compress_buffer: &str) -> Result<()> {
+ let compress_buffer = format!("{}\0", compress_buffer);
+ let compress_buffer_c = CStr::from_bytes_with_nul(compress_buffer.as_bytes())
+ .map_err(|_| ErrorKind::InvalidInput)?;
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // The string is defined in a verified way above.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe {
+ dlogutil_config_mode_set_compressed_memory_dump(self.config, compress_buffer_c.as_ptr())
+ } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+}
+
+impl DlogutilState {
+ /// Finalizes the config into a state struct by connecting to buffers.
+ ///
+ /// An application having platform privilege level can read platform log
+ /// data by declaring <http://tizen.org/privilege/log>.
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(Self)` - A handle to the state struct.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::InvalidInput`] - No buffers selected.
+ /// * [`std::io::ErrorKind::Uncategorized`] - Unsupported buffer set (KMSG + non-KMSG).
+ /// * [`std::io::ErrorKind::Uncategorized`] - Unsupported backend (zero-copy).
+ /// * [`std::io::ErrorKind::Uncategorized`] - No buffers were opened (incl. due to null backend).
+ /// * [`std::io::ErrorKind::Uncategorized`] - Couldn't read config file.
+ /// * [`std::io::ErrorKind::Uncategorized`] - Couldn't contact log backend.
+ /// * [`std::io::ErrorKind::OutOfMemory`] - There's not enough memory.
+ pub fn create(config: DlogutilConfig) -> Result<Self> {
+ let mut state = DlogutilState { state: null_mut() };
+ // SAFETY: the config pointer is guaranteed to be correct by the way it's created.
+ // Otherwise, the function is safe by itself. It returns either a valid pointer,
+ // in which case we return Ok, or NULL, in which case we return Err, which
+ // means that if Self is created, the inner pointer is guaranteed to be correct.
+ match unsafe { dlogutil_config_connect(config.config, &mut state.state) } {
+ 0 => Ok(state),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Retrieves a single log according to a dump request.
+ ///
+ /// Returns a returned log as a [`DlogutilEntry`] struct.
+ ///
+ /// If the calling process doesn't have `CAP_SYSLOG` and is not in the
+ /// log group, you will only get some of the logs.
+ /// Also, you must set the mode (`DlogutilConfig::mode_set_*`).
+ ///
+ /// [`DlogutilEntry`]: DlogutilEntry
+ ///
+ /// # Arguments
+ ///
+ /// * `timeout` - How many miliseconds to wait for the log.
+ /// The actual runtime of the call can obviously be slightly longer than
+ /// this argument. 0 means don't wait, None means wait indefinitely.
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(DlogutilEntry)` - A returned log.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::Uncategorized`] - Timeout exceeded.
+ /// * [`std::io::ErrorKind::Uncategorized`] - In dump mode, no more logs remaining.
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::InvalidInput`] - State not in log-getting mode.
+ /// * [`std::io::ErrorKind::OutOfMemory`] - There's not enough memory.
+ /// * [`std::io::ErrorKind::Uncategorized`] - Couldn't fulfill request.
+ pub fn get_log(&mut self, timeout: Option<Duration>) -> Result<DlogutilEntry> {
+ let mut entry_out = DlogutilEntry { entry: null_mut() };
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // The C function passes the ownership of the entry to the pointer iff the
+ // return value is nonzero, which is exactly the case in which we return
+ // the struct in an Ok. Since the function takes &mut, no other references can exist.
+ match unsafe {
+ dlogutil_get_log(
+ self.state,
+ timeout.map_or(-1, |t| t.as_millis() as i32),
+ &mut entry_out.entry,
+ )
+ } {
+ 0 => Ok(entry_out),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Irreversibly clears a log buffer from any logs inside.
+ ///
+ /// Either `CAP_SYSLOG` or being in the log group is required.
+ /// Also, you can't use one of the log-getting modes
+ /// (`DlogutilConfig::mode_set_*`).
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::Uncategorized`] - Couldn't fulfill request.
+ pub fn buffer_clear(&mut self, buffer: BufferId) -> Result<()> {
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Since the function takes &mut, no other references can exist.
+ match unsafe { dlogutil_buffer_clear(self.state, buffer.into()) } {
+ 0 => Ok(()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Gets the data storage capacity of a log buffer in bytes.
+ ///
+ /// Either `CAP_SYSLOG` or being in the log group is required.
+ /// Also, you can't use one of the log-getting modes
+ /// (`DlogutilConfig::mode_set_*`).
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(u32)` - The buffer's maximum capacity in bytes.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - State in log-getting mode.
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::Uncategorized`] - Couldn't fulfill request.
+ pub fn buffer_get_capacity(&mut self, buffer: BufferId) -> Result<u32> {
+ let mut capacity = 0;
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Note that it is not correct for this function to take a shared reference, as in case of
+ // the pipe backend, the function will write to a pipe and expect to read an answer
+ // immediately.
+ match unsafe { dlogutil_buffer_get_capacity(self.state, buffer.into(), &mut capacity) } {
+ 0 => Ok(capacity),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Gets the storage data usage of a log buffer in bytes.
+ ///
+ /// Either `CAP_SYSLOG` or being in the log group is required.
+ /// Also, you can't use one of the log-getting modes
+ /// (`DlogutilConfig::mode_set_*`).
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(u32)` - Buffer's current usage in bytes.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - State in log-getting mode.
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::Uncategorized`] - Couldn't fulfill request.
+ pub fn buffer_get_usage(&mut self, buffer: BufferId) -> Result<u32> {
+ let mut usage = 0;
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // Note that it is not correct for this function to take a shared reference, as in case of
+ // the pipe backend, the function will write to a pipe and expect to read an answer
+ // immediately.
+ match unsafe { dlogutil_buffer_get_usage(self.state, buffer.into(), &mut usage) } {
+ 0 => Ok(usage),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Gets the buffer aliasing (same storage) information.
+ ///
+ /// Sometimes, multiple buffers will be backed by a single log storage
+ /// (for example, by the same kernel device). In such cases, the storage
+ /// will only be opened once.
+ /// This function allows you to see whether this is the case.
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(BufferId)` - Buffer aliasing information.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ pub fn buffer_get_alias(&self, buffer: BufferId) -> Result<BufferId> {
+ let mut real_buffer = log_id_t::LOG_ID_MAIN;
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // This method only reads from the memory of the object, so it is ok for it to take
+ // a shared reference.
+ match unsafe { dlogutil_buffer_get_alias(self.state, buffer.into(), &mut real_buffer) } {
+ 0 => Ok(real_buffer.into()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+}
+
+impl DlogutilEntry {
+ /// Retrieves the timestamp of given type from the log entry.
+ ///
+ /// The information about timestamp availability can be retrieved using the
+ /// [`buffer_check_ts_type_available`] function.
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(Duration)` - Timestamp of the entry as a [`Duration`] struct.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// [`Duration`]: std::time::Duration
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - Invalid value of order.
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::Uncategorized`] - The timestamp is missing.
+ pub fn get_timestamp(&self, stamp_type: SortingOrder) -> Result<Duration> {
+ let mut ts = timespec {
+ tv_sec: 0,
+ tv_nsec: 0,
+ };
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // This method only reads from the memory of the object, so it is ok for it to take
+ // a shared reference.
+ match unsafe { dlogutil_entry_get_timestamp(self.entry, stamp_type.into(), &mut ts) } {
+ 0 => Ok(Duration::new(ts.tv_sec as u64, ts.tv_nsec as u32)),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Retrieves the TID (thread identificator) of the log sender.
+ ///
+ /// If [`LogIdKmsg`] is used as the buffer, this function will always return
+ /// `TIZEN_ERROR_NO_DATA`.
+ /// This is because the KMSG buffer contains no TID information.
+ ///
+ /// [`LogIdKmsg`]: BufferId::LogIdKmsg
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(i32)` - TID of the log sender.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::Uncategorized`] - TID is missing or not applicable.
+ pub fn get_tid(&self) -> Result<i32> {
+ let mut tid = 0;
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // This method only reads from the memory of the object, so it is ok for it to take
+ // a shared reference.
+ match unsafe { dlogutil_entry_get_tid(self.entry, &mut tid) } {
+ 0 => Ok(tid),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Retrieves the PID (process identificator) of the log sender.
+ ///
+ /// If [`LogIdKmsg`] is used as the buffer, this function will always return
+ /// `TIZEN_ERROR_NO_DATA`.
+ /// This is because the KMSG buffer contains no PID information.
+ ///
+ /// [`LogIdKmsg`]: BufferId::LogIdKmsg
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(i32)` - PID of the log sender.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::Uncategorized`] - PID is missing or not applicable.
+ pub fn get_pid(&self) -> Result<i32> {
+ let mut pid = 0;
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // This method only reads from the memory of the object, so it is ok for it to take
+ // a shared reference.
+ match unsafe { dlogutil_entry_get_pid(self.entry, &mut pid) } {
+ 0 => Ok(pid),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Retrieves the priority level metadata of the log entry.
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(Priority)` - Log priority.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::Uncategorized`] - The priority is missing.
+ pub fn get_priority(&self) -> Result<Priority> {
+ let mut prio = log_priority::DLOG_UNKNOWN;
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // This method only reads from the memory of the object, so it is ok for it to take
+ // a shared reference.
+ match unsafe { dlogutil_entry_get_priority(self.entry, &mut prio) } {
+ 0 => Ok(prio.into()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+
+ /// Retrieves the tag (arbitrary label) of the log entry.
+ ///
+ /// In some rare cases the entry may be malformed and the tag
+ /// may turn out to be unavailable.
+ ///
+ /// In such cases, an empty string may be returned instead.
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(&str)` - Log tag.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::Uncategorized`] - The tag is missing.
+ pub fn get_tag(&self) -> Result<&str> {
+ let mut tag_ptr = null();
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // The function returns either NULL, in which case we return Err,
+ // or a string with same lifetime as self.entry, in which case we can safely
+ // call CStr::from_ptr and return it in an Ok.
+ // This method only reads from the memory of the object, so it is ok for it to take
+ // a shared reference.
+ unsafe {
+ match dlogutil_entry_get_tag(self.entry, &mut tag_ptr) {
+ 0 => Ok(CStr::from_ptr(tag_ptr).to_str().unwrap()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+ }
+
+ /// Retrieves the message (without any metadata) of the log entry.
+ ///
+ /// In some rare cases the entry may be malformed and the message
+ /// may turn out to be unavailable.
+ ///
+ /// In such cases, an empty string may be returned instead.
+ ///
+ /// # Returns
+ ///
+ /// * `Ok(&str)` - Log message.
+ /// * `Err(std::io::Error)` - An error.
+ ///
+ /// # Errors
+ ///
+ /// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+ /// * [`std::io::ErrorKind::Uncategorized`] - The message is missing.
+ pub fn get_message(&self) -> Result<&str> {
+ let mut msg_ptr = null();
+ // SAFETY: the pointer is guaranteed to be correct by the way it's created.
+ // The function returns either NULL, in which case we return Err,
+ // or a string with same lifetime as self.entry, in which case we can safely
+ // call CStr::from_ptr and return it in an Ok.
+ // This method only reads from the memory of the object, so it is ok for it to take
+ // a shared reference.
+ unsafe {
+ match dlogutil_entry_get_message(self.entry, &mut msg_ptr) {
+ 0 => Ok(CStr::from_ptr(msg_ptr).to_str().unwrap()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+ }
+}
+
+/// Gets the human-readable, constant name of a buffer.
+///
+/// # Returns
+///
+/// * `Ok(&str)` - The name of the passed buffer.
+/// * `Err(std::io::Error)` - An error.
+///
+/// # Errors
+///
+/// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+pub fn buffer_get_name(buffer: BufferId) -> Result<&'static str> {
+ let mut name_ptr = null();
+ // SAFETY: the function is safe by itself provided the target is a valid pointer.
+ // The function returns either NULL, in which case we return Err,
+ // or a string with static lifetime, in which case we can safely call
+ // CStr::from_ptr and return it in an Ok.
+ unsafe {
+ match dlogutil_buffer_get_name(buffer.into(), &mut name_ptr) {
+ 0 => Ok(CStr::from_ptr(name_ptr).to_str().unwrap()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+ }
+}
+
+/// Gets the default sorting timestamp type of a buffer.
+///
+/// This is the timestamp type that will be used for sorting by default.
+/// We assume that it is always available and the input is sorted by it.
+///
+/// # Returns
+///
+/// * `Ok(SortingOrder)` - The default timestamp type of the passed buffer.
+/// * `Err(std::io::Error)` - An error.
+///
+/// # Errors
+///
+/// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+/// * [`std::io::ErrorKind::Uncategorized`] - Couldn't read config file.
+pub fn buffer_get_default_ts_type(buffer: BufferId) -> Result<SortingOrder> {
+ let mut typ = dlogutil_sorting_order::DLOGUTIL_SORT_SENT_MONO;
+ // SAFETY: the function is safe by itself provided the target is a valid pointer.
+ match unsafe { dlogutil_buffer_get_default_ts_type(buffer.into(), &mut typ) } {
+ 0 => Ok(typ.into()),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+}
+
+/// Checks if a buffer contains timestamps of a given type.
+///
+/// If false is returned, the timestamp may still be available in some of the logs.
+/// However, if true is returned, the timestamp will always be available.
+/// You can check the timestamp availability per log using the [`get_timestamp`]
+/// function.
+///
+/// [`get_timestamp`]: DlogutilEntry::get_timestamp
+///
+/// # Returns
+///
+/// * `Ok(bool)` - Whether the given timestamp type is guaranteed to be available.
+/// * `Err(std::io::Error)` - An error.
+///
+/// # Errors
+///
+/// * [`std::io::ErrorKind::InvalidInput`] - More than one buffer.
+/// * [`std::io::ErrorKind::InvalidInput`] - One of the pointers was NULL.
+/// * [`std::io::ErrorKind::Uncategorized`] - Couldn't read config file.
+pub fn buffer_check_ts_type_available(buffer: BufferId, stamp_type: SortingOrder) -> Result<bool> {
+ let mut available = false;
+ // SAFETY: the function is safe by itself provided the target is a valid pointer.
+ match unsafe {
+ dlogutil_buffer_check_ts_type_available(buffer.into(), stamp_type.into(), &mut available)
+ } {
+ 0 => Ok(available),
+ e => Err(Error::from_raw_os_error(-e)),
+ }
+}
projects / platform / core / system / rust-dlog.git / commitdiff