static void
initProfilingLogFile(void)
{
char *prog;
prog = arenaAlloc(prof_arena, strlen(prog_name) + 1);
strcpy(prog, prog_name);
#ifdef mingw32_HOST_OS
// on Windows, drop the .exe suffix if there is one
{
char *suff;
suff = strrchr(prog,'.');
if (suff != NULL && !strcmp(suff,".exe")) {
*suff = '\0';
}
}
#endif
if (RtsFlags.CcFlags.doCostCentres == 0 &&
RtsFlags.ProfFlags.doHeapProfile != HEAP_BY_RETAINER &&
RtsFlags.ProfFlags.retainerSelector == NULL)
{
/* No need for the <prog>.prof file */
prof_filename = NULL;
prof_file = NULL;
}
else
{
/* Initialise the log file name */
prof_filename = arenaAlloc(prof_arena, strlen(prog) + 6);
sprintf(prof_filename, "%s.prof", prog);
/* open the log file */
if ((prof_file = fopen(prof_filename, "w")) == NULL) {
debugBelch("Can't open profiling report file %s\n", prof_filename);
RtsFlags.CcFlags.doCostCentres = 0;
// The following line was added by Sung; retainer/LDV profiling may need
// two output files, i.e., <program>.prof/hp.
if (RtsFlags.ProfFlags.doHeapProfile == HEAP_BY_RETAINER)
RtsFlags.ProfFlags.doHeapProfile = 0;
return;
}
}
if (RtsFlags.ProfFlags.doHeapProfile) {
/* Initialise the log file name */
hp_filename = arenaAlloc(prof_arena, strlen(prog) + 6);
sprintf(hp_filename, "%s.hp", prog);
/* open the log file */
if ((hp_file = fopen(hp_filename, "w")) == NULL) {
debugBelch("Can't open profiling report file %s\n",
hp_filename);
RtsFlags.ProfFlags.doHeapProfile = 0;
return;
}
}
}
static void
initProfilingLogFile(void)
{
char *prog;
prog = arenaAlloc(prof_arena, strlen(prog_name) + 1);
strcpy(prog, prog_name);
#ifdef mingw32_HOST_OS
// on Windows, drop the .exe suffix if there is one
{
char *suff;
suff = strrchr(prog,'.');
if (suff != NULL && !strcmp(suff,".exe")) {
*suff = '\0';
}
}
#endif
if (RtsFlags.CcFlags.doCostCentres == 0 && !doingRetainerProfiling())
{
/* No need for the <prog>.prof file */
prof_filename = NULL;
prof_file = NULL;
}
else
{
/* Initialise the log file name */
prof_filename = arenaAlloc(prof_arena, strlen(prog) + 6);
sprintf(prof_filename, "%s.prof", prog);
/* open the log file */
if ((prof_file = fopen(prof_filename, "w")) == NULL) {
debugBelch("Can't open profiling report file %s\n", prof_filename);
RtsFlags.CcFlags.doCostCentres = 0;
// Retainer profiling (`-hr` or `-hr<cc> -h<x>`) writes to
// both <program>.hp as <program>.prof.
if (doingRetainerProfiling()) {
RtsFlags.ProfFlags.doHeapProfile = 0;
}
}
}
if (RtsFlags.ProfFlags.doHeapProfile) {
/* Initialise the log file name */
hp_filename = arenaAlloc(prof_arena, strlen(prog) + 6);
sprintf(hp_filename, "%s.hp", prog);
/* open the log file */
if ((hp_file = fopen(hp_filename, "w")) == NULL) {
debugBelch("Can't open profiling report file %s\n",
hp_filename);
RtsFlags.ProfFlags.doHeapProfile = 0;
}
}
}
void
LDV_recordDead( StgClosure *c, nat size )
{
void *id;
nat t;
counter *ctr;
if (era > 0 && closureSatisfiesConstraints(c)) {
size -= sizeofW(StgProfHeader);
ASSERT(LDVW(c) != 0);
if ((LDVW((c)) & LDV_STATE_MASK) == LDV_STATE_CREATE) {
t = (LDVW((c)) & LDV_CREATE_MASK) >> LDV_SHIFT;
if (t < era) {
if (RtsFlags.ProfFlags.bioSelector == NULL) {
censuses[t].void_total += (long)size;
censuses[era].void_total -= (long)size;
ASSERT(censuses[t].void_total < censuses[t].not_used);
} else {
id = closureIdentity(c);
ctr = lookupHashTable(censuses[t].hash, (StgWord)id);
ASSERT( ctr != NULL );
ctr->c.ldv.void_total += (long)size;
ctr = lookupHashTable(censuses[era].hash, (StgWord)id);
if (ctr == NULL) {
ctr = arenaAlloc(censuses[era].arena, sizeof(counter));
initLDVCtr(ctr);
insertHashTable(censuses[era].hash, (StgWord)id, ctr);
ctr->identity = id;
ctr->next = censuses[era].ctrs;
censuses[era].ctrs = ctr;
}
ctr->c.ldv.void_total -= (long)size;
}
}
} else {
void setFieldBasicConstraints(
DecodedItem &cert,
const CssmData &fieldValue)
{
CSSM_X509_EXTENSION_PTR cssmExt =
verifySetFreeExtension(fieldValue, false);
CE_BasicConstraints *cdsaObj =
(CE_BasicConstraints *)cssmExt->value.parsedValue;
/* Alloc an NSS-style BasicConstraints in cert.coder's memory */
SecNssCoder &coder = cert.coder();
NSS_BasicConstraints *nssObj =
(NSS_BasicConstraints *)coder.malloc(sizeof(NSS_BasicConstraints));
memset(nssObj, 0, sizeof(*nssObj));
/* cdsaObj --> nssObj */
ArenaAllocator arenaAlloc(coder);
clCssmBoolToNss(cdsaObj->cA, nssObj->cA, arenaAlloc);
if(cdsaObj->pathLenConstraintPresent) {
clIntToData(cdsaObj->pathLenConstraint,
nssObj->pathLenConstraint, arenaAlloc);
}
/* add to mExtensions */
cert.addExtension(nssObj, cssmExt->extnId, cssmExt->critical, false,
kSecAsn1BasicConstraintsTemplate);
}
/*
* Encode into a NSS-style Extensions.
*
* Each extension object, currently stored as some AsnType subclass,
* is BER-encoded and the result is stored as an octet string
* (AsnOcts) in a new Extension object in the TBS.
*
* Called from {Crl,Cert}CreateTemplate via encode{Tbs,Cts}().
*/
void DecodedExtensions::encodeToNss(
NSS_CertExtension **&extensions)
{
assert(extensions == NULL);
if(mNumExtensions == 0) {
/* no extensions, no error */
return;
}
/* malloc a NULL_terminated array of NSS_CertExtension pointers */
unsigned len = (mNumExtensions + 1) * sizeof(NSS_CertExtension *);
extensions = (NSS_CertExtension **)mCoder.malloc(len);
memset(extensions, 0, len);
/* grind thru our DecodedExtens, creating an NSS_CertExtension for
* each one */
for(unsigned extenDex=0; extenDex<mNumExtensions; extenDex++) {
NSS_CertExtension *thisNssExten =
(NSS_CertExtension *)mCoder.malloc(sizeof(NSS_CertExtension));
memset(thisNssExten, 0, sizeof(NSS_CertExtension));
extensions[extenDex] = thisNssExten;
const DecodedExten *decodedExt = getExtension(extenDex);
/* BER-encode the extension object if appropriate */
if(decodedExt->berEncoded()) {
/* unknown extension type, it's already encoded */
const CSSM_DATA *srcBer = (const CSSM_DATA *)decodedExt->rawExtn();
assert(srcBer != NULL);
mCoder.allocCopyItem(*srcBer, thisNssExten->value);
}
else {
PRErrorCode prtn;
prtn = mCoder.encodeItem(decodedExt->nssObj(),
decodedExt->templ(), thisNssExten->value);
if(prtn) {
clErrorLog("encodeToNss: extension encode error");
CssmError::throwMe(CSSMERR_CL_INTERNAL_ERROR);
}
}
ArenaAllocator arenaAlloc(mCoder);
if(decodedExt->critical()) {
/* optional, default false */
clCssmBoolToNss(CSSM_TRUE, thisNssExten->critical, arenaAlloc);
}
mCoder.allocCopyItem(decodedExt->extnId(), thisNssExten->extnId);
}
}
static void setField_PublicKeyInfo (
DecodedItem &item,
const CssmData &fieldValue)
{
DecodedCert &cert = dynamic_cast<DecodedCert &>(item);
CSSM_X509_SUBJECT_PUBLIC_KEY_INFO &dstKeyInfo =
cert.mCert.tbs.subjectPublicKeyInfo;
tbsSetCheck(dstKeyInfo.subjectPublicKey.Data, fieldValue,
sizeof(CSSM_X509_SUBJECT_PUBLIC_KEY_INFO), "PubKeyInfo");
CSSM_X509_SUBJECT_PUBLIC_KEY_INFO *srcKeyInfo =
(CSSM_X509_SUBJECT_PUBLIC_KEY_INFO *)fieldValue.Data;
if((srcKeyInfo->subjectPublicKey.Data == NULL) ||
(srcKeyInfo->subjectPublicKey.Length == 0)) {
CssmError::throwMe(CSSMERR_CL_INVALID_FIELD_POINTER);
}
ArenaAllocator arenaAlloc(cert.coder());
CL_copySubjPubKeyInfo(*srcKeyInfo, false, // length in bytes here
dstKeyInfo, true, // length in bits
arenaAlloc);
}
/* -----------------------------------------------------------------------------
* Finds or creates if needed a singleton retainer set.
* -------------------------------------------------------------------------- */
RetainerSet *
singleton(retainer r)
{
RetainerSet *rs;
StgWord hk;
hk = hashKeySingleton(r);
for (rs = hashTable[hash(hk)]; rs != NULL; rs = rs->link)
if (rs->num == 1 && rs->element[0] == r) return rs; // found it
// create it
rs = arenaAlloc( arena, sizeofRetainerSet(1) );
rs->num = 1;
rs->hashKey = hk;
rs->link = hashTable[hash(hk)];
rs->id = nextId++;
rs->element[0] = r;
// The new retainer set is placed at the head of the linked list.
hashTable[hash(hk)] = rs;
return rs;
}
/* -----------------------------------------------------------------------------
* Finds or creates a retainer set *rs augmented with r.
* Invariants:
* r is not a member of rs, i.e., isMember(r, rs) returns rtsFalse.
* rs is not NULL.
* Note:
* We could check if rs is NULL, in which case this function call
* reverts to singleton(). We do not choose this strategy because
* in most cases addElement() is invoked with non-NULL rs.
* -------------------------------------------------------------------------- */
RetainerSet *
addElement(retainer r, RetainerSet *rs)
{
nat i;
nat nl; // Number of retainers in *rs Less than r
RetainerSet *nrs; // New Retainer Set
StgWord hk; // Hash Key
#ifdef DEBUG_RETAINER
// debugBelch("addElement(%p, %p) = ", r, rs);
#endif
ASSERT(rs != NULL);
ASSERT(rs->num <= RtsFlags.ProfFlags.maxRetainerSetSize);
if (rs == &rs_MANY || rs->num == RtsFlags.ProfFlags.maxRetainerSetSize) {
return &rs_MANY;
}
ASSERT(!isMember(r, rs));
for (nl = 0; nl < rs->num; nl++)
if (r < rs->element[nl]) break;
// Now nl is the index for r into the new set.
// Also it denotes the number of retainers less than r in *rs.
// Thus, compare the first nl retainers, then r itself, and finally the
// remaining (rs->num - nl) retainers.
hk = hashKeyAddElement(r, rs);
for (nrs = hashTable[hash(hk)]; nrs != NULL; nrs = nrs->link) {
// test *rs and *nrs for equality
// check their size
if (rs->num + 1 != nrs->num) continue;
// compare the first nl retainers and find the first non-matching one.
for (i = 0; i < nl; i++)
if (rs->element[i] != nrs->element[i]) break;
if (i < nl) continue;
// compare r itself
if (r != nrs->element[i]) continue; // i == nl
// compare the remaining retainers
for (; i < rs->num; i++)
if (rs->element[i] != nrs->element[i + 1]) break;
if (i < rs->num) continue;
#ifdef DEBUG_RETAINER
// debugBelch("%p\n", nrs);
#endif
// The set we are seeking already exists!
return nrs;
}
// create a new retainer set
nrs = arenaAlloc( arena, sizeofRetainerSet(rs->num + 1) );
nrs->num = rs->num + 1;
nrs->hashKey = hk;
nrs->link = hashTable[hash(hk)];
nrs->id = nextId++;
for (i = 0; i < nl; i++) { // copy the first nl retainers
nrs->element[i] = rs->element[i];
}
nrs->element[i] = r; // copy r
for (; i < rs->num; i++) { // copy the remaining retainers
nrs->element[i + 1] = rs->element[i];
}
hashTable[hash(hk)] = nrs;
#ifdef DEBUG_RETAINER
// debugBelch("%p\n", nrs);
#endif
return nrs;
}
static void
initProfilingLogFile(void)
{
char *prog;
prog = arenaAlloc(prof_arena, strlen(prog_name) + 1);
strcpy(prog, prog_name);
#ifdef mingw32_HOST_OS
// on Windows, drop the .exe suffix if there is one
{
char *suff;
suff = strrchr(prog,'.');
if (suff != NULL && !strcmp(suff,".exe")) {
*suff = '\0';
}
}
#endif
if (RtsFlags.CcFlags.doCostCentres == 0 &&
RtsFlags.ProfFlags.doHeapProfile != HEAP_BY_RETAINER)
{
/* No need for the <prog>.prof file */
prof_filename = NULL;
prof_file = NULL;
}
else
{
/* Initialise the log file name */
prof_filename = arenaAlloc(prof_arena, strlen(prog) + 6);
sprintf(prof_filename, "%s.prof", prog);
/* open the log file */
if ((prof_file = fopen(prof_filename, "w")) == NULL) {
debugBelch("Can't open profiling report file %s\n", prof_filename);
RtsFlags.CcFlags.doCostCentres = 0;
// The following line was added by Sung; retainer/LDV profiling may need
// two output files, i.e., <program>.prof/hp.
if (RtsFlags.ProfFlags.doHeapProfile == HEAP_BY_RETAINER)
RtsFlags.ProfFlags.doHeapProfile = 0;
return;
}
if (RtsFlags.CcFlags.doCostCentres == COST_CENTRES_XML) {
/* dump the time, and the profiling interval */
fprintf(prof_file, "\"%s\"\n", time_str());
fprintf(prof_file, "\"%d ms\"\n", RtsFlags.MiscFlags.tickInterval);
/* declare all the cost centres */
{
CostCentre *cc;
for (cc = CC_LIST; cc != NULL; cc = cc->link) {
fprintf(prof_file, "%d %ld \"%s\" \"%s\"\n",
CC_UQ, cc->ccID, cc->label, cc->module);
}
}
}
}
if (RtsFlags.ProfFlags.doHeapProfile) {
/* Initialise the log file name */
hp_filename = arenaAlloc(prof_arena, strlen(prog) + 6);
sprintf(hp_filename, "%s.hp", prog);
/* open the log file */
if ((hp_file = fopen(hp_filename, "w")) == NULL) {
debugBelch("Can't open profiling report file %s\n",
hp_filename);
RtsFlags.ProfFlags.doHeapProfile = 0;
return;
}
}
}