Something went wrong. Try again.
Reactos
Something went wrong. Try again.
90 kB · 2616 lines
C++
at master
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617////////////////////////////////////////////////////////////////////// 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./////////////////////////////////////////////////////////////////////*
Module Name: FsCntrl.cpp
Abstract:
Contains code to handle the "File System IOCTL" dispatch entry point.
Environment:
Kernel mode only
*/
#include "udffs.h"
// define the file specific bug-check id#define UDF_BUG_CHECK_ID UDF_FILE_FS_CONTROL
NTSTATUS UDFBlankMount(IN PVCB Vcb);
PDIR_INDEX_HDR UDFDirIndexAlloc(IN uint_di i);
/* Function: UDFFSControl()
Description: The I/O Manager will invoke this routine to handle a File System Control request (this is IRP_MJ_FILE_SYSTEM_CONTROL dispatch point)
*/NTSTATUSNTAPIUDFFSControl( PDEVICE_OBJECT DeviceObject, // the logical volume device object PIRP Irp // I/O Request Packet ){ NTSTATUS RC = STATUS_SUCCESS; PtrUDFIrpContext PtrIrpContext; BOOLEAN AreWeTopLevel = FALSE;
UDFPrint(("\nUDFFSControl: \n\n"));
FsRtlEnterFileSystem(); ASSERT(DeviceObject); ASSERT(Irp);
// set the top level context AreWeTopLevel = UDFIsIrpTopLevel(Irp);
_SEH2_TRY {
// get an IRP context structure and issue the request PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject); if(PtrIrpContext) { RC = UDFCommonFSControl(PtrIrpContext, Irp); } else { RC = STATUS_INSUFFICIENT_RESOURCES; Irp->IoStatus.Status = RC; Irp->IoStatus.Information = 0; // complete the IRP IoCompleteRequest(Irp, IO_DISK_INCREMENT); }
} _SEH2_EXCEPT(UDFExceptionFilter(PtrIrpContext, _SEH2_GetExceptionInformation())) {
UDFPrintErr(("UDFFSControl: exception ***")); RC = UDFExceptionHandler(PtrIrpContext, Irp);
UDFLogEvent(UDF_ERROR_INTERNAL_ERROR, RC); } _SEH2_END;
if(AreWeTopLevel) { IoSetTopLevelIrp(NULL); }
FsRtlExitFileSystem();
return(RC);} // end UDFFSControl()
/* Function: UDFCommonFSControl()
Description: The actual work is performed here.
Expected Interrupt Level (for execution) : IRQL_PASSIVE_LEVEL (invocation at higher IRQL will cause execution to be deferred to a worker thread context)
Return Value: STATUS_SUCCESS/Error*/
NTSTATUSNTAPIUDFCommonFSControl( PtrUDFIrpContext PtrIrpContext, PIRP Irp // I/O Request Packet ){ NTSTATUS RC = STATUS_UNRECOGNIZED_VOLUME; PIO_STACK_LOCATION IrpSp = NULL;// PDEVICE_OBJECT PtrTargetDeviceObject = NULL;
UDFPrint(("\nUDFCommonFSControl\n\n"));// BrutePoint();
_SEH2_TRY {
IrpSp = IoGetCurrentIrpStackLocation(Irp); ASSERT(IrpSp);
switch ((IrpSp)->MinorFunction) { case IRP_MN_USER_FS_REQUEST: UDFPrint((" UDFFSControl: UserFsReq request ....\n"));
RC = UDFUserFsCtrlRequest(PtrIrpContext,Irp); break; case IRP_MN_MOUNT_VOLUME:
UDFPrint((" UDFFSControl: MOUNT_VOLUME request ....\n"));
RC = UDFMountVolume(PtrIrpContext,Irp); break; case IRP_MN_VERIFY_VOLUME:
UDFPrint((" UDFFSControl: VERIFY_VOLUME request ....\n"));
RC = UDFVerifyVolume(Irp); break; default: UDFPrintErr((" UDFFSControl: STATUS_INVALID_DEVICE_REQUEST MinorFunction %x\n", (IrpSp)->MinorFunction)); RC = STATUS_INVALID_DEVICE_REQUEST;
Irp->IoStatus.Status = RC; Irp->IoStatus.Information = 0; // complete the IRP IoCompleteRequest(Irp, IO_DISK_INCREMENT); break; }
//try_exit: NOTHING; } _SEH2_FINALLY { if (!_SEH2_AbnormalTermination()) { // Free up the Irp Context UDFPrint((" UDFCommonFSControl: finally\n")); UDFReleaseIrpContext(PtrIrpContext); } else { UDFPrint((" UDFCommonFSControl: finally after exception ***\n")); } } _SEH2_END;
return(RC);} // end UDFCommonFSControl()
/*Routine Description: This is the common routine for implementing the user's requests made through NtFsControlFile.
Arguments: Irp - Supplies the Irp being processed
Return Value: NTSTATUS - The return status for the operation
*/NTSTATUSNTAPIUDFUserFsCtrlRequest( PtrUDFIrpContext IrpContext, PIRP Irp ){ NTSTATUS RC; PEXTENDED_IO_STACK_LOCATION IrpSp = (PEXTENDED_IO_STACK_LOCATION) IoGetCurrentIrpStackLocation( Irp );
// Case on the control code. switch ( IrpSp->Parameters.FileSystemControl.FsControlCode ) {
case FSCTL_REQUEST_OPLOCK_LEVEL_1 : case FSCTL_REQUEST_OPLOCK_LEVEL_2 : case FSCTL_REQUEST_BATCH_OPLOCK : case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE : case FSCTL_OPBATCH_ACK_CLOSE_PENDING : case FSCTL_OPLOCK_BREAK_NOTIFY : case FSCTL_OPLOCK_BREAK_ACK_NO_2 : case FSCTL_REQUEST_FILTER_OPLOCK :
UDFPrint(("UDFUserFsCtrlRequest: OPLOCKS\n")); RC = STATUS_INVALID_DEVICE_REQUEST;
Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST; break;/* RC = UDFOplockRequest( IrpContext, Irp ); break;*/ case FSCTL_INVALIDATE_VOLUMES :
RC = UDFInvalidateVolumes( IrpContext, Irp ); break;/* case FSCTL_MOVE_FILE:
case FSCTL_QUERY_ALLOCATED_RANGES: case FSCTL_SET_ZERO_DATA: case FSCTL_SET_SPARSE:
case FSCTL_MARK_VOLUME_DIRTY:
RC = UDFDirtyVolume( IrpContext, Irp ); break;
*/ case FSCTL_IS_VOLUME_DIRTY:
RC = UDFIsVolumeDirty(IrpContext, Irp); break;
case FSCTL_ALLOW_EXTENDED_DASD_IO:
UDFPrint(("UDFUserFsCtrlRequest: FSCTL_ALLOW_EXTENDED_DASD_IO\n")); // DASD i/o is always permitted // So, no-op this call RC = STATUS_SUCCESS;
Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_SUCCESS; break;
case FSCTL_DISMOUNT_VOLUME:
RC = UDFDismountVolume( IrpContext, Irp ); break;
case FSCTL_IS_VOLUME_MOUNTED:
RC = UDFIsVolumeMounted( IrpContext, Irp ); break;
case FSCTL_FILESYSTEM_GET_STATISTICS:
RC = UDFGetStatistics( IrpContext, Irp ); break;
case FSCTL_LOCK_VOLUME:
RC = UDFLockVolume( IrpContext, Irp ); break;
case FSCTL_UNLOCK_VOLUME:
RC = UDFUnlockVolume( IrpContext, Irp ); break;
case FSCTL_IS_PATHNAME_VALID:
RC = UDFIsPathnameValid( IrpContext, Irp ); break;
case FSCTL_GET_VOLUME_BITMAP:
UDFPrint(("UDFUserFsCtrlRequest: FSCTL_GET_VOLUME_BITMAP\n")); RC = UDFGetVolumeBitmap( IrpContext, Irp ); break;
case FSCTL_GET_RETRIEVAL_POINTERS:
UDFPrint(("UDFUserFsCtrlRequest: FSCTL_GET_RETRIEVAL_POINTERS\n")); RC = UDFGetRetrievalPointers( IrpContext, Irp, 0 ); break;
// We don't support any of the known or unknown requests. default:
UDFPrintErr(("UDFUserFsCtrlRequest: STATUS_INVALID_DEVICE_REQUEST for %x\n", IrpSp->Parameters.FileSystemControl.FsControlCode)); RC = STATUS_INVALID_DEVICE_REQUEST;
Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST; break; }
IoCompleteRequest(Irp,IO_DISK_INCREMENT); return RC;
} // end UDFUserFsCtrlRequest()
/*Routine Description: This is the common routine for implementing the mount requests
Arguments: Irp - Supplies the Irp being processed
Return Value: NTSTATUS - The return status for the operation
*/NTSTATUSNTAPIUDFMountVolume( IN PtrUDFIrpContext PtrIrpContext, IN PIRP Irp ){ NTSTATUS RC; PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp); PDEVICE_OBJECT TargetDeviceObject = NULL; PFILTER_DEV_EXTENSION filterDevExt; PDEVICE_OBJECT fsDeviceObject; PVPB Vpb = IrpSp->Parameters.MountVolume.Vpb; PVCB Vcb = NULL;// PVCB OldVcb = NULL; PDEVICE_OBJECT VolDo = NULL; IO_STATUS_BLOCK Iosb; ULONG MediaChangeCount = 0; ULONG Characteristics; DEVICE_TYPE FsDeviceType; BOOLEAN RestoreDoVerify = FALSE; BOOLEAN WrongMedia = FALSE; BOOLEAN RemovableMedia = TRUE; BOOLEAN CompleteIrp = FALSE; ULONG Mode; TEST_UNIT_READY_USER_OUT TestUnitReadyBuffer; ULONG i; LARGE_INTEGER delay; BOOLEAN VcbAcquired = FALSE; BOOLEAN DeviceNotTouched = TRUE; BOOLEAN Locked = FALSE; int8* ioBuf = NULL;
ASSERT(IrpSp); UDFPrint(("\n !!! UDFMountVolume\n"));// UDFPrint(("Build " VER_STR_PRODUCT "\n\n"));
fsDeviceObject = PtrIrpContext->TargetDeviceObject; UDFPrint(("Mount on device object %x\n", fsDeviceObject)); filterDevExt = (PFILTER_DEV_EXTENSION)fsDeviceObject->DeviceExtension; if (filterDevExt->NodeIdentifier.NodeType == UDF_NODE_TYPE_FILTER_DEVOBJ && filterDevExt->NodeIdentifier.NodeSize == sizeof(FILTER_DEV_EXTENSION)) { CompleteIrp = FALSE; } else if (filterDevExt->NodeIdentifier.NodeType == UDF_NODE_TYPE_UDFFS_DEVOBJ && filterDevExt->NodeIdentifier.NodeSize == sizeof(UDFFS_DEV_EXTENSION)) { CompleteIrp = TRUE; } else { UDFPrintErr(("Invalid node type in FS or FILTER DeviceObject\n")); ASSERT(FALSE); } // Get a pointer to the target physical/virtual device object. TargetDeviceObject = IrpSp->Parameters.MountVolume.DeviceObject;
if(((Characteristics = TargetDeviceObject->Characteristics) & FILE_FLOPPY_DISKETTE) || (UDFGlobalData.UDFFlags & UDF_DATA_FLAGS_BEING_UNLOADED) ) { WrongMedia = TRUE; } else { RemovableMedia = (Characteristics & FILE_REMOVABLE_MEDIA) ? TRUE : FALSE; if(TargetDeviceObject->DeviceType != FILE_DEVICE_CD_ROM) { if(UDFGetRegParameter(NULL, REG_MOUNT_ON_CDONLY_NAME, TRUE)) { WrongMedia = TRUE; } } if(TargetDeviceObject->DeviceType == FILE_DEVICE_CD_ROM) { FsDeviceType = FILE_DEVICE_CD_ROM_FILE_SYSTEM;#ifdef UDF_HDD_SUPPORT } else if (TargetDeviceObject->DeviceType == FILE_DEVICE_DISK) { if(RemovableMedia) { if(!UDFGetRegParameter(NULL, REG_MOUNT_ON_ZIP_NAME, FALSE)) { WrongMedia = TRUE; } } else { if(!UDFGetRegParameter(NULL, REG_MOUNT_ON_HDD_NAME, FALSE)) { WrongMedia = TRUE; } } FsDeviceType = FILE_DEVICE_DISK_FILE_SYSTEM;#endif //UDF_HDD_SUPPORT } else { WrongMedia = TRUE; } }
// Acquire GlobalDataResource UDFAcquireResourceExclusive(&(UDFGlobalData.GlobalDataResource), TRUE);
_SEH2_TRY {
UDFScanForDismountedVcb(PtrIrpContext);
if(WrongMedia) try_return(RC = STATUS_UNRECOGNIZED_VOLUME);
if(RemovableMedia) { UDFPrint(("UDFMountVolume: removable media\n")); // just remember current MediaChangeCount // or fail if No Media ....
// experimental CHECK_VERIFY, for fucking BENQ DVD_DD_1620
// Now we can get device state via GET_EVENT (if supported) // or still one TEST_UNIT_READY command RC = UDFPhSendIOCTL( IOCTL_STORAGE_CHECK_VERIFY, TargetDeviceObject, NULL,0, &MediaChangeCount,sizeof(ULONG), FALSE,&Iosb );
// Send TEST_UNIT_READY comment // This can spin-up or wake-up the device if(UDFGetRegParameter(NULL, UDF_WAIT_CD_SPINUP, TRUE)) { delay.QuadPart = -15000000LL; // 1.5 sec for(i=0; i<UDF_READY_MAX_RETRY; i++) { // Use device default ready timeout Mode = 0; RC = UDFPhSendIOCTL( IOCTL_CDRW_TEST_UNIT_READY, TargetDeviceObject, &Mode,sizeof(Mode), &TestUnitReadyBuffer,sizeof(TEST_UNIT_READY_USER_OUT), FALSE,NULL); UDFPrint(("UDFMountVolume: TEST_UNIT_READY %x\n", RC)); if(!NT_SUCCESS(RC)) break; if(TestUnitReadyBuffer.SenseKey == SCSI_SENSE_NOT_READY && TestUnitReadyBuffer.AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY && TestUnitReadyBuffer.AdditionalSenseCodeQualifier == SCSI_SENSEQ_BECOMING_READY) { UDFPrint(("UDFMountVolume: retry\n")); KeDelayExecutionThread(KernelMode, FALSE, &delay); //delay.QuadPart -= 10000000LL; // 1.0 sec } else { break; } } if(i) { UDFPrint(("UDFMountVolume: additional delay 3 sec\n")); delay.QuadPart = -30000000LL; // 3.0 sec KeDelayExecutionThread(KernelMode, FALSE, &delay); } }
// Now we can get device state via GET_EVENT (if supported) // or still one TEST_UNIT_READY command RC = UDFPhSendIOCTL( IOCTL_STORAGE_CHECK_VERIFY, TargetDeviceObject, NULL,0, &MediaChangeCount,sizeof(ULONG), FALSE,&Iosb );
if(RC == STATUS_IO_DEVICE_ERROR) { UDFPrint(("UDFMountVolume: retry check verify\n")); RC = UDFPhSendIOCTL( IOCTL_STORAGE_CHECK_VERIFY, TargetDeviceObject, NULL,0, &MediaChangeCount,sizeof(ULONG), FALSE,&Iosb ); }
if(!NT_SUCCESS(RC) && (RC != STATUS_VERIFY_REQUIRED)) try_return(RC);
// Be safe about the count in case the driver didn't fill it in if(Iosb.Information != sizeof(ULONG)) { MediaChangeCount = 0; }
if(FsDeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM) { // Check if device is busy before locking tray and performing // further geomentry discovery. This is needed to avoid streaming // loss during CD-R recording. Note, that some recording tools // work with device via SPTI bypassing FS/Device driver layers.
ioBuf = (int8*)MyAllocatePool__(NonPagedPool,4096); if(!ioBuf) { try_return(RC = STATUS_INSUFFICIENT_RESOURCES); } RC = UDFPhSendIOCTL(IOCTL_CDROM_GET_DRIVE_GEOMETRY,TargetDeviceObject, ioBuf,sizeof(DISK_GEOMETRY), ioBuf,sizeof(DISK_GEOMETRY), FALSE, NULL );
if(RC == STATUS_DEVICE_NOT_READY) { // probably, the device is really busy, may be by CD/DVD recording UserPrint((" busy (*)\n")); try_return(RC); } }
// lock media for now if(!WrongMedia) { ((PPREVENT_MEDIA_REMOVAL_USER_IN)(&MediaChangeCount))->PreventMediaRemoval = TRUE; RC = UDFPhSendIOCTL( IOCTL_STORAGE_MEDIA_REMOVAL, TargetDeviceObject, &MediaChangeCount,sizeof(PREVENT_MEDIA_REMOVAL_USER_IN), NULL,0, FALSE,NULL); Locked = TRUE; }
} // Now before we can initialize the Vcb we need to set up the // Get our device object and alignment requirement. // Device extension == VCB UDFPrint(("UDFMountVolume: create device\n")); RC = IoCreateDevice( UDFGlobalData.DriverObject, sizeof(VCB), NULL, FsDeviceType, 0, FALSE, &VolDo );
if(!NT_SUCCESS(RC)) try_return(RC);
// Our alignment requirement is the larger of the processor alignment requirement // already in the volume device object and that in the DeviceObjectWeTalkTo if(TargetDeviceObject->AlignmentRequirement > VolDo->AlignmentRequirement) { VolDo->AlignmentRequirement = TargetDeviceObject->AlignmentRequirement; }
VolDo->Flags &= ~DO_DEVICE_INITIALIZING;
// device object field in the VPB to point to our new volume device // object. Vpb->DeviceObject = (PDEVICE_OBJECT) VolDo;
// We must initialize the stack size in our device object before // the following reads, because the I/O system has not done it yet. ((PDEVICE_OBJECT)VolDo)->StackSize = (CCHAR) (TargetDeviceObject->StackSize + 1);
Vcb = (PVCB)VolDo->DeviceExtension;
// Initialize the Vcb. This routine will raise on an allocation // failure. RC = UDFInitializeVCB(VolDo,TargetDeviceObject,Vpb); if(!NT_SUCCESS(RC)) { Vcb = NULL; try_return(RC); }
VolDo = NULL; Vpb = NULL;
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE ); VcbAcquired = TRUE;
// Let's reference the Vpb to make sure we are the one to // have the last dereference. Vcb->Vpb->ReferenceCount ++;
Vcb->MediaChangeCount = MediaChangeCount; Vcb->FsDeviceType = FsDeviceType;
// Clear the verify bit for the start of mount. if(Vcb->Vpb->RealDevice->Flags & DO_VERIFY_VOLUME) { Vcb->Vpb->RealDevice->Flags &= ~DO_VERIFY_VOLUME; RestoreDoVerify = TRUE; }
DeviceNotTouched = FALSE; RC = UDFGetDiskInfo(TargetDeviceObject,Vcb); if(!NT_SUCCESS(RC)) try_return(RC);
// **** Read registry settings **** UDFReadRegKeys(Vcb, FALSE, FALSE);
Vcb->MountPhErrorCount = 0;
// Initialize internal cache Mode = WCACHE_MODE_ROM; RC = WCacheInit__(&(Vcb->FastCache), Vcb->WCacheMaxFrames, Vcb->WCacheMaxBlocks, Vcb->WriteBlockSize, 5, Vcb->BlockSizeBits, Vcb->WCacheBlocksPerFrameSh, 0/*Vcb->FirstLBA*/, Vcb->LastPossibleLBA, Mode, 0/*WCACHE_CACHE_WHOLE_PACKET*/ | (Vcb->DoNotCompareBeforeWrite ? WCACHE_DO_NOT_COMPARE : 0) | (Vcb->CacheChainedIo ? WCACHE_CHAINED_IO : 0) | WCACHE_MARK_BAD_BLOCKS | WCACHE_RO_BAD_BLOCKS, // this will be cleared after mount Vcb->WCacheFramesToKeepFree,// UDFTWrite, UDFTRead, UDFTWriteVerify, UDFTReadVerify,#ifdef UDF_ASYNC_IO UDFTWriteAsync, UDFTReadAsync,#else //UDF_ASYNC_IO NULL, NULL,#endif //UDF_ASYNC_IO UDFIsBlockAllocated, UDFUpdateVAT, UDFWCacheErrorHandler); if(!NT_SUCCESS(RC)) try_return(RC);
RC = UDFVInit(Vcb); if(!NT_SUCCESS(RC)) try_return(RC);
UDFAcquireResourceExclusive(&(Vcb->BitMapResource1),TRUE); RC = UDFGetDiskInfoAndVerify(TargetDeviceObject,Vcb); UDFReleaseResource(&(Vcb->BitMapResource1));
ASSERT(!Vcb->Modified); WCacheChFlags__(&(Vcb->FastCache), WCACHE_CACHE_WHOLE_PACKET, // enable cache whole packet WCACHE_MARK_BAD_BLOCKS | WCACHE_RO_BAD_BLOCKS); // let user retry request on Bad Blocks
#ifdef UDF_READ_ONLY_BUILD Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY; Vcb->VCBFlags |= UDF_VCB_FLAGS_MEDIA_READ_ONLY;#endif //UDF_READ_ONLY_BUILD
if(!NT_SUCCESS(RC)) { UDFPrint(("UDFMountVolume: try raw mount\n")); if(Vcb->NSRDesc & VRS_ISO9660_FOUND) { UDFPrint(("UDFMountVolume: block raw mount due to ISO9660 presence\n")); Vcb->VCBFlags &= ~UDF_VCB_FLAGS_RAW_DISK; try_return(RC); }try_raw_mount: UDFPrint(("UDFMountVolume: try raw mount (2)\n")); if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
UDFPrint(("UDFMountVolume: trying raw mount...\n")); Vcb->VolIdent.Length = (Vcb->VolIdent.MaximumLength = sizeof(UDF_BLANK_VOLUME_LABEL)) - 2; if(Vcb->VolIdent.Buffer) MyFreePool__(Vcb->VolIdent.Buffer); Vcb->VolIdent.Buffer = (PWCHAR)MyAllocatePool__(NonPagedPool, sizeof(UDF_BLANK_VOLUME_LABEL)); if(!Vcb->VolIdent.Buffer) try_return(STATUS_INSUFFICIENT_RESOURCES); RtlCopyMemory(Vcb->VolIdent.Buffer, UDF_BLANK_VOLUME_LABEL, sizeof(UDF_BLANK_VOLUME_LABEL));
RC = UDFBlankMount(Vcb); if(!NT_SUCCESS(RC)) try_return(RC);
} else {// Vcb->VCBFlags &= ~UDF_VCB_FLAGS_RAW_DISK; try_return(RC); } } else { Vcb->MountPhErrorCount = -1;#ifndef UDF_READ_ONLY_BUILD // set cache mode according to media type if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_READ_ONLY)) { UDFPrint(("UDFMountVolume: writable volume\n")); if(!Vcb->CDR_Mode) { if((FsDeviceType == FILE_DEVICE_DISK_FILE_SYSTEM) || CdrwMediaClassEx_IsRAM(Vcb->MediaClassEx)) { UDFPrint(("UDFMountVolume: RAM mode\n")); Mode = WCACHE_MODE_RAM; } else { UDFPrint(("UDFMountVolume: RW mode\n")); Mode = WCACHE_MODE_RW; }/* if(FsDeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM) { } else { Vcb->WriteSecurity = TRUE; }*/ } else { UDFPrint(("UDFMountVolume: R mode\n")); Mode = WCACHE_MODE_R; } // we can't record ACL on old format disks if(!UDFNtAclSupported(Vcb)) { UDFPrint(("UDFMountVolume: NO ACL and ExtFE support\n")); Vcb->WriteSecurity = FALSE; Vcb->UseExtendedFE = FALSE; } } WCacheSetMode__(&(Vcb->FastCache), Mode);#endif //UDF_READ_ONLY_BUILD // Complete mount operations: create root FCB UDFAcquireResourceExclusive(&(Vcb->BitMapResource1),TRUE); RC = UDFCompleteMount(Vcb); UDFReleaseResource(&(Vcb->BitMapResource1)); if(!NT_SUCCESS(RC)) { // We must have Vcb->VCBOpenCount = 1 for UDFBlankMount() // Thus, we should not decrement it here // Also, if we shall not perform BlankMount, // but simply cleanup and return error, Vcb->VCBOpenCount // will be decremented during cleanup. Thus anyway it must // stay 1 unchanged here //UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount)); UDFCloseResidual(Vcb); Vcb->VCBOpenCount = 1; if(FsDeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM) Vcb->VCBFlags |= UDF_VCB_FLAGS_RAW_DISK; goto try_raw_mount; } Vcb->VCBFlags &= ~UDF_VCB_FLAGS_RAW_DISK; }
#ifndef UDF_READ_ONLY_BUILD if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_READ_ONLY)) { RC = UDFStartEjectWaiter(Vcb); if(!NT_SUCCESS(RC)) try_return(RC); } else { UDFPrint(("UDFMountVolume: RO mount\n")); Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY; }#endif //UDF_READ_ONLY_BUILD
Vcb->Vpb->SerialNumber = Vcb->PhSerialNumber; Vcb->Vpb->VolumeLabelLength = Vcb->VolIdent.Length; RtlCopyMemory( Vcb->Vpb->VolumeLabel, Vcb->VolIdent.Buffer, Vcb->VolIdent.Length );
Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_MOUNTED;
UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount)); Vcb->TotalAllocUnits = UDFGetTotalSpace(Vcb); Vcb->FreeAllocUnits = UDFGetFreeSpace(Vcb); // Register shutdown routine if(!Vcb->ShutdownRegistered) { UDFPrint(("UDFMountVolume: Register shutdown routine\n")); IoRegisterShutdownNotification(Vcb->VCBDeviceObject); Vcb->ShutdownRegistered = TRUE; }
// unlock media if(RemovableMedia) { if(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_READ_ONLY) { UDFPrint(("UDFMountVolume: unlock media on RO volume\n")); ((PPREVENT_MEDIA_REMOVAL_USER_IN)(&MediaChangeCount))->PreventMediaRemoval = FALSE; UDFPhSendIOCTL( IOCTL_STORAGE_MEDIA_REMOVAL, TargetDeviceObject, &MediaChangeCount,sizeof(PREVENT_MEDIA_REMOVAL_USER_IN), NULL,0, FALSE,NULL); if(Vcb->VCBFlags & UDF_VCB_FLAGS_OUR_DEVICE_DRIVER) UDFResetDeviceDriver(Vcb, Vcb->TargetDeviceObject, TRUE); } }
if (UDFGlobalData.MountEvent) { Vcb->IsVolumeJustMounted = TRUE; KeSetEvent(UDFGlobalData.MountEvent, 0, FALSE); }
// The new mount is complete. UDFReleaseResource( &(Vcb->VCBResource) ); VcbAcquired = FALSE; Vcb = NULL;
RC = STATUS_SUCCESS;
try_exit: NOTHING; } _SEH2_FINALLY {
UDFPrint(("UDFMountVolume: RC = %x\n", RC));
if(ioBuf) { MyFreePool__(ioBuf); }
if(!NT_SUCCESS(RC)) {
if(RemovableMedia && Locked) { UDFPrint(("UDFMountVolume: unlock media\n")); ((PPREVENT_MEDIA_REMOVAL_USER_IN)(&MediaChangeCount))->PreventMediaRemoval = FALSE; UDFPhSendIOCTL( IOCTL_STORAGE_MEDIA_REMOVAL, TargetDeviceObject, &MediaChangeCount,sizeof(PREVENT_MEDIA_REMOVAL_USER_IN), NULL,0, FALSE,NULL); }/* if((RC != STATUS_DEVICE_NOT_READY) && (RC != STATUS_NO_MEDIA_IN_DEVICE) ) {*/ // reset driver if(!DeviceNotTouched && (!Vcb || (Vcb && (Vcb->VCBFlags & UDF_VCB_FLAGS_OUR_DEVICE_DRIVER)))) { UDFPrint(("UDFMountVolume: reset driver\n")); UDFResetDeviceDriver(Vcb, TargetDeviceObject, TRUE); }
if(RC == STATUS_CRC_ERROR || RC == STATUS_FILE_CORRUPT_ERROR) { UDFPrint(("UDFMountVolume: status -> STATUS_UNRECOGNIZED_VOLUME\n")); RC = STATUS_UNRECOGNIZED_VOLUME; }
// If we didn't complete the mount then cleanup any remaining structures. if(Vpb) { Vpb->DeviceObject = NULL; }
if(Vcb) { // Restore the verify bit. if(RestoreDoVerify) { Vcb->Vpb->RealDevice->Flags |= DO_VERIFY_VOLUME; } // Make sure there is no Vcb since it could go away if(Vcb->VCBOpenCount) UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount)); // This procedure will also delete the volume device object if(UDFDismountVcb( Vcb, VcbAcquired )) { UDFReleaseResource( &(Vcb->VCBResource) ); } } else if(VolDo) { IoDeleteDevice( VolDo ); } } // Release the global resource. UDFReleaseResource( &(UDFGlobalData.GlobalDataResource) );
if (CompleteIrp || NT_SUCCESS(RC)) { if(!_SEH2_AbnormalTermination()) { // Set mount event
UDFPrint(("UDFMountVolume: complete req RC %x\n", RC)); UDFNotifyVolumeEvent(IrpSp->FileObject, FSRTL_VOLUME_MOUNT); // Complete the IRP. Irp->IoStatus.Status = RC; IoCompleteRequest(Irp, IO_NO_INCREMENT); } } else { // Pass Irp to lower driver (CDFS)
// Get this driver out of the driver stack and get to the next driver as // quickly as possible. Irp->CurrentLocation++; Irp->Tail.Overlay.CurrentStackLocation++;
// Now call the appropriate file system driver with the request. RC = IoCallDriver( filterDevExt->lowerFSDeviceObject, Irp );
}
} _SEH2_END;
UDFPrint(("UDFMountVolume: final RC = %x\n", RC)); return RC;
} // end UDFMountVolume()
NTSTATUSUDFStartEjectWaiter( IN PVCB Vcb ){// NTSTATUS RC; PREVENT_MEDIA_REMOVAL_USER_IN Buff; UDFPrint(("UDFStartEjectWaiter:\n"));
if(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_READ_ONLY) { UDFPrint((" UDF_VCB_FLAGS_MEDIA_READ_ONLY\n")); } if(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_LOCKED) { UDFPrint((" UDF_VCB_FLAGS_MEDIA_LOCKED\n")); } UDFPrint((" EjectWaiter=%x\n", Vcb->EjectWaiter)); if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_READ_ONLY) && /*!(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_LOCKED) &&*/ !(Vcb->EjectWaiter)) {
UDFPrint(("UDFStartEjectWaiter: check driver\n")); if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_OUR_DEVICE_DRIVER) && (Vcb->FsDeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM)) { // we don't know how to write without our device driver Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY; UDFPrint((" not our driver, ignore\n")); return STATUS_SUCCESS; } UDFPrint(("UDFStartEjectWaiter: check removable\n")); if(Vcb->VCBFlags & UDF_VCB_FLAGS_REMOVABLE_MEDIA) { // prevent media removal UDFPrint(("UDFStartEjectWaiter: lock media\n")); Buff.PreventMediaRemoval = TRUE; UDFTSendIOCTL( IOCTL_STORAGE_MEDIA_REMOVAL, Vcb, &Buff,sizeof(PREVENT_MEDIA_REMOVAL_USER_IN), NULL,0, FALSE,NULL ); Vcb->VCBFlags |= UDF_VCB_FLAGS_MEDIA_LOCKED; } UDFPrint(("UDFStartEjectWaiter: prepare to start\n")); // initialize Eject Request waiter Vcb->EjectWaiter = (PUDFEjectWaitContext)MyAllocatePool__(NonPagedPool, sizeof(UDFEjectWaitContext)); if(!(Vcb->EjectWaiter)) return STATUS_INSUFFICIENT_RESOURCES; KeInitializeEvent(&(Vcb->WaiterStopped), NotificationEvent, FALSE); Vcb->EjectWaiter->Vcb = Vcb; Vcb->EjectWaiter->SoftEjectReq = FALSE; KeInitializeEvent(&(Vcb->EjectWaiter->StopReq), NotificationEvent, FALSE);// Vcb->EjectWaiter->StopReq = FALSE; Vcb->EjectWaiter->WaiterStopped = &(Vcb->WaiterStopped); // This can occure after unexpected media loss, when EjectRequestWaiter // terminates automatically ASSERT(!(Vcb->VCBFlags & UDF_VCB_FLAGS_STOP_WAITER_EVENT)); Vcb->VCBFlags |= UDF_VCB_FLAGS_STOP_WAITER_EVENT; ExInitializeWorkItem(&(Vcb->EjectWaiter->EjectReqWorkQueueItem), UDFEjectReqWaiter, Vcb->EjectWaiter); UDFPrint(("UDFStartEjectWaiter: create thread\n")); ExQueueWorkItem(&(Vcb->EjectWaiter->EjectReqWorkQueueItem), DelayedWorkQueue); } else { UDFPrint((" ignore\n")); } return STATUS_SUCCESS;} // end UDFStartEjectWaiter()
NTSTATUSUDFCompleteMount( IN PVCB Vcb ){ NTSTATUS RC;// = STATUS_SUCCESS; PtrUDFNTRequiredFCB NtReqFcb = NULL; PFSRTL_COMMON_FCB_HEADER PtrCommonFCBHeader = NULL; UNICODE_STRING LocalPath; PtrUDFObjectName RootName; PtrUDFFCB RootFcb;
UDFPrint(("UDFCompleteMount:\n")); Vcb->ZBuffer = (PCHAR)DbgAllocatePoolWithTag(NonPagedPool, max(Vcb->LBlockSize, PAGE_SIZE), 'zNWD'); if(!Vcb->ZBuffer) return STATUS_INSUFFICIENT_RESOURCES; RtlZeroMemory(Vcb->ZBuffer, Vcb->LBlockSize);
UDFPrint(("UDFCompleteMount: alloc Root FCB\n")); // Create the root index and reference it in the Vcb. RootFcb = Vcb->RootDirFCB = UDFAllocateFCB(); if(!RootFcb) return STATUS_INSUFFICIENT_RESOURCES;
UDFPrint(("UDFCompleteMount: alloc Root ObjName\n")); // Allocate and set root FCB unique name RootName = UDFAllocateObjectName(); if(!RootName) { UDFCleanUpFCB(RootFcb); Vcb->RootDirFCB = NULL; return STATUS_INSUFFICIENT_RESOURCES; } RC = MyInitUnicodeString(&(RootName->ObjectName),UDF_ROOTDIR_NAME); if(!NT_SUCCESS(RC)) goto insuf_res_1;
RootFcb->FileInfo = (PUDF_FILE_INFO)MyAllocatePool__(NonPagedPool,sizeof(UDF_FILE_INFO)); if(!RootFcb->FileInfo) { RC = STATUS_INSUFFICIENT_RESOURCES;insuf_res_1: MyFreePool__(RootName->ObjectName.Buffer); UDFReleaseObjectName(RootName); UDFCleanUpFCB(RootFcb); Vcb->RootDirFCB = NULL; return RC; } UDFPrint(("UDFCompleteMount: open Root Dir\n")); // Open Root Directory RC = UDFOpenRootFile__( Vcb, &(Vcb->RootLbAddr), RootFcb->FileInfo ); if(!NT_SUCCESS(RC)) {insuf_res_2: UDFCleanUpFile__(Vcb, RootFcb->FileInfo); MyFreePool__(RootFcb->FileInfo); goto insuf_res_1; } RootFcb->FileInfo->Fcb = RootFcb;
if(!(RootFcb->NTRequiredFCB = RootFcb->FileInfo->Dloc->CommonFcb)) { UDFPrint(("UDFCompleteMount: alloc Root ObjName (2)\n")); if(!(RootFcb->NTRequiredFCB = (PtrUDFNTRequiredFCB)MyAllocatePool__(NonPagedPool, UDFQuadAlign(sizeof(UDFNTRequiredFCB))) ) ) { RC = STATUS_INSUFFICIENT_RESOURCES; goto insuf_res_2; } RtlZeroMemory(RootFcb->NTRequiredFCB, UDFQuadAlign(sizeof(UDFNTRequiredFCB))); RootFcb->FileInfo->Dloc->CommonFcb = RootFcb->NTRequiredFCB; } UDFPrint(("UDFCompleteMount: init FCB\n")); RC = UDFInitializeFCB(RootFcb,Vcb,RootName,UDF_FCB_ROOT_DIRECTORY | UDF_FCB_DIRECTORY,NULL); if(!NT_SUCCESS(RC)) { // if we get here, no resources are inited RootFcb->OpenHandleCount = RootFcb->ReferenceCount = RootFcb->NTRequiredFCB->CommonRefCount = 0;
UDFCleanUpFile__(Vcb, RootFcb->FileInfo); MyFreePool__(RootFcb->FileInfo); MyFreePool__(RootFcb->NTRequiredFCB); UDFCleanUpFCB(RootFcb); Vcb->RootDirFCB = NULL; return RC; }
// this is a part of UDF_RESIDUAL_REFERENCE UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount)); RootFcb->OpenHandleCount = RootFcb->ReferenceCount = RootFcb->NTRequiredFCB->CommonRefCount = 1;
UDFGetFileXTime(RootFcb->FileInfo, &(RootFcb->NTRequiredFCB->CreationTime.QuadPart), &(RootFcb->NTRequiredFCB->LastAccessTime.QuadPart), &(RootFcb->NTRequiredFCB->ChangeTime.QuadPart), &(RootFcb->NTRequiredFCB->LastWriteTime.QuadPart) );
if(Vcb->SysStreamLbAddr.logicalBlockNum) { Vcb->SysSDirFileInfo = (PUDF_FILE_INFO)MyAllocatePool__(NonPagedPool,sizeof(UDF_FILE_INFO)); if(!Vcb->SysSDirFileInfo) { RC = STATUS_INSUFFICIENT_RESOURCES; goto unwind_1; } // Open System SDir Directory RC = UDFOpenRootFile__( Vcb, &(Vcb->SysStreamLbAddr), Vcb->SysSDirFileInfo ); if(!NT_SUCCESS(RC)) { UDFCleanUpFile__(Vcb, Vcb->SysSDirFileInfo); MyFreePool__(Vcb->SysSDirFileInfo); Vcb->SysSDirFileInfo = NULL; goto unwind_1; } else { Vcb->SysSDirFileInfo->Dloc->DataLoc.Flags |= EXTENT_FLAG_VERIFY; } }
// Open Unallocatable space stream // Generally, it should be placed in SystemStreamDirectory, but some // stupid apps think that RootDirectory is much better place.... :(( RC = MyInitUnicodeString(&LocalPath, UDF_FN_NON_ALLOCATABLE); if(NT_SUCCESS(RC)) { RC = UDFOpenFile__(Vcb, FALSE, TRUE, &LocalPath, RootFcb->FileInfo, &(Vcb->NonAllocFileInfo), NULL); MyFreePool__(LocalPath.Buffer); } if(!NT_SUCCESS(RC) && (RC != STATUS_OBJECT_NAME_NOT_FOUND)) {
//unwind_2: UDFCleanUpFile__(Vcb, Vcb->NonAllocFileInfo); Vcb->NonAllocFileInfo = NULL; // this was a part of UDF_RESIDUAL_REFERENCE UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));unwind_1:
// UDFCloseResidual() will clean up everything
return RC; }
/* process Non-allocatable */ if(NT_SUCCESS(RC)) { UDFMarkSpaceAsXXX(Vcb, Vcb->NonAllocFileInfo->Dloc, Vcb->NonAllocFileInfo->Dloc->DataLoc.Mapping, AS_USED); // used UDFDirIndex(UDFGetDirIndexByFileInfo(Vcb->NonAllocFileInfo), Vcb->NonAllocFileInfo->Index)->FI_Flags |= UDF_FI_FLAG_FI_INTERNAL; } else { /* try to read Non-allocatable from alternate locations */ RC = MyInitUnicodeString(&LocalPath, UDF_FN_NON_ALLOCATABLE_2); if(!NT_SUCCESS(RC)) { goto unwind_1; } RC = UDFOpenFile__(Vcb, FALSE, TRUE, &LocalPath, RootFcb->FileInfo, &(Vcb->NonAllocFileInfo), NULL); MyFreePool__(LocalPath.Buffer); if(!NT_SUCCESS(RC) && (RC != STATUS_OBJECT_NAME_NOT_FOUND)) { goto unwind_1; } if(NT_SUCCESS(RC)) { UDFMarkSpaceAsXXX(Vcb, Vcb->NonAllocFileInfo->Dloc, Vcb->NonAllocFileInfo->Dloc->DataLoc.Mapping, AS_USED); // used UDFDirIndex(UDFGetDirIndexByFileInfo(Vcb->NonAllocFileInfo), Vcb->NonAllocFileInfo->Index)->FI_Flags |= UDF_FI_FLAG_FI_INTERNAL; } else if(Vcb->SysSDirFileInfo) { RC = MyInitUnicodeString(&LocalPath, UDF_SN_NON_ALLOCATABLE); if(!NT_SUCCESS(RC)) { goto unwind_1; } RC = UDFOpenFile__(Vcb, FALSE, TRUE, &LocalPath, Vcb->SysSDirFileInfo , &(Vcb->NonAllocFileInfo), NULL); MyFreePool__(LocalPath.Buffer); if(!NT_SUCCESS(RC) && (RC != STATUS_OBJECT_NAME_NOT_FOUND)) { goto unwind_1; } if(NT_SUCCESS(RC)) { UDFMarkSpaceAsXXX(Vcb, Vcb->NonAllocFileInfo->Dloc, Vcb->NonAllocFileInfo->Dloc->DataLoc.Mapping, AS_USED); // used// UDFDirIndex(UDFGetDirIndexByFileInfo(Vcb->NonAllocFileInfo), Vcb->NonAllocFileInfo->Index)->FI_Flags |= UDF_FI_FLAG_FI_INTERNAL; } else { RC = STATUS_SUCCESS; } } else { RC = STATUS_SUCCESS; } }
/* Read SN UID mapping */ if(Vcb->SysSDirFileInfo) { RC = MyInitUnicodeString(&LocalPath, UDF_SN_UID_MAPPING); if(!NT_SUCCESS(RC)) goto unwind_3; RC = UDFOpenFile__(Vcb, FALSE, TRUE, &LocalPath, Vcb->SysSDirFileInfo , &(Vcb->UniqueIDMapFileInfo), NULL); MyFreePool__(LocalPath.Buffer); if(!NT_SUCCESS(RC) && (RC != STATUS_OBJECT_NAME_NOT_FOUND)) {unwind_3:// UDFCloseFile__(Vcb, Vcb->NonAllocFileInfo);// UDFCleanUpFile__(Vcb, Vcb->NonAllocFileInfo);// if(Vcb->NonAllocFileInfo)// MyFreePool__(Vcb->NonAllocFileInfo);// Vcb->NonAllocFileInfo = NULL; goto unwind_1; } else { Vcb->UniqueIDMapFileInfo->Dloc->DataLoc.Flags |= EXTENT_FLAG_VERIFY; } RC = STATUS_SUCCESS; }
#define DWN_MAX_CFG_FILE_SIZE 0x10000
/* Read DWN config file from disk with disk-specific options */ RC = MyInitUnicodeString(&LocalPath, UDF_CONFIG_STREAM_NAME_W); if(NT_SUCCESS(RC)) {
int8* buff; SIZE_T len; PUDF_FILE_INFO CfgFileInfo = NULL;
RC = UDFOpenFile__(Vcb, FALSE, TRUE, &LocalPath, RootFcb->FileInfo, &CfgFileInfo, NULL); if(OS_SUCCESS(RC)) {
len = (ULONG)UDFGetFileSize(CfgFileInfo); if(len && len < DWN_MAX_CFG_FILE_SIZE) { buff = (int8*)MyAllocatePool__(NonPagedPool, len); if(buff) { RC = UDFReadFile__(Vcb, CfgFileInfo, 0, len, FALSE, buff, &len); if(OS_SUCCESS(RC)) { // parse config Vcb->Cfg = (PUCHAR)buff; Vcb->CfgLength = len; UDFReadRegKeys(Vcb, TRUE /*update*/, TRUE /*cfg*/); Vcb->Cfg = NULL; Vcb->CfgLength = 0; Vcb->CfgVersion = 0; } MyFreePool__(buff); } }
UDFCloseFile__(Vcb, CfgFileInfo); } if(CfgFileInfo) { UDFCleanUpFile__(Vcb, CfgFileInfo); } MyFreePool__(LocalPath.Buffer); } RC = STATUS_SUCCESS;
// clear Modified flags. It was not real modify, just // bitmap construction Vcb->BitmapModified = FALSE; //Vcb->Modified = FALSE; UDFPreClrModified(Vcb); UDFClrModified(Vcb); // this is a part of UDF_RESIDUAL_REFERENCE UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
NtReqFcb = RootFcb->NTRequiredFCB;
// Start initializing the fields contained in the CommonFCBHeader. PtrCommonFCBHeader = &(NtReqFcb->CommonFCBHeader);
// DisAllow fast-IO for now.// PtrCommonFCBHeader->IsFastIoPossible = FastIoIsNotPossible; PtrCommonFCBHeader->IsFastIoPossible = FastIoIsPossible;
// Initialize the MainResource and PagingIoResource pointers in // the CommonFCBHeader structure to point to the ERESOURCE structures we // have allocated and already initialized above.// PtrCommonFCBHeader->Resource = &(NtReqFcb->MainResource);// PtrCommonFCBHeader->PagingIoResource = &(NtReqFcb->PagingIoResource);
// Initialize the file size values here. PtrCommonFCBHeader->AllocationSize.QuadPart = 0; PtrCommonFCBHeader->FileSize.QuadPart = 0;
// The following will disable ValidDataLength support.// PtrCommonFCBHeader->ValidDataLength.QuadPart = 0x7FFFFFFFFFFFFFFFI64; PtrCommonFCBHeader->ValidDataLength.QuadPart = 0;
if(!NT_SUCCESS(RC)) return RC; UDFAssignAcl(Vcb, NULL, RootFcb, NtReqFcb);/* Vcb->CDBurnerVolumeValid = true;
len = Vcb->CDBurnerVolume.Length = 256; Vcb->CDBurnerVolume.MaximumLength = 256; Vcb->CDBurnerVolume.Buffer = (PWCHAR)ExAllocatePool(NonPagedPool, 256); RC = RegTGetStringValue(NULL, REG_CD_BURNER_KEY_NAME, REG_CD_BURNER_VOLUME_NAME, Vcb->CDBurnerVolume.Buffer, len); Vcb->CDBurnerVolume.Length = (USHORT)(wcslen(Vcb->CDBurnerVolume.Buffer)*sizeof(WCHAR));
if(RC != STATUS_OBJECT_NAME_NOT_FOUND && !NT_SUCCESS(RC) ) return RC;
if (NT_SUCCESS(RC)) { RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL, REG_CD_BURNER_KEY_NAME, REG_CD_BURNER_VOLUME_NAME, REG_SZ,L"",sizeof(L"")+1);
} else { Vcb->CDBurnerVolumeValid = false; RC = STATUS_SUCCESS; }*/ ASSERT(!Vcb->Modified);
return RC;} // end UDFCompleteMount()
NTSTATUSUDFBlankMount( IN PVCB Vcb ){ NTSTATUS RC;// = STATUS_SUCCESS; PtrUDFNTRequiredFCB NtReqFcb = NULL; PFSRTL_COMMON_FCB_HEADER PtrCommonFCBHeader = NULL; PtrUDFObjectName RootName; PtrUDFFCB RootFcb; PDIR_INDEX_HDR hDirNdx; PDIR_INDEX_ITEM DirNdx;
// Create the root index and reference it in the Vcb. RootFcb = Vcb->RootDirFCB = UDFAllocateFCB(); if(!RootFcb) return STATUS_INSUFFICIENT_RESOURCES; RtlZeroMemory(RootFcb,sizeof(UDFFCB));
// Allocate and set root FCB unique name RootName = UDFAllocateObjectName(); if(!RootName) {//bl_unwind_2: UDFCleanUpFCB(RootFcb); Vcb->RootDirFCB = NULL; return STATUS_INSUFFICIENT_RESOURCES; } RC = MyInitUnicodeString(&(RootName->ObjectName),UDF_ROOTDIR_NAME); if(!NT_SUCCESS(RC)) goto bl_unwind_1;
RootFcb->NodeIdentifier.NodeType = UDF_NODE_TYPE_FCB; RootFcb->NodeIdentifier.NodeSize = sizeof(UDFFCB);
RootFcb->FileInfo = (PUDF_FILE_INFO)MyAllocatePool__(NonPagedPool,sizeof(UDF_FILE_INFO)); if(!RootFcb->FileInfo) { MyFreePool__(RootName->ObjectName.Buffer); RC = STATUS_INSUFFICIENT_RESOURCES;bl_unwind_1: UDFReleaseObjectName(RootName); UDFCleanUpFCB(RootFcb); Vcb->RootDirFCB = NULL; return RC; } RtlZeroMemory(RootFcb->FileInfo, sizeof(UDF_FILE_INFO)); if(!OS_SUCCESS(RC = UDFStoreDloc(Vcb, RootFcb->FileInfo, 1))) { MyFreePool__(RootFcb->FileInfo); RootFcb->FileInfo = NULL; MyFreePool__(RootName->ObjectName.Buffer); goto bl_unwind_1; } RootFcb->FileInfo->NextLinkedFile = RootFcb->FileInfo->PrevLinkedFile = RootFcb->FileInfo;
hDirNdx = UDFDirIndexAlloc(2); DirNdx = UDFDirIndex(hDirNdx,0); DirNdx->FileCharacteristics = FILE_DIRECTORY; DirNdx->FI_Flags = UDF_FI_FLAG_SYS_ATTR; DirNdx->SysAttr = FILE_ATTRIBUTE_READONLY; RtlInitUnicodeString(&DirNdx->FName, L"."); DirNdx->FileInfo = RootFcb->FileInfo; DirNdx->FI_Flags |= UDFBuildHashEntry(Vcb, &(DirNdx->FName), &(DirNdx->hashes), HASH_ALL | HASH_KEEP_NAME);
DirNdx = UDFDirIndex(hDirNdx,1); DirNdx->FI_Flags = UDF_FI_FLAG_SYS_ATTR; if(Vcb->ShowBlankCd == 2) { DirNdx->FI_Flags |= UDF_FI_FLAG_FI_INTERNAL; } DirNdx->SysAttr = FILE_ATTRIBUTE_READONLY; RtlInitUnicodeString(&DirNdx->FName, L"Blank.CD"); DirNdx->FI_Flags |= UDFBuildHashEntry(Vcb, &(DirNdx->FName), &(DirNdx->hashes), HASH_ALL);
RootFcb->FileInfo->Dloc->DirIndex = hDirNdx; RootFcb->FileInfo->Fcb = RootFcb;
if(!(RootFcb->NTRequiredFCB = RootFcb->FileInfo->Dloc->CommonFcb)) { if(!(RootFcb->NTRequiredFCB = (PtrUDFNTRequiredFCB)MyAllocatePool__(NonPagedPool, UDFQuadAlign(sizeof(UDFNTRequiredFCB))) ) ) { MyFreePool__(RootName->ObjectName.Buffer); UDFReleaseObjectName(RootName); UDFCleanUpFCB(RootFcb); Vcb->RootDirFCB = NULL; return STATUS_INSUFFICIENT_RESOURCES; } RtlZeroMemory(RootFcb->NTRequiredFCB, UDFQuadAlign(sizeof(UDFNTRequiredFCB))); RootFcb->FileInfo->Dloc->CommonFcb = RootFcb->NTRequiredFCB; } RC = UDFInitializeFCB(RootFcb,Vcb,RootName,UDF_FCB_ROOT_DIRECTORY | UDF_FCB_DIRECTORY,NULL); if(!NT_SUCCESS(RC)) { // if we get here, no resources are inited RootFcb->OpenHandleCount = RootFcb->ReferenceCount = RootFcb->NTRequiredFCB->CommonRefCount = 0;
UDFCleanUpFile__(Vcb, RootFcb->FileInfo); MyFreePool__(RootFcb->FileInfo); MyFreePool__(RootFcb->NTRequiredFCB); UDFCleanUpFCB(RootFcb); Vcb->RootDirFCB = NULL; return RC; }
// this is a part of UDF_RESIDUAL_REFERENCE UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount)); RootFcb->OpenHandleCount = RootFcb->ReferenceCount = RootFcb->NTRequiredFCB->CommonRefCount = RootFcb->FileInfo->RefCount = RootFcb->FileInfo->Dloc->LinkRefCount = 1;
// this is a part of UDF_RESIDUAL_REFERENCE UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
NtReqFcb = RootFcb->NTRequiredFCB;
// Start initializing the fields contained in the CommonFCBHeader. PtrCommonFCBHeader = &(NtReqFcb->CommonFCBHeader);
// DisAllow fast-IO for now. PtrCommonFCBHeader->IsFastIoPossible = FastIoIsNotPossible;
// Initialize the MainResource and PagingIoResource pointers in // the CommonFCBHeader structure to point to the ERESOURCE structures we // have allocated and already initialized above. PtrCommonFCBHeader->Resource = &(NtReqFcb->MainResource); PtrCommonFCBHeader->PagingIoResource = &(NtReqFcb->PagingIoResource);
// Initialize the file size values here. PtrCommonFCBHeader->AllocationSize.QuadPart = 0; PtrCommonFCBHeader->FileSize.QuadPart = 0;
// The following will disable ValidDataLength support. PtrCommonFCBHeader->ValidDataLength.QuadPart = 0x7FFFFFFFFFFFFFFFLL;
return RC;} // end UDFBlankMount()
VOIDUDFCloseResidual( IN PVCB Vcb ){ // Deinitialize Non-alloc file if(Vcb->VCBOpenCount) UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount)); UDFPrint(("UDFCloseResidual: NonAllocFileInfo %x\n", Vcb->NonAllocFileInfo)); if(Vcb->NonAllocFileInfo) { UDFCloseFile__(Vcb,Vcb->NonAllocFileInfo); UDFCleanUpFile__(Vcb, Vcb->NonAllocFileInfo); MyFreePool__(Vcb->NonAllocFileInfo); Vcb->NonAllocFileInfo = NULL; } // Deinitialize Unique ID Mapping UDFPrint(("UDFCloseResidual: NonAllocFileInfo %x\n", Vcb->NonAllocFileInfo)); if(Vcb->UniqueIDMapFileInfo) { UDFCloseFile__(Vcb,Vcb->UniqueIDMapFileInfo); UDFCleanUpFile__(Vcb, Vcb->UniqueIDMapFileInfo); MyFreePool__(Vcb->UniqueIDMapFileInfo); Vcb->UniqueIDMapFileInfo = NULL; } // Deinitialize VAT file UDFPrint(("UDFCloseResidual: VatFileInfo %x\n", Vcb->VatFileInfo)); if(Vcb->VatFileInfo) { UDFCloseFile__(Vcb,Vcb->VatFileInfo); UDFCleanUpFile__(Vcb, Vcb->VatFileInfo); MyFreePool__(Vcb->VatFileInfo); Vcb->VatFileInfo = NULL; } // System StreamDir UDFPrint(("UDFCloseResidual: SysSDirFileInfo %x\n", Vcb->SysSDirFileInfo)); if(Vcb->SysSDirFileInfo) { UDFCloseFile__(Vcb, Vcb->SysSDirFileInfo); UDFCleanUpFile__(Vcb, Vcb->SysSDirFileInfo); MyFreePool__(Vcb->SysSDirFileInfo); Vcb->SysSDirFileInfo = NULL; }/* // Deinitialize root dir fcb if(Vcb->RootDirFCB) { UDFCloseFile__(Vcb,Vcb->RootDirFCB->FileInfo); UDFCleanUpFile__(Vcb, Vcb->RootDirFCB->FileInfo); MyFreePool__(Vcb->RootDirFCB->FileInfo); UDFCleanUpFCB(Vcb->RootDirFCB); // Remove root FCB reference in vcb if(Vcb->VCBOpenCount) Vcb->VCBOpenCount--; }
// Deinitialize Non-alloc file if(Vcb->VCBOpenCount) Vcb->VCBOpenCount--; if(Vcb->NonAllocFileInfo) { UDFCloseFile__(Vcb,Vcb->NonAllocFileInfo); // We must release VCB here !!!!// UDFCleanUpFcbChain(Vcb, Vcb->NonAllocFileInfo, 1); Vcb->NonAllocFileInfo = NULL; } // Deinitialize VAT file if(Vcb->VatFileInfo) { UDFCloseFile__(Vcb,Vcb->VatFileInfo); // We must release VCB here !!!!// UDFCleanUpFcbChain(Vcb, Vcb->VatFileInfo, 1); Vcb->VatFileInfo = NULL; }*/
// Deinitialize root dir fcb UDFPrint(("UDFCloseResidual: RootDirFCB %x\n", Vcb->RootDirFCB)); if(Vcb->RootDirFCB) { UDFCloseFile__(Vcb,Vcb->RootDirFCB->FileInfo); if(Vcb->RootDirFCB->OpenHandleCount) Vcb->RootDirFCB->OpenHandleCount--; UDFCleanUpFcbChain(Vcb, Vcb->RootDirFCB->FileInfo, 1, TRUE); // Remove root FCB reference in vcb if(Vcb->VCBOpenCount) UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount)); Vcb->RootDirFCB = NULL; }} // end UDFCloseResidual()
VOIDUDFCleanupVCB( IN PVCB Vcb ){ _SEH2_TRY { UDFReleaseFileIdCache(Vcb); UDFReleaseDlocList(Vcb); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { BrutePoint(); } _SEH2_END;
if(Vcb->ShutdownRegistered && Vcb->VCBDeviceObject) { IoUnregisterShutdownNotification(Vcb->VCBDeviceObject); Vcb->ShutdownRegistered = FALSE; }
MyFreeMemoryAndPointer(Vcb->Partitions); MyFreeMemoryAndPointer(Vcb->LVid); MyFreeMemoryAndPointer(Vcb->Vat); MyFreeMemoryAndPointer(Vcb->SparingTable);
if(Vcb->FSBM_Bitmap) { DbgFreePool(Vcb->FSBM_Bitmap); Vcb->FSBM_Bitmap = NULL; } if(Vcb->ZSBM_Bitmap) { DbgFreePool(Vcb->ZSBM_Bitmap); Vcb->ZSBM_Bitmap = NULL; } if(Vcb->BSBM_Bitmap) { DbgFreePool(Vcb->BSBM_Bitmap); Vcb->BSBM_Bitmap = NULL; }#ifdef UDF_TRACK_ONDISK_ALLOCATION_OWNERS if(Vcb->FSBM_Bitmap_owners) { DbgFreePool(Vcb->FSBM_Bitmap_owners); Vcb->FSBM_Bitmap_owners = NULL; }#endif //UDF_TRACK_ONDISK_ALLOCATION_OWNERS if(Vcb->FSBM_OldBitmap) { DbgFreePool(Vcb->FSBM_OldBitmap); Vcb->FSBM_OldBitmap = NULL; }
MyFreeMemoryAndPointer(Vcb->Statistics); MyFreeMemoryAndPointer(Vcb->NTRequiredFCB); MyFreeMemoryAndPointer(Vcb->VolIdent.Buffer); MyFreeMemoryAndPointer(Vcb->TargetDevName.Buffer);
if(Vcb->ZBuffer) { DbgFreePool(Vcb->ZBuffer); Vcb->ZBuffer = NULL; }
if(Vcb->fZBuffer) { DbgFreePool(Vcb->fZBuffer); Vcb->fZBuffer = NULL; }
MyFreeMemoryAndPointer(Vcb->OPCh); MyFreeMemoryAndPointer(Vcb->WParams); MyFreeMemoryAndPointer(Vcb->Error); MyFreeMemoryAndPointer(Vcb->TrackMap);
} // end UDFCleanupVCB()
/*
Routine Description:
This routine walks through the list of Vcb's looking for any which may now be deleted. They may have been left on the list because there were outstanding references.
Arguments:
Return Value:
None
*/VOIDUDFScanForDismountedVcb( IN PtrUDFIrpContext IrpContext ){ PVCB Vcb; PLIST_ENTRY Link;
// Walk through all of the Vcb's attached to the global data. Link = UDFGlobalData.VCBQueue.Flink;
while (Link != &(UDFGlobalData.VCBQueue)) {
Vcb = CONTAINING_RECORD( Link, VCB, NextVCB );
// Move to the next link now since the current Vcb may be deleted. Link = Link->Flink;
// If dismount is already underway then check if this Vcb can // go away. if((Vcb->VCBFlags & UDF_VCB_FLAGS_BEING_DISMOUNTED) || ((!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED)) && (Vcb->VCBOpenCount <= UDF_RESIDUAL_REFERENCE))) {
UDFCheckForDismount( IrpContext, Vcb, FALSE ); } }
return;} // end UDFScanForDismountedVcb()
/*Routine Description: This routine determines if a volume is currently mounted.
Arguments: Irp - Supplies the Irp to process
Return Value: NTSTATUS - The return status for the operation
*/NTSTATUSUDFIsVolumeMounted( IN PtrUDFIrpContext IrpContext, IN PIRP Irp ){ PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
PtrUDFFCB Fcb; PtrUDFCCB Ccb;
UDFPrint(("UDFIsVolumeMounted\n"));
Ccb = (PtrUDFCCB)IrpSp->FileObject->FsContext2; if(!Ccb) { UDFPrintErr((" !Ccb\n")); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; } Fcb = Ccb->Fcb;
if(Fcb && !(Fcb->Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) && !(Fcb->Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_LOCKED) ) {
// Disable PopUps, we want to return any error. IrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_FLAG_DISABLE_POPUPS;
// Verify the Vcb. This will raise in the error condition. UDFVerifyVcb( IrpContext, Fcb->Vcb ); }
Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_SUCCESS;
return STATUS_SUCCESS;} // end UDFIsVolumeMounted()
/* This routine returns the filesystem performance counters from the appropriate VCB.
Arguments: Irp - Supplies the Irp to process
Return Value: NTSTATUS - The return status for the operation*/NTSTATUSUDFGetStatistics( IN PtrUDFIrpContext IrpContext, IN PIRP Irp ){ PEXTENDED_IO_STACK_LOCATION IrpSp = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation( Irp ); NTSTATUS status; PVCB Vcb;
PFILE_SYSTEM_STATISTICS Buffer; ULONG BufferLength; ULONG StatsSize; ULONG BytesToCopy;
UDFPrint(("UDFGetStatistics\n"));
// Extract the buffer BufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength; // Get a pointer to the output buffer. Buffer = (PFILE_SYSTEM_STATISTICS)(Irp->AssociatedIrp.SystemBuffer);
// Make sure the buffer is big enough for at least the common part. if (BufferLength < sizeof(FILESYSTEM_STATISTICS)) { status = STATUS_BUFFER_TOO_SMALL; Irp->IoStatus.Information = 0; goto EO_stat; }
// Now see how many bytes we can copy. StatsSize = sizeof(FILE_SYSTEM_STATISTICS) * KeNumberProcessors; if (BufferLength < StatsSize) { BytesToCopy = BufferLength; status = STATUS_BUFFER_OVERFLOW; } else { BytesToCopy = StatsSize; status = STATUS_SUCCESS; }
Vcb = (PVCB)(((PDEVICE_OBJECT)IrpSp->DeviceObject)->DeviceExtension); // Fill in the output buffer RtlCopyMemory( Buffer, Vcb->Statistics, BytesToCopy ); Irp->IoStatus.Information = BytesToCopy;EO_stat: Irp->IoStatus.Status = status;
return status;} // end UDFGetStatistics()
/* This routine determines if pathname is valid path for UDF Filesystem
Arguments: Irp - Supplies the Irp to process
Return Value: NTSTATUS - The return status for the operation*/NTSTATUSUDFIsPathnameValid( IN PtrUDFIrpContext IrpContext, IN PIRP Irp ){ PEXTENDED_IO_STACK_LOCATION IrpSp = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation( Irp ); NTSTATUS RC; PPATHNAME_BUFFER PathnameBuffer; UNICODE_STRING PathName; UNICODE_STRING CurName; PWCHAR TmpBuffer;
UDFPrint(("UDFIsPathnameValid\n"));
// Extract the pathname PathnameBuffer = (PPATHNAME_BUFFER)Irp->AssociatedIrp.SystemBuffer; PathName.Buffer = PathnameBuffer->Name; PathName.Length = (USHORT)PathnameBuffer->PathNameLength;
_SEH2_TRY { // Check for an invalid buffer if (FIELD_OFFSET(PATHNAME_BUFFER, Name[0]) + PathnameBuffer->PathNameLength > IrpSp->Parameters.FileSystemControl.InputBufferLength) { try_return( RC = STATUS_INVALID_PARAMETER); } while (TRUE) { // get next path part... TmpBuffer = PathName.Buffer; PathName.Buffer = UDFDissectName(PathName.Buffer,&(CurName.Length) ); PathName.Length -= (USHORT)((ULONG_PTR)(PathName.Buffer) - (ULONG_PTR)TmpBuffer); CurName.Buffer = PathName.Buffer - CurName.Length; CurName.Length *= sizeof(WCHAR); CurName.MaximumLength -= CurName.Length;
if (CurName.Length) { // check path fragment size if (CurName.Length > UDF_NAME_LEN*sizeof(WCHAR)) { try_return(RC = STATUS_OBJECT_NAME_INVALID); } if (!UDFIsNameValid(&CurName, NULL, NULL)) { try_return(RC = STATUS_OBJECT_NAME_INVALID); } } else { try_return(RC = STATUS_SUCCESS); } }try_exit: NOTHING; } _SEH2_FINALLY { Irp->IoStatus.Information = 0; Irp->IoStatus.Status = RC; } _SEH2_END;
return RC;} // end UDFIsPathnameValid()
/* This routine performs the lock volume operation. It is responsible for either completing of enqueuing the input Irp.Arguments: Irp - Supplies the Irp to processReturn Value: NTSTATUS - The return status for the operation*/NTSTATUSUDFLockVolume( IN PtrUDFIrpContext IrpContext, IN PIRP Irp, IN ULONG PID ){ NTSTATUS RC;
KIRQL SavedIrql; PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
PVCB Vcb; PtrUDFFCB Fcb; PtrUDFCCB Ccb; BOOLEAN VcbAcquired = FALSE;
UDFPrint(("UDFLockVolume: PID %x\n", PID));
// Decode the file object, the only type of opens we accept are // user volume opens. Ccb = (PtrUDFCCB)(IrpSp->FileObject->FsContext2); if(!Ccb) { UDFPrintErr((" !Ccb\n")); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; } Fcb = Ccb->Fcb; Vcb = Fcb->Vcb;
// Check for volume open if (Vcb != (PVCB)Fcb || !(Ccb->CCBFlags & UDF_CCB_VOLUME_OPEN)) { Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; }
UDFNotifyVolumeEvent(IrpSp->FileObject, FSRTL_VOLUME_LOCK);
_SEH2_TRY {
if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)) UDFCloseAllSystemDelayedInDir(Vcb, Vcb->RootDirFCB->FileInfo);#ifdef UDF_DELAYED_CLOSE UDFCloseAllDelayed(Vcb);#endif //UDF_DELAYED_CLOSE
// Acquire exclusive access to the Vcb. UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE ); VcbAcquired = TRUE;
// Verify the Vcb. UDFVerifyVcb( IrpContext, Vcb );
// If the volume is already locked then complete with success if this file // object has the volume locked, fail otherwise./* if (Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_LOCKED) {
if (Vcb->VolumeLockFileObject == IrpSp->FileObject) { RC = STATUS_SUCCESS; } else { RC = STATUS_ACCESS_DENIED; } // If the open count for the volume is greater than 1 then this request // will fail. } else if (Vcb->VCBOpenCount > UDF_RESIDUAL_REFERENCE+1) { RC = STATUS_ACCESS_DENIED; // We will try to get rid of all of the user references. If there is only one // remaining after the purge then we can allow the volume to be locked. } else { // flush system cache UDFReleaseResource( &(Vcb->VCBResource) ); VcbAcquired = FALSE; }*/
} _SEH2_FINALLY {
// Release the Vcb. if(VcbAcquired) { UDFReleaseResource( &(Vcb->VCBResource) ); VcbAcquired = FALSE; } } _SEH2_END;
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE ); VcbAcquired = TRUE; UDFFlushLogicalVolume(NULL, NULL, Vcb/*, 0*/); UDFReleaseResource( &(Vcb->VCBResource) ); VcbAcquired = FALSE; // Check if the Vcb is already locked, or if the open file count // is greater than 1 (which implies that someone else also is // currently using the volume, or a file on the volume). IoAcquireVpbSpinLock( &SavedIrql );
if (!(Vcb->Vpb->Flags & VPB_LOCKED) && (Vcb->VolumeLockPID == (ULONG)-1) && (Vcb->VCBOpenCount <= UDF_RESIDUAL_REFERENCE+1) && (Vcb->Vpb->ReferenceCount == 2)) {
// Mark volume as locked if(PID == (ULONG)-1) { Vcb->Vpb->Flags |= VPB_LOCKED; } Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_LOCKED; Vcb->VolumeLockFileObject = IrpSp->FileObject; Vcb->VolumeLockPID = PID;
RC = STATUS_SUCCESS;
} else {
RC = STATUS_ACCESS_DENIED; }
IoReleaseVpbSpinLock( SavedIrql );
if(!NT_SUCCESS(RC)) { UDFNotifyVolumeEvent(IrpSp->FileObject, FSRTL_VOLUME_LOCK_FAILED); }
// Complete the request if there haven't been any exceptions. Irp->IoStatus.Information = 0; Irp->IoStatus.Status = RC; return RC;} // end UDFLockVolume()
/* This routine performs the unlock volume operation. It is responsible for either completing of enqueuing the input Irp.Arguments: Irp - Supplies the Irp to processReturn Value: NTSTATUS - The return status for the operation*/NTSTATUSUDFUnlockVolume( IN PtrUDFIrpContext IrpContext, IN PIRP Irp, IN ULONG PID ){ NTSTATUS RC = STATUS_INVALID_PARAMETER;
KIRQL SavedIrql; PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
PVCB Vcb; PtrUDFFCB Fcb; PtrUDFCCB Ccb;
UDFPrint(("UDFUnlockVolume: PID %x\n", PID));
// Decode the file object, the only type of opens we accept are // user volume opens. Ccb = (PtrUDFCCB)(IrpSp->FileObject->FsContext2); if(!Ccb) { UDFPrintErr((" !Ccb\n")); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; } Fcb = Ccb->Fcb; Vcb = Fcb->Vcb;
// Check for volume open if(Vcb != (PVCB)Fcb || !(Ccb->CCBFlags & UDF_CCB_VOLUME_OPEN)) { Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; }
// Acquire exclusive access to the Vcb/Vpb. IoAcquireVpbSpinLock( &SavedIrql );
_SEH2_TRY {
// We won't check for a valid Vcb for this request. An unlock will always // succeed on a locked volume. if(Vcb->Vpb->Flags & VPB_LOCKED || Vcb->VolumeLockPID == PID) { Vcb->Vpb->Flags &= ~VPB_LOCKED; Vcb->VCBFlags &= ~UDF_VCB_FLAGS_VOLUME_LOCKED; Vcb->VolumeLockFileObject = NULL; Vcb->VolumeLockPID = -1; UDFNotifyVolumeEvent(IrpSp->FileObject, FSRTL_VOLUME_UNLOCK); RC = STATUS_SUCCESS; } else { RC = STATUS_NOT_LOCKED; RC = STATUS_SUCCESS; RC = STATUS_VOLUME_DISMOUNTED; }
} _SEH2_FINALLY { ; } _SEH2_END;
// Release all of our resources IoReleaseVpbSpinLock( SavedIrql );
// Complete the request if there haven't been any exceptions. Irp->IoStatus.Information = 0; Irp->IoStatus.Status = RC; return RC;} // end UDFUnlockVolume()
/* This routine performs the dismount volume operation. It is responsible for either completing of enqueuing the input Irp. We only dismount a volume which has been locked. The intent here is that someone has locked the volume (they are the only remaining handle). We set the verify bit here and the user will close his handle. We will dismount a volume with no user's handles in the verify path.Arguments: Irp - Supplies the Irp to processReturn Value: NTSTATUS - The return status for the operation*/NTSTATUSUDFDismountVolume( IN PtrUDFIrpContext IrpContext, IN PIRP Irp ){ NTSTATUS RC;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
PVCB Vcb; PtrUDFFCB Fcb; PtrUDFCCB Ccb; PPREVENT_MEDIA_REMOVAL_USER_IN Buf = NULL; BOOLEAN VcbAcquired = FALSE;
UDFPrint(("\n ### UDFDismountVolume ###\n\n"));
// Decode the file object, the only type of opens we accept are // user volume opens. Ccb = (PtrUDFCCB)(IrpSp->FileObject->FsContext2); if(!Ccb) { UDFPrintErr((" !Ccb\n")); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; } Fcb = Ccb->Fcb; Vcb = Fcb->Vcb;
// Check for volume open if(Vcb != (PVCB)Fcb || !(Ccb->CCBFlags & UDF_CCB_VOLUME_OPEN)) { Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; }
UDFNotifyVolumeEvent(IrpSp->FileObject, FSRTL_VOLUME_DISMOUNT);
if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)) UDFCloseAllSystemDelayedInDir(Vcb, Vcb->RootDirFCB->FileInfo);#ifdef UDF_DELAYED_CLOSE UDFCloseAllDelayed(Vcb);#endif //UDF_DELAYED_CLOSE
// Acquire exclusive access to the Vcb. UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE ); VcbAcquired = TRUE;
_SEH2_TRY {
// Mark the volume as needs to be verified, but only do it if // the vcb is locked by this handle and the volume is currently mounted.
if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED)) { // disable Eject Request Waiter if any UDFReleaseResource( &(Vcb->VCBResource) ); VcbAcquired = FALSE;
UDFStopEjectWaiter(Vcb); RC = STATUS_SUCCESS; } else if(/*!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED) ||*/ !(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_LOCKED) || (Vcb->VCBOpenCount > (UDF_RESIDUAL_REFERENCE+1))) {
RC = STATUS_NOT_LOCKED; } else if((Vcb->VolumeLockFileObject != IrpSp->FileObject)) {
RC = STATUS_INVALID_PARAMETER;
} else {
Vcb->Vpb->RealDevice->Flags |= DO_VERIFY_VOLUME; Buf = (PPREVENT_MEDIA_REMOVAL_USER_IN)MyAllocatePool__(NonPagedPool, sizeof(PREVENT_MEDIA_REMOVAL_USER_IN)); if(!Buf) try_return(RC = STATUS_INSUFFICIENT_RESOURCES); UDFDoDismountSequence(Vcb, Buf, FALSE); Vcb->VCBFlags &= ~UDF_VCB_FLAGS_VOLUME_MOUNTED; Vcb->WriteSecurity = FALSE; // disable Eject Request Waiter if any UDFReleaseResource( &(Vcb->VCBResource) ); VcbAcquired = FALSE;
UDFStopEjectWaiter(Vcb); RC = STATUS_SUCCESS; }try_exit: NOTHING; } _SEH2_FINALLY { // Free memory if(Buf) MyFreePool__(Buf); // Release all of our resources if(VcbAcquired) UDFReleaseResource( &(Vcb->VCBResource) ); } _SEH2_END;
if(!NT_SUCCESS(RC)) { UDFNotifyVolumeEvent(IrpSp->FileObject, FSRTL_VOLUME_DISMOUNT_FAILED); }
// Complete the request if there haven't been any exceptions. Irp->IoStatus.Information = 0; Irp->IoStatus.Status = RC; return RC;} // end UDFDismountVolume()
/*
This routine returns the volume allocation bitmap.
Input = the STARTING_LCN_INPUT_BUFFER data structure is passed in through the input buffer. Output = the VOLUME_BITMAP_BUFFER data structure is returned through the output buffer.
We return as much as the user buffer allows starting the specified input LCN (trucated to a byte). If there is no input buffer, we start at zero.
Arguments:
Irp - Supplies the Irp being processed.
Return Value:
NTSTATUS - The return status for the operation.
*/NTSTATUSUDFGetVolumeBitmap( IN PtrUDFIrpContext IrpContext, IN PIRP Irp ){// NTSTATUS RC;
PEXTENDED_IO_STACK_LOCATION IrpSp = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation( Irp );
PVCB Vcb; PtrUDFFCB Fcb; PtrUDFCCB Ccb;
UDFPrint(("UDFGetVolumeBitmap\n"));
ULONG BytesToCopy; ULONG TotalClusters; ULONG DesiredClusters; ULONG StartingCluster; ULONG InputBufferLength; ULONG OutputBufferLength; LARGE_INTEGER StartingLcn; PVOLUME_BITMAP_BUFFER OutputBuffer; ULONG i, lim; PULONG FSBM;// PULONG Dest; ULONG LSh;
// Decode the file object, the only type of opens we accept are // user volume opens. Ccb = (PtrUDFCCB)(IrpSp->FileObject->FsContext2); if(!Ccb) { UDFPrintErr((" !Ccb\n")); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; } Fcb = Ccb->Fcb; Vcb = Fcb->Vcb;
InputBufferLength = IrpSp->Parameters.FileSystemControl.InputBufferLength; OutputBufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
OutputBuffer = (PVOLUME_BITMAP_BUFFER)UDFGetCallersBuffer(IrpContext, Irp); if(!OutputBuffer) return STATUS_INVALID_USER_BUFFER;
// Check for a minimum length on the input and output buffers. if ((InputBufferLength < sizeof(STARTING_LCN_INPUT_BUFFER)) || (OutputBufferLength < sizeof(VOLUME_BITMAP_BUFFER))) {
UDFUnlockCallersBuffer(IrpContext, Irp, OutputBuffer); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL; return STATUS_BUFFER_TOO_SMALL; }
// Check if a starting cluster was specified. TotalClusters = Vcb->FSBM_BitCount; StartingLcn = ((PSTARTING_LCN_INPUT_BUFFER)IrpSp->Parameters.FileSystemControl.Type3InputBuffer)->StartingLcn;
if (StartingLcn.HighPart || StartingLcn.LowPart >= TotalClusters) {
UDFUnlockCallersBuffer(IrpContext, Irp, OutputBuffer); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} else {
StartingCluster = StartingLcn.LowPart & ~7; }
OutputBufferLength -= FIELD_OFFSET(VOLUME_BITMAP_BUFFER, Buffer); DesiredClusters = TotalClusters - StartingCluster;
if (OutputBufferLength < (DesiredClusters + 7) / 8) {
BytesToCopy = OutputBufferLength;// RC = STATUS_BUFFER_OVERFLOW;
} else {
BytesToCopy = (DesiredClusters + 7) / 8;// RC = STATUS_SUCCESS; }
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE );
_SEH2_TRY {
// Fill in the fixed part of the output buffer OutputBuffer->StartingLcn.QuadPart = StartingCluster; OutputBuffer->BitmapSize.QuadPart = DesiredClusters;
RtlZeroMemory( &OutputBuffer->Buffer[0], BytesToCopy ); lim = BytesToCopy * 8; FSBM = (PULONG)(Vcb->FSBM_Bitmap); LSh = Vcb->LB2B_Bits;// Dest = (PULONG)(&OutputBuffer->Buffer[0]);
for(i=StartingCluster & ~7; i<lim; i++) { if(UDFGetFreeBit(FSBM, i<<LSh)) UDFSetFreeBit(FSBM, i); }
} _SEH2_EXCEPT(UDFExceptionFilter(IrpContext, _SEH2_GetExceptionInformation())) {
BrutePoint(); UDFPrintErr(("UDFGetVolumeBitmap: Exception\n"));// UDFUnlockCallersBuffer(IrpContext, Irp, OutputBuffer); BrutePoint();// RC = UDFExceptionHandler(IrpContext, Irp); UDFReleaseResource(&(Vcb->VCBResource)); UDFUnlockCallersBuffer(IrpContext, Irp, OutputBuffer);
Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_USER_BUFFER; return STATUS_INVALID_USER_BUFFER; } _SEH2_END;
UDFReleaseResource(&(Vcb->VCBResource));
UDFUnlockCallersBuffer(IrpContext, Irp, OutputBuffer); Irp->IoStatus.Information = FIELD_OFFSET(VOLUME_BITMAP_BUFFER, Buffer) + BytesToCopy; Irp->IoStatus.Status = STATUS_SUCCESS;
return STATUS_SUCCESS;
} // end UDFGetVolumeBitmap()
NTSTATUSUDFGetRetrievalPointers( IN PtrUDFIrpContext IrpContext, IN PIRP Irp, IN ULONG Special ){ NTSTATUS RC;
PEXTENDED_IO_STACK_LOCATION IrpSp = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation( Irp );
PVCB Vcb; PtrUDFFCB Fcb; PtrUDFCCB Ccb; PUDF_FILE_INFO FileInfo;
ULONG InputBufferLength; ULONG OutputBufferLength;
PRETRIEVAL_POINTERS_BUFFER OutputBuffer; PSTARTING_VCN_INPUT_BUFFER InputBuffer;
LARGE_INTEGER StartingVcn; int64 AllocationSize;
PEXTENT_MAP SubMapping = NULL; ULONG SubExtInfoSz; ULONG i; ULONG LBS; ULONG LBSh; ULONG L2BSh;
UDFPrint(("UDFGetRetrievalPointers\n"));
// Decode the file object, the only type of opens we accept are // user volume opens. Ccb = (PtrUDFCCB)(IrpSp->FileObject->FsContext2); if(!Ccb) { UDFPrintErr((" !Ccb\n")); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; } Fcb = Ccb->Fcb; Vcb = Fcb->Vcb;
// Get the input and output buffer lengths and pointers. // Initialize some variables. InputBufferLength = IrpSp->Parameters.FileSystemControl.InputBufferLength; OutputBufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
//OutputBuffer = (PRETRIEVAL_POINTERS_BUFFER)UDFGetCallersBuffer( IrpContext, Irp ); if(Special) { OutputBuffer = (PRETRIEVAL_POINTERS_BUFFER)Irp->AssociatedIrp.SystemBuffer; } else { OutputBuffer = (PRETRIEVAL_POINTERS_BUFFER)Irp->UserBuffer; } InputBuffer = (PSTARTING_VCN_INPUT_BUFFER)IrpSp->Parameters.FileSystemControl.Type3InputBuffer; if(!InputBuffer) { InputBuffer = (PSTARTING_VCN_INPUT_BUFFER)OutputBuffer; }
_SEH2_TRY {
Irp->IoStatus.Information = 0; // Check for a minimum length on the input and ouput buffers. if ((InputBufferLength < sizeof(STARTING_VCN_INPUT_BUFFER)) || (OutputBufferLength < sizeof(RETRIEVAL_POINTERS_BUFFER))) {
try_return( RC = STATUS_BUFFER_TOO_SMALL ); }
_SEH2_TRY {
if (Irp->RequestorMode != KernelMode) { ProbeForRead( IrpSp->Parameters.FileSystemControl.Type3InputBuffer, InputBufferLength, sizeof(UCHAR) ); ProbeForWrite( OutputBuffer, OutputBufferLength, sizeof(UCHAR) ); } StartingVcn = InputBuffer->StartingVcn;
} _SEH2_EXCEPT(Irp->RequestorMode != KernelMode ? EXCEPTION_EXECUTE_HANDLER: EXCEPTION_CONTINUE_SEARCH) {
RC = _SEH2_GetExceptionCode(); RC = FsRtlIsNtstatusExpected(RC) ? RC : STATUS_INVALID_USER_BUFFER; try_return(RC); } _SEH2_END;
switch(Special) { case 0: FileInfo = Fcb->FileInfo; break; case 1: FileInfo = Vcb->NonAllocFileInfo; break; default: try_return( RC = STATUS_INVALID_PARAMETER ); }
if(!FileInfo) { try_return( RC = STATUS_OBJECT_NAME_NOT_FOUND ); }
AllocationSize = UDFGetFileAllocationSize(Vcb, FileInfo);
LBS = Vcb->LBlockSize; LBSh = Vcb->LBlockSizeBits; L2BSh = Vcb->LB2B_Bits;
if (StartingVcn.HighPart || StartingVcn.LowPart >= (ULONG)(AllocationSize >> LBSh)) {
try_return( RC = STATUS_END_OF_FILE ); }
SubExtInfoSz = (OutputBufferLength - FIELD_OFFSET(RETRIEVAL_POINTERS_BUFFER, Extents[0])) / (sizeof(LARGE_INTEGER)*2); // re-use AllocationSize as NextVcn RC = UDFReadFileLocation__(Vcb, FileInfo, StartingVcn.QuadPart << LBSh, &SubMapping, &SubExtInfoSz, &AllocationSize); if(!NT_SUCCESS(RC)) try_return(RC);
OutputBuffer->ExtentCount = SubExtInfoSz; OutputBuffer->StartingVcn = StartingVcn; for(i=0; i<SubExtInfoSz; i++) { // assume, that // for not-allocated extents we have start Lba = -1 // for not-recorded extents start Lba.LowPart contains real Lba, Lba.HighPart = 0x80000000 // for recorded extents Lba.LowPart contains real Lba, Lba.HighPart = 0 if(SubMapping[i].extLocation == LBA_NOT_ALLOCATED) { OutputBuffer->Extents[i].Lcn.QuadPart = (int64)(-1); } else if(SubMapping[i].extLocation & 0x80000000) { OutputBuffer->Extents[i].Lcn.LowPart = (SubMapping[i].extLocation & 0x7fffffff) >> L2BSh; OutputBuffer->Extents[i].Lcn.HighPart = 0x80000000; } else { OutputBuffer->Extents[i].Lcn.LowPart = SubMapping[i].extLocation >> L2BSh; OutputBuffer->Extents[i].Lcn.HighPart = 0; } // alignment for last sector SubMapping[i].extLength += LBS-1; StartingVcn.QuadPart += SubMapping[i].extLength >> LBSh; OutputBuffer->Extents[i].NextVcn = StartingVcn; }
Irp->IoStatus.Information = FIELD_OFFSET(RETRIEVAL_POINTERS_BUFFER, Extents[0]) + i * sizeof(LARGE_INTEGER) * 2;
try_exit: NOTHING; } _SEH2_FINALLY {
if(SubMapping) MyFreePool__(SubMapping); Irp->IoStatus.Status = RC; } _SEH2_END;
return RC;} // end UDFGetRetrievalPointers()
NTSTATUSUDFIsVolumeDirty( IN PtrUDFIrpContext IrpContext, IN PIRP Irp ){ PULONG VolumeState; PEXTENDED_IO_STACK_LOCATION IrpSp = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation( Irp );
PVCB Vcb; PtrUDFFCB Fcb; PtrUDFCCB Ccb;
UDFPrint(("UDFIsVolumeDirty\n"));
Irp->IoStatus.Information = 0;
if (Irp->AssociatedIrp.SystemBuffer != NULL) { VolumeState = (PULONG)(Irp->AssociatedIrp.SystemBuffer); } else if (Irp->MdlAddress != NULL) { VolumeState = (PULONG)MmGetSystemAddressForMdl(Irp->MdlAddress); } else { UDFPrintErr((" STATUS_INVALID_USER_BUFFER\n")); Irp->IoStatus.Status = STATUS_INVALID_USER_BUFFER; return STATUS_INVALID_USER_BUFFER; }
if (IrpSp->Parameters.FileSystemControl.OutputBufferLength < sizeof(ULONG)) { UDFPrintErr((" STATUS_BUFFER_TOO_SMALL\n")); Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL; return STATUS_BUFFER_TOO_SMALL; }
(*VolumeState) = 0;
// Decode the file object, the only type of opens we accept are // user volume opens. Ccb = (PtrUDFCCB)(IrpSp->FileObject->FsContext2); if(!Ccb) { UDFPrintErr((" !Ccb\n")); Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; } Fcb = Ccb->Fcb; Vcb = Fcb->Vcb;
if(Vcb != (PVCB)Fcb || !(Ccb->CCBFlags & UDF_CCB_VOLUME_OPEN)) { UDFPrintErr((" !Volume\n")); Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; }
if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED)) { UDFPrintErr((" !Mounted\n")); Irp->IoStatus.Status = STATUS_VOLUME_DISMOUNTED; return STATUS_VOLUME_DISMOUNTED; }
if(Vcb->origIntegrityType == INTEGRITY_TYPE_OPEN) { UDFPrint((" Dirty\n")); (*VolumeState) |= VOLUME_IS_DIRTY; Irp->IoStatus.Information = sizeof(ULONG); } else { UDFPrint((" Clean\n")); } Irp->IoStatus.Status = STATUS_SUCCESS;
return STATUS_SUCCESS;
} // end UDFIsVolumeDirty()
NTSTATUSUDFInvalidateVolumes( IN PtrUDFIrpContext IrpContext, IN PIRP Irp ){ NTSTATUS RC; PEXTENDED_IO_STACK_LOCATION IrpSp = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation( Irp ); PPREVENT_MEDIA_REMOVAL_USER_IN Buf = NULL;
UDFPrint(("UDFInvalidateVolumes\n"));
KIRQL SavedIrql;
LUID TcbPrivilege = {SE_TCB_PRIVILEGE, 0};
HANDLE Handle;
PVPB NewVpb; PVCB Vcb;
PLIST_ENTRY Link;
PFILE_OBJECT FileToMarkBad; PDEVICE_OBJECT DeviceToMarkBad;
Irp->IoStatus.Information = 0;
// Check for the correct security access. // The caller must have the SeTcbPrivilege. if (IrpSp->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL && IrpSp->MinorFunction == IRP_MN_USER_FS_REQUEST && IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_INVALIDATE_VOLUMES && !SeSinglePrivilegeCheck( TcbPrivilege, UserMode )) { UDFPrintErr(("UDFInvalidateVolumes: STATUS_PRIVILEGE_NOT_HELD\n")); Irp->IoStatus.Status = STATUS_PRIVILEGE_NOT_HELD; return STATUS_PRIVILEGE_NOT_HELD; } // Try to get a pointer to the device object from the handle passed in. if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof( HANDLE )) { UDFPrintErr(("UDFInvalidateVolumes: STATUS_INVALID_PARAMETER\n")); Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER; }
Handle = *((PHANDLE) Irp->AssociatedIrp.SystemBuffer);
RC = ObReferenceObjectByHandle( Handle, 0, *IoFileObjectType, KernelMode, (PVOID*)&FileToMarkBad, NULL );
if (!NT_SUCCESS(RC)) { UDFPrintErr(("UDFInvalidateVolumes: can't get handle, RC=%x\n", RC)); Irp->IoStatus.Status = RC; return RC; }
// We only needed the pointer, not a reference. ObDereferenceObject( FileToMarkBad );
// Grab the DeviceObject from the FileObject. DeviceToMarkBad = FileToMarkBad->DeviceObject;
// Create a new Vpb for this device so that any new opens will mount // a new volume. NewVpb = (PVPB)DbgAllocatePoolWithTag( NonPagedPool, sizeof( VPB ), 'bpvU' ); if(!NewVpb) { UDFPrintErr(("UDFInvalidateVolumes: STATUS_INSUFFICIENT_RESOURCES\n")); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES; } RtlZeroMemory( NewVpb, sizeof( VPB ) );
NewVpb->Type = IO_TYPE_VPB; NewVpb->Size = sizeof( VPB ); NewVpb->RealDevice = DeviceToMarkBad; NewVpb->Flags = DeviceToMarkBad->Vpb->Flags & VPB_REMOVE_PENDING;
// Acquire GlobalDataResource UDFAcquireResourceExclusive(&(UDFGlobalData.GlobalDataResource), TRUE);
// Nothing can go wrong now. IoAcquireVpbSpinLock( &SavedIrql ); if (DeviceToMarkBad->Vpb->Flags & VPB_MOUNTED) { DeviceToMarkBad->Vpb = NewVpb; NewVpb = NULL; } ASSERT( DeviceToMarkBad->Vpb->DeviceObject == NULL ); IoReleaseVpbSpinLock( SavedIrql );
if (NewVpb) { DbgFreePool( NewVpb ); }
// Walk through all of the Vcb's attached to the global data. Link = UDFGlobalData.VCBQueue.Flink;
//ASSERT(FALSE);
while (Link != &(UDFGlobalData.VCBQueue)) { // Get 'next' Vcb Vcb = CONTAINING_RECORD( Link, VCB, NextVCB ); // Move to the next link now since the current Vcb may be deleted. Link = Link->Flink;
// Acquire Vcb resource UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
if (Vcb->Vpb->RealDevice == DeviceToMarkBad) {
if(!Buf) { Buf = (PPREVENT_MEDIA_REMOVAL_USER_IN)MyAllocatePool__(NonPagedPool, sizeof(PREVENT_MEDIA_REMOVAL_USER_IN)*2); if(!Buf) { UDFPrintErr(("UDFInvalidateVolumes: STATUS_INSUFFICIENT_RESOURCES (2)\n")); UDFReleaseResource(&(Vcb->VCBResource)); MyFreePool__(NewVpb); Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES; } }
#ifdef UDF_DELAYED_CLOSE UDFPrint((" UDFInvalidateVolumes: set UDF_VCB_FLAGS_NO_DELAYED_CLOSE\n")); Vcb->VCBFlags |= UDF_VCB_FLAGS_NO_DELAYED_CLOSE; UDFReleaseResource(&(Vcb->VCBResource));#endif //UDF_DELAYED_CLOSE
if(Vcb->RootDirFCB && Vcb->RootDirFCB->FileInfo) { UDFPrint((" UDFInvalidateVolumes: UDFCloseAllSystemDelayedInDir\n")); RC = UDFCloseAllSystemDelayedInDir(Vcb, Vcb->RootDirFCB->FileInfo); ASSERT(OS_SUCCESS(RC)); }#ifdef UDF_DELAYED_CLOSE UDFPrint((" UDFInvalidateVolumes: UDFCloseAllDelayed\n")); UDFCloseAllDelayed(Vcb); //ASSERT(OS_SUCCESS(RC));#endif //UDF_DELAYED_CLOSE
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
UDFDoDismountSequence(Vcb, Buf, FALSE); UDFReleaseResource(&(Vcb->VCBResource));
UDFStopEjectWaiter(Vcb); UDFPrint(("UDFInvalidateVolumes: Vcb %x dismounted\n", Vcb)); break; } else { UDFPrint(("UDFInvalidateVolumes: skip Vcb %x\n", Vcb)); UDFReleaseResource(&(Vcb->VCBResource)); }
} // Once we have processed all the mounted logical volumes, we can release // all acquired global resources and leave (in peace :-) UDFReleaseResource( &(UDFGlobalData.GlobalDataResource) );
Irp->IoStatus.Status = STATUS_SUCCESS;
if(Buf) { UDFPrint(("UDFInvalidateVolumes: free buffer\n")); MyFreePool__(Buf); }
// drop volume completly UDFPrint(("UDFInvalidateVolumes: drop volume completly\n")); UDFAcquireResourceExclusive(&(UDFGlobalData.GlobalDataResource), TRUE); UDFScanForDismountedVcb(IrpContext); UDFReleaseResource( &(UDFGlobalData.GlobalDataResource) );
UDFPrint(("UDFInvalidateVolumes: done\n")); return STATUS_SUCCESS;
} // end UDFInvalidateVolumes()