void
Test_RtlAreBitsSet(void)
{
RTL_BITMAP BitMapHeader;
ULONG *Buffer;
Buffer = AllocateGuarded(2 * sizeof(*Buffer));
RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
Buffer[0] = 0xff00ff00;
Buffer[1] = 0x3F303F30;
ok_hex(RtlAreBitsSet(&BitMapHeader, 0, 8), FALSE);
ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 8), TRUE);
ok_hex(RtlAreBitsSet(&BitMapHeader, 7, 8), FALSE);
ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 9), FALSE);
ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), FALSE);
RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), TRUE);
ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 7), TRUE);
ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 8), FALSE);
RtlInitializeBitMap(&BitMapHeader, Buffer, 64);
ok_hex(RtlAreBitsSet(&BitMapHeader, 60, 4), FALSE);
FreeGuarded(Buffer);
}
/******************************************************************
* macho_sect_is_code
*
* Checks if a section, identified by sectidx which is a 1-based
* index into the sections of all segments, in order of load
* commands, contains code.
*/
static BOOL macho_sect_is_code(struct macho_file_map* fmap, unsigned char sectidx)
{
TRACE("(%p/%d, %u)\n", fmap, fmap->fd, sectidx);
if (!RtlAreBitsSet(&fmap->sect_is_code, 0, 1))
{
int cursect = 0;
if (macho_enum_load_commands(fmap, LC_SEGMENT, macho_fill_sect_is_code, &cursect) < 0)
WARN("Couldn't load sect_is_code map\n");
RtlSetBits(&fmap->sect_is_code, 0, 1);
}
return RtlAreBitsSet(&fmap->sect_is_code, sectidx, 1);
}
/*
* @implemented
*/
BOOL
WINAPI
TlsFree(DWORD Index)
{
BOOL BitSet;
if (Index >= TLS_EXPANSION_SLOTS + TLS_MINIMUM_AVAILABLE)
{
SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
return FALSE;
}
RtlAcquirePebLock();
if (Index >= TLS_MINIMUM_AVAILABLE)
{
BitSet = RtlAreBitsSet(NtCurrentPeb()->TlsExpansionBitmap,
Index - TLS_MINIMUM_AVAILABLE,
1);
if (BitSet)
RtlClearBits(NtCurrentPeb()->TlsExpansionBitmap,
Index - TLS_MINIMUM_AVAILABLE,
1);
}
else
{
BitSet = RtlAreBitsSet(NtCurrentPeb()->TlsBitmap, Index, 1);
if (BitSet)
RtlClearBits(NtCurrentPeb()->TlsBitmap, Index, 1);
}
if (BitSet)
{
/* Clear the TLS cells (slots) in all threads of the current process. */
NtSetInformationThread(NtCurrentThread(),
ThreadZeroTlsCell,
&Index,
sizeof(DWORD));
}
else
{
SetLastError(ERROR_INVALID_PARAMETER);
}
RtlReleasePebLock();
return BitSet;
}
/******************************************************************
* macho_fill_sect_is_code
*
* Callback for macho_enum_load_commands. Determines which segments
* of a Mach-O file contain code. All commands are expected to be
* of LC_SEGMENT type.
*/
static int macho_fill_sect_is_code(struct macho_file_map* fmap,
const struct load_command* lc, void* user)
{
const struct segment_command* sc = (const struct segment_command*)lc;
const struct section* sections;
int* cursect = user;
int i;
TRACE("(%p/%d, %p, %p/%d) scanning %u sections\n", fmap, fmap->fd, lc,
cursect, *cursect, sc->nsects);
sections = (const struct section*)(sc + 1);
for (i = 0; i < sc->nsects; i++)
{
if (*cursect > MAX_SECT) return -1;
(*cursect)++;
if (!(sections[i].flags & SECTION_TYPE) &&
(sections[i].flags & (S_ATTR_PURE_INSTRUCTIONS|S_ATTR_SOME_INSTRUCTIONS)))
RtlSetBits(&fmap->sect_is_code, *cursect, 1);
else
RtlClearBits(&fmap->sect_is_code, *cursect, 1);
TRACE("Section %d (%d of this segment) is%s code\n", *cursect, i,
(RtlAreBitsSet(&fmap->sect_is_code, *cursect, 1) ? "" : " not"));
}
return 0;
}
BOOLEAN
SpIsAdapterControlTypeSupported(
IN PADAPTER_EXTENSION AdapterExtension,
IN SCSI_ADAPTER_CONTROL_TYPE ControlType
)
{
return RtlAreBitsSet(&(AdapterExtension->SupportedControlBitMap),
ControlType,
1);
}
VOID test_bitmap()
{
Pool pool;
ULONG Bitmap_Size, Index;
PULONG Bitmap_Buffer;
// Initialize
Bitmap_Size = 13; // Number of bits
Bitmap_Buffer = ExAllocatePoolWithTag (
NonPagedPool,
(ULONG)(((Bitmap_Size/8+1)/sizeof(ULONG) + 1)* sizeof(ULONG)),
BITMAP_TAG
);
RtlInitializeBitMap(
&pool.Bitmap,
(PULONG)(Bitmap_Buffer),
(ULONG)(Bitmap_Size)
);
RtlClearAllBits(&pool.Bitmap);
for (Index = 0; Index < 10; Index++)
RtlSetBit(&pool.Bitmap, Index);
if (RtlAreBitsSet(&pool.Bitmap, 0, 10) == TRUE)
DbgPrint("bitmap: bit[0..9] is set\r\n");
if (RtlCheckBit(&pool.Bitmap, 10))
DbgPrint("bitmap: bit[10] is set\r\n");
if (RtlCheckBit(&pool.Bitmap, 1024)) //Warning! Return 1 here
DbgPrint("bitmap: bit[1024] is set\r\n");
Index = 0;
do
{
Index = RtlFindClearBitsAndSet (
&pool.Bitmap,
1, //NumberToFind
Index //HintIndex
);
DbgPrint("%d\n", Index);
}while (Index != -1);
// Free
ExFreePoolWithTag(pool.Bitmap.Buffer, BITMAP_TAG);
}
VOID
XenevtchnReleaseIoMemory(PVOID va, ULONG nr_bytes)
{
KIRQL old_irql;
ULONG page_nr;
XM_ASSERT(((ULONG_PTR)va & (PAGE_SIZE - 1)) == 0);
nr_bytes = (nr_bytes + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
page_nr =
(ULONG)(((ULONG_PTR)va - (ULONG_PTR)io_hole_va_start) / PAGE_SIZE);
old_irql = acquire_irqsafe_lock(&io_hole_lock);
XM_ASSERT(RtlAreBitsSet(&io_hole_in_use,
page_nr,
nr_bytes / PAGE_SIZE));
RtlClearBits(&io_hole_in_use, page_nr, nr_bytes / PAGE_SIZE);
release_irqsafe_lock(&io_hole_lock, old_irql);
}
NTSTATUS
FatSetFsLabelInfo (
IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN PFILE_FS_LABEL_INFORMATION Buffer
)
/*++
Routine Description:
This routine implements the set volume label call
Arguments:
Vcb - Supplies the Vcb being queried
Buffer - Supplies the input where the information is stored.
Return Value:
NTSTATUS - Returns the status for the operation
--*/
{
NTSTATUS Status;
PDIRENT Dirent;
PBCB DirentBcb = NULL;
ULONG ByteOffset;
WCHAR TmpBuffer[11];
UCHAR OemBuffer[11];
OEM_STRING OemLabel;
UNICODE_STRING UnicodeString;
UNICODE_STRING UpcasedLabel;
DebugTrace(+1, Dbg, "FatSetFsLabelInfo...\n", 0);
//
// Setup our local variable
//
UnicodeString.Length = (USHORT)Buffer->VolumeLabelLength;
UnicodeString.MaximumLength = UnicodeString.Length;
UnicodeString.Buffer = (PWSTR) &Buffer->VolumeLabel[0];
//
// Make sure the name can fit into the stack buffer
//
if ( UnicodeString.Length > 11*sizeof(WCHAR) ) {
return STATUS_INVALID_VOLUME_LABEL;
}
//
// Upcase the name and convert it to the Oem code page.
//
OemLabel.Buffer = &OemBuffer[0];
OemLabel.Length = 0;
OemLabel.MaximumLength = 11;
Status = RtlUpcaseUnicodeStringToCountedOemString( &OemLabel,
&UnicodeString,
FALSE );
//
// Volume label that fits in 11 unicode character length limit
// is not necessary within 11 characters in OEM character set.
//
if (!NT_SUCCESS( Status )) {
DebugTrace(-1, Dbg, "FatSetFsLabelInfo: Label must be too long. %08lx\n", Status );
return STATUS_INVALID_VOLUME_LABEL;
}
//
// Strip spaces off of the label.
//
if (OemLabel.Length > 0) {
USHORT i;
USHORT LastSpaceIndex = MAXUSHORT;
//
// Check the label for illegal characters
//
for ( i = 0; i < (ULONG)OemLabel.Length; i += 1 ) {
if ( FsRtlIsLeadDbcsCharacter( OemLabel.Buffer[i] ) ) {
LastSpaceIndex = MAXUSHORT;
i += 1;
continue;
}
if (!FsRtlIsAnsiCharacterLegalFat(OemLabel.Buffer[i], FALSE) ||
(OemLabel.Buffer[i] == '.')) {
return STATUS_INVALID_VOLUME_LABEL;
}
//
// Watch for the last run of spaces, so we can strip them.
//
if (OemLabel.Buffer[i] == ' ' &&
LastSpaceIndex == MAXUSHORT) {
LastSpaceIndex = i;
} else {
LastSpaceIndex = MAXUSHORT;
}
}
if (LastSpaceIndex != MAXUSHORT) {
OemLabel.Length = LastSpaceIndex;
}
}
//
// Get the Unicode upcased string to store in the VPB.
//
UpcasedLabel.Length = UnicodeString.Length;
UpcasedLabel.MaximumLength = 11*sizeof(WCHAR);
UpcasedLabel.Buffer = &TmpBuffer[0];
Status = RtlOemStringToCountedUnicodeString( &UpcasedLabel,
&OemLabel,
FALSE );
if (!NT_SUCCESS( Status )) {
DebugTrace(-1, Dbg, "FatSetFsLabelInfo: Label must be too long. %08lx\n", Status );
return STATUS_INVALID_VOLUME_LABEL;
}
DirentBcb = NULL;
//
// Make this look like a write through to disk. This is important to
// avoid a unpleasant window where it looks like we have the wrong volume.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH );
try {
//
// Are we setting or removing the label? Note that shaving spaces could
// make this different than wondering if the input buffer is non-zero length.
//
if (OemLabel.Length > 0) {
//
// Locate the volume label if there already is one
//
FatLocateVolumeLabel( IrpContext,
Vcb,
&Dirent,
&DirentBcb,
&ByteOffset );
//
// Check that we really got one, if not then we need to create
// a new one. The procedure we call will raise an appropriate
// status if we are not able to allocate a new dirent
//
if (Dirent == NULL) {
ByteOffset = FatCreateNewDirent( IrpContext,
Vcb->RootDcb,
1 );
FatPrepareWriteDirectoryFile( IrpContext,
Vcb->RootDcb,
ByteOffset,
sizeof(DIRENT),
&DirentBcb,
&Dirent,
FALSE,
TRUE,
&Status );
ASSERT( NT_SUCCESS( Status ));
} else {
//
// Just mark this guy dirty now.
//
FatSetDirtyBcb( IrpContext, DirentBcb, Vcb, TRUE );
}
//
// Now reconstruct the volume label dirent.
//
FatConstructLabelDirent( IrpContext,
Dirent,
&OemLabel );
//
// Unpin the Bcb here so that we will get any IO errors
// here before changing the VPB label.
//
FatUnpinBcb( IrpContext, DirentBcb );
FatUnpinRepinnedBcbs( IrpContext );
//
// Now set the upcased label in the VPB
//
RtlCopyMemory( &Vcb->Vpb->VolumeLabel[0],
&UpcasedLabel.Buffer[0],
UpcasedLabel.Length );
Vcb->Vpb->VolumeLabelLength = UpcasedLabel.Length;
} else {
//
// Otherwise we're trying to delete the label
// Locate the current volume label if there already is one
//
FatLocateVolumeLabel( IrpContext,
Vcb,
&Dirent,
&DirentBcb,
&ByteOffset );
//
// Check that we really got one
//
if (Dirent == NULL) {
try_return( Status = STATUS_SUCCESS );
}
//
// Now delete the current label.
//
Dirent->FileName[0] = FAT_DIRENT_DELETED;
ASSERT( (Vcb->RootDcb->Specific.Dcb.UnusedDirentVbo == 0xffffffff) ||
RtlAreBitsSet( &Vcb->RootDcb->Specific.Dcb.FreeDirentBitmap,
ByteOffset / sizeof(DIRENT),
1 ) );
RtlClearBits( &Vcb->RootDcb->Specific.Dcb.FreeDirentBitmap,
ByteOffset / sizeof(DIRENT),
1 );
FatSetDirtyBcb( IrpContext, DirentBcb, Vcb, TRUE );
//
// Unpin the Bcb here so that we will get any IO errors
// here before changing the VPB label.
//
FatUnpinBcb( IrpContext, DirentBcb );
FatUnpinRepinnedBcbs( IrpContext );
//
// Now set the label in the VPB
//
Vcb->Vpb->VolumeLabelLength = 0;
}
Status = STATUS_SUCCESS;
FatSortDirectory(IrpContext, Vcb->RootDcb);
try_exit: NOTHING;
} finally {
DebugUnwind( FatSetFsALabelInfo );
FatUnpinBcb( IrpContext, DirentBcb );
DebugTrace(-1, Dbg, "FatSetFsALabelInfo -> STATUS_SUCCESS\n", 0);
}
return Status;
}
BOOL NtdllBitmap::AreBitsSet( ULONG starting_index, ULONG length )
{
assert(RtlAreBitsSet != NULL);
return RtlAreBitsSet(this, starting_index, length);
}