// static
size_t ParsedIntervalFilter_base::parseValue (
const char *aFilter, size_t aStart, size_t aEnd,
bool aIsSigned, const Limits &aLimits,
Widest &val)
{
char *endptr = NULL;
int vrc = 0;
if (aIsSigned)
vrc = RTStrToInt64Ex(aFilter + aStart, &endptr, 0, &val.ll);
else
vrc = RTStrToUInt64Ex(aFilter + aStart, &endptr, 0, &val.ull);
AssertReturn(endptr, 0);
size_t parsed = endptr - aFilter;
// return parsed if not able to parse to the end
if (parsed != aEnd)
return parsed;
// return aStart if out if range
if (vrc == VWRN_NUMBER_TOO_BIG ||
(aIsSigned &&
(val.ll < aLimits.min.ll ||
val.ll > aLimits.max.ll)) ||
(!aIsSigned &&
(val.ull < aLimits.min.ull ||
val.ull > aLimits.max.ull)))
return aStart;
return parsed;
}
/**
* Convenience method which attempts to find the attribute with the given
* name and returns its value as a signed long integer. This calls
* RTStrToInt64Ex internally and will only output the integer if that
* function returns no error.
*
* @param pcszMatch name of attribute to find (see findAttribute() for namespace remarks)
* @param i out: attribute value
* @return TRUE if attribute was found and str was thus updated.
*/
bool ElementNode::getAttributeValue(const char *pcszMatch, int64_t &i) const
{
const char *pcsz;
if ( (getAttributeValue(pcszMatch, pcsz))
&& (VINF_SUCCESS == RTStrToInt64Ex(pcsz, NULL, 0, &i))
)
return true;
return false;
}
/**
* Copies the value of a node into the given integer variable.
* Returns TRUE only if a value was found and was actually an
* integer of the given type.
* @return
*/
bool Node::copyValue(int64_t &i) const
{
const char *pcsz;
if ( ((pcsz = getValue()))
&& (VINF_SUCCESS == RTStrToInt64Ex(pcsz, NULL, 10, &i))
)
return true;
return false;
}
/**
* Internal worker that picks the processor speed in MHz from /proc/cpuinfo.
*
* @returns CPU frequency.
*/
static uint32_t rtMpLinuxGetFrequency(RTCPUID idCpu)
{
FILE *pFile = fopen("/proc/cpuinfo", "r");
if (!pFile)
return 0;
char sz[256];
RTCPUID idCpuFound = NIL_RTCPUID;
uint32_t Frequency = 0;
while (fgets(sz, sizeof(sz), pFile))
{
char *psz;
if ( !strncmp(sz, RT_STR_TUPLE("processor"))
&& (sz[10] == ' ' || sz[10] == '\t' || sz[10] == ':')
&& (psz = strchr(sz, ':')))
{
psz += 2;
int64_t iCpu;
int rc = RTStrToInt64Ex(psz, NULL, 0, &iCpu);
if (RT_SUCCESS(rc))
idCpuFound = iCpu;
}
else if ( idCpu == idCpuFound
&& !strncmp(sz, RT_STR_TUPLE("cpu MHz"))
&& (sz[10] == ' ' || sz[10] == '\t' || sz[10] == ':')
&& (psz = strchr(sz, ':')))
{
psz += 2;
int64_t v;
int rc = RTStrToInt64Ex(psz, &psz, 0, &v);
if (RT_SUCCESS(rc))
{
Frequency = v;
break;
}
}
}
fclose(pFile);
return Frequency;
}
RTDECL(int64_t) RTLinuxSysFsReadIntFileV(unsigned uBase, const char *pszFormat, va_list va)
{
int fd = RTLinuxSysFsOpenV(pszFormat, va);
if (fd == -1)
return -1;
int64_t i64Ret = -1;
char szNum[128];
ssize_t cchNum = RTLinuxSysFsReadStr(fd, szNum, sizeof(szNum));
if (cchNum > 0)
{
int rc = RTStrToInt64Ex(szNum, NULL, uBase, &i64Ret);
if (RT_FAILURE(rc))
{
i64Ret = -1;
errno = -ETXTBSY; /* just something that won't happen at read / open. */
}
}
else if (cchNum == 0)
errno = -ETXTBSY; /* just something that won't happen at read / open. */
RTLinuxSysFsClose(fd);
return i64Ret;
}
static int
dt_opt_rate(dtrace_hdl_t *dtp, const char *arg, uintptr_t option)
{
char *end;
int i;
dtrace_optval_t mul = 1, val = 0;
const struct {
char *name;
hrtime_t mul;
} suffix[] = {
{ "ns", NANOSEC / NANOSEC },
{ "nsec", NANOSEC / NANOSEC },
{ "us", NANOSEC / MICROSEC },
{ "usec", NANOSEC / MICROSEC },
{ "ms", NANOSEC / MILLISEC },
{ "msec", NANOSEC / MILLISEC },
{ "s", NANOSEC / SEC },
{ "sec", NANOSEC / SEC },
{ "m", NANOSEC * (hrtime_t)60 },
{ "min", NANOSEC * (hrtime_t)60 },
{ "h", NANOSEC * (hrtime_t)60 * (hrtime_t)60 },
{ "hour", NANOSEC * (hrtime_t)60 * (hrtime_t)60 },
{ "d", NANOSEC * (hrtime_t)(24 * 60 * 60) },
{ "day", NANOSEC * (hrtime_t)(24 * 60 * 60) },
{ "hz", 0 },
{ NULL }
};
if (arg != NULL) {
#ifndef VBOX
errno = 0;
val = strtoull(arg, &end, 0);
#else
int rc = RTStrToInt64Ex(arg, &end, 0, &val);
if (rc != VWRN_TRAILING_CHARS)
return (dt_set_errno(dtp, EDT_BADOPTVAL));
#endif
for (i = 0; suffix[i].name != NULL; i++) {
if (strcasecmp(suffix[i].name, end) == 0) {
mul = suffix[i].mul;
break;
}
}
if (suffix[i].name == NULL && *end != '\0' || val < 0)
return (dt_set_errno(dtp, EDT_BADOPTVAL));
if (mul == 0) {
/*
* The rate has been specified in frequency-per-second.
*/
if (val != 0)
val = NANOSEC / val;
} else {
val *= mul;
}
}
dtp->dt_options[option] = val;
return (0);
}
static int
dt_optval_parse(const char *arg, dtrace_optval_t *rval)
{
dtrace_optval_t mul = 1;
size_t len;
char *end;
#ifdef VBOX
int rc;
#endif
len = strlen(arg);
#ifndef VBOX
errno = 0;
#endif
switch (arg[len - 1]) {
case 't':
case 'T':
mul *= 1024;
/*FALLTHRU*/
case 'g':
case 'G':
mul *= 1024;
/*FALLTHRU*/
case 'm':
case 'M':
mul *= 1024;
/*FALLTHRU*/
case 'k':
case 'K':
mul *= 1024;
/*FALLTHRU*/
default:
break;
}
#ifndef VBOX
errno = 0;
*rval = strtoull(arg, &end, 0) * mul;
if ((mul > 1 && end != &arg[len - 1]) || (mul == 1 && *end != '\0') ||
*rval < 0 || errno != 0)
return (-1);
#else
*rval = -1;
if (mul == 1) {
rc = RTStrToInt64Full(arg, 0, rval);
if (rc != VINF_SUCCESS || *rval < 0)
return (-1);
} else {
rc = RTStrToInt64Ex(arg, &end, 0, rval);
if ( rc != VWRN_TRAILING_CHARS
|| end != &arg[len - 1]
|| *rval < 0)
return (-1);
*rval *= mul;
if (*rval < 0)
return (-1);
}
#endif
return (0);
}
