void sortlist(struct jbList *list)
{
struct jbNode *jb,**buf,**work;
uint32_t count=0;
for(jb=list->First;jb;jb=jb->Next)
count++;
if(count < 2)
return;
if(!(buf=(struct jbNode **)osAlloc(count * sizeof(struct jbNode *))))
return;
work=buf;
for(jb=list->First;jb;jb=jb->Next)
*work++=jb;
qsort(buf,(size_t)count,(size_t)sizeof(struct jbNode *),sortcompare);
jbNewList(list);
for(work=buf;count--;)
jbAddNode(list,*work++);
osFree(buf);
}
bool SortNodes(struct jbList *list)
{
struct NodeStatsNode *sn,**buf,**work;
uint32_t nc;
nc=0;
for(sn=(struct NodeStatsNode *)list->First;sn;sn=sn->Next)
nc++;
if(nc==0)
return(TRUE); /* Nothing to sort */
if(!(buf=(struct NodeStatsNode **)osAlloc(nc*sizeof(struct NodeStatsNode *))))
return(FALSE);
work=buf;
for(sn=(struct NodeStatsNode *)list->First;sn;sn=sn->Next)
*work++=sn;
qsort(buf,nc,ptrsize,CompareNodes);
jbNewList(list);
for(work=buf;nc--;)
jbAddNode(list,(struct jbNode *)*work++);
osFree(buf);
return(TRUE);
}
bool Sort(struct jbList *list,char sortmode)
{
uint32_t nc;
struct StatsNode *sn,**buf,**work;
nc=0;
for(sn=(struct StatsNode *)list->First;sn;sn=sn->Next)
nc++;
if(nc==0)
return(TRUE); /* Nothing to sort */
if(!(buf=(struct StatsNode **)osAlloc(nc*sizeof(struct StatsNode *))))
return(FALSE);
work=buf;
for(sn=(struct StatsNode *)list->First;sn;sn=sn->Next)
*work++=sn;
switch(sortmode)
{
case 'a': qsort(buf,nc,ptrsize,CompareAlpha);
break;
case 't': qsort(buf,nc,ptrsize,CompareTotal);
break;
case 'm': qsort(buf,nc,ptrsize,CompareMsgsDay);
break;
case 'd': qsort(buf,nc,ptrsize,CompareFirstTime);
break;
case 'l': qsort(buf,nc,ptrsize,CompareLastTime);
break;
case 'u': qsort(buf,nc,ptrsize,CompareDupes);
break;
}
jbNewList(list);
for(work=buf;nc--;)
jbAddNode(list,(struct jbNode *)*work++);
osFree(buf);
return(TRUE);
}
void addentry(char *dir,char *file,uint32_t type,struct Node4D *boss,bool flow)
{
struct osFileEntry *fe;
struct fileentry *entry;
struct Node4D n4d;
char buf[200];
char buf2[200];
uint32_t hex;
hex=hextodec(file);
if(boss)
{
Copy4D(&n4d,boss);
n4d.Point = hex;
}
else
{
n4d.Zone = cfg_Zone;
n4d.Net = NET(hex);
n4d.Node = NODE(hex);
n4d.Point = 0;
}
if(Compare4DPat(&cfg_Pattern,&n4d)!=0)
return;
if(dir) MakeFullPath(dir,file,buf,200);
else mystrncpy(buf,file,200);
MakeFullPath(cfg_Dir,buf,buf2,200);
if(!(fe=osGetFileEntry(buf2)))
{
return;
}
if(!(entry=osAlloc(sizeof(struct fileentry))))
{
osFree(fe);
return;
}
Copy4D(&entry->Node,&n4d);
if(dir)
{
MakeFullPath(dir,file,entry->file,100);
MakeFullPath(cfg_Dir,dir,entry->dir,100);
}
else
{
mystrncpy(entry->file,file,100);
mystrncpy(entry->dir,cfg_Dir,100);
}
mystrncpy(entry->file,buf,100);
entry->size=fe->Size;
entry->date=fe->Date;
entry->type=type;
entry->flow=flow;
jbAddNode(&list,(struct jbNode *)entry);
osFree(fe);
}
void* FMallocBinned::malloc(size_t size, uint32_t alignment)
{
#ifdef USE_COARSE_GRAIN_LOCKS
FScopeLock ScopedLock(&AccessGuard);
#endif
flushPendingFrees();
// Handle DEFAULT_ALIGNMENT for binned allocator.
if (alignment == DefaultAlignment)
{
alignment = default_binned_allocator_alignment;
}
FAssert(alignment <= pageSize);
alignment = std::max<uint32_t>(alignment, default_binned_allocator_alignment);
size = std::max<size_t>(alignment, FAlign(size, alignment));
MEM_TIME(MemTime -= FPlatformTime::Seconds());
STAT(currentAllocs++);
STAT(totalAllocs++);
FFreeMem* free = nullptr;
if( size < binnedSizeLimit )
{
// Allocate from pool.
FPoolTable* table = memSizeToPoolTable[size];
#ifdef USE_FINE_GRAIN_LOCKS
std::lock_guard<std::mutex> tableLock(table->mutex);
#endif
FAssert(size <= table->blockSize);
trackStats(table, (uint32_t)size);
FPoolInfo* pool = table->firstPool;
if( !pool )
{
pool = allocatePoolMemory(table, binned_alloc_pool_size/*PageSize*/, size);
}
free = allocateBlockFromPool(table, pool);
}
else if ( ((size >= binnedSizeLimit && size <= pagePoolTable[0].blockSize) ||
(size > pageSize && size <= pagePoolTable[1].blockSize))
&& alignment == default_binned_allocator_alignment )
{
// Bucket in a pool of 3*PageSize or 6*PageSize
uint32_t binType = size < pageSize ? 0 : 1;
uint32_t pageCount = 3 * binType + 3;
FPoolTable* table = &pagePoolTable[binType];
#ifdef USE_FINE_GRAIN_LOCKS
std::lock_guard<std::mutex> tableLock(table->mutex);
#endif
FAssert(size <= table->blockSize);
trackStats(table, (uint32_t)size);
FPoolInfo* pool = table->firstPool;
if( !pool )
{
pool = allocatePoolMemory(table, pageCount * pageSize, binnedSizeLimit + binType);
}
free = allocateBlockFromPool(table, pool);
}
else
{
// Use OS for large allocations.
UIntPtr_t alignedSize = FAlign(size, pageSize);
size_t actualPoolSize; //TODO: use this to reduce waste?
free = (FFreeMem*)osAlloc(alignedSize, actualPoolSize);
if( !free )
{
outOfMemory(alignedSize);
}
FAssert(!((size_t)free & (pageSize - 1)));
// Create indirect.
FPoolInfo* pool;
{
#ifdef USE_FINE_GRAIN_LOCKS
std::lock_guard<std::mutex> poolInfoLock(accessGuard);
#endif
pool = getPoolInfo((UIntPtr_t)free);
}
pool->setAllocationSizes((uint32_t)size, alignedSize, (uint32_t)binnedOSTableIndex, (uint32_t)binnedOSTableIndex);
STAT(osPeak = std::max(osPeak, osCurrent += alignedSize));
STAT(usedPeak = std::max(usedPeak, usedCurrent += size));
STAT(wastePeak = std::max(wastePeak, wasteCurrent += alignedSize - size));
}
MEM_TIME(MemTime += FPlatformTime::Seconds());
return free;
}
int main(int argc, char **argv)
{
osFile fh;
uint32_t total,areas,totaldupes;
time_t firsttime,t;
uint32_t DayStatsWritten;
char buf[200],date[30],date2[30];
struct DiskAreaStats dastat;
struct DiskNodeStats dnstat;
struct StatsNode *sn;
struct NodeStatsNode *nsn;
struct jbList StatsList;
struct jbList NodesList;
uint32_t c,num,tot;
uint16_t total8days[8];
char sortmode;
struct tm *tp;
char *monthnames[]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec","???"};
signal(SIGINT,breakfunc);
if(!osInit())
exit(OS_EXIT_ERROR);
if(argc > 1 &&
(strcmp(argv[1],"?")==0 ||
strcmp(argv[1],"-h")==0 ||
strcmp(argv[1],"--help")==0 ||
strcmp(argv[1],"help")==0 ||
strcmp(argv[1],"/h")==0 ||
strcmp(argv[1],"/?")==0 ))
{
printargs(args);
osEnd();
exit(OS_EXIT_OK);
}
if(!parseargs(args,argc,argv))
{
osEnd();
exit(OS_EXIT_ERROR);
}
sortmode='a';
if(args[ARG_SORT].data)
sortmode=tolower(((char *)args[ARG_SORT].data)[0]);
if(!strchr("amtdlu",sortmode))
{
printf("Unknown sort mode %c\n",sortmode);
osEnd();
exit(OS_EXIT_ERROR);
}
if(args[ARG_NOAREAS].data && args[ARG_NONODES].data)
{
printf("Nothing to do\n");
osEnd();
exit(OS_EXIT_ERROR);
}
printf("CrashStats "VERSION" © " COPYRIGHT " Johan Billing\n");
if(!(fh=osOpen(args[ARG_FILE].data,MODE_OLDFILE)))
{
uint32_t err=osError();
printf("Error opening %s\n",(char *)args[ARG_FILE].data);
printf("Error: %s\n",osErrorMsg(err));
osEnd();
exit(OS_EXIT_ERROR);
}
osRead(fh,buf,4);
buf[4]=0;
if(strcmp(buf,STATS_IDENTIFIER)!=0)
{
printf("Unknown format of stats file\n");
osClose(fh);
osEnd();
exit(OS_EXIT_ERROR);
}
osRead(fh,&DayStatsWritten,sizeof(uint32_t));
total=0;
totaldupes=0;
firsttime=0;
areas=0;
for(c=0;c<8;c++)
total8days[c]=0;
jbNewList(&StatsList);
jbNewList(&NodesList);
osRead(fh,&num,sizeof(uint32_t));
c=0;
if(!args[ARG_NOAREAS].data)
{
while(c<num && osRead(fh,&dastat,sizeof(struct DiskAreaStats))==sizeof(struct DiskAreaStats))
{
if(!args[ARG_GROUP].data || CheckFlags(dastat.Group,args[ARG_GROUP].data))
{
if(!(sn=osAlloc(sizeof(struct StatsNode))))
{
printf("Out of memory\n");
jbFreeList(&StatsList);
osClose(fh);
osEnd();
exit(OS_EXIT_ERROR);
}
jbAddNode(&StatsList,(struct jbNode *)sn);
strcpy(sn->Tagname,dastat.Tagname);
sn->Dupes=dastat.Dupes;
sn->Total=dastat.TotalTexts;
sn->FirstTime=dastat.FirstTime;
sn->LastTime=dastat.LastTime;
memcpy(&sn->Last8Days[0],&dastat.Last8Days[0],8*sizeof(uint16_t));
sn->Average=CalculateAverage(&dastat.Last8Days[0],dastat.TotalTexts,DayStatsWritten,sn->FirstTime / (24*60*60));
}
if(dastat.FirstTime!=0)
if(firsttime==0 || firsttime > dastat.FirstTime)
firsttime=dastat.FirstTime;
c++;
}
}
else
{
while(c<num && osRead(fh,&dastat,sizeof(struct DiskAreaStats))==sizeof(struct DiskAreaStats))
c++;
}
osRead(fh,&num,sizeof(uint32_t));
c=0;
if(!args[ARG_NONODES].data)
{
while(c<num && osRead(fh,&dnstat,sizeof(struct DiskNodeStats))==sizeof(struct DiskNodeStats))
{
if(!(nsn=osAlloc(sizeof(struct NodeStatsNode))))
{
printf("Out of memory\n");
jbFreeList(&NodesList);
jbFreeList(&StatsList);
osClose(fh);
osEnd();
exit(OS_EXIT_ERROR);
}
jbAddNode(&NodesList,(struct jbNode *)nsn);
Copy4D(&nsn->Node,&dnstat.Node);
nsn->GotNetmails=dnstat.GotNetmails;
nsn->GotNetmailBytes=dnstat.GotNetmailBytes;
nsn->SentNetmails=dnstat.SentNetmails;
nsn->SentNetmailBytes=dnstat.SentNetmailBytes;
nsn->GotEchomails=dnstat.GotEchomails;
nsn->GotEchomailBytes=dnstat.GotEchomailBytes;
nsn->SentEchomails=dnstat.SentEchomails;
nsn->SentEchomailBytes=dnstat.SentEchomailBytes;
nsn->Dupes=dnstat.Dupes;
nsn->Days=DayStatsWritten-dnstat.FirstTime % (24*60*60);
if(nsn->Days==0) nsn->Days=1;
nsn->FirstTime=dnstat.FirstTime;
if(dnstat.FirstTime!=0)
if(firsttime==0 || firsttime > dnstat.FirstTime)
firsttime=dnstat.FirstTime;
c++;
}
}
else
{
while(c<num && osRead(fh,&dnstat,sizeof(struct DiskNodeStats))==sizeof(struct DiskNodeStats))
c++;
}
osClose(fh);
t=(time_t)DayStatsWritten * 24*60*60;
tp=localtime(&firsttime);
sprintf(date,"%02d-%s-%02d",tp->tm_mday,monthnames[tp->tm_mon],tp->tm_year%100);
tp=localtime(&t);
sprintf(date2,"%02d-%s-%02d",tp->tm_mday,monthnames[tp->tm_mon],tp->tm_year%100);
printf("\nStatistics from %s to %s\n",date,date2);
if(!ctrlc && !args[ARG_NOAREAS].data)
{
Sort(&StatsList,'a');
Sort(&StatsList,sortmode);
printf("\n");
if(args[ARG_LAST7].data)
{
printf("Area ");
for(c=1;c<8;c++)
{
t=(DayStatsWritten-c)*24*60*60;
tp=localtime(&t);
printf(" %02d",tp->tm_mday);
}
printf(" Total\n============================================================================\n");
if(!ctrlc)
{
for(sn=(struct StatsNode *)StatsList.First;sn && !ctrlc;sn=sn->Next)
{
tot=0;
for(c=1;c<8;c++)
tot+=sn->Last8Days[c];
printf("%-33.33s %4d %4d %4d %4d %4d %4d %4d : %5d\n",
sn->Tagname,
sn->Last8Days[1],
sn->Last8Days[2],
sn->Last8Days[3],
sn->Last8Days[4],
sn->Last8Days[5],
sn->Last8Days[6],
sn->Last8Days[7],
tot);
for(c=1;c<8;c++)
total8days[c]+=sn->Last8Days[c];
areas++;
}
if(!ctrlc)
{
tot=0;
for(c=1;c<8;c++)
tot+=total8days[c];
printf("=============================================================================\n");
sprintf(buf,"Totally in all %u areas",areas);
printf("%-33.33s %4d %4d %4d %4d %4d %4d %4d : %5d\n",
buf,
total8days[1],
total8days[2],
total8days[3],
total8days[4],
total8days[5],
total8days[6],
total8days[7],
tot);
}
}
}
else
{
printf("Area First Last Msgs Msgs/day Dupes\n");
printf("============================================================================\n");
if(!ctrlc)
{
for(sn=(struct StatsNode *)StatsList.First;sn && !ctrlc;sn=sn->Next)
{
if(sn->LastTime==0)
{
strcpy(date2,"<Never>");
}
else
{
tp=localtime(&sn->LastTime);
sprintf(date2,"%02d-%s-%02d",tp->tm_mday,monthnames[tp->tm_mon],tp->tm_year%100);
}
if(sn->FirstTime==0)
{
strcpy(date,"<Never>");
}
else
{
tp=localtime(&sn->FirstTime);
sprintf(date,"%02d-%s-%02d",tp->tm_mday,monthnames[tp->tm_mon],tp->tm_year%100);
}
for(c=0;c<8;c++)
total8days[c]+=sn->Last8Days[c];
total+=sn->Total;
totaldupes+=sn->Dupes;
areas++;
printf("%-29.30s %-9.9s %-9.9s %7d %7d %7d\n",sn->Tagname,date,date2,sn->Total,sn->Average,sn->Dupes);
}
}
if(!ctrlc)
{
printf("============================================================================\n");
sprintf(buf,"Totally in all %u areas",areas);
printf("%-42s %7d %7d %7d\n",
buf,
total,
CalculateAverage(&total8days[0],total,DayStatsWritten,firsttime / (24*60*60)),
totaldupes);
}
}
}
if(!ctrlc && !args[ARG_NONODES].data)
{
SortNodes(&NodesList);
printf("\n");
printf("Nodes statistics\n");
printf("================\n");
for(nsn=(struct NodeStatsNode *)NodesList.First;nsn && !ctrlc;nsn=nsn->Next)
{
if(nsn->FirstTime==0)
{
strcpy(date,"<Never>");
}
else
{
tp=localtime(&nsn->FirstTime);
sprintf(date,"%0d-%s-%0d",tp->tm_mday,monthnames[tp->tm_mon],tp->tm_year%100);
}
sprintf(buf,"%u:%u/%u.%u",nsn->Node.Zone,nsn->Node.Net,nsn->Node.Node,nsn->Node.Point);
printf("%-30.40s Statistics since: %s\n\n",buf,date);
printf(" Sent netmails: %u/%s\n",nsn->SentNetmails,unit(nsn->SentNetmailBytes));
printf(" Received netmails: %u/%s\n",nsn->GotNetmails,unit(nsn->GotNetmailBytes));
printf(" Sent echomails: %u/%s\n",nsn->SentEchomails,unit(nsn->SentEchomailBytes));
printf(" Received echomails: %u/%s\n",nsn->GotEchomails,unit(nsn->GotEchomailBytes));
printf(" Dupes: %u\n",nsn->Dupes);
printf("\n");
}
}
if(ctrlc)
{
printf("*** Break\n");
}
else
{
printf("\n");
}
jbFreeList(&StatsList);
jbFreeList(&NodesList);
osEnd();
exit(OS_EXIT_OK);
}
bool OpenDupeDB(void)
{
char buf[300];
uint32_t offset,crc32,*crc32p;
uint16_t size,res;
if(!(dupebuf=osAlloc(config.cfg_DupeSize*sizeof(struct dupeentry))))
{
LogWrite(1,SYSTEMERR,"Not enough memory for dupe-check buffer\n");
return(FALSE);
}
dupeentrynum=0;
dupeentrymax=0;
dupechanged=FALSE;
if(!(dupefh=osOpen(config.cfg_DupeFile,MODE_READWRITE)))
{
uint32_t err=osError();
LogWrite(1,SYSTEMERR,"Failed to open dupe file %s in read/write mode",config.cfg_DupeFile);
LogWrite(1,SYSTEMERR,"Error: %s",osErrorMsg(err));
return(FALSE);
}
res=osRead(dupefh,buf,4);
buf[4]=0;
if(res == 0)
{
/* New file */
LogWrite(3,TOSSINGINFO,"Creating new dupe file %s",config.cfg_DupeFile);
strcpy(buf,DUPES_IDENTIFIER);
osWrite(dupefh,buf,4);
}
else if(res != 4 || strcmp(buf,DUPES_IDENTIFIER)!=0)
{
LogWrite(1,SYSTEMERR,"Invalid format of dupe file %s, exiting...",config.cfg_DupeFile);
osClose(dupefh);
return(FALSE);
}
offset=4;
while(osRead(dupefh,&size,sizeof(uint16_t))==sizeof(uint16_t))
{
if(size == 0 || size > 300) /* Unreasonably big */
{
LogWrite(1,SYSTEMERR,"Error in dupe file %s, exiting...",config.cfg_DupeFile);
osClose(dupefh);
return(FALSE);
}
if(osRead(dupefh,buf,(uint32_t)size) != size)
{
LogWrite(1,SYSTEMERR,"Error in dupe file %s, exiting...",config.cfg_DupeFile);
osClose(dupefh);
return(FALSE);
}
crc32p=(uint32_t *)buf;
crc32=*crc32p;
adddupeindex(offset,crc32);
offset += size+2;
}
dupechanged=FALSE;
return(TRUE);
}
