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); }