offsetof (struct cpuinfo_ia64, ptce_stride));
        BLANK();
        DEFINE(IA64_TIMESPEC_TV_NSEC_OFFSET,
-              offsetof (struct timespec, tv_nsec));
+              offsetof (struct __kernel_old_timespec, tv_nsec));
        DEFINE(IA64_TIME_SN_SPEC_SNSEC_OFFSET,
               offsetof (struct time_sn_spec, snsec));
 
 
 }
 
 static notrace long clock_gettime_fallback(clockid_t _clkid,
-                                          struct timespec *_ts)
+                                          struct __kernel_old_timespec *_ts)
 {
-       register struct timespec *ts asm("$r1") = _ts;
+       register struct __kernel_old_timespec *ts asm("$r1") = _ts;
        register clockid_t clkid asm("$r0") = _clkid;
        register long ret asm("$r0");
 
        return ret;
 }
 
-static notrace int do_realtime_coarse(struct timespec *ts,
+static notrace int do_realtime_coarse(struct __kernel_old_timespec *ts,
                                      struct vdso_data *vdata)
 {
        u32 seq;
        return 0;
 }
 
-static notrace int do_monotonic_coarse(struct timespec *ts,
+static notrace int do_monotonic_coarse(struct __kernel_old_timespec *ts,
                                       struct vdso_data *vdata)
 {
        struct timespec tomono;
        return ((u64) cycle_delta & vdso->cs_mask) * vdso->cs_mult;
 }
 
-static notrace int do_realtime(struct timespec *ts, struct vdso_data *vdata)
+static notrace int do_realtime(struct __kernel_old_timespec *ts, struct vdso_data *vdata)
 {
        unsigned count;
        u64 ns;
        return 0;
 }
 
-static notrace int do_monotonic(struct timespec *ts, struct vdso_data *vdata)
+static notrace int do_monotonic(struct __kernel_old_timespec *ts, struct vdso_data *vdata)
 {
        struct timespec tomono;
        u64 nsecs;
        return 0;
 }
 
-notrace int __vdso_clock_gettime(clockid_t clkid, struct timespec *ts)
+notrace int __vdso_clock_gettime(clockid_t clkid, struct __kernel_old_timespec *ts)
 {
        struct vdso_data *vdata;
        int ret = -1;
 }
 
 static notrace int clock_getres_fallback(clockid_t _clk_id,
-                                         struct timespec *_res)
+                                         struct __kernel_old_timespec *_res)
 {
        register clockid_t clk_id asm("$r0") = _clk_id;
-       register struct timespec *res asm("$r1") = _res;
+       register struct __kernel_old_timespec *res asm("$r1") = _res;
        register int ret asm("$r0");
 
        asm volatile ("movi     $r15, %3\n"
        return ret;
 }
 
-notrace int __vdso_clock_getres(clockid_t clk_id, struct timespec *res)
+notrace int __vdso_clock_getres(clockid_t clk_id, struct __kernel_old_timespec *res)
 {
        struct vdso_data *vdata = __get_datapage();
 
 
 notrace int __vdso_gettimeofday(struct __kernel_old_timeval *tv, struct timezone *tz)
 {
-       struct timespec ts;
+       struct __kernel_old_timespec ts;
        struct vdso_data *vdata;
        int ret;
 
 
        return (struct vvar_data *) ret;
 }
 
-notrace static long vdso_fallback_gettime(long clock, struct timespec *ts)
+notrace static long vdso_fallback_gettime(long clock, struct __kernel_old_timespec *ts)
 {
        register long num __asm__("g1") = __NR_clock_gettime;
        register long o0 __asm__("o0") = clock;
 }
 
 notrace static __always_inline int do_realtime(struct vvar_data *vvar,
-                                              struct timespec *ts)
+                                              struct __kernel_old_timespec *ts)
 {
        unsigned long seq;
        u64 ns;
 }
 
 notrace static __always_inline int do_realtime_stick(struct vvar_data *vvar,
-                                                    struct timespec *ts)
+                                                    struct __kernel_old_timespec *ts)
 {
        unsigned long seq;
        u64 ns;
 }
 
 notrace static __always_inline int do_monotonic(struct vvar_data *vvar,
-                                               struct timespec *ts)
+                                               struct __kernel_old_timespec *ts)
 {
        unsigned long seq;
        u64 ns;
 }
 
 notrace static __always_inline int do_monotonic_stick(struct vvar_data *vvar,
-                                                     struct timespec *ts)
+                                                     struct __kernel_old_timespec *ts)
 {
        unsigned long seq;
        u64 ns;
 }
 
 notrace static int do_realtime_coarse(struct vvar_data *vvar,
-                                     struct timespec *ts)
+                                     struct __kernel_old_timespec *ts)
 {
        unsigned long seq;
 
 }
 
 notrace static int do_monotonic_coarse(struct vvar_data *vvar,
-                                      struct timespec *ts)
+                                      struct __kernel_old_timespec *ts)
 {
        unsigned long seq;
 
 }
 
 notrace int
-__vdso_clock_gettime(clockid_t clock, struct timespec *ts)
+__vdso_clock_gettime(clockid_t clock, struct __kernel_old_timespec *ts)
 {
        struct vvar_data *vvd = get_vvar_data();
 
        return vdso_fallback_gettime(clock, ts);
 }
 int
-clock_gettime(clockid_t, struct timespec *)
+clock_gettime(clockid_t, struct __kernel_old_timespec *)
        __attribute__((weak, alias("__vdso_clock_gettime")));
 
 notrace int
-__vdso_clock_gettime_stick(clockid_t clock, struct timespec *ts)
+__vdso_clock_gettime_stick(clockid_t clock, struct __kernel_old_timespec *ts)
 {
        struct vvar_data *vvd = get_vvar_data();
 
        if (likely(vvd->vclock_mode != VCLOCK_NONE)) {
                if (likely(tv != NULL)) {
                        union tstv_t {
-                               struct timespec ts;
+                               struct __kernel_old_timespec ts;
                                struct __kernel_old_timeval tv;
                        } *tstv = (union tstv_t *) tv;
                        do_realtime(vvd, &tstv->ts);
        if (likely(vvd->vclock_mode != VCLOCK_NONE)) {
                if (likely(tv != NULL)) {
                        union tstv_t {
-                               struct timespec ts;
+                               struct __kernel_old_timespec ts;
                                struct __kernel_old_timeval tv;
                        } *tstv = (union tstv_t *) tv;
                        do_realtime_stick(vvd, &tstv->ts);
 
 #include <linux/getcpu.h>
 #include <asm/unistd.h>
 
-int __vdso_clock_gettime(clockid_t clock, struct timespec *ts)
+int __vdso_clock_gettime(clockid_t clock, struct __kernel_old_timespec *ts)
 {
        long ret;
 
 
        return ret;
 }
-int clock_gettime(clockid_t, struct timespec *)
+int clock_gettime(clockid_t, struct __kernel_old_timespec *)
        __attribute__((weak, alias("__vdso_clock_gettime")));
 
 int __vdso_gettimeofday(struct __kernel_old_timeval *tv, struct timezone *tz)