567 lines
14 KiB
C
567 lines
14 KiB
C
/*++
|
||
|
||
Copyright (c) 1991 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
Quota.c
|
||
|
||
Abstract:
|
||
|
||
This module implements the File set and query Quota routines for Ntfs called
|
||
by the dispatch driver.
|
||
|
||
Author:
|
||
|
||
Jeff Havens [Jhavens] 12-Jul-1996
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "NtfsProc.h"
|
||
|
||
//
|
||
// The local debug trace level
|
||
//
|
||
|
||
#define Dbg (DEBUG_TRACE_QUOTA)
|
||
|
||
//
|
||
// Define a tag for general pool allocations from this module
|
||
//
|
||
|
||
#undef MODULE_POOL_TAG
|
||
#define MODULE_POOL_TAG ('QFtN')
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text(PAGE, NtfsCommonQueryQuota)
|
||
#pragma alloc_text(PAGE, NtfsCommonSetQuota)
|
||
#endif
|
||
|
||
|
||
NTSTATUS
|
||
NtfsCommonQueryQuota (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This is the common routine for query Quota called by both the fsd and fsp
|
||
threads.
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp to process
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS Status;
|
||
PIO_STACK_LOCATION IrpSp;
|
||
PFILE_OBJECT FileObject;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PSCB Scb;
|
||
PCCB Ccb;
|
||
|
||
PFILE_GET_QUOTA_INFORMATION UserSidList;
|
||
PFILE_QUOTA_INFORMATION QuotaBuffer = NULL;
|
||
PFILE_QUOTA_INFORMATION MappedQuotaBuffer = NULL;
|
||
PFILE_QUOTA_INFORMATION OriginalQuotaBuffer;
|
||
ULONG OriginalBufferLength;
|
||
ULONG UserBufferLength;
|
||
ULONG UserSidListLength;
|
||
PSID UserStartSid;
|
||
ULONG OwnerId;
|
||
BOOLEAN RestartScan;
|
||
BOOLEAN ReturnSingleEntry;
|
||
BOOLEAN IndexSpecified;
|
||
BOOLEAN TempBufferAllocated = FALSE;
|
||
|
||
ASSERT_IRP_CONTEXT( IrpContext );
|
||
ASSERT_IRP( Irp );
|
||
ASSERT( FlagOn( IrpContext->TopLevelIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Get the current Irp stack location
|
||
//
|
||
|
||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||
|
||
DebugTrace( +1, Dbg, ("NtfsCommonQueryQuota\n") );
|
||
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
|
||
DebugTrace( 0, Dbg, ("Irp = %08lx\n", Irp) );
|
||
DebugTrace( 0, Dbg, ("SystemBuffer = %08lx\n", Irp->AssociatedIrp.SystemBuffer) );
|
||
DebugTrace( 0, Dbg, ("Length = %08lx\n", IrpSp->Parameters.QueryQuota.Length) );
|
||
DebugTrace( 0, Dbg, ("SidList = %08lx\n", IrpSp->Parameters.QueryQuota.SidList) );
|
||
DebugTrace( 0, Dbg, ("SidListLength = %08lx\n", IrpSp->Parameters.QueryQuota.SidListLength) );
|
||
DebugTrace( 0, Dbg, ("StartSid = %08lx\n", IrpSp->Parameters.QueryQuota.StartSid) );
|
||
DebugTrace( 0, Dbg, ("RestartScan = %08lx\n", FlagOn(IrpSp->Flags, SL_RESTART_SCAN)) );
|
||
DebugTrace( 0, Dbg, ("ReturnSingleEntry = %08lx\n", FlagOn(IrpSp->Flags, SL_RETURN_SINGLE_ENTRY)) );
|
||
DebugTrace( 0, Dbg, ("IndexSpecified = %08lx\n", FlagOn(IrpSp->Flags, SL_INDEX_SPECIFIED)) );
|
||
|
||
//
|
||
// Extract and decode the file object
|
||
//
|
||
|
||
FileObject = IrpSp->FileObject;
|
||
UserBufferLength = IrpSp->Parameters.QueryQuota.Length;
|
||
UserSidList = IrpSp->Parameters.QueryQuota.SidList;
|
||
UserSidListLength = IrpSp->Parameters.QueryQuota.SidListLength;
|
||
TypeOfOpen = NtfsDecodeFileObject( IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
|
||
|
||
//
|
||
// This must be a user file or directory and the Ccb must indicate that
|
||
// the caller opened the entire file. We don't like zero length user buffers or SidLists either.
|
||
//
|
||
|
||
if (((TypeOfOpen != UserFileOpen) &&
|
||
(TypeOfOpen != UserDirectoryOpen) &&
|
||
(TypeOfOpen != UserVolumeOpen) &&
|
||
(TypeOfOpen != UserViewIndexOpen)) ||
|
||
(UserBufferLength == 0) ||
|
||
((UserSidList != NULL) && (UserSidListLength == 0)) ||
|
||
(Ccb == NULL) ||
|
||
!FlagOn( Ccb->Flags, CCB_FLAG_OPEN_AS_FILE )) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||
DebugTrace( -1, Dbg, ("NtfsCommonQueryQuota -> %08lx\n", STATUS_INVALID_PARAMETER) );
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Return nothing if quotas are not enabled.
|
||
//
|
||
|
||
if (Vcb->QuotaTableScb == NULL) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
|
||
return STATUS_INVALID_DEVICE_REQUEST;
|
||
}
|
||
|
||
//
|
||
// Acquire the Vcb Shared.
|
||
//
|
||
|
||
NtfsAcquireSharedVcb( IrpContext, Vcb, TRUE );
|
||
|
||
//
|
||
// Use a try-finally to facilitate cleanup.
|
||
//
|
||
|
||
try {
|
||
|
||
if (!FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) {
|
||
|
||
Status = STATUS_VOLUME_DISMOUNTED;
|
||
leave;
|
||
}
|
||
|
||
//
|
||
// Reference our input parameters to make things easier
|
||
//
|
||
|
||
UserStartSid = IrpSp->Parameters.QueryQuota.StartSid;
|
||
RestartScan = BooleanFlagOn(IrpSp->Flags, SL_RESTART_SCAN);
|
||
ReturnSingleEntry = BooleanFlagOn(IrpSp->Flags, SL_RETURN_SINGLE_ENTRY);
|
||
IndexSpecified = BooleanFlagOn(IrpSp->Flags, SL_INDEX_SPECIFIED);
|
||
|
||
//
|
||
// Initialize our local variables.
|
||
//
|
||
|
||
Status = STATUS_SUCCESS;
|
||
|
||
//
|
||
// Map the user's buffer.
|
||
//
|
||
|
||
QuotaBuffer = NtfsMapUserBuffer( Irp );
|
||
|
||
//
|
||
// Allocate our own output buffer out of paranoia.
|
||
//
|
||
|
||
if (Irp->RequestorMode != KernelMode) {
|
||
|
||
MappedQuotaBuffer = QuotaBuffer;
|
||
QuotaBuffer = NtfsAllocatePool( PagedPool, UserBufferLength );
|
||
TempBufferAllocated = TRUE;
|
||
}
|
||
|
||
OriginalBufferLength = UserBufferLength;
|
||
OriginalQuotaBuffer = QuotaBuffer;
|
||
|
||
//
|
||
// Let's clear the output buffer.
|
||
//
|
||
|
||
RtlZeroMemory( QuotaBuffer, UserBufferLength );
|
||
|
||
//
|
||
// We now satisfy the user's request depending on whether he
|
||
// specified an Quota name list, an Quota index or restarting the
|
||
// search.
|
||
//
|
||
|
||
//
|
||
// The user has supplied a list of Quota names.
|
||
//
|
||
|
||
if (UserSidList != NULL) {
|
||
|
||
Status = NtfsQueryQuotaUserSidList( IrpContext,
|
||
Vcb,
|
||
UserSidList,
|
||
QuotaBuffer,
|
||
&UserBufferLength,
|
||
ReturnSingleEntry );
|
||
|
||
} else {
|
||
|
||
//
|
||
// The user supplied an index into the Quota list.
|
||
//
|
||
|
||
if (IndexSpecified) {
|
||
|
||
OwnerId = NtfsGetOwnerId( IrpContext,
|
||
UserStartSid,
|
||
FALSE,
|
||
NULL );
|
||
|
||
if (OwnerId == QUOTA_INVALID_ID) {
|
||
|
||
//
|
||
// Fail the request.
|
||
//
|
||
|
||
Status = STATUS_INVALID_PARAMETER;
|
||
leave;
|
||
}
|
||
|
||
} else {
|
||
|
||
//
|
||
// Start at the begining of the list if restart specified.
|
||
//
|
||
|
||
OwnerId = RestartScan ? QUOTA_FISRT_USER_ID - 1 : Ccb->LastOwnerId;
|
||
|
||
}
|
||
|
||
Status = NtfsFsQuotaQueryInfo( IrpContext,
|
||
Vcb,
|
||
OwnerId,
|
||
ReturnSingleEntry,
|
||
&QuotaBuffer,
|
||
&UserBufferLength,
|
||
Ccb );
|
||
|
||
//
|
||
// If we specified SingleEntry, NextEntryOffset would still be uninitialized.
|
||
//
|
||
|
||
if (NT_SUCCESS( Status ) && ReturnSingleEntry) {
|
||
|
||
QuotaBuffer->NextEntryOffset = 0;
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// Copy the data onto the user buffer if we ended up allocating
|
||
// a temporary buffer to work on. Check if there's anything to copy, too.
|
||
// UserBufferLength reflects how much of the buffer is left.
|
||
//
|
||
|
||
if (TempBufferAllocated &&
|
||
(UserBufferLength < OriginalBufferLength)) {
|
||
|
||
try {
|
||
|
||
RtlCopyMemory( MappedQuotaBuffer, OriginalQuotaBuffer,
|
||
OriginalBufferLength - UserBufferLength );
|
||
|
||
} except( EXCEPTION_EXECUTE_HANDLER ) {
|
||
|
||
try_return( Status = STATUS_INVALID_USER_BUFFER );
|
||
}
|
||
}
|
||
|
||
if (UserBufferLength <= OriginalBufferLength) {
|
||
|
||
Irp->IoStatus.Information = OriginalBufferLength - UserBufferLength;
|
||
|
||
} else {
|
||
|
||
ASSERT( FALSE );
|
||
Irp->IoStatus.Information = 0;
|
||
}
|
||
|
||
Irp->IoStatus.Status = Status;
|
||
|
||
try_exit: NOTHING;
|
||
} finally {
|
||
|
||
DebugUnwind( NtfsCommonQueryQuota );
|
||
|
||
//
|
||
// Release the Vcb.
|
||
//
|
||
|
||
NtfsReleaseVcb( IrpContext, Vcb );
|
||
|
||
if (TempBufferAllocated) {
|
||
|
||
NtfsFreePool( OriginalQuotaBuffer );
|
||
}
|
||
|
||
if (!AbnormalTermination()) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, Status );
|
||
}
|
||
|
||
//
|
||
// And return to our caller
|
||
//
|
||
|
||
DebugTrace( -1, Dbg, ("NtfsCommonQueryQuota -> %08lx\n", Status) );
|
||
}
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
NtfsCommonSetQuota (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This is the common routine for set Quota called by both the fsd and fsp
|
||
threads.
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp to process
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - The return status for the operation
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS Status;
|
||
PIO_STACK_LOCATION IrpSp;
|
||
PFILE_OBJECT FileObject;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PSCB Scb;
|
||
PCCB Ccb;
|
||
|
||
PFILE_QUOTA_INFORMATION Buffer;
|
||
PFILE_QUOTA_INFORMATION SafeBuffer = NULL;
|
||
ULONG UserBufferLength;
|
||
|
||
ASSERT_IRP_CONTEXT( IrpContext );
|
||
ASSERT_IRP( Irp );
|
||
ASSERT( FlagOn( IrpContext->TopLevelIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Get the current Irp stack location
|
||
//
|
||
|
||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||
|
||
DebugTrace( +1, Dbg, ("NtfsCommonSetQuota\n") );
|
||
DebugTrace( 0, Dbg, ("IrpContext = %08lx\n", IrpContext) );
|
||
DebugTrace( 0, Dbg, ("Irp = %08lx\n", Irp) );
|
||
|
||
//
|
||
// Extract and decode the file object
|
||
//
|
||
|
||
FileObject = IrpSp->FileObject;
|
||
TypeOfOpen = NtfsDecodeFileObject( IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, TRUE );
|
||
|
||
//
|
||
// Initialize the IoStatus values.
|
||
//
|
||
|
||
Irp->IoStatus.Information = 0;
|
||
Irp->IoStatus.Status = STATUS_SUCCESS;
|
||
UserBufferLength = IrpSp->Parameters.SetQuota.Length;
|
||
|
||
//
|
||
// Check that the file object is associated with either a user file or
|
||
// user directory open or an open by file ID.
|
||
//
|
||
|
||
if ((Ccb == NULL) ||
|
||
|
||
(!FlagOn( Ccb->AccessFlags, MANAGE_VOLUME_ACCESS) &&
|
||
((TypeOfOpen != UserViewIndexOpen) || (Fcb != Vcb->QuotaTableScb->Fcb))) ||
|
||
|
||
(UserBufferLength == 0) ||
|
||
|
||
!FlagOn( Ccb->Flags, CCB_FLAG_OPEN_AS_FILE )) {
|
||
|
||
if (UserBufferLength != 0) {
|
||
|
||
Status = STATUS_ACCESS_DENIED;
|
||
|
||
} else {
|
||
|
||
Status = STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, Status );
|
||
DebugTrace( -1, Dbg, ("NtfsCommonQueryQuota -> %08lx\n", Status) );
|
||
|
||
return Status;
|
||
}
|
||
|
||
//
|
||
// We must be writable.
|
||
//
|
||
|
||
if (NtfsIsVolumeReadOnly( Vcb )) {
|
||
|
||
Status = STATUS_MEDIA_WRITE_PROTECTED;
|
||
NtfsCompleteRequest( IrpContext, Irp, Status );
|
||
|
||
DebugTrace( -1, Dbg, ("NtfsCommonSetQuota -> %08lx\n", Status) );
|
||
return Status;
|
||
}
|
||
|
||
//
|
||
// We must be waitable.
|
||
//
|
||
|
||
if (!FlagOn( IrpContext->State, IRP_CONTEXT_STATE_WAIT )) {
|
||
|
||
Status = NtfsPostRequest( IrpContext, Irp );
|
||
|
||
DebugTrace( -1, Dbg, ("NtfsCommonSetQuota -> %08lx\n", Status) );
|
||
return Status;
|
||
}
|
||
|
||
//
|
||
// Acquire the vcb shared.
|
||
//
|
||
|
||
NtfsAcquireSharedVcb( IrpContext, Vcb, TRUE );
|
||
|
||
//
|
||
// Use a try-finally to facilitate cleanup.
|
||
//
|
||
|
||
try {
|
||
|
||
if (!FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) {
|
||
|
||
Status = STATUS_VOLUME_DISMOUNTED;
|
||
leave;
|
||
}
|
||
|
||
//
|
||
// Map the user's Quota buffer.
|
||
//
|
||
|
||
Buffer = NtfsMapUserBuffer( Irp );
|
||
|
||
//
|
||
// Be paranoid and copy the user buffer into kernel space.
|
||
//
|
||
|
||
if (Irp->RequestorMode != KernelMode) {
|
||
|
||
SafeBuffer = NtfsAllocatePool( PagedPool, UserBufferLength );
|
||
|
||
try {
|
||
|
||
RtlCopyMemory( SafeBuffer, Buffer, UserBufferLength );
|
||
|
||
} except( EXCEPTION_EXECUTE_HANDLER ) {
|
||
|
||
Status = STATUS_INVALID_USER_BUFFER;
|
||
leave;
|
||
}
|
||
|
||
Buffer = SafeBuffer;
|
||
}
|
||
|
||
//
|
||
// Update the caller's Iosb.
|
||
//
|
||
|
||
Irp->IoStatus.Information = 0;
|
||
Status = STATUS_SUCCESS;
|
||
|
||
Status = NtfsFsQuotaSetInfo( IrpContext,
|
||
Vcb,
|
||
Buffer,
|
||
UserBufferLength );
|
||
|
||
//
|
||
// Check if there are transactions to cleanup.
|
||
//
|
||
|
||
NtfsCleanupTransaction( IrpContext, Status, FALSE );
|
||
|
||
} finally {
|
||
|
||
DebugUnwind( NtfsCommonSetQuota );
|
||
|
||
//
|
||
// Release the Vcb.
|
||
//
|
||
|
||
NtfsReleaseVcb( IrpContext, Vcb );
|
||
|
||
//
|
||
// If we allocated a temporary buffer, free it.
|
||
//
|
||
|
||
if (SafeBuffer != NULL) {
|
||
|
||
NtfsFreePool( SafeBuffer );
|
||
}
|
||
|
||
//
|
||
// Complete the Irp.
|
||
//
|
||
|
||
if (!AbnormalTermination()) {
|
||
|
||
NtfsCompleteRequest( IrpContext, Irp, Status );
|
||
}
|
||
|
||
DebugTrace( -1, Dbg, ("NtfsCommonSetQuota -> %08lx\n", Status) );
|
||
}
|
||
|
||
return Status;
|
||
}
|