diff options
| -rw-r--r-- | sys/conf/files | 1 | ||||
| -rw-r--r-- | sys/kern/subr_fattime.c | 304 | ||||
| -rw-r--r-- | sys/sys/clock.h | 3 |
3 files changed, 308 insertions, 0 deletions
diff --git a/sys/conf/files b/sys/conf/files index e255f24..c257af4 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -1374,6 +1374,7 @@ kern/subr_clock.c standard kern/subr_devstat.c standard kern/subr_disk.c standard kern/subr_eventhandler.c standard +kern/subr_fattime.c standard kern/subr_firmware.c optional firmware kern/subr_hints.c standard kern/subr_kdb.c standard diff --git a/sys/kern/subr_fattime.c b/sys/kern/subr_fattime.c new file mode 100644 index 0000000..2a280e5 --- /dev/null +++ b/sys/kern/subr_fattime.c @@ -0,0 +1,304 @@ +/*- + * Copyright (c) 2006 Poul-Henning Kamp + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + * + * Convert MS-DOS FAT format timestamps to and from unix timespecs + * + * FAT filestamps originally consisted of two 16 bit integers, encoded like + * this: + * + * yyyyyyymmmmddddd (year - 1980, month, day) + * + * hhhhhmmmmmmsssss (hour, minutes, seconds divided by two) + * + * Subsequently even Microsoft realized that files could be accessed in less + * than two seconds and a byte was added containing: + * + * sfffffff (second mod two, 100ths of second) + * + * FAT timestamps are in the local timezone, with no indication of which + * timezone much less if daylight savings time applies. + * + * Later on again, in Windows NT, timestamps were defined relative to GMT. + * + * Purists will point out that UTC replaced GMT for such uses around + * a century ago, already then. Ironically "NT" was an abbreviation of + * "New Technology". Anyway... + * + * The functions below always assume UTC time, and the calling code + * must apply the local timezone offset as appropriate. Unless special + * conditions apply, the utc_offset() function be used for this. + * + * The conversion functions below cut time into four-year leap-second + * cycles rather than single years and uses table lookups inside those + * cycles to get the months and years sorted out. + * + * Obviously we cannot calculate the correct table index going from + * a posix seconds count to Y/M/D, but we can get pretty close by + * dividing the daycount by 32 (giving a too low index), and then + * adjusting upwards a couple of steps if necessary. + * + * FAT timestamps have 7 bits for the year and starts at 1980, so + * they can represent up to 2107 which means that the non-leap-year + * 2100 must be handled. + * + * XXX: As long as time_t is 32 bits this is not relevant or easily + * XXX: testable. Revisit when time_t grows bigger. + * XXX: grepfodder: 64 bit time_t, y2100, y2.1k, 2100, leap year + * + */ + +#include <sys/param.h> +#include <sys/types.h> +#include <sys/time.h> +#include <sys/clock.h> + +#define DAY (24 * 60 * 60) /* Length of day in seconds */ +#define YEAR 365 /* Length of normal year */ +#define LYC (4 * YEAR + 1) /* Length of 4 year leap-year cycle */ +#define T1980 (10 * 365 + 2) /* Days from 1970 to 1980 */ + +/* End of month is N days from start of (normal) year */ +#define JAN 31 +#define FEB (JAN + 28) +#define MAR (FEB + 31) +#define APR (MAR + 30) +#define MAY (APR + 31) +#define JUN (MAY + 30) +#define JUL (JUN + 31) +#define AUG (JUL + 31) +#define SEP (AUG + 30) +#define OCT (SEP + 31) +#define NOV (OCT + 30) +#define DEC (NOV + 31) + +/* Table of months in a 4 year leap-year cycle */ + +#define ENC(y,m) (((y) << 9) | ((m) << 5)) + +static const struct { + uint16_t days; /* month start in days relative to cycle */ + uint16_t coded; /* encoded year + month information */ +} mtab[48] = { + { 0 + 0 * YEAR, ENC(0, 1) }, + + { JAN + 0 * YEAR, ENC(0, 2) }, { FEB + 0 * YEAR + 1, ENC(0, 3) }, + { MAR + 0 * YEAR + 1, ENC(0, 4) }, { APR + 0 * YEAR + 1, ENC(0, 5) }, + { MAY + 0 * YEAR + 1, ENC(0, 6) }, { JUN + 0 * YEAR + 1, ENC(0, 7) }, + { JUL + 0 * YEAR + 1, ENC(0, 8) }, { AUG + 0 * YEAR + 1, ENC(0, 9) }, + { SEP + 0 * YEAR + 1, ENC(0, 10) }, { OCT + 0 * YEAR + 1, ENC(0, 11) }, + { NOV + 0 * YEAR + 1, ENC(0, 12) }, { DEC + 0 * YEAR + 1, ENC(1, 1) }, + + { JAN + 1 * YEAR + 1, ENC(1, 2) }, { FEB + 1 * YEAR + 1, ENC(1, 3) }, + { MAR + 1 * YEAR + 1, ENC(1, 4) }, { APR + 1 * YEAR + 1, ENC(1, 5) }, + { MAY + 1 * YEAR + 1, ENC(1, 6) }, { JUN + 1 * YEAR + 1, ENC(1, 7) }, + { JUL + 1 * YEAR + 1, ENC(1, 8) }, { AUG + 1 * YEAR + 1, ENC(1, 9) }, + { SEP + 1 * YEAR + 1, ENC(1, 10) }, { OCT + 1 * YEAR + 1, ENC(1, 11) }, + { NOV + 1 * YEAR + 1, ENC(1, 12) }, { DEC + 1 * YEAR + 1, ENC(2, 1) }, + + { JAN + 2 * YEAR + 1, ENC(2, 2) }, { FEB + 2 * YEAR + 1, ENC(2, 3) }, + { MAR + 2 * YEAR + 1, ENC(2, 4) }, { APR + 2 * YEAR + 1, ENC(2, 5) }, + { MAY + 2 * YEAR + 1, ENC(2, 6) }, { JUN + 2 * YEAR + 1, ENC(2, 7) }, + { JUL + 2 * YEAR + 1, ENC(2, 8) }, { AUG + 2 * YEAR + 1, ENC(2, 9) }, + { SEP + 2 * YEAR + 1, ENC(2, 10) }, { OCT + 2 * YEAR + 1, ENC(2, 11) }, + { NOV + 2 * YEAR + 1, ENC(2, 12) }, { DEC + 2 * YEAR + 1, ENC(3, 1) }, + + { JAN + 3 * YEAR + 1, ENC(3, 2) }, { FEB + 3 * YEAR + 1, ENC(3, 3) }, + { MAR + 3 * YEAR + 1, ENC(3, 4) }, { APR + 3 * YEAR + 1, ENC(3, 5) }, + { MAY + 3 * YEAR + 1, ENC(3, 6) }, { JUN + 3 * YEAR + 1, ENC(3, 7) }, + { JUL + 3 * YEAR + 1, ENC(3, 8) }, { AUG + 3 * YEAR + 1, ENC(3, 9) }, + { SEP + 3 * YEAR + 1, ENC(3, 10) }, { OCT + 3 * YEAR + 1, ENC(3, 11) }, + { NOV + 3 * YEAR + 1, ENC(3, 12) } +}; + + +void +timet2fattime(struct timespec *tsp, u_int16_t *ddp, u_int16_t *dtp, u_int8_t *dhp) +{ + time_t t1; + unsigned t2, l, m; + + t1 = tsp->tv_sec; + + if (dhp != NULL) + *dhp = (tsp->tv_sec & 1) * 100 + tsp->tv_nsec / 10000000; + if (dtp != NULL) { + *dtp = (t1 / 2) % 30; + *dtp |= ((t1 / 60) % 60) << 5; + *dtp |= ((t1 / 3600) % 24) << 11; + } + if (ddp != NULL) { + t2 = t1 / DAY; + if (t2 < T1980) { + /* Impossible date, truncate to 1980-01-01 */ + *ddp = 0x0021; + } else { + t2 -= T1980; + + /* + * 2100 is not a leap year. + * XXX: a 32 bit time_t can not get us here. + */ + if (t2 >= ((2100 - 1980) / 4 * LYC + FEB)) + t2++; + + /* Account for full leapyear cycles */ + l = t2 / LYC; + *ddp = (l * 4) << 9; + t2 -= l * LYC; + + /* Find approximate table entry */ + m = t2 / 32; + + /* Find correct table entry */ + while (m < 47 && mtab[m + 1].days <= t2) + m++; + + /* Get year + month from the table */ + *ddp += mtab[m].coded; + + /* And apply the day in the month */ + t2 -= mtab[m].days - 1; + *ddp |= t2; + } + } +} + +/* + * Table indexed by the bottom two bits of year + four bits of the month + * from the FAT timestamp, returning number of days into 4 year long + * leap-year cycle + */ + +#define DCOD(m, y, l) ((m) + YEAR * (y) + (l)) +static const uint16_t daytab[64] = { + 0, DCOD( 0, 0, 0), DCOD(JAN, 0, 0), DCOD(FEB, 0, 1), + DCOD(MAR, 0, 1), DCOD(APR, 0, 1), DCOD(MAY, 0, 1), DCOD(JUN, 0, 1), + DCOD(JUL, 0, 1), DCOD(AUG, 0, 1), DCOD(SEP, 0, 1), DCOD(OCT, 0, 1), + DCOD(NOV, 0, 1), DCOD(DEC, 0, 1), 0, 0, + 0, DCOD( 0, 1, 1), DCOD(JAN, 1, 1), DCOD(FEB, 1, 1), + DCOD(MAR, 1, 1), DCOD(APR, 1, 1), DCOD(MAY, 1, 1), DCOD(JUN, 1, 1), + DCOD(JUL, 1, 1), DCOD(AUG, 1, 1), DCOD(SEP, 1, 1), DCOD(OCT, 1, 1), + DCOD(NOV, 1, 1), DCOD(DEC, 1, 1), 0, 0, + 0, DCOD( 0, 2, 1), DCOD(JAN, 2, 1), DCOD(FEB, 2, 1), + DCOD(MAR, 2, 1), DCOD(APR, 2, 1), DCOD(MAY, 2, 1), DCOD(JUN, 2, 1), + DCOD(JUL, 2, 1), DCOD(AUG, 2, 1), DCOD(SEP, 2, 1), DCOD(OCT, 2, 1), + DCOD(NOV, 2, 1), DCOD(DEC, 2, 1), 0, 0, + 0, DCOD( 0, 3, 1), DCOD(JAN, 3, 1), DCOD(FEB, 3, 1), + DCOD(MAR, 3, 1), DCOD(APR, 3, 1), DCOD(MAY, 3, 1), DCOD(JUN, 3, 1), + DCOD(JUL, 3, 1), DCOD(AUG, 3, 1), DCOD(SEP, 3, 1), DCOD(OCT, 3, 1), + DCOD(NOV, 3, 1), DCOD(DEC, 3, 1), 0, 0 +}; + +void +fattime2timet(unsigned dd, unsigned dt, unsigned dh, struct timespec *tsp) +{ + unsigned day; + + /* Unpack time fields */ + tsp->tv_sec = (dt & 0x1f) << 1; + tsp->tv_sec += ((dt & 0x7e0) >> 5) * 60; + tsp->tv_sec += ((dt & 0xf800) >> 11) * 3600; + tsp->tv_sec += dh / 100; + tsp->tv_nsec = (dh % 100) * 10000000; + + /* Day of month */ + day = (dd & 0x1f) - 1; + + /* Full leap-year cycles */ + day += LYC * ((dd >> 11) & 0x1f); + + /* Month offset from leap-year cycle */ + day += daytab[(dd >> 5) & 0x3f]; + + /* + * 2100 is not a leap year. + * XXX: a 32 bit time_t can not get us here. + */ + if (day >= ((2100 - 1980) / 4 * LYC + FEB)) + day--; + + /* Align with time_t epoch */ + day += T1980; + + tsp->tv_sec += DAY * day; +} + +#ifdef TEST_DRIVER + +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> + +int +main(int argc __unused, char **argv __unused) +{ + int i; + struct timespec ts; + struct tm tm; + double a; + u_int16_t d, t; + u_int8_t p; + char buf[100]; + + for (i = 0; i < 10000; i++) { + do { + ts.tv_sec = random(); + } while (ts.tv_sec < T1980 * 86400); + ts.tv_nsec = random() % 1000000000; + + printf("%10d.%03ld -- ", ts.tv_sec, ts.tv_nsec / 1000000); + + gmtime_r(&ts.tv_sec, &tm); + strftime(buf, sizeof buf, "%Y %m %d %H %M %S", &tm); + printf("%s -- ", buf); + + a = ts.tv_sec + ts.tv_nsec * 1e-9; + d = t = p = 0; + timet2fattime(&ts, &d, &t, &p); + printf("%04x %04x %02x -- ", d, t, p); + printf("%3d %02d %02d %02d %02d %02d -- ", + ((d >> 9) & 0x7f) + 1980, + (d >> 5) & 0x0f, + (d >> 0) & 0x1f, + (t >> 11) & 0x1f, + (t >> 5) & 0x3f, + ((t >> 0) & 0x1f) * 2); + + ts.tv_sec = ts.tv_nsec = 0; + fattime2timet(d, t, p, &ts); + printf("%10d.%03ld == ", ts.tv_sec, ts.tv_nsec / 1000000); + gmtime_r(&ts.tv_sec, &tm); + strftime(buf, sizeof buf, "%Y %m %d %H %M %S", &tm); + printf("%s -- ", buf); + a -= ts.tv_sec + ts.tv_nsec * 1e-9; + printf("%.3f", a); + printf("\n"); + } + return (0); +} + +#endif /* TEST_DRIVER */ diff --git a/sys/sys/clock.h b/sys/sys/clock.h index 072328d..5c0252d 100644 --- a/sys/sys/clock.h +++ b/sys/sys/clock.h @@ -93,6 +93,9 @@ void clock_register(device_t, long); /* Traditional POSIX base year */ #define POSIX_BASE_YEAR 1970 +void timet2fattime(struct timespec *tsp, u_int16_t *ddp, u_int16_t *dtp, u_int8_t *dhp); +void fattime2timet(unsigned dd, unsigned dt, unsigned dh, struct timespec *tsp); + #endif /* _KERNEL */ #endif /* !_SYS_CLOCK_H_ */ |
