able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/ntfs/quota.c

567 lines
14 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
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;
}
Reference in a new issue Copy permalink