ExFastExtractTcb::~ExFastExtractTcb()
{
// Release resources acquired
//
freeResources();
delete qParent_.up;
delete qParent_.down;
if (workAtp_)
{
workAtp_->release();
deallocateAtp(workAtp_, getSpace());
}
if (inSqlBuffer_ && getHeap())
{
getHeap()->deallocateMemory(inSqlBuffer_);
inSqlBuffer_ = NULL;
childOutputTD_ = NULL;
}
if (sourceFieldsConvIndex_)
getHeap()->deallocateMemory(sourceFieldsConvIndex_);
} // ExFastExtractTcb::~ExFastExtractTcb()
ExExeUtilTcb::~ExExeUtilTcb()
{
delete qparent_.up;
delete qparent_.down;
if (workAtp_)
{
workAtp_->release();
deallocateAtp(workAtp_, getGlobals()->getSpace());
workAtp_ = NULL;
}
freeResources();
if (extractedPartsObj_)
{
delete extractedPartsObj_;
extractedPartsObj_ = NULL;
}
if (explQuery_)
NADELETEBASIC(explQuery_, getHeap());
if (childQueryId_ != NULL)
{
NADELETEBASIC(childQueryId_, getHeap());
childQueryId_ = NULL;
childQueryIdLen_ = 0;
}
if (outputBuf_ != NULL)
{
NADELETEBASIC(outputBuf_, getHeap());
outputBuf_ = NULL;
outputBuf_ = 0;
}
};
void CmpMessageEnvs::unpackMyself(IpcMessageObjType objType,
IpcMessageObjVersion objVersion,
NABoolean sameEndianness,
IpcMessageObjSize objSize,
IpcConstMessageBufferPtr& buffer)
{
CmpMessageObj::unpackMyself(objType, objVersion, sameEndianness,
objSize, buffer);
::unpackBuffer(buffer, operator_);
::unpackBuffer(buffer, nEnvs_);
if (nEnvs_)
{
envs_ = new(getHeap()) char*[nEnvs_];
for (Int32 i=0; i < nEnvs_; i++)
{
envs_[i] = 0;
unpackBuffer(buffer, envs_[i],getHeap());
}
}
else
envs_ = 0;
unpackBuffer(buffer, cwd_, getHeap());
::unpackBuffer(buffer, activeTrans_);
unpackBuffer(buffer, transId_);
}
void ExMsgResourceInfo::unpackObj(IpcMessageObjType objType,
IpcMessageObjVersion objVersion,
NABoolean sameEndianness,
IpcMessageObjSize objSize,
IpcConstMessageBufferPtr buffer)
{
ExScratchFileOptions *sfo;
IpcConstMessageBufferPtr start = buffer;
ex_assert(objType == ESP_RESOURCE_INFO AND
objVersion == 100 AND
sameEndianness AND
objSize > sizeof(IpcMessageObj),
"invalid type or version for ExMsgResourceInfo::unpackObj()");
unpackBaseClass(buffer);
str_cpy_all((char *) &totalNameLength_,buffer,sizeof(totalNameLength_));
buffer += sizeof(totalNameLength_);
buffer += sizeof(spare_);
if (bufferForDependentObjects_)
{
getHeap()->deallocateMemory(bufferForDependentObjects_);
bufferForDependentObjects_ = NULL;
}
sfo = new(getHeap()) ExScratchFileOptions;
// sfo_ is const
sfo_ = sfo;
sfo->ipcUnpackObj(objSize - (buffer-start),
buffer,
getHeap(),
totalNameLength_,
bufferForDependentObjects_);
}
void HdfsClient::setPath(const char *path)
{
if (path_ != NULL)
NADELETEBASIC(path_, getHeap());
short len = strlen(path);
path_ = new (getHeap()) char[len+1];
strcpy(path_, path);
}
ExMsgFragment::~ExMsgFragment()
{
if (f_.queryId_ != NULL)
getHeap()->deallocateMemory(f_.queryId_);
if (f_.userName_ != NULL)
getHeap()->deallocateMemory(f_.userName_);
if (f_.iOwnTheFragment_)
getHeap()->deallocateMemory(fragment_);
}
void CmpMessageRequest::destroyMe()
{
NADELETEBASIC(data_, getHeap());
if (allocated_ && parentQid_ != NULL)
{
NADELETEBASIC(parentQid_, getHeap());
parentQid_ = NULL;
parentQidLen_ = 0;
}
}
// destructor.
ExMsgSecurityInfo::~ExMsgSecurityInfo()
{
if (getHeap()) // members were allocated on this heap
{
getHeap()->deallocateMemory((void *)securityKey_);
getHeap()->deallocateMemory(authid_);
securityKey_ = NULL;
authid_ = NULL;
}
}
// The recipient of this object (connectionStream's actOnReceive)
// will unpack this object in unbuffered stream, whose unpacking
// function would have already unpacked the base class before getting
// here. So, do not unpack the base class here.
void ExMsgSecurityInfo::unpackObj(IpcMessageObjType objType,
IpcMessageObjVersion objVersion,
NABoolean sameEndianness,
IpcMessageObjSize objSize,
IpcConstMessageBufferPtr buffer)
{
buffer += sizeof(IpcMessageObj);
unpackBuffer(buffer,securityKey_, getHeap());
unpackBuffer(buffer,authid_, getHeap());
}
void CmpMessageISPRequest::destroyMe()
{
if (allocated_)
{
NADELETEBASIC(procName_, getHeap());
NADELETEBASIC((char*)inputExpr_, getHeap());
NADELETEBASIC((char*)outputExpr_, getHeap());
NADELETEBASIC((char*)keyExpr_, getHeap());
NADELETEBASIC((char*)inputData_, getHeap());
}
}
void HdfsClient::deleteHdfsFileInfo()
{
for (int i = 0; i < numFiles_ ; i ++) {
NADELETEBASIC(hdfsFileInfo_[i].mName, getHeap());
NADELETEBASIC(hdfsFileInfo_[i].mOwner, getHeap());
NADELETEBASIC(hdfsFileInfo_[i].mGroup, getHeap());
}
if (hdfsFileInfo_ != NULL)
NADELETEBASICARRAY(hdfsFileInfo_, getHeap());
numFiles_ = 0;
hdfsFileInfo_ = NULL;
}
void tenkListChunks(PVOID heapHandle) {
struct HPool *heap;
struct DestroyStruct dStruct;
struct HeapChunk *curChunk;
ULONG i;
heap = getHeap(&heapModel, heapHandle);
dprintf("[T] Currently tracking %d chunks for heap 0x%08x\n",
heap->numChunks, heap->base);
i = heap->inUseHead;
while (i != NULLNODE) {
if (CHUNK(i).inUse) {
dprintf("\tAddress: 0x%08x\tSize: 0x%08x", CHUNK(i).addr, CHUNK(i).size);
dprintf("\tFlags: 0x%08x\t%s\n\n", CHUNK(i).flags,
(CHUNK(i).free)?"FREE'D":"IN USE");
}
i = CHUNK(i).nextInUse;
}
if (heap->numChunks == 0) {
dStruct.heapHandle = heap->base;
heapDestroy(&heapModel, &dStruct);
}
}
HdfsClient::~HdfsClient()
{
QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::~HdfsClient() called.");
deleteHdfsFileInfo();
if (path_ != NULL)
NADELETEBASIC(path_, getHeap());
}
static u32 sceHeapAllocHeapMemoryWithOption(u32 heapAddr, u32 memSize, u32 paramsPtr) {
Heap *heap = getHeap(heapAddr);
u32 grain = 4;
if (!heap) {
ERROR_LOG(HLE, "sceHeapAllocHeapMemoryWithOption(%08x, %08x, %08x): invalid heap", heapAddr, memSize, paramsPtr);
return 0;
}
// 0 is ignored.
if (paramsPtr != 0) {
u32 size = Memory::Read_U32(paramsPtr);
if (size < 8) {
ERROR_LOG(HLE, "sceHeapAllocHeapMemoryWithOption(%08x, %08x, %08x): invalid param size", heapAddr, memSize, paramsPtr);
return 0;
}
if (size > 8) {
WARN_LOG_REPORT(HLE, "sceHeapAllocHeapMemoryWithOption(): unexpected param size %d", size);
}
grain = Memory::Read_U32(paramsPtr + 4);
}
DEBUG_LOG(HLE,"sceHeapAllocHeapMemoryWithOption(%08x, %08x, %08x)", heapAddr, memSize, paramsPtr);
// There's 8 bytes at the end of every block, reserved.
memSize += 8;
u32 addr = heap->alloc.AllocAligned(memSize, grain, grain, true);
return addr;
}
sp<IMemoryHeap> GPURegisterHeap::MemoryHeapRegs::GPUHandle::getMemory(
ssize_t* offset, size_t* size) const
{
sp<MemoryHeapPmem> heap = getHeap();
if (offset) *offset = 0;
if (size) *size = heap !=0 ? heap->virtualSize() : 0;
return heap;
}
void tenkValidate(PVOID heapHandle) {
struct HPool *heap;
struct DestroyStruct dStruct;
struct HeapChunk *curChunk;
ULONG chunkPtr;
ULONG i, nextIndex;
BOOL screwed = FALSE;
heap = getHeap(&heapModel, heapHandle);
i = heap->inUseHead;
while (i != NULLNODE) {
if (CHUNK(i).free) {
// CHUNK(i).nextInUse must be equal to the next ptr
if(!ReadMemory((ULONG64)(CHUNK(i).addr)+4, (PVOID) &chunkPtr, 4, NULL)) {
dprintf("[T] Unable to read memory at address 0x%08x\n!");
return;
}
// Find next free chunk - continue if there are no more
nextIndex = CHUNK(i).nextInUse;
while (nextIndex != NULLNODE && !(CHUNK(nextIndex).free))
nextIndex = CHUNK(nextIndex).nextInUse;
if (nextIndex == NULLNODE) {
i = CHUNK(i).nextInUse;
continue;
}
// Validate next free chunk
if (CHUNK(nextIndex).addr != (PVOID) chunkPtr) {
dprintf("[T] Corruped next pointer for chunk at 0x%08x\n", CHUNK(i).addr);
dprintf(">\tGot: 0x%08x\tExpected: 0x%08x\n", chunkPtr, CHUNK(nextIndex).addr);
screwed = TRUE;
}
// next free chunk prev, must equal CHUNK(i).addr
if(!ReadMemory((ULONG64)CHUNK(nextIndex).addr, (PVOID) &chunkPtr, 4, NULL)) {
dprintf("[T] Unable to read memory at address 0x%08x\n!");
return;
}
if ((PVOID) chunkPtr != CHUNK(i).addr) {
dprintf("[T] Corruped prev pointer for chunk at 0x%08x\n", CHUNK(nextIndex).addr);
dprintf(">\tGot: 0x%08x\tExpected: 0x%08x\n", chunkPtr, CHUNK(i).addr);
screwed = TRUE;
}
} else {
}
i = CHUNK(i).nextInUse;
}
dprintf("[T] Validation complete: ");
if (!screwed)
dprintf("all known free chunks are correct\n");
else
dprintf("errors found\n");
}
void CmpMessageRequest::copyToString(char* &dest, CmpMsgBufLenType& sz,
char* source, CmpMsgBufLenType sz1)
{
NADELETEBASIC(dest, getHeap());
if ( source )
{
sz = sz1 + 1;
dest = new (getHeap()) char[sz];
#pragma nowarn(1506) // warning elimination
str_cpy_all(dest, source, sz1);
#pragma warn(1506) // warning elimination
dest[sz1] = 0;
}
else
{
sz = 0;
dest = 0;
}
}
//
// This function frees any resources acquired.
// It should only be called by the TCB destructor.
//
void ExFastExtractTcb::freeResources()
{
for(Int16 i=0; i < numBuffers_; i++)
{
if(bufferPool_[i])
{
NADELETE(bufferPool_[i], IOBuffer, getHeap());
bufferPool_[i] = NULL;
}
}
}
HDFS_Client_RetCode HdfsClient::setHdfsFileInfo(JNIEnv *jenv, jint numFiles, jint fileNo, jboolean isDir,
jstring filename, jlong modTime, jlong len, jshort numReplicas, jlong blockSize,
jstring owner, jstring group, jshort permissions, jlong accessTime)
{
HDFS_FileInfo *hdfsFileInfo;
if (fileNo == 0 && hdfsFileInfo_ != NULL)
deleteHdfsFileInfo();
if (hdfsFileInfo_ == NULL) {
hdfsFileInfo_ = new (getHeap()) HDFS_FileInfo[numFiles];
numFiles_ = numFiles;
}
if (fileNo >= numFiles_)
return HDFS_CLIENT_ERROR_SET_HDFSFILEINFO;
hdfsFileInfo = &hdfsFileInfo_[fileNo];
if (isDir)
hdfsFileInfo->mKind = HDFS_DIRECTORY_KIND;
else
hdfsFileInfo->mKind = HDFS_FILE_KIND;
hdfsFileInfo->mLastMod = modTime;
hdfsFileInfo->mSize = len;
hdfsFileInfo->mReplication = numReplicas;
hdfsFileInfo->mBlockSize = blockSize;
hdfsFileInfo->mPermissions = permissions;
hdfsFileInfo->mLastAccess = accessTime;
jint tempLen = jenv->GetStringUTFLength(filename);
hdfsFileInfo->mName = new (getHeap()) char[tempLen+1];
strncpy(hdfsFileInfo->mName, jenv->GetStringUTFChars(filename, NULL), tempLen);
hdfsFileInfo->mName[tempLen] = '\0';
tempLen = jenv->GetStringUTFLength(owner);
hdfsFileInfo->mOwner = new (getHeap()) char[tempLen+1];
strncpy(hdfsFileInfo->mOwner, jenv->GetStringUTFChars(owner, NULL), tempLen);
hdfsFileInfo->mOwner[tempLen] = '\0';
tempLen = jenv->GetStringUTFLength(group);
hdfsFileInfo->mGroup = new (getHeap()) char[tempLen+1];
strncpy(hdfsFileInfo->mGroup, jenv->GetStringUTFChars(group, NULL), tempLen);
hdfsFileInfo->mGroup[tempLen] = '\0';
return HDFS_CLIENT_OK;
}
static int sceHeapDeleteHeap(u32 heapAddr) {
Heap *heap = getHeap(heapAddr);
if (!heap) {
ERROR_LOG(HLE, "sceHeapDeleteHeap(%08x): invalid heap", heapAddr);
return SCE_KERNEL_ERROR_INVALID_ID;
}
DEBUG_LOG(HLE, "sceHeapDeleteHeap(%08x)", heapAddr);
heapList.erase(heapAddr);
delete heap;
return 0;
}
short ExExeUtilLongRunningTcb::finalizeDoLongRunning()
{
// Close the statements
Lng32 rc = cliInterface()->prepareAndExecRowsEpilogue();
NADELETE(initialOutputVarPtrList_, Queue, getHeap());
NADELETE(continuingOutputVarPtrList_, Queue, getHeap());
NADELETEBASIC(lruStmtAndPartInfo_, getHeap());
NADELETEBASIC(lruStmtWithCKAndPartInfo_, getHeap());
// if this is an ESP, deallocate transaction
CliGlobals *cliGlobals = GetCliGlobals();
if (cliGlobals->isESPProcess())
{
NADELETEBASIC(currTransaction_, getHeap());
currTransaction_ = NULL;
}
return 0;
}
void CmpMessageISPRequest::unpackMyself(IpcMessageObjType objType,
IpcMessageObjVersion objVersion,
NABoolean sameEndianness,
IpcMessageObjSize objSize,
IpcConstMessageBufferPtr& buffer)
{
allocated_ = TRUE; // so that the allocated storages will be destroyed later.
CmpMessageRequest::unpackMyself(objType, objVersion, sameEndianness,
objSize, buffer);
unpackBuffer(buffer, procName_, getHeap());
::unpackBuffer(buffer, inputExprSize_);
unpackBuffer(buffer, inputExpr_, getHeap());
::unpackBuffer(buffer, outputExprSize_);
unpackBuffer(buffer, outputExpr_, getHeap());
::unpackBuffer(buffer, keyExprSize_);
unpackBuffer(buffer, keyExpr_, getHeap());
::unpackBuffer(buffer, inputDataSize_);
unpackBuffer(buffer, inputData_, getHeap());
::unpackBuffer(buffer, outputRowSize_);
::unpackBuffer(buffer, outputTotalSize_);
}
void CmpMessageRequest::unpackMyself(IpcMessageObjType objType,
IpcMessageObjVersion objVersion,
NABoolean sameEndianness,
IpcMessageObjSize objSize,
IpcConstMessageBufferPtr& buffer)
{
CmpMessageRequestBasic::unpackMyself(objType, objVersion, sameEndianness,
objSize, buffer);
::unpackBuffer(buffer, sz_);
::unpackBuffer(buffer, flags_);
::unpackBuffer(buffer, charSet_);
unpackBuffer(buffer, data_, getHeap());
::unpackBuffer(buffer, parentQidLen_);
if (parentQidLen_ != 0)
{
allocated_ = TRUE;
parentQid_ = new ((NAHeap *)(getHeap())) char[parentQidLen_+1];
unpackStrFromBuffer(buffer, (char *)parentQid_, parentQidLen_);
*((char *)(parentQid_+ parentQidLen_)) = '\0';
}
}
short ExExeUtilTcb::getObjectUid(char * catName, char * schName,
char * objName,
NABoolean isIndex, NABoolean isMv,
char* uid)
{
Lng32 cliRC = 0;
ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
ExExeUtilPrivateState & pstate =
*((ExExeUtilPrivateState*) pentry_down->pstate);
ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
const QueryString * qs;
Int32 sizeOfqs = 0;
versionStrLen_ = 0;
qs = getObjectUidQuery;
sizeOfqs = sizeof(getObjectUidQuery);
Int32 qryArraySize = sizeOfqs / sizeof(QueryString);
char * gluedQuery;
Lng32 gluedQuerySize;
glueQueryFragments(qryArraySize, qs,
gluedQuery, gluedQuerySize);
Lng32 extraSpace = 10 /*segment name*/+ ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES/*cat/sch/obj name in UTF8*/ + 100;
char * infoQuery =
new(getHeap()) char[gluedQuerySize + extraSpace + 1];
str_sprintf(infoQuery, gluedQuery,
catName, schName, objName,
(isIndex ? "IX" : "TA"),
(isMv ? "MV" : (isIndex ? "IX" : "BT")));
NADELETEBASIC(gluedQuery, getMyHeap());
Lng32 uidLen;
cliRC =
cliInterface()->executeImmediate(infoQuery,
uid, &uidLen);
if (cliRC < 0)
{
cliInterface()->retrieveSQLDiagnostics(getDiagsArea());
return -1;
}
uid[uidLen] = 0;
return 0;
}
ExHdfsFastExtractTcb::~ExHdfsFastExtractTcb()
{
if (lobGlob_ != NULL)
{
lobGlob_ = NULL;
}
if (sequenceFileWriter_ != NULL) {
NADELETE(sequenceFileWriter_, SequenceFileWriter, getHeap());
}
} // ExHdfsFastExtractTcb::~ExHdfsFastExtractTcb()
void ExMsgTimeoutData::unpackObj(IpcMessageObjType objType,
IpcMessageObjVersion objVersion,
NABoolean sameEndianness,
IpcMessageObjSize objSize,
IpcConstMessageBufferPtr buffer)
{
IpcConstMessageBufferPtr start = buffer;
ex_assert(objType == ESP_TIMEOUT_DATA AND
objVersion == 100 AND
sameEndianness AND
objSize > sizeof(IpcMessageObj),
"invalid type or version for ExMsgTimeoutData::unpackObj()");
unpackBaseClass(buffer);
timeoutData_ = new ( getHeap() ) TimeoutData( getHeap() ) ;
timeoutData_->unpackObj(buffer);
iOwnTD_ = TRUE; // on the ESP side; I own the newly allocated timeoutData_
}
short ExExeUtilHiveQueryTcb::work()
{
short rc = 0;
Lng32 cliRC = 0;
if (qparent_.down->isEmpty())
return WORK_OK;
if (qparent_.up->isFull())
return WORK_OK;
ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
ExExeUtilPrivateState & pstate = *((ExExeUtilPrivateState*) pentry_down->pstate);
while (1)
{
switch (step_)
{
case INITIAL_:
{
step_ = PROCESS_QUERY_;
}
break;
case PROCESS_QUERY_:
{
if (HiveClient_JNI::executeHiveSQL(htTdb().getHiveQuery()) != HVC_OK)
{
ExRaiseSqlError(getHeap(), &diagsArea_, -1214,
NULL, NULL, NULL,
getSqlJniErrorStr(), htTdb().getHiveQuery());
step_ = ERROR_;
break;
}
step_ = DONE_;
}
break;
case ERROR_:
{
if (handleError())
return WORK_OK;
step_ = DONE_;
}
break;
case DONE_:
{
if (handleDone())
return WORK_OK;
step_ = INITIAL_;
return WORK_OK;
}
break;
} // switch
} // while
}
SeqGenEntry * SequenceValueGenerator::getEntry(SequenceGeneratorAttributes &sga)
{
Int64 hashVal = sga.getSGObjectUID().get_value();
sgQueue()->position((char*)&hashVal, sizeof(hashVal));
SeqGenEntry * sge = NULL;
while ((sge = (SeqGenEntry *)sgQueue()->getNext()) != NULL)
{
if (sge->getSGObjectUID() == hashVal)
break;
}
if (! sge)
{
sge = new(getHeap()) SeqGenEntry(hashVal, getHeap());
sgQueue()->insert((char*)&hashVal, sizeof(hashVal), sge);
}
sge->setRetryNum(getRetryNum());
return sge;
}
Allocation::~Allocation()
{
size_t freedOffset = getOffset();
size_t freedSize = getSize();
if (freedSize) {
/* NOTE: it's VERY important to not free allocations of size 0 because
* they're special as they don't have any record in the allocator
* and could alias some real allocation (their offset is zero). */
// keep the size to unmap in excess
size_t pagesize = getpagesize();
size_t start = freedOffset;
size_t end = start + freedSize;
start &= ~(pagesize-1);
end = (end + pagesize-1) & ~(pagesize-1);
// give back to the kernel the pages we don't need
size_t free_start = freedOffset;
size_t free_end = free_start + freedSize;
if (start < free_start)
start = free_start;
if (end > free_end)
end = free_end;
start = (start + pagesize-1) & ~(pagesize-1);
end &= ~(pagesize-1);
if (start < end) {
void* const start_ptr = (void*)(intptr_t(getHeap()->base()) + start);
size_t size = end-start;
#ifndef NDEBUG
memset(start_ptr, 0xdf, size);
#endif
// MADV_REMOVE is not defined on Dapper based Goobuntu
#ifdef MADV_REMOVE
if (size) {
int err = madvise(start_ptr, size, MADV_REMOVE);
ALOGW_IF(err, "madvise(%p, %u, MADV_REMOVE) returned %s",
start_ptr, size, err<0 ? strerror(errno) : "Ok");
}
#endif
}
// This should be done after madvise(MADV_REMOVE), otherwise madvise()
// might kick out the memory region that's allocated and/or written
// right after the deallocation.
mDealer->deallocate(freedOffset);
}
}
Timer* TimerMinHeap::removeFromIndex (UINT32& index)
{
// first, flip the top of the minheap with the bottom of the minheap, found in minheap [numberOfTimersBeingManaged]
Timer** minheap = getHeap ();
UINT32 parent = index;
Timer* pTimer = minheap [parent];
minheap [parent] = minheap [getNumberOfTimers () - 1]; // Disrupt the minheap property
decNumberOfTimers ();
downHeapifyFromIndex (index);
COUT << "TimerMinHeap:: Removed item at index = " << index << endl;
return pTimer;
}