[APPHELP_APITEST] Add tests for SdbGetMatchingExe, to test matching on version resour...
[reactos.git] / reactos / drivers / storage / classpnp / retry.c
1 /*++
2
3 Copyright (C) Microsoft Corporation, 1991 - 1999
4
5 Module Name:
6
7 retry.c
8
9 Abstract:
10
11 Packet retry routines for CLASSPNP
12
13 Environment:
14
15 kernel mode only
16
17 Notes:
18
19
20 Revision History:
21
22 --*/
23
24 #include "classp.h"
25
26 /*
27 * InterpretTransferPacketError
28 *
29 * Interpret the SRB error into a meaningful IRP status.
30 * ClassInterpretSenseInfo also may modify the SRB for the retry.
31 *
32 * Return TRUE iff packet should be retried.
33 */
34 BOOLEAN NTAPI InterpretTransferPacketError(PTRANSFER_PACKET Pkt)
35 {
36 BOOLEAN shouldRetry = FALSE;
37 PCDB pCdb = (PCDB)Pkt->Srb.Cdb;
38
39 /*
40 * Interpret the error using the returned sense info first.
41 */
42 Pkt->RetryIntervalSec = 0;
43 if (pCdb->MEDIA_REMOVAL.OperationCode == SCSIOP_MEDIUM_REMOVAL){
44 /*
45 * This is an Ejection Control SRB. Interpret its sense info specially.
46 */
47 shouldRetry = ClassInterpretSenseInfo(
48 Pkt->Fdo,
49 &Pkt->Srb,
50 IRP_MJ_SCSI,
51 0,
52 MAXIMUM_RETRIES - Pkt->NumRetries,
53 &Pkt->Irp->IoStatus.Status,
54 &Pkt->RetryIntervalSec);
55 if (shouldRetry){
56 /*
57 * If the device is not ready, wait at least 2 seconds before retrying.
58 */
59 PSENSE_DATA senseInfoBuffer = Pkt->Srb.SenseInfoBuffer;
60 ASSERT(senseInfoBuffer);
61 if (((Pkt->Irp->IoStatus.Status == STATUS_DEVICE_NOT_READY) &&
62 (senseInfoBuffer->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY)) ||
63 (SRB_STATUS(Pkt->Srb.SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT)){
64
65 Pkt->RetryIntervalSec = MAX(Pkt->RetryIntervalSec, 2);
66 }
67 }
68 }
69 else if ((pCdb->MODE_SENSE.OperationCode == SCSIOP_MODE_SENSE) ||
70 (pCdb->MODE_SENSE.OperationCode == SCSIOP_MODE_SENSE10)){
71 /*
72 * This is an Mode Sense SRB. Interpret its sense info specially.
73 */
74 shouldRetry = ClassInterpretSenseInfo(
75 Pkt->Fdo,
76 &Pkt->Srb,
77 IRP_MJ_SCSI,
78 0,
79 MAXIMUM_RETRIES - Pkt->NumRetries,
80 &Pkt->Irp->IoStatus.Status,
81 &Pkt->RetryIntervalSec);
82 if (shouldRetry){
83 /*
84 * If the device is not ready, wait at least 2 seconds before retrying.
85 */
86 PSENSE_DATA senseInfoBuffer = Pkt->Srb.SenseInfoBuffer;
87 ASSERT(senseInfoBuffer);
88 if (((Pkt->Irp->IoStatus.Status == STATUS_DEVICE_NOT_READY) &&
89 (senseInfoBuffer->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY)) ||
90 (SRB_STATUS(Pkt->Srb.SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT)){
91
92 Pkt->RetryIntervalSec = MAX(Pkt->RetryIntervalSec, 2);
93 }
94 }
95
96 /*
97 * Some special cases for mode sense.
98 */
99 if (Pkt->Irp->IoStatus.Status == STATUS_VERIFY_REQUIRED){
100 shouldRetry = TRUE;
101 }
102 else if (SRB_STATUS(Pkt->Srb.SrbStatus) == SRB_STATUS_DATA_OVERRUN){
103 /*
104 * This is a HACK.
105 * Atapi returns SRB_STATUS_DATA_OVERRUN when it really means
106 * underrun (i.e. success, and the buffer is longer than needed).
107 * So treat this as a success.
108 */
109 Pkt->Irp->IoStatus.Status = STATUS_SUCCESS;
110 InterlockedExchangeAdd((PLONG)&Pkt->OriginalIrp->IoStatus.Information, (LONG)Pkt->Srb.DataTransferLength);
111 shouldRetry = FALSE;
112 }
113 }
114 else if (pCdb->CDB10.OperationCode == SCSIOP_READ_CAPACITY){
115 /*
116 * This is a Drive Capacity SRB. Interpret its sense info specially.
117 */
118 shouldRetry = ClassInterpretSenseInfo(
119 Pkt->Fdo,
120 &Pkt->Srb,
121 IRP_MJ_SCSI,
122 0,
123 MAXIMUM_RETRIES - Pkt->NumRetries,
124 &Pkt->Irp->IoStatus.Status,
125 &Pkt->RetryIntervalSec);
126 if (Pkt->Irp->IoStatus.Status == STATUS_VERIFY_REQUIRED){
127 shouldRetry = TRUE;
128 }
129 }
130 else if ((pCdb->CDB10.OperationCode == SCSIOP_READ) ||
131 (pCdb->CDB10.OperationCode == SCSIOP_WRITE)){
132 /*
133 * This is a Read/Write Data packet.
134 */
135 PIO_STACK_LOCATION origCurrentSp = IoGetCurrentIrpStackLocation(Pkt->OriginalIrp);
136
137 shouldRetry = ClassInterpretSenseInfo(
138 Pkt->Fdo,
139 &Pkt->Srb,
140 origCurrentSp->MajorFunction,
141 0,
142 MAXIMUM_RETRIES - Pkt->NumRetries,
143 &Pkt->Irp->IoStatus.Status,
144 &Pkt->RetryIntervalSec);
145 /*
146 * Deal with some special cases.
147 */
148 if (Pkt->Irp->IoStatus.Status == STATUS_INSUFFICIENT_RESOURCES){
149 /*
150 * We are in extreme low-memory stress.
151 * We will retry in smaller chunks.
152 */
153 shouldRetry = TRUE;
154 }
155 else if (TEST_FLAG(origCurrentSp->Flags, SL_OVERRIDE_VERIFY_VOLUME) &&
156 (Pkt->Irp->IoStatus.Status == STATUS_VERIFY_REQUIRED)){
157 /*
158 * We are still verifying a (possibly) reloaded disk/cdrom.
159 * So retry the request.
160 */
161 Pkt->Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
162 shouldRetry = TRUE;
163 }
164 }
165 else {
166 DBGERR(("Unhandled SRB Function %xh in error path for packet %p (did miniport change Srb.Cdb.OperationCode ?)", (ULONG)pCdb->CDB10.OperationCode, Pkt));
167 }
168
169 return shouldRetry;
170 }
171
172 /*
173 * RetryTransferPacket
174 *
175 * Retry sending a TRANSFER_PACKET.
176 *
177 * Return TRUE iff the packet is complete.
178 * (if so the status in pkt->irp is the final status).
179 */
180 BOOLEAN NTAPI RetryTransferPacket(PTRANSFER_PACKET Pkt)
181 {
182 BOOLEAN packetDone;
183
184 DBGTRACE(ClassDebugTrace, ("retrying failed transfer (pkt=%ph, op=%s)", Pkt, DBGGETSCSIOPSTR(&Pkt->Srb)));
185
186 ASSERT(Pkt->NumRetries > 0);
187 Pkt->NumRetries--;
188
189 /*
190 * Tone down performance on the retry.
191 * This increases the chance for success on the retry.
192 * We've seen instances of drives that fail consistently but then start working
193 * once this scale-down is applied.
194 */
195 SET_FLAG(Pkt->Srb.SrbFlags, SRB_FLAGS_DISABLE_DISCONNECT);
196 SET_FLAG(Pkt->Srb.SrbFlags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
197 CLEAR_FLAG(Pkt->Srb.SrbFlags, SRB_FLAGS_QUEUE_ACTION_ENABLE);
198 Pkt->Srb.QueueTag = SP_UNTAGGED;
199
200 if (Pkt->Irp->IoStatus.Status == STATUS_INSUFFICIENT_RESOURCES){
201 PCDB pCdb = (PCDB)Pkt->Srb.Cdb;
202 BOOLEAN isReadWrite = ((pCdb->CDB10.OperationCode == SCSIOP_READ) ||
203 (pCdb->CDB10.OperationCode == SCSIOP_WRITE));
204
205 if (Pkt->InLowMemRetry || !isReadWrite){
206 /*
207 * This should never happen.
208 * The memory manager guarantees that at least four pages will
209 * be available to allow forward progress in the port driver.
210 * So a one-page transfer should never fail with insufficient resources.
211 */
212 ASSERT(isReadWrite && !Pkt->InLowMemRetry);
213 packetDone = TRUE;
214 }
215 else {
216 /*
217 * We are in low-memory stress.
218 * Start the low-memory retry state machine, which tries to
219 * resend the packet in little one-page chunks.
220 */
221 InitLowMemRetry( Pkt,
222 Pkt->BufPtrCopy,
223 Pkt->BufLenCopy,
224 Pkt->TargetLocationCopy);
225 StepLowMemRetry(Pkt);
226 packetDone = FALSE;
227 }
228 }
229 else {
230 /*
231 * Retry the packet by simply resending it after a delay.
232 * Put the packet back in the pending queue and
233 * schedule a timer to retry the transfer.
234 *
235 * Do not call SetupReadWriteTransferPacket again because:
236 * (1) The minidriver may have set some bits
237 * in the SRB that it needs again and
238 * (2) doing so would reset numRetries.
239 *
240 * BECAUSE we do not call SetupReadWriteTransferPacket again,
241 * we have to reset a couple fields in the SRB that
242 * some miniports overwrite when they fail an SRB.
243 */
244
245 Pkt->Srb.DataBuffer = Pkt->BufPtrCopy;
246 Pkt->Srb.DataTransferLength = Pkt->BufLenCopy;
247
248 if (Pkt->RetryIntervalSec == 0){
249 /*
250 * Always delay by at least a little when retrying.
251 * Some problems (e.g. CRC errors) are not recoverable without a slight delay.
252 */
253 LARGE_INTEGER timerPeriod;
254
255 timerPeriod.HighPart = -1;
256 timerPeriod.LowPart = -(LONG)((ULONG)MINIMUM_RETRY_UNITS*KeQueryTimeIncrement());
257 KeInitializeTimer(&Pkt->RetryTimer);
258 KeInitializeDpc(&Pkt->RetryTimerDPC, TransferPacketRetryTimerDpc, Pkt);
259 KeSetTimer(&Pkt->RetryTimer, timerPeriod, &Pkt->RetryTimerDPC);
260 }
261 else {
262 LARGE_INTEGER timerPeriod;
263
264 ASSERT(Pkt->RetryIntervalSec < 100); // sanity check
265 timerPeriod.HighPart = -1;
266 timerPeriod.LowPart = Pkt->RetryIntervalSec*-10000000;
267 KeInitializeTimer(&Pkt->RetryTimer);
268 KeInitializeDpc(&Pkt->RetryTimerDPC, TransferPacketRetryTimerDpc, Pkt);
269 KeSetTimer(&Pkt->RetryTimer, timerPeriod, &Pkt->RetryTimerDPC);
270 }
271 packetDone = FALSE;
272 }
273
274 return packetDone;
275 }
276
277 VOID NTAPI TransferPacketRetryTimerDpc(IN PKDPC Dpc,
278 IN PVOID DeferredContext,
279 IN PVOID SystemArgument1,
280 IN PVOID SystemArgument2)
281 {
282 PTRANSFER_PACKET pkt = (PTRANSFER_PACKET)DeferredContext;
283 SubmitTransferPacket(pkt);
284 }
285
286 VOID NTAPI InitLowMemRetry(PTRANSFER_PACKET Pkt, PVOID BufPtr, ULONG Len, LARGE_INTEGER TargetLocation)
287 {
288 ASSERT(Len > 0);
289 ASSERT(!Pkt->InLowMemRetry);
290 Pkt->InLowMemRetry = TRUE;
291 Pkt->LowMemRetry_remainingBufPtr = BufPtr;
292 Pkt->LowMemRetry_remainingBufLen = Len;
293 Pkt->LowMemRetry_nextChunkTargetLocation = TargetLocation;
294 }
295
296 /*
297 * StepLowMemRetry
298 *
299 * During extreme low-memory stress, this function retries
300 * a packet in small one-page chunks, sent serially.
301 *
302 * Returns TRUE iff the packet is done.
303 */
304 BOOLEAN NTAPI StepLowMemRetry(PTRANSFER_PACKET Pkt)
305 {
306 BOOLEAN packetDone;
307
308 if (Pkt->LowMemRetry_remainingBufLen == 0){
309 packetDone = TRUE;
310 }
311 else {
312 ULONG thisChunkLen;
313 ULONG bytesToNextPageBoundary;
314
315 /*
316 * Make sure the little chunk we send is <= a page length
317 * AND that it does not cross any page boundaries.
318 */
319 bytesToNextPageBoundary = PAGE_SIZE-(ULONG)((ULONG_PTR)Pkt->LowMemRetry_remainingBufPtr%PAGE_SIZE);
320 thisChunkLen = MIN(Pkt->LowMemRetry_remainingBufLen, bytesToNextPageBoundary);
321
322 /*
323 * Set up the transfer packet for the new little chunk.
324 * This will reset numRetries so that we retry each chunk as required.
325 */
326 SetupReadWriteTransferPacket(Pkt,
327 Pkt->LowMemRetry_remainingBufPtr,
328 thisChunkLen,
329 Pkt->LowMemRetry_nextChunkTargetLocation,
330 Pkt->OriginalIrp);
331
332 Pkt->LowMemRetry_remainingBufPtr += thisChunkLen;
333 Pkt->LowMemRetry_remainingBufLen -= thisChunkLen;
334 Pkt->LowMemRetry_nextChunkTargetLocation.QuadPart += thisChunkLen;
335
336 SubmitTransferPacket(Pkt);
337 packetDone = FALSE;
338 }
339
340 return packetDone;
341 }