Struct WriteCtx 

pub struct WriteCtx<'a> {
    pub conn: Arc<ClientConnection>,
    pub lun: u64,
    pub itt: u32,
    pub cmd_sn: Arc<AtomicU32>,
    pub exp_stat_sn: Arc<AtomicU32>,
    pub cdb: [u8; 16],
    pub payload: Vec<u8>,
    pub buf: [u8; 48],
    pub sent_bytes: usize,
    pub total_bytes: usize,
    pub last_response: Option<PduResponse<ScsiCommandResponse>>,
    /* private fields */
}

This structure represents the context for a SCSI Write operation.

Fields

conn: Arc<ClientConnection>

The client connection.

lun: u64

The Logical Unit Number.

itt: u32

The Initiator Task Tag.

cmd_sn: Arc<AtomicU32>

The Command Sequence Number.

exp_stat_sn: Arc<AtomicU32>

The Expected Status Sequence Number.

cdb: [u8; 16]

The SCSI Command Descriptor Block.

payload: Vec<u8>

The data to be written.

buf: [u8; 48]

A buffer for the BHS.

sent_bytes: usize

The number of bytes that have been sent.

total_bytes: usize

The total number of bytes to be sent.

last_response: Option<PduResponse<ScsiCommandResponse>>

The last received command response.

Implementations

impl<'a> WriteCtx<'a>

pub fn new( conn: Arc<ClientConnection>, lun: u64, itt: Arc<AtomicU32>, cmd_sn: Arc<AtomicU32>, exp_stat_sn: Arc<AtomicU32>, cdb: [u8; 16], payload: impl Into<Vec<u8>>, ) -> Self

Creates a new WriteCtx for a SCSI Write operation.

Trait Implementations

impl<'a> Debug for WriteCtx<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'ctx> StateMachine<WriteCtx<'ctx>, Transition<WriteStates, Result<(), Error>>> for Start

IssueCmd

1. Send SCSI Command (WRITE) with no data in the command PDU.
2. If payload is empty → go straight to waiting for SCSI Response. Otherwise → wait for R2T.

type StepResult<'a> = Pin<Box<dyn Future<Output = Transition<WriteStates, Result<(), Error>>> + Send + 'a>> where Self: 'a, WriteCtx<'ctx>: 'a

The future returned by the step method.

fn step<'a>(&'a self, ctx: &'a mut WriteCtx<'ctx>) -> Self::StepResult<'a>

Executes a single step of the state machine.

impl<'ctx> StateMachine<WriteCtx<'ctx>, Transition<WriteStates, Result<(), Error>>> for WaitR2T

WaitR2T

Await an R2T. Compute the data window (offset,len) safely, then move to SendWindow. We assume sequential windows.

type StepResult<'a> = Pin<Box<dyn Future<Output = Transition<WriteStates, Result<(), Error>>> + Send + 'a>> where Self: 'a, WriteCtx<'ctx>: 'a

The future returned by the step method.

fn step<'a>(&'a self, ctx: &'a mut WriteCtx<'ctx>) -> Self::StepResult<'a>

Executes a single step of the state machine.

impl<'ctx> StateMachine<WriteCtx<'ctx>, Transition<WriteStates, Result<(), Error>>> for Finish

WaitResp

Final step: wait for SCSI Command Response and validate GOOD status.

type StepResult<'a> = Pin<Box<dyn Future<Output = Transition<WriteStates, Result<(), Error>>> + Send + 'a>> where Self: 'a, WriteCtx<'ctx>: 'a

The future returned by the step method.

fn step<'a>(&'a self, ctx: &'a mut WriteCtx<'ctx>) -> Self::StepResult<'a>

Executes a single step of the state machine.

impl<'ctx> StateMachineCtx<WriteCtx<'ctx>, WriteOutcome> for WriteCtx<'ctx>

async fn execute(&mut self, _cancel: &CancellationToken) -> Result<WriteOutcome>

Executes the state machine to completion.