static void addCompiledCallbackPattern (
const langType language, regex_t* const pattern,
const regexCallback callback)
{
patternSet* set;
regexPattern *ptrn;
if (language > SetUpper)
{
int i;
Sets = xRealloc (Sets, (language + 1), patternSet);
for (i = SetUpper + 1 ; i <= language ; ++i)
{
Sets [i].patterns = NULL;
Sets [i].count = 0;
}
SetUpper = language;
}
set = Sets + language;
set->patterns = xRealloc (set->patterns, (set->count + 1), regexPattern);
ptrn = &set->patterns [set->count];
set->count += 1;
ptrn->pattern = pattern;
ptrn->type = PTRN_CALLBACK;
ptrn->u.callback.function = callback;
}
extern void addTagXcmd (const langType language, vString* pathvstr)
{
#ifdef HAVE_COPROC
pathSet* set;
xcmdPath *path;
Assert (path != NULL);
if (language > SetUpper)
{
int i;
Sets = xRealloc (Sets, (language + 1), pathSet);
for (i = SetUpper + 1 ; i <= language ; ++i)
{
Sets [i].paths = NULL;
Sets [i].count = 0;
}
SetUpper = language;
}
set = Sets + language;
set->paths = xRealloc (set->paths, (set->count + 1), xcmdPath);
path = &set->paths [set->count];
path->path = pathvstr;
path->kinds = NULL;
path->kount = 0;
path->id = set->count;
set->count += 1;
path->available = (loadPathKinds (path, language));
useXcmdMethod (language);
if (path->available)
notifyAvailabilityXcmdMethod (language);
#endif
}
static void addCompiledTagPattern (
const langType language, regex_t* const pattern,
char* const name, const char kind, char* const kindName,
char *const description)
{
patternSet* set;
regexPattern *ptrn;
if (language > SetUpper)
{
int i;
Sets = xRealloc (Sets, (language + 1), patternSet);
for (i = SetUpper + 1 ; i <= language ; ++i)
{
Sets [i].patterns = NULL;
Sets [i].count = 0;
}
SetUpper = language;
}
set = Sets + language;
set->patterns = xRealloc (set->patterns, (set->count + 1), regexPattern);
ptrn = &set->patterns [set->count];
set->count += 1;
ptrn->pattern = pattern;
ptrn->type = PTRN_TAG;
ptrn->u.tag.name_pattern = name;
ptrn->u.tag.kind.enabled = TRUE;
ptrn->u.tag.kind.letter = kind;
ptrn->u.tag.kind.name = kindName;
ptrn->u.tag.kind.description = description;
}
static void appendLineFposMap (inputLineFposMap *lineFposMap, compoundPos *pos,
bool crAdjustment)
{
int lastCrAdjustment = 0;
if (lineFposMap->size == lineFposMap->count)
{
lineFposMap->size *= 2;
lineFposMap->pos = xRealloc (lineFposMap->pos,
lineFposMap->size,
compoundPos);
}
if (lineFposMap->count != 0)
{
lineFposMap->pos [lineFposMap->count - 1].open = false;
lastCrAdjustment = lineFposMap->pos [lineFposMap->count - 1].crAdjustment;
}
lineFposMap->pos [lineFposMap->count] = *pos;
lineFposMap->pos [lineFposMap->count].open = true;
lineFposMap->pos [lineFposMap->count].crAdjustment
= lastCrAdjustment + ((crAdjustment)? 1: 0);
lineFposMap->count++;
}
char* String_readLine(FILE* fd) {
const int step = 1024;
int bufSize = step;
char* buffer = xMalloc(step + 1);
char* at = buffer;
for (;;) {
char* ok = fgets(at, step + 1, fd);
if (!ok) {
free(buffer);
return NULL;
}
char* newLine = strrchr(at, '\n');
if (newLine) {
*newLine = '\0';
return buffer;
} else {
if (feof(fd)) {
return buffer;
}
}
bufSize += step;
buffer = xRealloc(buffer, bufSize + 1);
at = buffer + bufSize - step;
}
}
void *String::internalAlloc(uint32 nNewLength)
{
void *pMemoryBlock;
if (m_pString)
{
pMemoryBlock = ((int32 *) m_pString) - 2;
if (nNewLength > getCapacity())
{
uint32 nCapacity = calcNewCapacity(nNewLength);
pMemoryBlock = xRealloc(pMemoryBlock, sizeof(XCHAR)*(nCapacity + 1));
m_pString = (XCHAR *) (((int32 *)pMemoryBlock) + 2);
setCapacity(nCapacity);
}
}
else
{
uint32 nCapacity = calcNewCapacity(nNewLength);
pMemoryBlock = xAlloc(sizeof(StringData) + sizeof(XCHAR)*(nCapacity + 1));
m_pString = (XCHAR *) (((int32 *)pMemoryBlock) + 2);
setCapacity(nCapacity);
*(((int32 *) m_pString) - 1) = 1;
}
m_pString[ nNewLength ] = 0;
return pMemoryBlock;
}
ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList, uid_t userId) {
SolarisProcessList* spl = xCalloc(1, sizeof(SolarisProcessList));
ProcessList* pl = (ProcessList*) spl;
ProcessList_init(pl, Class(SolarisProcess), usersTable, pidWhiteList, userId);
spl->kd = kstat_open();
pl->cpuCount = sysconf(_SC_NPROCESSORS_ONLN);
if (pl->cpuCount == 1 ) {
spl->cpus = xRealloc(spl->cpus, sizeof(CPUData));
} else {
spl->cpus = xRealloc(spl->cpus, (pl->cpuCount + 1) * sizeof(CPUData));
}
return pl;
}
extern void addTagXcmd (const langType language, vString* pathvstr, const char* flags)
{
#ifdef HAVE_COPROC
pathSet* set;
xcmdPath *path;
#define COUNT(D) (sizeof(D)/sizeof(D[0]))
flagDefinition xcmdFlagDefs[] = {
{ '\0', "notAvailableStatus", NULL, xcmd_flag_not_avaible_status_long },
};
Assert (pathvstr != NULL);
if (language > SetUpper)
{
int i;
Sets = xRealloc (Sets, (language + 1), pathSet);
for (i = SetUpper + 1 ; i <= language ; ++i)
{
Sets [i].paths = NULL;
Sets [i].count = 0;
}
SetUpper = language;
}
set = Sets + language;
set->paths = xRealloc (set->paths, (set->count + 1), xcmdPath);
path = &set->paths [set->count];
path->path = pathvstr;
path->kinds = NULL;
path->n_kinds = 0;
path->id = set->count;
path->not_available_status = XCMD_NOT_AVAILABLE_STATUS;
set->count += 1;
flagsEval (flags, xcmdFlagDefs, COUNT(xcmdFlagDefs), path);
path->available = (loadPathKinds (path, language));
useXcmdMethod (language);
if (path->available)
notifyAvailabilityXcmdMethod (language);
#endif
}
static void appendLineFposMap (inputLineFposMap *lineFposMap, fpos_t pos)
{
if (lineFposMap->size == lineFposMap->count)
{
lineFposMap->size *= 2;
lineFposMap->pos = xRealloc (lineFposMap->pos,
lineFposMap->size,
fpos_t);
}
lineFposMap->pos [lineFposMap->count] = pos;
lineFposMap->count++;
}
void ColumnsPanel_update(Panel* super) {
ColumnsPanel* this = (ColumnsPanel*) super;
int size = Panel_size(super);
this->settings->changed = true;
this->settings->fields = xRealloc(this->settings->fields, sizeof(ProcessField) * (size+1));
this->settings->flags = 0;
for (int i = 0; i < size; i++) {
int key = ((ListItem*) Panel_get(super, i))->key;
this->settings->fields[i] = key;
this->settings->flags |= Process_fields[key].flags;
}
this->settings->fields[size] = 0;
}
extern void nestingLevelsPush(NestingLevels *nls,
const vString *name, int type)
{
NestingLevel *nl = NULL;
if (nls->n >= nls->allocated)
{
nls->allocated++;
nls->levels = xRealloc(nls->levels,
nls->allocated, NestingLevel);
nls->levels[nls->n].name = vStringNew();
}
nl = &nls->levels[nls->n];
nls->n++;
vStringCopy(nl->name, name);
nl->type = type;
}
static boolean loadPathKind (xcmdPath *const path, char* line, char *args[])
{
const char* backup = line;
char* off;
vString *desc;
kindOption *kind;
if (line[0] == '\0')
return FALSE;
else if (!isblank(line[1]))
{
error (WARNING, "[%s] a space after letter is not found in kind description line: %s", args[0], backup);
return FALSE;
}
path->kinds = xRealloc (path->kinds, path->n_kinds + 1, kindOption);
kind = &path->kinds [path->n_kinds];
memset (kind, 0, sizeof (*kind));
kind->enabled = TRUE;
kind->letter = line[0];
kind->name = NULL;
kind->description = NULL;
kind->referenceOnly = FALSE;
kind->nRoles = 0;
kind->roles = NULL;
verbose (" kind letter: <%c>\n", kind->letter);
for (line++; isblank(*line); line++)
; /* do nothing */
if (*line == '\0')
{
error (WARNING, "[%s] unexpectedly a kind description line is terminated: %s",
args[0], backup);
return FALSE;
}
Assert (!isblank (*line));
off = strrstr(line, "[off]");
if (off == line)
{
error (WARNING, "[%s] [off] is given but no kind description is found: %s",
args[0], backup);
return FALSE;
}
else if (off)
{
if (!isblank (*(off - 1)))
{
error (WARNING, "[%s] a whitespace must precede [off] flag: %s",
args[0], backup);
return FALSE;
}
kind->enabled = FALSE;
*off = '\0';
}
desc = vStringNewInit (line);
vStringStripTrailing (desc);
Assert (vStringLength (desc) > 0);
kind->description = vStringDeleteUnwrap (desc);
/* TODO: This conversion should be part of protocol. */
{
char *tmp = eStrdup (kind->description);
char *c;
for (c = tmp; *c != '\0'; c++)
{
if (*c == ' ' || *c == '\t')
*c = '_';
}
kind->name = tmp;
}
path->n_kinds += 1;
return TRUE;
}
ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList, uid_t userId) {
size_t len;
char errbuf[_POSIX2_LINE_MAX];
FreeBSDProcessList* fpl = xCalloc(1, sizeof(FreeBSDProcessList));
ProcessList* pl = (ProcessList*) fpl;
ProcessList_init(pl, Class(FreeBSDProcess), usersTable, pidWhiteList, userId);
// physical memory in system: hw.physmem
// physical page size: hw.pagesize
// usable pagesize : vm.stats.vm.v_page_size
len = 2; sysctlnametomib("hw.physmem", MIB_hw_physmem, &len);
len = sizeof(pageSize);
if (sysctlbyname("vm.stats.vm.v_page_size", &pageSize, &len, NULL, 0) == -1) {
pageSize = PAGE_SIZE;
pageSizeKb = PAGE_SIZE_KB;
} else {
pageSizeKb = pageSize / ONE_K;
}
// usable page count vm.stats.vm.v_page_count
// actually usable memory : vm.stats.vm.v_page_count * vm.stats.vm.v_page_size
len = 4; sysctlnametomib("vm.stats.vm.v_page_count", MIB_vm_stats_vm_v_page_count, &len);
len = 4; sysctlnametomib("vm.stats.vm.v_wire_count", MIB_vm_stats_vm_v_wire_count, &len);
len = 4; sysctlnametomib("vm.stats.vm.v_active_count", MIB_vm_stats_vm_v_active_count, &len);
len = 4; sysctlnametomib("vm.stats.vm.v_cache_count", MIB_vm_stats_vm_v_cache_count, &len);
len = 4; sysctlnametomib("vm.stats.vm.v_inactive_count", MIB_vm_stats_vm_v_inactive_count, &len);
len = 4; sysctlnametomib("vm.stats.vm.v_free_count", MIB_vm_stats_vm_v_free_count, &len);
len = 2; sysctlnametomib("vfs.bufspace", MIB_vfs_bufspace, &len);
len = sizeof(fpl->memZfsArc);
if (sysctlbyname("kstat.zfs.misc.arcstats.size", &fpl->memZfsArc, &len,
NULL, 0) == 0 && fpl->memZfsArc != 0) {
sysctlnametomib("kstat.zfs.misc.arcstats.size", MIB_kstat_zfs_misc_arcstats_size, &len);
fpl->zfsArcEnabled = 1;
} else {
fpl->zfsArcEnabled = 0;
}
int smp = 0;
len = sizeof(smp);
if (sysctlbyname("kern.smp.active", &smp, &len, NULL, 0) != 0 || len != sizeof(smp)) {
smp = 0;
}
int cpus = 1;
len = sizeof(cpus);
if (smp) {
int err = sysctlbyname("kern.smp.cpus", &cpus, &len, NULL, 0);
if (err) cpus = 1;
} else {
cpus = 1;
}
size_t sizeof_cp_time_array = sizeof(unsigned long) * CPUSTATES;
len = 2; sysctlnametomib("kern.cp_time", MIB_kern_cp_time, &len);
fpl->cp_time_o = xCalloc(cpus, sizeof_cp_time_array);
fpl->cp_time_n = xCalloc(cpus, sizeof_cp_time_array);
len = sizeof_cp_time_array;
// fetch initial single (or average) CPU clicks from kernel
sysctl(MIB_kern_cp_time, 2, fpl->cp_time_o, &len, NULL, 0);
// on smp box, fetch rest of initial CPU's clicks
if (cpus > 1) {
len = 2; sysctlnametomib("kern.cp_times", MIB_kern_cp_times, &len);
fpl->cp_times_o = xCalloc(cpus, sizeof_cp_time_array);
fpl->cp_times_n = xCalloc(cpus, sizeof_cp_time_array);
len = cpus * sizeof_cp_time_array;
sysctl(MIB_kern_cp_times, 2, fpl->cp_times_o, &len, NULL, 0);
}
pl->cpuCount = MAX(cpus, 1);
if (cpus == 1 ) {
fpl->cpus = xRealloc(fpl->cpus, sizeof(CPUData));
} else {
// on smp we need CPUs + 1 to store averages too (as kernel kindly provides that as well)
fpl->cpus = xRealloc(fpl->cpus, (pl->cpuCount + 1) * sizeof(CPUData));
}
len = sizeof(kernelFScale);
if (sysctlbyname("kern.fscale", &kernelFScale, &len, NULL, 0) == -1) {
//sane default for kernel provided CPU percentage scaling, at least on x86 machines, in case this sysctl call failed
kernelFScale = 2048;
}
fpl->kd = kvm_openfiles(NULL, "/dev/null", NULL, 0, errbuf);
if (fpl->kd == NULL) {
errx(1, "kvm_open: %s", errbuf);
}
return pl;
}
