I'm trying to compile drivers. do_posix_clock_monotonic_gettime was used in the source code and I'm made sure that the file had #include <linux/time.h>. I was getting implicit declaration when I tried to compile it. When I opened time.h file on my disk, it didn't have do_posix_clock_monotonic_gettime declared. Can someone help me with this?Here is the content of time.h#ifndef _LINUX_TIME_H#define _LINUX_TIME_H# include <linux/cache.h># include <linux/seqlock.h># include <linux/math64.h># include <linux/time64.h>extern struct timezone sys_tz;#define TIME_T_MAX  (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)static inline int timespec_equal(const struct timespec *a,                                 const struct timespec *b){    return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);}/* * lhs < rhs:  return <0 * lhs == rhs: return 0 * lhs > rhs:  return >0 */static inline int timespec_compare(const struct timespec *lhs, const struct timespec *rhs){    if (lhs->tv_sec < rhs->tv_sec)        return -1;    if (lhs->tv_sec > rhs->tv_sec)        return 1;    return lhs->tv_nsec - rhs->tv_nsec;}static inline int timeval_compare(const struct timeval *lhs, const struct timeval *rhs){    if (lhs->tv_sec < rhs->tv_sec)        return -1;    if (lhs->tv_sec > rhs->tv_sec)        return 1;    return lhs->tv_usec - rhs->tv_usec;}extern time64_t mktime64(const unsigned int year, const unsigned int mon,            const unsigned int day, const unsigned int hour,            const unsigned int min, const unsigned int sec);/** * Deprecated. Use mktime64(). */static inline unsigned long mktime(const unsigned int year,            const unsigned int mon, const unsigned int day,            const unsigned int hour, const unsigned int min,            const unsigned int sec){    return mktime64(year, mon, day, hour, min, sec);}extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);/* * timespec_add_safe assumes both values are positive and checks * for overflow. It will return TIME_T_MAX if the reutrn would be * smaller then either of the arguments. */extern struct timespec timespec_add_safe(const struct timespec lhs,                     const struct timespec rhs);static inline struct timespec timespec_add(struct timespec lhs,                        struct timespec rhs){    struct timespec ts_delta;    set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,                lhs.tv_nsec + rhs.tv_nsec);    return ts_delta;}/* * sub = lhs - rhs, in normalized form */static inline struct timespec timespec_sub(struct timespec lhs,                        struct timespec rhs){    struct timespec ts_delta;    set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,                lhs.tv_nsec - rhs.tv_nsec);    return ts_delta;}/* * Returns true if the timespec is norm, false if denorm: */static inline bool timespec_valid(const struct timespec *ts){    /* Dates before 1970 are bogus */    if (ts->tv_sec < 0)        return false;    /* Can't have more nanoseconds then a second */    if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)        return false;    return true;}static inline bool timespec_valid_strict(const struct timespec *ts){    if (!timespec_valid(ts))        return false;    /* Disallow values that could overflow ktime_t */    if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)        return false;    return true;}static inline bool timeval_valid(const struct timeval *tv){    /* Dates before 1970 are bogus */    if (tv->tv_sec < 0)        return false;    /* Can't have more microseconds then a second */    if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)        return false;    return true;}extern struct timespec timespec_trunc(struct timespec t, unsigned gran);/* * Validates if a timespec/timeval used to inject a time offset is valid. * Offsets can be postive or negative. The value of the timeval/timespec * is the sum of its fields, but *NOTE*: the field tv_usec/tv_nsec must * always be non-negative. */static inline bool timeval_inject_offset_valid(const struct timeval *tv){    /* We don't check the tv_sec as it can be positive or negative */    /* Can't have more microseconds then a second */    if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)        return false;    return true;}static inline bool timespec_inject_offset_valid(const struct timespec *ts){    /* We don't check the tv_sec as it can be positive or negative */    /* Can't have more nanoseconds then a second */    if (ts->tv_nsec < 0 || ts->tv_nsec >= NSEC_PER_SEC)        return false;    return true;}#define CURRENT_TIME        (current_kernel_time())#define CURRENT_TIME_SEC    ((struct timespec) { get_seconds(), 0 })/* Some architectures do not supply their own clocksource. * This is mainly the case in architectures that get their * inter-tick times by reading the counter on their interval * timer. Since these timers wrap every tick, they're not really * useful as clocksources. Wrapping them to act like one is possible * but not very efficient. So we provide a callout these arches * can implement for use with the jiffies clocksource to provide * finer then tick granular time. */#ifdef CONFIG_ARCH_USES_GETTIMEOFFSETextern u32 (*arch_gettimeoffset)(void);#endifstruct itimerval;extern int do_setitimer(int which, struct itimerval *value,            struct itimerval *ovalue);extern int do_getitimer(int which, struct itimerval *value);extern unsigned int alarm_setitimer(unsigned int seconds);extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);struct tms;extern void do_sys_times(struct tms *);/* * Similar to the struct tm in userspace <time.h>, but it needs to be here so * that the kernel source is self contained. */struct tm {    /*     * the number of seconds after the minute, normally in the range     * 0 to 59, but can be up to 60 to allow for leap seconds     */    int tm_sec;    /* the number of minutes after the hour, in the range 0 to 59*/    int tm_min;    /* the number of hours past midnight, in the range 0 to 23 */    int tm_hour;    /* the day of the month, in the range 1 to 31 */    int tm_mday;    /* the number of months since January, in the range 0 to 11 */    int tm_mon;    /* the number of years since 1900 */    long tm_year;    /* the number of days since Sunday, in the range 0 to 6 */    int tm_wday;    /* the number of days since January 1, in the range 0 to 365 */    int tm_yday;};void time_to_tm(time_t totalsecs, int offset, struct tm *result);/** * timespec_to_ns - Convert timespec to nanoseconds * @ts:     pointer to the timespec variable to be converted * * Returns the scalar nanosecond representation of the timespec * parameter. */static inline s64 timespec_to_ns(const struct timespec *ts){    return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;}/** * timeval_to_ns - Convert timeval to nanoseconds * @ts:     pointer to the timeval variable to be converted * * Returns the scalar nanosecond representation of the timeval * parameter. */static inline s64 timeval_to_ns(const struct timeval *tv){    return ((s64) tv->tv_sec * NSEC_PER_SEC) +        tv->tv_usec * NSEC_PER_USEC;}/** * ns_to_timespec - Convert nanoseconds to timespec * @nsec:   the nanoseconds value to be converted * * Returns the timespec representation of the nsec parameter. */extern struct timespec ns_to_timespec(const s64 nsec);/** * ns_to_timeval - Convert nanoseconds to timeval * @nsec:   the nanoseconds value to be converted * * Returns the timeval representation of the nsec parameter. */extern struct timeval ns_to_timeval(const s64 nsec);/** * timespec_add_ns - Adds nanoseconds to a timespec * @a:      pointer to timespec to be incremented * @ns:     unsigned nanoseconds value to be added * * This must always be inlined because its used from the x86-64 vdso, * which cannot call other kernel functions. */static __always_inline void timespec_add_ns(struct timespec *a, u64 ns){    a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);    a->tv_nsec = ns;}#endifUsing kernel 4.7.2-1 on Arch.Thanks in advance.Edit: I used configure and make. But didn't work. It was giving me an error regarding time and date. Exactly this is what I got error: macro __DATE__ might prevent reproducible builds [-Werror=date-time]. So, I supressed the warning by adding extra cflag Wno-error=date-time. Now I get this error: implicit declaration of function do_posix_clock_monotonic_gettime [-Werror=implicit-function-declaration]   do_posix_clock_monotonic_gettime(&tstamp);The code that was causing error isstatic void snd_timer_notify1(struct snd_timer_instance *ti, int event){    struct snd_timer *timer;    unsigned long flags;    unsigned long resolution = 0;    struct snd_timer_instance *ts;    struct timespec tstamp;    if (timer_tstamp_monotonic)        do_posix_clock_monotonic_gettime(&tstamp);    else        getnstimeofday(&tstamp);    if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_START ||               event > SNDRV_TIMER_EVENT_PAUSE))        return;    if (event == SNDRV_TIMER_EVENT_START ||        event == SNDRV_TIMER_EVENT_CONTINUE)        resolution = snd_timer_resolution(ti);    if (ti->ccallback)        ti->ccallback(ti, event, &tstamp, resolution);    if (ti->flags & SNDRV_TIMER_IFLG_SLAVE)        return;    timer = ti->timer;    if (timer == NULL)        return;    if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)        return;    spin_lock_irqsave(&timer->lock, flags);    list_for_each_entry(ts, &ti->slave_active_head, active_list)        if (ts->ccallback)            ts->ccallback(ti, event + 100, &tstamp, resolution);    spin_unlock_irqrestore(&timer->lock, flags);}There is one more function that uses do_posix_clock_monotime_gettime. It's code is:static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri,                      unsigned long resolution,                      unsigned long ticks){    struct snd_timer_user *tu = timeri->callback_data;    struct snd_timer_tread *r, r1;    struct timespec tstamp;    int prev, append = 0;    memset(&tstamp, 0, sizeof(tstamp));    spin_lock(&tu->qlock);    if ((tu->filter & ((1 << SNDRV_TIMER_EVENT_RESOLUTION) |               (1 << SNDRV_TIMER_EVENT_TICK))) == 0) {        spin_unlock(&tu->qlock);        return;    }    if (tu->last_resolution != resolution || ticks > 0) {        if (timer_tstamp_monotonic)            do_posix_clock_monotonic_gettime(&tstamp);        else            getnstimeofday(&tstamp);    }    if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) &&        tu->last_resolution != resolution) {        r1.event = SNDRV_TIMER_EVENT_RESOLUTION;        r1.tstamp = tstamp;        r1.val = resolution;        snd_timer_user_append_to_tqueue(tu, &r1);        tu->last_resolution = resolution;        append++;    }    if ((tu->filter & (1 << SNDRV_TIMER_EVENT_TICK)) == 0)        goto __wake;    if (ticks == 0)        goto __wake;    if (tu->qused > 0) {        prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;        r = &tu->tqueue[prev];        if (r->event == SNDRV_TIMER_EVENT_TICK) {            r->tstamp = tstamp;            r->val += ticks;            append++;            goto __wake;        }    }    r1.event = SNDRV_TIMER_EVENT_TICK;    r1.tstamp = tstamp;    r1.val = ticks;    snd_timer_user_append_to_tqueue(tu, &r1);    append++;      __wake:    spin_unlock(&tu->qlock);    if (append == 0)        return;    kill_fasync(&tu->fasync, SIGIO, POLL_IN);    wake_up(&tu->qchange_sleep);}
do_posix_clock_monotonic_gettime is missing in linux/time.h
linux kernel;proprietary drivers
The problem caused by removal of a #define do_posix_clock_monotonic_gettime before kernel 4.0.It used to be defined as:#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)You could include that define into some of driver's headers.Also, note that ktime_get_ts is defined in linux/timekeeping.h of 4.7.2.Also, I would not expect the driver to function properly under 4.7.2 for sure, as it seems it has only been tested under 3.x.x. Though, give it a try.I hope that helps