src/tools/sgutils2.rs

   1 //! Bindings for libsgutils2
   2 //!
   3 //! Incomplete, but we currently do not need more.
   4 //!
   5 //! See: `/usr/include/scsi/sg_pt.h`
   6
   7 use std::os::unix::io::AsRawFd;
   8
   9 use anyhow::{bail, Error};
  10 use libc::{c_char, c_int};
  11
  12 // Opaque wrapper for sg_pt_base
  13 #[repr(C)]
  14 struct SgPtBase { _private: [u8; 0] }
  15
  16 impl Drop for SgPtBase  {
  17     fn drop(&mut self) {
  18         unsafe { destruct_scsi_pt_obj(self as *mut SgPtBase) };
  19     }
  20 }
  21
  22 pub const SCSI_PT_RESULT_GOOD:c_int = 0;
  23 pub const SCSI_PT_RESULT_STATUS:c_int = 1;
  24 pub const SCSI_PT_RESULT_SENSE:c_int = 2;
  25 pub const SCSI_PT_RESULT_TRANSPORT_ERR:c_int = 3;
  26 pub const SCSI_PT_RESULT_OS_ERR:c_int = 4;
  27
  28 #[link(name = "sgutils2")]
  29 extern {
  30
  31     #[allow(dead_code)]
  32     fn scsi_pt_open_device(
  33         device_name: * const c_char,
  34         read_only: bool,
  35         verbose: c_int,
  36     ) -> c_int;
  37
  38     fn sg_is_scsi_cdb(
  39         cdbp: *const u8,
  40         clen: c_int,
  41     ) -> bool;
  42
  43     fn construct_scsi_pt_obj() -> *mut SgPtBase;
  44     fn destruct_scsi_pt_obj(objp: *mut SgPtBase);
  45
  46     fn set_scsi_pt_data_in(
  47         objp: *mut SgPtBase,
  48         dxferp: *const u8,
  49         dxfer_ilen: c_int,
  50     );
  51
  52     fn set_scsi_pt_data_out(
  53         objp: *mut SgPtBase,
  54         dxferp: *const u8,
  55         dxfer_olen: c_int,
  56     );
  57
  58     fn set_scsi_pt_cdb(
  59         objp: *mut SgPtBase,
  60         cdb: *const u8,
  61         cdb_len: c_int,
  62     );
  63
  64     fn set_scsi_pt_sense(
  65         objp: *mut SgPtBase,
  66         sense: *const u8,
  67         max_sense_len: c_int,
  68     );
  69
  70     fn do_scsi_pt(
  71         objp: *mut SgPtBase,
  72         fd: c_int,
  73         timeout_secs: c_int,
  74         verbose: c_int,
  75     ) -> c_int;
  76
  77     fn get_scsi_pt_resid(objp: *const SgPtBase) -> c_int;
  78
  79     fn get_scsi_pt_sense_len(objp: *const SgPtBase) -> c_int;
  80
  81     fn get_scsi_pt_status_response(objp: *const SgPtBase) -> c_int;
  82
  83     #[allow(dead_code)]
  84     fn get_scsi_pt_result_category(objp: *const SgPtBase) -> c_int;
  85 }
  86
  87 /// Creates a `Box<SgPtBase>`
  88 ///
  89 /// Which get automatically dropped, so you do not need to call
  90 /// destruct_scsi_pt_obj yourself.
  91 fn boxed_scsi_pt_obj() -> Result<Box<SgPtBase>, Error> {
  92     let objp = unsafe {
  93         construct_scsi_pt_obj()
  94     };
  95     if objp.is_null() {
  96         bail!("construct_scsi_pt_ob failed");
  97     }
  98
  99     Ok(unsafe { std::mem::transmute(objp)})
 100 }
 101
 102 /// Safe interface to run RAW SCSI commands
 103 pub struct SgRaw<'a, F> {
 104     file: &'a mut F,
 105     buffer: Box<[u8]>,
 106     sense_buffer: [u8; 32],
 107     timeout: i32,
 108 }
 109
 110 /// Allocate a page aligned buffer
 111 ///
 112 /// SG RAWIO commands needs page aligned transfer buffers.
 113 pub fn alloc_page_aligned_buffer(buffer_size: usize) -> Result<Box<[u8]> , Error> {
 114     let page_size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) } as usize;
 115     let layout = std::alloc::Layout::from_size_align(buffer_size, page_size)?;
 116     let dinp = unsafe { std::alloc::alloc_zeroed(layout) };
 117     if dinp.is_null() {
 118         bail!("alloc SCSI output buffer failed");
 119     }
 120
 121     let buffer_slice = unsafe { std::slice::from_raw_parts_mut(dinp, buffer_size)};
 122     Ok(unsafe { Box::from_raw(buffer_slice) })
 123 }
 124
 125 impl <'a, F: AsRawFd> SgRaw<'a, F> {
 126
 127     /// Create a new instance to run commands
 128     ///
 129     /// The file must be a handle to a SCSI device.
 130     pub fn new(file: &'a mut F, buffer_size: usize) -> Result<Self, Error> {
 131
 132         let buffer;
 133
 134         if buffer_size > 0 {
 135             buffer = alloc_page_aligned_buffer(buffer_size)?;
 136         } else {
 137             buffer =  Box::new([]);
 138         }
 139
 140         let sense_buffer = [0u8; 32];
 141
 142         Ok(Self { file, buffer, sense_buffer, timeout: 0 })
 143     }
 144
 145     /// Set the command timeout in seconds (0 means default (60 seconds))
 146     pub fn set_timeout(&mut self, seconds: usize) {
 147         if seconds > (i32::MAX as usize) {
 148             self.timeout = i32::MAX; // don't care about larger values
 149         } else {
 150             self.timeout = seconds as i32;
 151         }
 152     }
 153
 154     // create new object with initialized data_in and sense buffer
 155     fn create_boxed_scsi_pt_obj(&mut self) -> Result<Box<SgPtBase>, Error> {
 156
 157         let mut ptvp = boxed_scsi_pt_obj()?;
 158
 159         if self.buffer.len() > 0 {
 160             unsafe {
 161                 set_scsi_pt_data_in(
 162                     &mut *ptvp,
 163                     self.buffer.as_ptr(),
 164                     self.buffer.len() as c_int,
 165                 )
 166             };
 167         }
 168
 169         unsafe {
 170             set_scsi_pt_sense(
 171                 &mut *ptvp,
 172                 self.sense_buffer.as_ptr(),
 173                 self.sense_buffer.len() as c_int,
 174             )
 175         };
 176
 177         Ok(ptvp)
 178     }
 179
 180     /// Run the specified RAW SCSI command
 181     pub fn do_command(&mut self, cmd: &[u8]) -> Result<&[u8], Error> {
 182
 183         if !unsafe { sg_is_scsi_cdb(cmd.as_ptr(), cmd.len() as c_int) } {
 184             bail!("no valid SCSI command");
 185         }
 186
 187         if self.buffer.len() < 16 {
 188             bail!("output buffer too small");
 189         }
 190
 191         let mut ptvp = self.create_boxed_scsi_pt_obj()?;
 192
 193         unsafe {
 194             set_scsi_pt_cdb(
 195                 &mut *ptvp,
 196                 cmd.as_ptr(),
 197                 cmd.len() as c_int,
 198             )
 199         };
 200
 201         let res = unsafe { do_scsi_pt(&mut *ptvp, self.file.as_raw_fd(), self.timeout, 0) };
 202         if res < 0 {
 203             let err = nix::Error::last();
 204             bail!("do_scsi_pt failed  - {}", err);
 205         }
 206         if res != 0 {
 207             bail!("do_scsi_pt failed {}", res);
 208         }
 209
 210         // todo: what about sense data?
 211         let _sense_len = unsafe { get_scsi_pt_sense_len(&*ptvp) };
 212
 213         let status = unsafe { get_scsi_pt_status_response(&*ptvp) };
 214         if status != 0 {
 215             // toto: improve error reporting
 216             bail!("unknown scsi error - status response {}", status);
 217         }
 218
 219         let data_len = self.buffer.len() -
 220             (unsafe { get_scsi_pt_resid(&*ptvp) } as usize);
 221         if data_len == 0 {
 222             bail!("do_scsi_pt failed - no data received");
 223         }
 224
 225         Ok(&self.buffer[..data_len])
 226     }
 227
 228     /// Run dataout command
 229     ///
 230     /// Note: use alloc_page_aligned_buffer to alloc data transfer buffer
 231     pub fn do_out_command(&mut self, cmd: &[u8], data: &[u8]) -> Result<(), Error> {
 232
 233         if !unsafe { sg_is_scsi_cdb(cmd.as_ptr(), cmd.len() as c_int) } {
 234             bail!("no valid SCSI command");
 235         }
 236
 237         let page_size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) } as usize;
 238         if ((data.as_ptr() as usize) & (page_size -1)) != 0 {
 239             bail!("wrong transfer buffer alignment");
 240         }
 241
 242         let mut ptvp = self.create_boxed_scsi_pt_obj()?;
 243
 244         unsafe {
 245             set_scsi_pt_data_out(
 246                 &mut *ptvp,
 247                 data.as_ptr(),
 248                 data.len() as c_int,
 249             );
 250
 251             set_scsi_pt_cdb(
 252                 &mut *ptvp,
 253                 cmd.as_ptr(),
 254                 cmd.len() as c_int,
 255             );
 256          };
 257
 258         let res = unsafe { do_scsi_pt(&mut *ptvp, self.file.as_raw_fd(), self.timeout, 0) };
 259         if res < 0 {
 260             let err = nix::Error::last();
 261             bail!("do_scsi_pt failed  - {}", err);
 262         }
 263         if res != 0 {
 264             bail!("do_scsi_pt failed {}", res);
 265         }
 266
 267         // todo: what about sense data?
 268         let _sense_len = unsafe { get_scsi_pt_sense_len(&*ptvp) };
 269
 270         let status = unsafe { get_scsi_pt_status_response(&*ptvp) };
 271         if status != 0 {
 272             // toto: improve error reporting
 273             bail!("unknown scsi error - status response {}", status);
 274         }
 275
 276         Ok(())
 277     }
 278 }