Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879/*++
Copyright (C) Microsoft Corporation. All rights reserved.
Module Name:
common.c
Abstract:
shared private routines for cdrom.sys
Environment:
kernel mode only
Notes:
Revision History:
--*/
#include "ntddk.h"#include "ntddstor.h"#include "ntstrsafe.h"
#include "cdrom.h"#include "scratch.h"
#ifdef DEBUG_USE_WPP#include "common.tmh"#endif
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, DeviceGetParameter)#pragma alloc_text(PAGE, DeviceSetParameter)#pragma alloc_text(PAGE, DeviceSendSrbSynchronously)#pragma alloc_text(PAGE, DevicePickDvdRegion)#pragma alloc_text(PAGE, StringsAreMatched)#pragma alloc_text(PAGE, PerformEjectionControl)#pragma alloc_text(PAGE, DeviceFindFeaturePage)#pragma alloc_text(PAGE, DevicePrintAllFeaturePages)#pragma alloc_text(PAGE, DeviceRegisterInterface)#pragma alloc_text(PAGE, DeviceRestoreDefaultSpeed)#pragma alloc_text(PAGE, DeviceSendRequestSynchronously)#pragma alloc_text(PAGE, MediaReadCapacity)#pragma alloc_text(PAGE, MediaReadCapacityDataInterpret)#pragma alloc_text(PAGE, DeviceRetrieveModeSenseUsingScratch)#pragma alloc_text(PAGE, ModeSenseFindSpecificPage)#pragma alloc_text(PAGE, DeviceUnlockExclusive)
#endif
LPCSTR LockTypeStrings[] = {"Simple", "Secure", "Internal" };
VOIDRequestSetReceivedTime( _In_ WDFREQUEST Request ){ PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request); LARGE_INTEGER temp;
KeQueryTickCount(&temp);
requestContext->TimeReceived = temp;
return;}
VOIDRequestSetSentTime( _In_ WDFREQUEST Request ){ PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request); LARGE_INTEGER temp;
KeQueryTickCount(&temp);
if (requestContext->TimeSentDownFirstTime.QuadPart == 0) { requestContext->TimeSentDownFirstTime = temp; }
requestContext->TimeSentDownLasttTime = temp;
if (requestContext->OriginalRequest != NULL) { PCDROM_REQUEST_CONTEXT originalRequestContext = RequestGetContext(requestContext->OriginalRequest);
if (originalRequestContext->TimeSentDownFirstTime.QuadPart == 0) { originalRequestContext->TimeSentDownFirstTime = temp; }
originalRequestContext->TimeSentDownLasttTime = temp; }
return;}
VOIDRequestClearSendTime( _In_ WDFREQUEST Request )/*Routine Description:
This function is used to clean SentTime fields in reusable request context.
Arguments: Request -
Return Value: N/A
*/{ PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);
requestContext->TimeSentDownFirstTime.QuadPart = 0; requestContext->TimeSentDownLasttTime.QuadPart = 0;
return;}
_IRQL_requires_max_(PASSIVE_LEVEL)VOIDDeviceGetParameter( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_opt_ PWSTR SubkeyName, _In_ PWSTR ParameterName, _Inout_ PULONG ParameterValue // also default value )/*++Routine Description:
retrieve device parameter from registry.
Arguments:
DeviceExtension - device context.
SubkeyName - name of subkey
ParameterName - the registry parameter to be retrieved
Return Value:
ParameterValue - registry value retrieved
--*/{ NTSTATUS status; WDFKEY rootKey = NULL; WDFKEY subKey = NULL; UNICODE_STRING registrySubKeyName; UNICODE_STRING registryValueName; ULONG defaultParameterValue;
PAGED_CODE();
RtlInitUnicodeString(®istryValueName, ParameterName);
if (SubkeyName != NULL) { RtlInitUnicodeString(®istrySubKeyName, SubkeyName); }
// open the hardware key status = WdfDeviceOpenRegistryKey(DeviceExtension->Device, PLUGPLAY_REGKEY_DEVICE, KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, &rootKey);
// open the sub key if (NT_SUCCESS(status) && (SubkeyName != NULL)) { status = WdfRegistryOpenKey(rootKey, ®istrySubKeyName, KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, &subKey);
if (!NT_SUCCESS(status)) { WdfRegistryClose(rootKey); rootKey = NULL; } }
if (NT_SUCCESS(status) && (rootKey != NULL)) { defaultParameterValue = *ParameterValue;
status = WdfRegistryQueryULong((subKey != NULL) ? subKey : rootKey, ®istryValueName, ParameterValue);
if (!NT_SUCCESS(status)) { *ParameterValue = defaultParameterValue; // use default value } }
// close what we open if (subKey != NULL) { WdfRegistryClose(subKey); subKey = NULL; }
if (rootKey != NULL) { WdfRegistryClose(rootKey); rootKey = NULL; }
// Windows 2000 SP3 uses the driver-specific key, so look in there if (!NT_SUCCESS(status)) { // open the software key status = WdfDeviceOpenRegistryKey(DeviceExtension->Device, PLUGPLAY_REGKEY_DRIVER, KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, &rootKey);
// open the sub key if (NT_SUCCESS(status) && (SubkeyName != NULL)) { status = WdfRegistryOpenKey(rootKey, ®istrySubKeyName, KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, &subKey);
if (!NT_SUCCESS(status)) { WdfRegistryClose(rootKey); rootKey = NULL; } }
if (NT_SUCCESS(status) && (rootKey != NULL)) { defaultParameterValue = *ParameterValue;
status = WdfRegistryQueryULong((subKey != NULL) ? subKey : rootKey, ®istryValueName, ParameterValue);
if (!NT_SUCCESS(status)) { *ParameterValue = defaultParameterValue; // use default value } else { // Migrate the value over to the device-specific key DeviceSetParameter(DeviceExtension, SubkeyName, ParameterName, *ParameterValue); } }
// close what we open if (subKey != NULL) { WdfRegistryClose(subKey); subKey = NULL; }
if (rootKey != NULL) { WdfRegistryClose(rootKey); rootKey = NULL; } }
return;
} // end DeviceetParameter()
_IRQL_requires_max_(PASSIVE_LEVEL)NTSTATUSDeviceSetParameter( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_opt_z_ PWSTR SubkeyName, _In_ PWSTR ParameterName, _In_ ULONG ParameterValue )/*++Routine Description:
set parameter to registry.
Arguments:
DeviceExtension - device context.
SubkeyName - name of subkey
ParameterName - the registry parameter to be retrieved
ParameterValue - registry value to be set
Return Value: NTSTATUS
--*/{ NTSTATUS status; WDFKEY rootKey = NULL; WDFKEY subKey = NULL; UNICODE_STRING registrySubKeyName; UNICODE_STRING registryValueName;
PAGED_CODE();
RtlInitUnicodeString(®istryValueName, ParameterName);
if (SubkeyName != NULL) { RtlInitUnicodeString(®istrySubKeyName, SubkeyName); }
// open the hardware key status = WdfDeviceOpenRegistryKey(DeviceExtension->Device, PLUGPLAY_REGKEY_DEVICE, KEY_READ | KEY_WRITE, WDF_NO_OBJECT_ATTRIBUTES, &rootKey);
// open the sub key if (NT_SUCCESS(status) && (SubkeyName != NULL)) { status = WdfRegistryOpenKey(rootKey, ®istrySubKeyName, KEY_READ | KEY_WRITE, WDF_NO_OBJECT_ATTRIBUTES, &subKey);
if (!NT_SUCCESS(status)) { WdfRegistryClose(rootKey); rootKey = NULL; } }
if (NT_SUCCESS(status) && (rootKey != NULL)) { status = WdfRegistryAssignULong((subKey != NULL) ? subKey : rootKey, ®istryValueName, ParameterValue); }
// close what we open if (subKey != NULL) { WdfRegistryClose(subKey); subKey = NULL; }
if (rootKey != NULL) { WdfRegistryClose(rootKey); rootKey = NULL; }
return status;
} // end DeviceSetParameter()
_IRQL_requires_max_(APC_LEVEL)NTSTATUSDeviceSendRequestSynchronously( _In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ BOOLEAN RequestFormated )/*++Routine Description:
send a request to lower driver synchronously.
Arguments:
Device - device object.
Request - request object
RequestFormated - if the request is already formatted, will no do it in this function
Return Value: NTSTATUS
--*/{ NTSTATUS status = STATUS_SUCCESS; PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device); BOOLEAN requestCancelled = FALSE; PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);
PAGED_CODE();
if (!RequestFormated) { // set request up for sending down WdfRequestFormatRequestUsingCurrentType(Request); }
// get cancellation status for the original request if (requestContext->OriginalRequest != NULL) { requestCancelled = WdfRequestIsCanceled(requestContext->OriginalRequest); }
if (!requestCancelled) { status = RequestSend(deviceExtension, Request, deviceExtension->IoTarget, WDF_REQUEST_SEND_OPTION_SYNCHRONOUS, NULL); } else { status = STATUS_CANCELLED; }
return status;}
_IRQL_requires_max_(PASSIVE_LEVEL)NTSTATUSDeviceSendSrbSynchronously( _In_ WDFDEVICE Device, _In_ PSCSI_REQUEST_BLOCK Srb, _In_opt_ PVOID BufferAddress, _In_ ULONG BufferLength, _In_ BOOLEAN WriteToDevice, _In_opt_ WDFREQUEST OriginalRequest )/*++Routine Description:
Send a SRB structure to lower driver synchronously.
Process of this function: 1. Allocate SenseBuffer; Create Request; Allocate MDL 2. Do following loop if necessary 2.1 Reuse Request 2.2 Format Srb, Irp 2.3 Send Request 2.4 Error Intepret and retry decision making. 3. Release all allocated resosurces.
Arguments:
Device - device object.
Request - request object
RequestFormated - if the request is already formatted, will no do it in this function
Return Value: NTSTATUS
NOTE:The caller needs to setup following fields before calling this routine. srb.CdbLength srb.TimeOutValue cdb
BufferLength and WriteToDevice to control the data direction of the device BufferLength = 0: No data transfer BufferLenth != 0 && !WriteToDevice: get data from device BufferLenth != 0 && WriteToDevice: send data to device--*/{ NTSTATUS status; PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device); PCDROM_PRIVATE_FDO_DATA fdoData = deviceExtension->PrivateFdoData; PUCHAR senseInfoBuffer = NULL; ULONG retryCount = 0; BOOLEAN retry = FALSE; ULONG ioctlCode = 0; WDFREQUEST request = NULL; PIRP irp = NULL; PIO_STACK_LOCATION nextStack = NULL; PMDL mdlAddress = NULL; BOOLEAN memoryLocked = FALSE; WDF_OBJECT_ATTRIBUTES attributes; PZERO_POWER_ODD_INFO zpoddInfo = deviceExtension->ZeroPowerODDInfo;
PAGED_CODE();
// NOTE: This code is only pagable because we are not freezing // the queue. Allowing the queue to be frozen from a pagable // routine could leave the queue frozen as we try to page in // the code to unfreeze the queue. The result would be a nice // case of deadlock. Therefore, since we are unfreezing the // queue regardless of the result, just set the NO_FREEZE_QUEUE // flag in the SRB. NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
//1. allocate SenseBuffer and initiate Srb common fields // these fields will not be changed by lower driver. { // Write length to SRB. Srb->Length = sizeof(SCSI_REQUEST_BLOCK); Srb->Function = SRB_FUNCTION_EXECUTE_SCSI; Srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
// Sense buffer is in aligned nonpaged pool. senseInfoBuffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, SENSE_BUFFER_SIZE, CDROM_TAG_SENSE_INFO);
if (senseInfoBuffer == NULL) { status = STATUS_INSUFFICIENT_RESOURCES;
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "DeviceSendSrbSynchronously: Can't allocate MDL\n"));
goto Exit; }
Srb->SenseInfoBuffer = senseInfoBuffer; Srb->DataBuffer = BufferAddress;
// set timeout value to default value if it's not specifically set by caller. if (Srb->TimeOutValue == 0) { Srb->TimeOutValue = deviceExtension->TimeOutValue; } }
//2. Create Request object { WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CDROM_REQUEST_CONTEXT);
status = WdfRequestCreate(&attributes, deviceExtension->IoTarget, &request);
if (!NT_SUCCESS(status)) { TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "DeviceSendSrbSynchronously: Can't create request: %lx\n", status));
goto Exit; }
irp = WdfRequestWdmGetIrp(request); }
// 3. Build an MDL for the data buffer and stick it into the irp. if (BufferAddress != NULL) { mdlAddress = IoAllocateMdl( BufferAddress, BufferLength, FALSE, FALSE, irp ); if (mdlAddress == NULL) { status = STATUS_INSUFFICIENT_RESOURCES;
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "DeviceSendSrbSynchronously: Can't allocate MDL\n"));
goto Exit; }
_SEH2_TRY { MmProbeAndLockPages(mdlAddress, KernelMode, (WriteToDevice ? IoReadAccess : IoWriteAccess)); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { status = _SEH2_GetExceptionCode();
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "DeviceSendSrbSynchronously: Exception %lx locking buffer\n", status));
_SEH2_YIELD(goto Exit); } _SEH2_END;
memoryLocked = TRUE; }
// 4. Format Srb, Irp; Send request and retry when necessary do { // clear the control variable. retry = FALSE;
// 4.1 reuse the request object; set originalRequest field. { WDF_REQUEST_REUSE_PARAMS params; PCDROM_REQUEST_CONTEXT requestContext = NULL;
// deassign the MdlAddress, this is the value we assign explicitly. // doing this can prevent WdfRequestReuse to release the Mdl unexpectly. if (irp->MdlAddress) { irp->MdlAddress = NULL; }
WDF_REQUEST_REUSE_PARAMS_INIT(¶ms, WDF_REQUEST_REUSE_NO_FLAGS, STATUS_SUCCESS);
status = WdfRequestReuse(request, ¶ms);
if (!NT_SUCCESS(status)) { TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "DeviceSendSrbSynchronously: WdfRequestReuse failed, %!STATUS!\n", status)); // exit the loop. break; }
// WDF requests to format the request befor sending it status = WdfIoTargetFormatRequestForInternalIoctlOthers(deviceExtension->IoTarget, request, ioctlCode, NULL, NULL, NULL, NULL, NULL, NULL);
if (!NT_SUCCESS(status)) { TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "DeviceSendSrbSynchronously: WdfIoTargetFormatRequestForInternalIoctlOthers failed, %!STATUS!\n", status)); // exit the loop. break; }
requestContext = RequestGetContext(request); requestContext->OriginalRequest = OriginalRequest; }
// 4.2 Format Srb and Irp { Srb->OriginalRequest = irp; Srb->QueueAction = SRB_SIMPLE_TAG_REQUEST; Srb->DataTransferLength = BufferLength; Srb->SrbFlags = deviceExtension->SrbFlags;
// Disable synchronous transfer for these requests. SET_FLAG(Srb->SrbFlags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER); SET_FLAG(Srb->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE);
if (BufferAddress != NULL) { if (WriteToDevice) { SET_FLAG(Srb->SrbFlags, SRB_FLAGS_DATA_OUT); ioctlCode = IOCTL_SCSI_EXECUTE_OUT; } else { SET_FLAG(Srb->SrbFlags, SRB_FLAGS_DATA_IN); ioctlCode = IOCTL_SCSI_EXECUTE_IN; } } else { ioctlCode = IOCTL_SCSI_EXECUTE_NONE; }
// Zero out status. Srb->ScsiStatus = 0; Srb->SrbStatus = 0; Srb->NextSrb = NULL;
// irp related fields irp->MdlAddress = mdlAddress;
nextStack = IoGetNextIrpStackLocation(irp);
nextStack->MajorFunction = IRP_MJ_SCSI; nextStack->Parameters.DeviceIoControl.IoControlCode = ioctlCode; nextStack->Parameters.Scsi.Srb = Srb; }
// 4.3 send Request to lower driver. status = DeviceSendRequestSynchronously(Device, request, TRUE);
if (status != STATUS_CANCELLED) { NT_ASSERT(SRB_STATUS(Srb->SrbStatus) != SRB_STATUS_PENDING); NT_ASSERT(status != STATUS_PENDING); NT_ASSERT(!(Srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN));
// 4.4 error process. if (SRB_STATUS(Srb->SrbStatus) != SRB_STATUS_SUCCESS) { LONGLONG retryIntervalIn100ns = 0;
// Update status and determine if request should be retried. retry = RequestSenseInfoInterpret(deviceExtension, request, Srb, retryCount, &status, &retryIntervalIn100ns);
if (retry) { LARGE_INTEGER t; t.QuadPart = -retryIntervalIn100ns; retryCount++; KeDelayExecutionThread(KernelMode, FALSE, &t); } } else { // Request succeeded. fdoData->LoggedTURFailureSinceLastIO = FALSE; status = STATUS_SUCCESS; retry = FALSE; } } } while(retry);
if ((zpoddInfo != NULL) && (zpoddInfo->MonitorStartStopUnit != FALSE) && (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SUCCESS)) { TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER, "DeviceSendSrbSynchronously: soft eject detected, device marked as active\n"));
DeviceMarkActive(deviceExtension, TRUE, FALSE); }
// 5. Release all allocated resources.
// required even though we allocated our own, since the port driver may // have allocated one also if (PORT_ALLOCATED_SENSE(deviceExtension, Srb)) { FREE_PORT_ALLOCATED_SENSE_BUFFER(deviceExtension, Srb); }
Exit:
if (senseInfoBuffer != NULL) { FREE_POOL(senseInfoBuffer); }
Srb->SenseInfoBuffer = NULL; Srb->SenseInfoBufferLength = 0;
if (mdlAddress) { if (memoryLocked) { MmUnlockPages(mdlAddress); memoryLocked = FALSE; }
IoFreeMdl(mdlAddress); irp->MdlAddress = NULL; }
if (request) { WdfObjectDelete(request); }
return status;}
VOIDDeviceSendNotification( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ const GUID* Guid, _In_ ULONG ExtraDataSize, _In_opt_ PVOID ExtraData )/*++Routine Description:
send notification to other components
Arguments:
DeviceExtension - device context.
Guid - GUID for the notification
ExtraDataSize - data size along with notification
ExtraData - data buffer send with notification
Return Value: None
--*/{ PTARGET_DEVICE_CUSTOM_NOTIFICATION notification; ULONG requiredSize; NTSTATUS status;
status = RtlULongAdd((sizeof(TARGET_DEVICE_CUSTOM_NOTIFICATION) - sizeof(UCHAR)), ExtraDataSize, &requiredSize);
if (!(NT_SUCCESS(status)) || (requiredSize > 0x0000ffff)) { // MAX_USHORT, max total size for these events! TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, "Error sending event: size too large! (%x)\n", requiredSize)); return; }
notification = ExAllocatePoolWithTag(NonPagedPoolNx, requiredSize, CDROM_TAG_NOTIFICATION);
// if none allocated, exit if (notification == NULL) { return; }
// Prepare and send the request! RtlZeroMemory(notification, requiredSize); notification->Version = 1; notification->Size = (USHORT)(requiredSize); notification->FileObject = NULL; notification->NameBufferOffset = -1; notification->Event = *Guid;
if (ExtraData != NULL) { RtlCopyMemory(notification->CustomDataBuffer, ExtraData, ExtraDataSize); }
IoReportTargetDeviceChangeAsynchronous(DeviceExtension->LowerPdo, notification, NULL, NULL);
FREE_POOL(notification);
return;}
VOIDDeviceSendStartUnit( _In_ WDFDEVICE Device )/*++
Routine Description:
Send command to SCSI unit to start or power up. Because this command is issued asynchronounsly, that is, without waiting on it to complete, the IMMEDIATE flag is not set. This means that the CDB will not return until the drive has powered up. This should keep subsequent requests from being submitted to the device before it has completely spun up.
This routine is called from the InterpretSense routine, when a request sense returns data indicating that a drive must be powered up.
This routine may also be called from a class driver's error handler, or anytime a non-critical start device should be sent to the device.
Arguments:
Device - The device object.
Return Value:
None.
--*/{ NTSTATUS status = STATUS_SUCCESS; PCDROM_DEVICE_EXTENSION deviceExtension = NULL; WDF_OBJECT_ATTRIBUTES attributes; WDFREQUEST startUnitRequest = NULL; WDFMEMORY inputMemory = NULL;
PCOMPLETION_CONTEXT context = NULL; PSCSI_REQUEST_BLOCK srb = NULL; PCDB cdb = NULL;
deviceExtension = DeviceGetExtension(Device);
if (NT_SUCCESS(status)) { // Allocate Srb from nonpaged pool. context = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(COMPLETION_CONTEXT), CDROM_TAG_COMPLETION_CONTEXT);
if (context == NULL) { TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "DeviceSendStartUnit: Failed to allocate completion context\n"));
status = STATUS_INTERNAL_ERROR; } }
if (NT_SUCCESS(status)) { // Save the device object in the context for use by the completion // routine. context->Device = Device; srb = &context->Srb;
// Zero out srb. RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
// setup SRB structure. srb->Length = sizeof(SCSI_REQUEST_BLOCK); srb->Function = SRB_FUNCTION_EXECUTE_SCSI; srb->TimeOutValue = START_UNIT_TIMEOUT;
srb->SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER | SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
// setup CDB srb->CdbLength = 6; cdb = (PCDB)srb->Cdb;
cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT; cdb->START_STOP.Start = 1; cdb->START_STOP.Immediate = 0; cdb->START_STOP.LogicalUnitNumber = srb->Lun;
//Create Request for sending down to port driver WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CDROM_REQUEST_CONTEXT); attributes.ParentObject = deviceExtension->IoTarget;
status = WdfRequestCreate(&attributes, deviceExtension->IoTarget, &startUnitRequest); }
if (NT_SUCCESS(status)) { srb->OriginalRequest = WdfRequestWdmGetIrp(startUnitRequest); NT_ASSERT(srb->OriginalRequest != NULL);
//Prepare the request WDF_OBJECT_ATTRIBUTES_INIT(&attributes); attributes.ParentObject = startUnitRequest;
status = WdfMemoryCreatePreallocated(&attributes, (PVOID)srb, sizeof(SCSI_REQUEST_BLOCK), &inputMemory); }
if (NT_SUCCESS(status)) { status = WdfIoTargetFormatRequestForInternalIoctlOthers(deviceExtension->IoTarget, startUnitRequest, IOCTL_SCSI_EXECUTE_NONE, inputMemory, NULL, NULL, NULL, NULL, NULL); }
if (NT_SUCCESS(status)) { // Set a CompletionRoutine callback function. WdfRequestSetCompletionRoutine(startUnitRequest, DeviceAsynchronousCompletion, context);
status = RequestSend(deviceExtension, startUnitRequest, deviceExtension->IoTarget, 0, NULL); }
// release resources when failed. if (!NT_SUCCESS(status)) { FREE_POOL(context); if (startUnitRequest != NULL) { WdfObjectDelete(startUnitRequest); } }
return;} // end StartUnit()
VOIDDeviceSendIoctlAsynchronously( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT TargetDeviceObject )/*++
Routine Description:
Send an IOCTL asynchronously
Arguments:
DeviceExtension - device context. IoControlCode - IOCTL code. TargetDeviceObject - target device object.
Return Value:
None.
--*/{ PIRP irp = NULL; PIO_STACK_LOCATION nextIrpStack = NULL;
irp = IoAllocateIrp(DeviceExtension->DeviceObject->StackSize, FALSE);
if (irp != NULL) { nextIrpStack = IoGetNextIrpStackLocation(irp);
nextIrpStack->MajorFunction = IRP_MJ_DEVICE_CONTROL;
nextIrpStack->Parameters.DeviceIoControl.OutputBufferLength = 0; nextIrpStack->Parameters.DeviceIoControl.InputBufferLength = 0; nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IoControlCode; nextIrpStack->Parameters.DeviceIoControl.Type3InputBuffer = NULL;
IoSetCompletionRoutine(irp, RequestAsynchronousIrpCompletion, DeviceExtension, TRUE, TRUE, TRUE);
(VOID) IoCallDriver(TargetDeviceObject, irp); }}
NTSTATUSNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */RequestAsynchronousIrpCompletion( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context )/*++
Routine Description:
Free the Irp.
Arguments:
DeviceObject - device that the completion routine fires on.
Irp - The irp to be completed.
Context - IRP context
Return Value: NTSTATUS
--*/{ UNREFERENCED_PARAMETER(DeviceObject); UNREFERENCED_PARAMETER(Context);
IoFreeIrp(Irp);
return STATUS_MORE_PROCESSING_REQUIRED;}
VOIDNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */DeviceAsynchronousCompletion( _In_ WDFREQUEST Request, _In_ WDFIOTARGET Target, _In_ PWDF_REQUEST_COMPLETION_PARAMS Params, _In_ WDFCONTEXT Context )/*++
Routine Description:
This routine is called when an asynchronous I/O request which was issused by the class driver completes. Examples of such requests are release queue or START UNIT. This routine releases the queue if necessary. It then frees the context and the IRP.
Arguments:
DeviceObject - The device object for the logical unit; however since this is the top stack location the value is NULL.
Irp - Supplies a pointer to the Irp to be processed.
Context - Supplies the context to be used to process this request.
Return Value:
None.
--*/{ PCOMPLETION_CONTEXT context = (PCOMPLETION_CONTEXT)Context; PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(context->Device);
UNREFERENCED_PARAMETER(Target); UNREFERENCED_PARAMETER(Params);
// If this is an execute srb, then check the return status and make sure. // the queue is not frozen. if (context->Srb.Function == SRB_FUNCTION_EXECUTE_SCSI) { // Check for a frozen queue. if (context->Srb.SrbStatus & SRB_STATUS_QUEUE_FROZEN) { // Unfreeze the queue getting the device object from the context. DeviceReleaseQueue(context->Device); } }
// free port-allocated sense buffer if we can detect // if (PORT_ALLOCATED_SENSE(deviceExtension, &context->Srb)) { FREE_PORT_ALLOCATED_SENSE_BUFFER(deviceExtension, &context->Srb); }
FREE_POOL(context);
WdfObjectDelete(Request);
} // end DeviceAsynchronousCompletion()
VOIDDeviceReleaseQueue( _In_ WDFDEVICE Device )/*++
Routine Description:
This routine issues an internal device control command to the port driver to release a frozen queue. The call is issued asynchronously as DeviceReleaseQueue will be invoked from the IO completion DPC (and will have no context to wait for a synchronous call to complete).
This routine must be called with the remove lock held.
Arguments:
Device - The functional device object for the device with the frozen queue.
Return Value:
None.
--*/{ PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device); PSCSI_REQUEST_BLOCK srb = NULL; KIRQL currentIrql;
// we raise irql seperately so we're not swapped out or suspended // while holding the release queue irp in this routine. this lets // us release the spin lock before lowering irql. KeRaiseIrql(DISPATCH_LEVEL, ¤tIrql);
WdfSpinLockAcquire(deviceExtension->ReleaseQueueSpinLock);
if (deviceExtension->ReleaseQueueInProgress) { // Someone is already doing this work - just set the flag to indicate that // we need to release the queue again. deviceExtension->ReleaseQueueNeeded = TRUE; WdfSpinLockRelease(deviceExtension->ReleaseQueueSpinLock); KeLowerIrql(currentIrql);
return; }
// Mark that there is a release queue in progress and drop the spinlock. deviceExtension->ReleaseQueueInProgress = TRUE;
WdfSpinLockRelease(deviceExtension->ReleaseQueueSpinLock);
srb = &(deviceExtension->ReleaseQueueSrb);
// Optical media are removable, so we just flush the queue. This will also release it. srb->Function = SRB_FUNCTION_FLUSH_QUEUE;
srb->OriginalRequest = WdfRequestWdmGetIrp(deviceExtension->ReleaseQueueRequest);
// Set a CompletionRoutine callback function. WdfRequestSetCompletionRoutine(deviceExtension->ReleaseQueueRequest, DeviceReleaseQueueCompletion, Device); // Send the request. If an error occurs, complete the request. RequestSend(deviceExtension, deviceExtension->ReleaseQueueRequest, deviceExtension->IoTarget, WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE, NULL);
KeLowerIrql(currentIrql);
return;
} // end DeviceReleaseQueue()
VOIDNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */DeviceReleaseQueueCompletion( _In_ WDFREQUEST Request, _In_ WDFIOTARGET Target, _In_ PWDF_REQUEST_COMPLETION_PARAMS Params, _In_ WDFCONTEXT Context )/*++
Routine Description:
This routine is called when an asynchronous release queue request which was issused in DeviceReleaseQueue completes. This routine prepares for the next release queue request and resends it if necessary.
Arguments:
Request - The completed request.
Target - IoTarget object
Params - Completion parameters
Context - WDFDEVICE object handle.
Return Value:
None.
--*/{ NTSTATUS status; WDFDEVICE device = Context; PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(device);
BOOLEAN releaseQueueNeeded = FALSE; WDF_REQUEST_REUSE_PARAMS params = {0};
UNREFERENCED_PARAMETER(Target); UNREFERENCED_PARAMETER(Params);
WDF_REQUEST_REUSE_PARAMS_INIT(¶ms, WDF_REQUEST_REUSE_NO_FLAGS, STATUS_SUCCESS);
// Grab the spinlock and clear the release queue in progress flag so others // can run. Save (and clear) the state of the release queue needed flag // so that we can issue a new release queue outside the spinlock. WdfSpinLockAcquire(deviceExtension->ReleaseQueueSpinLock);
releaseQueueNeeded = deviceExtension->ReleaseQueueNeeded;
deviceExtension->ReleaseQueueNeeded = FALSE; deviceExtension->ReleaseQueueInProgress = FALSE;
// Reuse the ReleaseQueueRequest for the next time. status = WdfRequestReuse(Request,¶ms);
if (NT_SUCCESS(status)) { // Preformat the ReleaseQueueRequest for the next time. // This should always succeed because it was already preformatted once during device initialization status = WdfIoTargetFormatRequestForInternalIoctlOthers(deviceExtension->IoTarget, Request, IOCTL_SCSI_EXECUTE_NONE, deviceExtension->ReleaseQueueInputMemory, NULL, NULL, NULL, NULL, NULL); }
if (!NT_SUCCESS(status)) { TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "DeviceReleaseQueueCompletion: WdfIoTargetFormatRequestForInternalIoctlOthers failed, %!STATUS!\n", status)); }
RequestClearSendTime(Request);
WdfSpinLockRelease(deviceExtension->ReleaseQueueSpinLock);
// If we need a release queue then issue one now. Another processor may // have already started one in which case we'll try to issue this one after // it is done - but we should never recurse more than one deep. if (releaseQueueNeeded) { DeviceReleaseQueue(device); }
return;
} // DeviceReleaseQueueCompletion()
//// In order to provide better performance without the need to reboot,// we need to implement a self-adjusting method to set and clear the// srb flags based upon current performance.//// whenever there is an error, immediately grab the spin lock. the// MP perf hit here is acceptable, since we're in an error path. this// is also neccessary because we are guaranteed to be modifying the// SRB flags here, setting SuccessfulIO to zero, and incrementing the// actual error count (which is always done within this spinlock).//// whenever there is no error, increment a counter. if there have been// errors on the device, and we've enabled dynamic perf, *and* we've// just crossed the perf threshhold, then grab the spin lock and// double check that the threshhold has, indeed been hit(*). then// decrement the error count, and if it's dropped sufficiently, undo// some of the safety changes made in the SRB flags due to the errors.//// * this works in all cases. even if lots of ios occur after the// previous guy went in and cleared the successfulio counter, that// just means that we've hit the threshhold again, and so it's proper// to run the inner loop again.//
VOIDDevicePerfIncrementErrorCount( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension ){ PCDROM_PRIVATE_FDO_DATA fdoData = DeviceExtension->PrivateFdoData; KIRQL oldIrql; ULONG errors;
KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
fdoData->Perf.SuccessfulIO = 0; // implicit interlock errors = InterlockedIncrement((PLONG)&DeviceExtension->ErrorCount);
if (errors >= CLASS_ERROR_LEVEL_1) { // If the error count has exceeded the error limit, then disable // any tagged queuing, multiple requests per lu queueing // and sychronous data transfers. // // Clearing the no queue freeze flag prevents the port driver // from sending multiple requests per logical unit. CLEAR_FLAG(DeviceExtension->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE); CLEAR_FLAG(DeviceExtension->SrbFlags, SRB_FLAGS_QUEUE_ACTION_ENABLE);
SET_FLAG(DeviceExtension->SrbFlags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "PerfIncrementErrorCount: Too many errors; disabling tagged queuing and " "synchronous data tranfers.\n")); }
if (errors >= CLASS_ERROR_LEVEL_2) { // If a second threshold is reached, disable disconnects. SET_FLAG(DeviceExtension->SrbFlags, SRB_FLAGS_DISABLE_DISCONNECT); TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "PerfIncrementErrorCount: Too many errors; disabling disconnects.\n")); }
KeReleaseSpinLock(&fdoData->SpinLock, oldIrql); return;}
_IRQL_requires_max_(APC_LEVEL)PVOIDDeviceFindFeaturePage( _In_reads_bytes_(Length) PGET_CONFIGURATION_HEADER FeatureBuffer, _In_ ULONG const Length, _In_ FEATURE_NUMBER const Feature )/*++Routine Description:
find the specific feature page in the buffer
Arguments:
FeatureBuffer - buffer contains the device feature set.
Length - buffer length
Feature - the feature number looking for.
Return Value:
PVOID - pointer to the starting location of the specific feature in buffer.
--*/{ PUCHAR buffer; PUCHAR limit; ULONG validLength;
PAGED_CODE();
if (Length < sizeof(GET_CONFIGURATION_HEADER) + sizeof(FEATURE_HEADER)) { return NULL; }
// Calculate the length of valid data available in the // capabilities buffer from the DataLength field REVERSE_BYTES(&validLength, FeatureBuffer->DataLength);
validLength += RTL_SIZEOF_THROUGH_FIELD(GET_CONFIGURATION_HEADER, DataLength);
// set limit to point to first illegal address limit = (PUCHAR)FeatureBuffer; limit += min(Length, validLength);
// set buffer to point to first page buffer = FeatureBuffer->Data;
// loop through each page until we find the requested one, or // until it's not safe to access the entire feature header // (if equal, have exactly enough for the feature header) while (buffer + sizeof(FEATURE_HEADER) <= limit) { PFEATURE_HEADER header = (PFEATURE_HEADER)buffer; FEATURE_NUMBER thisFeature;
thisFeature = (header->FeatureCode[0] << 8) | (header->FeatureCode[1]);
if (thisFeature == Feature) { PUCHAR temp;
// if don't have enough memory to safely access all the feature // information, return NULL temp = buffer; temp += sizeof(FEATURE_HEADER); temp += header->AdditionalLength;
if (temp > limit) { // this means the transfer was cut-off, an insufficiently // small buffer was given, or other arbitrary error. since // it's not safe to view the amount of data (even though // the header is safe) in this feature, pretend it wasn't // transferred at all... TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "Feature %x exists, but not safe to access all its data. returning NULL\n", Feature)); return NULL; } else { return buffer; } }
if ((header->AdditionalLength % 4) && !(Feature >= 0xff00 && Feature <= 0xffff)) { return NULL; }
buffer += sizeof(FEATURE_HEADER); buffer += header->AdditionalLength; }
return NULL;}
_IRQL_requires_max_(APC_LEVEL)VOIDDevicePrintAllFeaturePages( _In_reads_bytes_(Usable) PGET_CONFIGURATION_HEADER Buffer, _In_ ULONG const Usable )/*++Routine Description:
print out all feature pages in the buffer
Arguments:
Buffer - buffer contains the device feature set.
Usable -
Return Value:
none
--*/{#if DBG PFEATURE_HEADER header;
PAGED_CODE();
//////////////////////////////////////////////////////////////////////////////// // items expected to ALWAYS be current if they exist ////////////////////////////////////////////////////////////////////////////////
header = DeviceFindFeaturePage(Buffer, Usable, FeatureProfileList); if (header != NULL) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: CurrentProfile %x " "with %x bytes of data at %p\n", Buffer->CurrentProfile[0] << 8 | Buffer->CurrentProfile[1], Usable, Buffer)); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureCore); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "CORE Features" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureMorphing); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Morphing" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureRemovableMedium); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Removable Medium" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeaturePowerManagement); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Power Management" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureEmbeddedChanger); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Embedded Changer" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureMicrocodeUpgrade); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Microcode Update" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureTimeout); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Timeouts" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureLogicalUnitSerialNumber); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "LUN Serial Number" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureFirmwareDate); if (header) {
ULONG featureSize = header->AdditionalLength; featureSize += RTL_SIZEOF_THROUGH_FIELD(FEATURE_HEADER, AdditionalLength);
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Firmware Date" ));
if (featureSize >= RTL_SIZEOF_THROUGH_FIELD(FEATURE_DATA_FIRMWARE_DATE, Minute)) { PFEATURE_DATA_FIRMWARE_DATE date = (PFEATURE_DATA_FIRMWARE_DATE)header; // show date as "YYYY/MM/DD hh:mm", which is 18 chars (17+NULL) UCHAR dateString[18] = { 0 }; dateString[ 0] = date->Year[0]; dateString[ 1] = date->Year[1]; dateString[ 2] = date->Year[2]; dateString[ 3] = date->Year[3]; dateString[ 4] = '/'; dateString[ 5] = date->Month[0]; dateString[ 6] = date->Month[1]; dateString[ 7] = '/'; dateString[ 8] = date->Day[0]; dateString[ 9] = date->Day[1]; dateString[10] = ' '; dateString[11] = ' '; dateString[12] = date->Hour[0]; dateString[13] = date->Hour[1]; dateString[14] = ':'; dateString[15] = date->Minute[0]; dateString[16] = date->Minute[1]; dateString[17] = 0; // SECONDS IS NOT AVAILABLE ON EARLY IMPLEMENTATIONS -- ignore it //dateString[17] = ':'; //dateString[18] = date->Seconds[0]; //dateString[19] = date->Seconds[1]; //dateString[20] = 0; TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: Firmware Date/Time %s (UTC)\n", (PCSTR)dateString )); } }
////////////////////////////////////////////////////////////////////////////////// items expected not to always be current////////////////////////////////////////////////////////////////////////////////
header = DeviceFindFeaturePage(Buffer, Usable, FeatureWriteProtect); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Software Write Protect" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureRandomReadable); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Random Reads" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureMultiRead); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Multi-Read" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureCdRead); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "reading from CD-ROM/R/RW" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDvdRead); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD Structure Reads" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureRandomWritable); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Random Writes" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureIncrementalStreamingWritable); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Incremental Streaming Writing" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureSectorErasable); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Sector Erasable Media" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureFormattable); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Formatting" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDefectManagement); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "defect management" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureWriteOnce); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Write Once Media" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureRestrictedOverwrite); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Restricted Overwrites" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureCdrwCAVWrite); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "CD-RW CAV recording" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureMrw); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Mount Rainier media" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureEnhancedDefectReporting); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Enhanced Defect Reporting" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDvdPlusRW); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD+RW media" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureRigidRestrictedOverwrite); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Rigid Restricted Overwrite" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureCdTrackAtOnce); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "CD Recording (Track At Once)" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureCdMastering); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "CD Recording (Mastering)" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDvdRecordableWrite); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD Recording (Mastering)" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDDCDRead); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DD CD Reading" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDDCDRWrite); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DD CD-R Writing" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDDCDRWWrite); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DD CD-RW Writing" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureLayerJumpRecording); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Layer Jump Recording" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureHDDVDRead); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "HD-DVD Reading" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureHDDVDWrite); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "HD-DVD Writing" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureSMART); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "S.M.A.R.T." )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureCDAudioAnalogPlay); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Analogue CD Audio Operations" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDvdCSS); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD CSS" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureRealTimeStreaming); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "Real-time Streaming Reads" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDiscControlBlocks); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD Disc Control Blocks" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureDvdCPRM); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "DVD CPRM" )); }
header = DeviceFindFeaturePage(Buffer, Usable, FeatureAACS); if (header) { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT, "CdromGetConfiguration: %s %s\n", (header->Current ? "Currently supports" : "Is able to support"), "AACS" )); }
#else PAGED_CODE();
UNREFERENCED_PARAMETER(Usable); UNREFERENCED_PARAMETER(Buffer);
#endif // DBG return;}
_IRQL_requires_max_(PASSIVE_LEVEL)NTSTATUSMediaReadCapacity( _In_ WDFDEVICE Device )/*++Routine Description:
Get media capacity
Arguments:
Device - the device that owns the media
Return Value:
NTSTATUS
--*/{ NTSTATUS status; SCSI_REQUEST_BLOCK srb; PCDB cdb = NULL; READ_CAPACITY_DATA capacityData;
PAGED_CODE();
RtlZeroMemory(&srb, sizeof(srb)); RtlZeroMemory(&capacityData, sizeof(capacityData));
cdb = (PCDB)(&srb.Cdb);
//Prepare SCSI command fields srb.CdbLength = 10; srb.TimeOutValue = CDROM_READ_CAPACITY_TIMEOUT; cdb->CDB10.OperationCode = SCSIOP_READ_CAPACITY;
status = DeviceSendSrbSynchronously(Device, &srb, &capacityData, sizeof(READ_CAPACITY_DATA), FALSE, NULL);
//Remember the result if (!NT_SUCCESS(status)) { //Set the BytesPerBlock to zero, this is for safe as if error happens this field should stay zero (no change). //it will be treated as error case in MediaReadCapacityDataInterpret() capacityData.BytesPerBlock = 0; }
MediaReadCapacityDataInterpret(Device, &capacityData);
return status;}
_IRQL_requires_max_(APC_LEVEL)VOIDMediaReadCapacityDataInterpret( _In_ WDFDEVICE Device, _In_ PREAD_CAPACITY_DATA ReadCapacityBuffer )/*++Routine Description:
Interpret media capacity and set corresponding fields in device context
Arguments:
Device - the device that owns the media
ReadCapacityBuffer - data buffer of capacity
Return Value:
none
--*/{ PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device); ULONG lastSector = 0; ULONG bps = 0; ULONG lastBit = 0; ULONG bytesPerBlock = 0; BOOLEAN errorHappened = FALSE;
PAGED_CODE();
NT_ASSERT(ReadCapacityBuffer);
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "MediaReadCapacityDataInterpret: Entering\n"));
// Swizzle bytes from Read Capacity and translate into // the necessary geometry information in the device extension. bytesPerBlock = ReadCapacityBuffer->BytesPerBlock;
((PFOUR_BYTE)&bps)->Byte0 = ((PFOUR_BYTE)&bytesPerBlock)->Byte3; ((PFOUR_BYTE)&bps)->Byte1 = ((PFOUR_BYTE)&bytesPerBlock)->Byte2; ((PFOUR_BYTE)&bps)->Byte2 = ((PFOUR_BYTE)&bytesPerBlock)->Byte1; ((PFOUR_BYTE)&bps)->Byte3 = ((PFOUR_BYTE)&bytesPerBlock)->Byte0;
// Insure that bps is a power of 2. // This corrects a problem with the HP 4020i CDR where it // returns an incorrect number for bytes per sector. if (!bps) { // Set disk geometry to default values (per ISO 9660). bps = 2048; errorHappened = TRUE; } else { lastBit = (ULONG)(-1); while (bps) { lastBit++; bps = (bps >> 1); } bps = (1 << lastBit); }
deviceExtension->DiskGeometry.BytesPerSector = bps;
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "MediaReadCapacityDataInterpret: Calculated bps %#x\n", deviceExtension->DiskGeometry.BytesPerSector));
// Copy last sector in reverse byte order. bytesPerBlock = ReadCapacityBuffer->LogicalBlockAddress;
((PFOUR_BYTE)&lastSector)->Byte0 = ((PFOUR_BYTE)&bytesPerBlock)->Byte3; ((PFOUR_BYTE)&lastSector)->Byte1 = ((PFOUR_BYTE)&bytesPerBlock)->Byte2; ((PFOUR_BYTE)&lastSector)->Byte2 = ((PFOUR_BYTE)&bytesPerBlock)->Byte1; ((PFOUR_BYTE)&lastSector)->Byte3 = ((PFOUR_BYTE)&bytesPerBlock)->Byte0;
// Calculate sector to byte shift. WHICH_BIT(bps, deviceExtension->SectorShift);
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL, "MediaReadCapacityDataInterpret: Sector size is %d\n", deviceExtension->DiskGeometry.BytesPerSector));
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "MediaReadCapacityDataInterpret: Number of Sectors is %d\n", lastSector + 1));
// Calculate media capacity in bytes. if (errorHappened) { // Set disk geometry to default values (per ISO 9660). deviceExtension->PartitionLength.QuadPart = (LONGLONG)(0x7fffffff); } else { deviceExtension->PartitionLength.QuadPart = (LONGLONG)(lastSector + 1); deviceExtension->PartitionLength.QuadPart = (deviceExtension->PartitionLength.QuadPart << deviceExtension->SectorShift); }
// we've defaulted to 32/64 forever. don't want to change this now... deviceExtension->DiskGeometry.TracksPerCylinder = 0x40; deviceExtension->DiskGeometry.SectorsPerTrack = 0x20;
// Calculate number of cylinders. deviceExtension->DiskGeometry.Cylinders.QuadPart = (LONGLONG)((lastSector + 1) / (32 * 64));
deviceExtension->DiskGeometry.MediaType = RemovableMedia;
return;}
_IRQL_requires_max_(APC_LEVEL)VOIDDevicePickDvdRegion( _In_ WDFDEVICE Device )/*++
Routine Description:
pick a default dvd region
Arguments:
Device - Device Object
Return Value:
none
--*/{ NTSTATUS status; PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
// these five pointers all point to dvdReadStructure or part of // its data, so don't deallocate them more than once! PDVD_READ_STRUCTURE dvdReadStructure; PDVD_COPY_PROTECT_KEY copyProtectKey; PDVD_COPYRIGHT_DESCRIPTOR dvdCopyRight; PDVD_RPC_KEY rpcKey; PDVD_SET_RPC_KEY dvdRpcKey;
size_t bytesReturned = 0; ULONG bufferLen = 0; UCHAR mediaRegion = 0; ULONG pickDvdRegion = 0; ULONG defaultDvdRegion = 0; ULONG dvdRegion = 0; WDFKEY registryKey = NULL;
DECLARE_CONST_UNICODE_STRING(registryValueName, DVD_DEFAULT_REGION);
PAGED_CODE();
if ((pickDvdRegion = InterlockedExchange((PLONG)&deviceExtension->DeviceAdditionalData.PickDvdRegion, 0)) == 0) { // it was non-zero, so either another thread will do this, or // we no longer need to pick a region return; }
bufferLen = max( max(sizeof(DVD_DESCRIPTOR_HEADER) + sizeof(DVD_COPYRIGHT_DESCRIPTOR), sizeof(DVD_READ_STRUCTURE) ), max(DVD_RPC_KEY_LENGTH, DVD_SET_RPC_KEY_LENGTH ) );
dvdReadStructure = (PDVD_READ_STRUCTURE) ExAllocatePoolWithTag(PagedPool, bufferLen, DVD_TAG_DVD_REGION);
if (dvdReadStructure == NULL) { InterlockedExchange((PLONG)&deviceExtension->DeviceAdditionalData.PickDvdRegion, pickDvdRegion); return; }
copyProtectKey = (PDVD_COPY_PROTECT_KEY)dvdReadStructure;
dvdCopyRight = (PDVD_COPYRIGHT_DESCRIPTOR) ((PDVD_DESCRIPTOR_HEADER)dvdReadStructure)->Data;
// get the media region RtlZeroMemory (dvdReadStructure, bufferLen); dvdReadStructure->Format = DvdCopyrightDescriptor;
// Build and send a request for READ_KEY TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Getting Copyright Descriptor\n", Device));
status = ReadDvdStructure(deviceExtension, NULL, dvdReadStructure, sizeof(DVD_READ_STRUCTURE), dvdReadStructure, sizeof(DVD_DESCRIPTOR_HEADER) + sizeof(DVD_COPYRIGHT_DESCRIPTOR), &bytesReturned);
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Got Copyright Descriptor %x\n", Device, status));
if ((NT_SUCCESS(status)) && (dvdCopyRight->CopyrightProtectionType == 0x01)) { // keep the media region bitmap around // a 1 means ok to play if (dvdCopyRight->RegionManagementInformation == 0xff) { TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): RegionManagementInformation " "is set to dis-allow playback for all regions. This is " "most likely a poorly authored disc. defaulting to all " "region disc for purpose of choosing initial region\n", Device)); dvdCopyRight->RegionManagementInformation = 0; }
mediaRegion = ~dvdCopyRight->RegionManagementInformation; } else { // can't automatically pick a default region on a drive without media, so just exit TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): failed to auto-choose a region due to status %x getting copyright descriptor\n", Device, status)); goto getout; }
// get the device region RtlZeroMemory (copyProtectKey, bufferLen); copyProtectKey->KeyLength = DVD_RPC_KEY_LENGTH; copyProtectKey->KeyType = DvdGetRpcKey;
// Build and send a request for READ_KEY for RPC key TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Getting RpcKey\n", Device)); status = DvdStartSessionReadKey(deviceExtension, IOCTL_DVD_READ_KEY, NULL, copyProtectKey, DVD_RPC_KEY_LENGTH, copyProtectKey, DVD_RPC_KEY_LENGTH, &bytesReturned);
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Got RpcKey %x\n", Device, status));
if (!NT_SUCCESS(status)) { TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): failed to get RpcKey from " "a DVD Device\n", Device)); goto getout; }
// so we now have what we can get for the media region and the // drive region. we will not set a region if the drive has one // set already (mask is not all 1's), nor will we set a region // if there are no more user resets available. rpcKey = (PDVD_RPC_KEY)copyProtectKey->KeyData;
if (rpcKey->RegionMask != 0xff) { TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): not picking a region since " "it is already chosen\n", Device)); goto getout; }
if (rpcKey->UserResetsAvailable <= 1) { TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): not picking a region since " "only one change remains\n", Device)); goto getout; }
// OOBE sets this key based upon the system locale status = WdfDriverOpenParametersRegistryKey(WdfGetDriver(), KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, ®istryKey);
if (NT_SUCCESS(status)) { status = WdfRegistryQueryULong(registryKey, ®istryValueName, &defaultDvdRegion);
WdfRegistryClose(registryKey); }
if (!NT_SUCCESS(status)) { TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): failed to read registry value due to status %x\n", Device, status));
// by default the default Dvd region is 0 defaultDvdRegion = 0; status = STATUS_SUCCESS; }
if (defaultDvdRegion > DVD_MAX_REGION) { // the registry has a bogus default TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): registry has a bogus default " "region value of %x\n", Device, defaultDvdRegion));
defaultDvdRegion = 0; }
// if defaultDvdRegion == 0, it means no default.
// we will select the initial dvd region for the user
if ((defaultDvdRegion != 0) && (mediaRegion & (1 << (defaultDvdRegion - 1)))) { // first choice: // the media has region that matches // the default dvd region. dvdRegion = (1 << (defaultDvdRegion - 1));
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Choice #1: media matches " "drive's default, chose region %x\n", Device, dvdRegion)); } else if (mediaRegion) { // second choice: // pick the lowest region number from the media UCHAR mask = 1; dvdRegion = 0;
while (mediaRegion && !dvdRegion) { // pick the lowest bit dvdRegion = mediaRegion & mask; mask <<= 1; }
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Choice #2: choosing lowest " "media region %x\n", Device, dvdRegion)); } else if (defaultDvdRegion) { // third choice: // default dvd region from the dvd class installer dvdRegion = (1 << (defaultDvdRegion - 1)); TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Choice #3: using default " "region for this install %x\n", Device, dvdRegion)); } else { // unable to pick one for the user -- this should rarely // happen, since the proppage dvd class installer sets // the key based upon the system locale TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Choice #4: failed to choose " "a media region\n", Device)); goto getout; }
// now that we've chosen a region, set the region by sending the // appropriate request to the drive RtlZeroMemory (copyProtectKey, bufferLen); copyProtectKey->KeyLength = DVD_SET_RPC_KEY_LENGTH; copyProtectKey->KeyType = DvdSetRpcKey; dvdRpcKey = (PDVD_SET_RPC_KEY)copyProtectKey->KeyData; dvdRpcKey->PreferredDriveRegionCode = (UCHAR)~dvdRegion;
// Build and send request for SEND_KEY TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Sending new Rpc Key to region %x\n", Device, dvdRegion));
status = DvdSendKey(deviceExtension, NULL, copyProtectKey, DVD_SET_RPC_KEY_LENGTH, &bytesReturned);
TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Sent new Rpc Key %x\n", Device, status));
if (!NT_SUCCESS(status)) { TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): unable to set dvd initial " " region code (%x)\n", Device, status)); } else { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL, "DevicePickDvdRegion (%p): Successfully set dvd " "initial region\n", Device));
pickDvdRegion = 0; }
getout: if (dvdReadStructure) { FREE_POOL(dvdReadStructure); }
// update the new PickDvdRegion value InterlockedExchange((PLONG)&deviceExtension->DeviceAdditionalData.PickDvdRegion, pickDvdRegion);
return;}
_IRQL_requires_max_(PASSIVE_LEVEL)NTSTATUSDeviceRegisterInterface( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ CDROM_DEVICE_INTERFACES InterfaceType )/*++Routine Description:
used to register device class interface or mount device interface
Arguments:
DeviceExtension - device context
InterfaceType - interface type to be registered.
Return Value:
NTSTATUS
--*/{ NTSTATUS status; WDFSTRING string = NULL; GUID* interfaceGuid = NULL; PUNICODE_STRING savingString = NULL; BOOLEAN setRestricted = FALSE; UNICODE_STRING localString;
PAGED_CODE();
//Get parameters switch(InterfaceType) { case CdRomDeviceInterface: interfaceGuid = (LPGUID)&GUID_DEVINTERFACE_CDROM; setRestricted = TRUE; savingString = &localString; break; case MountedDeviceInterface: interfaceGuid = (LPGUID)&MOUNTDEV_MOUNTED_DEVICE_GUID; savingString = &(DeviceExtension->MountedDeviceInterfaceName); break; default: return STATUS_INVALID_PARAMETER; }
status = WdfDeviceCreateDeviceInterface(DeviceExtension->Device, interfaceGuid, NULL);
if (!NT_SUCCESS(status)) { TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT, "DeviceRegisterInterface: Unable to register cdrom " "DCA for fdo %p type: %s [%lx]\n", DeviceExtension->Device, (InterfaceType == CdRomDeviceInterface)? "CdRom Interface" : "Mounted Device Interface", status)); }
// Retrieve interface string if (NT_SUCCESS(status)) { // The string object will be released when its parent object is released. WDF_OBJECT_ATTRIBUTES attributes;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes); attributes.ParentObject = DeviceExtension->Device;
status = WdfStringCreate(WDF_NO_OBJECT_ATTRIBUTES, NULL, &string); }
if (NT_SUCCESS(status)) { status = WdfDeviceRetrieveDeviceInterfaceString(DeviceExtension->Device, interfaceGuid, NULL, string); }
if (NT_SUCCESS(status)) { WdfStringGetUnicodeString(string, savingString);
if (setRestricted) {
WdfObjectDelete(string); } }
return status;} // end DeviceRegisterInterface()
VOIDNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */DeviceRestoreDefaultSpeed( _In_ WDFWORKITEM WorkItem )/*++
Routine Description:
This workitem is called on a media change when the CDROM device speed should be restored to the default value.
Arguments:
Fdo - Supplies the device object for the CDROM device. WorkItem - Supplies the pointer to the workitem.
Return Value:
None
--*/{ NTSTATUS status; WDFDEVICE device = WdfWorkItemGetParentObject(WorkItem); PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(device); PPERFORMANCE_DESCRIPTOR perfDescriptor; ULONG transferLength = sizeof(PERFORMANCE_DESCRIPTOR); SCSI_REQUEST_BLOCK srb = {0}; PCDB cdb = (PCDB)srb.Cdb;
PAGED_CODE();
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DeviceRestoreDefaultSpeed: Restore device speed for %p\n", device));
perfDescriptor = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, transferLength, CDROM_TAG_STREAM); if (perfDescriptor == NULL) { return; }
RtlZeroMemory(perfDescriptor, transferLength);
perfDescriptor->RestoreDefaults = TRUE;
srb.TimeOutValue = deviceExtension->TimeOutValue;
srb.CdbLength = 12; cdb->SET_STREAMING.OperationCode = SCSIOP_SET_STREAMING; REVERSE_BYTES_SHORT(&cdb->SET_STREAMING.ParameterListLength, &transferLength);
status = DeviceSendSrbSynchronously(device, &srb, perfDescriptor, transferLength, TRUE, NULL); TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DeviceRestoreDefaultSpeed: Set Streaming command completed with status: 0x%X\n", status));
FREE_POOL(perfDescriptor); WdfObjectDelete(WorkItem);
return;}
// custom string match -- careful!_IRQL_requires_max_(APC_LEVEL)BOOLEANStringsAreMatched( _In_opt_z_ PCHAR StringToMatch, _In_z_ PCHAR TargetString )/*++
Routine Description:
compares if two strings are identical
Arguments:
StringToMatch - source string. TargetString - target string.
Return Value:
BOOLEAN - TRUE (identical); FALSE (not match)
--*/{ size_t length;
PAGED_CODE();
NT_ASSERT(TargetString);
// if no match requested, return TRUE if (StringToMatch == NULL) { return TRUE; }
// cache the string length for efficiency length = strlen(StringToMatch);
// ZERO-length strings may only match zero-length strings if (length == 0) { return (strlen(TargetString) == 0); }
// strncmp returns zero if the strings match return (strncmp(StringToMatch, TargetString, length) == 0);}
NTSTATUSRequestSetContextFields( _In_ WDFREQUEST Request, _In_ PSYNC_HANDLER Handler )/*++
Routine Description:
set the request object context fields
Arguments:
Request - request object. Handler - the function that finally handles this request.
Return Value:
NTSTATUS
--*/{ NTSTATUS status = STATUS_SUCCESS; PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request); PKEVENT syncEvent = NULL;
syncEvent = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(KEVENT), CDROM_TAG_SYNC_EVENT);
if (syncEvent == NULL) { // memory allocation failed. status = STATUS_INSUFFICIENT_RESOURCES; } else { // now, put the special synchronization information into the context requestContext->SyncRequired = TRUE; requestContext->SyncEvent = syncEvent; requestContext->SyncCallback = Handler;
status = STATUS_SUCCESS; }
return status;}
NTSTATUSRequestDuidGetDeviceIdProperty( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t * DataLength )/*++
Routine Description:
Arguments:
DeviceExtension - device context Request - request object. RequestParameters - request parameter DataLength - transferred data length.
Return Value:
NTSTATUS
--*/{ NTSTATUS status = STATUS_SUCCESS; PSTORAGE_DEVICE_ID_DESCRIPTOR deviceIdDescriptor = NULL; PSTORAGE_DESCRIPTOR_HEADER descHeader = NULL; STORAGE_PROPERTY_ID propertyId = StorageDeviceIdProperty;
*DataLength = 0;
// Get the VPD page 83h data. status = DeviceRetrieveDescriptor(DeviceExtension->Device, &propertyId, (PSTORAGE_DESCRIPTOR_HEADER*)&deviceIdDescriptor);
if (NT_SUCCESS(status) && (deviceIdDescriptor == NULL)) { status = STATUS_NOT_FOUND; }
if (NT_SUCCESS(status)) { status = WdfRequestRetrieveOutputBuffer(Request, RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, &descHeader, NULL); }
if (NT_SUCCESS(status)) { PSTORAGE_DEVICE_UNIQUE_IDENTIFIER storageDuid = NULL; ULONG offset = descHeader->Size; PUCHAR dest = (PUCHAR)descHeader + offset; size_t outputBufferSize;
outputBufferSize = RequestParameters.Parameters.DeviceIoControl.OutputBufferLength;
// Adjust required size and potential destination location. status = RtlULongAdd(descHeader->Size, deviceIdDescriptor->Size, &descHeader->Size);
if (NT_SUCCESS(status) && (outputBufferSize < descHeader->Size)) { // Output buffer is too small. Return error and make sure // the caller gets info about required buffer size. *DataLength = descHeader->Size; status = STATUS_BUFFER_OVERFLOW; }
if (NT_SUCCESS(status)) { storageDuid = (PSTORAGE_DEVICE_UNIQUE_IDENTIFIER)descHeader; storageDuid->StorageDeviceIdOffset = offset;
RtlCopyMemory(dest, deviceIdDescriptor, deviceIdDescriptor->Size);
*DataLength = storageDuid->Size; status = STATUS_SUCCESS; }
FREE_POOL(deviceIdDescriptor); }
return status;}
NTSTATUSRequestDuidGetDeviceProperty( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t * DataLength )/*++
Routine Description:
Arguments:
DeviceExtension - device context Request - request object. RequestParameters - request parameter DataLength - transferred data length.
Return Value:
NTSTATUS
--*/{ NTSTATUS status = STATUS_SUCCESS; PSTORAGE_DEVICE_DESCRIPTOR deviceDescriptor = DeviceExtension->DeviceDescriptor; PSTORAGE_DESCRIPTOR_HEADER descHeader = NULL; PSTORAGE_DEVICE_UNIQUE_IDENTIFIER storageDuid; PUCHAR dest = NULL;
if (deviceDescriptor == NULL) { status = STATUS_NOT_FOUND; }
if (NT_SUCCESS(status)) { status = WdfRequestRetrieveOutputBuffer(Request, RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, &descHeader, NULL); }
if (NT_SUCCESS(status) && (deviceDescriptor->SerialNumberOffset == 0)) { status = STATUS_NOT_FOUND; }
// Use this info only if serial number is available. if (NT_SUCCESS(status)) { ULONG offset = descHeader->Size; size_t outputBufferSize = RequestParameters.Parameters.DeviceIoControl.OutputBufferLength;
// Adjust required size and potential destination location. dest = (PUCHAR)descHeader + offset;
status = RtlULongAdd(descHeader->Size, deviceDescriptor->Size, &descHeader->Size);
if (NT_SUCCESS(status) && (outputBufferSize < descHeader->Size)) { // Output buffer is too small. Return error and make sure // the caller get info about required buffer size. *DataLength = descHeader->Size; status = STATUS_BUFFER_OVERFLOW; }
if (NT_SUCCESS(status)) { storageDuid = (PSTORAGE_DEVICE_UNIQUE_IDENTIFIER)descHeader; storageDuid->StorageDeviceOffset = offset;
RtlCopyMemory(dest, deviceDescriptor, deviceDescriptor->Size);
*DataLength = storageDuid->Size; status = STATUS_SUCCESS; } }
return status;}
_IRQL_requires_max_(APC_LEVEL)ULONGDeviceRetrieveModeSenseUsingScratch( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageCode, _In_ UCHAR PageControl )/*++
Routine Description:
retrieve mode sense informaiton of the device
Arguments:
DeviceExtension - device context ModeSenseBuffer - buffer to savee the mode sense info. Length - buffer length PageCode - . PageControl -
Return Value:
ULONG - transferred data length
--*/{ NTSTATUS status = STATUS_SUCCESS; ULONG transferSize = min(Length, DeviceExtension->ScratchContext.ScratchBufferSize); CDB cdb;
PAGED_CODE();
ScratchBuffer_BeginUse(DeviceExtension);
RtlZeroMemory(&cdb, sizeof(CDB)); // Set up the CDB cdb.MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE; cdb.MODE_SENSE.PageCode = PageCode; cdb.MODE_SENSE.Pc = PageControl; cdb.MODE_SENSE.AllocationLength = (UCHAR)transferSize;
status = ScratchBuffer_ExecuteCdb(DeviceExtension, NULL, transferSize, TRUE, &cdb, 6);
if (NT_SUCCESS(status)) { transferSize = min(Length, DeviceExtension->ScratchContext.ScratchSrb->DataTransferLength); RtlCopyMemory(ModeSenseBuffer, DeviceExtension->ScratchContext.ScratchBuffer, transferSize); }
ScratchBuffer_EndUse(DeviceExtension);
return transferSize;}
_IRQL_requires_max_(APC_LEVEL)PVOIDModeSenseFindSpecificPage( _In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ size_t Length, _In_ UCHAR PageMode, _In_ BOOLEAN Use6BytesCdb )/*++
Routine Description:
This routine scans through the mode sense data and finds the requested mode sense page code.
Arguments: ModeSenseBuffer - Supplies a pointer to the mode sense data.
Length - Indicates the length of valid data.
PageMode - Supplies the page mode to be searched for.
Use6BytesCdb - Indicates whether 6 or 10 byte mode sense was used.
Return Value:
A pointer to the the requested mode page. If the mode page was not found then NULL is return.
--*/{ PCHAR limit; ULONG parameterHeaderLength; PVOID result = NULL;
PAGED_CODE();
limit = ModeSenseBuffer + Length; parameterHeaderLength = (Use6BytesCdb) ? sizeof(MODE_PARAMETER_HEADER) : sizeof(MODE_PARAMETER_HEADER10);
if (Length >= parameterHeaderLength) { PMODE_PARAMETER_HEADER10 modeParam10; ULONG blockDescriptorLength;
// Skip the mode select header and block descriptors. if (Use6BytesCdb) { blockDescriptorLength = ((PMODE_PARAMETER_HEADER)ModeSenseBuffer)->BlockDescriptorLength; } else { modeParam10 = (PMODE_PARAMETER_HEADER10) ModeSenseBuffer; blockDescriptorLength = modeParam10->BlockDescriptorLength[1]; }
ModeSenseBuffer += parameterHeaderLength + blockDescriptorLength;
// ModeSenseBuffer now points at pages. Walk the pages looking for the // requested page until the limit is reached. while (ModeSenseBuffer + RTL_SIZEOF_THROUGH_FIELD(MODE_DISCONNECT_PAGE, PageLength) < limit) { if (((PMODE_DISCONNECT_PAGE) ModeSenseBuffer)->PageCode == PageMode) { // found the mode page. make sure it's safe to touch it all // before returning the pointer to caller if (ModeSenseBuffer + ((PMODE_DISCONNECT_PAGE)ModeSenseBuffer)->PageLength > limit) { // Return NULL since the page is not safe to access in full result = NULL; } else { result = ModeSenseBuffer; } break; }
// Advance to the next page which is 4-byte-aligned offset after this page. ModeSenseBuffer += ((PMODE_DISCONNECT_PAGE) ModeSenseBuffer)->PageLength + RTL_SIZEOF_THROUGH_FIELD(MODE_DISCONNECT_PAGE, PageLength); } }
return result;} // end ModeSenseFindSpecificPage()
_IRQL_requires_max_(PASSIVE_LEVEL)NTSTATUSPerformEjectionControl( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ MEDIA_LOCK_TYPE LockType, _In_ BOOLEAN Lock )/*++
Routine Description:
ejection control process
Arguments:
DeviceExtension - device extension Request - WDF request to be used for communication with the device LockType - the type of lock Lock - if TRUE, lock the device; if FALSE, unlock it
Return Value:
NTSTATUS
--*/{ NTSTATUS status; PFILE_OBJECT_CONTEXT fileObjectContext = NULL; SCSI_REQUEST_BLOCK srb; PCDB cdb = NULL;
LONG newLockCount = 0; LONG newProtectedLockCount = 0; LONG newInternalLockCount = 0; LONG newFileLockCount = 0; BOOLEAN countChanged = FALSE; BOOLEAN previouslyLocked = FALSE; BOOLEAN nowLocked = FALSE;
PAGED_CODE();
// Prevent race conditions while working with lock counts status = WdfWaitLockAcquire(DeviceExtension->EjectSynchronizationLock, NULL); if (!NT_SUCCESS(status)) { NT_ASSERT(FALSE); }
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "PerformEjectionControl: " "Received request for %s lock type\n", LockTypeStrings[LockType] ));
// If this is a "secured" request, retrieve the file object context if (LockType == SecureMediaLock) { WDFFILEOBJECT fileObject = NULL;
fileObject = WdfRequestGetFileObject(Request);
if (fileObject == NULL) { status = STATUS_INVALID_HANDLE;
TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "FileObject does not match to the one in IRP_MJ_CREATE, KMDF returns NULL\n")); goto Exit; }
fileObjectContext = FileObjectGetContext(fileObject); NT_ASSERT(fileObjectContext != NULL); }
// Lock counts should never fall below 0 NT_ASSERT(DeviceExtension->LockCount >= 0); NT_ASSERT(DeviceExtension->ProtectedLockCount >= 0); NT_ASSERT(DeviceExtension->InternalLockCount >= 0);
// Get the current lock counts newLockCount = DeviceExtension->LockCount; newProtectedLockCount = DeviceExtension->ProtectedLockCount; newInternalLockCount = DeviceExtension->InternalLockCount; if (fileObjectContext) { // fileObjectContext->LockCount is ULONG and should always >= 0 newFileLockCount = fileObjectContext->LockCount; }
// Determine which lock counts need to be changed and how if (Lock && LockType == SimpleMediaLock) { newLockCount++; countChanged = TRUE; } else if (Lock && LockType == SecureMediaLock) { newFileLockCount++; newProtectedLockCount++; countChanged = TRUE; } else if (Lock && LockType == InternalMediaLock) { newInternalLockCount++; countChanged = TRUE; } else if (!Lock && LockType == SimpleMediaLock) { if (newLockCount != 0) { newLockCount--; countChanged = TRUE; } } else if (!Lock && LockType == SecureMediaLock) { if ( (newFileLockCount == 0) || (newProtectedLockCount == 0) ) { status = STATUS_INVALID_DEVICE_STATE; goto Exit; } newFileLockCount--; newProtectedLockCount--; countChanged = TRUE; } else if (!Lock && LockType == InternalMediaLock) { NT_ASSERT(newInternalLockCount != 0); newInternalLockCount--; countChanged = TRUE; }
if ( (DeviceExtension->LockCount != 0) || (DeviceExtension->ProtectedLockCount != 0) || (DeviceExtension->InternalLockCount != 0) ) { previouslyLocked = TRUE; } if ( (newLockCount != 0) || (newProtectedLockCount != 0) || (newInternalLockCount != 0) ) { nowLocked = TRUE; }
// Only send command down to device when necessary if (previouslyLocked != nowLocked) { // Compose and send the PREVENT ALLOW MEDIA REMOVAL command. RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));
srb.CdbLength = 6; srb.TimeOutValue = DeviceExtension->TimeOutValue;
cdb = (PCDB)&srb.Cdb; cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL; cdb->MEDIA_REMOVAL.Prevent = Lock;
status = DeviceSendSrbSynchronously(DeviceExtension->Device, &srb, NULL, 0, FALSE, Request); }
Exit:
// Store the updated lock counts on success if (countChanged && NT_SUCCESS(status)) { DeviceExtension->LockCount = newLockCount; DeviceExtension->ProtectedLockCount = newProtectedLockCount; DeviceExtension->InternalLockCount = newInternalLockCount; if (fileObjectContext) { fileObjectContext->LockCount = newFileLockCount; } }
WdfWaitLockRelease(DeviceExtension->EjectSynchronizationLock);
TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "PerformEjectionControl: %!STATUS!, " "Count Changed: %d, Command Sent: %d, " "Current Counts: Internal: %x Secure: %x Simple: %x\n", status, countChanged, previouslyLocked != nowLocked, DeviceExtension->InternalLockCount, DeviceExtension->ProtectedLockCount, DeviceExtension->LockCount ));
return status;}
_IRQL_requires_max_(APC_LEVEL)NTSTATUSDeviceUnlockExclusive( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFFILEOBJECT FileObject, _In_ BOOLEAN IgnorePreviousMediaChanges )/*++
Routine Description:
to unlock the exclusive lock
Arguments:
DeviceExtension - device context FileObject - file object that currently holds the lock IgnorePreviousMediaChanges - if TRUE, ignore previously accumulated media changes
Return Value:
NTSTATUS
--*/{ NTSTATUS status = STATUS_SUCCESS; PCDROM_DATA cdData = &DeviceExtension->DeviceAdditionalData; PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; BOOLEAN ANPending = 0; LONG requestInUse = 0;
PAGED_CODE();
if (!EXCLUSIVE_MODE(cdData)) { // Device is not locked for exclusive access. // Can not process unlock request. TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "RequestHandleExclusiveAccessUnlockDevice: Device not locked for exclusive access, can't unlock device.\n")); status = STATUS_INVALID_DEVICE_REQUEST; } else if (!EXCLUSIVE_OWNER(cdData, FileObject)) { // Request not from the exclusive owner, can't unlock the device. TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "RequestHandleExclusiveAccessUnlockDevice: Unable to unlock device, invalid file object\n"));
status = STATUS_INVALID_HANDLE; }
if (NT_SUCCESS(status)) { // Unless we were explicitly requested not to do so, generate a media removal notification // followed by a media arrival notification similar to volume lock/unlock file system events. if (!IgnorePreviousMediaChanges) { MEDIA_CHANGE_DETECTION_STATE previousMediaState = MediaUnknown;
// Change the media state to "unavailable", which will cause a removal notification if the media // was previously present. At the same time, store the previous state in previousMediaState. DeviceSetMediaChangeStateEx(DeviceExtension, MediaUnavailable, &previousMediaState); TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DeviceUnlockExclusive: Changing the media state to MediaUnavailable\n"));
// Restore the previous media state, which will cause a media arrival notification if the media // was originally present. DeviceSetMediaChangeStateEx(DeviceExtension, previousMediaState, NULL); }
// Set DO_VERIFY_VOLUME so that the file system will remount on it. if (IsVolumeMounted(DeviceExtension->DeviceObject)) { SET_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME); }
// Set MMC state to update required cdData->Mmc.WriteAllowed = FALSE; cdData->Mmc.UpdateState = CdromMmcUpdateRequired;
// Send unlock notification DeviceSendNotification(DeviceExtension, &GUID_IO_CDROM_EXCLUSIVE_UNLOCK, 0, NULL);
InterlockedExchangePointer((PVOID)&cdData->ExclusiveOwner, NULL);
if ((info != NULL) && (info->AsynchronousNotificationSupported != FALSE)) { ANPending = info->ANSignalPendingDueToExclusiveLock; info->ANSignalPendingDueToExclusiveLock = FALSE;
if ((ANPending != FALSE) && (info->MediaChangeDetectionDisableCount == 0)) { // if the request is not in use, mark it as such. requestInUse = InterlockedCompareExchange((PLONG)&info->MediaChangeRequestInUse, 1, 0);
if (requestInUse == 0) { // The last MCN finished. ok to issue the new one. RequestSetupMcnSyncIrp(DeviceExtension);
// The irp will go into KMDF framework and a request will be created there to represent it. IoCallDriver(DeviceExtension->DeviceObject, info->MediaChangeSyncIrp); } } } }
return status;}
VOIDRequestCompletion( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ NTSTATUS Status, _In_ ULONG_PTR Information ){#ifdef DBG ULONG ioctlCode = 0; WDF_REQUEST_PARAMETERS requestParameters;
// Get the Request parameters WDF_REQUEST_PARAMETERS_INIT(&requestParameters); WdfRequestGetParameters(Request, &requestParameters);
if (requestParameters.Type == WdfRequestTypeDeviceControl) { ioctlCode = requestParameters.Parameters.DeviceIoControl.IoControlCode;
if (requestParameters.Parameters.DeviceIoControl.IoControlCode != IOCTL_MCN_SYNC_FAKE_IOCTL) { TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "Request complete - IOCTL - code: %X; Status: %X; Information: %X\n", ioctlCode, Status, (ULONG)Information)); } else { TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL, "Request complete - IOCTL - code: %X; Status: %X; Information: %X\n", ioctlCode, Status, (ULONG)Information)); } } else if (requestParameters.Type == WdfRequestTypeRead) { TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "Request complete - READ - Starting Offset: %X; Length: %X; Transferred Length: %X; Status: %X\n", (ULONG)requestParameters.Parameters.Read.DeviceOffset, (ULONG)requestParameters.Parameters.Read.Length, (ULONG)Information, Status)); } else if (requestParameters.Type == WdfRequestTypeWrite) { TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "Request complete - WRITE - Starting Offset: %X; Length: %X; Transferred Length: %X; Status: %X\n", (ULONG)requestParameters.Parameters.Write.DeviceOffset, (ULONG)requestParameters.Parameters.Write.Length, (ULONG)Information, Status)); }#endif
if (IoIsErrorUserInduced(Status)) { PIRP irp = WdfRequestWdmGetIrp(Request); if (irp->Tail.Overlay.Thread) { IoSetHardErrorOrVerifyDevice(irp, DeviceExtension->DeviceObject); } }
if (!NT_SUCCESS(Status) && DeviceExtension->SurpriseRemoved == TRUE) { // IMAPI expects ERROR_DEV_NOT_EXISTS if recorder has been surprised removed, // or it will retry WRITE commands for up to 3 minutes // CDROM behavior should be consistent for all requests, including SCSI pass-through Status = STATUS_DEVICE_DOES_NOT_EXIST; }
WdfRequestCompleteWithInformation(Request, Status, Information);
return;}
VOIDNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */RequestDummyCompletionRoutine( _In_ WDFREQUEST Request, _In_ WDFIOTARGET Target, _In_ PWDF_REQUEST_COMPLETION_PARAMS Params, _In_ WDFCONTEXT Context )/*++
Routine Description:
This is a dummy competion routine that simply calls WdfRequestComplete. We have to use this dummy competion routine instead of WDF_REQUEST_SEND_OPTION_SEND_AND_FORGET, because the latter causes the framework to not check if the I/O target is closed or not.
Arguments:
Request - completed request Target - the I/O target that completed the request Params - request parameters Context - not used
Return Value:
none
--*/{ UNREFERENCED_PARAMETER(Target); UNREFERENCED_PARAMETER(Params); UNREFERENCED_PARAMETER(Context);
WdfRequestCompleteWithInformation(Request, WdfRequestGetStatus(Request), WdfRequestGetInformation(Request));}
_IRQL_requires_max_(DISPATCH_LEVEL)NTSTATUSDeviceSendPowerDownProcessRequest( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE CompletionRoutine, _In_opt_ PVOID Context )/*++
Routine Description:
This function is called during processing power down request. It is used to send either SYNC CACHE command or STOP UNIT command.
Caller should set proper value in deviceExtension->PowerContext.PowerChangeState.PowerDown to trigger the correct command be sent.
Arguments:
DeviceExtension -
CompletionRoutine - Completion routine that needs to be set for the request
Context - Completion context associated with the completion routine
Return Value:
NTSTATUS
--*/{ NTSTATUS status; BOOLEAN requestSent = FALSE;
BOOLEAN shouldRetry = TRUE; PCDB cdb = (PCDB)DeviceExtension->PowerContext.Srb.Cdb; ULONG timeoutValue = DeviceExtension->TimeOutValue; ULONG retryCount = 1;
// reset some fields. DeviceExtension->PowerContext.RetryIntervalIn100ns = 0; status = PowerContextReuseRequest(DeviceExtension); RequestClearSendTime(DeviceExtension->PowerContext.PowerRequest);
if (!NT_SUCCESS(status)) { return status; }
// set proper timeout value and max retry count. switch(DeviceExtension->PowerContext.PowerChangeState.PowerDown) { case PowerDownDeviceInitial: case PowerDownDeviceQuiesced: case PowerDownDeviceStopped: break;
case PowerDownDeviceLocked: // Case of issuing SYNC CACHE command. Do not use power irp timeout remaining time in this case // as we want to give best try on SYNC CACHE command. retryCount = MAXIMUM_RETRIES; timeoutValue = DeviceExtension->TimeOutValue; break;
case PowerDownDeviceFlushed: { // Case of issuing STOP UNIT command // As "Imme" bit is set to '1', this command should be completed in short time. // This command is at low importance, failure of this command has very small impact. ULONG secondsRemaining = 0;
#if (WINVER >= 0x0601) // this API is introduced in Windows7 PoQueryWatchdogTime(DeviceExtension->LowerPdo, &secondsRemaining);#endif
if (secondsRemaining == 0) { // not able to retrieve remaining time from PoQueryWatchdogTime API, use default values. retryCount = MAXIMUM_RETRIES; timeoutValue = SCSI_CDROM_TIMEOUT; } else { // plan to leave about 30 seconds to lower level drivers if possible. if (secondsRemaining >= 32) { retryCount = (secondsRemaining - 30)/SCSI_CDROM_TIMEOUT + 1; timeoutValue = SCSI_CDROM_TIMEOUT;
if (retryCount > MAXIMUM_RETRIES) { retryCount = MAXIMUM_RETRIES; }
if (retryCount == 1) { timeoutValue = secondsRemaining - 30; } } else { // issue the command with minimal timeout value and do not retry on it. retryCount = 1; timeoutValue = 2; } } } break; default: NT_ASSERT( FALSE ); status = STATUS_NOT_IMPLEMENTED; return status; }
DeviceExtension->PowerContext.RetryCount = retryCount;
// issue command. while (shouldRetry) {
// set SRB fields. DeviceExtension->PowerContext.Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER | SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE | SRB_FLAGS_BYPASS_LOCKED_QUEUE | SRB_FLAGS_D3_PROCESSING;
DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_EXECUTE_SCSI; DeviceExtension->PowerContext.Srb.TimeOutValue = timeoutValue;
if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceInitial) { DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_LOCK_QUEUE; } else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceLocked) { DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_QUIESCE_DEVICE; } else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced) { // Case of issuing SYNC CACHE command. DeviceExtension->PowerContext.Srb.CdbLength = 10; cdb->SYNCHRONIZE_CACHE10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE; } else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceFlushed) { // Case of issuing STOP UNIT command. DeviceExtension->PowerContext.Srb.CdbLength = 6; cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT; cdb->START_STOP.Start = 0; cdb->START_STOP.Immediate = 1; } else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceStopped) { DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_UNLOCK_QUEUE; }
// Set up completion routine and context if requested if (CompletionRoutine) { WdfRequestSetCompletionRoutine(DeviceExtension->PowerContext.PowerRequest, CompletionRoutine, Context); }
status = RequestSend(DeviceExtension, DeviceExtension->PowerContext.PowerRequest, DeviceExtension->IoTarget, CompletionRoutine ? 0 : WDF_REQUEST_SEND_OPTION_SYNCHRONOUS, &requestSent);
if (requestSent) { if ((CompletionRoutine == NULL) && (SRB_STATUS(DeviceExtension->PowerContext.Srb.SrbStatus) != SRB_STATUS_SUCCESS)) { TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_POWER, "%p\tError occured when issuing %s command to device. Srb %p, Status %x\n", DeviceExtension->PowerContext.PowerRequest, (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced) ? "SYNC CACHE" : "STOP UNIT", &DeviceExtension->PowerContext.Srb, DeviceExtension->PowerContext.Srb.SrbStatus));
NT_ASSERT(!(TEST_FLAG(DeviceExtension->PowerContext.Srb.SrbStatus, SRB_STATUS_QUEUE_FROZEN)));
shouldRetry = RequestSenseInfoInterpret(DeviceExtension, DeviceExtension->PowerContext.PowerRequest, &(DeviceExtension->PowerContext.Srb), retryCount - DeviceExtension->PowerContext.RetryCount, &status, &(DeviceExtension->PowerContext.RetryIntervalIn100ns));
if (shouldRetry && (DeviceExtension->PowerContext.RetryCount-- == 0)) { shouldRetry = FALSE; } } else { // succeeded, do not need to retry. shouldRetry = FALSE; }
} else { // request failed to be sent shouldRetry = FALSE; }
if (shouldRetry) { LARGE_INTEGER t; t.QuadPart = -DeviceExtension->PowerContext.RetryIntervalIn100ns; KeDelayExecutionThread(KernelMode, FALSE, &t);
status = PowerContextReuseRequest(DeviceExtension); if (!NT_SUCCESS(status)) { shouldRetry = FALSE; } } }
if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced) { // record SYNC CACHE command completion time stamp. KeQueryTickCount(&DeviceExtension->PowerContext.Step1CompleteTime); }
return status;}
NTSTATUSRequestSend( _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDFIOTARGET IoTarget, _In_ ULONG Flags, _Out_opt_ PBOOLEAN RequestSent )/*++
Routine Description:
Send the request to the target, wake up the device from Zero Power state if necessary.
Arguments:
DeviceExtension - device extension Request - the request to be sent IoTarget - target of the above request Flags - flags for the operation RequestSent - optional, if the request was sent
Return Value:
NTSTATUS
--*/{ NTSTATUS status = STATUS_SUCCESS; BOOLEAN requestSent = FALSE; WDF_REQUEST_SEND_OPTIONS options;
UNREFERENCED_PARAMETER(DeviceExtension);
if ((DeviceExtension->ZeroPowerODDInfo != NULL) && (DeviceExtension->ZeroPowerODDInfo->InZeroPowerState != FALSE)) { }
// Now send down the request if (NT_SUCCESS(status)) { WDF_REQUEST_SEND_OPTIONS_INIT(&options, Flags);
RequestSetSentTime(Request);
// send request and check status
// Disable SDV warning about infinitely waiting in caller's context: // 1. Some requests (such as SCSI_PASS_THROUGH, contains buffer from user space) need to be sent down in caller�s context. // Consequently, these requests wait in caller�s context until they are allowed to be sent down. // 2. Considering the situation that during sleep, a request can be hold by storage port driver. When system resumes, any time out value (if we set using KMDF time out value) might be expires. // This will cause the waiting request being failed (behavior change). We�d rather not set time out value.
_Analysis_assume_(options.Timeout != 0); requestSent = WdfRequestSend(Request, IoTarget, &options); _Analysis_assume_(options.Timeout == 0);
// If WdfRequestSend fails, or if the WDF_REQUEST_SEND_OPTION_SYNCHRONOUS flag is set, // the driver can call WdfRequestGetStatus immediately after calling WdfRequestSend. if ((requestSent == FALSE) || (Flags & WDF_REQUEST_SEND_OPTION_SYNCHRONOUS)) { status = WdfRequestGetStatus(Request);
if (requestSent == FALSE) { TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "WdfRequestSend failed: %lx\n", status )); } } else { status = STATUS_SUCCESS; }
if (RequestSent != NULL) { *RequestSent = requestSent; } }
return status;}