void sw_timeString(char *buf) {
buf[0]=0;
if(readDays()>0)sprintf(buf,"%d days ",readDays());
buf=strchr(buf,0);
if(readHours()>0)sprintf(buf,"%d hours ",readHours());
buf=strchr(buf,0);
if(readMinutes()>0)sprintf(buf,"%d min. ",readMinutes());
buf=strchr(buf,0);
if(readSeconds()>0)sprintf(buf,"%d seconds ",readSeconds());
buf=strchr(buf,0);
sprintf(buf,"%d ms ",readmSeconds());
}
/**
* Read the registers from the Real Time Clock.
*
* It reads the registers from the RTC and stores the data in the struct which
* pointer it receives. It handles the different types of format in which the data
* is stored in the RTC registers.
*
* @param regs Pointer to struct where the data from RTC registers will be stored.
*
*/
void readRTCRegisters(RTCRegisters *regs){
int format;
// Getting format register
outB(RTCADDRESS, 11);
format = inB(RTCDATA);
// Getting seconds
regs->seconds = readSeconds();
// Getting minutes
regs->minutes = readMinutes();
// Getting hours (value may be 12hs o 24hs format)
regs->hours = readHours();
// Getting day of the month
regs->day = readDay();
// Getting month
regs->month = readMonth();
// Getting year
regs->year = readYear();
// Getting century
regs->century = readCentury();
// If in BCD mode, convert to binary
if ((format & 0x02) == 0x02 ) {
regs->seconds = BCDTOBINARY(regs->seconds);
regs->minutes = BCDTOBINARY( regs->minutes);
regs->hours = BCDTOBINARY(regs->hours);
regs->day = BCDTOBINARY(regs->day );
regs->month = BCDTOBINARY(regs->month);
regs->year = BCDTOBINARY(regs->year);
regs->century = BCDTOBINARY(regs->century);
}
// If in 12 hs mode, convert to 24 hs mode
if ((format & 0x04) == 0x04) {
// Masking off the pm/am bit
if ( (regs->hours & 0x80) == 0x80 ) {
regs->hours &= 0x7F;
// Setting 12 pm as 0 regs->hours and adjusting the rest
regs->hours = (regs->hours == 12)? 0 : regs->hours + 12;
}
}
}
static void convertMonotonic(struct timespec *result,
const AndroidLogEntry *entry)
{
struct listnode *node;
struct conversionList {
struct listnode node; /* first */
struct timespec time;
struct timespec convert;
} *list, *next;
struct timespec time, convert;
/* If we do not have a conversion list, build one up */
if (list_empty(&convertHead)) {
bool suspended_pending = false;
struct timespec suspended_monotonic = { 0, 0 };
struct timespec suspended_diff = { 0, 0 };
/*
* Read dmesg for _some_ synchronization markers and insert
* Anything in the Android Logger before the dmesg logging span will
* be highly suspect regarding the monotonic time calculations.
*/
FILE *p = popen("/system/bin/dmesg", "re");
if (p) {
char *line = NULL;
size_t len = 0;
while (getline(&line, &len, p) > 0) {
static const char suspend[] = "PM: suspend entry ";
static const char resume[] = "PM: suspend exit ";
static const char healthd[] = "healthd";
static const char battery[] = ": battery ";
static const char suspended[] = "Suspended for ";
struct timespec monotonic;
struct tm tm;
char *cp, *e = line;
bool add_entry = true;
if (*e == '<') {
while (*e && (*e != '>')) {
++e;
}
if (*e != '>') {
continue;
}
}
if (*e != '[') {
continue;
}
while (*++e == ' ') {
;
}
e = readSeconds(e, &monotonic);
if (!e || (*e != ']')) {
continue;
}
if ((e = strstr(e, suspend))) {
e += sizeof(suspend) - 1;
} else if ((e = strstr(line, resume))) {
e += sizeof(resume) - 1;
} else if (((e = strstr(line, healthd)))
&& ((e = strstr(e + sizeof(healthd) - 1, battery)))) {
/* NB: healthd is roughly 150us late, worth the price to
* deal with ntp-induced or hardware clock drift. */
e += sizeof(battery) - 1;
} else if ((e = strstr(line, suspended))) {
e += sizeof(suspended) - 1;
e = readSeconds(e, &time);
if (!e) {
continue;
}
add_entry = false;
suspended_pending = true;
suspended_monotonic = monotonic;
suspended_diff = time;
} else {
continue;
}
if (add_entry) {
/* look for "????-??-?? ??:??:??.????????? UTC" */
cp = strstr(e, " UTC");
if (!cp || ((cp - e) < 29) || (cp[-10] != '.')) {
continue;
}
e = cp - 29;
cp = readSeconds(cp - 10, &time);
if (!cp) {
continue;
}
cp = strptime(e, "%Y-%m-%d %H:%M:%S.", &tm);
if (!cp) {
continue;
}
cp = getenv(tz);
if (cp) {
cp = strdup(cp);
}
setenv(tz, utc, 1);
time.tv_sec = mktime(&tm);
if (cp) {
setenv(tz, cp, 1);
free(cp);
} else {
unsetenv(tz);
}
list = calloc(1, sizeof(struct conversionList));
list_init(&list->node);
list->time = time;
subTimespec(&list->convert, &time, &monotonic);
list_add_tail(&convertHead, &list->node);
}
if (suspended_pending && !list_empty(&convertHead)) {
list = node_to_item(list_tail(&convertHead),
struct conversionList, node);
if (subTimespec(&time,
subTimespec(&time,
&list->time,
&list->convert),
&suspended_monotonic)->tv_sec > 0) {
/* resume, what is convert factor before? */
subTimespec(&convert, &list->convert, &suspended_diff);
} else {
/* suspend */
convert = list->convert;
}
time = suspended_monotonic;
sumTimespec(&time, &convert);
/* breakpoint just before sleep */
list = calloc(1, sizeof(struct conversionList));
list_init(&list->node);
list->time = time;
list->convert = convert;
list_add_tail(&convertHead, &list->node);
/* breakpoint just after sleep */
list = calloc(1, sizeof(struct conversionList));
list_init(&list->node);
list->time = time;
sumTimespec(&list->time, &suspended_diff);
list->convert = convert;
sumTimespec(&list->convert, &suspended_diff);
list_add_tail(&convertHead, &list->node);
suspended_pending = false;
}
}
pclose(p);
}