scsir 0.3.0

A simple library for issuing SCSI commands
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use std::io;

use crate::{command::sense::SenseData, error};

#[cfg(target_os = "linux")]
use crate::os::linux::{DriverStatus, HostStatus};

#[derive(Debug)]
pub struct ResultData<'a, D> {
    pub(crate) ioctl_result: i32,
    pub(crate) transfered_data_length: usize,
    pub(crate) data: &'a mut D,
    pub(crate) transfered_sense_length: usize,
    pub(crate) sense_buffer: &'a SenseData,
    pub(crate) status: Status,
    #[cfg(target_os = "linux")]
    pub(crate) host_status: HostStatus,
    #[cfg(target_os = "linux")]
    pub(crate) driver_status: DriverStatus,
}

#[allow(dead_code)]
#[derive(Clone, Copy, Debug)]
pub enum Status {
    Good,
    CheckCondition,
    ConditionMet,
    Busy,
    ReservationConflict,
    TaskSetFull,
    AcaActive,
    TaskAborted,
    Unknown(u8),
}

impl<D> ResultData<'_, D> {
    pub fn check_common_error(&self) -> crate::Result<()> {
        let mut result = String::new();

        #[cfg(target_os = "linux")]
        {
            if !matches!(self.host_status, crate::os::linux::HostStatus::Ok) {
                result.push_str(&format!("host status: {:?}. ", self.host_status));
            }

            if !self.driver_status.is_empty() {
                result.push_str(&format!("driver status: {:?}. ", self.driver_status));
            }
        }

        if !matches!(self.status, Status::Good) {
            result.push_str(&format!("Status: {:?}. ", self.status));
        }

        if self.transfered_sense_length != 0 {
            result.push_str(&format!("Sense data: {:02X?}", self.sense_buffer));
        }

        if !result.is_empty() {
            return Err(crate::Error::Other(result));
        }

        Ok(())
    }

    pub fn check_ioctl_error(&self) -> crate::Result<()> {
        match self.ioctl_result {
            0 => Ok(()),
            _ => Err(error::Error::IO(io::Error::last_os_error())),
        }
    }

    pub fn ioctl_result(&self) -> i32 {
        self.ioctl_result
    }

    pub fn transfered_data_length(&self) -> usize {
        self.transfered_data_length
    }

    pub fn data(&self) -> &D {
        self.data
    }

    pub fn transfered_sense_length(&self) -> usize {
        self.transfered_sense_length
    }

    pub fn sense_buffer(&self) -> &SenseData {
        self.sense_buffer
    }
}

impl From<u8> for Status {
    fn from(value: u8) -> Self {
        match value {
            0x00 => Self::Good,
            0x02 => Self::CheckCondition,
            0x04 => Self::ConditionMet,
            0x08 => Self::Busy,
            0x18 => Self::ReservationConflict,
            0x28 => Self::TaskSetFull,
            0x30 => Self::AcaActive,
            0x40 => Self::TaskAborted,
            _ => Self::Unknown(value),
        }
    }
}