/**
* Allocate a new BUF_SIZE buffer and add it to the queue specified by
* 'context' and 'streamId'.
*/
static void
queueNewBuffer(CUcontext context, uint32_t streamId)
{
size_t size = BUF_SIZE;
uint8_t *buffer = (uint8_t *)malloc(size+ALIGN_SIZE);
CUPTI_CALL(cuptiActivityEnqueueBuffer(context, streamId, ALIGN_BUFFER(buffer, ALIGN_SIZE), size));
}
/*
* Allocate a new buffer and add it to the queue specified by a CUDA context.
*
* @param cuCtx the CUDA context, specifying the queue
*
* @return pointer to the created buffer
*/
static uint8_t* vt_cuptiact_queueNewBuffer(CUcontext cuCtx)
{
uint8_t *buffer = (uint8_t *)malloc(vt_cuptiact_bufSize);
VT_CUPTI_CALL(cuptiActivityEnqueueBuffer(cuCtx, 0, ALIGN_BUFFER(buffer, 8),
vt_cuptiact_bufSize),
"cuptiActivityEnqueueBuffer");
return buffer;
}
/* Returns pointer to and size of free codec RAM. Aligns to CACHEALIGN_SIZE. */
void *codec_get_buffer_callback(size_t *size)
{
void *buf = &codecbuf[codec_size];
ssize_t s = CODEC_SIZE - codec_size;
if (s <= 0)
return NULL;
*size = s;
ALIGN_BUFFER(buf, *size, CACHEALIGN_SIZE);
return buf;
}
/* Initialize buffer manager */
void
buflib_init(struct buflib_context *ctx, void *buf, size_t size)
{
union buflib_data *bd_buf = buf;
/* Align on sizeof(buflib_data), to prevent unaligned access */
ALIGN_BUFFER(bd_buf, size, sizeof(union buflib_data));
size /= sizeof(union buflib_data);
/* The handle table is initialized with no entries */
ctx->handle_table = bd_buf + size;
ctx->last_handle = bd_buf + size;
ctx->first_free_handle = bd_buf + size - 1;
ctx->first_free_block = bd_buf;
ctx->buf_start = bd_buf;
/* A marker is needed for the end of allocated data, to make sure that it
* does not collide with the handle table, and to detect end-of-buffer.
*/
ctx->alloc_end = bd_buf;
ctx->compact = true;
}
BOOLEAN
BlReadSignature(
IN PCHAR DiskName,
IN BOOLEAN IsCdRom
)
/*++
Routine Description:
Given an ARC disk name, reads the MBR and adds its signature to the list of
disks.
Arguments:
Diskname - Supplies the name of the disk.
IsCdRom - Indicates whether the disk is a CD-ROM.
Return Value:
TRUE - Success
FALSE - Failure
--*/
{
PARC_DISK_SIGNATURE Signature;
UCHAR SectorBuffer[2048+256];
UCHAR Partition[100];
ULONG DiskId;
ULONG Status;
LARGE_INTEGER SeekValue;
PUCHAR Sector;
ULONG i;
ULONG Sum;
ULONG Count;
ULONG SectorSize;
if (IsCdRom) {
SectorSize = 2048;
} else {
SectorSize = 512;
}
Signature = BlAllocateHeap(sizeof(ARC_DISK_SIGNATURE));
if (Signature==NULL) {
return(FALSE);
}
Signature->ArcName = BlAllocateHeap(strlen(DiskName)+2);
if (Signature->ArcName==NULL) {
return(FALSE);
}
#if defined(_i386_)
//
// NTDETECT creates an "eisa(0)..." arcname for detected
// BIOS disks on an EISA machine. Change this to "multi(0)..."
// in order to be consistent with the rest of the system
// (particularly the arcname in boot.ini)
//
if (_strnicmp(DiskName,"eisa",4)==0) {
strcpy(Signature->ArcName,"multi");
strcpy(Partition,"multi");
strcat(Signature->ArcName,DiskName+4);
strcat(Partition,DiskName+4);
} else {
strcpy(Signature->ArcName, DiskName);
strcpy(Partition, DiskName);
}
#else
strcpy(Signature->ArcName, DiskName);
strcpy(Partition, DiskName);
#endif
strcat(Partition, "partition(0)");
Status = ArcOpen(Partition, ArcOpenReadOnly, &DiskId);
if (Status != ESUCCESS) {
return(TRUE);
}
//
// Read in the first sector
//
Sector = ALIGN_BUFFER(SectorBuffer);
if (IsCdRom) {
//
// For a CD-ROM, the interesting data starts at 0x8000.
//
SeekValue.QuadPart = 0x8000;
} else {
SeekValue.QuadPart = 0;
}
Status = ArcSeek(DiskId, &SeekValue, SeekAbsolute);
if (Status == ESUCCESS) {
Status = ArcRead(DiskId,
Sector,
SectorSize,
&Count);
}
ArcClose(DiskId);
if (Status != ESUCCESS) {
return(TRUE);
}
//
// Check to see whether this disk has a valid partition table signature or not.
//
if (((PUSHORT)Sector)[BOOT_SIGNATURE_OFFSET] != BOOT_RECORD_SIGNATURE) {
Signature->ValidPartitionTable = FALSE;
} else {
Signature->ValidPartitionTable = TRUE;
}
Signature->Signature = ((PULONG)Sector)[PARTITION_TABLE_OFFSET/2-1];
//
// compute the checksum
//
Sum = 0;
for (i=0; i<(SectorSize/4); i++) {
Sum += ((PULONG)Sector)[i];
}
Signature->CheckSum = ~Sum + 1;
InsertHeadList(&BlLoaderBlock->ArcDiskInformation->DiskSignatures,
&Signature->ListEntry);
return(TRUE);
}
PBL_DEVICE_ENTRY_TABLE
IsCdfsFileStructure (
IN ULONG DeviceId,
IN PVOID StructureContext
)
/*++
Routine Description:
This routine determines if the partition on the specified channel
contains a Cdfs file system volume.
Arguments:
DeviceId - Supplies the file table index for the device on which
read operations are to be performed.
StructureContext - Supplies a pointer to a Hpfs file structure context.
Return Value:
A pointer to the Cdfs entry table is returned if the partition is
recognized as containing a Cdfs volume. Otherwise, NULL is returned.
--*/
{
UCHAR UnalignedSector[CD_SECTOR_SIZE + 256];
PRAW_ISO_VD RawVd;
PRAW_DIR_REC RootDe;
UCHAR DescType;
UCHAR Version;
BOOLEAN IsoVol;
BOOLEAN HsgVol;
STRING IsoVolId;
STRING HsgVolId;
STRING DiskId;
ULONG DiskOffset;
//
// Capture in our global variable the Cdfs Structure context record
//
CdfsStructureContext = (PCDFS_STRUCTURE_CONTEXT)StructureContext;
RtlZeroMemory((PVOID)CdfsStructureContext, sizeof(CDFS_STRUCTURE_CONTEXT));
//
// Compute the properly aligned buffer for reading in cdrom
// sectors.
//
RawVd = ALIGN_BUFFER( UnalignedSector );
//
// Initialize the string Id's to match.
//
RtlInitString( &IsoVolId, ISO_VOL_ID );
RtlInitString( &HsgVolId, HSG_VOL_ID );
DiskId.Length = 5;
DiskId.MaximumLength = 5;
//
// We initially start at the first volume descriptor.
//
DiskOffset = FIRST_VD_SECTOR * CD_SECTOR_SIZE;
//
// We loop, reading in volume descriptors until we find either
// a primary, terminator or a sector that cannot contain either.
//
while (TRUE) {
//
// Initialize the Hsg boolean.
//
HsgVol = FALSE;
//
// Read the sector at our current position. Return NULL on an
// error
//
if (CdfsReadDisk( DeviceId,
DiskOffset,
CD_SECTOR_SIZE,
RawVd ) != ESUCCESS) {
return NULL;
}
//
// Compare the Id string in the volume descriptor with the Iso
// and Hsg values.
//
DiskId.Buffer = RVD_STD_ID( RawVd, TRUE );
IsoVol = (BOOLEAN)(CdfsCompareNames( &DiskId, &IsoVolId ) == EqualTo);
if (!IsoVol) {
//
// Repeat the test with the Hsg Id string.
//
DiskId.Buffer = RVD_STD_ID( RawVd, FALSE );
HsgVol = (BOOLEAN)(CdfsCompareNames( &DiskId, &HsgVolId ) == EqualTo);
//
// If neither, then return NULL.
//
if (!HsgVol) {
return NULL;
}
}
//
// Get the volume descriptor type and standard version number.
//
DescType = RVD_DESC_TYPE( RawVd, IsoVol );
Version = RVD_VERSION( RawVd, IsoVol );
//
// Return NULL, if the version is incorrect or this is a terminal
// volume descriptor.
//
if (Version != VERSION_1
|| DescType == VD_TERMINATOR) {
return NULL;
}
//
// If this is a primary volume descriptor, then our search is over.
//
if (DescType == VD_PRIMARY) {
//
// Update the fields of the Cdfs context structure that apply
// to the volume.
//
CdfsStructureContext->IsIsoVol = IsoVol;
CdfsStructureContext->LbnBlockSize = RVD_LB_SIZE( RawVd, IsoVol );
CdfsStructureContext->LogicalBlockCount = RVD_VOL_SIZE( RawVd, IsoVol );
//
// Get the information on the root directory and save it in
// the context structure.
//
RootDe = (PRAW_DIR_REC) (RVD_ROOT_DE( RawVd, IsoVol ));
CdfsGetDirectoryInfo( RootDe,
IsoVol,
&CdfsStructureContext->RootDirSectorOffset,
&CdfsStructureContext->RootDirDiskOffset,
&CdfsStructureContext->RootDirSize );
//
// Exit the loop.
//
break;
}
//
// Otherwise move to the next sector.
//
DiskOffset += CD_SECTOR_SIZE;
}
//
// Initialize the file entry table.
//
CdfsDeviceEntryTable.Open = CdfsOpen;
CdfsDeviceEntryTable.Close = CdfsClose;
CdfsDeviceEntryTable.Read = CdfsRead;
CdfsDeviceEntryTable.Seek = CdfsSeek;
CdfsDeviceEntryTable.Write = CdfsWrite;
CdfsDeviceEntryTable.GetFileInformation = CdfsGetFileInformation;
CdfsDeviceEntryTable.SetFileInformation = CdfsSetFileInformation;
CdfsDeviceEntryTable.BootFsInfo = &CdfsBootFsInfo;
//
// And return the address of the table to our caller.
//
return &CdfsDeviceEntryTable;
}
ARC_STATUS
CdfsSearchDirectory(
IN PSTRING Name,
OUT PBOOLEAN IsDirectory
)
/*++
Routine Description:
This routine walks through the current directory in the Cdfs
context structure, looking for a match for 'Name'. We will find
the first non-multi-extent, non-interleave file. We will ignore
any version number for the file. The details about the file, if
found, are stored in the Cdfs context structure.
Arguments:
Name - This is the name of the file to search for.
IsDirectory - Supplies the address of a boolean where we store
whether this is or is not a directory.
Return Value:
ESUCCESS is returned if the operation is successful. Otherwise,
an unsuccessful status is returned that describes the reason for failure.
--*/
{
ARC_STATUS Status;
ULONG SectorOffset;
ULONG SectorDiskOffset;
ULONG DirentOffset;
ULONG RemainingBytes;
BOOLEAN ReadSector;
BOOLEAN SearchForMultiEnd;
UCHAR UnalignedBuffer[CD_SECTOR_SIZE + 256];
PUCHAR RawSector;
PRAW_DIR_REC RawDe;
COMPARISON_RESULTS ComparisonResult;
//
// Initialize the local variables.
//
RawSector = ALIGN_BUFFER( UnalignedBuffer );
SearchForMultiEnd = FALSE;
//
// Remember where we are within the disk, sector and directory file.
//
SectorOffset = CdfsStructureContext->DirSectorOffset;
SectorDiskOffset = CdfsStructureContext->DirDiskOffset - SectorOffset;
DirentOffset = 0;
ReadSector = FALSE;
//
// If this is the root directory, then we can return immediately.
//
if (Name->Length == 1
&& *Name->Buffer == '\\') {
*IsDirectory = TRUE;
//
// The structure context is already filled in.
//
return ESUCCESS;
}
//
// Compute the remaining bytes in this sector.
//
RemainingBytes = CD_SECTOR_SIZE - SectorOffset;
//
// Loop until the directory is exhausted or a matching dirent for the
// target name is found.
//
while (TRUE) {
//
// If the current offset is beyond the end of the directory,
// raise an appropriate status.
//
if (DirentOffset >= CdfsStructureContext->DirSize) {
return ENOENT;
}
//
// If the remaining bytes in this sector is less than the
// minimum needed for a dirent, then move to the next sector.
//
if (RemainingBytes < MIN_DIR_REC_SIZE) {
SectorDiskOffset += CD_SECTOR_SIZE;
DirentOffset += RemainingBytes;
SectorOffset = 0;
RemainingBytes = CD_SECTOR_SIZE;
ReadSector = FALSE;
continue;
}
//
// If we have not read in the sector, do so now.
//
if (!ReadSector) {
Status = CdfsReadDisk( CdfsFileTableEntry->DeviceId,
SectorDiskOffset,
CD_SECTOR_SIZE,
RawSector );
if (Status != ESUCCESS) {
return Status;
}
ReadSector = TRUE;
}
//
// If the first byte of the next dirent is '\0', then we move to
// the next sector.
//
if (*(RawSector + SectorOffset) == '\0') {
SectorDiskOffset += CD_SECTOR_SIZE;
DirentOffset += RemainingBytes;
SectorOffset = 0;
RemainingBytes = CD_SECTOR_SIZE;
ReadSector = FALSE;
continue;
}
RawDe = (PRAW_DIR_REC) ((PUCHAR) RawSector + SectorOffset);
//
// If the size of this dirent extends beyond the end of this sector
// we abort the search.
//
if ((ULONG)RawDe->DirLen > RemainingBytes) {
return EINVAL;
}
//
// We have correctly found the next dirent. We first check whether
// we are looking for the last dirent for a multi-extent.
//
if (SearchForMultiEnd) {
//
// If this is the last of a multi-extent we change our search
// state.
//
if (!FlagOn( DE_FILE_FLAGS( CdfsStructureContext->IsIsoVol, RawDe ),
ISO_ATTR_MULTI )) {
SearchForMultiEnd = TRUE;
}
//
// If this is a multi-extent dirent, we change our search state.
//
} else if (FlagOn( DE_FILE_FLAGS( CdfsStructureContext->IsIsoVol, RawDe ),
ISO_ATTR_MULTI )) {
SearchForMultiEnd = TRUE;
//
// If this is a file match, we update the Cdfs context structure
// and the 'IsDirectory' flag.
//
} else {
ComparisonResult = CdfsFileMatch( RawDe, Name );
if (ComparisonResult == EqualTo) {
CdfsGetDirectoryInfo( RawDe,
CdfsStructureContext->IsIsoVol,
&CdfsStructureContext->DirSectorOffset,
&CdfsStructureContext->DirDiskOffset,
&CdfsStructureContext->DirSize );
*IsDirectory = FlagOn( DE_FILE_FLAGS( CdfsStructureContext->IsIsoVol, RawDe ),
ISO_ATTR_DIRECTORY );
return ESUCCESS;
//
// If we have passed this file in the directory, then
// exit with the appropriate error code.
//
} else if (ComparisonResult == GreaterThan) {
return ENOENT;
}
}
//
// Otherwise we simply compute the next sector offset, disk offset
// and file offset.
//
SectorOffset += RawDe->DirLen;
DirentOffset += RawDe->DirLen;
RemainingBytes -= RawDe->DirLen;
}
return ESUCCESS;
}
/* Initialized the OSD and set its backbuffer */
static bool _osd_init(struct osd *osd, unsigned flags, void *backbuf,
size_t backbuf_size, osd_draw_cb_fn_t draw_cb,
int *width, int *height, size_t *bufused)
{
_osd_destroy(osd);
if (!draw_cb)
return false;
if (!backbuf)
return false;
void *backbuf_orig = backbuf; /* Save in case of ptr advance */
ALIGN_BUFFER(backbuf, backbuf_size, MAX(FB_DATA_SZ, 4));
if (!backbuf_size)
return false;
if (flags & OSD_INIT_MAJOR_HEIGHT)
{
if (!height || *height <= 0)
return false;
if ((flags & (OSD_INIT_MINOR_MIN | OSD_INIT_MINOR_MAX)) &&
(!width || *width <= 0))
{
return false;
}
}
else
{
if (!width || *width <= 0)
return false;
if ((flags & (OSD_INIT_MINOR_MIN | OSD_INIT_MINOR_MAX)) &&
(!height || *height <= 0))
{
return false;
}
}
/* Store requested sizes in max(width|height) */
if (width)
osd->maxwidth = *width;
else
osd->maxwidth = LCD_WIDTH;
if (height)
osd->maxheight = *height;
else
osd->maxheight = LCD_HEIGHT;
if (!osd->init_buffers(osd, flags, backbuf, &backbuf_size))
{
osd->maxwidth = osd->maxheight = 0;
return false;
}
osd->draw_cb = draw_cb;
if (bufused)
*bufused = backbuf_size + (backbuf_orig - backbuf);
if (width)
*width = osd->maxwidth;
if (height)
*height = osd->maxheight;
/* Set the default position to the whole thing */
osd->set_viewport_pos(&osd->vp, 0, 0, osd->maxwidth, osd->maxheight);
osd->status = OSD_HIDDEN; /* Ready when you are */
return true;
}
