double QwtHighResolutionClock::precision() { struct timespec resolution; int clockId = isMonotonic() ? CLOCK_MONOTONIC : CLOCK_REALTIME; ::clock_getres( clockId, &resolution ); return resolution.tv_nsec / 1e3; }
// // Returns the index of the most recent falling temperature edge // bool FloatLog::isCooling(float vChange, uint8_t range, uint8_t window, float wLimit){ // check for monotonic decrease in temperature in near history // trend must be "range" entries long, with a value change of at least "vChange" // Also, range cannot include any steep changes in temperature (wLimit degrees over window samples) // Doh. No input error checking... if ( ((_log[range] - _log[0]) > vChange) && isMonotonic(0,range) && !hasFastChange(0,range,window,wLimit)){ return TRUE; } return FALSE; }
/** * @return overall monotonicity */ bool ExtSourceProperties::isMonotonic() const { PluginAtom* pa = ea ? ea->pluginAtom : this->pa; assert (pa); const std::vector<PluginAtom::InputType>& it = pa->getInputTypes(); int i = 0; BOOST_FOREACH (PluginAtom::InputType t, it) { if (t == PluginAtom::PREDICATE && !isMonotonic(i)) return false; i++; } return true; }
int main(void) { int Input[] = {1,2,2,3}; int InputSize = sizeof(Input)/sizeof(int); printf("The input array is:\n"); printArray(Input, InputSize); bool result = isMonotonic(Input, InputSize); if (result) printf("The array is monotonic!\n"); else printf("The array is not monotonic!\n"); return 0; }
static struct ffAli *forceMonotonic(struct ffAli *aliList, struct dnaSeq *qSeq, struct dnaSeq *tSeq, enum ffStringency stringency, boolean isProt, struct trans3 *t3List) /* Remove any blocks that violate strictly increasing order in both coordinates. * This is not optimal, but it turns out to be very rarely used. */ { if (!isProt) { if (!isMonotonic(aliList)) { struct ffAli *leftovers = NULL; int score; ssFindBestBig(aliList, qSeq, tSeq, stringency, isProt, t3List, &aliList, &score, &leftovers); ffFreeAli(&leftovers); } } return aliList; }
// // log a message into the kernel log buffer // // Filter rules to parse <PRI> <TIME> <tag> and <message> in order for // them to appear correct in the logcat output: // // LOG_KERN (0): // <PRI>[<TIME>] <tag> ":" <message> // <PRI>[<TIME>] <tag> <tag> ":" <message> // <PRI>[<TIME>] <tag> <tag>_work ":" <message> // <PRI>[<TIME>] <tag> '<tag>.<num>' ":" <message> // <PRI>[<TIME>] <tag> '<tag><num>' ":" <message> // <PRI>[<TIME>] <tag>_host '<tag>.<num>' ":" <message> // (unimplemented) <PRI>[<TIME>] <tag> '<num>.<tag>' ":" <message> // <PRI>[<TIME>] "[INFO]"<tag> : <message> // <PRI>[<TIME>] "------------[ cut here ]------------" (?) // <PRI>[<TIME>] "---[ end trace 3225a3070ca3e4ac ]---" (?) // LOG_USER, LOG_MAIL, LOG_DAEMON, LOG_AUTH, LOG_SYSLOG, LOG_LPR, LOG_NEWS // LOG_UUCP, LOG_CRON, LOG_AUTHPRIV, LOG_FTP: // <PRI+TAG>[<TIME>] (see sys/syslog.h) // Observe: // Minimum tag length = 3 NB: drops things like r5:c00bbadf, but allow PM: // Maximum tag words = 2 // Maximum tag length = 16 NB: we are thinking of how ugly logcat can get. // Not a Tag if there is no message content. // leading additional spaces means no tag, inherit last tag. // Not a Tag if <tag>: is "ERROR:", "WARNING:", "INFO:" or "CPU:" // Drop: // empty messages // messages with ' audit(' in them if auditd is running // logd.klogd: // return -1 if message logd.klogd: <signature> // int LogKlog::log(const char *buf, size_t len) { if (auditd && strnstr(buf, len, " audit(")) { return 0; } const char *p = buf; int pri = parseKernelPrio(&p, len); log_time now; sniffTime(now, &p, len - (p - buf), false); // sniff for start marker const char klogd_message[] = "logd.klogd: "; const char *start = strnstr(p, len - (p - buf), klogd_message); if (start) { uint64_t sig = strtoll(start + sizeof(klogd_message) - 1, NULL, 10); if (sig == signature.nsec()) { if (initialized) { enableLogging = true; } else { enableLogging = false; } return -1; } return 0; } if (!enableLogging) { return 0; } // Parse pid, tid and uid const pid_t pid = sniffPid(p, len - (p - buf)); const pid_t tid = pid; const uid_t uid = pid ? logbuf->pidToUid(pid) : 0; // Parse (rules at top) to pull out a tag from the incoming kernel message. // Some may view the following as an ugly heuristic, the desire is to // beautify the kernel logs into an Android Logging format; the goal is // admirable but costly. while ((p < &buf[len]) && (isspace(*p) || !*p)) { ++p; } if (p >= &buf[len]) { // timestamp, no content return 0; } start = p; const char *tag = ""; const char *etag = tag; size_t taglen = len - (p - buf); if (!isspace(*p) && *p) { const char *bt, *et, *cp; bt = p; if ((taglen >= 6) && !fast<strncmp>(p, "[INFO]", 6)) { // <PRI>[<TIME>] "[INFO]"<tag> ":" message bt = p + 6; taglen -= 6; } for(et = bt; taglen && *et && (*et != ':') && !isspace(*et); ++et, --taglen) { // skip ':' within [ ... ] if (*et == '[') { while (taglen && *et && *et != ']') { ++et; --taglen; } } } for(cp = et; taglen && isspace(*cp); ++cp, --taglen); size_t size; if (*cp == ':') { // One Word tag = bt; etag = et; p = cp + 1; } else if (taglen) { size = et - bt; if ((taglen > size) && // enough space for match plus trailing : (*bt == *cp) && // ubber fast<strncmp> pair fast<strncmp>(bt + 1, cp + 1, size - 1)) { // <PRI>[<TIME>] <tag>_host '<tag>.<num>' : message if (!fast<strncmp>(bt + size - 5, "_host", 5) && !fast<strncmp>(bt + 1, cp + 1, size - 6)) { const char *b = cp; cp += size - 5; taglen -= size - 5; if (*cp == '.') { while (--taglen && !isspace(*++cp) && (*cp != ':')); const char *e; for(e = cp; taglen && isspace(*cp); ++cp, --taglen); if (*cp == ':') { tag = b; etag = e; p = cp + 1; } } } else { while (--taglen && !isspace(*++cp) && (*cp != ':')); const char *e; for(e = cp; taglen && isspace(*cp); ++cp, --taglen); // Two words if (*cp == ':') { tag = bt; etag = e; p = cp + 1; } } } else if (isspace(cp[size])) { cp += size; taglen -= size; while (--taglen && isspace(*++cp)); // <PRI>[<TIME>] <tag> <tag> : message if (*cp == ':') { tag = bt; etag = et; p = cp + 1; } } else if (cp[size] == ':') { // <PRI>[<TIME>] <tag> <tag> : message tag = bt; etag = et; p = cp + size + 1; } else if ((cp[size] == '.') || isdigit(cp[size])) { // <PRI>[<TIME>] <tag> '<tag>.<num>' : message // <PRI>[<TIME>] <tag> '<tag><num>' : message const char *b = cp; cp += size; taglen -= size; while (--taglen && !isspace(*++cp) && (*cp != ':')); const char *e = cp; while (taglen && isspace(*cp)) { ++cp; --taglen; } if (*cp == ':') { tag = b; etag = e; p = cp + 1; } } else { while (--taglen && !isspace(*++cp) && (*cp != ':')); const char *e = cp; while (taglen && isspace(*cp)) { ++cp; --taglen; } // Two words if (*cp == ':') { tag = bt; etag = e; p = cp + 1; } } } /* else no tag */ size = etag - tag; if ((size <= 1) // register names like x9 || ((size == 2) && (isdigit(tag[0]) || isdigit(tag[1]))) // register names like x18 but not driver names like en0 || ((size == 3) && (isdigit(tag[1]) && isdigit(tag[2]))) // blacklist || ((size == 3) && !fast<strncmp>(tag, "CPU", 3)) || ((size == 7) && !fast<strncasecmp>(tag, "WARNING", 7)) || ((size == 5) && !fast<strncasecmp>(tag, "ERROR", 5)) || ((size == 4) && !fast<strncasecmp>(tag, "INFO", 4))) { p = start; etag = tag = ""; } } // Suppress additional stutter in tag: // eg: [143:healthd]healthd -> [143:healthd] taglen = etag - tag; // Mediatek-special printk induced stutter const char *mp = strnrchr(tag, ']', taglen); if (mp && (++mp < etag)) { size_t s = etag - mp; if (((s + s) < taglen) && !fast<memcmp>(mp, mp - 1 - s, s)) { taglen = mp - tag; } } // Deal with sloppy and simplistic harmless p = cp + 1 etc above. if (len < (size_t)(p - buf)) { p = &buf[len]; } // skip leading space while ((p < &buf[len]) && (isspace(*p) || !*p)) { ++p; } // truncate trailing space or nuls size_t b = len - (p - buf); while (b && (isspace(p[b-1]) || !p[b-1])) { --b; } // trick ... allow tag with empty content to be logged. log() drops empty if (!b && taglen) { p = " "; b = 1; } // paranoid sanity check, can not happen ... if (b > LOGGER_ENTRY_MAX_PAYLOAD) { b = LOGGER_ENTRY_MAX_PAYLOAD; } if (taglen > LOGGER_ENTRY_MAX_PAYLOAD) { taglen = LOGGER_ENTRY_MAX_PAYLOAD; } // calculate buffer copy requirements size_t n = 1 + taglen + 1 + b + 1; // paranoid sanity check, first two just can not happen ... if ((taglen > n) || (b > n) || (n > USHRT_MAX)) { return -EINVAL; } // Careful. // We are using the stack to house the log buffer for speed reasons. // If we malloc'd this buffer, we could get away without n's USHRT_MAX // test above, but we would then required a max(n, USHRT_MAX) as // truncating length argument to logbuf->log() below. Gain is protection // of stack sanity and speedup, loss is truncated long-line content. char newstr[n]; char *np = newstr; // Convert priority into single-byte Android logger priority *np = convertKernelPrioToAndroidPrio(pri); ++np; // Copy parsed tag following priority memcpy(np, tag, taglen); np += taglen; *np = '\0'; ++np; // Copy main message to the remainder memcpy(np, p, b); np[b] = '\0'; if (!isMonotonic()) { // Watch out for singular race conditions with timezone causing near // integer quarter-hour jumps in the time and compensate accordingly. // Entries will be temporal within near_seconds * 2. b/21868540 static uint32_t vote_time[3]; vote_time[2] = vote_time[1]; vote_time[1] = vote_time[0]; vote_time[0] = now.tv_sec; if (vote_time[1] && vote_time[2]) { static const unsigned near_seconds = 10; static const unsigned timezones_seconds = 900; int diff0 = (vote_time[0] - vote_time[1]) / near_seconds; unsigned abs0 = (diff0 < 0) ? -diff0 : diff0; int diff1 = (vote_time[1] - vote_time[2]) / near_seconds; unsigned abs1 = (diff1 < 0) ? -diff1 : diff1; if ((abs1 <= 1) && // last two were in agreement on timezone ((abs0 + 1) % (timezones_seconds / near_seconds)) <= 2) { abs0 = (abs0 + 1) / (timezones_seconds / near_seconds) * timezones_seconds; now.tv_sec -= (diff0 < 0) ? -abs0 : abs0; } } } // Log message int rc = logbuf->log(LOG_ID_KERNEL, now, uid, pid, tid, newstr, (unsigned short) n); // notify readers if (!rc) { reader->notifyNewLog(); } return rc; }
void LogKlog::sniffTime(log_time &now, const char **buf, size_t len, bool reverse) { const char *cp = now.strptime(*buf, "[ %s.%q]"); if (cp && (cp >= &(*buf)[len])) { cp = NULL; } if (cp) { static const char healthd[] = "healthd"; static const char battery[] = ": battery "; len -= cp - *buf; if (len && isspace(*cp)) { ++cp; --len; } *buf = cp; if (isMonotonic()) { return; } const char *b; if (((b = strnstr(cp, len, suspendStr))) && ((size_t)((b += sizeof(suspendStr) - 1) - cp) < len)) { len -= b - cp; calculateCorrection(now, b, len); } else if (((b = strnstr(cp, len, resumeStr))) && ((size_t)((b += sizeof(resumeStr) - 1) - cp) < len)) { len -= b - cp; calculateCorrection(now, b, len); } else if (((b = strnstr(cp, len, healthd))) && ((size_t)((b += sizeof(healthd) - 1) - cp) < len) && ((b = strnstr(b, len -= b - cp, battery))) && ((size_t)((b += sizeof(battery) - 1) - cp) < len)) { // NB: healthd is roughly 150us late, so we use it instead to // trigger a check for ntp-induced or hardware clock drift. log_time real(CLOCK_REALTIME); log_time mono(CLOCK_MONOTONIC); correction = (real < mono) ? log_time::EPOCH : (real - mono); } else if (((b = strnstr(cp, len, suspendedStr))) && ((size_t)((b += sizeof(suspendStr) - 1) - cp) < len)) { len -= b - cp; log_time real; char *endp; real.tv_sec = strtol(b, &endp, 10); if ((*endp == '.') && ((size_t)(endp - b) < len)) { unsigned long multiplier = NS_PER_SEC; real.tv_nsec = 0; len -= endp - b; while (--len && isdigit(*++endp) && (multiplier /= 10)) { real.tv_nsec += (*endp - '0') * multiplier; } if (reverse) { if (real > correction) { correction = log_time::EPOCH; } else { correction -= real; } } else { correction += real; } } } convertMonotonicToReal(now); } else { if (isMonotonic()) { now = log_time(CLOCK_MONOTONIC); } else { now = log_time(CLOCK_REALTIME); } } }
// // log a message into the kernel log buffer // // Filter rules to parse <PRI> <TIME> <tag> and <message> in order for // them to appear correct in the logcat output: // // LOG_KERN (0): // <PRI>[<TIME>] <tag> ":" <message> // <PRI>[<TIME>] <tag> <tag> ":" <message> // <PRI>[<TIME>] <tag> <tag>_work ":" <message> // <PRI>[<TIME>] <tag> '<tag>.<num>' ":" <message> // <PRI>[<TIME>] <tag> '<tag><num>' ":" <message> // <PRI>[<TIME>] <tag>_host '<tag>.<num>' ":" <message> // (unimplemented) <PRI>[<TIME>] <tag> '<num>.<tag>' ":" <message> // <PRI>[<TIME>] "[INFO]"<tag> : <message> // <PRI>[<TIME>] "------------[ cut here ]------------" (?) // <PRI>[<TIME>] "---[ end trace 3225a3070ca3e4ac ]---" (?) // LOG_USER, LOG_MAIL, LOG_DAEMON, LOG_AUTH, LOG_SYSLOG, LOG_LPR, LOG_NEWS // LOG_UUCP, LOG_CRON, LOG_AUTHPRIV, LOG_FTP: // <PRI+TAG>[<TIME>] (see sys/syslog.h) // Observe: // Minimum tag length = 3 NB: drops things like r5:c00bbadf, but allow PM: // Maximum tag words = 2 // Maximum tag length = 16 NB: we are thinking of how ugly logcat can get. // Not a Tag if there is no message content. // leading additional spaces means no tag, inherit last tag. // Not a Tag if <tag>: is "ERROR:", "WARNING:", "INFO:" or "CPU:" // Drop: // empty messages // messages with ' audit(' in them if auditd is running // logd.klogd: // return -1 if message logd.klogd: <signature> // int LogKlog::log(const char* buf, ssize_t len) { if (auditd && android::strnstr(buf, len, auditStr)) { return 0; } const char* p = buf; int pri = parseKernelPrio(p, len); log_time now; sniffTime(now, p, len - (p - buf), false); // sniff for start marker const char* start = android::strnstr(p, len - (p - buf), klogdStr); if (start) { uint64_t sig = strtoll(start + strlen(klogdStr), nullptr, 10); if (sig == signature.nsec()) { if (initialized) { enableLogging = true; } else { enableLogging = false; } return -1; } return 0; } if (!enableLogging) { return 0; } // Parse pid, tid and uid const pid_t pid = sniffPid(p, len - (p - buf)); const pid_t tid = pid; uid_t uid = AID_ROOT; if (pid) { logbuf->wrlock(); uid = logbuf->pidToUid(pid); logbuf->unlock(); } // Parse (rules at top) to pull out a tag from the incoming kernel message. // Some may view the following as an ugly heuristic, the desire is to // beautify the kernel logs into an Android Logging format; the goal is // admirable but costly. while ((p < &buf[len]) && (isspace(*p) || !*p)) { ++p; } if (p >= &buf[len]) { // timestamp, no content return 0; } start = p; const char* tag = ""; const char* etag = tag; ssize_t taglen = len - (p - buf); const char* bt = p; static const char infoBrace[] = "[INFO]"; static const ssize_t infoBraceLen = strlen(infoBrace); if ((taglen >= infoBraceLen) && !fastcmp<strncmp>(p, infoBrace, infoBraceLen)) { // <PRI>[<TIME>] "[INFO]"<tag> ":" message bt = p + infoBraceLen; taglen -= infoBraceLen; } const char* et; for (et = bt; (taglen > 0) && *et && (*et != ':') && !isspace(*et); ++et, --taglen) { // skip ':' within [ ... ] if (*et == '[') { while ((taglen > 0) && *et && *et != ']') { ++et; --taglen; } if (taglen <= 0) { break; } } } const char* cp; for (cp = et; (taglen > 0) && isspace(*cp); ++cp, --taglen) { } // Validate tag ssize_t size = et - bt; if ((taglen > 0) && (size > 0)) { if (*cp == ':') { // ToDo: handle case insensitive colon separated logging stutter: // <tag> : <tag>: ... // One Word tag = bt; etag = et; p = cp + 1; } else if ((taglen > size) && (tolower(*bt) == tolower(*cp))) { // clean up any tag stutter if (!fastcmp<strncasecmp>(bt + 1, cp + 1, size - 1)) { // no match // <PRI>[<TIME>] <tag> <tag> : message // <PRI>[<TIME>] <tag> <tag>: message // <PRI>[<TIME>] <tag> '<tag>.<num>' : message // <PRI>[<TIME>] <tag> '<tag><num>' : message // <PRI>[<TIME>] <tag> '<tag><stuff>' : message const char* b = cp; cp += size; taglen -= size; while ((--taglen > 0) && !isspace(*++cp) && (*cp != ':')) { } const char* e; for (e = cp; (taglen > 0) && isspace(*cp); ++cp, --taglen) { } if ((taglen > 0) && (*cp == ':')) { tag = b; etag = e; p = cp + 1; } } else { // what about <PRI>[<TIME>] <tag>_host '<tag><stuff>' : message static const char host[] = "_host"; static const ssize_t hostlen = strlen(host); if ((size > hostlen) && !fastcmp<strncmp>(bt + size - hostlen, host, hostlen) && !fastcmp<strncmp>(bt + 1, cp + 1, size - hostlen - 1)) { const char* b = cp; cp += size - hostlen; taglen -= size - hostlen; if (*cp == '.') { while ((--taglen > 0) && !isspace(*++cp) && (*cp != ':')) { } const char* e; for (e = cp; (taglen > 0) && isspace(*cp); ++cp, --taglen) { } if ((taglen > 0) && (*cp == ':')) { tag = b; etag = e; p = cp + 1; } } } else { goto twoWord; } } } else { // <PRI>[<TIME>] <tag> <stuff>' : message twoWord: while ((--taglen > 0) && !isspace(*++cp) && (*cp != ':')) { } const char* e; for (e = cp; (taglen > 0) && isspace(*cp); ++cp, --taglen) { } // Two words if ((taglen > 0) && (*cp == ':')) { tag = bt; etag = e; p = cp + 1; } } } // else no tag static const char cpu[] = "CPU"; static const ssize_t cpuLen = strlen(cpu); static const char warning[] = "WARNING"; static const ssize_t warningLen = strlen(warning); static const char error[] = "ERROR"; static const ssize_t errorLen = strlen(error); static const char info[] = "INFO"; static const ssize_t infoLen = strlen(info); size = etag - tag; if ((size <= 1) || // register names like x9 ((size == 2) && (isdigit(tag[0]) || isdigit(tag[1]))) || // register names like x18 but not driver names like en0 ((size == 3) && (isdigit(tag[1]) && isdigit(tag[2]))) || // blacklist ((size == cpuLen) && !fastcmp<strncmp>(tag, cpu, cpuLen)) || ((size == warningLen) && !fastcmp<strncasecmp>(tag, warning, warningLen)) || ((size == errorLen) && !fastcmp<strncasecmp>(tag, error, errorLen)) || ((size == infoLen) && !fastcmp<strncasecmp>(tag, info, infoLen))) { p = start; etag = tag = ""; } // Suppress additional stutter in tag: // eg: [143:healthd]healthd -> [143:healthd] taglen = etag - tag; // Mediatek-special printk induced stutter const char* mp = strnrchr(tag, taglen, ']'); if (mp && (++mp < etag)) { ssize_t s = etag - mp; if (((s + s) < taglen) && !fastcmp<memcmp>(mp, mp - 1 - s, s)) { taglen = mp - tag; } } // Deal with sloppy and simplistic harmless p = cp + 1 etc above. if (len < (p - buf)) { p = &buf[len]; } // skip leading space while ((p < &buf[len]) && (isspace(*p) || !*p)) { ++p; } // truncate trailing space or nuls ssize_t b = len - (p - buf); while ((b > 0) && (isspace(p[b - 1]) || !p[b - 1])) { --b; } // trick ... allow tag with empty content to be logged. log() drops empty if ((b <= 0) && (taglen > 0)) { p = " "; b = 1; } // paranoid sanity check, can not happen ... if (b > LOGGER_ENTRY_MAX_PAYLOAD) { b = LOGGER_ENTRY_MAX_PAYLOAD; } if (taglen > LOGGER_ENTRY_MAX_PAYLOAD) { taglen = LOGGER_ENTRY_MAX_PAYLOAD; } // calculate buffer copy requirements ssize_t n = 1 + taglen + 1 + b + 1; // paranoid sanity check, first two just can not happen ... if ((taglen > n) || (b > n) || (n > (ssize_t)USHRT_MAX) || (n <= 0)) { return -EINVAL; } // Careful. // We are using the stack to house the log buffer for speed reasons. // If we malloc'd this buffer, we could get away without n's USHRT_MAX // test above, but we would then required a max(n, USHRT_MAX) as // truncating length argument to logbuf->log() below. Gain is protection // of stack sanity and speedup, loss is truncated long-line content. char newstr[n]; char* np = newstr; // Convert priority into single-byte Android logger priority *np = convertKernelPrioToAndroidPrio(pri); ++np; // Copy parsed tag following priority memcpy(np, tag, taglen); np += taglen; *np = '\0'; ++np; // Copy main message to the remainder memcpy(np, p, b); np[b] = '\0'; if (!isMonotonic()) { // Watch out for singular race conditions with timezone causing near // integer quarter-hour jumps in the time and compensate accordingly. // Entries will be temporal within near_seconds * 2. b/21868540 static uint32_t vote_time[3]; vote_time[2] = vote_time[1]; vote_time[1] = vote_time[0]; vote_time[0] = now.tv_sec; if (vote_time[1] && vote_time[2]) { static const unsigned near_seconds = 10; static const unsigned timezones_seconds = 900; int diff0 = (vote_time[0] - vote_time[1]) / near_seconds; unsigned abs0 = (diff0 < 0) ? -diff0 : diff0; int diff1 = (vote_time[1] - vote_time[2]) / near_seconds; unsigned abs1 = (diff1 < 0) ? -diff1 : diff1; if ((abs1 <= 1) && // last two were in agreement on timezone ((abs0 + 1) % (timezones_seconds / near_seconds)) <= 2) { abs0 = (abs0 + 1) / (timezones_seconds / near_seconds) * timezones_seconds; now.tv_sec -= (diff0 < 0) ? -abs0 : abs0; } } } // Log message int rc = logbuf->log(LOG_ID_KERNEL, now, uid, pid, tid, newstr, (unsigned short)n); // notify readers if (!rc) { reader->notifyNewLog(); } return rc; }
void LogKlog::sniffTime(log_time& now, const char*& buf, ssize_t len, bool reverse) { if (len <= 0) return; const char* cp = nullptr; if ((len > 10) && (*buf == '[')) { cp = now.strptime(buf, "[ %s.%q]"); // can index beyond buffer bounds if (cp && (cp > &buf[len - 1])) cp = nullptr; } if (cp) { len -= cp - buf; if ((len > 0) && isspace(*cp)) { ++cp; --len; } buf = cp; if (isMonotonic()) return; const char* b; if (((b = android::strnstr(cp, len, suspendStr))) && (((b += strlen(suspendStr)) - cp) < len)) { len -= b - cp; calculateCorrection(now, b, len); } else if (((b = android::strnstr(cp, len, resumeStr))) && (((b += strlen(resumeStr)) - cp) < len)) { len -= b - cp; calculateCorrection(now, b, len); } else if (((b = android::strnstr(cp, len, healthdStr))) && (((b += strlen(healthdStr)) - cp) < len) && ((b = android::strnstr(b, len -= b - cp, batteryStr))) && (((b += strlen(batteryStr)) - cp) < len)) { // NB: healthd is roughly 150us late, so we use it instead to // trigger a check for ntp-induced or hardware clock drift. log_time real(CLOCK_REALTIME); log_time mono(CLOCK_MONOTONIC); correction = (real < mono) ? log_time::EPOCH : (real - mono); } else if (((b = android::strnstr(cp, len, suspendedStr))) && (((b += strlen(suspendStr)) - cp) < len)) { len -= b - cp; log_time real; char* endp; real.tv_sec = strtol(b, &endp, 10); if ((*endp == '.') && ((endp - b) < len)) { unsigned long multiplier = NS_PER_SEC; real.tv_nsec = 0; len -= endp - b; while (--len && isdigit(*++endp) && (multiplier /= 10)) { real.tv_nsec += (*endp - '0') * multiplier; } if (reverse) { if (real > correction) { correction = log_time::EPOCH; } else { correction -= real; } } else { correction += real; } } } convertMonotonicToReal(now); } else { if (isMonotonic()) { now = log_time(CLOCK_MONOTONIC); } else { now = log_time(CLOCK_REALTIME); } } }
QwtHighResolutionClock::QwtHighResolutionClock() { d_clockId = isMonotonic() ? CLOCK_MONOTONIC : CLOCK_REALTIME; d_timeStamp.tv_sec = d_timeStamp.tv_nsec = 0; }
int LogAudit::logPrint(const char *fmt, ...) { if (fmt == NULL) { return -EINVAL; } va_list args; char *str = NULL; va_start(args, fmt); int rc = vasprintf(&str, fmt, args); va_end(args); if (rc < 0) { return rc; } char *cp; while ((cp = strstr(str, " "))) { memmove(cp, cp + 1, strlen(cp + 1) + 1); } bool loaded = strstr(str, " policy loaded "); if (loaded) { if (policyLoaded) { // SELinux policy changes are not allowed enforceIntegrity(); } else { logToDmesg("policy loaded"); policyLoaded = true; } } bool permissive = strstr(str, " enforcing=0") || strstr(str, " permissive=1"); if (permissive) { // SELinux in permissive mode is not allowed enforceIntegrity(); } bool info = loaded || permissive; if ((fdDmesg >= 0) && initialized) { struct iovec iov[3]; static const char log_info[] = { KMSG_PRIORITY(LOG_INFO) }; static const char log_warning[] = { KMSG_PRIORITY(LOG_WARNING) }; iov[0].iov_base = info ? const_cast<char *>(log_info) : const_cast<char *>(log_warning); iov[0].iov_len = info ? sizeof(log_info) : sizeof(log_warning); iov[1].iov_base = str; iov[1].iov_len = strlen(str); iov[2].iov_base = const_cast<char *>("\n"); iov[2].iov_len = 1; writev(fdDmesg, iov, sizeof(iov) / sizeof(iov[0])); } pid_t pid = getpid(); pid_t tid = gettid(); uid_t uid = AID_LOGD; log_time now; static const char audit_str[] = " audit("; char *timeptr = strstr(str, audit_str); if (timeptr && ((cp = now.strptime(timeptr + sizeof(audit_str) - 1, "%s.%q"))) && (*cp == ':')) { memcpy(timeptr + sizeof(audit_str) - 1, "0.0", 3); memmove(timeptr + sizeof(audit_str) - 1 + 3, cp, strlen(cp) + 1); if (!isMonotonic()) { if (android::isMonotonic(now)) { LogKlog::convertMonotonicToReal(now); } } else { if (!android::isMonotonic(now)) { LogKlog::convertRealToMonotonic(now); } } } else if (isMonotonic()) { now = log_time(CLOCK_MONOTONIC); } else { now = log_time(CLOCK_REALTIME); } static const char pid_str[] = " pid="; char *pidptr = strstr(str, pid_str); if (pidptr && isdigit(pidptr[sizeof(pid_str) - 1])) { cp = pidptr + sizeof(pid_str) - 1; pid = 0; while (isdigit(*cp)) { pid = (pid * 10) + (*cp - '0'); ++cp; } tid = pid; logbuf->lock(); uid = logbuf->pidToUid(pid); logbuf->unlock(); memmove(pidptr, cp, strlen(cp) + 1); } // log to events size_t l = strnlen(str, LOGGER_ENTRY_MAX_PAYLOAD); size_t n = l + sizeof(android_log_event_string_t); bool notify = false; { // begin scope for event buffer uint32_t buffer[(n + sizeof(uint32_t) - 1) / sizeof(uint32_t)]; android_log_event_string_t *event = reinterpret_cast<android_log_event_string_t *>(buffer); event->header.tag = htole32(AUDITD_LOG_TAG); event->type = EVENT_TYPE_STRING; event->length = htole32(l); memcpy(event->data, str, l); rc = logbuf->log(LOG_ID_EVENTS, now, uid, pid, tid, reinterpret_cast<char *>(event), (n <= USHRT_MAX) ? (unsigned short) n : USHRT_MAX); if (rc >= 0) { notify = true; } // end scope for event buffer } // log to main static const char comm_str[] = " comm=\""; const char *comm = strstr(str, comm_str); const char *estr = str + strlen(str); const char *commfree = NULL; if (comm) { estr = comm; comm += sizeof(comm_str) - 1; } else if (pid == getpid()) { pid = tid; comm = "auditd"; } else { logbuf->lock(); comm = commfree = logbuf->pidToName(pid); logbuf->unlock(); if (!comm) { comm = "unknown"; } } const char *ecomm = strchr(comm, '"'); if (ecomm) { ++ecomm; l = ecomm - comm; } else { l = strlen(comm) + 1; ecomm = ""; } size_t b = estr - str; if (b > LOGGER_ENTRY_MAX_PAYLOAD) { b = LOGGER_ENTRY_MAX_PAYLOAD; } size_t e = strnlen(ecomm, LOGGER_ENTRY_MAX_PAYLOAD - b); n = b + e + l + 2; { // begin scope for main buffer char newstr[n]; *newstr = info ? ANDROID_LOG_INFO : ANDROID_LOG_WARN; strlcpy(newstr + 1, comm, l); strncpy(newstr + 1 + l, str, b); strncpy(newstr + 1 + l + b, ecomm, e); rc = logbuf->log(LOG_ID_MAIN, now, uid, pid, tid, newstr, (n <= USHRT_MAX) ? (unsigned short) n : USHRT_MAX); if (rc >= 0) { notify = true; } // end scope for main buffer } free(const_cast<char *>(commfree)); free(str); if (notify) { reader->notifyNewLog(); if (rc < 0) { rc = n; } } return rc; }
QElapsedTimer::ClockType QElapsedTimer::clockType() { return isMonotonic() ? MonotonicClock : SystemTime; }
/** * @return overall nonmonotonicity */ bool ExtSourceProperties::isNonmonotonic() const { return !isMonotonic(); }