2208 lines
63 KiB
C
2208 lines
63 KiB
C
/*++
|
||
|
||
Copyright (c) 1996 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
ObjIdSup.c
|
||
|
||
Abstract:
|
||
|
||
This module implements the object id support routines for Ntfs
|
||
|
||
Author:
|
||
|
||
Keith Kaplan [KeithKa] 27-Jun-1996
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "NtfsProc.h"
|
||
|
||
//
|
||
// The local debug trace level
|
||
//
|
||
|
||
#define Dbg (DEBUG_TRACE_OBJIDSUP)
|
||
|
||
|
||
//
|
||
// Define a tag for general pool allocations from this module
|
||
//
|
||
|
||
#undef MODULE_POOL_TAG
|
||
#define MODULE_POOL_TAG ('OFtN')
|
||
|
||
//
|
||
// Local define for number of times to attempt to generate a unique object id.
|
||
//
|
||
|
||
#define NTFS_MAX_OBJID_RETRIES 16
|
||
|
||
NTSTATUS
|
||
NtfsSetObjectIdExtendedInfoInternal (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb,
|
||
IN PVCB Vcb,
|
||
IN PUCHAR ExtendedInfoBuffer
|
||
);
|
||
|
||
VOID
|
||
NtfsGetIdFromGenerator (
|
||
OUT PFILE_OBJECTID_BUFFER ObjectId
|
||
);
|
||
|
||
NTSTATUS
|
||
NtfsSetObjectIdInternal (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb,
|
||
IN PVCB Vcb,
|
||
IN PFILE_OBJECTID_BUFFER ObjectIdBuffer
|
||
);
|
||
|
||
NTSTATUS
|
||
NtfsDeleteObjectIdInternal (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb,
|
||
IN PVCB Vcb,
|
||
IN BOOLEAN DeleteFileAttribute
|
||
);
|
||
|
||
VOID
|
||
NtfsGetIdFromGenerator (
|
||
OUT PFILE_OBJECTID_BUFFER ObjectId
|
||
);
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text(PAGE, NtfsCreateOrGetObjectId)
|
||
#pragma alloc_text(PAGE, NtfsDeleteObjectId)
|
||
#pragma alloc_text(PAGE, NtfsDeleteObjectIdInternal)
|
||
#pragma alloc_text(PAGE, NtfsGetIdFromGenerator)
|
||
#pragma alloc_text(PAGE, NtfsGetObjectId)
|
||
#pragma alloc_text(PAGE, NtfsGetObjectIdExtendedInfo)
|
||
#pragma alloc_text(PAGE, NtfsGetObjectIdInternal)
|
||
#pragma alloc_text(PAGE, NtfsInitializeObjectIdIndex)
|
||
#pragma alloc_text(PAGE, NtfsSetObjectId)
|
||
#pragma alloc_text(PAGE, NtfsSetObjectIdExtendedInfo)
|
||
#pragma alloc_text(PAGE, NtfsSetObjectIdExtendedInfoInternal)
|
||
#pragma alloc_text(PAGE, NtfsSetObjectIdInternal)
|
||
#endif
|
||
|
||
|
||
VOID
|
||
NtfsInitializeObjectIdIndex (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb,
|
||
IN PVCB Vcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine opens the object id index for the volume. If the index does not
|
||
exist it is created and initialized. We also look up the volume's object id,
|
||
if any, in this routine.
|
||
|
||
Arguments:
|
||
|
||
Fcb - Pointer to Fcb for the object id file.
|
||
|
||
Vcb - Volume control block for volume being mounted.
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS Status;
|
||
UNICODE_STRING IndexName = CONSTANT_UNICODE_STRING( L"$O" );
|
||
FILE_OBJECTID_BUFFER ObjectId;
|
||
|
||
PAGED_CODE();
|
||
|
||
NtfsAcquireExclusiveFcb( IrpContext, Fcb, NULL, 0 );
|
||
|
||
try {
|
||
|
||
Status = NtOfsCreateIndex( IrpContext,
|
||
Fcb,
|
||
IndexName,
|
||
CREATE_OR_OPEN,
|
||
0,
|
||
COLLATION_NTOFS_ULONGS,
|
||
NtOfsCollateUlongs,
|
||
NULL,
|
||
&Vcb->ObjectIdTableScb );
|
||
|
||
if (NT_SUCCESS( Status )) {
|
||
|
||
//
|
||
// We were able to create the index, now let's see if the volume has an object id.
|
||
//
|
||
|
||
Status = NtfsGetObjectIdInternal( IrpContext,
|
||
Vcb->VolumeDasdScb->Fcb,
|
||
FALSE,
|
||
&ObjectId );
|
||
|
||
if (NT_SUCCESS( Status )) {
|
||
|
||
//
|
||
// The volume does indeed have an object id, so copy it into the Vcb
|
||
// and set the appropriate flag.
|
||
//
|
||
|
||
RtlCopyMemory( Vcb->VolumeObjectId,
|
||
&ObjectId.ObjectId,
|
||
OBJECT_ID_KEY_LENGTH );
|
||
|
||
SetFlag( Vcb->VcbState, VCB_STATE_VALID_OBJECT_ID );
|
||
}
|
||
}
|
||
|
||
} finally {
|
||
|
||
NtfsReleaseFcb( IrpContext, Fcb );
|
||
}
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
NtfsSetObjectId (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine associates an object id with a file. If the object id is already
|
||
in use on the volume we return STATUS_DUPLICATE_NAME. If the file already has
|
||
an object id, we return STATUS_OBJECT_NAME_COLLISION.
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp to process.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status = STATUS_OBJECT_NAME_INVALID;
|
||
PIO_STACK_LOCATION IrpSp;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PSCB Scb;
|
||
PCCB Ccb;
|
||
|
||
//
|
||
// Get the current Irp stack location and save some references.
|
||
//
|
||
|
||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||
|
||
TypeOfOpen = NtfsDecodeFileObject( IrpContext, IrpSp->FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
|
||
|
||
if (!(((TypeOfOpen == UserFileOpen) || (TypeOfOpen == UserDirectoryOpen)) &&
|
||
(IrpSp->Parameters.FileSystemControl.InputBufferLength == sizeof( FILE_OBJECTID_BUFFER )))) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Read only volumes stay read only.
|
||
//
|
||
|
||
if (NtfsIsVolumeReadOnly( Vcb )) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_MEDIA_WRITE_PROTECTED );
|
||
return STATUS_MEDIA_WRITE_PROTECTED;
|
||
}
|
||
|
||
//
|
||
// Cleanly exit for volumes without oid indices, such as non-upgraded
|
||
// version 1.x volumes.
|
||
//
|
||
|
||
if (Vcb->ObjectIdTableScb == NULL) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_VOLUME_NOT_UPGRADED );
|
||
return STATUS_VOLUME_NOT_UPGRADED;
|
||
}
|
||
|
||
//
|
||
// Capture the source information.
|
||
//
|
||
|
||
IrpContext->SourceInfo = Ccb->UsnSourceInfo;
|
||
|
||
try {
|
||
|
||
//
|
||
// Only a restore operator or the I/O system (using its private irp minor code)
|
||
// is allowed to set an arbitrary object id.
|
||
//
|
||
|
||
if ((FlagOn( Ccb->AccessFlags, RESTORE_ACCESS )) ||
|
||
(IrpSp->MinorFunction == IRP_MN_KERNEL_CALL)) {
|
||
|
||
Status = NtfsSetObjectIdInternal( IrpContext,
|
||
Fcb,
|
||
Vcb,
|
||
(PFILE_OBJECTID_BUFFER) Irp->AssociatedIrp.SystemBuffer );
|
||
|
||
//
|
||
// Remember to update the timestamps.
|
||
//
|
||
|
||
if (NT_SUCCESS( Status )) {
|
||
SetFlag( Ccb->Flags, CCB_FLAG_UPDATE_LAST_CHANGE );
|
||
}
|
||
|
||
} else {
|
||
|
||
Status = STATUS_ACCESS_DENIED;
|
||
}
|
||
|
||
} finally {
|
||
|
||
if (!AbnormalTermination()) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, Status );
|
||
}
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
NtfsSetObjectIdExtendedInfo (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine sets the extended info for a file which already has an object
|
||
id. If the file does not yet have an object id, we return a status other
|
||
than STATUS_SUCCESS.
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp to process.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status = STATUS_OBJECT_NAME_INVALID;
|
||
PIO_STACK_LOCATION IrpSp;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PSCB Scb;
|
||
PCCB Ccb;
|
||
|
||
//
|
||
// Get the current Irp stack location and save some references.
|
||
//
|
||
|
||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||
|
||
TypeOfOpen = NtfsDecodeFileObject( IrpContext, IrpSp->FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
|
||
if (!(((TypeOfOpen == UserFileOpen) || (TypeOfOpen == UserDirectoryOpen)) &&
|
||
(IrpSp->Parameters.FileSystemControl.InputBufferLength == OBJECT_ID_EXT_INFO_LENGTH))) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Read only volumes stay read only.
|
||
//
|
||
|
||
if (NtfsIsVolumeReadOnly( Vcb )) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_MEDIA_WRITE_PROTECTED );
|
||
return STATUS_MEDIA_WRITE_PROTECTED;
|
||
}
|
||
|
||
//
|
||
// Cleanly exit for volumes without oid indices, such as non-upgraded
|
||
// version 1.x volumes.
|
||
//
|
||
|
||
if (Vcb->ObjectIdTableScb == NULL) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_VOLUME_NOT_UPGRADED );
|
||
return STATUS_VOLUME_NOT_UPGRADED;
|
||
}
|
||
|
||
//
|
||
// Capture the source information.
|
||
//
|
||
|
||
IrpContext->SourceInfo = Ccb->UsnSourceInfo;
|
||
|
||
try {
|
||
|
||
//
|
||
// Setting extended info requires either write access or else it has
|
||
// to be the I/O system using its private irp minor code.
|
||
//
|
||
|
||
if ((FlagOn( Ccb->AccessFlags, WRITE_DATA_ACCESS | WRITE_ATTRIBUTES_ACCESS )) ||
|
||
(IrpSp->MinorFunction == IRP_MN_KERNEL_CALL)) {
|
||
|
||
Status = NtfsSetObjectIdExtendedInfoInternal( IrpContext,
|
||
Fcb,
|
||
Vcb,
|
||
(PUCHAR) Irp->AssociatedIrp.SystemBuffer );
|
||
|
||
//
|
||
// Remember to update the timestamps.
|
||
//
|
||
|
||
if (NT_SUCCESS( Status )) {
|
||
SetFlag( Ccb->Flags, CCB_FLAG_UPDATE_LAST_CHANGE );
|
||
}
|
||
|
||
} else {
|
||
|
||
Status = STATUS_ACCESS_DENIED;
|
||
}
|
||
|
||
} finally {
|
||
|
||
if (!AbnormalTermination()) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, Status );
|
||
}
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
NtfsSetObjectIdInternal (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb,
|
||
IN PVCB Vcb,
|
||
IN PFILE_OBJECTID_BUFFER ObjectIdBuffer
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine associates an object id with a file. If the object id is already
|
||
in use on the volume we return STATUS_DUPLICATE_NAME. If the file already has
|
||
an object id, we return STATUS_OBJECT_NAME_COLLISION.
|
||
|
||
Arguments:
|
||
|
||
Fcb - The file to associate with the object id.
|
||
|
||
Vcb - The volume whose object id index the entry should be added to.
|
||
|
||
ObjectIdBuffer - Supplies both the object id and the extended info.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status = STATUS_OBJECT_NAME_INVALID;
|
||
|
||
NTFS_OBJECTID_INFORMATION ObjectIdInfo;
|
||
FILE_OBJECTID_INFORMATION FileObjectIdInfo;
|
||
|
||
INDEX_KEY IndexKey;
|
||
INDEX_ROW IndexRow;
|
||
|
||
ATTRIBUTE_ENUMERATION_CONTEXT AttributeContext;
|
||
BOOLEAN InitializedAttributeContext = FALSE;
|
||
BOOLEAN AcquiredPaging = FALSE;
|
||
|
||
try {
|
||
|
||
RtlZeroMemory( &ObjectIdInfo,
|
||
sizeof( NTFS_OBJECTID_INFORMATION ) );
|
||
|
||
RtlCopyMemory( &ObjectIdInfo.FileSystemReference,
|
||
&Fcb->FileReference,
|
||
sizeof( FILE_REFERENCE ) );
|
||
|
||
RtlCopyMemory( ObjectIdInfo.ExtendedInfo,
|
||
ObjectIdBuffer->ExtendedInfo,
|
||
OBJECT_ID_EXT_INFO_LENGTH );
|
||
|
||
} except(EXCEPTION_EXECUTE_HANDLER) {
|
||
|
||
return STATUS_INVALID_ADDRESS;
|
||
}
|
||
|
||
//
|
||
// Acquire the file we're setting the object id on. Main blocks
|
||
// anybody else from deleting the file or setting another object
|
||
// id behind our backs. Paging blocks collided flushes if we have to convert
|
||
// another (data) attribute to be non-resident.
|
||
//
|
||
// Don't use AcquireFcbWithPaging because
|
||
// it can't recursively acquire paging and we come in often with it
|
||
// preacquired
|
||
//
|
||
|
||
if (Fcb->PagingIoResource != NULL) {
|
||
ExAcquireResourceExclusiveLite( Fcb->PagingIoResource, TRUE );
|
||
AcquiredPaging = TRUE;
|
||
}
|
||
NtfsAcquireExclusiveFcb( IrpContext, Fcb, NULL, 0 );
|
||
|
||
try {
|
||
|
||
//
|
||
// if there is now a paging resource release main and grab both
|
||
// This is the case for a named data stream in a directory created between our
|
||
// unsafe test and owning the main
|
||
// Note: if we already owned main before entrance this could never happen. So we can just drop
|
||
// and not worry about still owning main and taking paging
|
||
//
|
||
|
||
if (!AcquiredPaging && (Fcb->PagingIoResource != NULL)) {
|
||
NtfsReleaseFcb( IrpContext, Fcb );
|
||
ExAcquireResourceExclusiveLite( Fcb->PagingIoResource, TRUE );
|
||
AcquiredPaging = TRUE;
|
||
NtfsAcquireExclusiveFcb( IrpContext, Fcb, NULL, 0 );
|
||
}
|
||
|
||
if (!IsListEmpty( &Fcb->ScbQueue )) {
|
||
PSCB Scb;
|
||
|
||
Scb = CONTAINING_RECORD( Fcb->ScbQueue.Flink, SCB, FcbLinks );
|
||
ASSERT( Scb->Header.Resource == Fcb->Resource );
|
||
if (FlagOn( Scb->ScbState, SCB_STATE_VOLUME_DISMOUNTED )) {
|
||
try_return( Status = STATUS_VOLUME_DISMOUNTED );
|
||
}
|
||
}
|
||
|
||
//
|
||
// Post the change to the Usn Journal (on errors change is backed out).
|
||
// We dont' want to do this if we've been called because create is
|
||
// trying to set an object id from the tunnel cache, since we can't
|
||
// call the Usn package yet, since the file record doesn't have a file
|
||
// name yet.
|
||
//
|
||
|
||
if (IrpContext->MajorFunction != IRP_MJ_CREATE) {
|
||
|
||
NtfsPostUsnChange( IrpContext, Fcb, USN_REASON_OBJECT_ID_CHANGE );
|
||
}
|
||
|
||
//
|
||
// Make sure the file doesn't already have an object id.
|
||
//
|
||
|
||
NtfsInitializeAttributeContext( &AttributeContext );
|
||
InitializedAttributeContext = TRUE;
|
||
|
||
if (NtfsLookupAttributeByCode( IrpContext,
|
||
Fcb,
|
||
&Fcb->FileReference,
|
||
$OBJECT_ID,
|
||
&AttributeContext )) {
|
||
|
||
try_return( Status = STATUS_OBJECT_NAME_COLLISION );
|
||
}
|
||
|
||
//
|
||
// Add ObjectId to the index, associate it with this file.
|
||
//
|
||
|
||
IndexKey.Key = ObjectIdBuffer->ObjectId;
|
||
IndexKey.KeyLength = OBJECT_ID_KEY_LENGTH;
|
||
IndexRow.KeyPart = IndexKey;
|
||
|
||
IndexRow.DataPart.DataLength = sizeof( ObjectIdInfo );
|
||
IndexRow.DataPart.Data = &ObjectIdInfo;
|
||
|
||
//
|
||
// NtOfsAddRecords may raise if the object id isn't unique.
|
||
//
|
||
|
||
NtOfsAddRecords( IrpContext,
|
||
Vcb->ObjectIdTableScb,
|
||
1, // adding one record to the index
|
||
&IndexRow,
|
||
FALSE ); // sequential insert
|
||
|
||
//
|
||
// Now add the objectid attribute to the file. Notice that
|
||
// we do _not_ log this operation if we're within a create
|
||
// operation, i.e. if we're restoring an object id from the
|
||
// tunnel cache. The create path has its own logging scheme
|
||
// that we don't want to interfere with.
|
||
//
|
||
|
||
NtfsCleanupAttributeContext( IrpContext, &AttributeContext );
|
||
|
||
NtfsCreateAttributeWithValue( IrpContext,
|
||
Fcb,
|
||
$OBJECT_ID,
|
||
NULL,
|
||
ObjectIdBuffer->ObjectId,
|
||
OBJECT_ID_KEY_LENGTH,
|
||
0,
|
||
NULL,
|
||
(BOOLEAN)(IrpContext->MajorFunction != IRP_MJ_CREATE),
|
||
&AttributeContext );
|
||
|
||
|
||
ASSERT( IrpContext->TransactionId != 0 );
|
||
|
||
//
|
||
// Notify anybody who's interested.
|
||
//
|
||
|
||
if (Vcb->ViewIndexNotifyCount != 0) {
|
||
|
||
//
|
||
// The FRS field is only populated for the notification of a failed
|
||
// object id restore from the tunnel cache.
|
||
//
|
||
|
||
FileObjectIdInfo.FileReference = 0L;
|
||
|
||
RtlCopyMemory( FileObjectIdInfo.ObjectId,
|
||
ObjectIdBuffer->ObjectId,
|
||
OBJECT_ID_KEY_LENGTH );
|
||
|
||
RtlCopyMemory( FileObjectIdInfo.ExtendedInfo,
|
||
ObjectIdBuffer->ExtendedInfo,
|
||
OBJECT_ID_EXT_INFO_LENGTH );
|
||
|
||
NtfsReportViewIndexNotify( Vcb,
|
||
Vcb->ObjectIdTableScb->Fcb,
|
||
FILE_NOTIFY_CHANGE_FILE_NAME,
|
||
FILE_ACTION_ADDED,
|
||
&FileObjectIdInfo,
|
||
sizeof(FILE_OBJECTID_INFORMATION) );
|
||
}
|
||
|
||
//
|
||
// If we made it this far and didn't have to jump into the
|
||
// finally clause yet, all must have gone well.
|
||
//
|
||
|
||
Status = STATUS_SUCCESS;
|
||
|
||
try_exit: NOTHING;
|
||
|
||
NtfsCleanupTransaction( IrpContext, Status, FALSE );
|
||
|
||
} finally {
|
||
|
||
if (AcquiredPaging) {
|
||
ExReleaseResourceLite( Fcb->PagingIoResource );
|
||
}
|
||
NtfsReleaseFcb( IrpContext, Fcb );
|
||
|
||
if (InitializedAttributeContext) {
|
||
|
||
NtfsCleanupAttributeContext( IrpContext, &AttributeContext );
|
||
}
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
NtfsCreateOrGetObjectId (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine generates a new object id, if possible, for a given file. It is
|
||
different from NtfsSetObjectId in that it does not take an object id as an
|
||
input, rather it calls a routine to generate one. If the file already has
|
||
an object id, that existing object id is returned.
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp to process.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
STATUS_DUPLICATE_NAME if we are unable to generate a unique id
|
||
in NTFS_MAX_OBJID_RETRIES retries.
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status;
|
||
PIO_STACK_LOCATION IrpSp;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PSCB Scb;
|
||
PCCB Ccb;
|
||
|
||
FILE_OBJECTID_BUFFER ObjectId;
|
||
FILE_OBJECTID_BUFFER *OutputBuffer;
|
||
|
||
ULONG RetryCount = 0;
|
||
|
||
//
|
||
// Get the current Irp stack location and save some references.
|
||
//
|
||
|
||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||
TypeOfOpen = NtfsDecodeFileObject( IrpContext, IrpSp->FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
|
||
|
||
//
|
||
// This only works for files and directories.
|
||
//
|
||
|
||
if ((TypeOfOpen != UserFileOpen) && (TypeOfOpen != UserDirectoryOpen)) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Cleanly exit for volumes without oid indices, such as non-upgraded
|
||
// version 1.x volumes.
|
||
//
|
||
|
||
if (Vcb->ObjectIdTableScb == NULL) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_VOLUME_NOT_UPGRADED );
|
||
return STATUS_VOLUME_NOT_UPGRADED;
|
||
}
|
||
|
||
//
|
||
// Get a pointer to the output buffer. Look at the system buffer field in the
|
||
// irp first, then the Irp Mdl.
|
||
//
|
||
|
||
if (Irp->AssociatedIrp.SystemBuffer != NULL) {
|
||
|
||
OutputBuffer = (FILE_OBJECTID_BUFFER *)Irp->AssociatedIrp.SystemBuffer;
|
||
|
||
} else if (Irp->MdlAddress != NULL) {
|
||
|
||
OutputBuffer = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority );
|
||
|
||
if (OutputBuffer == NULL) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INSUFFICIENT_RESOURCES );
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
} else {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_USER_BUFFER );
|
||
return STATUS_INVALID_USER_BUFFER;
|
||
}
|
||
|
||
//
|
||
// Make sure the output buffer is large enough.
|
||
//
|
||
|
||
if (IrpSp->Parameters.FileSystemControl.OutputBufferLength < sizeof(ObjectId)) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Capture the source information.
|
||
//
|
||
|
||
IrpContext->SourceInfo = Ccb->UsnSourceInfo;
|
||
|
||
try {
|
||
|
||
//
|
||
// Get this file exlusively so we know nobody else is trying
|
||
// to do this at the same time. At this point the irpcontext flag
|
||
// is not set so paging is not acquired.
|
||
//
|
||
|
||
NtfsAcquireFcbWithPaging( IrpContext, Fcb, 0 );
|
||
|
||
//
|
||
// Let's make sure the volume is still mounted.
|
||
//
|
||
|
||
if (FlagOn( Scb->ScbState, SCB_STATE_VOLUME_DISMOUNTED )) {
|
||
|
||
try_return( Status = STATUS_VOLUME_DISMOUNTED );
|
||
}
|
||
|
||
DebugTrace( +1, Dbg, ("NtfsCreateOrGetObjectId\n") );
|
||
|
||
//
|
||
// If this file already has an object id, let's return it. Doing this
|
||
// first saves a (possibly expensive) call to NtfsGetIdFromGenerator.
|
||
//
|
||
|
||
Status = NtfsGetObjectIdInternal( IrpContext, Fcb, TRUE, OutputBuffer );
|
||
|
||
if (Status == STATUS_OBJECTID_NOT_FOUND) {
|
||
|
||
DebugTrace( 0, Dbg, ("File has no oid, we have to generate one\n") );
|
||
|
||
//
|
||
// We want to keep retrying if the object id generator returns a
|
||
// duplicate name. If we have success, or any other error, we
|
||
// should stop trying. For instance, if we fail because the file
|
||
// already has an object id, retrying is just a waste of time.
|
||
// We also need some sane limit on the number of times we retry
|
||
// this operation.
|
||
//
|
||
|
||
do {
|
||
|
||
RetryCount += 1;
|
||
|
||
//
|
||
// Drop this file so we don't deadlock in the guid generator.
|
||
//
|
||
|
||
ASSERT( 0 == IrpContext->TransactionId );
|
||
NtfsReleaseFcbWithPaging( IrpContext, Fcb );
|
||
|
||
DebugTrace( 0, Dbg, ("Calling oid generator\n") );
|
||
NtfsGetIdFromGenerator( &ObjectId );
|
||
|
||
//
|
||
// Reacquire the file so we know nobody else is trying to do
|
||
// this at the same time. SetObjIdInternal acquires both so we need to
|
||
// do the same
|
||
//
|
||
|
||
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ACQUIRE_PAGING );
|
||
NtfsAcquireFcbWithPaging( IrpContext, Fcb, 0 );
|
||
|
||
//
|
||
// Make sure we didn't miss a dismount.
|
||
//
|
||
|
||
if (FlagOn( Scb->ScbState, SCB_STATE_VOLUME_DISMOUNTED )) {
|
||
|
||
try_return( Status = STATUS_VOLUME_DISMOUNTED );
|
||
}
|
||
|
||
//
|
||
// Let's make sure this file didn't get an object id assigned to it
|
||
// while we weren't holding the Fcb above.
|
||
//
|
||
|
||
Status = NtfsGetObjectIdInternal( IrpContext, Fcb, TRUE, OutputBuffer );
|
||
|
||
if (Status == STATUS_OBJECTID_NOT_FOUND) {
|
||
|
||
if (NtfsIsVolumeReadOnly( Vcb )) {
|
||
|
||
try_return( Status = STATUS_MEDIA_WRITE_PROTECTED );
|
||
}
|
||
|
||
DebugTrace( 0, Dbg, ("File still has no oid, attempting to set generated one\n") );
|
||
|
||
//
|
||
// The object id generator only generates the indexed part, so
|
||
// we need to fill in the rest of the 'birth id' now. Note that if
|
||
// the volume has no object id, we're relying on the Vcb creation
|
||
// code to zero init the Vcb->VolumeObjectId for us. The net result
|
||
// is right -- we get zeroes in the volume id part of the extended
|
||
// info if the volume has no object id.
|
||
//
|
||
|
||
RtlCopyMemory( &ObjectId.BirthVolumeId,
|
||
Vcb->VolumeObjectId,
|
||
OBJECT_ID_KEY_LENGTH );
|
||
|
||
RtlCopyMemory( &ObjectId.BirthObjectId,
|
||
&ObjectId.ObjectId,
|
||
OBJECT_ID_KEY_LENGTH );
|
||
|
||
RtlZeroMemory( &ObjectId.DomainId,
|
||
OBJECT_ID_KEY_LENGTH );
|
||
|
||
Status = NtfsSetObjectIdInternal( IrpContext,
|
||
Fcb,
|
||
Vcb,
|
||
&ObjectId );
|
||
|
||
if (Status == STATUS_SUCCESS) {
|
||
|
||
DebugTrace( 0, Dbg, ("Successfully set generated oid\n") );
|
||
|
||
//
|
||
// We have successfully generated and set an object id for this
|
||
// file, so we need to tell our caller what that id is.
|
||
//
|
||
|
||
RtlCopyMemory( OutputBuffer,
|
||
&ObjectId,
|
||
sizeof(ObjectId) );
|
||
|
||
//
|
||
// Let's also remember to update the timestamps.
|
||
//
|
||
|
||
SetFlag( Ccb->Flags, CCB_FLAG_UPDATE_LAST_CHANGE );
|
||
}
|
||
}
|
||
|
||
} while ((Status == STATUS_DUPLICATE_NAME) &&
|
||
(RetryCount <= NTFS_MAX_OBJID_RETRIES));
|
||
|
||
} else if (Status == STATUS_SUCCESS) {
|
||
|
||
//
|
||
// If we found an ID, make sure it isn't a partially formed id with
|
||
// an all zero extended info. If it's partially formed, we'll generate
|
||
// extended info now.
|
||
//
|
||
|
||
if (RtlCompareMemory( (PUCHAR)&OutputBuffer->ExtendedInfo, &NtfsZeroExtendedInfo, sizeof(ObjectId.ExtendedInfo)) == sizeof(ObjectId.ExtendedInfo)) {
|
||
|
||
RtlCopyMemory( &OutputBuffer->BirthVolumeId,
|
||
Vcb->VolumeObjectId,
|
||
OBJECT_ID_KEY_LENGTH );
|
||
|
||
RtlCopyMemory( &OutputBuffer->BirthObjectId,
|
||
&OutputBuffer->ObjectId,
|
||
OBJECT_ID_KEY_LENGTH );
|
||
|
||
Status = NtfsSetObjectIdExtendedInfoInternal( IrpContext,
|
||
Fcb,
|
||
Vcb,
|
||
(PUCHAR) &OutputBuffer->ExtendedInfo );
|
||
}
|
||
}
|
||
|
||
if (Status == STATUS_SUCCESS) {
|
||
|
||
//
|
||
// If we found an existing id for the file, or managed to generate one
|
||
// ourselves, we need to set the size in the information field so the
|
||
// rdr can handle this operation correctly.
|
||
//
|
||
|
||
IrpContext->OriginatingIrp->IoStatus.Information = sizeof( ObjectId );
|
||
}
|
||
|
||
try_exit: NOTHING;
|
||
} finally {
|
||
}
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, Status );
|
||
|
||
DebugTrace( -1, Dbg, ("NtfsCreateOrGetObjectId -> %08lx\n", Status) );
|
||
return Status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
NtfsGetObjectId (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine finds the object id, if any, for a given file.
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp to process.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
PIO_STACK_LOCATION IrpSp;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PSCB Scb;
|
||
PCCB Ccb;
|
||
|
||
FILE_OBJECTID_BUFFER *OutputBuffer;
|
||
|
||
//
|
||
// Get the current Irp stack location and save some references.
|
||
//
|
||
|
||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||
|
||
TypeOfOpen = NtfsDecodeFileObject( IrpContext, IrpSp->FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
|
||
|
||
//
|
||
// This only works for files and directories.
|
||
//
|
||
|
||
if ((TypeOfOpen != UserFileOpen) && (TypeOfOpen != UserDirectoryOpen)) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Cleanly exit for volumes without oid indices, such as non-upgraded
|
||
// version 1.x volumes.
|
||
//
|
||
|
||
if (Vcb->ObjectIdTableScb == NULL) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_VOLUME_NOT_UPGRADED );
|
||
return STATUS_VOLUME_NOT_UPGRADED;
|
||
}
|
||
|
||
//
|
||
// Get a pointer to the output buffer. Look at the system buffer field in the
|
||
// irp first, then the Irp Mdl.
|
||
//
|
||
|
||
if (Irp->AssociatedIrp.SystemBuffer != NULL) {
|
||
|
||
OutputBuffer = (FILE_OBJECTID_BUFFER *)Irp->AssociatedIrp.SystemBuffer;
|
||
|
||
} else if (Irp->MdlAddress != NULL) {
|
||
|
||
OutputBuffer = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority );
|
||
|
||
if (OutputBuffer == NULL) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INSUFFICIENT_RESOURCES );
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
} else {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_USER_BUFFER );
|
||
return STATUS_INVALID_USER_BUFFER;
|
||
}
|
||
|
||
//
|
||
// Make sure the output buffer is large enough.
|
||
//
|
||
|
||
if (IrpSp->Parameters.FileSystemControl.OutputBufferLength < sizeof(FILE_OBJECTID_BUFFER)) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
try {
|
||
|
||
//
|
||
// Call the function that does the real work.
|
||
//
|
||
|
||
Status = NtfsGetObjectIdInternal( IrpContext, Fcb, TRUE, OutputBuffer );
|
||
|
||
if (NT_SUCCESS( Status )) {
|
||
|
||
//
|
||
// And set the size in the information field so the rdr
|
||
// can handle this correctly.
|
||
//
|
||
|
||
IrpContext->OriginatingIrp->IoStatus.Information = sizeof( FILE_OBJECTID_BUFFER );
|
||
}
|
||
|
||
} finally {
|
||
|
||
if (!AbnormalTermination()) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, Status );
|
||
}
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
NtfsGetObjectIdInternal (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb,
|
||
IN BOOLEAN GetExtendedInfo,
|
||
OUT FILE_OBJECTID_BUFFER *OutputBuffer
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Internal function to find the object id, if any, for a given file. Called
|
||
in response to the user's ioctl and by NtfsDeleteObjectIdInternal.
|
||
|
||
Arguments:
|
||
|
||
Fcb - The file whose object id we need to look up.
|
||
|
||
GetExtendedInfo - If TRUE, we also copy the object id's extended information
|
||
to the OutputBuffer, otherwise we only copy the object id
|
||
itself. For instance, NtfsDeleteObjectIdInternal is not
|
||
interested in the extended info -- it only needs to know
|
||
which object id to delete from the index.
|
||
|
||
OutputBuffer - Where to store the object id (and optionally, extended info)
|
||
if an object id is found.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
STATUS_OBJECT_NAME_NOT_FOUND if the file does not have an object id.
|
||
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
UCHAR *ObjectId;
|
||
|
||
ATTRIBUTE_ENUMERATION_CONTEXT AttributeContext;
|
||
BOOLEAN InitializedAttributeContext = FALSE;
|
||
|
||
if ((OutputBuffer == NULL) ||
|
||
(OutputBuffer->ObjectId == NULL)) {
|
||
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Acquire the file we're getting the object id for. We don't
|
||
// want anybody else deleting the file or setting an object
|
||
// id behind our backs.
|
||
//
|
||
|
||
NtfsAcquireSharedFcb( IrpContext, Fcb, NULL, 0 );
|
||
|
||
|
||
try {
|
||
|
||
if (!IsListEmpty( &Fcb->ScbQueue )) {
|
||
PSCB Scb;
|
||
|
||
Scb = CONTAINING_RECORD( Fcb->ScbQueue.Flink, SCB, FcbLinks );
|
||
ASSERT( Scb->Header.Resource == Fcb->Resource );
|
||
if (FlagOn( Scb->ScbState, SCB_STATE_VOLUME_DISMOUNTED )) {
|
||
Status = STATUS_VOLUME_DISMOUNTED;
|
||
leave;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Make sure the file has an object id.
|
||
//
|
||
|
||
NtfsInitializeAttributeContext( &AttributeContext );
|
||
InitializedAttributeContext = TRUE;
|
||
|
||
if (NtfsLookupAttributeByCode( IrpContext,
|
||
Fcb,
|
||
&Fcb->FileReference,
|
||
$OBJECT_ID,
|
||
&AttributeContext )) {
|
||
//
|
||
// Prepare the object id to be returned
|
||
//
|
||
|
||
ObjectId = (UCHAR *) NtfsAttributeValue( NtfsFoundAttribute( &AttributeContext ));
|
||
|
||
RtlCopyMemory( &OutputBuffer->ObjectId,
|
||
ObjectId,
|
||
OBJECT_ID_KEY_LENGTH );
|
||
|
||
if (GetExtendedInfo) {
|
||
|
||
Status = NtfsGetObjectIdExtendedInfo( IrpContext,
|
||
Fcb->Vcb,
|
||
ObjectId,
|
||
OutputBuffer->ExtendedInfo );
|
||
}
|
||
|
||
} else {
|
||
|
||
//
|
||
// This file has no object id.
|
||
//
|
||
|
||
Status = STATUS_OBJECTID_NOT_FOUND;
|
||
}
|
||
|
||
} finally {
|
||
|
||
NtfsReleaseFcb( IrpContext, Fcb );
|
||
|
||
if (InitializedAttributeContext) {
|
||
|
||
NtfsCleanupAttributeContext( IrpContext, &AttributeContext );
|
||
}
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
NtfsGetObjectIdExtendedInfo (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PVCB Vcb,
|
||
IN UCHAR *ObjectId,
|
||
IN OUT UCHAR *ExtendedInfo
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine finds the extended info stored with a given object id.
|
||
|
||
Arguments:
|
||
|
||
Vcb - Supplies the volume whose object id index should be searched.
|
||
|
||
ObjectId - Supplies the object id to lookup in the index.
|
||
|
||
ExtendedInfo - Where to store the extended info. Must be a buffer with
|
||
room for OBJECT_ID_EXT_INFO_LENGTH UCHARs.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
INDEX_KEY IndexKey;
|
||
INDEX_ROW IndexRow;
|
||
MAP_HANDLE MapHandle;
|
||
|
||
BOOLEAN InitializedMapHandle = FALSE;
|
||
BOOLEAN IndexAcquired = FALSE;
|
||
|
||
try {
|
||
|
||
//
|
||
// Now look for object id in the index so we can return the
|
||
// extended info.
|
||
//
|
||
|
||
IndexKey.Key = ObjectId;
|
||
IndexKey.KeyLength = OBJECT_ID_KEY_LENGTH;
|
||
|
||
NtOfsInitializeMapHandle( &MapHandle );
|
||
InitializedMapHandle = TRUE;
|
||
|
||
//
|
||
// Acquire the object id index before doing the lookup.
|
||
// We need to make sure the file is acquired first to prevent
|
||
// a possible deadlock.
|
||
//
|
||
|
||
// **** ASSERT_EXCLUSIVE_FCB( Fcb ); ****
|
||
|
||
//
|
||
// We shouldn't try to get the object id index while holding the Mft.
|
||
//
|
||
|
||
ASSERT( !NtfsIsExclusiveScb( Vcb->MftScb ) ||
|
||
NtfsIsSharedScb( Vcb->ObjectIdTableScb ) );
|
||
|
||
NtfsAcquireSharedScb( IrpContext, Vcb->ObjectIdTableScb );
|
||
IndexAcquired = TRUE;
|
||
|
||
if ( NtOfsFindRecord( IrpContext,
|
||
Vcb->ObjectIdTableScb,
|
||
&IndexKey,
|
||
&IndexRow,
|
||
&MapHandle,
|
||
NULL) != STATUS_SUCCESS ) {
|
||
|
||
//
|
||
// If the object id attribute exists for the file,
|
||
// but it isn't in the index, the object id index
|
||
// for this volume is corrupt.
|
||
//
|
||
|
||
SetFlag( Vcb->ObjectIdState, VCB_OBJECT_ID_CORRUPT );
|
||
|
||
try_return( Status = STATUS_OBJECT_NAME_NOT_FOUND );
|
||
}
|
||
|
||
RtlCopyMemory( ExtendedInfo,
|
||
((NTFS_OBJECTID_INFORMATION *)IndexRow.DataPart.Data)->ExtendedInfo,
|
||
OBJECT_ID_EXT_INFO_LENGTH );
|
||
|
||
try_exit: NOTHING;
|
||
} finally {
|
||
|
||
if (IndexAcquired) {
|
||
|
||
NtfsReleaseScb( IrpContext, Vcb->ObjectIdTableScb );
|
||
}
|
||
|
||
if (InitializedMapHandle) {
|
||
|
||
NtOfsReleaseMap( IrpContext, &MapHandle );
|
||
}
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
|
||
NTSTATUS
|
||
NtfsDeleteObjectId (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine deletes the object id attribute from a file
|
||
and removes that object id from the index.
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp to process
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
PIO_STACK_LOCATION IrpSp;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PSCB Scb;
|
||
PCCB Ccb;
|
||
|
||
//
|
||
// Get the current Irp stack location and save some references.
|
||
//
|
||
|
||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||
|
||
TypeOfOpen = NtfsDecodeFileObject( IrpContext, IrpSp->FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
|
||
|
||
//
|
||
// This only works for files and directories.
|
||
//
|
||
|
||
if ((TypeOfOpen != UserFileOpen) && (TypeOfOpen != UserDirectoryOpen)) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Read only volumes stay read only.
|
||
//
|
||
|
||
if (NtfsIsVolumeReadOnly( Vcb )) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_MEDIA_WRITE_PROTECTED );
|
||
return STATUS_MEDIA_WRITE_PROTECTED;
|
||
}
|
||
|
||
//
|
||
// Cleanly exit for volumes without oid indices, such as non-upgraded
|
||
// version 1.x volumes.
|
||
//
|
||
|
||
if (Vcb->ObjectIdTableScb == NULL) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_VOLUME_NOT_UPGRADED );
|
||
return STATUS_VOLUME_NOT_UPGRADED;
|
||
}
|
||
|
||
//
|
||
// Capture the source information.
|
||
//
|
||
|
||
IrpContext->SourceInfo = Ccb->UsnSourceInfo;
|
||
|
||
try {
|
||
|
||
//
|
||
// Only a restore operator or the I/O system (using its private irp minor code)
|
||
// is allowed to delete an object id.
|
||
//
|
||
|
||
if (FlagOn( Ccb->AccessFlags, RESTORE_ACCESS | WRITE_DATA_ACCESS) ||
|
||
(IrpSp->MinorFunction == IRP_MN_KERNEL_CALL)) {
|
||
|
||
Status = NtfsDeleteObjectIdInternal( IrpContext,
|
||
Fcb,
|
||
Vcb,
|
||
TRUE );
|
||
|
||
} else {
|
||
|
||
Status = STATUS_ACCESS_DENIED;
|
||
}
|
||
|
||
} finally {
|
||
|
||
//
|
||
// Update the last change timestamp
|
||
//
|
||
|
||
if (NT_SUCCESS( Status )) {
|
||
SetFlag( Ccb->Flags, CCB_FLAG_UPDATE_LAST_CHANGE );
|
||
}
|
||
|
||
//
|
||
// If there was no object id - just return success
|
||
//
|
||
|
||
if (STATUS_OBJECTID_NOT_FOUND == Status) {
|
||
Status = STATUS_SUCCESS;
|
||
}
|
||
|
||
if (!AbnormalTermination()) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, Status );
|
||
}
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
NtfsDeleteObjectIdInternal (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb,
|
||
IN PVCB Vcb,
|
||
IN BOOLEAN DeleteFileAttribute
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Internal function to (optionally) delete the object id attribute from
|
||
a file and remove that object id from the index.
|
||
|
||
Arguments:
|
||
|
||
Fcb - The file from which to delete the object id.
|
||
|
||
Vcb - The volume whose object id index the object id should be removed from.
|
||
|
||
DeleteFileAttribute - Specifies whether to delete the object id file attribute
|
||
from the file in addition to removing the id from the index.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
FILE_OBJECTID_BUFFER ObjectIdBuffer;
|
||
FILE_OBJECTID_INFORMATION FileObjectIdInfo;
|
||
|
||
INDEX_KEY IndexKey;
|
||
INDEX_ROW IndexRow;
|
||
MAP_HANDLE MapHandle;
|
||
|
||
ATTRIBUTE_ENUMERATION_CONTEXT AttributeContext;
|
||
BOOLEAN InitializedAttributeContext = FALSE;
|
||
BOOLEAN InitializedMapHandle = FALSE;
|
||
BOOLEAN IndexAcquired = FALSE;
|
||
|
||
//
|
||
// Cleanly exit for volumes without oid indices, such as non-upgraded
|
||
// version 1.x volumes.
|
||
//
|
||
|
||
if (Vcb->ObjectIdTableScb == NULL) {
|
||
|
||
return STATUS_VOLUME_NOT_UPGRADED;
|
||
}
|
||
|
||
//
|
||
// Acquire the file we're deleting the object id from. We don't
|
||
// want anybody else deleting the file or object id behind
|
||
// our backs.
|
||
//
|
||
|
||
NtfsAcquireExclusiveFcb( IrpContext, Fcb, NULL, 0 );
|
||
|
||
try {
|
||
|
||
//
|
||
// We need to look up the object id. It's quite possible that
|
||
// this file has no object id, so we'll treat that as success.
|
||
//
|
||
|
||
Status = NtfsGetObjectIdInternal( IrpContext,
|
||
Fcb,
|
||
FALSE,
|
||
&ObjectIdBuffer );
|
||
|
||
if (Status != STATUS_SUCCESS) {
|
||
|
||
try_return( NOTHING );
|
||
}
|
||
|
||
//
|
||
// Look for object id in the index.
|
||
//
|
||
|
||
IndexKey.Key = ObjectIdBuffer.ObjectId;
|
||
IndexKey.KeyLength = sizeof( ObjectIdBuffer.ObjectId );
|
||
|
||
NtOfsInitializeMapHandle( &MapHandle );
|
||
InitializedMapHandle = TRUE;
|
||
|
||
//
|
||
// Acquire the object id index before doing the lookup.
|
||
// We need to make sure the file is acquired first to prevent
|
||
// a possible deadlock.
|
||
//
|
||
|
||
ASSERT_EXCLUSIVE_FCB( Fcb );
|
||
NtfsAcquireExclusiveScb( IrpContext, Vcb->ObjectIdTableScb );
|
||
IndexAcquired = TRUE;
|
||
|
||
if ( NtOfsFindRecord( IrpContext,
|
||
Vcb->ObjectIdTableScb,
|
||
&IndexKey,
|
||
&IndexRow,
|
||
&MapHandle,
|
||
NULL) != STATUS_SUCCESS ) {
|
||
|
||
try_return( Status = STATUS_OBJECT_NAME_NOT_FOUND );
|
||
}
|
||
|
||
ASSERT( IndexRow.DataPart.DataLength == sizeof( NTFS_OBJECTID_INFORMATION ) );
|
||
|
||
//
|
||
// Copy objectid info into the correct buffer if we need it for the notify
|
||
// below.
|
||
//
|
||
|
||
if ((Vcb->ViewIndexNotifyCount != 0) &&
|
||
(IndexRow.DataPart.DataLength == sizeof( NTFS_OBJECTID_INFORMATION ))) {
|
||
|
||
//
|
||
// The FRS field is only populated for the notification of a failed
|
||
// object id restore from the tunnel cache.
|
||
//
|
||
|
||
FileObjectIdInfo.FileReference = 0L;
|
||
|
||
RtlCopyMemory( &FileObjectIdInfo.ObjectId,
|
||
ObjectIdBuffer.ObjectId,
|
||
OBJECT_ID_KEY_LENGTH );
|
||
|
||
RtlCopyMemory( &FileObjectIdInfo.ExtendedInfo,
|
||
((NTFS_OBJECTID_INFORMATION *)IndexRow.DataPart.Data)->ExtendedInfo,
|
||
OBJECT_ID_EXT_INFO_LENGTH );
|
||
}
|
||
|
||
//
|
||
// Remove ObjectId from the index.
|
||
//
|
||
|
||
NtOfsDeleteRecords( IrpContext,
|
||
Vcb->ObjectIdTableScb,
|
||
1, // deleting one record from the index
|
||
&IndexKey );
|
||
|
||
//
|
||
// Notify anybody who's interested. We use a different action if the
|
||
// object id is being deleted by the fsctl versus a delete file.
|
||
//
|
||
|
||
if (Vcb->ViewIndexNotifyCount != 0) {
|
||
|
||
NtfsReportViewIndexNotify( Vcb,
|
||
Vcb->ObjectIdTableScb->Fcb,
|
||
FILE_NOTIFY_CHANGE_FILE_NAME,
|
||
(DeleteFileAttribute ?
|
||
FILE_ACTION_REMOVED :
|
||
FILE_ACTION_REMOVED_BY_DELETE),
|
||
&FileObjectIdInfo,
|
||
sizeof(FILE_OBJECTID_INFORMATION) );
|
||
}
|
||
|
||
if (DeleteFileAttribute) {
|
||
|
||
//
|
||
// Post the change to the Usn Journal (on errors change is backed out)
|
||
//
|
||
|
||
NtfsPostUsnChange( IrpContext, Fcb, USN_REASON_OBJECT_ID_CHANGE );
|
||
|
||
//
|
||
// Now remove the object id attribute from the file.
|
||
//
|
||
|
||
NtfsInitializeAttributeContext( &AttributeContext );
|
||
InitializedAttributeContext = TRUE;
|
||
|
||
if (NtfsLookupAttributeByCode( IrpContext,
|
||
Fcb,
|
||
&Fcb->FileReference,
|
||
$OBJECT_ID,
|
||
&AttributeContext )) {
|
||
|
||
NtfsDeleteAttributeRecord( IrpContext,
|
||
Fcb,
|
||
DELETE_LOG_OPERATION |
|
||
DELETE_RELEASE_FILE_RECORD |
|
||
DELETE_RELEASE_ALLOCATION,
|
||
&AttributeContext );
|
||
} else {
|
||
|
||
//
|
||
// If the object id was in the index, but the attribute
|
||
// isn't on the file, then the object id index for this
|
||
// volume is corrupt. We can repair this corruption in
|
||
// the background, so let's start doing that now.
|
||
//
|
||
|
||
NtfsPostSpecial( IrpContext, Vcb, NtfsRepairObjectId, NULL );
|
||
}
|
||
|
||
NtfsCleanupTransaction( IrpContext, Status, FALSE );
|
||
}
|
||
|
||
try_exit: NOTHING;
|
||
} finally {
|
||
|
||
if (InitializedMapHandle) {
|
||
|
||
NtOfsReleaseMap( IrpContext, &MapHandle );
|
||
}
|
||
|
||
if (InitializedAttributeContext) {
|
||
|
||
NtfsCleanupAttributeContext( IrpContext, &AttributeContext );
|
||
}
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
VOID
|
||
NtfsRepairObjectId (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PVOID Context
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to repair the object Id index. This is called when
|
||
the system detects that the object Id index may be out of date. For example
|
||
after the volume was mounted on 4.0.
|
||
|
||
Arguments:
|
||
|
||
IrpContext - context of the call
|
||
|
||
Context - NULL
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
BOOLEAN AcquiredVcb = FALSE;
|
||
BOOLEAN SetRepairFlag = FALSE;
|
||
BOOLEAN IncrementedCloseCounts = FALSE;
|
||
PBCB Bcb = NULL;
|
||
PVCB Vcb = IrpContext->Vcb;
|
||
PSCB ObjectIdScb;
|
||
PREAD_CONTEXT ReadContext = NULL;
|
||
PINDEX_ROW IndexRow = NULL;
|
||
PINDEX_ROW ObjectIdRow;
|
||
INDEX_KEY IndexKey;
|
||
MAP_HANDLE MapHandle;
|
||
PNTFS_OBJECTID_INFORMATION ObjectIdInfo;
|
||
PVOID RowBuffer = NULL;
|
||
ULONG Count;
|
||
ULONG i;
|
||
BOOLEAN IndexAcquired = FALSE;
|
||
FILE_OBJECTID_BUFFER ObjectIdBuffer;
|
||
PFILE_RECORD_SEGMENT_HEADER FileRecord;
|
||
LONGLONG MftOffset;
|
||
|
||
PAGED_CODE();
|
||
|
||
UNREFERENCED_PARAMETER( Context );
|
||
|
||
ASSERT( Vcb->MajorVersion >= NTFS_OBJECT_ID_VERSION );
|
||
|
||
//
|
||
// Use a try-except to catch errors.
|
||
//
|
||
|
||
NtfsAcquireSharedVcb( IrpContext, Vcb, TRUE );
|
||
AcquiredVcb = TRUE;
|
||
|
||
try {
|
||
|
||
//
|
||
// Now that we're holding the Vcb, we can safely test for the presence
|
||
// of the ObjectId index, as well as whether the volume is mounted.
|
||
//
|
||
|
||
if (FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED ) &&
|
||
(Vcb->ObjectIdTableScb != NULL) &&
|
||
(!FlagOn( Vcb->ObjectIdTableScb->ScbState, SCB_STATE_VOLUME_DISMOUNTED ))) {
|
||
|
||
ObjectIdScb = Vcb->ObjectIdTableScb;
|
||
NtfsAcquireExclusiveScb( IrpContext, ObjectIdScb );
|
||
IndexAcquired = TRUE;
|
||
|
||
//
|
||
// Since we'll be dropping the ObjectIdScb periodically, and we're
|
||
// not holding anything else, there's a chance that a dismount could
|
||
// happen, and make it unsafe for us to reacquire the ObjectIdScb.
|
||
// By incrementing the close counts, we keep it around as long as
|
||
// we need it.
|
||
//
|
||
|
||
NtfsIncrementCloseCounts( ObjectIdScb, TRUE, FALSE );
|
||
IncrementedCloseCounts = TRUE;
|
||
|
||
NtfsReleaseVcb( IrpContext, Vcb );
|
||
AcquiredVcb = FALSE;
|
||
|
||
} else {
|
||
|
||
NtfsRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED, NULL, NULL );
|
||
}
|
||
|
||
//
|
||
// The volume could've gotten write-protected by now.
|
||
//
|
||
|
||
if (NtfsIsVolumeReadOnly( Vcb )) {
|
||
|
||
NtfsRaiseStatus( IrpContext, STATUS_MEDIA_WRITE_PROTECTED, NULL, NULL );
|
||
}
|
||
|
||
if (!FlagOn( Vcb->ObjectIdState, VCB_OBJECT_ID_REPAIR_RUNNING )) {
|
||
|
||
SetFlag( Vcb->ObjectIdState, VCB_OBJECT_ID_REPAIR_RUNNING );
|
||
SetRepairFlag = TRUE;
|
||
|
||
//
|
||
// Check the object id index. Periodically release all resources.
|
||
// See NtfsClearAndVerifyQuotaIndex
|
||
//
|
||
|
||
NtOfsInitializeMapHandle( &MapHandle );
|
||
|
||
//
|
||
// Allocate a buffer large enough for several rows.
|
||
//
|
||
|
||
RowBuffer = NtfsAllocatePool( PagedPool, PAGE_SIZE );
|
||
|
||
try {
|
||
|
||
//
|
||
// Allocate a bunch of index row entries.
|
||
//
|
||
|
||
Count = PAGE_SIZE / sizeof( NTFS_OBJECTID_INFORMATION );
|
||
|
||
IndexRow = NtfsAllocatePool( PagedPool,
|
||
Count * sizeof( INDEX_ROW ) );
|
||
|
||
//
|
||
// Iterate through the object id entries. Start at the beginning.
|
||
//
|
||
|
||
RtlZeroMemory( &ObjectIdBuffer, sizeof(ObjectIdBuffer) );
|
||
|
||
IndexKey.Key = ObjectIdBuffer.ObjectId;
|
||
IndexKey.KeyLength = sizeof( ObjectIdBuffer.ObjectId );
|
||
|
||
Status = NtOfsReadRecords( IrpContext,
|
||
ObjectIdScb,
|
||
&ReadContext,
|
||
&IndexKey,
|
||
NtOfsMatchAll,
|
||
NULL,
|
||
&Count,
|
||
IndexRow,
|
||
PAGE_SIZE,
|
||
RowBuffer );
|
||
|
||
while (NT_SUCCESS( Status )) {
|
||
|
||
//
|
||
// Acquire the VCB shared and check whether we should
|
||
// continue.
|
||
//
|
||
|
||
if (!NtfsIsVcbAvailable( Vcb )) {
|
||
|
||
//
|
||
// The volume is going away, bail out.
|
||
//
|
||
|
||
Status = STATUS_VOLUME_DISMOUNTED;
|
||
leave;
|
||
}
|
||
|
||
ObjectIdRow = IndexRow;
|
||
|
||
for (i = 0; i < Count; i++, ObjectIdRow++) {
|
||
|
||
ObjectIdInfo = ObjectIdRow->DataPart.Data;
|
||
|
||
//
|
||
// Make sure the mft record referenced in the index
|
||
// row still exists and hasn't been deleted, etc.
|
||
//
|
||
// We start by reading the disk and checking that the file record
|
||
// sequence number matches and that the file record is in use. If
|
||
// we find an invalid entry, we will simply delete it from the
|
||
// object id index.
|
||
//
|
||
|
||
MftOffset = NtfsFullSegmentNumber( &ObjectIdInfo->FileSystemReference );
|
||
|
||
MftOffset = Int64ShllMod32(MftOffset, Vcb->MftShift);
|
||
|
||
if (MftOffset >= Vcb->MftScb->Header.FileSize.QuadPart) {
|
||
|
||
DebugTrace( 0, Dbg, ("File Id doesn't lie within Mft FRS %04x:%08lx\n",
|
||
ObjectIdInfo->FileSystemReference.SequenceNumber,
|
||
ObjectIdInfo->FileSystemReference.SegmentNumberLowPart) );
|
||
|
||
NtOfsDeleteRecords( IrpContext,
|
||
ObjectIdScb,
|
||
1, // deleting one record from the index
|
||
&ObjectIdRow->KeyPart );
|
||
|
||
} else {
|
||
|
||
NtfsReadMftRecord( IrpContext,
|
||
Vcb,
|
||
&ObjectIdInfo->FileSystemReference,
|
||
FALSE,
|
||
&Bcb,
|
||
&FileRecord,
|
||
NULL );
|
||
|
||
//
|
||
// This file record better be in use, have a matching sequence number and
|
||
// be the primary file record for this file.
|
||
//
|
||
|
||
if ((*((PULONG) FileRecord->MultiSectorHeader.Signature) != *((PULONG) FileSignature)) ||
|
||
!FlagOn( FileRecord->Flags, FILE_RECORD_SEGMENT_IN_USE ) ||
|
||
(FileRecord->SequenceNumber != ObjectIdInfo->FileSystemReference.SequenceNumber) ||
|
||
(*((PLONGLONG) &FileRecord->BaseFileRecordSegment) != 0)) {
|
||
|
||
DebugTrace( 0, Dbg, ("RepairOID removing an orphaned OID\n") );
|
||
|
||
NtOfsDeleteRecords( IrpContext,
|
||
ObjectIdScb,
|
||
1, // deleting one record from the index
|
||
&ObjectIdRow->KeyPart );
|
||
|
||
} else {
|
||
|
||
DebugTrace( 0, Dbg, ("RepairOID happy with OID %08lx on FRS %04x:%08lx\n",
|
||
*((PULONG) ObjectIdRow->KeyPart.Key),
|
||
ObjectIdInfo->FileSystemReference.SequenceNumber,
|
||
ObjectIdInfo->FileSystemReference.SegmentNumberLowPart) );
|
||
}
|
||
|
||
NtfsUnpinBcb( IrpContext, &Bcb );
|
||
}
|
||
}
|
||
|
||
//
|
||
// Release the index and commit what has been done so far.
|
||
//
|
||
|
||
ASSERT( IndexAcquired );
|
||
NtfsReleaseScb( IrpContext, ObjectIdScb );
|
||
IndexAcquired = FALSE;
|
||
|
||
//
|
||
// Complete the request which commits the pending
|
||
// transaction if there is one and releases of the
|
||
// acquired resources. The IrpContext will not
|
||
// be deleted because the no delete flag is set.
|
||
//
|
||
|
||
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_DONT_DELETE | IRP_CONTEXT_FLAG_RETAIN_FLAGS );
|
||
NtfsCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
|
||
|
||
//
|
||
// Remember how far we got so we can restart correctly. **** ??? ****
|
||
//
|
||
|
||
// Vcb->QuotaFileReference.SegmentNumberLowPart =
|
||
// *((PULONG) IndexRow[Count - 1].KeyPart.Key);
|
||
|
||
//
|
||
// Reacquire the object id index for the next pass.
|
||
//
|
||
|
||
NtfsAcquireExclusiveScb( IrpContext, ObjectIdScb );
|
||
IndexAcquired = TRUE;
|
||
|
||
//
|
||
// Make sure a dismount didn't occur while we weren't holding any
|
||
// resources.
|
||
//
|
||
|
||
if (FlagOn( ObjectIdScb->ScbState, SCB_STATE_VOLUME_DISMOUNTED )) {
|
||
|
||
NtfsRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED, NULL, NULL );
|
||
}
|
||
|
||
//
|
||
// Look up the next set of entries in the object id index.
|
||
//
|
||
|
||
Count = PAGE_SIZE / sizeof( NTFS_OBJECTID_INFORMATION );
|
||
Status = NtOfsReadRecords( IrpContext,
|
||
ObjectIdScb,
|
||
&ReadContext,
|
||
NULL,
|
||
NtOfsMatchAll,
|
||
NULL,
|
||
&Count,
|
||
IndexRow,
|
||
PAGE_SIZE,
|
||
RowBuffer );
|
||
}
|
||
|
||
ASSERT( (Status == STATUS_NO_MORE_MATCHES) ||
|
||
(Status == STATUS_NO_MATCH) );
|
||
|
||
} finally {
|
||
|
||
NtfsUnpinBcb( IrpContext, &Bcb );
|
||
|
||
NtfsFreePool( RowBuffer );
|
||
NtOfsReleaseMap( IrpContext, &MapHandle );
|
||
|
||
if (IndexAcquired) {
|
||
NtfsReleaseScb( IrpContext, ObjectIdScb );
|
||
IndexAcquired = FALSE;
|
||
}
|
||
|
||
if (IndexRow != NULL) {
|
||
NtfsFreePool( IndexRow );
|
||
}
|
||
|
||
if (ReadContext != NULL) {
|
||
NtOfsFreeReadContext( ReadContext );
|
||
}
|
||
}
|
||
|
||
//
|
||
// Acquire the Vcb to clear the object ID flag on disk. Since we got the
|
||
// Vcb shared before, we better not still be holding it when we try to
|
||
// get it exclusively now or else we'll have a one thread deadlock.
|
||
//
|
||
|
||
ASSERT( !AcquiredVcb );
|
||
NtfsAcquireExclusiveVcb( IrpContext, Vcb, TRUE );
|
||
AcquiredVcb = TRUE;
|
||
|
||
if (!NtfsIsVcbAvailable( Vcb )) {
|
||
|
||
NtfsRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED, NULL, NULL );
|
||
}
|
||
|
||
//
|
||
// Clear the on-disk flag indicating the repair is underway.
|
||
//
|
||
|
||
NtfsSetVolumeInfoFlagState( IrpContext,
|
||
Vcb,
|
||
VOLUME_REPAIR_OBJECT_ID,
|
||
FALSE,
|
||
TRUE );
|
||
|
||
//
|
||
// Make sure we don't own any resources at this point.
|
||
//
|
||
|
||
NtfsPurgeFileRecordCache( IrpContext );
|
||
NtfsCheckpointCurrentTransaction( IrpContext );
|
||
}
|
||
|
||
} except( NtfsExceptionFilter( IrpContext, GetExceptionInformation())) {
|
||
|
||
Status = IrpContext->TopLevelIrpContext->ExceptionStatus;
|
||
}
|
||
|
||
//
|
||
// Clear the repair_running flag if we're the ones who set it, making sure
|
||
// to only change the ObjectIdState bits while holding the ObjectId index.
|
||
//
|
||
|
||
if (SetRepairFlag) {
|
||
|
||
if (!IndexAcquired) {
|
||
|
||
NtfsAcquireExclusiveScb( IrpContext, ObjectIdScb );
|
||
IndexAcquired = TRUE;
|
||
}
|
||
|
||
ClearFlag( Vcb->ObjectIdState, VCB_OBJECT_ID_REPAIR_RUNNING );
|
||
}
|
||
|
||
if (IncrementedCloseCounts) {
|
||
|
||
if (!IndexAcquired) {
|
||
|
||
NtfsAcquireExclusiveScb( IrpContext, ObjectIdScb );
|
||
IndexAcquired = TRUE;
|
||
}
|
||
|
||
NtfsDecrementCloseCounts( IrpContext, ObjectIdScb, NULL, TRUE, FALSE, FALSE );
|
||
}
|
||
|
||
//
|
||
// Drop the index and the Vcb.
|
||
//
|
||
|
||
if (IndexAcquired) {
|
||
|
||
NtfsReleaseScb( IrpContext, ObjectIdScb );
|
||
}
|
||
|
||
if (AcquiredVcb) {
|
||
|
||
NtfsReleaseVcb( IrpContext, Vcb );
|
||
}
|
||
|
||
//
|
||
// If this is a fatal failure then do any final cleanup.
|
||
//
|
||
|
||
if (!NT_SUCCESS( Status )) {
|
||
|
||
//
|
||
// If we will not be called back then clear the running state bits.
|
||
//
|
||
|
||
if ((Status != STATUS_CANT_WAIT) && (Status != STATUS_LOG_FILE_FULL)) {
|
||
|
||
//
|
||
// Do we want to log this error? Some may be expected (i.e. STATUS_VOLUME_DISMOUNTED ).
|
||
//
|
||
|
||
// NtfsLogEvent( IrpContext, NULL, IO_FILE_OBJECTID_REPAIR_FAILED, Status );
|
||
}
|
||
|
||
NtfsRaiseStatus( IrpContext, Status, NULL, NULL );
|
||
}
|
||
}
|
||
|
||
//
|
||
// Local support routine
|
||
//
|
||
|
||
|
||
NTSTATUS
|
||
NtfsSetObjectIdExtendedInfoInternal (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb,
|
||
IN PVCB Vcb,
|
||
IN PUCHAR ExtendedInfoBuffer
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine sets the extended info for a file which already has an object
|
||
id. If the file does not yet have an object id, we return a status other
|
||
than STATUS_SUCCESS.
|
||
|
||
Arguments:
|
||
|
||
Fcb - The file whose extended info is to be set.
|
||
|
||
Vcb - The volume whose object id index the entry should be modified in.
|
||
|
||
ExtendedInfoBuffer - Supplies the new extended info.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation.
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS Status;
|
||
NTFS_OBJECTID_INFORMATION ObjectIdInfo;
|
||
FILE_OBJECTID_BUFFER ObjectIdBuffer;
|
||
INDEX_ROW IndexRow;
|
||
|
||
PAGED_CODE( );
|
||
|
||
Status = NtfsGetObjectIdInternal( IrpContext,
|
||
Fcb,
|
||
FALSE, // GetExtendedInfo
|
||
&ObjectIdBuffer );
|
||
|
||
if (Status != STATUS_SUCCESS) {
|
||
|
||
//
|
||
// This file may not have an object id yet.
|
||
//
|
||
|
||
return Status;
|
||
}
|
||
|
||
//
|
||
// Setup the index row for updating. Since part of the data
|
||
// is passed into this function (the new extended info) and
|
||
// the rest can be determined easily (the file reference), we
|
||
// don't need to look up any of the existing data before
|
||
// proceeding. If the NTFS_OBJECTID_INFORMATION structure
|
||
// ever changes, this code may have to be changed to include
|
||
// a lookup of the data currently in the object id index.
|
||
//
|
||
|
||
RtlCopyMemory( &ObjectIdInfo.FileSystemReference,
|
||
&Fcb->FileReference,
|
||
sizeof( ObjectIdInfo.FileSystemReference ) );
|
||
|
||
RtlCopyMemory( &ObjectIdInfo.ExtendedInfo,
|
||
ExtendedInfoBuffer,
|
||
OBJECT_ID_EXT_INFO_LENGTH );
|
||
|
||
IndexRow.DataPart.Data = &ObjectIdInfo;
|
||
IndexRow.DataPart.DataLength = sizeof( NTFS_OBJECTID_INFORMATION );
|
||
|
||
IndexRow.KeyPart.Key = &ObjectIdBuffer;
|
||
IndexRow.KeyPart.KeyLength = OBJECT_ID_KEY_LENGTH;
|
||
|
||
//
|
||
// Acquire the object id index before doing the modification.
|
||
//
|
||
|
||
NtfsAcquireExclusiveScb( IrpContext, Vcb->ObjectIdTableScb );
|
||
|
||
|
||
//
|
||
// Post the change to the Usn Journal (on errors change is backed out)
|
||
//
|
||
|
||
NtfsPostUsnChange( IrpContext, Fcb, USN_REASON_OBJECT_ID_CHANGE );
|
||
|
||
//
|
||
// Update the ObjectId index record's data in place.
|
||
//
|
||
|
||
NtOfsUpdateRecord( IrpContext,
|
||
Vcb->ObjectIdTableScb,
|
||
1, // Count
|
||
&IndexRow,
|
||
NULL, // QuickIndexHint
|
||
NULL ); // MapHandle
|
||
|
||
NtfsCleanupTransaction( IrpContext, Status, FALSE );
|
||
return Status;
|
||
}
|
||
|
||
//
|
||
// Local support routine
|
||
//
|
||
|
||
|
||
VOID
|
||
NtfsGetIdFromGenerator (
|
||
OUT PFILE_OBJECTID_BUFFER ObjectId
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function conjures up a random object id.
|
||
|
||
Arguments:
|
||
|
||
ObjectId - The location where the generated object id will be stored.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE( );
|
||
|
||
//
|
||
// Cal the id generator.
|
||
//
|
||
|
||
ExUuidCreate( (UUID *)ObjectId->ObjectId );
|
||
}
|