Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654////////////////////////////////////////////////////////////////////// Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine// All rights reserved// This file was released under the GPLv2 on June 2015.////////////////////////////////////////////////////////////////////
/*********************************************************************/
OSSTATUS __fastcall WCacheCheckLimits(IN PW_CACHE Cache, IN PVOID Context, IN lba_t ReqLba, IN ULONG BCount);
OSSTATUS __fastcall WCacheCheckLimitsRAM(IN PW_CACHE Cache, IN PVOID Context, IN lba_t ReqLba, IN ULONG BCount);
OSSTATUS __fastcall WCacheCheckLimitsRW(IN PW_CACHE Cache, IN PVOID Context, IN lba_t ReqLba, IN ULONG BCount);
OSSTATUS __fastcall WCacheCheckLimitsR(IN PW_CACHE Cache, IN PVOID Context, IN lba_t ReqLba, IN ULONG BCount);
VOID __fastcall WCachePurgeAllRW(IN PW_CACHE Cache, IN PVOID Context);
VOID __fastcall WCacheFlushAllRW(IN PW_CACHE Cache, IN PVOID Context);
VOID __fastcall WCachePurgeAllR(IN PW_CACHE Cache, IN PVOID Context);
OSSTATUS __fastcall WCacheDecodeFlags(IN PW_CACHE Cache, IN ULONG Flags);
#define ASYNC_STATE_NONE 0#define ASYNC_STATE_READ_PRE 1#define ASYNC_STATE_READ 2#define ASYNC_STATE_WRITE_PRE 3#define ASYNC_STATE_WRITE 4#define ASYNC_STATE_DONE 5
#define ASYNC_CMD_NONE 0#define ASYNC_CMD_READ 1#define ASYNC_CMD_UPDATE 2
#define WCACHE_MAX_CHAIN (0x10)
#define MEM_WCCTX_TAG 'xtCW'#define MEM_WCFRM_TAG 'rfCW'#define MEM_WCBUF_TAG 'fbCW'
#define USE_WC_PRINT
#ifdef USE_WC_PRINT #define WcPrint UDFPrint#else #define WcPrint(x) {;}#endif
typedef struct _W_CACHE_ASYNC { UDF_PH_CALL_CONTEXT PhContext; ULONG State; ULONG Cmd; PW_CACHE Cache; PVOID Buffer; PVOID Buffer2; SIZE_T TransferredBytes; ULONG BCount; lba_t Lba; struct _W_CACHE_ASYNC* NextWContext; struct _W_CACHE_ASYNC* PrevWContext;} W_CACHE_ASYNC, *PW_CACHE_ASYNC;
VOIDWCacheUpdatePacketComplete( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN OUT PW_CACHE_ASYNC* FirstWContext, // pointer to head async IO context IN OUT PW_CACHE_ASYNC* PrevWContext, // pointer to tail async IO context IN BOOLEAN FreePacket = TRUE );
/*********************************************************************/ULONG WCache_random;
/* WCacheInit__() fills all necesary fileds in passed in PW_CACHE Cache structure, allocates memory and synchronization resources. Cacheable area is subdiveded on Frames - contiguous sets of blocks. Internally each Frame is an array of pointers and attributes of cached Blocks. To optimize memory usage WCache keeps in memory limited number of frames (MaxFrames). Frame length (number of Blocks) must be be a power of 2 and aligned on minimum writeable block size - Packet. Packet size must be a power of 2 (2, 4, 8, 16, etc.). Each cached Block belongs to one of the Frames. To optimize memory usage WCache keeps in memory limited number of Blocks (MaxBlocks). Block size must be a power of 2. WCache splits low-level request(s) into some parts if requested data length exceeds MaxBytesToRead. If requested data length exceeds maximum cache size WCache makes recursive calls to read/write routines with shorter requests
WCacheInit__() returns initialization status. If initialization failed, all allocated memory and resources are automaticelly freed.
Public routine */OSSTATUSWCacheInit__( IN PW_CACHE Cache, // pointer to the Cache Control structure to be initialized IN ULONG MaxFrames, // maximum number of Frames to be kept in memory // simultaneously IN ULONG MaxBlocks, // maximum number of Blocks to be kept in memory // simultaneously IN SIZE_T MaxBytesToRead, // maximum IO length (split boundary) IN ULONG PacketSizeSh, // number of blocks in packet (bit shift) // Packes size = 2^PacketSizeSh IN ULONG BlockSizeSh, // Block size (bit shift) // Block size = 2^BlockSizeSh IN ULONG BlocksPerFrameSh,// number of blocks in Frame (bit shift) // Frame size = 2^BlocksPerFrameSh IN lba_t FirstLba, // Logical Block Address (LBA) of the 1st block // in cacheable area IN lba_t LastLba, // Logical Block Address (LBA) of the last block // in cacheable area IN ULONG Mode, // media mode: // WCACHE_MODE_ROM // WCACHE_MODE_RW // WCACHE_MODE_R // WCACHE_MODE_RAM // the following modes are planned to be implemented: // WCACHE_MODE_EWR IN ULONG Flags, // cache mode flags: // WCACHE_CACHE_WHOLE_PACKET // read long (Packet-sized) blocks of // data from media IN ULONG FramesToKeepFree, // number of Frames to be flushed & purged from cache // when Frame counter reaches top-limit and allocation // of a new Frame required IN PWRITE_BLOCK WriteProc, // pointer to synchronous physical write call-back routine IN PREAD_BLOCK ReadProc, // pointer to synchronous physical read call-back routine IN PWRITE_BLOCK_ASYNC WriteProcAsync, // pointer to _asynchronous_ physical write call-back routine // currently must be set to NULL because async support // is not completly implemented IN PREAD_BLOCK_ASYNC ReadProcAsync, // pointer to _asynchronous_ physical read call-back routine // must be set to NULL (see above) IN PCHECK_BLOCK CheckUsedProc, // pointer to call-back routine that checks whether the Block // specified (by LBA) is allocated for some data or should // be treated as unused (and thus, zero-filled). // Is used to avoid physical reads and writes from/to such Blocks IN PUPDATE_RELOC UpdateRelocProc, // pointer to call-back routine that updates caller's // relocation table _after_ physical write (append) in WORM // (WCACHE_MODE_R) mode. WCache sends original and new // (derived from last LBA) logical addresses to this routine IN PWC_ERROR_HANDLER ErrorHandlerProc ){ ULONG l1, l2, l3; ULONG PacketSize = (1) << PacketSizeSh; ULONG BlockSize = (1) << BlockSizeSh; ULONG BlocksPerFrame = (1) << BlocksPerFrameSh; OSSTATUS RC = STATUS_SUCCESS; LARGE_INTEGER rseed; ULONG res_init_flags = 0;
#define WCLOCK_RES 1
_SEH2_TRY { // check input parameters if(Mode == WCACHE_MODE_R) { UDFPrint(("Disable Async-Write for WORM media\n")); WriteProcAsync = NULL; } if((MaxBlocks % PacketSize) || !MaxBlocks) { UDFPrint(("Total number of sectors must be packet-size-aligned\n")); try_return(RC = STATUS_INVALID_PARAMETER); } if(BlocksPerFrame % PacketSize) { UDFPrint(("Number of sectors per Frame must be packet-size-aligned\n")); try_return(RC = STATUS_INVALID_PARAMETER); } if(!ReadProc) { UDFPrint(("Read routine pointer must be valid\n")); try_return(RC = STATUS_INVALID_PARAMETER); } if(FirstLba >= LastLba) { UDFPrint(("Invalid cached area parameters: (%x - %x)\n",FirstLba, LastLba)); try_return(RC = STATUS_INVALID_PARAMETER); } if(!MaxFrames) { UDFPrint(("Total frame number must be non-zero\n",FirstLba, LastLba)); try_return(RC = STATUS_INVALID_PARAMETER); } if(Mode > WCACHE_MODE_MAX) { UDFPrint(("Invalid media mode. Should be 0-%x\n",WCACHE_MODE_MAX)); try_return(RC = STATUS_INVALID_PARAMETER); } if(FramesToKeepFree >= MaxFrames/2) { UDFPrint(("Invalid FramesToKeepFree (%x). Should be Less or equal to MaxFrames/2 (%x)\n", FramesToKeepFree, MaxFrames/2)); try_return(RC = STATUS_INVALID_PARAMETER); } // check 'features' if(!WriteProc) { UDFPrint(("Write routine not specified\n")); UDFPrint(("Read-only mode enabled\n")); } MaxBlocks = max(MaxBlocks, BlocksPerFrame*3); // initialize required structures // we'll align structure size on system page size to // avoid system crashes caused by pool fragmentation if(!(Cache->FrameList = (PW_CACHE_FRAME)MyAllocatePoolTag__(NonPagedPool, l1 = (((LastLba >> BlocksPerFrameSh)+1)*sizeof(W_CACHE_FRAME)), MEM_WCFRM_TAG) )) { UDFPrint(("Cache init err 1\n")); try_return(RC = STATUS_INSUFFICIENT_RESOURCES); } if(!(Cache->CachedBlocksList = (PULONG)MyAllocatePoolTag__(NonPagedPool, l2 = ((MaxBlocks+2)*sizeof(lba_t)), MEM_WCFRM_TAG) )) { UDFPrint(("Cache init err 2\n")); try_return(RC = STATUS_INSUFFICIENT_RESOURCES); } if(!(Cache->CachedModifiedBlocksList = (PULONG)MyAllocatePoolTag__(NonPagedPool, l2, MEM_WCFRM_TAG) )) { UDFPrint(("Cache init err 3\n")); try_return(RC = STATUS_INSUFFICIENT_RESOURCES); } if(!(Cache->CachedFramesList = (PULONG)MyAllocatePoolTag__(NonPagedPool, l3 = ((MaxFrames+2)*sizeof(lba_t)), MEM_WCFRM_TAG) )) { UDFPrint(("Cache init err 4\n")); try_return(RC = STATUS_INSUFFICIENT_RESOURCES); } RtlZeroMemory(Cache->FrameList, l1); RtlZeroMemory(Cache->CachedBlocksList, l2); RtlZeroMemory(Cache->CachedModifiedBlocksList, l2); RtlZeroMemory(Cache->CachedFramesList, l3); // remember all useful parameters Cache->BlocksPerFrame = BlocksPerFrame; Cache->BlocksPerFrameSh = BlocksPerFrameSh; Cache->BlockCount = 0; Cache->MaxBlocks = MaxBlocks; Cache->MaxBytesToRead = MaxBytesToRead; Cache->FrameCount = 0; Cache->MaxFrames = MaxFrames; Cache->PacketSize = PacketSize; Cache->PacketSizeSh = PacketSizeSh; Cache->BlockSize = BlockSize; Cache->BlockSizeSh = BlockSizeSh; Cache->WriteCount = 0; Cache->FirstLba = FirstLba; Cache->LastLba = LastLba; Cache->Mode = Mode;
if(!OS_SUCCESS(RC = WCacheDecodeFlags(Cache, Flags))) { return RC; }
Cache->FramesToKeepFree = FramesToKeepFree; Cache->WriteProc = WriteProc; Cache->ReadProc = ReadProc; Cache->WriteProcAsync = WriteProcAsync; Cache->ReadProcAsync = ReadProcAsync; Cache->CheckUsedProc = CheckUsedProc; Cache->UpdateRelocProc = UpdateRelocProc; Cache->ErrorHandlerProc = ErrorHandlerProc; // init permanent tmp buffers if(!(Cache->tmp_buff = (PCHAR)MyAllocatePoolTag__(NonPagedPool, PacketSize*BlockSize, MEM_WCFRM_TAG))) { UDFPrint(("Cache init err 5.W\n")); try_return(RC = STATUS_INSUFFICIENT_RESOURCES); } if(!(Cache->tmp_buff_r = (PCHAR)MyAllocatePoolTag__(NonPagedPool, PacketSize*BlockSize, MEM_WCFRM_TAG))) { UDFPrint(("Cache init err 5.R\n")); try_return(RC = STATUS_INSUFFICIENT_RESOURCES); } if(!(Cache->reloc_tab = (PULONG)MyAllocatePoolTag__(NonPagedPool, Cache->PacketSize*sizeof(ULONG), MEM_WCFRM_TAG))) { UDFPrint(("Cache init err 6\n")); try_return(RC = STATUS_INSUFFICIENT_RESOURCES); } if(!OS_SUCCESS(RC = ExInitializeResourceLite(&(Cache->WCacheLock)))) { UDFPrint(("Cache init err (res)\n")); try_return(RC); } res_init_flags |= WCLOCK_RES; KeQuerySystemTime((PLARGE_INTEGER)(&rseed)); WCache_random = rseed.LowPart;
try_exit: NOTHING;
} _SEH2_FINALLY {
if(!OS_SUCCESS(RC)) { if(res_init_flags & WCLOCK_RES) ExDeleteResourceLite(&(Cache->WCacheLock)); if(Cache->FrameList) MyFreePool__(Cache->FrameList); if(Cache->CachedBlocksList) MyFreePool__(Cache->CachedBlocksList); if(Cache->CachedModifiedBlocksList) MyFreePool__(Cache->CachedModifiedBlocksList); if(Cache->CachedFramesList) MyFreePool__(Cache->CachedFramesList); if(Cache->tmp_buff_r) MyFreePool__(Cache->tmp_buff_r); if(Cache->tmp_buff) MyFreePool__(Cache->tmp_buff); if(Cache->reloc_tab) MyFreePool__(Cache->reloc_tab); RtlZeroMemory(Cache, sizeof(W_CACHE)); } else { Cache->Tag = 0xCAC11E00; }
} _SEH2_END;
return RC;} // end WCacheInit__()
/* WCacheRandom() - just a random generator Returns random LONGLONG number Internal routine */LONGLONGWCacheRandom(VOID){ WCache_random = (WCache_random * 0x8088405 + 1); return WCache_random;} // end WCacheRandom()
/* WCacheFindLbaToRelease() finds Block to be flushed and purged from cache Returns random LBA Internal routine */lba_t__fastcallWCacheFindLbaToRelease( IN PW_CACHE Cache ){ if(!(Cache->BlockCount)) return WCACHE_INVALID_LBA; return(Cache->CachedBlocksList[((ULONG)WCacheRandom() % Cache->BlockCount)]);} // end WCacheFindLbaToRelease()
/* WCacheFindModifiedLbaToRelease() finds Block to be flushed and purged from cache. This routine looks for Blocks among modified ones Returns random LBA (nodified) Internal routine */lba_t__fastcallWCacheFindModifiedLbaToRelease( IN PW_CACHE Cache ){ if(!(Cache->WriteCount)) return WCACHE_INVALID_LBA; return(Cache->CachedModifiedBlocksList[((ULONG)WCacheRandom() % Cache->WriteCount)]);} // end WCacheFindModifiedLbaToRelease()
/* WCacheFindFrameToRelease() finds Frame to be flushed and purged with all Blocks (from this Frame) from cache Returns random Frame number Internal routine */lba_t__fastcallWCacheFindFrameToRelease( IN PW_CACHE Cache ){ ULONG i, j; ULONG frame = 0; ULONG prev_uc = -1; ULONG uc = -1; lba_t lba; BOOLEAN mod = FALSE;
if(!(Cache->FrameCount)) return 0; /* return(Cache->CachedFramesList[((ULONG)WCacheRandom() % Cache->FrameCount)]); */
for(i=0; i<Cache->FrameCount; i++) {
j = Cache->CachedFramesList[i];
mod |= (Cache->FrameList[j].UpdateCount != 0); uc = Cache->FrameList[j].UpdateCount*32 + Cache->FrameList[j].AccessCount;
if(prev_uc > uc) { prev_uc = uc; frame = j; } } if(!mod) { frame = Cache->CachedFramesList[((ULONG)WCacheRandom() % Cache->FrameCount)]; lba = frame << Cache->BlocksPerFrameSh; WcPrint(("WC:-frm %x\n", lba)); } else { lba = frame << Cache->BlocksPerFrameSh; WcPrint(("WC:-frm(mod) %x\n", lba)); for(i=0; i<Cache->FrameCount; i++) {
j = Cache->CachedFramesList[i]; Cache->FrameList[j].UpdateCount = (Cache->FrameList[j].UpdateCount*2)/3; Cache->FrameList[j].AccessCount = (Cache->FrameList[j].AccessCount*3)/4; } } return frame;} // end WCacheFindFrameToRelease()
/* WCacheGetSortedListIndex() returns index of searched Lba (Lba is ULONG in sorted array) or index of minimal cached Lba greater than searched. If requested Lba is less than minimum cached, 0 is returned. If requested Lba is greater than maximum cached, BlockCount value is returned. Internal routine */
#ifdef _MSC_VER#pragma warning(push)#pragma warning(disable:4035) // re-enable below#endif
ULONG//__fastcallWCacheGetSortedListIndex( IN ULONG BlockCount, // number of items in array (pointed by List) IN lba_t* List, // pointer to sorted (ASC) array of ULONGs IN lba_t Lba // ULONG value to be searched for ){ if(!BlockCount) return 0;
#if defined(_X86_) && defined(_MSC_VER) && !defined(__clang__)
__asm push ecx __asm push ebx __asm push edx __asm push esi __asm push edi// left = 0;// right = BlockCount - 1;// pos = 0; __asm xor edx,edx // left __asm mov ebx,BlockCount __asm dec ebx // right __asm xor esi,esi // pos __asm mov edi,List // List __asm mov ecx,Lba // Lba
While_1:// while(left != right) { __asm cmp edx,ebx __asm jz EO_while_1
// pos = (left + right) >> 1; __asm lea esi,[ebx+edx] __asm shr esi,1// if(List[pos] == Lba)// return pos; __asm mov eax,[edi+esi*4] __asm cmp eax,ecx __asm jz EO_while_2
// if(right - left == 1) { __asm sub ebx,edx __asm cmp ebx,1 __asm jne NO_r_sub_l_eq_1// if(List[pos+1] < Lba) <=> if(List[pos+1] >= Lba)// return (pos+2); <=> break;// break; <=> return (pos+2); __asm cmp [edi+esi*4+4],ecx __asm jae EO_while_1 __asm add esi,2 __asm jmp EO_while_2// }NO_r_sub_l_eq_1:// if(List[pos] < Lba) { __asm cmp eax,ecx __asm jae Update_r// left = pos; __asm add ebx,edx __asm mov edx,esi __asm jmp While_1// } else {Update_r:// right = pos; __asm mov ebx,esi __asm jmp While_1// }// }EO_while_1:// if((List[pos] < Lba) && ((pos+1) <= BlockCount)) pos++; __asm mov eax,[edi+esi*4] __asm cmp eax,ecx __asm jae EO_while_2 __asm inc esi __asm cmp esi,BlockCount __asm jbe EO_while_2 __asm dec esiEO_while_2:// return pos; __asm mov eax,esi
__asm pop edi __asm pop esi __asm pop edx __asm pop ebx __asm pop ecx
#else // NO X86 optimization , use generic C/C++
ULONG pos; ULONG left; ULONG right;
if(!BlockCount) return 0;
left = 0; right = BlockCount - 1; pos = 0; while(left != right) { pos = (left + right) >> 1; if(List[pos] == Lba) return pos; if(right - left == 1) { if(List[pos+1] < Lba) return (pos+2); break; } if(List[pos] < Lba) { left = pos; } else { right = pos; } } if((List[pos] < Lba) && ((pos+1) <= BlockCount)) pos++;
return pos;
#endif // _X86_
}
#ifdef _MSC_VER#pragma warning(pop) // re-enable warning #4035#endif
/* WCacheInsertRangeToList() inserts values laying in range described by Lba (1st value) and BCount (number of sequentially incremented values) in sorted array of ULONGs pointed by List. Ex.: (Lba, BCount)=(7,3) will insert values {7,8,9}. If target array already contains one or more values falling in requested range, they will be removed before insertion. WCacheInsertRangeToList() updates value of (*BlockCount) to reflect performed changes. WCacheInsertRangeToList() assumes that target array is of enough size. Internal routine */VOID__fastcallWCacheInsertRangeToList( IN lba_t* List, // pointer to sorted (ASC) array of ULONGs IN PULONG BlockCount, // pointer to number of items in array (pointed by List) IN lba_t Lba, // initial value for insertion IN ULONG BCount // number of sequentially incremented values to be inserted ){ if(!BCount) return;
ASSERT(!(BCount & 0x80000000));
ULONG firstPos = WCacheGetSortedListIndex(*BlockCount, List, Lba); ULONG lastPos = WCacheGetSortedListIndex(*BlockCount, List, Lba+BCount); ULONG offs = firstPos + BCount - lastPos;
if(offs) { // move list tail// ASSERT(lastPos+offs + ((*BlockCount) - lastPos) <= qq); if(*BlockCount) {#ifdef WCACHE_BOUND_CHECKS MyCheckArray(List, lastPos+offs+(*BlockCount)-lastPos-1);#endif //WCACHE_BOUND_CHECKS DbgMoveMemory(&(List[lastPos+offs]), &(List[lastPos]), ((*BlockCount) - lastPos) * sizeof(ULONG)); } lastPos += offs; for(; firstPos<lastPos; firstPos++) {#ifdef WCACHE_BOUND_CHECKS MyCheckArray(List, firstPos);#endif //WCACHE_BOUND_CHECKS List[firstPos] = Lba; Lba++; } (*BlockCount) += offs; }} // end WCacheInsertRangeToList()
/* WCacheInsertItemToList() inserts value Lba in sorted array of ULONGs pointed by List. If target array already contains requested value, no operations are performed. WCacheInsertItemToList() updates value of (*BlockCount) to reflect performed changes. WCacheInsertItemToList() assumes that target array is of enough size. Internal routine */VOID__fastcallWCacheInsertItemToList( IN lba_t* List, // pointer to sorted (ASC) array of lba_t's IN PULONG BlockCount, // pointer to number of items in array (pointed by List) IN lba_t Lba // value to be inserted ){ ULONG firstPos = WCacheGetSortedListIndex(*BlockCount, List, Lba+1); if(firstPos && (List[firstPos-1] == Lba)) return;
// move list tail if(*BlockCount) {#ifdef WCACHE_BOUND_CHECKS MyCheckArray(List, firstPos+1+(*BlockCount)-firstPos-1);#endif //WCACHE_BOUND_CHECKS// DbgMoveMemory(&(List[firstPos+1]), &(List[firstPos]), ((*BlockCount) - firstPos)*sizeof(ULONG)); DbgMoveMemory(&(List[firstPos+1]), &(List[firstPos]), ((*BlockCount) - firstPos) * sizeof(ULONG)); }#ifdef WCACHE_BOUND_CHECKS MyCheckArray(List, firstPos);#endif //WCACHE_BOUND_CHECKS List[firstPos] = Lba; (*BlockCount) ++;} // end WCacheInsertItemToList()
/* WCacheRemoveRangeFromList() removes values falling in range described by Lba (1st value) and BCount (number of sequentially incremented values) from sorted array of ULONGs pointed by List. Ex.: (Lba, BCount)=(7,3) will remove values {7,8,9}. If target array doesn't contain values falling in requested range, no operation is performed. WCacheRemoveRangeFromList() updates value of (*BlockCount) to reflect performed changes. Internal routine */VOID__fastcallWCacheRemoveRangeFromList( IN lba_t* List, // pointer to sorted (ASC) array of ULONGs IN PULONG BlockCount, // pointer to number of items in array (pointed by List) IN lba_t Lba, // initial value for removal IN ULONG BCount // number of sequentially incremented values to be removed ){ ULONG firstPos = WCacheGetSortedListIndex(*BlockCount, List, Lba); ULONG lastPos = WCacheGetSortedListIndex(*BlockCount, List, Lba+BCount); ULONG offs = lastPos - firstPos;
if(offs) { // move list tail DbgMoveMemory(&(List[lastPos-offs]), &(List[lastPos]), ((*BlockCount) - lastPos) * sizeof(ULONG)); (*BlockCount) -= offs; }} // end WCacheRemoveRangeFromList()
/* WCacheRemoveItemFromList() removes value Lba from sorted array of ULONGs pointed by List. If target array doesn't contain requested value, no operations are performed. WCacheRemoveItemFromList() updates value of (*BlockCount) to reflect performed changes. Internal routine */VOID__fastcallWCacheRemoveItemFromList( IN lba_t* List, // pointer to sorted (ASC) array of ULONGs IN PULONG BlockCount, // pointer to number of items in array (pointed by List) IN lba_t Lba // value to be removed ){ if(!(*BlockCount)) return; ULONG lastPos = WCacheGetSortedListIndex(*BlockCount, List, Lba+1); if(!lastPos || (lastPos && (List[lastPos-1] != Lba))) return;
// move list tail DbgMoveMemory(&(List[lastPos-1]), &(List[lastPos]), ((*BlockCount) - lastPos) * sizeof(ULONG)); (*BlockCount) --;} // end WCacheRemoveItemFromList()
/* WCacheInitFrame() allocates storage for Frame (block_array) with index 'frame', fills it with 0 (none of Blocks from this Frame is cached) and inserts it's index to sorted array of frame indexes. WCacheInitFrame() also checks if number of frames reaches limit and invokes WCacheCheckLimits() to free some Frames/Blocks Internal routine */PW_CACHE_ENTRY__fastcallWCacheInitFrame( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // caller's context (currently unused) IN ULONG frame // frame index ){ PW_CACHE_ENTRY block_array; ULONG l;#ifdef DBG ULONG old_count = Cache->FrameCount;#endif //DBG
// We are about to add new cache frame. // Thus check if we have enough free entries and // flush unused ones if it is neccessary. if(Cache->FrameCount >= Cache->MaxFrames) { BrutePoint(); WCacheCheckLimits(Cache, Context, frame << Cache->BlocksPerFrameSh, Cache->PacketSize*2); } ASSERT(Cache->FrameCount < Cache->MaxFrames); block_array = (PW_CACHE_ENTRY)MyAllocatePoolTag__(NonPagedPool, l = sizeof(W_CACHE_ENTRY) << Cache->BlocksPerFrameSh, MEM_WCFRM_TAG); Cache->FrameList[frame].Frame = block_array;
// Keep history !!! //Cache->FrameList[frame].UpdateCount = 0; //Cache->FrameList[frame].AccessCount = 0;
if(block_array) { ASSERT((ULONG_PTR)block_array > 0x1000); WCacheInsertItemToList(Cache->CachedFramesList, &(Cache->FrameCount), frame); RtlZeroMemory(block_array, l); } else { BrutePoint(); } ASSERT(Cache->FrameCount <= Cache->MaxFrames);#ifdef DBG ASSERT(old_count < Cache->FrameCount);#endif //DBG return block_array;} // end WCacheInitFrame()
/* WCacheRemoveFrame() frees storage for Frame (block_array) with index 'frame' and removes it's index from sorted array of frame indexes. Internal routine */VOID__fastcallWCacheRemoveFrame( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user's context (currently unused) IN ULONG frame // frame index ){ PW_CACHE_ENTRY block_array;#ifdef DBG ULONG old_count = Cache->FrameCount;#endif //DBG
ASSERT(Cache->FrameCount <= Cache->MaxFrames); block_array = Cache->FrameList[frame].Frame;
WCacheRemoveItemFromList(Cache->CachedFramesList, &(Cache->FrameCount), frame); MyFreePool__(block_array);// ASSERT(!(Cache->FrameList[frame].WriteCount));// ASSERT(!(Cache->FrameList[frame].WriteCount)); Cache->FrameList[frame].Frame = NULL; ASSERT(Cache->FrameCount < Cache->MaxFrames);#ifdef DBG ASSERT(old_count > Cache->FrameCount);#endif //DBG
} // end WCacheRemoveFrame()
/* WCacheSetModFlag() sets Modified flag for Block with offset 'i' in Frame 'block_array' Internal routine */#define WCacheSetModFlag(block_array, i) \ *((PULONG)&(block_array[i].Sector)) |= WCACHE_FLAG_MODIFIED
/* WCacheClrModFlag() clears Modified flag for Block with offset 'i' in Frame 'block_array' Internal routine */#define WCacheClrModFlag(block_array, i) \ *((PULONG)&(block_array[i].Sector)) &= ~WCACHE_FLAG_MODIFIED
/* WCacheGetModFlag() returns non-zero value if Modified flag for Block with offset 'i' in Frame 'block_array' is set. Otherwise 0 is returned. Internal routine */#define WCacheGetModFlag(block_array, i) \ (*((PULONG)&(block_array[i].Sector)) & WCACHE_FLAG_MODIFIED)
#if 0/* WCacheSetBadFlag() sets Modified flag for Block with offset 'i' in Frame 'block_array' Internal routine */#define WCacheSetBadFlag(block_array, i) \ *((PULONG)&(block_array[i].Sector)) |= WCACHE_FLAG_BAD
/* WCacheClrBadFlag() clears Modified flag for Block with offset 'i' in Frame 'block_array' Internal routine */#define WCacheClrBadFlag(block_array, i) \ *((PULONG)&(block_array[i].Sector)) &= ~WCACHE_FLAG_BAD
/* WCacheGetBadFlag() returns non-zero value if Modified flag for Block with offset 'i' in Frame 'block_array' is set. Otherwise 0 is returned. Internal routine */#define WCacheGetBadFlag(block_array, i) \ (((UCHAR)(block_array[i].Sector)) & WCACHE_FLAG_BAD)#endif //0
/* WCacheSectorAddr() returns pointer to memory block containing cached data for Block described by Frame (block_array) and offset in this Frame (i). If requested Block is not cached yet NULL is returned. Internal routine */#define WCacheSectorAddr(block_array, i) \ ((ULONG_PTR)(block_array[i].Sector) & WCACHE_ADDR_MASK)
/* WCacheFreeSector() releases memory block containing cached data for Block described by Frame (block_array) and offset in this Frame (i). Should never be called for non-cached Blocks. Internal routine */#define WCacheFreeSector(frame, offs) \{ \ DbgFreePool((PVOID)WCacheSectorAddr(block_array, offs)); \ block_array[offs].Sector = NULL; \ Cache->FrameList[frame].BlockCount--; \}
/* WCacheAllocAsyncEntry() allocates storage for async IO context, links it to previously allocated async IO context (if any), initializes synchronization (completion) event and allocates temporary IO buffers. Async IO contexts are used to create chained set of IO requests durring top-level request precessing and wait for their completion. Internal routine */PW_CACHE_ASYNCWCacheAllocAsyncEntry( IN PW_CACHE Cache, // pointer to the Cache Control structure IN OUT PW_CACHE_ASYNC* FirstWContext, // pointer to the pointer to // the head of async IO context chain IN OUT PW_CACHE_ASYNC* PrevWContext, // pointer to the storage for pointer // to newly allocated async IO context chain IN ULONG BufferSize // requested IO buffer size ){ PW_CACHE_ASYNC WContext; PCHAR Buffer;
WContext = (PW_CACHE_ASYNC)MyAllocatePoolTag__(NonPagedPool,sizeof(W_CACHE_ASYNC), MEM_WCCTX_TAG); if(!WContext) return NULL; Buffer = (PCHAR)DbgAllocatePoolWithTag(NonPagedPool, BufferSize*(2-Cache->Chained), MEM_WCBUF_TAG); if(!Buffer) { MyFreePool__(WContext); return NULL; }
if(!Cache->Chained) KeInitializeEvent(&(WContext->PhContext.event), SynchronizationEvent, FALSE); WContext->Cache = Cache; if(*PrevWContext) (*PrevWContext)->NextWContext = WContext;// WContext->NextWContext = (*PrevWContext); WContext->NextWContext = NULL; WContext->Buffer = Buffer; WContext->Buffer2 = Buffer+(Cache->Chained ? 0 : BufferSize);
if(!(*FirstWContext)) (*FirstWContext) = WContext; (*PrevWContext) = WContext;
return WContext;} // end WCacheAllocAsyncEntry()
/* WCacheFreeAsyncEntry() releases storage previously allocated for async IO context. Internal routine */VOIDWCacheFreeAsyncEntry( IN PW_CACHE Cache, // pointer to the Cache Control structure PW_CACHE_ASYNC WContext // pointer to async IO context to release ){ DbgFreePool(WContext->Buffer); MyFreePool__(WContext);} // end WCacheFreeAsyncEntry()
//#define WCacheRaiseIoError(c, ct, s, l, bc, b, o, r)
OSSTATUSWCacheRaiseIoError( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, IN OSSTATUS Status, IN ULONG Lba, IN ULONG BCount, IN PVOID Buffer, IN BOOLEAN ReadOp, IN PBOOLEAN Retry ){ if(!Cache->ErrorHandlerProc) return Status;
WCACHE_ERROR_CONTEXT ec;
ec.WCErrorCode = ReadOp ? WCACHE_ERROR_READ : WCACHE_ERROR_WRITE; ec.Status = Status; ec.ReadWrite.Lba = Lba; ec.ReadWrite.BCount = BCount; ec.ReadWrite.Buffer = Buffer; Status = Cache->ErrorHandlerProc(Context, &ec); if(Retry) (*Retry) = ec.Retry;
return Status;
} // end WCacheRaiseIoError()
/* WCacheUpdatePacket() attempts to updates packet containing target Block. If async IO is enabled new IO context is added to the chain. If packet containing target Block is modified and PrefereWrite flag is NOT set, function returns with status STATUS_RETRY. This setting is user in WCACHE_MODE_R mode to reduce physical writes on flush. 'State' parameter is used in async mode to determine the next processing stege for given request Internal routine */OSSTATUSWCacheUpdatePacket( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user's context to be passed to user-supplied // low-level IO routines (IO callbacks) IN OUT PW_CACHE_ASYNC* FirstWContext, // pointer to head async IO context IN OUT PW_CACHE_ASYNC* PrevWContext, // pointer to tail async IO context IN PW_CACHE_ENTRY block_array, // pointer to target Frame IN lba_t firstLba, // LBA of the 1st block in target Frame IN lba_t Lba, // LBA of target Block IN ULONG BSh, // bit shift for Block size IN ULONG BS, // Block size (bytes) IN ULONG PS, // Packet size (bytes) IN ULONG PSs, // Packet size (sectors) IN PSIZE_T ReadBytes, // pointer to number of successfully read/written bytes IN BOOLEAN PrefereWrite, // allow physical write (flush) of modified packet IN ULONG State // callers state ){ OSSTATUS status; PCHAR tmp_buff = Cache->tmp_buff; PCHAR tmp_buff2 = Cache->tmp_buff; BOOLEAN mod; BOOLEAN read; BOOLEAN zero; ULONG i; lba_t Lba0; PW_CACHE_ASYNC WContext; BOOLEAN Async = (Cache->ReadProcAsync && Cache->WriteProcAsync); ULONG block_type; BOOLEAN Chained = Cache->Chained;
// Check if we are going to write down to disk // all prewiously prepared (chained) data if(State == ASYNC_STATE_WRITE) { WContext = (*PrevWContext); tmp_buff = (PCHAR)(WContext->Buffer); tmp_buff2 = (PCHAR)(WContext->Buffer2); if(!Chained) mod = (DbgCompareMemory(tmp_buff2, tmp_buff, PS) != PS); goto try_write; }
// Check if packet contains modified blocks // If packet contains non-cached and unchanged, but used // blocks, it must be read from media before modification mod = read = zero = FALSE; Lba0 = Lba - firstLba; for(i=0; i<PSs; i++, Lba0++) { if(WCacheGetModFlag(block_array, Lba0)) { mod = TRUE; } else if(!WCacheSectorAddr(block_array,Lba0) && ((block_type = Cache->CheckUsedProc(Context, Lba+i)) & WCACHE_BLOCK_USED) ) { // if(block_type & WCACHE_BLOCK_ZERO) { zero = TRUE; } else { read = TRUE; } } } // check if we are allowed to write to media if(mod && !PrefereWrite) { return STATUS_RETRY; } // return STATUS_SUCCESS if requested packet contains no modified blocks if(!mod) { (*ReadBytes) = PS; return STATUS_SUCCESS; }
// pefrorm full update cycle: prepare(optional)/read/modify/write
// do some preparations if(Chained || Async) { // For chained and async I/O we allocates context entry // and add it to list (chain) // We shall only read data to temporary buffer and // modify it. Write operations will be invoked later. // This is introduced in order to avoid frequent // read.write mode switching, because it significantly degrades // performance WContext = WCacheAllocAsyncEntry(Cache, FirstWContext, PrevWContext, PS); if(!WContext) { //return STATUS_INSUFFICIENT_RESOURCES; // try to recover Chained = FALSE; Async = FALSE; } else { tmp_buff = tmp_buff2 = (PCHAR)(WContext->Buffer); WContext->Lba = Lba; WContext->Cmd = ASYNC_CMD_UPDATE; WContext->State = ASYNC_STATE_NONE; } }
// read packet (if it necessary) if(read) { if(Async) { WContext->State = ASYNC_STATE_READ; status = Cache->ReadProcAsync(Context, WContext, tmp_buff, PS, Lba, &(WContext->TransferredBytes));// tmp_buff2 = (PCHAR)(WContext->Buffer2); (*ReadBytes) = PS; return status; } else { status = Cache->ReadProc(Context, tmp_buff, PS, Lba, ReadBytes, PH_TMP_BUFFER); } if(!OS_SUCCESS(status)) { status = WCacheRaiseIoError(Cache, Context, status, Lba, PSs, tmp_buff, WCACHE_R_OP, NULL); if(!OS_SUCCESS(status)) { return status; } } } else if(zero) { RtlZeroMemory(tmp_buff, PS); }
if(Chained) { // indicate that we prepared for writing block to disk WContext->State = ASYNC_STATE_WRITE_PRE; tmp_buff2 = tmp_buff; status = STATUS_SUCCESS; }
// modify packet
// If we didn't read packet from media, we can't // perform comparison to assure that packet was really modified. // Thus, assume that it is modified in this case. mod = !read || Cache->DoNotCompare; Lba0 = Lba - firstLba; for(i=0; i<PSs; i++, Lba0++) { if( WCacheGetModFlag(block_array, Lba0) || (!read && WCacheSectorAddr(block_array,Lba0)) ) {
#ifdef _NTDEF_ ASSERT((ULONG)WCacheSectorAddr(block_array,Lba0) & 0x80000000);#endif //_NTDEF_ if(!mod) { ASSERT(read); mod = (DbgCompareMemory(tmp_buff2 + (i << BSh), (PVOID)WCacheSectorAddr(block_array, Lba0), BS) != BS); } if(mod) { DbgCopyMemory(tmp_buff2 + (i << BSh), (PVOID)WCacheSectorAddr(block_array, Lba0), BS); } } }
if(Chained && WContext->State == ASYNC_STATE_WRITE_PRE) { // Return if block is prepared for write and we are in chained mode. if(!mod) { // Mark block as written if we have found that data in it // is not actually modified. WContext->State = ASYNC_STATE_DONE; (*ReadBytes) = PS; } return STATUS_SUCCESS; }
// write packet
// If the check above reported some changes in packet // we should write packet out to media. // Otherwise, just complete request. if(mod) {try_write: if(Async) { WContext->State = ASYNC_STATE_WRITE; status = Cache->WriteProcAsync(Context, WContext, tmp_buff2, PS, Lba, &(WContext->TransferredBytes), FALSE); (*ReadBytes) = PS; } else { status = Cache->WriteProc(Context, tmp_buff2, PS, Lba, ReadBytes, 0); if(!OS_SUCCESS(status)) { status = WCacheRaiseIoError(Cache, Context, status, Lba, PSs, tmp_buff2, WCACHE_W_OP, NULL); } } } else { if(Async) WCacheCompleteAsync__(WContext, STATUS_SUCCESS); (*ReadBytes) = PS; return STATUS_SUCCESS; }
return status;} // end WCacheUpdatePacket()
/* WCacheFreePacket() releases storage for all Blocks in packet. 'frame' describes Frame, offset - Block in Frame. offset should be aligned on Packet size. Internal routine */VOIDWCacheFreePacket( IN PW_CACHE Cache, // pointer to the Cache Control structure// IN PVOID Context, IN ULONG frame, // Frame index IN PW_CACHE_ENTRY block_array, // Frame IN ULONG offs, // offset in Frame IN ULONG PSs // Packet size (in Blocks) ){ ULONG i; // mark as non-cached & free pool for(i=0; i<PSs; i++, offs++) { if(WCacheSectorAddr(block_array,offs)) { WCacheFreeSector(frame, offs); } }} // end WCacheFreePacket()
/* WCacheUpdatePacketComplete() is called to continue processing of packet being updated. In async mode it waits for completion of pre-read requests, initiates writes, waits for their completion and returns control to caller. Internal routine */VOIDWCacheUpdatePacketComplete( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN OUT PW_CACHE_ASYNC* FirstWContext, // pointer to head async IO context IN OUT PW_CACHE_ASYNC* PrevWContext, // pointer to tail async IO context IN BOOLEAN FreePacket ){ PW_CACHE_ASYNC WContext = (*FirstWContext); if(!WContext) return; PW_CACHE_ASYNC NextWContext; ULONG PS = Cache->BlockSize << Cache->PacketSizeSh; // packet size (bytes) ULONG PSs = Cache->PacketSize; ULONG frame; lba_t firstLba;
// Walk through all chained blocks and wait // for completion of read operations. // Also invoke writes of already prepared packets. while(WContext) { if(WContext->Cmd == ASYNC_CMD_UPDATE && WContext->State == ASYNC_STATE_READ) { // wait for async read for update DbgWaitForSingleObject(&(WContext->PhContext.event), NULL);
WContext->State = ASYNC_STATE_WRITE; WCacheUpdatePacket(Cache, Context, NULL, &WContext, NULL, -1, WContext->Lba, -1, -1, PS, -1, &(WContext->TransferredBytes), TRUE, ASYNC_STATE_WRITE); } else if(WContext->Cmd == ASYNC_CMD_UPDATE && WContext->State == ASYNC_STATE_WRITE_PRE) { // invoke physical write it the packet is prepared for writing // by previuous call to WCacheUpdatePacket() WContext->State = ASYNC_STATE_WRITE; WCacheUpdatePacket(Cache, Context, NULL, &WContext, NULL, -1, WContext->Lba, -1, -1, PS, -1, &(WContext->TransferredBytes), TRUE, ASYNC_STATE_WRITE); WContext->State = ASYNC_STATE_DONE; } else if(WContext->Cmd == ASYNC_CMD_READ && WContext->State == ASYNC_STATE_READ) { // wait for async read DbgWaitForSingleObject(&(WContext->PhContext.event), NULL); } WContext = WContext->NextWContext; } // Walk through all chained blocks and wait // and wait for completion of async writes (if any). // Also free temporary buffers containing already written blocks. WContext = (*FirstWContext); while(WContext) { NextWContext = WContext->NextWContext; if(WContext->Cmd == ASYNC_CMD_UPDATE && WContext->State == ASYNC_STATE_WRITE) {
if(!Cache->Chained) DbgWaitForSingleObject(&(WContext->PhContext.event), NULL);
frame = WContext->Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh;
if(FreePacket) { WCacheFreePacket(Cache, frame, Cache->FrameList[frame].Frame, WContext->Lba - firstLba, PSs); } } WCacheFreeAsyncEntry(Cache, WContext); WContext = NextWContext; } (*FirstWContext) = NULL; (*PrevWContext) = NULL;} // end WCacheUpdatePacketComplete()
/* WCacheCheckLimits() checks if we've enough free Frame- & Block-entries under Frame- and Block-limit to feet requested Blocks. If there is not enough entries, WCache initiates flush & purge process to satisfy request. This is dispatch routine, which calls WCacheCheckLimitsR() or WCacheCheckLimitsRW() depending on media type. Internal routine */OSSTATUS__fastcallWCacheCheckLimits( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN lba_t ReqLba, // first LBA to access/cache IN ULONG BCount // number of Blocks to access/cache ){/* if(!Cache->FrameCount || !Cache->BlockCount) { ASSERT(!Cache->FrameCount); ASSERT(!Cache->BlockCount); if(!Cache->FrameCount) return STATUS_SUCCESS; }*/
// check if we have reached Frame or Block limit if(!Cache->FrameCount && !Cache->BlockCount) { return STATUS_SUCCESS; }
// check for empty frames if(Cache->FrameCount > (Cache->MaxFrames*3)/4) { ULONG frame; ULONG i; for(i=Cache->FrameCount; i>0; i--) { frame = Cache->CachedFramesList[i-1]; // check if frame is empty if(!(Cache->FrameList[frame].BlockCount)) { WCacheRemoveFrame(Cache, Context, frame); } else { ASSERT(Cache->FrameList[frame].Frame); } } }
if(!Cache->BlockCount) { return STATUS_SUCCESS; }
// invoke media-specific limit-checker switch(Cache->Mode) { case WCACHE_MODE_RAM: return WCacheCheckLimitsRAM(Cache, Context, ReqLba, BCount); case WCACHE_MODE_ROM: case WCACHE_MODE_RW: return WCacheCheckLimitsRW(Cache, Context, ReqLba, BCount); case WCACHE_MODE_R: return WCacheCheckLimitsR(Cache, Context, ReqLba, BCount); } return STATUS_DRIVER_INTERNAL_ERROR;} // end WCacheCheckLimits()
/* WCacheCheckLimitsRW() implements automatic flush and purge of unused blocks to keep enough free cache entries for newly read/written blocks for Random Access and ReWritable media using Read/Modify/Write technology. See also WCacheCheckLimits() Internal routine */OSSTATUS__fastcallWCacheCheckLimitsRW( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN lba_t ReqLba, // first LBA to access/cache IN ULONG BCount // number of Blocks to access/cache ){ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedBlocksList; lba_t lastLba; lba_t Lba;// PCHAR tmp_buff = Cache->tmp_buff; ULONG firstPos; ULONG lastPos; ULONG BSh = Cache->BlockSizeSh; ULONG BS = Cache->BlockSize; ULONG PS = BS << Cache->PacketSizeSh; // packet size (bytes) ULONG PSs = Cache->PacketSize; ULONG try_count = 0; PW_CACHE_ENTRY block_array; OSSTATUS status; SIZE_T ReadBytes; ULONG FreeFrameCount = 0;// PVOID addr; PW_CACHE_ASYNC FirstWContext = NULL; PW_CACHE_ASYNC PrevWContext = NULL; ULONG chain_count = 0;
if(Cache->FrameCount >= Cache->MaxFrames) { FreeFrameCount = Cache->FramesToKeepFree; } else if((Cache->BlockCount + WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba) + BCount - WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba+BCount)) > Cache->MaxBlocks) { // we need free space to grow WCache without flushing data // for some period of time FreeFrameCount = Cache->FramesToKeepFree; goto Try_Another_Frame; } // remove(flush) some frames while((Cache->FrameCount >= Cache->MaxFrames) || FreeFrameCount) {Try_Another_Frame: if(!Cache->FrameCount || !Cache->BlockCount) { //ASSERT(!Cache->FrameCount); if(Cache->FrameCount) { UDFPrint(("ASSERT: Cache->FrameCount = %d, when 0 is expected\n", Cache->FrameCount)); } ASSERT(!Cache->BlockCount); if(!Cache->FrameCount) break; }
frame = WCacheFindFrameToRelease(Cache);#if 0 if(Cache->FrameList[frame].WriteCount) { try_count++; if(try_count < MAX_TRIES_FOR_NA) goto Try_Another_Frame; } else { try_count = 0; }#else if(Cache->FrameList[frame].UpdateCount) { try_count = MAX_TRIES_FOR_NA; } else { try_count = 0; }#endif
if(FreeFrameCount) FreeFrameCount--;
firstLba = frame << Cache->BlocksPerFrameSh; lastLba = firstLba + Cache->BlocksPerFrame; firstPos = WCacheGetSortedListIndex(Cache->BlockCount, List, firstLba); lastPos = WCacheGetSortedListIndex(Cache->BlockCount, List, lastLba); block_array = Cache->FrameList[frame].Frame;
if(!block_array) { UDFPrint(("Hmm...\n")); BrutePoint(); return STATUS_DRIVER_INTERNAL_ERROR; }
while(firstPos < lastPos) { // flush packet Lba = List[firstPos] & ~(PSs-1);
// write packet out or prepare and add to chain (if chained mode enabled) status = WCacheUpdatePacket(Cache, Context, &FirstWContext, &PrevWContext, block_array, firstLba, Lba, BSh, BS, PS, PSs, &ReadBytes, TRUE, ASYNC_STATE_NONE);
if(status != STATUS_PENDING) { // free memory WCacheFreePacket(Cache, frame, block_array, Lba-firstLba, PSs); }
Lba += PSs; while((firstPos < lastPos) && (Lba > List[firstPos])) { firstPos++; } chain_count++; // write chained packets if(chain_count >= WCACHE_MAX_CHAIN) { WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext, FALSE); chain_count = 0; } } // remove flushed blocks from all lists WCacheRemoveRangeFromList(List, &(Cache->BlockCount), firstLba, Cache->BlocksPerFrame); WCacheRemoveRangeFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), firstLba, Cache->BlocksPerFrame);
WCacheRemoveFrame(Cache, Context, frame); }
// check if we try to read too much data if(BCount > Cache->MaxBlocks) { WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext); return STATUS_INVALID_PARAMETER; }
// remove(flush) packet while((Cache->BlockCount + WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba) + BCount - WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba+BCount)) > Cache->MaxBlocks) { try_count = 0;Try_Another_Block:
Lba = WCacheFindLbaToRelease(Cache) & ~(PSs-1); if(Lba == WCACHE_INVALID_LBA) { ASSERT(!Cache->FrameCount); ASSERT(!Cache->BlockCount); break; } frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; firstPos = WCacheGetSortedListIndex(Cache->BlockCount, List, Lba); lastPos = WCacheGetSortedListIndex(Cache->BlockCount, List, Lba+PSs); block_array = Cache->FrameList[frame].Frame; if(!block_array) { // write already prepared blocks to disk and return error WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext); ASSERT(FALSE); return STATUS_DRIVER_INTERNAL_ERROR; }
// write packet out or prepare and add to chain (if chained mode enabled) status = WCacheUpdatePacket(Cache, Context, &FirstWContext, &PrevWContext, block_array, firstLba, Lba, BSh, BS, PS, PSs, &ReadBytes, (try_count >= MAX_TRIES_FOR_NA), ASYNC_STATE_NONE);
if(status == STATUS_RETRY) { try_count++; goto Try_Another_Block; }
// free memory WCacheFreePacket(Cache, frame, block_array, Lba-firstLba, PSs);
WCacheRemoveRangeFromList(List, &(Cache->BlockCount), Lba, PSs); WCacheRemoveRangeFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba, PSs); // check if frame is empty if(!(Cache->FrameList[frame].BlockCount)) { WCacheRemoveFrame(Cache, Context, frame); } else { ASSERT(Cache->FrameList[frame].Frame); } chain_count++; if(chain_count >= WCACHE_MAX_CHAIN) { WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext, FALSE); chain_count = 0; } } WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext); return STATUS_SUCCESS;} // end WCacheCheckLimitsRW()
OSSTATUS__fastcallWCacheFlushBlocksRAM( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks PW_CACHE_ENTRY block_array, lba_t* List, ULONG firstPos, ULONG lastPos, BOOLEAN Purge ){ ULONG frame; lba_t Lba; lba_t PrevLba; lba_t firstLba; PCHAR tmp_buff = NULL; ULONG n; ULONG BSh = Cache->BlockSizeSh; ULONG BS = Cache->BlockSize;// ULONG PS = BS << Cache->PacketSizeSh; // packet size (bytes) ULONG PSs = Cache->PacketSize; SIZE_T _WrittenBytes; OSSTATUS status = STATUS_SUCCESS;
frame = List[firstPos] >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh;
while(firstPos < lastPos) { // flush blocks ASSERT(Cache->FrameCount <= Cache->MaxFrames); Lba = List[firstPos]; if(!WCacheGetModFlag(block_array, Lba - firstLba)) { // free memory if(Purge) { WCacheFreePacket(Cache, frame, block_array, Lba-firstLba, 1); } firstPos++; continue; } tmp_buff = Cache->tmp_buff; PrevLba = Lba; n=1; while((firstPos+n < lastPos) && (List[firstPos+n] == PrevLba+1)) { PrevLba++; if(!WCacheGetModFlag(block_array, PrevLba - firstLba)) break; DbgCopyMemory(tmp_buff + (n << BSh), (PVOID)WCacheSectorAddr(block_array, PrevLba - firstLba), BS); n++; if(n >= PSs) break; } if(n > 1) { DbgCopyMemory(tmp_buff, (PVOID)WCacheSectorAddr(block_array, Lba - firstLba), BS); } else { tmp_buff = (PCHAR)WCacheSectorAddr(block_array, Lba - firstLba); } // write sectors out status = Cache->WriteProc(Context, tmp_buff, n<<BSh, Lba, &_WrittenBytes, 0); if(!OS_SUCCESS(status)) { status = WCacheRaiseIoError(Cache, Context, status, Lba, n, tmp_buff, WCACHE_W_OP, NULL); if(!OS_SUCCESS(status)) { BrutePoint(); } } firstPos += n; if(Purge) { // free memory WCacheFreePacket(Cache, frame, block_array, Lba-firstLba, n); } else { // clear Modified flag ULONG i; Lba -= firstLba; for(i=0; i<n; i++) { WCacheClrModFlag(block_array, Lba+i); } } }
return status;} // end WCacheFlushBlocksRAM()
/* WCacheCheckLimitsRAM() implements automatic flush and purge of unused blocks to keep enough free cache entries for newly read/written blocks for Random Access media. See also WCacheCheckLimits() Internal routine */OSSTATUS__fastcallWCacheCheckLimitsRAM( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN lba_t ReqLba, // first LBA to access/cache IN ULONG BCount // number of Blocks to access/cache ){ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedBlocksList; lba_t lastLba; lba_t Lba;// PCHAR tmp_buff = Cache->tmp_buff; ULONG firstPos; ULONG lastPos;// ULONG BSh = Cache->BlockSizeSh;// ULONG BS = Cache->BlockSize;// ULONG PS = BS << Cache->PacketSizeSh; // packet size (bytes) ULONG PSs = Cache->PacketSize;// ULONG try_count = 0; PW_CACHE_ENTRY block_array;// OSSTATUS status; ULONG FreeFrameCount = 0;// PVOID addr;
if(Cache->FrameCount >= Cache->MaxFrames) { FreeFrameCount = Cache->FramesToKeepFree; } else if((Cache->BlockCount + WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba) + BCount - WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba+BCount)) > Cache->MaxBlocks) { // we need free space to grow WCache without flushing data // for some period of time FreeFrameCount = Cache->FramesToKeepFree; goto Try_Another_Frame; } // remove(flush) some frames while((Cache->FrameCount >= Cache->MaxFrames) || FreeFrameCount) { ASSERT(Cache->FrameCount <= Cache->MaxFrames);Try_Another_Frame: if(!Cache->FrameCount || !Cache->BlockCount) { ASSERT(!Cache->FrameCount); ASSERT(!Cache->BlockCount); if(!Cache->FrameCount) break; }
frame = WCacheFindFrameToRelease(Cache);#if 0 if(Cache->FrameList[frame].WriteCount) { try_count++; if(try_count < MAX_TRIES_FOR_NA) goto Try_Another_Frame; } else { try_count = 0; }#else/* if(Cache->FrameList[frame].UpdateCount) { try_count = MAX_TRIES_FOR_NA; } else { try_count = 0; }*/#endif
if(FreeFrameCount) FreeFrameCount--;
firstLba = frame << Cache->BlocksPerFrameSh; lastLba = firstLba + Cache->BlocksPerFrame; firstPos = WCacheGetSortedListIndex(Cache->BlockCount, List, firstLba); lastPos = WCacheGetSortedListIndex(Cache->BlockCount, List, lastLba); block_array = Cache->FrameList[frame].Frame;
if(!block_array) { UDFPrint(("Hmm...\n")); BrutePoint(); return STATUS_DRIVER_INTERNAL_ERROR; } WCacheFlushBlocksRAM(Cache, Context, block_array, List, firstPos, lastPos, TRUE);
WCacheRemoveRangeFromList(List, &(Cache->BlockCount), firstLba, Cache->BlocksPerFrame); WCacheRemoveRangeFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), firstLba, Cache->BlocksPerFrame); WCacheRemoveFrame(Cache, Context, frame); }
// check if we try to read too much data if(BCount > Cache->MaxBlocks) { return STATUS_INVALID_PARAMETER; }
// remove(flush) packet while((Cache->BlockCount + WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba) + BCount - WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba+BCount)) > Cache->MaxBlocks) {// try_count = 0;//Try_Another_Block:
ASSERT(Cache->FrameCount <= Cache->MaxFrames); Lba = WCacheFindLbaToRelease(Cache) & ~(PSs-1); if(Lba == WCACHE_INVALID_LBA) { ASSERT(!Cache->FrameCount); ASSERT(!Cache->BlockCount); break; } frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; firstPos = WCacheGetSortedListIndex(Cache->BlockCount, List, Lba); lastPos = WCacheGetSortedListIndex(Cache->BlockCount, List, Lba+PSs); block_array = Cache->FrameList[frame].Frame; if(!block_array) { ASSERT(FALSE); return STATUS_DRIVER_INTERNAL_ERROR; } WCacheFlushBlocksRAM(Cache, Context, block_array, List, firstPos, lastPos, TRUE); WCacheRemoveRangeFromList(List, &(Cache->BlockCount), Lba, PSs); WCacheRemoveRangeFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba, PSs); // check if frame is empty if(!(Cache->FrameList[frame].BlockCount)) { WCacheRemoveFrame(Cache, Context, frame); } else { ASSERT(Cache->FrameList[frame].Frame); } } return STATUS_SUCCESS;} // end WCacheCheckLimitsRAM()
/* WCachePurgeAllRAM() Internal routine */OSSTATUS__fastcallWCachePurgeAllRAM( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context // user-supplied context for IO callbacks ){ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedBlocksList; lba_t lastLba; ULONG firstPos; ULONG lastPos; PW_CACHE_ENTRY block_array;// OSSTATUS status;
// remove(flush) some frames while(Cache->FrameCount) {
frame = Cache->CachedFramesList[0];
firstLba = frame << Cache->BlocksPerFrameSh; lastLba = firstLba + Cache->BlocksPerFrame; firstPos = WCacheGetSortedListIndex(Cache->BlockCount, List, firstLba); lastPos = WCacheGetSortedListIndex(Cache->BlockCount, List, lastLba); block_array = Cache->FrameList[frame].Frame;
if(!block_array) { UDFPrint(("Hmm...\n")); BrutePoint(); return STATUS_DRIVER_INTERNAL_ERROR; } WCacheFlushBlocksRAM(Cache, Context, block_array, List, firstPos, lastPos, TRUE);
WCacheRemoveRangeFromList(List, &(Cache->BlockCount), firstLba, Cache->BlocksPerFrame); WCacheRemoveRangeFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), firstLba, Cache->BlocksPerFrame); WCacheRemoveFrame(Cache, Context, frame); }
ASSERT(!Cache->FrameCount); ASSERT(!Cache->BlockCount); return STATUS_SUCCESS;} // end WCachePurgeAllRAM()
/* WCacheFlushAllRAM() Internal routine */OSSTATUS__fastcallWCacheFlushAllRAM( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context // user-supplied context for IO callbacks ){ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedBlocksList; lba_t lastLba; ULONG firstPos; ULONG lastPos; PW_CACHE_ENTRY block_array;// OSSTATUS status;
// flush frames while(Cache->WriteCount) {
frame = Cache->CachedModifiedBlocksList[0] >> Cache->BlocksPerFrameSh;
firstLba = frame << Cache->BlocksPerFrameSh; lastLba = firstLba + Cache->BlocksPerFrame; firstPos = WCacheGetSortedListIndex(Cache->BlockCount, List, firstLba); lastPos = WCacheGetSortedListIndex(Cache->BlockCount, List, lastLba); block_array = Cache->FrameList[frame].Frame;
if(!block_array) { UDFPrint(("Hmm...\n")); BrutePoint(); return STATUS_DRIVER_INTERNAL_ERROR; } WCacheFlushBlocksRAM(Cache, Context, block_array, List, firstPos, lastPos, FALSE);
WCacheRemoveRangeFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), firstLba, Cache->BlocksPerFrame); }
return STATUS_SUCCESS;} // end WCacheFlushAllRAM()
/* WCachePreReadPacket__() reads & caches the whole packet containing requested LBA. This routine just caches data, it doesn't copy anything to user buffer. In general we have no user buffer here... ;) Public routine*/OSSTATUSWCachePreReadPacket__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN lba_t Lba // LBA to cache together with whole packet ){ ULONG frame; OSSTATUS status = STATUS_SUCCESS; PW_CACHE_ENTRY block_array; ULONG BSh = Cache->BlockSizeSh; ULONG BS = Cache->BlockSize; PCHAR addr; SIZE_T _ReadBytes; ULONG PS = Cache->PacketSize; // (in blocks) ULONG BCount = PS; ULONG i, n, err_count; BOOLEAN sector_added = FALSE; ULONG block_type; BOOLEAN zero = FALSE;//TRUE;/* ULONG first_zero=0, last_zero=0; BOOLEAN count_first_zero = TRUE;*/
Lba &= ~(PS-1); frame = Lba >> Cache->BlocksPerFrameSh; i = Lba - (frame << Cache->BlocksPerFrameSh);
// assume successful operation block_array = Cache->FrameList[frame].Frame; if(!block_array) { ASSERT(Cache->FrameCount < Cache->MaxFrames); block_array = WCacheInitFrame(Cache, Context, frame); if(!block_array) return STATUS_INSUFFICIENT_RESOURCES; }
// skip cached extent (if any) n=0; while((n < BCount) && (n < Cache->BlocksPerFrame)) {
addr = (PCHAR)WCacheSectorAddr(block_array, i+n); block_type = Cache->CheckUsedProc(Context, Lba+n); if(/*WCacheGetBadFlag(block_array,i+n)*/ block_type & WCACHE_BLOCK_BAD) { // bad packet. no pre-read return STATUS_DEVICE_DATA_ERROR; } if(!(block_type & WCACHE_BLOCK_ZERO)) { zero = FALSE; //count_first_zero = FALSE; //last_zero = 0; if(!addr) { // sector is not cached, stop search break; } } else {/* if(count_first_zero) { first_zero++; } last_zero++;*/ } n++; } // do nothing if all sectors are already cached if(n < BCount) {
// read whole packet if(!zero) { status = Cache->ReadProc(Context, Cache->tmp_buff_r, PS<<BSh, Lba, &_ReadBytes, PH_TMP_BUFFER); if(!OS_SUCCESS(status)) { status = WCacheRaiseIoError(Cache, Context, status, Lba, PS, Cache->tmp_buff_r, WCACHE_R_OP, NULL); } } else { status = STATUS_SUCCESS; //RtlZeroMemory(Cache->tmp_buff_r, PS<<BSh); _ReadBytes = PS<<BSh; } if(OS_SUCCESS(status)) { // and now we'll copy them to cache for(n=0; n<BCount; n++, i++) { if(WCacheSectorAddr(block_array,i)) { continue; } addr = block_array[i].Sector = (PCHAR)DbgAllocatePoolWithTag(CACHED_BLOCK_MEMORY_TYPE, BS, MEM_WCBUF_TAG); if(!addr) { BrutePoint(); break; } sector_added = TRUE; if(!zero) { DbgCopyMemory(addr, Cache->tmp_buff_r+(n<<BSh), BS); } else { RtlZeroMemory(addr, BS); } Cache->FrameList[frame].BlockCount++; } } else { // read sectors one by one and copy them to cache // unreadable sectors will be treated as zero-filled err_count = 0; for(n=0; n<BCount; n++, i++) { if(WCacheSectorAddr(block_array,i)) { continue; } addr = block_array[i].Sector = (PCHAR)DbgAllocatePoolWithTag(CACHED_BLOCK_MEMORY_TYPE, BS, MEM_WCBUF_TAG); if(!addr) { BrutePoint(); break; } sector_added = TRUE; status = Cache->ReadProc(Context, Cache->tmp_buff_r, BS, Lba+n, &_ReadBytes, PH_TMP_BUFFER); if(!OS_SUCCESS(status)) { status = WCacheRaiseIoError(Cache, Context, status, Lba+n, 1, Cache->tmp_buff_r, WCACHE_R_OP, NULL); if(!OS_SUCCESS(status)) { err_count++; } } if(!zero && OS_SUCCESS(status)) { DbgCopyMemory(addr, Cache->tmp_buff_r, BS); } else if(Cache->RememberBB) { RtlZeroMemory(addr, BS); /* if(!OS_SUCCESS(status)) { WCacheSetBadFlag(block_array,i); } */ } Cache->FrameList[frame].BlockCount++; if(err_count >= 2) { break; } }// _ReadBytes = n<<BSh; } }
// we know the number of unread sectors if an error occured // so we can need to update BlockCount // return number of read bytes if(sector_added) WCacheInsertRangeToList(Cache->CachedBlocksList, &(Cache->BlockCount), Lba, n);
return status;} // end WCachePreReadPacket__()
/* WCacheReadBlocks__() reads data from cache or read it form media and store in cache. Public routine */OSSTATUSWCacheReadBlocks__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN PCHAR Buffer, // user-supplied buffer for read blocks IN lba_t Lba, // LBA to start read from IN ULONG BCount, // number of blocks to be read OUT PSIZE_T ReadBytes, // user-supplied pointer to ULONG that will // recieve number of actually read bytes IN BOOLEAN CachedOnly // specifies that cache is already locked ){ ULONG frame; ULONG i, saved_i, saved_BC = BCount, n; OSSTATUS status = STATUS_SUCCESS; PW_CACHE_ENTRY block_array; ULONG BSh = Cache->BlockSizeSh; SIZE_T BS = Cache->BlockSize; PCHAR addr; ULONG to_read, saved_to_read;// PCHAR saved_buff = Buffer; SIZE_T _ReadBytes; ULONG PS = Cache->PacketSize; ULONG MaxR = Cache->MaxBytesToRead; ULONG PacketMask = PS-1; // here we assume that Packet Size value is 2^n ULONG d; ULONG block_type;
WcPrint(("WC:R %x (%x)\n", Lba, BCount));
(*ReadBytes) = 0; // check if we try to read too much data if(BCount >= Cache->MaxBlocks) { i = 0; if(CachedOnly) { status = STATUS_INVALID_PARAMETER; goto EO_WCache_R2; } while(TRUE) { status = WCacheReadBlocks__(Cache, Context, Buffer + (i<<BSh), Lba, PS, &_ReadBytes, FALSE); (*ReadBytes) += _ReadBytes; if(!OS_SUCCESS(status) || (BCount <= PS)) break; BCount -= PS; Lba += PS; i += PS; } return status; } // check if we try to access beyond cached area if((Lba < Cache->FirstLba) || (Lba + BCount - 1 > Cache->LastLba)) { status = Cache->ReadProc(Context, Buffer, BCount, Lba, ReadBytes, 0); if(!OS_SUCCESS(status)) { status = WCacheRaiseIoError(Cache, Context, status, Lba, BCount, Buffer, WCACHE_R_OP, NULL); } return status; } if(!CachedOnly) { ExAcquireResourceExclusiveLite(&(Cache->WCacheLock), TRUE); }
frame = Lba >> Cache->BlocksPerFrameSh; i = Lba - (frame << Cache->BlocksPerFrameSh);
if(Cache->CacheWholePacket && (BCount < PS)) { if(!CachedOnly && !OS_SUCCESS(status = WCacheCheckLimits(Cache, Context, Lba & ~(PS-1), PS*2)) ) { ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); return status; } } else { if(!CachedOnly && !OS_SUCCESS(status = WCacheCheckLimits(Cache, Context, Lba, BCount))) { ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); return status; } } if(!CachedOnly) { // convert to shared// ExConvertExclusiveToSharedLite(&(Cache->WCacheLock)); }
// pre-read packet. It is very useful for // highly fragmented files if(Cache->CacheWholePacket && (BCount < PS)) {// status = WCacheReadBlocks__(Cache, Context, Cache->tmp_buff_r, Lba & (~PacketMask), PS, &_ReadBytes, TRUE); // we should not perform IO if user requested CachedOnly data if(!CachedOnly) { status = WCachePreReadPacket__(Cache, Context, Lba); } status = STATUS_SUCCESS; }
// assume successful operation block_array = Cache->FrameList[frame].Frame; if(!block_array) { ASSERT(!CachedOnly); ASSERT(Cache->FrameCount < Cache->MaxFrames); block_array = WCacheInitFrame(Cache, Context, frame); if(!block_array) { status = STATUS_INSUFFICIENT_RESOURCES; goto EO_WCache_R; } }
Cache->FrameList[frame].AccessCount++; while(BCount) { if(i >= Cache->BlocksPerFrame) { frame++; block_array = Cache->FrameList[frame].Frame; i -= Cache->BlocksPerFrame; } if(!block_array) { ASSERT(Cache->FrameCount < Cache->MaxFrames); block_array = WCacheInitFrame(Cache, Context, frame); if(!block_array) { status = STATUS_INSUFFICIENT_RESOURCES; goto EO_WCache_R; } } // 'read' cached extent (if any) // it is just copying while(BCount && (i < Cache->BlocksPerFrame) && (addr = (PCHAR)WCacheSectorAddr(block_array, i)) ) { block_type = Cache->CheckUsedProc(Context, Lba+saved_BC-BCount); if(block_type & WCACHE_BLOCK_BAD) { //if(WCacheGetBadFlag(block_array,i)) { status = STATUS_DEVICE_DATA_ERROR; goto EO_WCache_R; } DbgCopyMemory(Buffer, addr, BS); Buffer += BS; *ReadBytes += BS; i++; BCount--; } // read non-cached packet-size-aligned extent (if any) // now we'll calculate total length & decide if it has enough size if(!((d = Lba+saved_BC-BCount) & PacketMask) && d ) { n = 0; while(BCount && (i < Cache->BlocksPerFrame) && (!WCacheSectorAddr(block_array, i)) ) { n++; BCount--; } BCount += n; n &= ~PacketMask; if(n>PS) { if(!OS_SUCCESS(status = Cache->ReadProc(Context, Buffer, BS*n, Lba+saved_BC-BCount, &_ReadBytes, 0))) { status = WCacheRaiseIoError(Cache, Context, status, Lba+saved_BC-BCount, n, Buffer, WCACHE_R_OP, NULL); if(!OS_SUCCESS(status)) { goto EO_WCache_R; } }// WCacheInsertRangeToList(Cache->CachedBlocksList, &(Cache->BlockCount), Lba, saved_BC - BCount); BCount -= n; Lba += saved_BC - BCount; saved_BC = BCount; i += n; Buffer += BS*n; *ReadBytes += BS*n; }// } else {// UDFPrint(("Unaligned\n")); } // read non-cached extent (if any) // firstable, we'll get total number of sectors to read to_read = 0; saved_i = i; d = BCount; while(d && (i < Cache->BlocksPerFrame) && (!WCacheSectorAddr(block_array, i)) ) { i++; to_read += BS; d--; } // read some not cached sectors if(to_read) { i = saved_i; saved_to_read = to_read; d = BCount - d; // split request if necessary if(saved_to_read > MaxR) { WCacheInsertRangeToList(Cache->CachedBlocksList, &(Cache->BlockCount), Lba, saved_BC - BCount); n = MaxR >> BSh; do { status = Cache->ReadProc(Context, Buffer, MaxR, i + (frame << Cache->BlocksPerFrameSh), &_ReadBytes, 0); *ReadBytes += _ReadBytes; if(!OS_SUCCESS(status)) { _ReadBytes &= ~(BS-1); BCount -= _ReadBytes >> BSh; saved_to_read -= _ReadBytes; Buffer += _ReadBytes; saved_BC = BCount; goto store_read_data_1; } Buffer += MaxR; saved_to_read -= MaxR; i += n; BCount -= n; d -= n; } while(saved_to_read > MaxR); saved_BC = BCount; } if(saved_to_read) { status = Cache->ReadProc(Context, Buffer, saved_to_read, i + (frame << Cache->BlocksPerFrameSh), &_ReadBytes, 0); *ReadBytes += _ReadBytes; if(!OS_SUCCESS(status)) { _ReadBytes &= ~(BS-1); BCount -= _ReadBytes >> BSh; saved_to_read -= _ReadBytes; Buffer += _ReadBytes; goto store_read_data_1; } Buffer += saved_to_read; saved_to_read = 0; BCount -= d; }
store_read_data_1: // and now we'll copy them to cache
// Buffer -= (to_read - saved_to_read); i = saved_i; while(to_read - saved_to_read) { block_array[i].Sector = (PCHAR)DbgAllocatePoolWithTag(CACHED_BLOCK_MEMORY_TYPE, BS, MEM_WCBUF_TAG); if(!block_array[i].Sector) { BCount += to_read >> BSh; status = STATUS_INSUFFICIENT_RESOURCES; goto EO_WCache_R; } DbgCopyMemory(block_array[i].Sector, Buffer, BS); Cache->FrameList[frame].BlockCount++; i++; Buffer += BS; to_read -= BS; } if(!OS_SUCCESS(status)) goto EO_WCache_R; to_read = 0; } }
EO_WCache_R:
// we know the number of unread sectors if an error occured // so we can need to update BlockCount // return number of read bytes WCacheInsertRangeToList(Cache->CachedBlocksList, &(Cache->BlockCount), Lba, saved_BC - BCount);// Cache->FrameList[frame].BlockCount -= BCount;EO_WCache_R2: if(!CachedOnly) { ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); }
return status;} // end WCacheReadBlocks__()
/* WCacheWriteBlocks__() writes data to cache. Data is written directly to media if: 1) requested block is Packet-aligned 2) requested Lba(s) lays beyond cached area Public routine */OSSTATUSWCacheWriteBlocks__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN PCHAR Buffer, // user-supplied buffer containing data to be written IN lba_t Lba, // LBA to start write from IN ULONG BCount, // number of blocks to be written OUT PSIZE_T WrittenBytes, // user-supplied pointer to ULONG that will // recieve number of actually written bytes IN BOOLEAN CachedOnly // specifies that cache is already locked ){ ULONG frame; ULONG i, saved_BC = BCount, n, d; OSSTATUS status = STATUS_SUCCESS; PW_CACHE_ENTRY block_array; ULONG BSh = Cache->BlockSizeSh; ULONG BS = Cache->BlockSize; PCHAR addr;// PCHAR saved_buff = Buffer; SIZE_T _WrittenBytes; ULONG PS = Cache->PacketSize; ULONG PacketMask = PS-1; // here we assume that Packet Size value is 2^n ULONG block_type;// BOOLEAN Aligned = FALSE;
BOOLEAN WriteThrough = FALSE; lba_t WTh_Lba; ULONG WTh_BCount;
WcPrint(("WC:W %x (%x)\n", Lba, BCount));
*WrittenBytes = 0;// UDFPrint(("BCount:%x\n",BCount)); // check if we try to read too much data if(BCount >= Cache->MaxBlocks) { i = 0; if(CachedOnly) { status = STATUS_INVALID_PARAMETER; goto EO_WCache_W2; } while(TRUE) {// UDFPrint((" BCount:%x\n",BCount)); status = WCacheWriteBlocks__(Cache, Context, Buffer + (i<<BSh), Lba, min(PS,BCount), &_WrittenBytes, FALSE); (*WrittenBytes) += _WrittenBytes; BCount -= PS; Lba += PS; i += PS; if(!OS_SUCCESS(status) || (BCount < PS)) return status; } } // check if we try to access beyond cached area if((Lba < Cache->FirstLba) || (Lba + BCount - 1 > Cache->LastLba)) { return STATUS_INVALID_PARAMETER; } if(!CachedOnly) { ExAcquireResourceExclusiveLite(&(Cache->WCacheLock), TRUE); }
frame = Lba >> Cache->BlocksPerFrameSh; i = Lba - (frame << Cache->BlocksPerFrameSh);
if(!CachedOnly && !OS_SUCCESS(status = WCacheCheckLimits(Cache, Context, Lba, BCount))) { ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); return status; }
// assume successful operation block_array = Cache->FrameList[frame].Frame; if(!block_array) {
if(BCount && !(BCount & (PS-1)) && !(Lba & (PS-1)) && (Cache->Mode != WCACHE_MODE_R) && (i+BCount <= Cache->BlocksPerFrame) && !Cache->NoWriteThrough) { status = Cache->WriteProc(Context, Buffer, BCount<<BSh, Lba, WrittenBytes, 0); if(!OS_SUCCESS(status)) { status = WCacheRaiseIoError(Cache, Context, status, Lba, BCount, Buffer, WCACHE_W_OP, NULL); } goto EO_WCache_W2; }
ASSERT(!CachedOnly); ASSERT(Cache->FrameCount < Cache->MaxFrames); block_array = WCacheInitFrame(Cache, Context, frame); if(!block_array) { status = STATUS_INSUFFICIENT_RESOURCES; goto EO_WCache_W; } }
if(Cache->Mode == WCACHE_MODE_RAM && BCount &&// !(Lba & (PS-1)) && (!(BCount & (PS-1)) || (BCount > PS)) ) { WriteThrough = TRUE; WTh_Lba = Lba; WTh_BCount = BCount; } else if(Cache->Mode == WCACHE_MODE_RAM && ((Lba & ~PacketMask) != ((Lba+BCount-1) & ~PacketMask)) ) { WriteThrough = TRUE; WTh_Lba = Lba & ~PacketMask; WTh_BCount = PS; }
Cache->FrameList[frame].UpdateCount++;// UDFPrint((" BCount:%x\n",BCount)); while(BCount) { if(i >= Cache->BlocksPerFrame) { frame++; block_array = Cache->FrameList[frame].Frame; i -= Cache->BlocksPerFrame; } if(!block_array) { ASSERT(Cache->FrameCount < Cache->MaxFrames); block_array = WCacheInitFrame(Cache, Context, frame); if(!block_array) { status = STATUS_INSUFFICIENT_RESOURCES; goto EO_WCache_W; } } // 'write' cached extent (if any) // it is just copying while(BCount && (i < Cache->BlocksPerFrame) && (addr = (PCHAR)WCacheSectorAddr(block_array, i)) ) {// UDFPrint(("addr:%x:Buffer:%x:BS:%x:BCount:%x\n",addr, Buffer, BS, BCount)); block_type = Cache->CheckUsedProc(Context, Lba+saved_BC-BCount); if(Cache->NoWriteBB && /*WCacheGetBadFlag(block_array,i)*/ (block_type & WCACHE_BLOCK_BAD)) { // bad packet. no cached write status = STATUS_DEVICE_DATA_ERROR; goto EO_WCache_W; } DbgCopyMemory(addr, Buffer, BS); WCacheSetModFlag(block_array, i); Buffer += BS; *WrittenBytes += BS; i++; BCount--; } // write non-cached not-aligned extent (if any) till aligned one while(BCount && (i & PacketMask) && (Cache->Mode != WCACHE_MODE_R) && (i < Cache->BlocksPerFrame) && (!WCacheSectorAddr(block_array, i)) ) { block_array[i].Sector = (PCHAR)DbgAllocatePoolWithTag(CACHED_BLOCK_MEMORY_TYPE, BS, MEM_WCBUF_TAG); if(!block_array[i].Sector) { status = STATUS_INSUFFICIENT_RESOURCES; goto EO_WCache_W; }// UDFPrint(("addr:%x:Buffer:%x:BS:%x:BCount:%x\n",block_array[i].Sector, Buffer, BS, BCount)); DbgCopyMemory(block_array[i].Sector, Buffer, BS); WCacheSetModFlag(block_array, i); i++; Buffer += BS; *WrittenBytes += BS; BCount--; Cache->FrameList[frame].BlockCount ++; } // write non-cached packet-size-aligned extent (if any) // now we'll calculate total length & decide if has enough size if(!Cache->NoWriteThrough && ( !(i & PacketMask) || ((Cache->Mode == WCACHE_MODE_R) && (BCount >= PS)) )) { n = 0; while(BCount && (i < Cache->BlocksPerFrame) && (!WCacheSectorAddr(block_array, i)) ) { n++; BCount--; } BCount += n; n &= ~PacketMask;// if(!OS_SUCCESS(status = Cache->WriteProcAsync(Context, Buffer, BS*n, Lba+saved_BC-BCount, &_WrittenBytes, FALSE))) if(n) { // add previously written data to list d = saved_BC - BCount; WCacheInsertRangeToList(Cache->CachedBlocksList, &(Cache->BlockCount), Lba, d); WCacheInsertRangeToList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba, d); Lba += d; saved_BC = BCount;
while(n) { if(Cache->Mode == WCACHE_MODE_R) Cache->UpdateRelocProc(Context, Lba, NULL, PS); if(!OS_SUCCESS(status = Cache->WriteProc(Context, Buffer, PS<<BSh, Lba, &_WrittenBytes, 0))) { status = WCacheRaiseIoError(Cache, Context, status, Lba, PS, Buffer, WCACHE_W_OP, NULL); if(!OS_SUCCESS(status)) { goto EO_WCache_W; } } BCount -= PS; Lba += PS; saved_BC = BCount; i += PS; Buffer += PS<<BSh; *WrittenBytes += PS<<BSh; n-=PS; } } } // write non-cached not-aligned extent (if any) while(BCount && (i < Cache->BlocksPerFrame) && (!WCacheSectorAddr(block_array, i)) ) { block_array[i].Sector = (PCHAR)DbgAllocatePoolWithTag(CACHED_BLOCK_MEMORY_TYPE, BS, MEM_WCBUF_TAG); if(!block_array[i].Sector) { status = STATUS_INSUFFICIENT_RESOURCES; goto EO_WCache_W; }// UDFPrint(("addr:%x:Buffer:%x:BS:%x:BCount:%x\n",block_array[i].Sector, Buffer, BS, BCount)); DbgCopyMemory(block_array[i].Sector, Buffer, BS); WCacheSetModFlag(block_array, i); i++; Buffer += BS; *WrittenBytes += BS; BCount--; Cache->FrameList[frame].BlockCount ++; } }
EO_WCache_W:
// we know the number of unread sectors if an error occured // so we can need to update BlockCount // return number of read bytes WCacheInsertRangeToList(Cache->CachedBlocksList, &(Cache->BlockCount), Lba, saved_BC - BCount); WCacheInsertRangeToList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba, saved_BC - BCount);
if(WriteThrough && !BCount) { ULONG d;// lba_t lastLba; ULONG firstPos; ULONG lastPos;
BCount = WTh_BCount; Lba = WTh_Lba; while(BCount) { frame = Lba >> Cache->BlocksPerFrameSh;// firstLba = frame << Cache->BlocksPerFrameSh; firstPos = WCacheGetSortedListIndex(Cache->BlockCount, Cache->CachedBlocksList, Lba); d = min(Lba+BCount, (frame+1) << Cache->BlocksPerFrameSh) - Lba; lastPos = WCacheGetSortedListIndex(Cache->BlockCount, Cache->CachedBlocksList, Lba+d); block_array = Cache->FrameList[frame].Frame; if(!block_array) { ASSERT(FALSE); BCount -= d; Lba += d; continue; } status = WCacheFlushBlocksRAM(Cache, Context, block_array, Cache->CachedBlocksList, firstPos, lastPos, FALSE); WCacheRemoveRangeFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba, d); BCount -= d; Lba += d; } }
EO_WCache_W2:
if(!CachedOnly) { ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); } return status;} // end WCacheWriteBlocks__()
/* WCacheFlushAll__() copies all data stored in cache to media. Flushed blocks are kept in cache. Public routine */VOIDWCacheFlushAll__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context) // user-supplied context for IO callbacks{ if(!(Cache->ReadProc)) return; ExAcquireResourceExclusiveLite(&(Cache->WCacheLock), TRUE);
switch(Cache->Mode) { case WCACHE_MODE_RAM: WCacheFlushAllRAM(Cache, Context); break; case WCACHE_MODE_ROM: case WCACHE_MODE_RW: WCacheFlushAllRW(Cache, Context); break; case WCACHE_MODE_R: WCachePurgeAllR(Cache, Context); break; }
ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); return;} // end WCacheFlushAll__()
/* WCachePurgeAll__() copies all data stored in cache to media. Flushed blocks are removed cache. Public routine */VOIDWCachePurgeAll__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context) // user-supplied context for IO callbacks{ if(!(Cache->ReadProc)) return; ExAcquireResourceExclusiveLite(&(Cache->WCacheLock), TRUE);
switch(Cache->Mode) { case WCACHE_MODE_RAM: WCachePurgeAllRAM(Cache, Context); break; case WCACHE_MODE_ROM: case WCACHE_MODE_RW: WCachePurgeAllRW(Cache, Context); break; case WCACHE_MODE_R: WCachePurgeAllR(Cache, Context); break; }
ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); return;} // end WCachePurgeAll__()/* WCachePurgeAllRW() copies modified blocks from cache to media and removes them from cache This routine can be used for RAM, RW and ROM media. For ROM media blocks are just removed. Internal routine */VOID__fastcallWCachePurgeAllRW( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context) // user-supplied context for IO callbacks{ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedBlocksList; lba_t Lba;// ULONG firstPos;// ULONG lastPos; ULONG BSh = Cache->BlockSizeSh; ULONG BS = Cache->BlockSize; ULONG PS = BS << Cache->PacketSizeSh; // packet size (bytes) ULONG PSs = Cache->PacketSize; PW_CACHE_ENTRY block_array;// OSSTATUS status; SIZE_T ReadBytes; PW_CACHE_ASYNC FirstWContext = NULL; PW_CACHE_ASYNC PrevWContext = NULL; ULONG chain_count = 0;
if(!(Cache->ReadProc)) return;
while(Cache->BlockCount) { Lba = List[0] & ~(PSs-1); frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh;// firstPos = WCacheGetSortedListIndex(Cache->BlockCount, List, Lba);// lastPos = WCacheGetSortedListIndex(Cache->BlockCount, List, Lba+PSs); block_array = Cache->FrameList[frame].Frame; if(!block_array) { BrutePoint(); return; }
WCacheUpdatePacket(Cache, Context, &FirstWContext, &PrevWContext, block_array, firstLba, Lba, BSh, BS, PS, PSs, &ReadBytes, TRUE, ASYNC_STATE_NONE);
// free memory WCacheFreePacket(Cache, frame, block_array, Lba-firstLba, PSs);
WCacheRemoveRangeFromList(List, &(Cache->BlockCount), Lba, PSs); WCacheRemoveRangeFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba, PSs); // check if frame is empty if(!(Cache->FrameList[frame].BlockCount)) { WCacheRemoveFrame(Cache, Context, frame); } else { ASSERT(Cache->FrameList[frame].Frame); } chain_count++; if(chain_count >= WCACHE_MAX_CHAIN) { WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext, FALSE); chain_count = 0; } } WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext); return;} // end WCachePurgeAllRW()
/* WCacheFlushAllRW() copies modified blocks from cache to media. All blocks are not removed from cache. This routine can be used for RAM, RW and ROM media. Internal routine */VOID__fastcallWCacheFlushAllRW( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context) // user-supplied context for IO callbacks{ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedModifiedBlocksList; lba_t Lba;// ULONG firstPos;// ULONG lastPos; ULONG BSh = Cache->BlockSizeSh; ULONG BS = Cache->BlockSize; ULONG PS = BS << Cache->PacketSizeSh; // packet size (bytes) ULONG PSs = Cache->PacketSize; ULONG BFs = Cache->BlocksPerFrameSh; PW_CACHE_ENTRY block_array;// OSSTATUS status; SIZE_T ReadBytes; PW_CACHE_ASYNC FirstWContext = NULL; PW_CACHE_ASYNC PrevWContext = NULL; ULONG i; ULONG chain_count = 0;
if(!(Cache->ReadProc)) return;
// walk through modified blocks while(Cache->WriteCount) { Lba = List[0] & ~(PSs-1); frame = Lba >> BFs; firstLba = frame << BFs;// firstPos = WCacheGetSortedListIndex(Cache->WriteCount, List, Lba);// lastPos = WCacheGetSortedListIndex(Cache->WriteCount, List, Lba+PSs); block_array = Cache->FrameList[frame].Frame; if(!block_array) { BrutePoint(); continue;; } // queue modify request WCacheUpdatePacket(Cache, Context, &FirstWContext, &PrevWContext, block_array, firstLba, Lba, BSh, BS, PS, PSs, &ReadBytes, TRUE, ASYNC_STATE_NONE); // clear MODIFIED flag for queued blocks WCacheRemoveRangeFromList(List, &(Cache->WriteCount), Lba, PSs); Lba -= firstLba; for(i=0; i<PSs; i++) { WCacheClrModFlag(block_array, Lba+i); } chain_count++; // check queue size if(chain_count >= WCACHE_MAX_CHAIN) { WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext, FALSE); chain_count = 0; } } WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext, FALSE);#ifdef DBG#if 1 // check consistency List = Cache->CachedBlocksList; for(i=0; i<Cache->BlockCount; i++) { Lba = List[i] /*& ~(PSs-1)*/; frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; block_array = Cache->FrameList[frame].Frame; if(!block_array) { BrutePoint(); } ASSERT(!WCacheGetModFlag(block_array, Lba-firstLba)); }#endif // 1#endif // DBG return;} // end WCacheFlushAllRW()
/* WCacheRelease__() frees all allocated memory blocks and deletes synchronization resources Public routine */VOIDWCacheRelease__( IN PW_CACHE Cache // pointer to the Cache Control structure ){ ULONG i, j, k; PW_CACHE_ENTRY block_array;
Cache->Tag = 0xDEADCACE; if(!(Cache->ReadProc)) return;// ASSERT(Cache->Tag == 0xCAC11E00); ExAcquireResourceExclusiveLite(&(Cache->WCacheLock), TRUE); for(i=0; i<Cache->FrameCount; i++) { j = Cache->CachedFramesList[i]; block_array = Cache->FrameList[j].Frame; if(block_array) { for(k=0; k<Cache->BlocksPerFrame; k++) { if(WCacheSectorAddr(block_array, k)) { WCacheFreeSector(j, k); } } MyFreePool__(block_array); } } if(Cache->FrameList) MyFreePool__(Cache->FrameList); if(Cache->CachedBlocksList) MyFreePool__(Cache->CachedBlocksList); if(Cache->CachedModifiedBlocksList) MyFreePool__(Cache->CachedModifiedBlocksList); if(Cache->CachedFramesList) MyFreePool__(Cache->CachedFramesList); if(Cache->tmp_buff_r) MyFreePool__(Cache->tmp_buff_r); if(Cache->CachedFramesList) MyFreePool__(Cache->tmp_buff); if(Cache->CachedFramesList) MyFreePool__(Cache->reloc_tab); ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); ExDeleteResourceLite(&(Cache->WCacheLock)); RtlZeroMemory(Cache, sizeof(W_CACHE)); return;} // end WCacheRelease__()
/* WCacheIsInitialized__() checks if the pointer supplied points to initialized cache structure. Public routine */BOOLEANWCacheIsInitialized__( IN PW_CACHE Cache ){ return (Cache->ReadProc != NULL);} // end WCacheIsInitialized__()
OSSTATUSWCacheFlushBlocksRW( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN lba_t _Lba, // LBA to start flush from IN ULONG BCount // number of blocks to be flushed ){ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedModifiedBlocksList; lba_t Lba;// ULONG firstPos;// ULONG lastPos; ULONG BSh = Cache->BlockSizeSh; ULONG BS = Cache->BlockSize; ULONG PS = BS << Cache->PacketSizeSh; // packet size (bytes) ULONG PSs = Cache->PacketSize; ULONG BFs = Cache->BlocksPerFrameSh; PW_CACHE_ENTRY block_array;// OSSTATUS status; SIZE_T ReadBytes; PW_CACHE_ASYNC FirstWContext = NULL; PW_CACHE_ASYNC PrevWContext = NULL; ULONG i; ULONG chain_count = 0; lba_t lim;
if(!(Cache->ReadProc)) return STATUS_INVALID_PARAMETER;
// walk through modified blocks lim = (_Lba+BCount+PSs-1) & ~(PSs-1); for(Lba = _Lba & ~(PSs-1);Lba < lim ; Lba += PSs) { frame = Lba >> BFs; firstLba = frame << BFs;// firstPos = WCacheGetSortedListIndex(Cache->WriteCount, List, Lba);// lastPos = WCacheGetSortedListIndex(Cache->WriteCount, List, Lba+PSs); block_array = Cache->FrameList[frame].Frame; if(!block_array) { // not cached block may be requested for flush Lba += (1 << BFs) - PSs; continue; } // queue modify request WCacheUpdatePacket(Cache, Context, &FirstWContext, &PrevWContext, block_array, firstLba, Lba, BSh, BS, PS, PSs, &ReadBytes, TRUE, ASYNC_STATE_NONE); // clear MODIFIED flag for queued blocks WCacheRemoveRangeFromList(List, &(Cache->WriteCount), Lba, PSs); Lba -= firstLba; for(i=0; i<PSs; i++) { WCacheClrModFlag(block_array, Lba+i); } Lba += firstLba; chain_count++; // check queue size if(chain_count >= WCACHE_MAX_CHAIN) { WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext, FALSE); chain_count = 0; } } WCacheUpdatePacketComplete(Cache, Context, &FirstWContext, &PrevWContext, FALSE);/* if(Cache->Mode != WCACHE_MODE_RAM) return STATUS_SUCCESS;*/
return STATUS_SUCCESS;} // end WCacheFlushBlocksRW()
/* WCacheFlushBlocks__() copies specified blocks stored in cache to media. Flushed blocks are kept in cache. Public routine */OSSTATUSWCacheFlushBlocks__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN lba_t Lba, // LBA to start flush from IN ULONG BCount // number of blocks to be flushed ){ OSSTATUS status;
if(!(Cache->ReadProc)) return STATUS_INVALID_PARAMETER; ExAcquireResourceExclusiveLite(&(Cache->WCacheLock), TRUE);
// check if we try to access beyond cached area if((Lba < Cache->FirstLba) || (Lba+BCount-1 > Cache->LastLba)) { UDFPrint(("LBA %#x (%x) is beyond cacheable area\n", Lba, BCount)); BrutePoint(); status = STATUS_INVALID_PARAMETER; goto EO_WCache_F; }
switch(Cache->Mode) { case WCACHE_MODE_RAM:// WCacheFlushBlocksRW(Cache, Context);// break; case WCACHE_MODE_ROM: case WCACHE_MODE_RW: status = WCacheFlushBlocksRW(Cache, Context, Lba, BCount); break; case WCACHE_MODE_R: status = STATUS_SUCCESS; break; }EO_WCache_F: ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); return status;} // end WCacheFlushBlocks__()
/* WCacheDirect__() returns pointer to memory block where requested block is stored in. If no #CachedOnly flag specified this routine locks cache, otherwise it assumes that cache is already locked by previous call to WCacheStartDirect__(). Cache can be unlocked by WCacheEODirect__(). Using this routine caller can access cached block directly in memory without Read_to_Tmp and Modify/Write steps. Public routine */OSSTATUSWCacheDirect__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN lba_t Lba, // LBA of block to get pointer to IN BOOLEAN Modified, // indicates that block will be modified OUT PCHAR* CachedBlock, // address for pointer to cached block to be stored in IN BOOLEAN CachedOnly // specifies that cache is already locked ){ ULONG frame; ULONG i; OSSTATUS status = STATUS_SUCCESS; PW_CACHE_ENTRY block_array; ULONG BS = Cache->BlockSize; PCHAR addr; SIZE_T _ReadBytes; ULONG block_type;
WcPrint(("WC:%sD %x (1)\n", Modified ? "W" : "R", Lba));
// lock cache if nececcary if(!CachedOnly) { ExAcquireResourceExclusiveLite(&(Cache->WCacheLock), TRUE); } // check if we try to access beyond cached area if((Lba < Cache->FirstLba) || (Lba > Cache->LastLba)) { UDFPrint(("LBA %#x is beyond cacheable area\n", Lba)); BrutePoint(); status = STATUS_INVALID_PARAMETER; goto EO_WCache_D; }
frame = Lba >> Cache->BlocksPerFrameSh; i = Lba - (frame << Cache->BlocksPerFrameSh); // check if we have enough space to store requested block if(!CachedOnly && !OS_SUCCESS(status = WCacheCheckLimits(Cache, Context, Lba, 1))) { BrutePoint(); goto EO_WCache_D; }
// small updates are more important block_array = Cache->FrameList[frame].Frame; if(Modified) { Cache->FrameList[frame].UpdateCount+=8; } else { Cache->FrameList[frame].AccessCount+=8; } if(!block_array) { ASSERT(Cache->FrameCount < Cache->MaxFrames); block_array = WCacheInitFrame(Cache, Context, frame); if(!block_array) { status = STATUS_INSUFFICIENT_RESOURCES; goto EO_WCache_D; } } // check if requested block is already cached if( !(addr = (PCHAR)WCacheSectorAddr(block_array, i)) ) { // block is not cached // allocate memory and read block from media // do not set block_array[i].Sector here, because if media access fails and recursive access to cache // comes, this block should not be marked as 'cached' addr = (PCHAR)DbgAllocatePoolWithTag(CACHED_BLOCK_MEMORY_TYPE, BS, MEM_WCBUF_TAG); if(!addr) { status = STATUS_INSUFFICIENT_RESOURCES; goto EO_WCache_D; } block_type = Cache->CheckUsedProc(Context, Lba); if(block_type == WCACHE_BLOCK_USED) { status = Cache->ReadProc(Context, addr, BS, Lba, &_ReadBytes, PH_TMP_BUFFER); if(Cache->RememberBB) { if(!OS_SUCCESS(status)) { RtlZeroMemory(addr, BS); //WCacheSetBadFlag(block_array,i); } } } else { if(block_type & WCACHE_BLOCK_BAD) { DbgFreePool(addr); addr = NULL; status = STATUS_DEVICE_DATA_ERROR; goto EO_WCache_D; } if(!(block_type & WCACHE_BLOCK_ZERO)) { BrutePoint(); } status = STATUS_SUCCESS; RtlZeroMemory(addr, BS); } // now add pointer to buffer to common storage block_array[i].Sector = addr; WCacheInsertItemToList(Cache->CachedBlocksList, &(Cache->BlockCount), Lba); if(Modified) { WCacheInsertItemToList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba); WCacheSetModFlag(block_array, i); } Cache->FrameList[frame].BlockCount ++; } else { // block is not cached // just return pointer block_type = Cache->CheckUsedProc(Context, Lba); if(block_type & WCACHE_BLOCK_BAD) { //if(WCacheGetBadFlag(block_array,i)) { // bad packet. no pre-read status = STATUS_DEVICE_DATA_ERROR; goto EO_WCache_D; }#ifndef UDF_CHECK_UTIL ASSERT(block_type & WCACHE_BLOCK_USED);#else if(!(block_type & WCACHE_BLOCK_USED)) { UDFPrint(("LBA %#x is not marked as used\n", Lba)); }#endif if(Modified && !WCacheGetModFlag(block_array, i)) { WCacheInsertItemToList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba); WCacheSetModFlag(block_array, i); } } (*CachedBlock) = addr;
EO_WCache_D:
return status;} // end WCacheDirect__()
/* WCacheEODirect__() must be used to unlock cache after calls to to WCacheStartDirect__(). Public routine */OSSTATUSWCacheEODirect__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context // user-supplied context for IO callbacks ){ ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); return STATUS_SUCCESS;} // end WCacheEODirect__()
/* WCacheStartDirect__() locks cache for exclusive use. Using this routine caller can access cached block directly in memory without Read_to_Tmp and Modify/Write steps. See also WCacheDirect__() Cache can be unlocked by WCacheEODirect__(). Public routine */OSSTATUSWCacheStartDirect__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN BOOLEAN Exclusive // lock cache for exclusive use, // currently must be TRUE. ){ if(Exclusive) { ExAcquireResourceExclusiveLite(&(Cache->WCacheLock), TRUE); } else { BrutePoint(); ExAcquireResourceSharedLite(&(Cache->WCacheLock), TRUE); } return STATUS_SUCCESS;} // end WCacheStartDirect__()
/* WCacheIsCached__() checks if requested blocks are immediately available. Cache must be previously locked for exclusive use with WCacheStartDirect__(). Using this routine caller can access cached block directly in memory without Read_to_Tmp and Modify/Write steps. See also WCacheDirect__(). Cache can be unlocked by WCacheEODirect__(). Public routine */BOOLEANWCacheIsCached__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN lba_t Lba, // LBA to start check from IN ULONG BCount // number of blocks to be checked ){ ULONG frame; ULONG i; PW_CACHE_ENTRY block_array;
// check if we try to access beyond cached area if((Lba < Cache->FirstLba) || (Lba + BCount - 1 > Cache->LastLba)) { return FALSE; }
frame = Lba >> Cache->BlocksPerFrameSh; i = Lba - (frame << Cache->BlocksPerFrameSh);
block_array = Cache->FrameList[frame].Frame; if(!block_array) { return FALSE; }
while(BCount) { if(i >= Cache->BlocksPerFrame) { frame++; block_array = Cache->FrameList[frame].Frame; i -= Cache->BlocksPerFrame; } if(!block_array) { return FALSE; } // 'read' cached extent (if any) while(BCount && (i < Cache->BlocksPerFrame) && WCacheSectorAddr(block_array, i) && /*!WCacheGetBadFlag(block_array, i)*/ /*!(Cache->CheckUsedProc(Context, Lba) & WCACHE_BLOCK_BAD)*/ TRUE ) { i++; BCount--; Lba++; } if(BCount && (i < Cache->BlocksPerFrame) /*&& (!WCacheSectorAddr(block_array, i))*/ ) { return FALSE; } } return TRUE;} // end WCacheIsCached__()
/* WCacheCheckLimitsR() implements automatic flush and purge of unused blocks to keep enough free cache entries for newly read/written blocks for WORM media. See also WCacheCheckLimits() Internal routine */OSSTATUS__fastcallWCacheCheckLimitsR( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context, // user-supplied context for IO callbacks IN lba_t ReqLba, // first LBA to access/cache IN ULONG BCount // number of Blocks to access/cache ){ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedBlocksList; lba_t Lba; PCHAR tmp_buff = Cache->tmp_buff; ULONG firstPos; ULONG BSh = Cache->BlockSizeSh; ULONG BS = Cache->BlockSize; ULONG PS = BS << Cache->PacketSizeSh; // packet size (bytes) ULONG PSs = Cache->PacketSize; ULONG i; PW_CACHE_ENTRY block_array; BOOLEAN mod; OSSTATUS status; SIZE_T ReadBytes; ULONG MaxReloc = Cache->PacketSize; PULONG reloc_tab = Cache->reloc_tab;
// check if we try to read too much data if(BCount > Cache->MaxBlocks) { return STATUS_INVALID_PARAMETER; }
// remove(flush) packets from entire frame(s) while( ((Cache->BlockCount + WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba) + BCount - WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba+BCount)) > Cache->MaxBlocks) || (Cache->FrameCount >= Cache->MaxFrames) ) {
WCCL_retry_1:
Lba = WCacheFindLbaToRelease(Cache); if(Lba == WCACHE_INVALID_LBA) { ASSERT(!Cache->FrameCount); ASSERT(!Cache->BlockCount); break; } frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; firstPos = WCacheGetSortedListIndex(Cache->BlockCount, List, Lba); block_array = Cache->FrameList[frame].Frame; if(!block_array) { return STATUS_DRIVER_INTERNAL_ERROR; } // check if modified mod = WCacheGetModFlag(block_array, Lba - firstLba); // read/modify/write if(mod && (Cache->CheckUsedProc(Context, Lba) & WCACHE_BLOCK_USED)) { if(Cache->WriteCount < MaxReloc) goto WCCL_retry_1; firstPos = WCacheGetSortedListIndex(Cache->WriteCount, Cache->CachedModifiedBlocksList, Lba); if(!block_array) { return STATUS_DRIVER_INTERNAL_ERROR; } // prepare packet & reloc table for(i=0; i<MaxReloc; i++) { Lba = Cache->CachedModifiedBlocksList[firstPos]; frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; block_array = Cache->FrameList[frame].Frame; DbgCopyMemory(tmp_buff + (i << BSh), (PVOID)WCacheSectorAddr(block_array, Lba-firstLba), BS); reloc_tab[i] = Lba; WCacheRemoveItemFromList(List, &(Cache->BlockCount), Lba); WCacheRemoveItemFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba); // mark as non-cached & free pool WCacheFreeSector(frame, Lba-firstLba); // check if frame is empty if(!Cache->FrameList[frame].BlockCount) { WCacheRemoveFrame(Cache, Context, frame); } if(firstPos >= Cache->WriteCount) firstPos=0; } // write packet// status = Cache->WriteProcAsync(Context, tmp_buff, PS, Lba, &ReadBytes, FALSE); Cache->UpdateRelocProc(Context, NULL, reloc_tab, MaxReloc); status = Cache->WriteProc(Context, tmp_buff, PS, NULL, &ReadBytes, 0); if(!OS_SUCCESS(status)) { status = WCacheRaiseIoError(Cache, Context, status, NULL, PSs, tmp_buff, WCACHE_W_OP, NULL); } } else {
if((i = Cache->BlockCount - Cache->WriteCount) > MaxReloc) i = MaxReloc; // discard blocks for(; i; i--) { Lba = List[firstPos]; frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; block_array = Cache->FrameList[frame].Frame;
if( (mod = WCacheGetModFlag(block_array, Lba - firstLba)) && (Cache->CheckUsedProc(Context, Lba) & WCACHE_BLOCK_USED) ) continue; WCacheRemoveItemFromList(List, &(Cache->BlockCount), Lba); if(mod) WCacheRemoveItemFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba); // mark as non-cached & free pool WCacheFreeSector(frame, Lba-firstLba); // check if frame is empty if(!Cache->FrameList[frame].BlockCount) { WCacheRemoveFrame(Cache, Context, frame); } if(firstPos >= Cache->WriteCount) firstPos=0; } } } return STATUS_SUCCESS;} // end WCacheCheckLimitsR()
/* WCachePurgeAllR() copies modified blocks from cache to media and removes them from cache This routine can be used for R media only. Internal routine */VOID__fastcallWCachePurgeAllR( IN PW_CACHE Cache, // pointer to the Cache Control structure IN PVOID Context) // user-supplied context for IO callbacks{ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedBlocksList; lba_t Lba; PCHAR tmp_buff = Cache->tmp_buff; ULONG BSh = Cache->BlockSizeSh; ULONG BS = Cache->BlockSize;// ULONG PS = BS << Cache->PacketSizeSh; // packet size (bytes)// ULONG PSs = Cache->PacketSize; PW_CACHE_ENTRY block_array; BOOLEAN mod; OSSTATUS status; SIZE_T ReadBytes; ULONG MaxReloc = Cache->PacketSize; PULONG reloc_tab = Cache->reloc_tab; ULONG RelocCount = 0; BOOLEAN IncompletePacket; ULONG i=0; ULONG PacketTail;
while(Cache->WriteCount < Cache->BlockCount) {
Lba = List[i]; frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; block_array = Cache->FrameList[frame].Frame; if(!block_array) { BrutePoint(); return; } // check if modified mod = WCacheGetModFlag(block_array, Lba - firstLba); // just discard if(!mod || !(Cache->CheckUsedProc(Context, Lba) & WCACHE_BLOCK_USED)) { // mark as non-cached & free pool if(WCacheSectorAddr(block_array,Lba-firstLba)) { WCacheRemoveItemFromList(List, &(Cache->BlockCount), Lba); if(mod) WCacheRemoveItemFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba); // mark as non-cached & free pool WCacheFreeSector(frame, Lba-firstLba); // check if frame is empty if(!Cache->FrameList[frame].BlockCount) { WCacheRemoveFrame(Cache, Context, frame); } } else { BrutePoint(); } } else { i++; } }
PacketTail = Cache->WriteCount & (MaxReloc-1); IncompletePacket = (Cache->WriteCount >= MaxReloc) ? FALSE : TRUE;
// remove(flush) packet while((Cache->WriteCount > PacketTail) || (Cache->WriteCount && IncompletePacket)) {
Lba = List[0]; frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; block_array = Cache->FrameList[frame].Frame; if(!block_array) { BrutePoint(); return; } // check if modified mod = WCacheGetModFlag(block_array, Lba - firstLba); // pack/reloc/write if(mod) { DbgCopyMemory(tmp_buff + (RelocCount << BSh), (PVOID)WCacheSectorAddr(block_array, Lba-firstLba), BS); reloc_tab[RelocCount] = Lba; RelocCount++; // write packet if((RelocCount >= MaxReloc) || (Cache->BlockCount == 1)) {// status = Cache->WriteProcAsync(Context, tmp_buff, PS, Lba, &ReadBytes, FALSE); Cache->UpdateRelocProc(Context, NULL, reloc_tab, RelocCount); status = Cache->WriteProc(Context, tmp_buff, RelocCount<<BSh, NULL, &ReadBytes, 0); if(!OS_SUCCESS(status)) { status = WCacheRaiseIoError(Cache, Context, status, NULL, RelocCount, tmp_buff, WCACHE_W_OP, NULL); } RelocCount = 0; } WCacheRemoveItemFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba); } else { BrutePoint(); } // mark as non-cached & free pool if(WCacheSectorAddr(block_array,Lba-firstLba)) { WCacheRemoveItemFromList(List, &(Cache->BlockCount), Lba); // mark as non-cached & free pool WCacheFreeSector(frame, Lba-firstLba); // check if frame is empty if(!Cache->FrameList[frame].BlockCount) { WCacheRemoveFrame(Cache, Context, frame); } } else { BrutePoint(); } }} // end WCachePurgeAllR()
/* WCacheSetMode__() changes cache operating mode (ROM/R/RW/RAM). Public routine */OSSTATUSWCacheSetMode__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN ULONG Mode // cache mode/media type to be used ){ if(Mode > WCACHE_MODE_MAX) return STATUS_INVALID_PARAMETER; Cache->Mode = Mode; return STATUS_SUCCESS;} // end WCacheSetMode__()
/* WCacheGetMode__() returns cache operating mode (ROM/R/RW/RAM). Public routine */ULONGWCacheGetMode__( IN PW_CACHE Cache ){ return Cache->Mode;} // end WCacheGetMode__()
/* WCacheGetWriteBlockCount__() returns number of modified blocks, those are not flushed to media. Is usually used to preallocate blocks for relocation table on WORM (R) media. Public routine */ULONGWCacheGetWriteBlockCount__( IN PW_CACHE Cache ){ return Cache->WriteCount;} // end WCacheGetWriteBlockCount__()
/* WCacheSyncReloc__() builds list of all modified blocks, currently stored in cache. For each modified block WCacheSyncReloc__() calls user-supplied callback routine in order to update relocation table on WORM (R) media. Public routine */VOIDWCacheSyncReloc__( IN PW_CACHE Cache, IN PVOID Context){ ULONG frame; lba_t firstLba; lba_t* List = Cache->CachedBlocksList; lba_t Lba;// ULONG BSh = Cache->BlockSizeSh;// ULONG BS = Cache->BlockSize;// ULONG PS = BS << Cache->PacketSizeSh; // packet size (bytes)// ULONG PSs = Cache->PacketSize; PW_CACHE_ENTRY block_array; BOOLEAN mod; ULONG MaxReloc = Cache->PacketSize; PULONG reloc_tab = Cache->reloc_tab; ULONG RelocCount = 0; BOOLEAN IncompletePacket;
IncompletePacket = (Cache->WriteCount >= MaxReloc) ? FALSE : TRUE; // enumerate modified blocks for(ULONG i=0; IncompletePacket && (i<Cache->BlockCount); i++) {
Lba = List[i]; frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; block_array = Cache->FrameList[frame].Frame; if(!block_array) { return; } // check if modified mod = WCacheGetModFlag(block_array, Lba - firstLba); // update relocation table for modified sectors if(mod && (Cache->CheckUsedProc(Context, Lba) & WCACHE_BLOCK_USED)) { reloc_tab[RelocCount] = Lba; RelocCount++; if(RelocCount >= Cache->WriteCount) { Cache->UpdateRelocProc(Context, NULL, reloc_tab, RelocCount); break; } } }} // end WCacheSyncReloc__()
/* WCacheDiscardBlocks__() removes specified blocks from cache. Blocks are not flushed to media. Public routine */VOIDWCacheDiscardBlocks__( IN PW_CACHE Cache, IN PVOID Context, IN lba_t ReqLba, IN ULONG BCount ){ ULONG frame; lba_t firstLba; lba_t* List; lba_t Lba; PW_CACHE_ENTRY block_array; BOOLEAN mod; ULONG i;
ExAcquireResourceExclusiveLite(&(Cache->WCacheLock), TRUE);
UDFPrint((" Discard req: %x@%x\n",BCount, ReqLba));
List = Cache->CachedBlocksList; if(!List) { ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); return; } i = WCacheGetSortedListIndex(Cache->BlockCount, List, ReqLba);
// enumerate requested blocks while((List[i] < (ReqLba+BCount)) && (i < Cache->BlockCount)) {
Lba = List[i]; frame = Lba >> Cache->BlocksPerFrameSh; firstLba = frame << Cache->BlocksPerFrameSh; block_array = Cache->FrameList[frame].Frame; if(!block_array) { ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread()); BrutePoint(); return; } // check if modified mod = WCacheGetModFlag(block_array, Lba - firstLba); // just discard
// mark as non-cached & free pool if(WCacheSectorAddr(block_array,Lba-firstLba)) { WCacheRemoveItemFromList(List, &(Cache->BlockCount), Lba); if(mod) WCacheRemoveItemFromList(Cache->CachedModifiedBlocksList, &(Cache->WriteCount), Lba); // mark as non-cached & free pool WCacheFreeSector(frame, Lba-firstLba); // check if frame is empty if(!Cache->FrameList[frame].BlockCount) { WCacheRemoveFrame(Cache, Context, frame); } else { ASSERT(Cache->FrameList[frame].Frame); } } else { // we should never get here !!! // getting this part of code means that we have // placed non-cached block in CachedBlocksList BrutePoint(); } } ExReleaseResourceForThreadLite(&(Cache->WCacheLock), ExGetCurrentResourceThread());} // end WCacheDiscardBlocks__()
OSSTATUSWCacheCompleteAsync__( IN PVOID WContext, IN OSSTATUS Status ){ PW_CACHE_ASYNC AsyncCtx = (PW_CACHE_ASYNC)WContext;// PW_CACHE Cache = AsyncCtx->Cache;
AsyncCtx->PhContext.IosbToUse.Status = Status; KeSetEvent(&(AsyncCtx->PhContext.event), 0, FALSE);
return STATUS_SUCCESS;} // end WCacheSetMode__()
/* WCacheDecodeFlags() updates internal BOOLEANs according to Flags Internal routine */OSSTATUS__fastcallWCacheDecodeFlags( IN PW_CACHE Cache, // pointer to the Cache Control structure IN ULONG Flags // cache mode flags ){ //ULONG OldFlags; if(Flags & ~WCACHE_VALID_FLAGS) { UDFPrint(("Invalid flags: %x\n", Flags & ~WCACHE_VALID_FLAGS)); return STATUS_INVALID_PARAMETER; } Cache->CacheWholePacket = (Flags & WCACHE_CACHE_WHOLE_PACKET) ? TRUE : FALSE; Cache->DoNotCompare = (Flags & WCACHE_DO_NOT_COMPARE) ? TRUE : FALSE; Cache->Chained = (Flags & WCACHE_CHAINED_IO) ? TRUE : FALSE; Cache->RememberBB = (Flags & WCACHE_MARK_BAD_BLOCKS) ? TRUE : FALSE; if(Cache->RememberBB) { Cache->NoWriteBB = (Flags & WCACHE_RO_BAD_BLOCKS) ? TRUE : FALSE; } Cache->NoWriteThrough = (Flags & WCACHE_NO_WRITE_THROUGH) ? TRUE : FALSE;
Cache->Flags = Flags;
return STATUS_SUCCESS;}
/* WCacheChFlags__() changes cache flags. Public routine */ULONGWCacheChFlags__( IN PW_CACHE Cache, // pointer to the Cache Control structure IN ULONG SetFlags, // cache mode/media type to be set IN ULONG ClrFlags // cache mode/media type to be cleared ){ ULONG Flags;
if(SetFlags || ClrFlags) { Flags = (Cache->Flags & ~ClrFlags) | SetFlags;
if(!OS_SUCCESS(WCacheDecodeFlags(Cache, Flags))) { return -1; } } else { return Cache->Flags; } return Flags;} // end WCacheSetMode__()