Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 153b5d054ac2d98ea0d86504884326b6777f683d

Authored by Roman Zippel 2008-05-01 19:34:37 +0800

Committed by Linus Torvalds 2008-05-01 23:03:59 +0800

ntp: support for TAI

This adds support for setting the TAI value (International Atomic Time).  The
value is reported back to userspace via timex (as we don't have a
ntp_gettime() syscall).

Signed-off-by: Roman Zippel <zippel@linux-m68k.org>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 4 changed files with 15 additions and 3 deletions Inline Diff

include/linux/compat.h
include/linux/timex.h
kernel/compat.c
kernel/time/ntp.c

include/linux/compat.h

Diff comments View file @ 153b5d0

 #ifndef _LINUX_COMPAT_H
 #define _LINUX_COMPAT_H
 /*
  * These are the type definitions for the architecture specific
  * syscall compatibility layer.
  */
 #ifdef CONFIG_COMPAT
 #include <linux/stat.h>
 #include <linux/param.h>	/* for HZ */
 #include <linux/sem.h>
 #include <asm/compat.h>
 #include <asm/siginfo.h>
 #include <asm/signal.h>
 #define compat_jiffies_to_clock_t(x)	\
 		(((unsigned long)(x) * COMPAT_USER_HZ) / HZ)
 typedef __compat_uid32_t	compat_uid_t;
 typedef __compat_gid32_t	compat_gid_t;
 struct rusage;
 struct compat_itimerspec {
 	struct compat_timespec it_interval;
 	struct compat_timespec it_value;
 };
 struct compat_utimbuf {
 	compat_time_t		actime;
 	compat_time_t		modtime;
 };
 struct compat_itimerval {
 	struct compat_timeval	it_interval;
 	struct compat_timeval	it_value;
 };
 struct compat_tms {
 	compat_clock_t		tms_utime;
 	compat_clock_t		tms_stime;
 	compat_clock_t		tms_cutime;
 	compat_clock_t		tms_cstime;
 };
 struct compat_timex {
 	compat_uint_t modes;
 	compat_long_t offset;
 	compat_long_t freq;
 	compat_long_t maxerror;
 	compat_long_t esterror;
 	compat_int_t status;
 	compat_long_t constant;
 	compat_long_t precision;
 	compat_long_t tolerance;
 	struct compat_timeval time;
 	compat_long_t tick;
 	compat_long_t ppsfreq;
 	compat_long_t jitter;
 	compat_int_t shift;
 	compat_long_t stabil;
 	compat_long_t jitcnt;
 	compat_long_t calcnt;
 	compat_long_t errcnt;
 	compat_long_t stbcnt;
+	compat_int_t tai;
 	compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
 	compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
-	compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
+	compat_int_t :32; compat_int_t :32; compat_int_t :32;
 };
 #define _COMPAT_NSIG_WORDS	(_COMPAT_NSIG / _COMPAT_NSIG_BPW)
 typedef struct {
 	compat_sigset_word	sig[_COMPAT_NSIG_WORDS];
 } compat_sigset_t;
 extern int cp_compat_stat(struct kstat *, struct compat_stat __user *);
 extern int get_compat_timespec(struct timespec *, const struct compat_timespec __user *);
 extern int put_compat_timespec(const struct timespec *, struct compat_timespec __user *);
 struct compat_iovec {
 	compat_uptr_t	iov_base;
 	compat_size_t	iov_len;
 };
 struct compat_rlimit {
 	compat_ulong_t	rlim_cur;
 	compat_ulong_t	rlim_max;
 };
 struct compat_rusage {
 	struct compat_timeval ru_utime;
 	struct compat_timeval ru_stime;
 	compat_long_t	ru_maxrss;
 	compat_long_t	ru_ixrss;
 	compat_long_t	ru_idrss;
 	compat_long_t	ru_isrss;
 	compat_long_t	ru_minflt;
 	compat_long_t	ru_majflt;
 	compat_long_t	ru_nswap;
 	compat_long_t	ru_inblock;
 	compat_long_t	ru_oublock;
 	compat_long_t	ru_msgsnd;
 	compat_long_t	ru_msgrcv;
 	compat_long_t	ru_nsignals;
 	compat_long_t	ru_nvcsw;
 	compat_long_t	ru_nivcsw;
 };
 extern int put_compat_rusage(const struct rusage *, struct compat_rusage __user *);
 struct compat_siginfo;
 extern asmlinkage long compat_sys_waitid(int, compat_pid_t,
 		struct compat_siginfo __user *, int,
 		struct compat_rusage __user *);
 struct compat_dirent {
 	u32		d_ino;
 	compat_off_t	d_off;
 	u16		d_reclen;
 	char		d_name[256];
 };
 typedef union compat_sigval {
 	compat_int_t	sival_int;
 	compat_uptr_t	sival_ptr;
 } compat_sigval_t;
 #define COMPAT_SIGEV_PAD_SIZE	((SIGEV_MAX_SIZE/sizeof(int)) - 3)
 typedef struct compat_sigevent {
 	compat_sigval_t sigev_value;
 	compat_int_t sigev_signo;
 	compat_int_t sigev_notify;
 	union {
 		compat_int_t _pad[COMPAT_SIGEV_PAD_SIZE];
 		compat_int_t _tid;
 		struct {
 			compat_uptr_t _function;
 			compat_uptr_t _attribute;
 		} _sigev_thread;
 	} _sigev_un;
 } compat_sigevent_t;
 struct compat_robust_list {
 	compat_uptr_t			next;
 };
 struct compat_robust_list_head {
 	struct compat_robust_list	list;
 	compat_long_t			futex_offset;
 	compat_uptr_t			list_op_pending;
 };
 extern void compat_exit_robust_list(struct task_struct *curr);
 asmlinkage long
 compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
 			   compat_size_t len);
 asmlinkage long
 compat_sys_get_robust_list(int pid, compat_uptr_t __user *head_ptr,
 			   compat_size_t __user *len_ptr);
 long compat_sys_semctl(int first, int second, int third, void __user *uptr);
 long compat_sys_msgsnd(int first, int second, int third, void __user *uptr);
 long compat_sys_msgrcv(int first, int second, int msgtyp, int third,
 		int version, void __user *uptr);
 long compat_sys_msgctl(int first, int second, void __user *uptr);
 long compat_sys_shmat(int first, int second, compat_uptr_t third, int version,
 		void __user *uptr);
 long compat_sys_shmctl(int first, int second, void __user *uptr);
 long compat_sys_semtimedop(int semid, struct sembuf __user *tsems,
 		unsigned nsems, const struct compat_timespec __user *timeout);
 asmlinkage long compat_sys_keyctl(u32 option,
 			      u32 arg2, u32 arg3, u32 arg4, u32 arg5);
 asmlinkage ssize_t compat_sys_readv(unsigned long fd,
 		const struct compat_iovec __user *vec, unsigned long vlen);
 asmlinkage ssize_t compat_sys_writev(unsigned long fd,
 		const struct compat_iovec __user *vec, unsigned long vlen);
 int compat_do_execve(char * filename, compat_uptr_t __user *argv,
 	        compat_uptr_t __user *envp, struct pt_regs * regs);
 asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
 		compat_ulong_t __user *outp, compat_ulong_t __user *exp,
 		struct compat_timeval __user *tvp);
 asmlinkage long compat_sys_wait4(compat_pid_t pid,
 				 compat_uint_t __user *stat_addr, int options,
 				 struct compat_rusage __user *ru);
 #define BITS_PER_COMPAT_LONG    (8*sizeof(compat_long_t))
 #define BITS_TO_COMPAT_LONGS(bits) \
 	(((bits)+BITS_PER_COMPAT_LONG-1)/BITS_PER_COMPAT_LONG)
 long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
 		       unsigned long bitmap_size);
 long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
 		       unsigned long bitmap_size);
 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from);
 int copy_siginfo_to_user32(struct compat_siginfo __user *to, siginfo_t *from);
 int get_compat_sigevent(struct sigevent *event,
 		const struct compat_sigevent __user *u_event);
 static inline int compat_timeval_compare(struct compat_timeval *lhs,
 					struct compat_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;
 }
 static inline int compat_timespec_compare(struct compat_timespec *lhs,
 					struct compat_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;
 }
 extern int get_compat_itimerspec(struct itimerspec *dst,
 				 const struct compat_itimerspec __user *src);
 extern int put_compat_itimerspec(struct compat_itimerspec __user *dst,
 				 const struct itimerspec *src);
 asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp);
 extern int compat_printk(const char *fmt, ...);
 extern void sigset_from_compat(sigset_t *set, compat_sigset_t *compat);
 asmlinkage long compat_sys_migrate_pages(compat_pid_t pid,
 		compat_ulong_t maxnode, const compat_ulong_t __user *old_nodes,
 		const compat_ulong_t __user *new_nodes);
 extern int compat_ptrace_request(struct task_struct *child,
 				 compat_long_t request,
 				 compat_ulong_t addr, compat_ulong_t data);
 #ifdef __ARCH_WANT_COMPAT_SYS_PTRACE
 extern long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
 			       compat_ulong_t addr, compat_ulong_t data);
 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
 				  compat_long_t addr, compat_long_t data);
 #endif	/* __ARCH_WANT_COMPAT_SYS_PTRACE */
 /*
  * epoll (fs/eventpoll.c) compat bits follow ...
  */
 struct epoll_event;
 #define compat_epoll_event	epoll_event
 asmlinkage long compat_sys_epoll_pwait(int epfd,
 			struct compat_epoll_event __user *events,
 			int maxevents, int timeout,
 			const compat_sigset_t __user *sigmask,
 			compat_size_t sigsetsize);
 asmlinkage long compat_sys_utimensat(unsigned int dfd, char __user *filename,
 				struct compat_timespec __user *t, int flags);
 asmlinkage long compat_sys_signalfd(int ufd,
 				const compat_sigset_t __user *sigmask,
                                 compat_size_t sigsetsize);
 asmlinkage long compat_sys_timerfd_settime(int ufd, int flags,
 				   const struct compat_itimerspec __user *utmr,
 				   struct compat_itimerspec __user *otmr);
 asmlinkage long compat_sys_timerfd_gettime(int ufd,
 				   struct compat_itimerspec __user *otmr);
 #endif /* CONFIG_COMPAT */
 #endif /* _LINUX_COMPAT_H */

include/linux/timex.h

Diff comments View file @ 153b5d0

 /*****************************************************************************
  *                                                                           *
  * Copyright (c) David L. Mills 1993                                         *
  *                                                                           *
  * Permission to use, copy, modify, and distribute this software and its     *
  * documentation for any purpose and without fee is hereby granted, provided *
  * that the above copyright notice appears in all copies and that both the   *
  * copyright notice and this permission notice appear in supporting          *
  * documentation, and that the name University of Delaware not be used in    *
  * advertising or publicity pertaining to distribution of the software       *
  * without specific, written prior permission.  The University of Delaware   *
  * makes no representations about the suitability this software for any      *
  * purpose.  It is provided "as is" without express or implied warranty.     *
  *                                                                           *
  *****************************************************************************/
 /*
  * Modification history timex.h
  *
  * 29 Dec 97	Russell King
  *	Moved CLOCK_TICK_RATE, CLOCK_TICK_FACTOR and FINETUNE to asm/timex.h
  *	for ARM machines
  *
  *  9 Jan 97    Adrian Sun
  *      Shifted LATCH define to allow access to alpha machines.
  *
  * 26 Sep 94	David L. Mills
  *	Added defines for hybrid phase/frequency-lock loop.
  *
  * 19 Mar 94	David L. Mills
  *	Moved defines from kernel routines to header file and added new
  *	defines for PPS phase-lock loop.
  *
  * 20 Feb 94	David L. Mills
  *	Revised status codes and structures for external clock and PPS
  *	signal discipline.
  *
  * 28 Nov 93	David L. Mills
  *	Adjusted parameters to improve stability and increase poll
  *	interval.
  *
  * 17 Sep 93    David L. Mills
  *      Created file $NTP/include/sys/timex.h
  * 07 Oct 93    Torsten Duwe
  *      Derived linux/timex.h
  * 1995-08-13    Torsten Duwe
  *      kernel PLL updated to 1994-12-13 specs (rfc-1589)
  * 1997-08-30    Ulrich Windl
  *      Added new constant NTP_PHASE_LIMIT
  * 2004-08-12    Christoph Lameter
  *      Reworked time interpolation logic
  */
 #ifndef _LINUX_TIMEX_H
 #define _LINUX_TIMEX_H
 #include <linux/compiler.h>
 #include <linux/time.h>
 #include <asm/param.h>
 #define NTP_API		4	/* NTP API version */
 /*
  * SHIFT_KG and SHIFT_KF establish the damping of the PLL and are chosen
  * for a slightly underdamped convergence characteristic. SHIFT_KH
  * establishes the damping of the FLL and is chosen by wisdom and black
  * art.
  *
  * MAXTC establishes the maximum time constant of the PLL. With the
  * SHIFT_KG and SHIFT_KF values given and a time constant range from
  * zero to MAXTC, the PLL will converge in 15 minutes to 16 hours,
  * respectively.
  */
 #define SHIFT_PLL	4	/* PLL frequency factor (shift) */
 #define SHIFT_FLL	2	/* FLL frequency factor (shift) */
 #define MAXTC		10	/* maximum time constant (shift) */
 /*
  * SHIFT_USEC defines the scaling (shift) of the time_freq and
  * time_tolerance variables, which represent the current frequency
  * offset and maximum frequency tolerance.
  */
 #define SHIFT_USEC 16		/* frequency offset scale (shift) */
 #define PPM_SCALE (NSEC_PER_USEC << (TICK_LENGTH_SHIFT - SHIFT_USEC))
 #define PPM_SCALE_INV_SHIFT 20
 #define PPM_SCALE_INV ((1ll << (PPM_SCALE_INV_SHIFT + TICK_LENGTH_SHIFT)) / \
 		       PPM_SCALE + 1)
 #define MAXPHASE 500000000l	/* max phase error (ns) */
 #define MAXFREQ 500000		/* max frequency error (ns/s) */
 #define MAXFREQ_SCALED ((s64)MAXFREQ << TICK_LENGTH_SHIFT)
 #define MINSEC 256		/* min interval between updates (s) */
 #define MAXSEC 2048		/* max interval between updates (s) */
 #define NTP_PHASE_LIMIT ((MAXPHASE / NSEC_PER_USEC) << 5) /* beyond max. dispersion */
 /*
  * syscall interface - used (mainly by NTP daemon)
  * to discipline kernel clock oscillator
  */
 struct timex {
 	unsigned int modes;	/* mode selector */
 	long offset;		/* time offset (usec) */
 	long freq;		/* frequency offset (scaled ppm) */
 	long maxerror;		/* maximum error (usec) */
 	long esterror;		/* estimated error (usec) */
 	int status;		/* clock command/status */
 	long constant;		/* pll time constant */
 	long precision;		/* clock precision (usec) (read only) */
 	long tolerance;		/* clock frequency tolerance (ppm)
 				 * (read only)
 				 */
 	struct timeval time;	/* (read only) */
 	long tick;		/* (modified) usecs between clock ticks */
 	long ppsfreq;           /* pps frequency (scaled ppm) (ro) */
 	long jitter;            /* pps jitter (us) (ro) */
 	int shift;              /* interval duration (s) (shift) (ro) */
 	long stabil;            /* pps stability (scaled ppm) (ro) */
 	long jitcnt;            /* jitter limit exceeded (ro) */
 	long calcnt;            /* calibration intervals (ro) */
 	long errcnt;            /* calibration errors (ro) */
 	long stbcnt;            /* stability limit exceeded (ro) */
+	int tai;		/* TAI offset (ro) */
 	int  :32; int  :32; int  :32; int  :32;
 	int  :32; int  :32; int  :32; int  :32;
-	int  :32; int  :32; int  :32; int  :32;
+	int  :32; int  :32; int  :32;
 };
 /*
  * Mode codes (timex.mode)
  */
 #define ADJ_OFFSET		0x0001	/* time offset */
 #define ADJ_FREQUENCY		0x0002	/* frequency offset */
 #define ADJ_MAXERROR		0x0004	/* maximum time error */
 #define ADJ_ESTERROR		0x0008	/* estimated time error */
 #define ADJ_STATUS		0x0010	/* clock status */
 #define ADJ_TIMECONST		0x0020	/* pll time constant */
+#define ADJ_TAI			0x0080	/* set TAI offset */
 #define ADJ_MICRO		0x1000	/* select microsecond resolution */
 #define ADJ_NANO		0x2000	/* select nanosecond resolution */
 #define ADJ_TICK		0x4000	/* tick value */
 #define ADJ_OFFSET_SINGLESHOT	0x8001	/* old-fashioned adjtime */
 #define ADJ_OFFSET_SS_READ	0xa001  /* read-only adjtime */
 /* xntp 3.4 compatibility names */
 #define MOD_OFFSET	ADJ_OFFSET
 #define MOD_FREQUENCY	ADJ_FREQUENCY
 #define MOD_MAXERROR	ADJ_MAXERROR
 #define MOD_ESTERROR	ADJ_ESTERROR
 #define MOD_STATUS	ADJ_STATUS
 #define MOD_TIMECONST	ADJ_TIMECONST
 /*
  * Status codes (timex.status)
  */
 #define STA_PLL		0x0001	/* enable PLL updates (rw) */
 #define STA_PPSFREQ	0x0002	/* enable PPS freq discipline (rw) */
 #define STA_PPSTIME	0x0004	/* enable PPS time discipline (rw) */
 #define STA_FLL		0x0008	/* select frequency-lock mode (rw) */
 #define STA_INS		0x0010	/* insert leap (rw) */
 #define STA_DEL		0x0020	/* delete leap (rw) */
 #define STA_UNSYNC	0x0040	/* clock unsynchronized (rw) */
 #define STA_FREQHOLD	0x0080	/* hold frequency (rw) */
 #define STA_PPSSIGNAL	0x0100	/* PPS signal present (ro) */
 #define STA_PPSJITTER	0x0200	/* PPS signal jitter exceeded (ro) */
 #define STA_PPSWANDER	0x0400	/* PPS signal wander exceeded (ro) */
 #define STA_PPSERROR	0x0800	/* PPS signal calibration error (ro) */
 #define STA_CLOCKERR	0x1000	/* clock hardware fault (ro) */
 #define STA_NANO	0x2000	/* resolution (0 = us, 1 = ns) (ro) */
 #define STA_MODE	0x4000	/* mode (0 = PLL, 1 = FLL) (ro) */
 #define STA_CLK		0x8000	/* clock source (0 = A, 1 = B) (ro) */
 /* read-only bits */
 #define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | \
 	STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK)
 /*
  * Clock states (time_state)
  */
 #define TIME_OK		0	/* clock synchronized, no leap second */
 #define TIME_INS	1	/* insert leap second */
 #define TIME_DEL	2	/* delete leap second */
 #define TIME_OOP	3	/* leap second in progress */
 #define TIME_WAIT	4	/* leap second has occurred */
 #define TIME_ERROR	5	/* clock not synchronized */
 #define TIME_BAD	TIME_ERROR /* bw compat */
 #ifdef __KERNEL__
 #include <asm/timex.h>
 /*
  * kernel variables
  * Note: maximum error = NTP synch distance = dispersion + delay / 2;
  * estimated error = NTP dispersion.
  */
 extern unsigned long tick_usec;		/* USER_HZ period (usec) */
 extern unsigned long tick_nsec;		/* ACTHZ          period (nsec) */
 extern int tickadj;			/* amount of adjustment per tick */
 /*
  * phase-lock loop variables
  */
 extern int time_status;		/* clock synchronization status bits */
 extern long time_maxerror;	/* maximum error */
 extern long time_esterror;	/* estimated error */
 extern long time_adjust;	/* The amount of adjtime left */
 extern void ntp_clear(void);
 /**
  * ntp_synced - Returns 1 if the NTP status is not UNSYNC
  *
  */
 static inline int ntp_synced(void)
 {
 	return !(time_status & STA_UNSYNC);
 }
 /* Required to safely shift negative values */
 #define shift_right(x, s) ({	\
 	__typeof__(x) __x = (x);	\
 	__typeof__(s) __s = (s);	\
 	__x < 0 ? -(-__x >> __s) : __x >> __s;	\
 })
 #define TICK_LENGTH_SHIFT	32
 #ifdef CONFIG_NO_HZ
 #define NTP_INTERVAL_FREQ  (2)
 #else
 #define NTP_INTERVAL_FREQ  (HZ)
 #endif
 #define NTP_INTERVAL_LENGTH (NSEC_PER_SEC/NTP_INTERVAL_FREQ)
 /* Returns how long ticks are at present, in ns / 2^(SHIFT_SCALE-10). */
 extern u64 current_tick_length(void);
 extern void second_overflow(void);
 extern void update_ntp_one_tick(void);
 extern int do_adjtimex(struct timex *);
 /* Don't use! Compatibility define for existing users. */
 #define tickadj	(500/HZ ? : 1)
 int read_current_timer(unsigned long *timer_val);
 #endif /* KERNEL */
 #endif /* LINUX_TIMEX_H */

kernel/compat.c

Diff comments View file @ 153b5d0

 /*
  *  linux/kernel/compat.c
  *
  *  Kernel compatibililty routines for e.g. 32 bit syscall support
  *  on 64 bit kernels.
  *
  *  Copyright (C) 2002-2003 Stephen Rothwell, IBM Corporation
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.
  */
 #include <linux/linkage.h>
 #include <linux/compat.h>
 #include <linux/errno.h>
 #include <linux/time.h>
 #include <linux/signal.h>
 #include <linux/sched.h>	/* for MAX_SCHEDULE_TIMEOUT */
 #include <linux/syscalls.h>
 #include <linux/unistd.h>
 #include <linux/security.h>
 #include <linux/timex.h>
 #include <linux/migrate.h>
 #include <linux/posix-timers.h>
 #include <asm/uaccess.h>
 int get_compat_timespec(struct timespec *ts, const struct compat_timespec __user *cts)
 {
 	return (!access_ok(VERIFY_READ, cts, sizeof(*cts)) ||
 			__get_user(ts->tv_sec, &cts->tv_sec) ||
 			__get_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0;
 }
 int put_compat_timespec(const struct timespec *ts, struct compat_timespec __user *cts)
 {
 	return (!access_ok(VERIFY_WRITE, cts, sizeof(*cts)) ||
 			__put_user(ts->tv_sec, &cts->tv_sec) ||
 			__put_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0;
 }
 static long compat_nanosleep_restart(struct restart_block *restart)
 {
 	struct compat_timespec __user *rmtp;
 	struct timespec rmt;
 	mm_segment_t oldfs;
 	long ret;
 	restart->nanosleep.rmtp = (struct timespec __user *) &rmt;
 	oldfs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = hrtimer_nanosleep_restart(restart);
 	set_fs(oldfs);
 	if (ret) {
 		rmtp = restart->nanosleep.compat_rmtp;
 		if (rmtp && put_compat_timespec(&rmt, rmtp))
 			return -EFAULT;
 	}
 	return ret;
 }
 asmlinkage long compat_sys_nanosleep(struct compat_timespec __user *rqtp,
 				     struct compat_timespec __user *rmtp)
 {
 	struct timespec tu, rmt;
 	mm_segment_t oldfs;
 	long ret;
 	if (get_compat_timespec(&tu, rqtp))
 		return -EFAULT;
 	if (!timespec_valid(&tu))
 		return -EINVAL;
 	oldfs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = hrtimer_nanosleep(&tu,
 				rmtp ? (struct timespec __user *)&rmt : NULL,
 				HRTIMER_MODE_REL, CLOCK_MONOTONIC);
 	set_fs(oldfs);
 	if (ret) {
 		struct restart_block *restart
 			= &current_thread_info()->restart_block;
 		restart->fn = compat_nanosleep_restart;
 		restart->nanosleep.compat_rmtp = rmtp;
 		if (rmtp && put_compat_timespec(&rmt, rmtp))
 			return -EFAULT;
 	}
 	return ret;
 }
 static inline long get_compat_itimerval(struct itimerval *o,
 		struct compat_itimerval __user *i)
 {
 	return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
 		(__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
 		 __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
 		 __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
 		 __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
 }
 static inline long put_compat_itimerval(struct compat_itimerval __user *o,
 		struct itimerval *i)
 {
 	return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
 		(__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
 		 __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
 		 __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
 		 __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
 }
 asmlinkage long compat_sys_getitimer(int which,
 		struct compat_itimerval __user *it)
 {
 	struct itimerval kit;
 	int error;
 	error = do_getitimer(which, &kit);
 	if (!error && put_compat_itimerval(it, &kit))
 		error = -EFAULT;
 	return error;
 }
 asmlinkage long compat_sys_setitimer(int which,
 		struct compat_itimerval __user *in,
 		struct compat_itimerval __user *out)
 {
 	struct itimerval kin, kout;
 	int error;
 	if (in) {
 		if (get_compat_itimerval(&kin, in))
 			return -EFAULT;
 	} else
 		memset(&kin, 0, sizeof(kin));
 	error = do_setitimer(which, &kin, out ? &kout : NULL);
 	if (error || !out)
 		return error;
 	if (put_compat_itimerval(out, &kout))
 		return -EFAULT;
 	return 0;
 }
 asmlinkage long compat_sys_times(struct compat_tms __user *tbuf)
 {
 	/*
 	 *	In the SMP world we might just be unlucky and have one of
 	 *	the times increment as we use it. Since the value is an
 	 *	atomically safe type this is just fine. Conceptually its
 	 *	as if the syscall took an instant longer to occur.
 	 */
 	if (tbuf) {
 		struct compat_tms tmp;
 		struct task_struct *tsk = current;
 		struct task_struct *t;
 		cputime_t utime, stime, cutime, cstime;
 		read_lock(&tasklist_lock);
 		utime = tsk->signal->utime;
 		stime = tsk->signal->stime;
 		t = tsk;
 		do {
 			utime = cputime_add(utime, t->utime);
 			stime = cputime_add(stime, t->stime);
 			t = next_thread(t);
 		} while (t != tsk);
 		/*
 		 * While we have tasklist_lock read-locked, no dying thread
 		 * can be updating current->signal->[us]time.  Instead,
 		 * we got their counts included in the live thread loop.
 		 * However, another thread can come in right now and
 		 * do a wait call that updates current->signal->c[us]time.
 		 * To make sure we always see that pair updated atomically,
 		 * we take the siglock around fetching them.
 		 */
 		spin_lock_irq(&tsk->sighand->siglock);
 		cutime = tsk->signal->cutime;
 		cstime = tsk->signal->cstime;
 		spin_unlock_irq(&tsk->sighand->siglock);
 		read_unlock(&tasklist_lock);
 		tmp.tms_utime = compat_jiffies_to_clock_t(cputime_to_jiffies(utime));
 		tmp.tms_stime = compat_jiffies_to_clock_t(cputime_to_jiffies(stime));
 		tmp.tms_cutime = compat_jiffies_to_clock_t(cputime_to_jiffies(cutime));
 		tmp.tms_cstime = compat_jiffies_to_clock_t(cputime_to_jiffies(cstime));
 		if (copy_to_user(tbuf, &tmp, sizeof(tmp)))
 			return -EFAULT;
 	}
 	return compat_jiffies_to_clock_t(jiffies);
 }
 /*
  * Assumption: old_sigset_t and compat_old_sigset_t are both
  * types that can be passed to put_user()/get_user().
  */
 asmlinkage long compat_sys_sigpending(compat_old_sigset_t __user *set)
 {
 	old_sigset_t s;
 	long ret;
 	mm_segment_t old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = sys_sigpending((old_sigset_t __user *) &s);
 	set_fs(old_fs);
 	if (ret == 0)
 		ret = put_user(s, set);
 	return ret;
 }
 asmlinkage long compat_sys_sigprocmask(int how, compat_old_sigset_t __user *set,
 		compat_old_sigset_t __user *oset)
 {
 	old_sigset_t s;
 	long ret;
 	mm_segment_t old_fs;
 	if (set && get_user(s, set))
 		return -EFAULT;
 	old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = sys_sigprocmask(how,
 			      set ? (old_sigset_t __user *) &s : NULL,
 			      oset ? (old_sigset_t __user *) &s : NULL);
 	set_fs(old_fs);
 	if (ret == 0)
 		if (oset)
 			ret = put_user(s, oset);
 	return ret;
 }
 asmlinkage long compat_sys_setrlimit(unsigned int resource,
 		struct compat_rlimit __user *rlim)
 {
 	struct rlimit r;
 	int ret;
 	mm_segment_t old_fs = get_fs ();
 	if (resource >= RLIM_NLIMITS)
 		return -EINVAL;
 	if (!access_ok(VERIFY_READ, rlim, sizeof(*rlim)) ||
 	    __get_user(r.rlim_cur, &rlim->rlim_cur) ||
 	    __get_user(r.rlim_max, &rlim->rlim_max))
 		return -EFAULT;
 	if (r.rlim_cur == COMPAT_RLIM_INFINITY)
 		r.rlim_cur = RLIM_INFINITY;
 	if (r.rlim_max == COMPAT_RLIM_INFINITY)
 		r.rlim_max = RLIM_INFINITY;
 	set_fs(KERNEL_DS);
 	ret = sys_setrlimit(resource, (struct rlimit __user *) &r);
 	set_fs(old_fs);
 	return ret;
 }
 #ifdef COMPAT_RLIM_OLD_INFINITY
 asmlinkage long compat_sys_old_getrlimit(unsigned int resource,
 		struct compat_rlimit __user *rlim)
 {
 	struct rlimit r;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = sys_old_getrlimit(resource, &r);
 	set_fs(old_fs);
 	if (!ret) {
 		if (r.rlim_cur > COMPAT_RLIM_OLD_INFINITY)
 			r.rlim_cur = COMPAT_RLIM_INFINITY;
 		if (r.rlim_max > COMPAT_RLIM_OLD_INFINITY)
 			r.rlim_max = COMPAT_RLIM_INFINITY;
 		if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
 		    __put_user(r.rlim_cur, &rlim->rlim_cur) ||
 		    __put_user(r.rlim_max, &rlim->rlim_max))
 			return -EFAULT;
 	}
 	return ret;
 }
 #endif
 asmlinkage long compat_sys_getrlimit (unsigned int resource,
 		struct compat_rlimit __user *rlim)
 {
 	struct rlimit r;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = sys_getrlimit(resource, (struct rlimit __user *) &r);
 	set_fs(old_fs);
 	if (!ret) {
 		if (r.rlim_cur > COMPAT_RLIM_INFINITY)
 			r.rlim_cur = COMPAT_RLIM_INFINITY;
 		if (r.rlim_max > COMPAT_RLIM_INFINITY)
 			r.rlim_max = COMPAT_RLIM_INFINITY;
 		if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
 		    __put_user(r.rlim_cur, &rlim->rlim_cur) ||
 		    __put_user(r.rlim_max, &rlim->rlim_max))
 			return -EFAULT;
 	}
 	return ret;
 }
 int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru)
 {
 	if (!access_ok(VERIFY_WRITE, ru, sizeof(*ru)) ||
 	    __put_user(r->ru_utime.tv_sec, &ru->ru_utime.tv_sec) ||
 	    __put_user(r->ru_utime.tv_usec, &ru->ru_utime.tv_usec) ||
 	    __put_user(r->ru_stime.tv_sec, &ru->ru_stime.tv_sec) ||
 	    __put_user(r->ru_stime.tv_usec, &ru->ru_stime.tv_usec) ||
 	    __put_user(r->ru_maxrss, &ru->ru_maxrss) ||
 	    __put_user(r->ru_ixrss, &ru->ru_ixrss) ||
 	    __put_user(r->ru_idrss, &ru->ru_idrss) ||
 	    __put_user(r->ru_isrss, &ru->ru_isrss) ||
 	    __put_user(r->ru_minflt, &ru->ru_minflt) ||
 	    __put_user(r->ru_majflt, &ru->ru_majflt) ||
 	    __put_user(r->ru_nswap, &ru->ru_nswap) ||
 	    __put_user(r->ru_inblock, &ru->ru_inblock) ||
 	    __put_user(r->ru_oublock, &ru->ru_oublock) ||
 	    __put_user(r->ru_msgsnd, &ru->ru_msgsnd) ||
 	    __put_user(r->ru_msgrcv, &ru->ru_msgrcv) ||
 	    __put_user(r->ru_nsignals, &ru->ru_nsignals) ||
 	    __put_user(r->ru_nvcsw, &ru->ru_nvcsw) ||
 	    __put_user(r->ru_nivcsw, &ru->ru_nivcsw))
 		return -EFAULT;
 	return 0;
 }
 asmlinkage long compat_sys_getrusage(int who, struct compat_rusage __user *ru)
 {
 	struct rusage r;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = sys_getrusage(who, (struct rusage __user *) &r);
 	set_fs(old_fs);
 	if (ret)
 		return ret;
 	if (put_compat_rusage(&r, ru))
 		return -EFAULT;
 	return 0;
 }
 asmlinkage long
 compat_sys_wait4(compat_pid_t pid, compat_uint_t __user *stat_addr, int options,
 	struct compat_rusage __user *ru)
 {
 	if (!ru) {
 		return sys_wait4(pid, stat_addr, options, NULL);
 	} else {
 		struct rusage r;
 		int ret;
 		unsigned int status;
 		mm_segment_t old_fs = get_fs();
 		set_fs (KERNEL_DS);
 		ret = sys_wait4(pid,
 				(stat_addr ?
 				 (unsigned int __user *) &status : NULL),
 				options, (struct rusage __user *) &r);
 		set_fs (old_fs);
 		if (ret > 0) {
 			if (put_compat_rusage(&r, ru))
 				return -EFAULT;
 			if (stat_addr && put_user(status, stat_addr))
 				return -EFAULT;
 		}
 		return ret;
 	}
 }
 asmlinkage long compat_sys_waitid(int which, compat_pid_t pid,
 		struct compat_siginfo __user *uinfo, int options,
 		struct compat_rusage __user *uru)
 {
 	siginfo_t info;
 	struct rusage ru;
 	long ret;
 	mm_segment_t old_fs = get_fs();
 	memset(&info, 0, sizeof(info));
 	set_fs(KERNEL_DS);
 	ret = sys_waitid(which, pid, (siginfo_t __user *)&info, options,
 			 uru ? (struct rusage __user *)&ru : NULL);
 	set_fs(old_fs);
 	if ((ret < 0) || (info.si_signo == 0))
 		return ret;
 	if (uru) {
 		ret = put_compat_rusage(&ru, uru);
 		if (ret)
 			return ret;
 	}
 	BUG_ON(info.si_code & __SI_MASK);
 	info.si_code |= __SI_CHLD;
 	return copy_siginfo_to_user32(uinfo, &info);
 }
 static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr,
 				    unsigned len, cpumask_t *new_mask)
 {
 	unsigned long *k;
 	if (len < sizeof(cpumask_t))
 		memset(new_mask, 0, sizeof(cpumask_t));
 	else if (len > sizeof(cpumask_t))
 		len = sizeof(cpumask_t);
 	k = cpus_addr(*new_mask);
 	return compat_get_bitmap(k, user_mask_ptr, len * 8);
 }
 asmlinkage long compat_sys_sched_setaffinity(compat_pid_t pid,
 					     unsigned int len,
 					     compat_ulong_t __user *user_mask_ptr)
 {
 	cpumask_t new_mask;
 	int retval;
 	retval = compat_get_user_cpu_mask(user_mask_ptr, len, &new_mask);
 	if (retval)
 		return retval;
 	return sched_setaffinity(pid, &new_mask);
 }
 asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid, unsigned int len,
 					     compat_ulong_t __user *user_mask_ptr)
 {
 	int ret;
 	cpumask_t mask;
 	unsigned long *k;
 	unsigned int min_length = sizeof(cpumask_t);
 	if (NR_CPUS <= BITS_PER_COMPAT_LONG)
 		min_length = sizeof(compat_ulong_t);
 	if (len < min_length)
 		return -EINVAL;
 	ret = sched_getaffinity(pid, &mask);
 	if (ret < 0)
 		return ret;
 	k = cpus_addr(mask);
 	ret = compat_put_bitmap(user_mask_ptr, k, min_length * 8);
 	if (ret)
 		return ret;
 	return min_length;
 }
 int get_compat_itimerspec(struct itimerspec *dst,
 			  const struct compat_itimerspec __user *src)
 {
 	if (get_compat_timespec(&dst->it_interval, &src->it_interval) ||
 	    get_compat_timespec(&dst->it_value, &src->it_value))
 		return -EFAULT;
 	return 0;
 }
 int put_compat_itimerspec(struct compat_itimerspec __user *dst,
 			  const struct itimerspec *src)
 {
 	if (put_compat_timespec(&src->it_interval, &dst->it_interval) ||
 	    put_compat_timespec(&src->it_value, &dst->it_value))
 		return -EFAULT;
 	return 0;
 }
 long compat_sys_timer_create(clockid_t which_clock,
 			struct compat_sigevent __user *timer_event_spec,
 			timer_t __user *created_timer_id)
 {
 	struct sigevent __user *event = NULL;
 	if (timer_event_spec) {
 		struct sigevent kevent;
 		event = compat_alloc_user_space(sizeof(*event));
 		if (get_compat_sigevent(&kevent, timer_event_spec) ||
 		    copy_to_user(event, &kevent, sizeof(*event)))
 			return -EFAULT;
 	}
 	return sys_timer_create(which_clock, event, created_timer_id);
 }
 long compat_sys_timer_settime(timer_t timer_id, int flags,
 			  struct compat_itimerspec __user *new,
 			  struct compat_itimerspec __user *old)
 {
 	long err;
 	mm_segment_t oldfs;
 	struct itimerspec newts, oldts;
 	if (!new)
 		return -EINVAL;
 	if (get_compat_itimerspec(&newts, new))
 		return -EFAULT;
 	oldfs = get_fs();
 	set_fs(KERNEL_DS);
 	err = sys_timer_settime(timer_id, flags,
 				(struct itimerspec __user *) &newts,
 				(struct itimerspec __user *) &oldts);
 	set_fs(oldfs);
 	if (!err && old && put_compat_itimerspec(old, &oldts))
 		return -EFAULT;
 	return err;
 }
 long compat_sys_timer_gettime(timer_t timer_id,
 		struct compat_itimerspec __user *setting)
 {
 	long err;
 	mm_segment_t oldfs;
 	struct itimerspec ts;
 	oldfs = get_fs();
 	set_fs(KERNEL_DS);
 	err = sys_timer_gettime(timer_id,
 				(struct itimerspec __user *) &ts);
 	set_fs(oldfs);
 	if (!err && put_compat_itimerspec(setting, &ts))
 		return -EFAULT;
 	return err;
 }
 long compat_sys_clock_settime(clockid_t which_clock,
 		struct compat_timespec __user *tp)
 {
 	long err;
 	mm_segment_t oldfs;
 	struct timespec ts;
 	if (get_compat_timespec(&ts, tp))
 		return -EFAULT;
 	oldfs = get_fs();
 	set_fs(KERNEL_DS);
 	err = sys_clock_settime(which_clock,
 				(struct timespec __user *) &ts);
 	set_fs(oldfs);
 	return err;
 }
 long compat_sys_clock_gettime(clockid_t which_clock,
 		struct compat_timespec __user *tp)
 {
 	long err;
 	mm_segment_t oldfs;
 	struct timespec ts;
 	oldfs = get_fs();
 	set_fs(KERNEL_DS);
 	err = sys_clock_gettime(which_clock,
 				(struct timespec __user *) &ts);
 	set_fs(oldfs);
 	if (!err && put_compat_timespec(&ts, tp))
 		return -EFAULT;
 	return err;
 }
 long compat_sys_clock_getres(clockid_t which_clock,
 		struct compat_timespec __user *tp)
 {
 	long err;
 	mm_segment_t oldfs;
 	struct timespec ts;
 	oldfs = get_fs();
 	set_fs(KERNEL_DS);
 	err = sys_clock_getres(which_clock,
 			       (struct timespec __user *) &ts);
 	set_fs(oldfs);
 	if (!err && tp && put_compat_timespec(&ts, tp))
 		return -EFAULT;
 	return err;
 }
 static long compat_clock_nanosleep_restart(struct restart_block *restart)
 {
 	long err;
 	mm_segment_t oldfs;
 	struct timespec tu;
 	struct compat_timespec *rmtp = restart->nanosleep.compat_rmtp;
 	restart->nanosleep.rmtp = (struct timespec __user *) &tu;
 	oldfs = get_fs();
 	set_fs(KERNEL_DS);
 	err = clock_nanosleep_restart(restart);
 	set_fs(oldfs);
 	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
 	    put_compat_timespec(&tu, rmtp))
 		return -EFAULT;
 	if (err == -ERESTART_RESTARTBLOCK) {
 		restart->fn = compat_clock_nanosleep_restart;
 		restart->nanosleep.compat_rmtp = rmtp;
 	}
 	return err;
 }
 long compat_sys_clock_nanosleep(clockid_t which_clock, int flags,
 			    struct compat_timespec __user *rqtp,
 			    struct compat_timespec __user *rmtp)
 {
 	long err;
 	mm_segment_t oldfs;
 	struct timespec in, out;
 	struct restart_block *restart;
 	if (get_compat_timespec(&in, rqtp))
 		return -EFAULT;
 	oldfs = get_fs();
 	set_fs(KERNEL_DS);
 	err = sys_clock_nanosleep(which_clock, flags,
 				  (struct timespec __user *) &in,
 				  (struct timespec __user *) &out);
 	set_fs(oldfs);
 	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
 	    put_compat_timespec(&out, rmtp))
 		return -EFAULT;
 	if (err == -ERESTART_RESTARTBLOCK) {
 		restart = &current_thread_info()->restart_block;
 		restart->fn = compat_clock_nanosleep_restart;
 		restart->nanosleep.compat_rmtp = rmtp;
 	}
 	return err;
 }
 /*
  * We currently only need the following fields from the sigevent
  * structure: sigev_value, sigev_signo, sig_notify and (sometimes
  * sigev_notify_thread_id).  The others are handled in user mode.
  * We also assume that copying sigev_value.sival_int is sufficient
  * to keep all the bits of sigev_value.sival_ptr intact.
  */
 int get_compat_sigevent(struct sigevent *event,
 		const struct compat_sigevent __user *u_event)
 {
 	memset(event, 0, sizeof(*event));
 	return (!access_ok(VERIFY_READ, u_event, sizeof(*u_event)) ||
 		__get_user(event->sigev_value.sival_int,
 			&u_event->sigev_value.sival_int) ||
 		__get_user(event->sigev_signo, &u_event->sigev_signo) ||
 		__get_user(event->sigev_notify, &u_event->sigev_notify) ||
 		__get_user(event->sigev_notify_thread_id,
 			&u_event->sigev_notify_thread_id))
 		? -EFAULT : 0;
 }
 long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
 		       unsigned long bitmap_size)
 {
 	int i, j;
 	unsigned long m;
 	compat_ulong_t um;
 	unsigned long nr_compat_longs;
 	/* align bitmap up to nearest compat_long_t boundary */
 	bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
 	if (!access_ok(VERIFY_READ, umask, bitmap_size / 8))
 		return -EFAULT;
 	nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
 	for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
 		m = 0;
 		for (j = 0; j < sizeof(m)/sizeof(um); j++) {
 			/*
 			 * We dont want to read past the end of the userspace
 			 * bitmap. We must however ensure the end of the
 			 * kernel bitmap is zeroed.
 			 */
 			if (nr_compat_longs-- > 0) {
 				if (__get_user(um, umask))
 					return -EFAULT;
 			} else {
 				um = 0;
 			}
 			umask++;
 			m |= (long)um << (j * BITS_PER_COMPAT_LONG);
 		}
 		*mask++ = m;
 	}
 	return 0;
 }
 long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
 		       unsigned long bitmap_size)
 {
 	int i, j;
 	unsigned long m;
 	compat_ulong_t um;
 	unsigned long nr_compat_longs;
 	/* align bitmap up to nearest compat_long_t boundary */
 	bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
 	if (!access_ok(VERIFY_WRITE, umask, bitmap_size / 8))
 		return -EFAULT;
 	nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
 	for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
 		m = *mask++;
 		for (j = 0; j < sizeof(m)/sizeof(um); j++) {
 			um = m;
 			/*
 			 * We dont want to write past the end of the userspace
 			 * bitmap.
 			 */
 			if (nr_compat_longs-- > 0) {
 				if (__put_user(um, umask))
 					return -EFAULT;
 			}
 			umask++;
 			m >>= 4*sizeof(um);
 			m >>= 4*sizeof(um);
 		}
 	}
 	return 0;
 }
 void
 sigset_from_compat (sigset_t *set, compat_sigset_t *compat)
 {
 	switch (_NSIG_WORDS) {
 	case 4: set->sig[3] = compat->sig[6] | (((long)compat->sig[7]) << 32 );
 	case 3: set->sig[2] = compat->sig[4] | (((long)compat->sig[5]) << 32 );
 	case 2: set->sig[1] = compat->sig[2] | (((long)compat->sig[3]) << 32 );
 	case 1: set->sig[0] = compat->sig[0] | (((long)compat->sig[1]) << 32 );
 	}
 }
 asmlinkage long
 compat_sys_rt_sigtimedwait (compat_sigset_t __user *uthese,
 		struct compat_siginfo __user *uinfo,
 		struct compat_timespec __user *uts, compat_size_t sigsetsize)
 {
 	compat_sigset_t s32;
 	sigset_t s;
 	int sig;
 	struct timespec t;
 	siginfo_t info;
 	long ret, timeout = 0;
 	if (sigsetsize != sizeof(sigset_t))
 		return -EINVAL;
 	if (copy_from_user(&s32, uthese, sizeof(compat_sigset_t)))
 		return -EFAULT;
 	sigset_from_compat(&s, &s32);
 	sigdelsetmask(&s,sigmask(SIGKILL)|sigmask(SIGSTOP));
 	signotset(&s);
 	if (uts) {
 		if (get_compat_timespec (&t, uts))
 			return -EFAULT;
 		if (t.tv_nsec >= 1000000000L || t.tv_nsec < 0
 				|| t.tv_sec < 0)
 			return -EINVAL;
 	}
 	spin_lock_irq(&current->sighand->siglock);
 	sig = dequeue_signal(current, &s, &info);
 	if (!sig) {
 		timeout = MAX_SCHEDULE_TIMEOUT;
 		if (uts)
 			timeout = timespec_to_jiffies(&t)
 				+(t.tv_sec || t.tv_nsec);
 		if (timeout) {
 			current->real_blocked = current->blocked;
 			sigandsets(&current->blocked, &current->blocked, &s);
 			recalc_sigpending();
 			spin_unlock_irq(&current->sighand->siglock);
 			timeout = schedule_timeout_interruptible(timeout);
 			spin_lock_irq(&current->sighand->siglock);
 			sig = dequeue_signal(current, &s, &info);
 			current->blocked = current->real_blocked;
 			siginitset(&current->real_blocked, 0);
 			recalc_sigpending();
 		}
 	}
 	spin_unlock_irq(&current->sighand->siglock);
 	if (sig) {
 		ret = sig;
 		if (uinfo) {
 			if (copy_siginfo_to_user32(uinfo, &info))
 				ret = -EFAULT;
 		}
 	}else {
 		ret = timeout?-EINTR:-EAGAIN;
 	}
 	return ret;
 }
 #ifdef __ARCH_WANT_COMPAT_SYS_TIME
 /* compat_time_t is a 32 bit "long" and needs to get converted. */
 asmlinkage long compat_sys_time(compat_time_t __user * tloc)
 {
 	compat_time_t i;
 	struct timeval tv;
 	do_gettimeofday(&tv);
 	i = tv.tv_sec;
 	if (tloc) {
 		if (put_user(i,tloc))
 			i = -EFAULT;
 	}
 	return i;
 }
 asmlinkage long compat_sys_stime(compat_time_t __user *tptr)
 {
 	struct timespec tv;
 	int err;
 	if (get_user(tv.tv_sec, tptr))
 		return -EFAULT;
 	tv.tv_nsec = 0;
 	err = security_settime(&tv, NULL);
 	if (err)
 		return err;
 	do_settimeofday(&tv);
 	return 0;
 }
 #endif /* __ARCH_WANT_COMPAT_SYS_TIME */
 #ifdef __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
 asmlinkage long compat_sys_rt_sigsuspend(compat_sigset_t __user *unewset, compat_size_t sigsetsize)
 {
 	sigset_t newset;
 	compat_sigset_t newset32;
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(sigset_t))
 		return -EINVAL;
 	if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
 		return -EFAULT;
 	sigset_from_compat(&newset, &newset32);
 	sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
 	spin_lock_irq(&current->sighand->siglock);
 	current->saved_sigmask = current->blocked;
 	current->blocked = newset;
 	recalc_sigpending();
 	spin_unlock_irq(&current->sighand->siglock);
 	current->state = TASK_INTERRUPTIBLE;
 	schedule();
 	set_restore_sigmask();
 	return -ERESTARTNOHAND;
 }
 #endif /* __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND */
 asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp)
 {
 	struct timex txc;
 	int ret;
 	memset(&txc, 0, sizeof(struct timex));
 	if (!access_ok(VERIFY_READ, utp, sizeof(struct compat_timex)) ||
 			__get_user(txc.modes, &utp->modes) ||
 			__get_user(txc.offset, &utp->offset) ||
 			__get_user(txc.freq, &utp->freq) ||
 			__get_user(txc.maxerror, &utp->maxerror) ||
 			__get_user(txc.esterror, &utp->esterror) ||
 			__get_user(txc.status, &utp->status) ||
 			__get_user(txc.constant, &utp->constant) ||
 			__get_user(txc.precision, &utp->precision) ||
 			__get_user(txc.tolerance, &utp->tolerance) ||
 			__get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
 			__get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
 			__get_user(txc.tick, &utp->tick) ||
 			__get_user(txc.ppsfreq, &utp->ppsfreq) ||
 			__get_user(txc.jitter, &utp->jitter) ||
 			__get_user(txc.shift, &utp->shift) ||
 			__get_user(txc.stabil, &utp->stabil) ||
 			__get_user(txc.jitcnt, &utp->jitcnt) ||
 			__get_user(txc.calcnt, &utp->calcnt) ||
 			__get_user(txc.errcnt, &utp->errcnt) ||
 			__get_user(txc.stbcnt, &utp->stbcnt))
 		return -EFAULT;
 	ret = do_adjtimex(&txc);
 	if (!access_ok(VERIFY_WRITE, utp, sizeof(struct compat_timex)) ||
 			__put_user(txc.modes, &utp->modes) ||
 			__put_user(txc.offset, &utp->offset) ||
 			__put_user(txc.freq, &utp->freq) ||
 			__put_user(txc.maxerror, &utp->maxerror) ||
 			__put_user(txc.esterror, &utp->esterror) ||
 			__put_user(txc.status, &utp->status) ||
 			__put_user(txc.constant, &utp->constant) ||
 			__put_user(txc.precision, &utp->precision) ||
 			__put_user(txc.tolerance, &utp->tolerance) ||
 			__put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
 			__put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
 			__put_user(txc.tick, &utp->tick) ||
 			__put_user(txc.ppsfreq, &utp->ppsfreq) ||
 			__put_user(txc.jitter, &utp->jitter) ||
 			__put_user(txc.shift, &utp->shift) ||
 			__put_user(txc.stabil, &utp->stabil) ||
 			__put_user(txc.jitcnt, &utp->jitcnt) ||
 			__put_user(txc.calcnt, &utp->calcnt) ||
 			__put_user(txc.errcnt, &utp->errcnt) ||
-			__put_user(txc.stbcnt, &utp->stbcnt))
+			__put_user(txc.stbcnt, &utp->stbcnt) ||
+			__put_user(txc.tai, &utp->tai))
 		ret = -EFAULT;
 	return ret;
 }
 #ifdef CONFIG_NUMA
 asmlinkage long compat_sys_move_pages(pid_t pid, unsigned long nr_pages,
 		compat_uptr_t __user *pages32,
 		const int __user *nodes,
 		int __user *status,
 		int flags)
 {
 	const void __user * __user *pages;
 	int i;
 	pages = compat_alloc_user_space(nr_pages * sizeof(void *));
 	for (i = 0; i < nr_pages; i++) {
 		compat_uptr_t p;
 		if (get_user(p, pages32 + i) ||
 			put_user(compat_ptr(p), pages + i))
 			return -EFAULT;
 	}
 	return sys_move_pages(pid, nr_pages, pages, nodes, status, flags);
 }
 asmlinkage long compat_sys_migrate_pages(compat_pid_t pid,
 			compat_ulong_t maxnode,
 			const compat_ulong_t __user *old_nodes,
 			const compat_ulong_t __user *new_nodes)
 {
 	unsigned long __user *old = NULL;
 	unsigned long __user *new = NULL;
 	nodemask_t tmp_mask;
 	unsigned long nr_bits;
 	unsigned long size;
 	nr_bits = min_t(unsigned long, maxnode - 1, MAX_NUMNODES);
 	size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
 	if (old_nodes) {
 		if (compat_get_bitmap(nodes_addr(tmp_mask), old_nodes, nr_bits))
 			return -EFAULT;
 		old = compat_alloc_user_space(new_nodes ? size * 2 : size);
 		if (new_nodes)
 			new = old + size / sizeof(unsigned long);
 		if (copy_to_user(old, nodes_addr(tmp_mask), size))
 			return -EFAULT;
 	}
 	if (new_nodes) {
 		if (compat_get_bitmap(nodes_addr(tmp_mask), new_nodes, nr_bits))
 			return -EFAULT;
 		if (new == NULL)
 			new = compat_alloc_user_space(size);
 		if (copy_to_user(new, nodes_addr(tmp_mask), size))
 			return -EFAULT;
 	}
 	return sys_migrate_pages(pid, nr_bits + 1, old, new);
 }
 #endif
 struct compat_sysinfo {
 	s32 uptime;
 	u32 loads[3];
 	u32 totalram;
 	u32 freeram;
 	u32 sharedram;
 	u32 bufferram;
 	u32 totalswap;
 	u32 freeswap;
 	u16 procs;
 	u16 pad;
 	u32 totalhigh;
 	u32 freehigh;
 	u32 mem_unit;
 	char _f[20-2*sizeof(u32)-sizeof(int)];
 };
 asmlinkage long
 compat_sys_sysinfo(struct compat_sysinfo __user *info)
 {
 	struct sysinfo s;
 	do_sysinfo(&s);
 	/* Check to see if any memory value is too large for 32-bit and scale
 	 *  down if needed
 	 */
 	if ((s.totalram >> 32) || (s.totalswap >> 32)) {
 		int bitcount = 0;
 		while (s.mem_unit < PAGE_SIZE) {
 			s.mem_unit <<= 1;
 			bitcount++;
 		}
 		s.totalram >>= bitcount;
 		s.freeram >>= bitcount;
 		s.sharedram >>= bitcount;
 		s.bufferram >>= bitcount;
 		s.totalswap >>= bitcount;
 		s.freeswap >>= bitcount;
 		s.totalhigh >>= bitcount;
 		s.freehigh >>= bitcount;
 	}
 	if (!access_ok(VERIFY_WRITE, info, sizeof(struct compat_sysinfo)) ||
 	    __put_user (s.uptime, &info->uptime) ||
 	    __put_user (s.loads[0], &info->loads[0]) ||
 	    __put_user (s.loads[1], &info->loads[1]) ||
 	    __put_user (s.loads[2], &info->loads[2]) ||
 	    __put_user (s.totalram, &info->totalram) ||
 	    __put_user (s.freeram, &info->freeram) ||
 	    __put_user (s.sharedram, &info->sharedram) ||
 	    __put_user (s.bufferram, &info->bufferram) ||
 	    __put_user (s.totalswap, &info->totalswap) ||
 	    __put_user (s.freeswap, &info->freeswap) ||
 	    __put_user (s.procs, &info->procs) ||
 	    __put_user (s.totalhigh, &info->totalhigh) ||
 	    __put_user (s.freehigh, &info->freehigh) ||
 	    __put_user (s.mem_unit, &info->mem_unit))
 		return -EFAULT;
 	return 0;
 }

kernel/time/ntp.c

Diff comments View file @ 153b5d0

 /*
  * linux/kernel/time/ntp.c
  *
  * NTP state machine interfaces and logic.
  *
  * This code was mainly moved from kernel/timer.c and kernel/time.c
  * Please see those files for relevant copyright info and historical
  * changelogs.
  */
 #include <linux/mm.h>
 #include <linux/time.h>
 #include <linux/timer.h>
 #include <linux/timex.h>
 #include <linux/jiffies.h>
 #include <linux/hrtimer.h>
 #include <linux/capability.h>
 #include <linux/math64.h>
 #include <asm/timex.h>
 /*
  * Timekeeping variables
  */
 unsigned long tick_usec = TICK_USEC; 		/* USER_HZ period (usec) */
 unsigned long tick_nsec;			/* ACTHZ period (nsec) */
 static u64 tick_length, tick_length_base;
 #define MAX_TICKADJ		500		/* microsecs */
 #define MAX_TICKADJ_SCALED	(((u64)(MAX_TICKADJ * NSEC_PER_USEC) << \
 				  TICK_LENGTH_SHIFT) / NTP_INTERVAL_FREQ)
 /*
  * phase-lock loop variables
  */
 /* TIME_ERROR prevents overwriting the CMOS clock */
 static int time_state = TIME_OK;	/* clock synchronization status	*/
 int time_status = STA_UNSYNC;		/* clock status bits		*/
+static long time_tai;			/* TAI offset (s)		*/
 static s64 time_offset;			/* time adjustment (ns)		*/
 static long time_constant = 2;		/* pll time constant		*/
 long time_maxerror = NTP_PHASE_LIMIT;	/* maximum error (us)		*/
 long time_esterror = NTP_PHASE_LIMIT;	/* estimated error (us)		*/
 static s64 time_freq;			/* frequency offset (scaled ns/s)*/
 static long time_reftime;		/* time at last adjustment (s)	*/
 long time_adjust;
 static long ntp_tick_adj;
 static void ntp_update_frequency(void)
 {
 	u64 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
 				<< TICK_LENGTH_SHIFT;
 	second_length += (s64)ntp_tick_adj << TICK_LENGTH_SHIFT;
 	second_length += time_freq;
 	tick_length_base = second_length;
 	tick_nsec = div_u64(second_length, HZ) >> TICK_LENGTH_SHIFT;
 	tick_length_base = div_u64(tick_length_base, NTP_INTERVAL_FREQ);
 }
 static void ntp_update_offset(long offset)
 {
 	long mtemp;
 	s64 freq_adj;
 	if (!(time_status & STA_PLL))
 		return;
 	if (!(time_status & STA_NANO))
 		offset *= NSEC_PER_USEC;
 	/*
 	 * Scale the phase adjustment and
 	 * clamp to the operating range.
 	 */
 	offset = min(offset, MAXPHASE);
 	offset = max(offset, -MAXPHASE);
 	/*
 	 * Select how the frequency is to be controlled
 	 * and in which mode (PLL or FLL).
 	 */
 	if (time_status & STA_FREQHOLD || time_reftime == 0)
 		time_reftime = xtime.tv_sec;
 	mtemp = xtime.tv_sec - time_reftime;
 	time_reftime = xtime.tv_sec;
 	freq_adj = (s64)offset * mtemp;
 	freq_adj <<= TICK_LENGTH_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant);
 	time_status &= ~STA_MODE;
 	if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > MAXSEC)) {
 		freq_adj += div_s64((s64)offset << (TICK_LENGTH_SHIFT - SHIFT_FLL),
 				    mtemp);
 		time_status |= STA_MODE;
 	}
 	freq_adj += time_freq;
 	freq_adj = min(freq_adj, MAXFREQ_SCALED);
 	time_freq = max(freq_adj, -MAXFREQ_SCALED);
 	time_offset = div_s64((s64)offset << TICK_LENGTH_SHIFT, NTP_INTERVAL_FREQ);
 }
 /**
  * ntp_clear - Clears the NTP state variables
  *
  * Must be called while holding a write on the xtime_lock
  */
 void ntp_clear(void)
 {
 	time_adjust = 0;		/* stop active adjtime() */
 	time_status |= STA_UNSYNC;
 	time_maxerror = NTP_PHASE_LIMIT;
 	time_esterror = NTP_PHASE_LIMIT;
 	ntp_update_frequency();
 	tick_length = tick_length_base;
 	time_offset = 0;
 }
 /*
  * this routine handles the overflow of the microsecond field
  *
  * The tricky bits of code to handle the accurate clock support
  * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
  * They were originally developed for SUN and DEC kernels.
  * All the kudos should go to Dave for this stuff.
  */
 void second_overflow(void)
 {
 	s64 time_adj;
 	/* Bump the maxerror field */
 	time_maxerror += MAXFREQ / NSEC_PER_USEC;
 	if (time_maxerror > NTP_PHASE_LIMIT) {
 		time_maxerror = NTP_PHASE_LIMIT;
 		time_status |= STA_UNSYNC;
 	}
 	/*
 	 * Leap second processing. If in leap-insert state at the end of the
 	 * day, the system clock is set back one second; if in leap-delete
 	 * state, the system clock is set ahead one second. The microtime()
 	 * routine or external clock driver will insure that reported time is
 	 * always monotonic. The ugly divides should be replaced.
 	 */
 	switch (time_state) {
 	case TIME_OK:
 		if (time_status & STA_INS)
 			time_state = TIME_INS;
 		else if (time_status & STA_DEL)
 			time_state = TIME_DEL;
 		break;
 	case TIME_INS:
 		if (xtime.tv_sec % 86400 == 0) {
 			xtime.tv_sec--;
 			wall_to_monotonic.tv_sec++;
 			time_state = TIME_OOP;
 			printk(KERN_NOTICE "Clock: inserting leap second "
 					"23:59:60 UTC\n");
 		}
 		break;
 	case TIME_DEL:
 		if ((xtime.tv_sec + 1) % 86400 == 0) {
 			xtime.tv_sec++;
+			time_tai--;
 			wall_to_monotonic.tv_sec--;
 			time_state = TIME_WAIT;
 			printk(KERN_NOTICE "Clock: deleting leap second "
 					"23:59:59 UTC\n");
 		}
 		break;
 	case TIME_OOP:
+		time_tai++;
 		time_state = TIME_WAIT;
 		break;
 	case TIME_WAIT:
 		if (!(time_status & (STA_INS | STA_DEL)))
 			time_state = TIME_OK;
 	}
 	/*
 	 * Compute the phase adjustment for the next second. The offset is
 	 * reduced by a fixed factor times the time constant.
 	 */
 	tick_length = tick_length_base;
 	time_adj = shift_right(time_offset, SHIFT_PLL + time_constant);
 	time_offset -= time_adj;
 	tick_length += time_adj;
 	if (unlikely(time_adjust)) {
 		if (time_adjust > MAX_TICKADJ) {
 			time_adjust -= MAX_TICKADJ;
 			tick_length += MAX_TICKADJ_SCALED;
 		} else if (time_adjust < -MAX_TICKADJ) {
 			time_adjust += MAX_TICKADJ;
 			tick_length -= MAX_TICKADJ_SCALED;
 		} else {
 			tick_length += (s64)(time_adjust * NSEC_PER_USEC /
 					NTP_INTERVAL_FREQ) << TICK_LENGTH_SHIFT;
 			time_adjust = 0;
 		}
 	}
 }
 /*
  * Return how long ticks are at the moment, that is, how much time
  * update_wall_time_one_tick will add to xtime next time we call it
  * (assuming no calls to do_adjtimex in the meantime).
  * The return value is in fixed-point nanoseconds shifted by the
  * specified number of bits to the right of the binary point.
  * This function has no side-effects.
  */
 u64 current_tick_length(void)
 {
 	return tick_length;
 }
 #ifdef CONFIG_GENERIC_CMOS_UPDATE
 /* Disable the cmos update - used by virtualization and embedded */
 int no_sync_cmos_clock  __read_mostly;
 static void sync_cmos_clock(unsigned long dummy);
 static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0);
 static void sync_cmos_clock(unsigned long dummy)
 {
 	struct timespec now, next;
 	int fail = 1;
 	/*
 	 * If we have an externally synchronized Linux clock, then update
 	 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
 	 * called as close as possible to 500 ms before the new second starts.
 	 * This code is run on a timer.  If the clock is set, that timer
 	 * may not expire at the correct time.  Thus, we adjust...
 	 */
 	if (!ntp_synced())
 		/*
 		 * Not synced, exit, do not restart a timer (if one is
 		 * running, let it run out).
 		 */
 		return;
 	getnstimeofday(&now);
 	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
 		fail = update_persistent_clock(now);
 	next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec;
 	if (next.tv_nsec <= 0)
 		next.tv_nsec += NSEC_PER_SEC;
 	if (!fail)
 		next.tv_sec = 659;
 	else
 		next.tv_sec = 0;
 	if (next.tv_nsec >= NSEC_PER_SEC) {
 		next.tv_sec++;
 		next.tv_nsec -= NSEC_PER_SEC;
 	}
 	mod_timer(&sync_cmos_timer, jiffies + timespec_to_jiffies(&next));
 }
 static void notify_cmos_timer(void)
 {
 	if (!no_sync_cmos_clock)
 		mod_timer(&sync_cmos_timer, jiffies + 1);
 }
 #else
 static inline void notify_cmos_timer(void) { }
 #endif
 /* adjtimex mainly allows reading (and writing, if superuser) of
  * kernel time-keeping variables. used by xntpd.
  */
 int do_adjtimex(struct timex *txc)
 {
 	struct timespec ts;
 	long save_adjust;
 	int result;
 	/* In order to modify anything, you gotta be super-user! */
 	if (txc->modes && !capable(CAP_SYS_TIME))
 		return -EPERM;
 	/* Now we validate the data before disabling interrupts */
 	if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT) {
 		/* singleshot must not be used with any other mode bits */
 		if (txc->modes & ~ADJ_OFFSET_SS_READ)
 			return -EINVAL;
 	}
 	/* if the quartz is off by more than 10% something is VERY wrong ! */
 	if (txc->modes & ADJ_TICK)
 		if (txc->tick <  900000/USER_HZ ||
 		    txc->tick > 1100000/USER_HZ)
 			return -EINVAL;
 	write_seqlock_irq(&xtime_lock);
 	/* Save for later - semantics of adjtime is to return old value */
 	save_adjust = time_adjust;
 	/* If there are input parameters, then process them */
 	if (txc->modes) {
 		if (txc->modes & ADJ_STATUS) {
 			if ((time_status & STA_PLL) &&
 			    !(txc->status & STA_PLL)) {
 				time_state = TIME_OK;
 				time_status = STA_UNSYNC;
 			}
 			/* only set allowed bits */
 			time_status &= STA_RONLY;
 			time_status |= txc->status & ~STA_RONLY;
 		}
 		if (txc->modes & ADJ_NANO)
 			time_status |= STA_NANO;
 		if (txc->modes & ADJ_MICRO)
 			time_status &= ~STA_NANO;
 		if (txc->modes & ADJ_FREQUENCY) {
 			time_freq = (s64)txc->freq * PPM_SCALE;
 			time_freq = min(time_freq, MAXFREQ_SCALED);
 			time_freq = max(time_freq, -MAXFREQ_SCALED);
 		}
 		if (txc->modes & ADJ_MAXERROR)
 			time_maxerror = txc->maxerror;
 		if (txc->modes & ADJ_ESTERROR)
 			time_esterror = txc->esterror;
 		if (txc->modes & ADJ_TIMECONST) {
 			time_constant = txc->constant;
 			if (!(time_status & STA_NANO))
 				time_constant += 4;
 			time_constant = min(time_constant, (long)MAXTC);
 			time_constant = max(time_constant, 0l);
 		}
+		if (txc->modes & ADJ_TAI && txc->constant > 0)
+			time_tai = txc->constant;
 		if (txc->modes & ADJ_OFFSET) {
 			if (txc->modes == ADJ_OFFSET_SINGLESHOT)
 				/* adjtime() is independent from ntp_adjtime() */
 				time_adjust = txc->offset;
 			else
 				ntp_update_offset(txc->offset);
 		}
 		if (txc->modes & ADJ_TICK)
 			tick_usec = txc->tick;
 		if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
 			ntp_update_frequency();
 	}
 	result = time_state;	/* mostly `TIME_OK' */
 	if (time_status & (STA_UNSYNC|STA_CLOCKERR))
 		result = TIME_ERROR;
 	if ((txc->modes == ADJ_OFFSET_SINGLESHOT) ||
 	    (txc->modes == ADJ_OFFSET_SS_READ))
 		txc->offset = save_adjust;
 	else {
 		txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
 					  TICK_LENGTH_SHIFT);
 		if (!(time_status & STA_NANO))
 			txc->offset /= NSEC_PER_USEC;
 	}
 	txc->freq	   = shift_right((s32)(time_freq >> PPM_SCALE_INV_SHIFT) *
 					 (s64)PPM_SCALE_INV,
 					 TICK_LENGTH_SHIFT);
 	txc->maxerror	   = time_maxerror;
 	txc->esterror	   = time_esterror;
 	txc->status	   = time_status;
 	txc->constant	   = time_constant;
 	txc->precision	   = 1;
 	txc->tolerance	   = MAXFREQ_SCALED / PPM_SCALE;
 	txc->tick	   = tick_usec;
+	txc->tai	   = time_tai;
 	/* PPS is not implemented, so these are zero */
 	txc->ppsfreq	   = 0;
 	txc->jitter	   = 0;
 	txc->shift	   = 0;
 	txc->stabil	   = 0;
 	txc->jitcnt	   = 0;
 	txc->calcnt	   = 0;
 	txc->errcnt	   = 0;
 	txc->stbcnt	   = 0;
 	write_sequnlock_irq(&xtime_lock);
 	getnstimeofday(&ts);
 	txc->time.tv_sec = ts.tv_sec;
 	txc->time.tv_usec = ts.tv_nsec;
 	if (!(time_status & STA_NANO))
 		txc->time.tv_usec /= NSEC_PER_USEC;
 	notify_cmos_timer();
 	return result;
 }
 static int __init ntp_tick_adj_setup(char *str)
 {
 	ntp_tick_adj = simple_strtol(str, NULL, 0);
 	return 1;
 }
 __setup("ntp_tick_adj=", ntp_tick_adj_setup);