Eric Lee / smarc-fsl-linux-kernel

Commit b845b517b5e3706a3729f6ea83b88ab85f0725b0

Authored by Peter Zijlstra 17 years ago

Committed by Ingo Molnar 17 years ago

Exists in master and in 39 other branches

printk: robustify printk

Avoid deadlocks against rq->lock and xtime_lock by deferring the klogd
wakeup by polling from the timer tick.

Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

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

include/linux/kernel.h
kernel/printk.c
kernel/time/tick-sched.c
kernel/timer.c

include/linux/kernel.h

Diff comments View file @ b845b51

 #ifndef _LINUX_KERNEL_H
 #define _LINUX_KERNEL_H
 /*
  * 'kernel.h' contains some often-used function prototypes etc
  */
 #ifdef __KERNEL__
 #include <stdarg.h>
 #include <linux/linkage.h>
 #include <linux/stddef.h>
 #include <linux/types.h>
 #include <linux/compiler.h>
 #include <linux/bitops.h>
 #include <linux/log2.h>
 #include <linux/typecheck.h>
 #include <linux/ratelimit.h>
 #include <asm/byteorder.h>
 #include <asm/bug.h>
 extern const char linux_banner[];
 extern const char linux_proc_banner[];
 #define USHORT_MAX	((u16)(~0U))
 #define SHORT_MAX	((s16)(USHORT_MAX>>1))
 #define SHORT_MIN	(-SHORT_MAX - 1)
 #define INT_MAX		((int)(~0U>>1))
 #define INT_MIN		(-INT_MAX - 1)
 #define UINT_MAX	(~0U)
 #define LONG_MAX	((long)(~0UL>>1))
 #define LONG_MIN	(-LONG_MAX - 1)
 #define ULONG_MAX	(~0UL)
 #define LLONG_MAX	((long long)(~0ULL>>1))
 #define LLONG_MIN	(-LLONG_MAX - 1)
 #define ULLONG_MAX	(~0ULL)
 #define STACK_MAGIC	0xdeadbeef
 #define ALIGN(x,a)		__ALIGN_MASK(x,(typeof(x))(a)-1)
 #define __ALIGN_MASK(x,mask)	(((x)+(mask))&~(mask))
 #define PTR_ALIGN(p, a)		((typeof(p))ALIGN((unsigned long)(p), (a)))
 #define IS_ALIGNED(x, a)		(((x) & ((typeof(x))(a) - 1)) == 0)
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
 #define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
 #define _RET_IP_		(unsigned long)__builtin_return_address(0)
 #define _THIS_IP_  ({ __label__ __here; __here: (unsigned long)&&__here; })
 #ifdef CONFIG_LBD
 # include <asm/div64.h>
 # define sector_div(a, b) do_div(a, b)
 #else
 # define sector_div(n, b)( \
 { \
 	int _res; \
 	_res = (n) % (b); \
 	(n) /= (b); \
 	_res; \
 } \
 )
 #endif
 /**
  * upper_32_bits - return bits 32-63 of a number
  * @n: the number we're accessing
  *
  * A basic shift-right of a 64- or 32-bit quantity.  Use this to suppress
  * the "right shift count >= width of type" warning when that quantity is
  * 32-bits.
  */
 #define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
 /**
  * lower_32_bits - return bits 0-31 of a number
  * @n: the number we're accessing
  */
 #define lower_32_bits(n) ((u32)(n))
 #define	KERN_EMERG	"<0>"	/* system is unusable			*/
 #define	KERN_ALERT	"<1>"	/* action must be taken immediately	*/
 #define	KERN_CRIT	"<2>"	/* critical conditions			*/
 #define	KERN_ERR	"<3>"	/* error conditions			*/
 #define	KERN_WARNING	"<4>"	/* warning conditions			*/
 #define	KERN_NOTICE	"<5>"	/* normal but significant condition	*/
 #define	KERN_INFO	"<6>"	/* informational			*/
 #define	KERN_DEBUG	"<7>"	/* debug-level messages			*/
 /*
  * Annotation for a "continued" line of log printout (only done after a
  * line that had no enclosing \n). Only to be used by core/arch code
  * during early bootup (a continued line is not SMP-safe otherwise).
  */
 #define	KERN_CONT	""
 extern int console_printk[];
 #define console_loglevel (console_printk[0])
 #define default_message_loglevel (console_printk[1])
 #define minimum_console_loglevel (console_printk[2])
 #define default_console_loglevel (console_printk[3])
 struct completion;
 struct pt_regs;
 struct user;
 /**
  * might_sleep - annotation for functions that can sleep
  *
  * this macro will print a stack trace if it is executed in an atomic
  * context (spinlock, irq-handler, ...).
  *
  * This is a useful debugging help to be able to catch problems early and not
  * be bitten later when the calling function happens to sleep when it is not
  * supposed to.
  */
 #ifdef CONFIG_PREEMPT_VOLUNTARY
 extern int _cond_resched(void);
 # define might_resched() _cond_resched()
 #else
 # define might_resched() do { } while (0)
 #endif
 #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
   void __might_sleep(char *file, int line);
 # define might_sleep() \
 	do { __might_sleep(__FILE__, __LINE__); might_resched(); } while (0)
 #else
 # define might_sleep() do { might_resched(); } while (0)
 #endif
 #define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)
 #define abs(x) ({				\
 		int __x = (x);			\
 		(__x < 0) ? -__x : __x;		\
 	})
 extern struct atomic_notifier_head panic_notifier_list;
 extern long (*panic_blink)(long time);
 NORET_TYPE void panic(const char * fmt, ...)
 	__attribute__ ((NORET_AND format (printf, 1, 2))) __cold;
 extern void oops_enter(void);
 extern void oops_exit(void);
 extern int oops_may_print(void);
 NORET_TYPE void do_exit(long error_code)
 	ATTRIB_NORET;
 NORET_TYPE void complete_and_exit(struct completion *, long)
 	ATTRIB_NORET;
 extern unsigned long simple_strtoul(const char *,char **,unsigned int);
 extern long simple_strtol(const char *,char **,unsigned int);
 extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
 extern long long simple_strtoll(const char *,char **,unsigned int);
 extern int strict_strtoul(const char *, unsigned int, unsigned long *);
 extern int strict_strtol(const char *, unsigned int, long *);
 extern int strict_strtoull(const char *, unsigned int, unsigned long long *);
 extern int strict_strtoll(const char *, unsigned int, long long *);
 extern int sprintf(char * buf, const char * fmt, ...)
 	__attribute__ ((format (printf, 2, 3)));
 extern int vsprintf(char *buf, const char *, va_list)
 	__attribute__ ((format (printf, 2, 0)));
 extern int snprintf(char * buf, size_t size, const char * fmt, ...)
 	__attribute__ ((format (printf, 3, 4)));
 extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
 	__attribute__ ((format (printf, 3, 0)));
 extern int scnprintf(char * buf, size_t size, const char * fmt, ...)
 	__attribute__ ((format (printf, 3, 4)));
 extern int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
 	__attribute__ ((format (printf, 3, 0)));
 extern char *kasprintf(gfp_t gfp, const char *fmt, ...)
 	__attribute__ ((format (printf, 2, 3)));
 extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
 extern int sscanf(const char *, const char *, ...)
 	__attribute__ ((format (scanf, 2, 3)));
 extern int vsscanf(const char *, const char *, va_list)
 	__attribute__ ((format (scanf, 2, 0)));
 extern int get_option(char **str, int *pint);
 extern char *get_options(const char *str, int nints, int *ints);
 extern unsigned long long memparse(char *ptr, char **retptr);
 extern int core_kernel_text(unsigned long addr);
 extern int __kernel_text_address(unsigned long addr);
 extern int kernel_text_address(unsigned long addr);
 struct pid;
 extern struct pid *session_of_pgrp(struct pid *pgrp);
 #ifdef CONFIG_PRINTK
 asmlinkage int vprintk(const char *fmt, va_list args)
 	__attribute__ ((format (printf, 1, 0)));
 asmlinkage int printk(const char * fmt, ...)
 	__attribute__ ((format (printf, 1, 2))) __cold;
 extern struct ratelimit_state printk_ratelimit_state;
 extern int printk_ratelimit(void);
 extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
 				   unsigned int interval_msec);
+extern void printk_tick(void);
+extern int printk_needs_cpu(int);
 #else
 static inline int vprintk(const char *s, va_list args)
 	__attribute__ ((format (printf, 1, 0)));
 static inline int vprintk(const char *s, va_list args) { return 0; }
 static inline int printk(const char *s, ...)
 	__attribute__ ((format (printf, 1, 2)));
 static inline int __cold printk(const char *s, ...) { return 0; }
 static inline int printk_ratelimit(void) { return 0; }
 static inline bool printk_timed_ratelimit(unsigned long *caller_jiffies, \
 					  unsigned int interval_msec)	\
 		{ return false; }
+static inline void printk_tick(void) { }
+static inline int printk_needs_cpu(int) { return 0; }
 #endif
 extern void asmlinkage __attribute__((format(printf, 1, 2)))
 	early_printk(const char *fmt, ...);
 unsigned long int_sqrt(unsigned long);
 static inline void console_silent(void)
 {
 	console_loglevel = 0;
 }
 static inline void console_verbose(void)
 {
 	if (console_loglevel)
 		console_loglevel = 15;
 }
 extern void bust_spinlocks(int yes);
 extern void wake_up_klogd(void);
 extern int oops_in_progress;		/* If set, an oops, panic(), BUG() or die() is in progress */
 extern int panic_timeout;
 extern int panic_on_oops;
 extern int panic_on_unrecovered_nmi;
 extern int tainted;
 extern const char *print_tainted(void);
 extern void add_taint(unsigned);
 extern int root_mountflags;
 /* Values used for system_state */
 extern enum system_states {
 	SYSTEM_BOOTING,
 	SYSTEM_RUNNING,
 	SYSTEM_HALT,
 	SYSTEM_POWER_OFF,
 	SYSTEM_RESTART,
 	SYSTEM_SUSPEND_DISK,
 } system_state;
 #define TAINT_PROPRIETARY_MODULE	(1<<0)
 #define TAINT_FORCED_MODULE		(1<<1)
 #define TAINT_UNSAFE_SMP		(1<<2)
 #define TAINT_FORCED_RMMOD		(1<<3)
 #define TAINT_MACHINE_CHECK		(1<<4)
 #define TAINT_BAD_PAGE			(1<<5)
 #define TAINT_USER			(1<<6)
 #define TAINT_DIE			(1<<7)
 #define TAINT_OVERRIDDEN_ACPI_TABLE	(1<<8)
 #define TAINT_WARN			(1<<9)
 extern void dump_stack(void) __cold;
 enum {
 	DUMP_PREFIX_NONE,
 	DUMP_PREFIX_ADDRESS,
 	DUMP_PREFIX_OFFSET
 };
 extern void hex_dump_to_buffer(const void *buf, size_t len,
 				int rowsize, int groupsize,
 				char *linebuf, size_t linebuflen, bool ascii);
 extern void print_hex_dump(const char *level, const char *prefix_str,
 				int prefix_type, int rowsize, int groupsize,
 				const void *buf, size_t len, bool ascii);
 extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
 			const void *buf, size_t len);
 extern const char hex_asc[];
 #define hex_asc_lo(x)	hex_asc[((x) & 0x0f)]
 #define hex_asc_hi(x)	hex_asc[((x) & 0xf0) >> 4]
 static inline char *pack_hex_byte(char *buf, u8 byte)
 {
 	*buf++ = hex_asc_hi(byte);
 	*buf++ = hex_asc_lo(byte);
 	return buf;
 }
 #define pr_emerg(fmt, arg...) \
 	printk(KERN_EMERG fmt, ##arg)
 #define pr_alert(fmt, arg...) \
 	printk(KERN_ALERT fmt, ##arg)
 #define pr_crit(fmt, arg...) \
 	printk(KERN_CRIT fmt, ##arg)
 #define pr_err(fmt, arg...) \
 	printk(KERN_ERR fmt, ##arg)
 #define pr_warning(fmt, arg...) \
 	printk(KERN_WARNING fmt, ##arg)
 #define pr_notice(fmt, arg...) \
 	printk(KERN_NOTICE fmt, ##arg)
 #define pr_info(fmt, arg...) \
 	printk(KERN_INFO fmt, ##arg)
 #ifdef DEBUG
 /* If you are writing a driver, please use dev_dbg instead */
 #define pr_debug(fmt, arg...) \
 	printk(KERN_DEBUG fmt, ##arg)
 #else
 #define pr_debug(fmt, arg...) \
 	({ if (0) printk(KERN_DEBUG fmt, ##arg); 0; })
 #endif
 /*
  *      Display an IP address in readable format.
  */
 #define NIPQUAD(addr) \
 	((unsigned char *)&addr)[0], \
 	((unsigned char *)&addr)[1], \
 	((unsigned char *)&addr)[2], \
 	((unsigned char *)&addr)[3]
 #define NIPQUAD_FMT "%u.%u.%u.%u"
 #define NIP6(addr) \
 	ntohs((addr).s6_addr16[0]), \
 	ntohs((addr).s6_addr16[1]), \
 	ntohs((addr).s6_addr16[2]), \
 	ntohs((addr).s6_addr16[3]), \
 	ntohs((addr).s6_addr16[4]), \
 	ntohs((addr).s6_addr16[5]), \
 	ntohs((addr).s6_addr16[6]), \
 	ntohs((addr).s6_addr16[7])
 #define NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
 #define NIP6_SEQFMT "%04x%04x%04x%04x%04x%04x%04x%04x"
 #if defined(__LITTLE_ENDIAN)
 #define HIPQUAD(addr) \
 	((unsigned char *)&addr)[3], \
 	((unsigned char *)&addr)[2], \
 	((unsigned char *)&addr)[1], \
 	((unsigned char *)&addr)[0]
 #elif defined(__BIG_ENDIAN)
 #define HIPQUAD	NIPQUAD
 #else
 #error "Please fix asm/byteorder.h"
 #endif /* __LITTLE_ENDIAN */
 /*
  * min()/max()/clamp() macros that also do
  * strict type-checking.. See the
  * "unnecessary" pointer comparison.
  */
 #define min(x, y) ({				\
 	typeof(x) _min1 = (x);			\
 	typeof(y) _min2 = (y);			\
 	(void) (&_min1 == &_min2);		\
 	_min1 < _min2 ? _min1 : _min2; })
 #define max(x, y) ({				\
 	typeof(x) _max1 = (x);			\
 	typeof(y) _max2 = (y);			\
 	(void) (&_max1 == &_max2);		\
 	_max1 > _max2 ? _max1 : _max2; })
 /**
  * clamp - return a value clamped to a given range with strict typechecking
  * @val: current value
  * @min: minimum allowable value
  * @max: maximum allowable value
  *
  * This macro does strict typechecking of min/max to make sure they are of the
  * same type as val.  See the unnecessary pointer comparisons.
  */
 #define clamp(val, min, max) ({			\
 	typeof(val) __val = (val);		\
 	typeof(min) __min = (min);		\
 	typeof(max) __max = (max);		\
 	(void) (&__val == &__min);		\
 	(void) (&__val == &__max);		\
 	__val = __val < __min ? __min: __val;	\
 	__val > __max ? __max: __val; })
 /*
  * ..and if you can't take the strict
  * types, you can specify one yourself.
  *
  * Or not use min/max/clamp at all, of course.
  */
 #define min_t(type, x, y) ({			\
 	type __min1 = (x);			\
 	type __min2 = (y);			\
 	__min1 < __min2 ? __min1: __min2; })
 #define max_t(type, x, y) ({			\
 	type __max1 = (x);			\
 	type __max2 = (y);			\
 	__max1 > __max2 ? __max1: __max2; })
 /**
  * clamp_t - return a value clamped to a given range using a given type
  * @type: the type of variable to use
  * @val: current value
  * @min: minimum allowable value
  * @max: maximum allowable value
  *
  * This macro does no typechecking and uses temporary variables of type
  * 'type' to make all the comparisons.
  */
 #define clamp_t(type, val, min, max) ({		\
 	type __val = (val);			\
 	type __min = (min);			\
 	type __max = (max);			\
 	__val = __val < __min ? __min: __val;	\
 	__val > __max ? __max: __val; })
 /**
  * clamp_val - return a value clamped to a given range using val's type
  * @val: current value
  * @min: minimum allowable value
  * @max: maximum allowable value
  *
  * This macro does no typechecking and uses temporary variables of whatever
  * type the input argument 'val' is.  This is useful when val is an unsigned
  * type and min and max are literals that will otherwise be assigned a signed
  * integer type.
  */
 #define clamp_val(val, min, max) ({		\
 	typeof(val) __val = (val);		\
 	typeof(val) __min = (min);		\
 	typeof(val) __max = (max);		\
 	__val = __val < __min ? __min: __val;	\
 	__val > __max ? __max: __val; })
 /**
  * container_of - cast a member of a structure out to the containing structure
  * @ptr:	the pointer to the member.
  * @type:	the type of the container struct this is embedded in.
  * @member:	the name of the member within the struct.
  *
  */
 #define container_of(ptr, type, member) ({			\
 	const typeof( ((type *)0)->member ) *__mptr = (ptr);	\
 	(type *)( (char *)__mptr - offsetof(type,member) );})
 struct sysinfo;
 extern int do_sysinfo(struct sysinfo *info);
 #endif /* __KERNEL__ */
 #define SI_LOAD_SHIFT	16
 struct sysinfo {
 	long uptime;			/* Seconds since boot */
 	unsigned long loads[3];		/* 1, 5, and 15 minute load averages */
 	unsigned long totalram;		/* Total usable main memory size */
 	unsigned long freeram;		/* Available memory size */
 	unsigned long sharedram;	/* Amount of shared memory */
 	unsigned long bufferram;	/* Memory used by buffers */
 	unsigned long totalswap;	/* Total swap space size */
 	unsigned long freeswap;		/* swap space still available */
 	unsigned short procs;		/* Number of current processes */
 	unsigned short pad;		/* explicit padding for m68k */
 	unsigned long totalhigh;	/* Total high memory size */
 	unsigned long freehigh;		/* Available high memory size */
 	unsigned int mem_unit;		/* Memory unit size in bytes */
 	char _f[20-2*sizeof(long)-sizeof(int)];	/* Padding: libc5 uses this.. */
 };
 /* Force a compilation error if condition is true */
 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
 /* Force a compilation error if condition is true, but also produce a
    result (of value 0 and type size_t), so the expression can be used
    e.g. in a structure initializer (or where-ever else comma expressions
    aren't permitted). */
 #define BUILD_BUG_ON_ZERO(e) (sizeof(char[1 - 2 * !!(e)]) - 1)
 /* Trap pasters of __FUNCTION__ at compile-time */
 #define __FUNCTION__ (__func__)
 /* This helps us to avoid #ifdef CONFIG_NUMA */
 #ifdef CONFIG_NUMA
 #define NUMA_BUILD 1
 #else
 #define NUMA_BUILD 0
 #endif
 #endif

kernel/printk.c

Diff comments View file @ b845b51

 /*
  *  linux/kernel/printk.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  * Modified to make sys_syslog() more flexible: added commands to
  * return the last 4k of kernel messages, regardless of whether
  * they've been read or not.  Added option to suppress kernel printk's
  * to the console.  Added hook for sending the console messages
  * elsewhere, in preparation for a serial line console (someday).
  * Ted Ts'o, 2/11/93.
  * Modified for sysctl support, 1/8/97, Chris Horn.
  * Fixed SMP synchronization, 08/08/99, Manfred Spraul
  *     manfred@colorfullife.com
  * Rewrote bits to get rid of console_lock
  *	01Mar01 Andrew Morton <andrewm@uow.edu.au>
  */
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/console.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
 #include <linux/nmi.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/interrupt.h>			/* For in_interrupt() */
 #include <linux/delay.h>
 #include <linux/smp.h>
 #include <linux/security.h>
 #include <linux/bootmem.h>
 #include <linux/syscalls.h>
 #include <asm/uaccess.h>
 /*
  * Architectures can override it:
  */
 void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
 {
 }
 #define __LOG_BUF_LEN	(1 << CONFIG_LOG_BUF_SHIFT)
 /* printk's without a loglevel use this.. */
 #define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
 /* We show everything that is MORE important than this.. */
 #define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
 #define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
 DECLARE_WAIT_QUEUE_HEAD(log_wait);
 int console_printk[4] = {
 	DEFAULT_CONSOLE_LOGLEVEL,	/* console_loglevel */
 	DEFAULT_MESSAGE_LOGLEVEL,	/* default_message_loglevel */
 	MINIMUM_CONSOLE_LOGLEVEL,	/* minimum_console_loglevel */
 	DEFAULT_CONSOLE_LOGLEVEL,	/* default_console_loglevel */
 };
 /*
  * Low level drivers may need that to know if they can schedule in
  * their unblank() callback or not. So let's export it.
  */
 int oops_in_progress;
 EXPORT_SYMBOL(oops_in_progress);
 /*
  * console_sem protects the console_drivers list, and also
  * provides serialisation for access to the entire console
  * driver system.
  */
 static DECLARE_MUTEX(console_sem);
 static DECLARE_MUTEX(secondary_console_sem);
 struct console *console_drivers;
 EXPORT_SYMBOL_GPL(console_drivers);
 /*
  * This is used for debugging the mess that is the VT code by
  * keeping track if we have the console semaphore held. It's
  * definitely not the perfect debug tool (we don't know if _WE_
  * hold it are racing, but it helps tracking those weird code
  * path in the console code where we end up in places I want
  * locked without the console sempahore held
  */
 static int console_locked, console_suspended;
 /*
  * logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
  * It is also used in interesting ways to provide interlocking in
  * release_console_sem().
  */
 static DEFINE_SPINLOCK(logbuf_lock);
 #define LOG_BUF_MASK (log_buf_len-1)
 #define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
 /*
  * The indices into log_buf are not constrained to log_buf_len - they
  * must be masked before subscripting
  */
 static unsigned log_start;	/* Index into log_buf: next char to be read by syslog() */
 static unsigned con_start;	/* Index into log_buf: next char to be sent to consoles */
 static unsigned log_end;	/* Index into log_buf: most-recently-written-char + 1 */
 /*
  *	Array of consoles built from command line options (console=)
  */
 struct console_cmdline
 {
 	char	name[8];			/* Name of the driver	    */
 	int	index;				/* Minor dev. to use	    */
 	char	*options;			/* Options for the driver   */
 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
 	char	*brl_options;			/* Options for braille driver */
 #endif
 };
 #define MAX_CMDLINECONSOLES 8
 static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
 static int selected_console = -1;
 static int preferred_console = -1;
 int console_set_on_cmdline;
 EXPORT_SYMBOL(console_set_on_cmdline);
 /* Flag: console code may call schedule() */
 static int console_may_schedule;
 #ifdef CONFIG_PRINTK
 static char __log_buf[__LOG_BUF_LEN];
 static char *log_buf = __log_buf;
 static int log_buf_len = __LOG_BUF_LEN;
 static unsigned logged_chars; /* Number of chars produced since last read+clear operation */
 static int __init log_buf_len_setup(char *str)
 {
 	unsigned size = memparse(str, &str);
 	unsigned long flags;
 	if (size)
 		size = roundup_pow_of_two(size);
 	if (size > log_buf_len) {
 		unsigned start, dest_idx, offset;
 		char *new_log_buf;
 		new_log_buf = alloc_bootmem(size);
 		if (!new_log_buf) {
 			printk(KERN_WARNING "log_buf_len: allocation failed\n");
 			goto out;
 		}
 		spin_lock_irqsave(&logbuf_lock, flags);
 		log_buf_len = size;
 		log_buf = new_log_buf;
 		offset = start = min(con_start, log_start);
 		dest_idx = 0;
 		while (start != log_end) {
 			log_buf[dest_idx] = __log_buf[start & (__LOG_BUF_LEN - 1)];
 			start++;
 			dest_idx++;
 		}
 		log_start -= offset;
 		con_start -= offset;
 		log_end -= offset;
 		spin_unlock_irqrestore(&logbuf_lock, flags);
 		printk(KERN_NOTICE "log_buf_len: %d\n", log_buf_len);
 	}
 out:
 	return 1;
 }
 __setup("log_buf_len=", log_buf_len_setup);
 #ifdef CONFIG_BOOT_PRINTK_DELAY
 static unsigned int boot_delay; /* msecs delay after each printk during bootup */
 static unsigned long long printk_delay_msec; /* per msec, based on boot_delay */
 static int __init boot_delay_setup(char *str)
 {
 	unsigned long lpj;
 	unsigned long long loops_per_msec;
 	lpj = preset_lpj ? preset_lpj : 1000000;	/* some guess */
 	loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
 	get_option(&str, &boot_delay);
 	if (boot_delay > 10 * 1000)
 		boot_delay = 0;
 	printk_delay_msec = loops_per_msec;
 	printk(KERN_DEBUG "boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
 		"HZ: %d, printk_delay_msec: %llu\n",
 		boot_delay, preset_lpj, lpj, HZ, printk_delay_msec);
 	return 1;
 }
 __setup("boot_delay=", boot_delay_setup);
 static void boot_delay_msec(void)
 {
 	unsigned long long k;
 	unsigned long timeout;
 	if (boot_delay == 0 || system_state != SYSTEM_BOOTING)
 		return;
 	k = (unsigned long long)printk_delay_msec * boot_delay;
 	timeout = jiffies + msecs_to_jiffies(boot_delay);
 	while (k) {
 		k--;
 		cpu_relax();
 		/*
 		 * use (volatile) jiffies to prevent
 		 * compiler reduction; loop termination via jiffies
 		 * is secondary and may or may not happen.
 		 */
 		if (time_after(jiffies, timeout))
 			break;
 		touch_nmi_watchdog();
 	}
 }
 #else
 static inline void boot_delay_msec(void)
 {
 }
 #endif
 /*
  * Return the number of unread characters in the log buffer.
  */
 static int log_buf_get_len(void)
 {
 	return logged_chars;
 }
 /*
  * Copy a range of characters from the log buffer.
  */
 int log_buf_copy(char *dest, int idx, int len)
 {
 	int ret, max;
 	bool took_lock = false;
 	if (!oops_in_progress) {
 		spin_lock_irq(&logbuf_lock);
 		took_lock = true;
 	}
 	max = log_buf_get_len();
 	if (idx < 0 || idx >= max) {
 		ret = -1;
 	} else {
 		if (len > max)
 			len = max;
 		ret = len;
 		idx += (log_end - max);
 		while (len-- > 0)
 			dest[len] = LOG_BUF(idx + len);
 	}
 	if (took_lock)
 		spin_unlock_irq(&logbuf_lock);
 	return ret;
 }
 /*
  * Commands to do_syslog:
  *
  * 	0 -- Close the log.  Currently a NOP.
  * 	1 -- Open the log. Currently a NOP.
  * 	2 -- Read from the log.
  * 	3 -- Read all messages remaining in the ring buffer.
  * 	4 -- Read and clear all messages remaining in the ring buffer
  * 	5 -- Clear ring buffer.
  * 	6 -- Disable printk's to console
  * 	7 -- Enable printk's to console
  *	8 -- Set level of messages printed to console
  *	9 -- Return number of unread characters in the log buffer
  *     10 -- Return size of the log buffer
  */
 int do_syslog(int type, char __user *buf, int len)
 {
 	unsigned i, j, limit, count;
 	int do_clear = 0;
 	char c;
 	int error = 0;
 	error = security_syslog(type);
 	if (error)
 		return error;
 	switch (type) {
 	case 0:		/* Close log */
 		break;
 	case 1:		/* Open log */
 		break;
 	case 2:		/* Read from log */
 		error = -EINVAL;
 		if (!buf || len < 0)
 			goto out;
 		error = 0;
 		if (!len)
 			goto out;
 		if (!access_ok(VERIFY_WRITE, buf, len)) {
 			error = -EFAULT;
 			goto out;
 		}
 		error = wait_event_interruptible(log_wait,
 							(log_start - log_end));
 		if (error)
 			goto out;
 		i = 0;
 		spin_lock_irq(&logbuf_lock);
 		while (!error && (log_start != log_end) && i < len) {
 			c = LOG_BUF(log_start);
 			log_start++;
 			spin_unlock_irq(&logbuf_lock);
 			error = __put_user(c,buf);
 			buf++;
 			i++;
 			cond_resched();
 			spin_lock_irq(&logbuf_lock);
 		}
 		spin_unlock_irq(&logbuf_lock);
 		if (!error)
 			error = i;
 		break;
 	case 4:		/* Read/clear last kernel messages */
 		do_clear = 1;
 		/* FALL THRU */
 	case 3:		/* Read last kernel messages */
 		error = -EINVAL;
 		if (!buf || len < 0)
 			goto out;
 		error = 0;
 		if (!len)
 			goto out;
 		if (!access_ok(VERIFY_WRITE, buf, len)) {
 			error = -EFAULT;
 			goto out;
 		}
 		count = len;
 		if (count > log_buf_len)
 			count = log_buf_len;
 		spin_lock_irq(&logbuf_lock);
 		if (count > logged_chars)
 			count = logged_chars;
 		if (do_clear)
 			logged_chars = 0;
 		limit = log_end;
 		/*
 		 * __put_user() could sleep, and while we sleep
 		 * printk() could overwrite the messages
 		 * we try to copy to user space. Therefore
 		 * the messages are copied in reverse. <manfreds>
 		 */
 		for (i = 0; i < count && !error; i++) {
 			j = limit-1-i;
 			if (j + log_buf_len < log_end)
 				break;
 			c = LOG_BUF(j);
 			spin_unlock_irq(&logbuf_lock);
 			error = __put_user(c,&buf[count-1-i]);
 			cond_resched();
 			spin_lock_irq(&logbuf_lock);
 		}
 		spin_unlock_irq(&logbuf_lock);
 		if (error)
 			break;
 		error = i;
 		if (i != count) {
 			int offset = count-error;
 			/* buffer overflow during copy, correct user buffer. */
 			for (i = 0; i < error; i++) {
 				if (__get_user(c,&buf[i+offset]) ||
 				    __put_user(c,&buf[i])) {
 					error = -EFAULT;
 					break;
 				}
 				cond_resched();
 			}
 		}
 		break;
 	case 5:		/* Clear ring buffer */
 		logged_chars = 0;
 		break;
 	case 6:		/* Disable logging to console */
 		console_loglevel = minimum_console_loglevel;
 		break;
 	case 7:		/* Enable logging to console */
 		console_loglevel = default_console_loglevel;
 		break;
 	case 8:		/* Set level of messages printed to console */
 		error = -EINVAL;
 		if (len < 1 || len > 8)
 			goto out;
 		if (len < minimum_console_loglevel)
 			len = minimum_console_loglevel;
 		console_loglevel = len;
 		error = 0;
 		break;
 	case 9:		/* Number of chars in the log buffer */
 		error = log_end - log_start;
 		break;
 	case 10:	/* Size of the log buffer */
 		error = log_buf_len;
 		break;
 	default:
 		error = -EINVAL;
 		break;
 	}
 out:
 	return error;
 }
 asmlinkage long sys_syslog(int type, char __user *buf, int len)
 {
 	return do_syslog(type, buf, len);
 }
 /*
  * Call the console drivers on a range of log_buf
  */
 static void __call_console_drivers(unsigned start, unsigned end)
 {
 	struct console *con;
 	for (con = console_drivers; con; con = con->next) {
 		if ((con->flags & CON_ENABLED) && con->write &&
 				(cpu_online(smp_processor_id()) ||
 				(con->flags & CON_ANYTIME)))
 			con->write(con, &LOG_BUF(start), end - start);
 	}
 }
 static int __read_mostly ignore_loglevel;
 static int __init ignore_loglevel_setup(char *str)
 {
 	ignore_loglevel = 1;
 	printk(KERN_INFO "debug: ignoring loglevel setting.\n");
 	return 0;
 }
 early_param("ignore_loglevel", ignore_loglevel_setup);
 /*
  * Write out chars from start to end - 1 inclusive
  */
 static void _call_console_drivers(unsigned start,
 				unsigned end, int msg_log_level)
 {
 	if ((msg_log_level < console_loglevel || ignore_loglevel) &&
 			console_drivers && start != end) {
 		if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
 			/* wrapped write */
 			__call_console_drivers(start & LOG_BUF_MASK,
 						log_buf_len);
 			__call_console_drivers(0, end & LOG_BUF_MASK);
 		} else {
 			__call_console_drivers(start, end);
 		}
 	}
 }
 /*
  * Call the console drivers, asking them to write out
  * log_buf[start] to log_buf[end - 1].
  * The console_sem must be held.
  */
 static void call_console_drivers(unsigned start, unsigned end)
 {
 	unsigned cur_index, start_print;
 	static int msg_level = -1;
 	BUG_ON(((int)(start - end)) > 0);
 	cur_index = start;
 	start_print = start;
 	while (cur_index != end) {
 		if (msg_level < 0 && ((end - cur_index) > 2) &&
 				LOG_BUF(cur_index + 0) == '<' &&
 				LOG_BUF(cur_index + 1) >= '0' &&
 				LOG_BUF(cur_index + 1) <= '7' &&
 				LOG_BUF(cur_index + 2) == '>') {
 			msg_level = LOG_BUF(cur_index + 1) - '0';
 			cur_index += 3;
 			start_print = cur_index;
 		}
 		while (cur_index != end) {
 			char c = LOG_BUF(cur_index);
 			cur_index++;
 			if (c == '\n') {
 				if (msg_level < 0) {
 					/*
 					 * printk() has already given us loglevel tags in
 					 * the buffer.  This code is here in case the
 					 * log buffer has wrapped right round and scribbled
 					 * on those tags
 					 */
 					msg_level = default_message_loglevel;
 				}
 				_call_console_drivers(start_print, cur_index, msg_level);
 				msg_level = -1;
 				start_print = cur_index;
 				break;
 			}
 		}
 	}
 	_call_console_drivers(start_print, end, msg_level);
 }
 static void emit_log_char(char c)
 {
 	LOG_BUF(log_end) = c;
 	log_end++;
 	if (log_end - log_start > log_buf_len)
 		log_start = log_end - log_buf_len;
 	if (log_end - con_start > log_buf_len)
 		con_start = log_end - log_buf_len;
 	if (logged_chars < log_buf_len)
 		logged_chars++;
 }
 /*
  * Zap console related locks when oopsing. Only zap at most once
  * every 10 seconds, to leave time for slow consoles to print a
  * full oops.
  */
 static void zap_locks(void)
 {
 	static unsigned long oops_timestamp;
 	if (time_after_eq(jiffies, oops_timestamp) &&
 			!time_after(jiffies, oops_timestamp + 30 * HZ))
 		return;
 	oops_timestamp = jiffies;
 	/* If a crash is occurring, make sure we can't deadlock */
 	spin_lock_init(&logbuf_lock);
 	/* And make sure that we print immediately */
 	init_MUTEX(&console_sem);
 }
 #if defined(CONFIG_PRINTK_TIME)
 static int printk_time = 1;
 #else
 static int printk_time = 0;
 #endif
 module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
 /* Check if we have any console registered that can be called early in boot. */
 static int have_callable_console(void)
 {
 	struct console *con;
 	for (con = console_drivers; con; con = con->next)
 		if (con->flags & CON_ANYTIME)
 			return 1;
 	return 0;
 }
 /**
  * printk - print a kernel message
  * @fmt: format string
  *
  * This is printk().  It can be called from any context.  We want it to work.
  * Be aware of the fact that if oops_in_progress is not set, we might try to
  * wake klogd up which could deadlock on runqueue lock if printk() is called
  * from scheduler code.
  *
  * We try to grab the console_sem.  If we succeed, it's easy - we log the output and
  * call the console drivers.  If we fail to get the semaphore we place the output
  * into the log buffer and return.  The current holder of the console_sem will
  * notice the new output in release_console_sem() and will send it to the
  * consoles before releasing the semaphore.
  *
  * One effect of this deferred printing is that code which calls printk() and
  * then changes console_loglevel may break. This is because console_loglevel
  * is inspected when the actual printing occurs.
  *
  * See also:
  * printf(3)
  */
 asmlinkage int printk(const char *fmt, ...)
 {
 	va_list args;
 	int r;
 	va_start(args, fmt);
 	r = vprintk(fmt, args);
 	va_end(args);
 	return r;
 }
 /* cpu currently holding logbuf_lock */
 static volatile unsigned int printk_cpu = UINT_MAX;
 /*
  * Can we actually use the console at this time on this cpu?
  *
  * Console drivers may assume that per-cpu resources have
  * been allocated. So unless they're explicitly marked as
  * being able to cope (CON_ANYTIME) don't call them until
  * this CPU is officially up.
  */
 static inline int can_use_console(unsigned int cpu)
 {
 	return cpu_online(cpu) || have_callable_console();
 }
 /*
  * Try to get console ownership to actually show the kernel
  * messages from a 'printk'. Return true (and with the
  * console_semaphore held, and 'console_locked' set) if it
  * is successful, false otherwise.
  *
  * This gets called with the 'logbuf_lock' spinlock held and
  * interrupts disabled. It should return with 'lockbuf_lock'
  * released but interrupts still disabled.
  */
 static int acquire_console_semaphore_for_printk(unsigned int cpu)
 {
 	int retval = 0;
 	if (!try_acquire_console_sem()) {
 		retval = 1;
 		/*
 		 * If we can't use the console, we need to release
 		 * the console semaphore by hand to avoid flushing
 		 * the buffer. We need to hold the console semaphore
 		 * in order to do this test safely.
 		 */
 		if (!can_use_console(cpu)) {
 			console_locked = 0;
 			up(&console_sem);
 			retval = 0;
 		}
 	}
 	printk_cpu = UINT_MAX;
 	spin_unlock(&logbuf_lock);
 	return retval;
 }
 static const char recursion_bug_msg [] =
 		KERN_CRIT "BUG: recent printk recursion!\n";
 static int recursion_bug;
 	static int new_text_line = 1;
 static char printk_buf[1024];
 asmlinkage int vprintk(const char *fmt, va_list args)
 {
 	int printed_len = 0;
 	int current_log_level = default_message_loglevel;
 	unsigned long flags;
 	int this_cpu;
 	char *p;
 	boot_delay_msec();
 	preempt_disable();
 	/* This stops the holder of console_sem just where we want him */
 	raw_local_irq_save(flags);
 	this_cpu = smp_processor_id();
 	/*
 	 * Ouch, printk recursed into itself!
 	 */
 	if (unlikely(printk_cpu == this_cpu)) {
 		/*
 		 * If a crash is occurring during printk() on this CPU,
 		 * then try to get the crash message out but make sure
 		 * we can't deadlock. Otherwise just return to avoid the
 		 * recursion and return - but flag the recursion so that
 		 * it can be printed at the next appropriate moment:
 		 */
 		if (!oops_in_progress) {
 			recursion_bug = 1;
 			goto out_restore_irqs;
 		}
 		zap_locks();
 	}
 	lockdep_off();
 	spin_lock(&logbuf_lock);
 	printk_cpu = this_cpu;
 	if (recursion_bug) {
 		recursion_bug = 0;
 		strcpy(printk_buf, recursion_bug_msg);
 		printed_len = sizeof(recursion_bug_msg);
 	}
 	/* Emit the output into the temporary buffer */
 	printed_len += vscnprintf(printk_buf + printed_len,
 				  sizeof(printk_buf) - printed_len, fmt, args);
 	/*
 	 * Copy the output into log_buf.  If the caller didn't provide
 	 * appropriate log level tags, we insert them here
 	 */
 	for (p = printk_buf; *p; p++) {
 		if (new_text_line) {
 			/* If a token, set current_log_level and skip over */
 			if (p[0] == '<' && p[1] >= '0' && p[1] <= '7' &&
 			    p[2] == '>') {
 				current_log_level = p[1] - '0';
 				p += 3;
 				printed_len -= 3;
 			}
 			/* Always output the token */
 			emit_log_char('<');
 			emit_log_char(current_log_level + '0');
 			emit_log_char('>');
 			printed_len += 3;
 			new_text_line = 0;
 			if (printk_time) {
 				/* Follow the token with the time */
 				char tbuf[50], *tp;
 				unsigned tlen;
 				unsigned long long t;
 				unsigned long nanosec_rem;
 				t = cpu_clock(printk_cpu);
 				nanosec_rem = do_div(t, 1000000000);
 				tlen = sprintf(tbuf, "[%5lu.%06lu] ",
 						(unsigned long) t,
 						nanosec_rem / 1000);
 				for (tp = tbuf; tp < tbuf + tlen; tp++)
 					emit_log_char(*tp);
 				printed_len += tlen;
 			}
 			if (!*p)
 				break;
 		}
 		emit_log_char(*p);
 		if (*p == '\n')
 			new_text_line = 1;
 	}
 	/*
 	 * Try to acquire and then immediately release the
 	 * console semaphore. The release will do all the
 	 * actual magic (print out buffers, wake up klogd,
 	 * etc).
 	 *
 	 * The acquire_console_semaphore_for_printk() function
 	 * will release 'logbuf_lock' regardless of whether it
 	 * actually gets the semaphore or not.
 	 */
 	if (acquire_console_semaphore_for_printk(this_cpu))
 		release_console_sem();
 	lockdep_on();
 out_restore_irqs:
 	raw_local_irq_restore(flags);
 	preempt_enable();
 	return printed_len;
 }
 EXPORT_SYMBOL(printk);
 EXPORT_SYMBOL(vprintk);
 #else
 asmlinkage long sys_syslog(int type, char __user *buf, int len)
 {
 	return -ENOSYS;
 }
 static void call_console_drivers(unsigned start, unsigned end)
 {
 }
 #endif
 static int __add_preferred_console(char *name, int idx, char *options,
 				   char *brl_options)
 {
 	struct console_cmdline *c;
 	int i;
 	/*
 	 *	See if this tty is not yet registered, and
 	 *	if we have a slot free.
 	 */
 	for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
 		if (strcmp(console_cmdline[i].name, name) == 0 &&
 			  console_cmdline[i].index == idx) {
 				if (!brl_options)
 					selected_console = i;
 				return 0;
 		}
 	if (i == MAX_CMDLINECONSOLES)
 		return -E2BIG;
 	if (!brl_options)
 		selected_console = i;
 	c = &console_cmdline[i];
 	strlcpy(c->name, name, sizeof(c->name));
 	c->options = options;
 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
 	c->brl_options = brl_options;
 #endif
 	c->index = idx;
 	return 0;
 }
 /*
  * Set up a list of consoles.  Called from init/main.c
  */
 static int __init console_setup(char *str)
 {
 	char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for index */
 	char *s, *options, *brl_options = NULL;
 	int idx;
 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
 	if (!memcmp(str, "brl,", 4)) {
 		brl_options = "";
 		str += 4;
 	} else if (!memcmp(str, "brl=", 4)) {
 		brl_options = str + 4;
 		str = strchr(brl_options, ',');
 		if (!str) {
 			printk(KERN_ERR "need port name after brl=\n");
 			return 1;
 		}
 		*(str++) = 0;
 	}
 #endif
 	/*
 	 * Decode str into name, index, options.
 	 */
 	if (str[0] >= '0' && str[0] <= '9') {
 		strcpy(buf, "ttyS");
 		strncpy(buf + 4, str, sizeof(buf) - 5);
 	} else {
 		strncpy(buf, str, sizeof(buf) - 1);
 	}
 	buf[sizeof(buf) - 1] = 0;
 	if ((options = strchr(str, ',')) != NULL)
 		*(options++) = 0;
 #ifdef __sparc__
 	if (!strcmp(str, "ttya"))
 		strcpy(buf, "ttyS0");
 	if (!strcmp(str, "ttyb"))
 		strcpy(buf, "ttyS1");
 #endif
 	for (s = buf; *s; s++)
 		if ((*s >= '0' && *s <= '9') || *s == ',')
 			break;
 	idx = simple_strtoul(s, NULL, 10);
 	*s = 0;
 	__add_preferred_console(buf, idx, options, brl_options);
 	console_set_on_cmdline = 1;
 	return 1;
 }
 __setup("console=", console_setup);
 /**
  * add_preferred_console - add a device to the list of preferred consoles.
  * @name: device name
  * @idx: device index
  * @options: options for this console
  *
  * The last preferred console added will be used for kernel messages
  * and stdin/out/err for init.  Normally this is used by console_setup
  * above to handle user-supplied console arguments; however it can also
  * be used by arch-specific code either to override the user or more
  * commonly to provide a default console (ie from PROM variables) when
  * the user has not supplied one.
  */
 int add_preferred_console(char *name, int idx, char *options)
 {
 	return __add_preferred_console(name, idx, options, NULL);
 }
 int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
 {
 	struct console_cmdline *c;
 	int i;
 	for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
 		if (strcmp(console_cmdline[i].name, name) == 0 &&
 			  console_cmdline[i].index == idx) {
 				c = &console_cmdline[i];
 				strlcpy(c->name, name_new, sizeof(c->name));
 				c->name[sizeof(c->name) - 1] = 0;
 				c->options = options;
 				c->index = idx_new;
 				return i;
 		}
 	/* not found */
 	return -1;
 }
 int console_suspend_enabled = 1;
 EXPORT_SYMBOL(console_suspend_enabled);
 static int __init console_suspend_disable(char *str)
 {
 	console_suspend_enabled = 0;
 	return 1;
 }
 __setup("no_console_suspend", console_suspend_disable);
 /**
  * suspend_console - suspend the console subsystem
  *
  * This disables printk() while we go into suspend states
  */
 void suspend_console(void)
 {
 	if (!console_suspend_enabled)
 		return;
 	printk("Suspending console(s) (use no_console_suspend to debug)\n");
 	acquire_console_sem();
 	console_suspended = 1;
 }
 void resume_console(void)
 {
 	if (!console_suspend_enabled)
 		return;
 	console_suspended = 0;
 	release_console_sem();
 }
 /**
  * acquire_console_sem - lock the console system for exclusive use.
  *
  * Acquires a semaphore which guarantees that the caller has
  * exclusive access to the console system and the console_drivers list.
  *
  * Can sleep, returns nothing.
  */
 void acquire_console_sem(void)
 {
 	BUG_ON(in_interrupt());
 	if (console_suspended) {
 		down(&secondary_console_sem);
 		return;
 	}
 	down(&console_sem);
 	console_locked = 1;
 	console_may_schedule = 1;
 }
 EXPORT_SYMBOL(acquire_console_sem);
 int try_acquire_console_sem(void)
 {
 	if (down_trylock(&console_sem))
 		return -1;
 	console_locked = 1;
 	console_may_schedule = 0;
 	return 0;
 }
 EXPORT_SYMBOL(try_acquire_console_sem);
 int is_console_locked(void)
 {
 	return console_locked;
 }
-void wake_up_klogd(void)
+static DEFINE_PER_CPU(int, printk_pending);
+void printk_tick(void)
 {
-	if (!oops_in_progress && waitqueue_active(&log_wait))
+	if (__get_cpu_var(printk_pending)) {
+		__get_cpu_var(printk_pending) = 0;
 		wake_up_interruptible(&log_wait);
+	}
+}
+int printk_needs_cpu(int cpu)
+{
+	return per_cpu(printk_pending, cpu);
+}
+void wake_up_klogd(void)
+{
+	if (waitqueue_active(&log_wait))
+		__get_cpu_var(printk_pending) = 1;
 }
 /**
  * release_console_sem - unlock the console system
  *
  * Releases the semaphore which the caller holds on the console system
  * and the console driver list.
  *
  * While the semaphore was held, console output may have been buffered
  * by printk().  If this is the case, release_console_sem() emits
  * the output prior to releasing the semaphore.
  *
  * If there is output waiting for klogd, we wake it up.
  *
  * release_console_sem() may be called from any context.
  */
 void release_console_sem(void)
 {
 	unsigned long flags;
 	unsigned _con_start, _log_end;
 	unsigned wake_klogd = 0;
 	if (console_suspended) {
 		up(&secondary_console_sem);
 		return;
 	}
 	console_may_schedule = 0;
 	for ( ; ; ) {
 		spin_lock_irqsave(&logbuf_lock, flags);
 		wake_klogd |= log_start - log_end;
 		if (con_start == log_end)
 			break;			/* Nothing to print */
 		_con_start = con_start;
 		_log_end = log_end;
 		con_start = log_end;		/* Flush */
 		spin_unlock(&logbuf_lock);
 		stop_critical_timings();	/* don't trace print latency */
 		call_console_drivers(_con_start, _log_end);
 		start_critical_timings();
 		local_irq_restore(flags);
 	}
 	console_locked = 0;
 	up(&console_sem);
 	spin_unlock_irqrestore(&logbuf_lock, flags);
 	if (wake_klogd)
 		wake_up_klogd();
 }
 EXPORT_SYMBOL(release_console_sem);
 /**
  * console_conditional_schedule - yield the CPU if required
  *
  * If the console code is currently allowed to sleep, and
  * if this CPU should yield the CPU to another task, do
  * so here.
  *
  * Must be called within acquire_console_sem().
  */
 void __sched console_conditional_schedule(void)
 {
 	if (console_may_schedule)
 		cond_resched();
 }
 EXPORT_SYMBOL(console_conditional_schedule);
 void console_print(const char *s)
 {
 	printk(KERN_EMERG "%s", s);
 }
 EXPORT_SYMBOL(console_print);
 void console_unblank(void)
 {
 	struct console *c;
 	/*
 	 * console_unblank can no longer be called in interrupt context unless
 	 * oops_in_progress is set to 1..
 	 */
 	if (oops_in_progress) {
 		if (down_trylock(&console_sem) != 0)
 			return;
 	} else
 		acquire_console_sem();
 	console_locked = 1;
 	console_may_schedule = 0;
 	for (c = console_drivers; c != NULL; c = c->next)
 		if ((c->flags & CON_ENABLED) && c->unblank)
 			c->unblank();
 	release_console_sem();
 }
 /*
  * Return the console tty driver structure and its associated index
  */
 struct tty_driver *console_device(int *index)
 {
 	struct console *c;
 	struct tty_driver *driver = NULL;
 	acquire_console_sem();
 	for (c = console_drivers; c != NULL; c = c->next) {
 		if (!c->device)
 			continue;
 		driver = c->device(c, index);
 		if (driver)
 			break;
 	}
 	release_console_sem();
 	return driver;
 }
 /*
  * Prevent further output on the passed console device so that (for example)
  * serial drivers can disable console output before suspending a port, and can
  * re-enable output afterwards.
  */
 void console_stop(struct console *console)
 {
 	acquire_console_sem();
 	console->flags &= ~CON_ENABLED;
 	release_console_sem();
 }
 EXPORT_SYMBOL(console_stop);
 void console_start(struct console *console)
 {
 	acquire_console_sem();
 	console->flags |= CON_ENABLED;
 	release_console_sem();
 }
 EXPORT_SYMBOL(console_start);
 /*
  * The console driver calls this routine during kernel initialization
  * to register the console printing procedure with printk() and to
  * print any messages that were printed by the kernel before the
  * console driver was initialized.
  */
 void register_console(struct console *console)
 {
 	int i;
 	unsigned long flags;
 	struct console *bootconsole = NULL;
 	if (console_drivers) {
 		if (console->flags & CON_BOOT)
 			return;
 		if (console_drivers->flags & CON_BOOT)
 			bootconsole = console_drivers;
 	}
 	if (preferred_console < 0 || bootconsole || !console_drivers)
 		preferred_console = selected_console;
 	if (console->early_setup)
 		console->early_setup();
 	/*
 	 *	See if we want to use this console driver. If we
 	 *	didn't select a console we take the first one
 	 *	that registers here.
 	 */
 	if (preferred_console < 0) {
 		if (console->index < 0)
 			console->index = 0;
 		if (console->setup == NULL ||
 		    console->setup(console, NULL) == 0) {
 			console->flags |= CON_ENABLED;
 			if (console->device) {
 				console->flags |= CON_CONSDEV;
 				preferred_console = 0;
 			}
 		}
 	}
 	/*
 	 *	See if this console matches one we selected on
 	 *	the command line.
 	 */
 	for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
 			i++) {
 		if (strcmp(console_cmdline[i].name, console->name) != 0)
 			continue;
 		if (console->index >= 0 &&
 		    console->index != console_cmdline[i].index)
 			continue;
 		if (console->index < 0)
 			console->index = console_cmdline[i].index;
 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
 		if (console_cmdline[i].brl_options) {
 			console->flags |= CON_BRL;
 			braille_register_console(console,
 					console_cmdline[i].index,
 					console_cmdline[i].options,
 					console_cmdline[i].brl_options);
 			return;
 		}
 #endif
 		if (console->setup &&
 		    console->setup(console, console_cmdline[i].options) != 0)
 			break;
 		console->flags |= CON_ENABLED;
 		console->index = console_cmdline[i].index;
 		if (i == selected_console) {
 			console->flags |= CON_CONSDEV;
 			preferred_console = selected_console;
 		}
 		break;
 	}
 	if (!(console->flags & CON_ENABLED))
 		return;
 	if (bootconsole && (console->flags & CON_CONSDEV)) {
 		printk(KERN_INFO "console handover: boot [%s%d] -> real [%s%d]\n",
 		       bootconsole->name, bootconsole->index,
 		       console->name, console->index);
 		unregister_console(bootconsole);
 		console->flags &= ~CON_PRINTBUFFER;
 	} else {
 		printk(KERN_INFO "console [%s%d] enabled\n",
 		       console->name, console->index);
 	}
 	/*
 	 *	Put this console in the list - keep the
 	 *	preferred driver at the head of the list.
 	 */
 	acquire_console_sem();
 	if ((console->flags & CON_CONSDEV) || console_drivers == NULL) {
 		console->next = console_drivers;
 		console_drivers = console;
 		if (console->next)
 			console->next->flags &= ~CON_CONSDEV;
 	} else {
 		console->next = console_drivers->next;
 		console_drivers->next = console;
 	}
 	if (console->flags & CON_PRINTBUFFER) {
 		/*
 		 * release_console_sem() will print out the buffered messages
 		 * for us.
 		 */
 		spin_lock_irqsave(&logbuf_lock, flags);
 		con_start = log_start;
 		spin_unlock_irqrestore(&logbuf_lock, flags);
 	}
 	release_console_sem();
 }
 EXPORT_SYMBOL(register_console);
 int unregister_console(struct console *console)
 {
         struct console *a, *b;
 	int res = 1;
 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
 	if (console->flags & CON_BRL)
 		return braille_unregister_console(console);
 #endif
 	acquire_console_sem();
 	if (console_drivers == console) {
 		console_drivers=console->next;
 		res = 0;
 	} else if (console_drivers) {
 		for (a=console_drivers->next, b=console_drivers ;
 		     a; b=a, a=b->next) {
 			if (a == console) {
 				b->next = a->next;
 				res = 0;
 				break;
 			}
 		}
 	}
 	/*
 	 * If this isn't the last console and it has CON_CONSDEV set, we
 	 * need to set it on the next preferred console.
 	 */
 	if (console_drivers != NULL && console->flags & CON_CONSDEV)
 		console_drivers->flags |= CON_CONSDEV;
 	release_console_sem();
 	return res;
 }
 EXPORT_SYMBOL(unregister_console);
 static int __init disable_boot_consoles(void)
 {
 	if (console_drivers != NULL) {
 		if (console_drivers->flags & CON_BOOT) {
 			printk(KERN_INFO "turn off boot console %s%d\n",
 				console_drivers->name, console_drivers->index);
 			return unregister_console(console_drivers);
 		}
 	}
 	return 0;
 }
 late_initcall(disable_boot_consoles);
 /**
  * tty_write_message - write a message to a certain tty, not just the console.
  * @tty: the destination tty_struct
  * @msg: the message to write
  *
  * This is used for messages that need to be redirected to a specific tty.
  * We don't put it into the syslog queue right now maybe in the future if
  * really needed.
  */
 void tty_write_message(struct tty_struct *tty, char *msg)
 {
 	if (tty && tty->ops->write)
 		tty->ops->write(tty, msg, strlen(msg));
 	return;
 }
 #if defined CONFIG_PRINTK
 /*
  * printk rate limiting, lifted from the networking subsystem.
  *
  * This enforces a rate limit: not more than 10 kernel messages
  * every 5s to make a denial-of-service attack impossible.
  */
 DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
 int printk_ratelimit(void)
 {
 	return __ratelimit(&printk_ratelimit_state);
 }
 EXPORT_SYMBOL(printk_ratelimit);
 /**
  * printk_timed_ratelimit - caller-controlled printk ratelimiting
  * @caller_jiffies: pointer to caller's state
  * @interval_msecs: minimum interval between prints
  *
  * printk_timed_ratelimit() returns true if more than @interval_msecs
  * milliseconds have elapsed since the last time printk_timed_ratelimit()
  * returned true.
  */
 bool printk_timed_ratelimit(unsigned long *caller_jiffies,
 			unsigned int interval_msecs)
 {
 	if (*caller_jiffies == 0 || time_after(jiffies, *caller_jiffies)) {
 		*caller_jiffies = jiffies + msecs_to_jiffies(interval_msecs);
 		return true;
 	}
 	return false;
 }
 EXPORT_SYMBOL(printk_timed_ratelimit);
 #endif

kernel/time/tick-sched.c

Diff comments View file @ b845b51

1	/*	1	/*
2	* linux/kernel/time/tick-sched.c	2	* linux/kernel/time/tick-sched.c
3	*	3	*
4	* Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>	4	* Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
5	* Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar	5	* Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
6	* Copyright(C) 2006-2007 Timesys Corp., Thomas Gleixner	6	* Copyright(C) 2006-2007 Timesys Corp., Thomas Gleixner
7	*	7	*
8	* No idle tick implementation for low and high resolution timers	8	* No idle tick implementation for low and high resolution timers
9	*	9	*
10	* Started by: Thomas Gleixner and Ingo Molnar	10	* Started by: Thomas Gleixner and Ingo Molnar
11	*	11	*
12	* Distribute under GPLv2.	12	* Distribute under GPLv2.
13	*/	13	*/
14	#include <linux/cpu.h>	14	#include <linux/cpu.h>
15	#include <linux/err.h>	15	#include <linux/err.h>
16	#include <linux/hrtimer.h>	16	#include <linux/hrtimer.h>
17	#include <linux/interrupt.h>	17	#include <linux/interrupt.h>
18	#include <linux/kernel_stat.h>	18	#include <linux/kernel_stat.h>
19	#include <linux/percpu.h>	19	#include <linux/percpu.h>
20	#include <linux/profile.h>	20	#include <linux/profile.h>
21	#include <linux/sched.h>	21	#include <linux/sched.h>
22	#include <linux/tick.h>	22	#include <linux/tick.h>
23		23
24	#include <asm/irq_regs.h>	24	#include <asm/irq_regs.h>
25		25
26	#include "tick-internal.h"	26	#include "tick-internal.h"
27		27
28	/*	28	/*
29	* Per cpu nohz control structure	29	* Per cpu nohz control structure
30	*/	30	*/
31	static DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);	31	static DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);
32		32
33	/*	33	/*
34	* The time, when the last jiffy update happened. Protected by xtime_lock.	34	* The time, when the last jiffy update happened. Protected by xtime_lock.
35	*/	35	*/
36	static ktime_t last_jiffies_update;	36	static ktime_t last_jiffies_update;
37		37
38	struct tick_sched *tick_get_tick_sched(int cpu)	38	struct tick_sched *tick_get_tick_sched(int cpu)
39	{	39	{
40	return &per_cpu(tick_cpu_sched, cpu);	40	return &per_cpu(tick_cpu_sched, cpu);
41	}	41	}
42		42
43	/*	43	/*
44	* Must be called with interrupts disabled !	44	* Must be called with interrupts disabled !
45	*/	45	*/
46	static void tick_do_update_jiffies64(ktime_t now)	46	static void tick_do_update_jiffies64(ktime_t now)
47	{	47	{
48	unsigned long ticks = 0;	48	unsigned long ticks = 0;
49	ktime_t delta;	49	ktime_t delta;
50		50
51	/*	51	/*
52	* Do a quick check without holding xtime_lock:	52	* Do a quick check without holding xtime_lock:
53	*/	53	*/
54	delta = ktime_sub(now, last_jiffies_update);	54	delta = ktime_sub(now, last_jiffies_update);
55	if (delta.tv64 < tick_period.tv64)	55	if (delta.tv64 < tick_period.tv64)
56	return;	56	return;
57		57
58	/* Reevalute with xtime_lock held */	58	/* Reevalute with xtime_lock held */
59	write_seqlock(&xtime_lock);	59	write_seqlock(&xtime_lock);
60		60
61	delta = ktime_sub(now, last_jiffies_update);	61	delta = ktime_sub(now, last_jiffies_update);
62	if (delta.tv64 >= tick_period.tv64) {	62	if (delta.tv64 >= tick_period.tv64) {
63		63
64	delta = ktime_sub(delta, tick_period);	64	delta = ktime_sub(delta, tick_period);
65	last_jiffies_update = ktime_add(last_jiffies_update,	65	last_jiffies_update = ktime_add(last_jiffies_update,
66	tick_period);	66	tick_period);
67		67
68	/* Slow path for long timeouts */	68	/* Slow path for long timeouts */
69	if (unlikely(delta.tv64 >= tick_period.tv64)) {	69	if (unlikely(delta.tv64 >= tick_period.tv64)) {
70	s64 incr = ktime_to_ns(tick_period);	70	s64 incr = ktime_to_ns(tick_period);
71		71
72	ticks = ktime_divns(delta, incr);	72	ticks = ktime_divns(delta, incr);
73		73
74	last_jiffies_update = ktime_add_ns(last_jiffies_update,	74	last_jiffies_update = ktime_add_ns(last_jiffies_update,
75	incr * ticks);	75	incr * ticks);
76	}	76	}
77	do_timer(++ticks);	77	do_timer(++ticks);
78	}	78	}
79	write_sequnlock(&xtime_lock);	79	write_sequnlock(&xtime_lock);
80	}	80	}
81		81
82	/*	82	/*
83	* Initialize and return retrieve the jiffies update.	83	* Initialize and return retrieve the jiffies update.
84	*/	84	*/
85	static ktime_t tick_init_jiffy_update(void)	85	static ktime_t tick_init_jiffy_update(void)
86	{	86	{
87	ktime_t period;	87	ktime_t period;
88		88
89	write_seqlock(&xtime_lock);	89	write_seqlock(&xtime_lock);
90	/* Did we start the jiffies update yet ? */	90	/* Did we start the jiffies update yet ? */
91	if (last_jiffies_update.tv64 == 0)	91	if (last_jiffies_update.tv64 == 0)
92	last_jiffies_update = tick_next_period;	92	last_jiffies_update = tick_next_period;
93	period = last_jiffies_update;	93	period = last_jiffies_update;
94	write_sequnlock(&xtime_lock);	94	write_sequnlock(&xtime_lock);
95	return period;	95	return period;
96	}	96	}
97		97
98	/*	98	/*
99	* NOHZ - aka dynamic tick functionality	99	* NOHZ - aka dynamic tick functionality
100	*/	100	*/
101	#ifdef CONFIG_NO_HZ	101	#ifdef CONFIG_NO_HZ
102	/*	102	/*
103	* NO HZ enabled ?	103	* NO HZ enabled ?
104	*/	104	*/
105	static int tick_nohz_enabled __read_mostly = 1;	105	static int tick_nohz_enabled __read_mostly = 1;
106		106
107	/*	107	/*
108	* Enable / Disable tickless mode	108	* Enable / Disable tickless mode
109	*/	109	*/
110	static int __init setup_tick_nohz(char *str)	110	static int __init setup_tick_nohz(char *str)
111	{	111	{
112	if (!strcmp(str, "off"))	112	if (!strcmp(str, "off"))
113	tick_nohz_enabled = 0;	113	tick_nohz_enabled = 0;
114	else if (!strcmp(str, "on"))	114	else if (!strcmp(str, "on"))
115	tick_nohz_enabled = 1;	115	tick_nohz_enabled = 1;
116	else	116	else
117	return 0;	117	return 0;
118	return 1;	118	return 1;
119	}	119	}
120		120
121	__setup("nohz=", setup_tick_nohz);	121	__setup("nohz=", setup_tick_nohz);
122		122
123	/**	123	/**
124	* tick_nohz_update_jiffies - update jiffies when idle was interrupted	124	* tick_nohz_update_jiffies - update jiffies when idle was interrupted
125	*	125	*
126	* Called from interrupt entry when the CPU was idle	126	* Called from interrupt entry when the CPU was idle
127	*	127	*
128	* In case the sched_tick was stopped on this CPU, we have to check if jiffies	128	* In case the sched_tick was stopped on this CPU, we have to check if jiffies
129	* must be updated. Otherwise an interrupt handler could use a stale jiffy	129	* must be updated. Otherwise an interrupt handler could use a stale jiffy
130	* value. We do this unconditionally on any cpu, as we don't know whether the	130	* value. We do this unconditionally on any cpu, as we don't know whether the
131	* cpu, which has the update task assigned is in a long sleep.	131	* cpu, which has the update task assigned is in a long sleep.
132	*/	132	*/
133	void tick_nohz_update_jiffies(void)	133	void tick_nohz_update_jiffies(void)
134	{	134	{
135	int cpu = smp_processor_id();	135	int cpu = smp_processor_id();
136	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);	136	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
137	unsigned long flags;	137	unsigned long flags;
138	ktime_t now;	138	ktime_t now;
139		139
140	if (!ts->tick_stopped)	140	if (!ts->tick_stopped)
141	return;	141	return;
142		142
143	cpu_clear(cpu, nohz_cpu_mask);	143	cpu_clear(cpu, nohz_cpu_mask);
144	now = ktime_get();	144	now = ktime_get();
145	ts->idle_waketime = now;	145	ts->idle_waketime = now;
146		146
147	local_irq_save(flags);	147	local_irq_save(flags);
148	tick_do_update_jiffies64(now);	148	tick_do_update_jiffies64(now);
149	local_irq_restore(flags);	149	local_irq_restore(flags);
150		150
151	touch_softlockup_watchdog();	151	touch_softlockup_watchdog();
152	}	152	}
153		153
154	void tick_nohz_stop_idle(int cpu)	154	void tick_nohz_stop_idle(int cpu)
155	{	155	{
156	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);	156	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
157		157
158	if (ts->idle_active) {	158	if (ts->idle_active) {
159	ktime_t now, delta;	159	ktime_t now, delta;
160	now = ktime_get();	160	now = ktime_get();
161	delta = ktime_sub(now, ts->idle_entrytime);	161	delta = ktime_sub(now, ts->idle_entrytime);
162	ts->idle_lastupdate = now;	162	ts->idle_lastupdate = now;
163	ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);	163	ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
164	ts->idle_active = 0;	164	ts->idle_active = 0;
165	}	165	}
166	}	166	}
167		167
168	static ktime_t tick_nohz_start_idle(struct tick_sched *ts)	168	static ktime_t tick_nohz_start_idle(struct tick_sched *ts)
169	{	169	{
170	ktime_t now, delta;	170	ktime_t now, delta;
171		171
172	now = ktime_get();	172	now = ktime_get();
173	if (ts->idle_active) {	173	if (ts->idle_active) {
174	delta = ktime_sub(now, ts->idle_entrytime);	174	delta = ktime_sub(now, ts->idle_entrytime);
175	ts->idle_lastupdate = now;	175	ts->idle_lastupdate = now;
176	ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);	176	ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
177	}	177	}
178	ts->idle_entrytime = now;	178	ts->idle_entrytime = now;
179	ts->idle_active = 1;	179	ts->idle_active = 1;
180	return now;	180	return now;
181	}	181	}
182		182
183	u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)	183	u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
184	{	184	{
185	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);	185	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
186		186
187	*last_update_time = ktime_to_us(ts->idle_lastupdate);	187	*last_update_time = ktime_to_us(ts->idle_lastupdate);
188	return ktime_to_us(ts->idle_sleeptime);	188	return ktime_to_us(ts->idle_sleeptime);
189	}	189	}
190		190
191	/**	191	/**
192	* tick_nohz_stop_sched_tick - stop the idle tick from the idle task	192	* tick_nohz_stop_sched_tick - stop the idle tick from the idle task
193	*	193	*
194	* When the next event is more than a tick into the future, stop the idle tick	194	* When the next event is more than a tick into the future, stop the idle tick
195	* Called either from the idle loop or from irq_exit() when an idle period was	195	* Called either from the idle loop or from irq_exit() when an idle period was
196	* just interrupted by an interrupt which did not cause a reschedule.	196	* just interrupted by an interrupt which did not cause a reschedule.
197	*/	197	*/
198	void tick_nohz_stop_sched_tick(int inidle)	198	void tick_nohz_stop_sched_tick(int inidle)
199	{	199	{
200	unsigned long seq, last_jiffies, next_jiffies, delta_jiffies, flags;	200	unsigned long seq, last_jiffies, next_jiffies, delta_jiffies, flags;
201	struct tick_sched *ts;	201	struct tick_sched *ts;
202	ktime_t last_update, expires, now;	202	ktime_t last_update, expires, now;
203	struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;	203	struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;
204	int cpu;	204	int cpu;
205		205
206	local_irq_save(flags);	206	local_irq_save(flags);
207		207
208	cpu = smp_processor_id();	208	cpu = smp_processor_id();
209	ts = &per_cpu(tick_cpu_sched, cpu);	209	ts = &per_cpu(tick_cpu_sched, cpu);
210	now = tick_nohz_start_idle(ts);	210	now = tick_nohz_start_idle(ts);
211		211
212	/*	212	/*
213	* If this cpu is offline and it is the one which updates	213	* If this cpu is offline and it is the one which updates
214	* jiffies, then give up the assignment and let it be taken by	214	* jiffies, then give up the assignment and let it be taken by
215	* the cpu which runs the tick timer next. If we don't drop	215	* the cpu which runs the tick timer next. If we don't drop
216	* this here the jiffies might be stale and do_timer() never	216	* this here the jiffies might be stale and do_timer() never
217	* invoked.	217	* invoked.
218	*/	218	*/
219	if (unlikely(!cpu_online(cpu))) {	219	if (unlikely(!cpu_online(cpu))) {
220	if (cpu == tick_do_timer_cpu)	220	if (cpu == tick_do_timer_cpu)
221	tick_do_timer_cpu = -1;	221	tick_do_timer_cpu = -1;
222	}	222	}
223		223
224	if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))	224	if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))
225	goto end;	225	goto end;
226		226
227	if (!inidle && !ts->inidle)	227	if (!inidle && !ts->inidle)
228	goto end;	228	goto end;
229		229
230	ts->inidle = 1;	230	ts->inidle = 1;
231		231
232	if (need_resched())	232	if (need_resched())
233	goto end;	233	goto end;
234		234
235	if (unlikely(local_softirq_pending())) {	235	if (unlikely(local_softirq_pending())) {
236	static int ratelimit;	236	static int ratelimit;
237		237
238	if (ratelimit < 10) {	238	if (ratelimit < 10) {
239	printk(KERN_ERR "NOHZ: local_softirq_pending %02x\n",	239	printk(KERN_ERR "NOHZ: local_softirq_pending %02x\n",
240	local_softirq_pending());	240	local_softirq_pending());
241	ratelimit++;	241	ratelimit++;
242	}	242	}
243	goto end;	243	goto end;
244	}	244	}
245		245
246	ts->idle_calls++;	246	ts->idle_calls++;
247	/* Read jiffies and the time when jiffies were updated last */	247	/* Read jiffies and the time when jiffies were updated last */
248	do {	248	do {
249	seq = read_seqbegin(&xtime_lock);	249	seq = read_seqbegin(&xtime_lock);
250	last_update = last_jiffies_update;	250	last_update = last_jiffies_update;
251	last_jiffies = jiffies;	251	last_jiffies = jiffies;
252	} while (read_seqretry(&xtime_lock, seq));	252	} while (read_seqretry(&xtime_lock, seq));
253		253
254	/* Get the next timer wheel timer */	254	/* Get the next timer wheel timer */
255	next_jiffies = get_next_timer_interrupt(last_jiffies);	255	next_jiffies = get_next_timer_interrupt(last_jiffies);
256	delta_jiffies = next_jiffies - last_jiffies;	256	delta_jiffies = next_jiffies - last_jiffies;
257		257
258	if (rcu_needs_cpu(cpu))	258	if (rcu_needs_cpu(cpu) \|\| printk_needs_cpu(cpu))
259	delta_jiffies = 1;	259	delta_jiffies = 1;
260	/*	260	/*
261	* Do not stop the tick, if we are only one off	261	* Do not stop the tick, if we are only one off
262	* or if the cpu is required for rcu	262	* or if the cpu is required for rcu
263	*/	263	*/
264	if (!ts->tick_stopped && delta_jiffies == 1)	264	if (!ts->tick_stopped && delta_jiffies == 1)
265	goto out;	265	goto out;
266		266
267	/* Schedule the tick, if we are at least one jiffie off */	267	/* Schedule the tick, if we are at least one jiffie off */
268	if ((long)delta_jiffies >= 1) {	268	if ((long)delta_jiffies >= 1) {
269		269
270	if (delta_jiffies > 1)	270	if (delta_jiffies > 1)
271	cpu_set(cpu, nohz_cpu_mask);	271	cpu_set(cpu, nohz_cpu_mask);
272	/*	272	/*
273	* nohz_stop_sched_tick can be called several times before	273	* nohz_stop_sched_tick can be called several times before
274	* the nohz_restart_sched_tick is called. This happens when	274	* the nohz_restart_sched_tick is called. This happens when
275	* interrupts arrive which do not cause a reschedule. In the	275	* interrupts arrive which do not cause a reschedule. In the
276	* first call we save the current tick time, so we can restart	276	* first call we save the current tick time, so we can restart
277	* the scheduler tick in nohz_restart_sched_tick.	277	* the scheduler tick in nohz_restart_sched_tick.
278	*/	278	*/
279	if (!ts->tick_stopped) {	279	if (!ts->tick_stopped) {
280	if (select_nohz_load_balancer(1)) {	280	if (select_nohz_load_balancer(1)) {
281	/*	281	/*
282	* sched tick not stopped!	282	* sched tick not stopped!
283	*/	283	*/
284	cpu_clear(cpu, nohz_cpu_mask);	284	cpu_clear(cpu, nohz_cpu_mask);
285	goto out;	285	goto out;
286	}	286	}
287		287
288	ts->idle_tick = ts->sched_timer.expires;	288	ts->idle_tick = ts->sched_timer.expires;
289	ts->tick_stopped = 1;	289	ts->tick_stopped = 1;
290	ts->idle_jiffies = last_jiffies;	290	ts->idle_jiffies = last_jiffies;
291	rcu_enter_nohz();	291	rcu_enter_nohz();
292	sched_clock_tick_stop(cpu);	292	sched_clock_tick_stop(cpu);
293	}	293	}
294		294
295	/*	295	/*
296	* If this cpu is the one which updates jiffies, then	296	* If this cpu is the one which updates jiffies, then
297	* give up the assignment and let it be taken by the	297	* give up the assignment and let it be taken by the
298	* cpu which runs the tick timer next, which might be	298	* cpu which runs the tick timer next, which might be
299	* this cpu as well. If we don't drop this here the	299	* this cpu as well. If we don't drop this here the
300	* jiffies might be stale and do_timer() never	300	* jiffies might be stale and do_timer() never
301	* invoked.	301	* invoked.
302	*/	302	*/
303	if (cpu == tick_do_timer_cpu)	303	if (cpu == tick_do_timer_cpu)
304	tick_do_timer_cpu = -1;	304	tick_do_timer_cpu = -1;
305		305
306	ts->idle_sleeps++;	306	ts->idle_sleeps++;
307		307
308	/*	308	/*
309	* delta_jiffies >= NEXT_TIMER_MAX_DELTA signals that	309	* delta_jiffies >= NEXT_TIMER_MAX_DELTA signals that
310	* there is no timer pending or at least extremly far	310	* there is no timer pending or at least extremly far
311	* into the future (12 days for HZ=1000). In this case	311	* into the future (12 days for HZ=1000). In this case
312	* we simply stop the tick timer:	312	* we simply stop the tick timer:
313	*/	313	*/
314	if (unlikely(delta_jiffies >= NEXT_TIMER_MAX_DELTA)) {	314	if (unlikely(delta_jiffies >= NEXT_TIMER_MAX_DELTA)) {
315	ts->idle_expires.tv64 = KTIME_MAX;	315	ts->idle_expires.tv64 = KTIME_MAX;
316	if (ts->nohz_mode == NOHZ_MODE_HIGHRES)	316	if (ts->nohz_mode == NOHZ_MODE_HIGHRES)
317	hrtimer_cancel(&ts->sched_timer);	317	hrtimer_cancel(&ts->sched_timer);
318	goto out;	318	goto out;
319	}	319	}
320		320
321	/*	321	/*
322	* calculate the expiry time for the next timer wheel	322	* calculate the expiry time for the next timer wheel
323	* timer	323	* timer
324	*/	324	*/
325	expires = ktime_add_ns(last_update, tick_period.tv64 *	325	expires = ktime_add_ns(last_update, tick_period.tv64 *
326	delta_jiffies);	326	delta_jiffies);
327	ts->idle_expires = expires;	327	ts->idle_expires = expires;
328		328
329	if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {	329	if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
330	hrtimer_start(&ts->sched_timer, expires,	330	hrtimer_start(&ts->sched_timer, expires,
331	HRTIMER_MODE_ABS);	331	HRTIMER_MODE_ABS);
332	/* Check, if the timer was already in the past */	332	/* Check, if the timer was already in the past */
333	if (hrtimer_active(&ts->sched_timer))	333	if (hrtimer_active(&ts->sched_timer))
334	goto out;	334	goto out;
335	} else if (!tick_program_event(expires, 0))	335	} else if (!tick_program_event(expires, 0))
336	goto out;	336	goto out;
337	/*	337	/*
338	* We are past the event already. So we crossed a	338	* We are past the event already. So we crossed a
339	* jiffie boundary. Update jiffies and raise the	339	* jiffie boundary. Update jiffies and raise the
340	* softirq.	340	* softirq.
341	*/	341	*/
342	tick_do_update_jiffies64(ktime_get());	342	tick_do_update_jiffies64(ktime_get());
343	cpu_clear(cpu, nohz_cpu_mask);	343	cpu_clear(cpu, nohz_cpu_mask);
344	}	344	}
345	raise_softirq_irqoff(TIMER_SOFTIRQ);	345	raise_softirq_irqoff(TIMER_SOFTIRQ);
346	out:	346	out:
347	ts->next_jiffies = next_jiffies;	347	ts->next_jiffies = next_jiffies;
348	ts->last_jiffies = last_jiffies;	348	ts->last_jiffies = last_jiffies;
349	ts->sleep_length = ktime_sub(dev->next_event, now);	349	ts->sleep_length = ktime_sub(dev->next_event, now);
350	end:	350	end:
351	local_irq_restore(flags);	351	local_irq_restore(flags);
352	}	352	}
353		353
354	/**	354	/**
355	* tick_nohz_get_sleep_length - return the length of the current sleep	355	* tick_nohz_get_sleep_length - return the length of the current sleep
356	*	356	*
357	* Called from power state control code with interrupts disabled	357	* Called from power state control code with interrupts disabled
358	*/	358	*/
359	ktime_t tick_nohz_get_sleep_length(void)	359	ktime_t tick_nohz_get_sleep_length(void)
360	{	360	{
361	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);	361	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
362		362
363	return ts->sleep_length;	363	return ts->sleep_length;
364	}	364	}
365		365
366	/**	366	/**
367	* tick_nohz_restart_sched_tick - restart the idle tick from the idle task	367	* tick_nohz_restart_sched_tick - restart the idle tick from the idle task
368	*	368	*
369	* Restart the idle tick when the CPU is woken up from idle	369	* Restart the idle tick when the CPU is woken up from idle
370	*/	370	*/
371	void tick_nohz_restart_sched_tick(void)	371	void tick_nohz_restart_sched_tick(void)
372	{	372	{
373	int cpu = smp_processor_id();	373	int cpu = smp_processor_id();
374	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);	374	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
375	unsigned long ticks;	375	unsigned long ticks;
376	ktime_t now;	376	ktime_t now;
377		377
378	local_irq_disable();	378	local_irq_disable();
379	tick_nohz_stop_idle(cpu);	379	tick_nohz_stop_idle(cpu);
380		380
381	if (!ts->inidle \|\| !ts->tick_stopped) {	381	if (!ts->inidle \|\| !ts->tick_stopped) {
382	ts->inidle = 0;	382	ts->inidle = 0;
383	local_irq_enable();	383	local_irq_enable();
384	return;	384	return;
385	}	385	}
386		386
387	ts->inidle = 0;	387	ts->inidle = 0;
388		388
389	rcu_exit_nohz();	389	rcu_exit_nohz();
390		390
391	/* Update jiffies first */	391	/* Update jiffies first */
392	select_nohz_load_balancer(0);	392	select_nohz_load_balancer(0);
393	now = ktime_get();	393	now = ktime_get();
394	tick_do_update_jiffies64(now);	394	tick_do_update_jiffies64(now);
395	sched_clock_tick_start(cpu);	395	sched_clock_tick_start(cpu);
396	cpu_clear(cpu, nohz_cpu_mask);	396	cpu_clear(cpu, nohz_cpu_mask);
397		397
398	/*	398	/*
399	* We stopped the tick in idle. Update process times would miss the	399	* We stopped the tick in idle. Update process times would miss the
400	* time we slept as update_process_times does only a 1 tick	400	* time we slept as update_process_times does only a 1 tick
401	* accounting. Enforce that this is accounted to idle !	401	* accounting. Enforce that this is accounted to idle !
402	*/	402	*/
403	ticks = jiffies - ts->idle_jiffies;	403	ticks = jiffies - ts->idle_jiffies;
404	/*	404	/*
405	* We might be one off. Do not randomly account a huge number of ticks!	405	* We might be one off. Do not randomly account a huge number of ticks!
406	*/	406	*/
407	if (ticks && ticks < LONG_MAX) {	407	if (ticks && ticks < LONG_MAX) {
408	add_preempt_count(HARDIRQ_OFFSET);	408	add_preempt_count(HARDIRQ_OFFSET);
409	account_system_time(current, HARDIRQ_OFFSET,	409	account_system_time(current, HARDIRQ_OFFSET,
410	jiffies_to_cputime(ticks));	410	jiffies_to_cputime(ticks));
411	sub_preempt_count(HARDIRQ_OFFSET);	411	sub_preempt_count(HARDIRQ_OFFSET);
412	}	412	}
413		413
414	touch_softlockup_watchdog();	414	touch_softlockup_watchdog();
415	/*	415	/*
416	* Cancel the scheduled timer and restore the tick	416	* Cancel the scheduled timer and restore the tick
417	*/	417	*/
418	ts->tick_stopped = 0;	418	ts->tick_stopped = 0;
419	ts->idle_exittime = now;	419	ts->idle_exittime = now;
420	hrtimer_cancel(&ts->sched_timer);	420	hrtimer_cancel(&ts->sched_timer);
421	ts->sched_timer.expires = ts->idle_tick;	421	ts->sched_timer.expires = ts->idle_tick;
422		422
423	while (1) {	423	while (1) {
424	/* Forward the time to expire in the future */	424	/* Forward the time to expire in the future */
425	hrtimer_forward(&ts->sched_timer, now, tick_period);	425	hrtimer_forward(&ts->sched_timer, now, tick_period);
426		426
427	if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {	427	if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
428	hrtimer_start(&ts->sched_timer,	428	hrtimer_start(&ts->sched_timer,
429	ts->sched_timer.expires,	429	ts->sched_timer.expires,
430	HRTIMER_MODE_ABS);	430	HRTIMER_MODE_ABS);
431	/* Check, if the timer was already in the past */	431	/* Check, if the timer was already in the past */
432	if (hrtimer_active(&ts->sched_timer))	432	if (hrtimer_active(&ts->sched_timer))
433	break;	433	break;
434	} else {	434	} else {
435	if (!tick_program_event(ts->sched_timer.expires, 0))	435	if (!tick_program_event(ts->sched_timer.expires, 0))
436	break;	436	break;
437	}	437	}
438	/* Update jiffies and reread time */	438	/* Update jiffies and reread time */
439	tick_do_update_jiffies64(now);	439	tick_do_update_jiffies64(now);
440	now = ktime_get();	440	now = ktime_get();
441	}	441	}
442	local_irq_enable();	442	local_irq_enable();
443	}	443	}
444		444
445	static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)	445	static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)
446	{	446	{
447	hrtimer_forward(&ts->sched_timer, now, tick_period);	447	hrtimer_forward(&ts->sched_timer, now, tick_period);
448	return tick_program_event(ts->sched_timer.expires, 0);	448	return tick_program_event(ts->sched_timer.expires, 0);
449	}	449	}
450		450
451	/*	451	/*
452	* The nohz low res interrupt handler	452	* The nohz low res interrupt handler
453	*/	453	*/
454	static void tick_nohz_handler(struct clock_event_device *dev)	454	static void tick_nohz_handler(struct clock_event_device *dev)
455	{	455	{
456	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);	456	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
457	struct pt_regs *regs = get_irq_regs();	457	struct pt_regs *regs = get_irq_regs();
458	int cpu = smp_processor_id();	458	int cpu = smp_processor_id();
459	ktime_t now = ktime_get();	459	ktime_t now = ktime_get();
460		460
461	dev->next_event.tv64 = KTIME_MAX;	461	dev->next_event.tv64 = KTIME_MAX;
462		462
463	/*	463	/*
464	* Check if the do_timer duty was dropped. We don't care about	464	* Check if the do_timer duty was dropped. We don't care about
465	* concurrency: This happens only when the cpu in charge went	465	* concurrency: This happens only when the cpu in charge went
466	* into a long sleep. If two cpus happen to assign themself to	466	* into a long sleep. If two cpus happen to assign themself to
467	* this duty, then the jiffies update is still serialized by	467	* this duty, then the jiffies update is still serialized by
468	* xtime_lock.	468	* xtime_lock.
469	*/	469	*/
470	if (unlikely(tick_do_timer_cpu == -1))	470	if (unlikely(tick_do_timer_cpu == -1))
471	tick_do_timer_cpu = cpu;	471	tick_do_timer_cpu = cpu;
472		472
473	/* Check, if the jiffies need an update */	473	/* Check, if the jiffies need an update */
474	if (tick_do_timer_cpu == cpu)	474	if (tick_do_timer_cpu == cpu)
475	tick_do_update_jiffies64(now);	475	tick_do_update_jiffies64(now);
476		476
477	/*	477	/*
478	* When we are idle and the tick is stopped, we have to touch	478	* When we are idle and the tick is stopped, we have to touch
479	* the watchdog as we might not schedule for a really long	479	* the watchdog as we might not schedule for a really long
480	* time. This happens on complete idle SMP systems while	480	* time. This happens on complete idle SMP systems while
481	* waiting on the login prompt. We also increment the "start	481	* waiting on the login prompt. We also increment the "start
482	* of idle" jiffy stamp so the idle accounting adjustment we	482	* of idle" jiffy stamp so the idle accounting adjustment we
483	* do when we go busy again does not account too much ticks.	483	* do when we go busy again does not account too much ticks.
484	*/	484	*/
485	if (ts->tick_stopped) {	485	if (ts->tick_stopped) {
486	touch_softlockup_watchdog();	486	touch_softlockup_watchdog();
487	ts->idle_jiffies++;	487	ts->idle_jiffies++;
488	}	488	}
489		489
490	update_process_times(user_mode(regs));	490	update_process_times(user_mode(regs));
491	profile_tick(CPU_PROFILING);	491	profile_tick(CPU_PROFILING);
492		492
493	/* Do not restart, when we are in the idle loop */	493	/* Do not restart, when we are in the idle loop */
494	if (ts->tick_stopped)	494	if (ts->tick_stopped)
495	return;	495	return;
496		496
497	while (tick_nohz_reprogram(ts, now)) {	497	while (tick_nohz_reprogram(ts, now)) {
498	now = ktime_get();	498	now = ktime_get();
499	tick_do_update_jiffies64(now);	499	tick_do_update_jiffies64(now);
500	}	500	}
501	}	501	}
502		502
503	/**	503	/**
504	* tick_nohz_switch_to_nohz - switch to nohz mode	504	* tick_nohz_switch_to_nohz - switch to nohz mode
505	*/	505	*/
506	static void tick_nohz_switch_to_nohz(void)	506	static void tick_nohz_switch_to_nohz(void)
507	{	507	{
508	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);	508	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
509	ktime_t next;	509	ktime_t next;
510		510
511	if (!tick_nohz_enabled)	511	if (!tick_nohz_enabled)
512	return;	512	return;
513		513
514	local_irq_disable();	514	local_irq_disable();
515	if (tick_switch_to_oneshot(tick_nohz_handler)) {	515	if (tick_switch_to_oneshot(tick_nohz_handler)) {
516	local_irq_enable();	516	local_irq_enable();
517	return;	517	return;
518	}	518	}
519		519
520	ts->nohz_mode = NOHZ_MODE_LOWRES;	520	ts->nohz_mode = NOHZ_MODE_LOWRES;
521		521
522	/*	522	/*
523	* Recycle the hrtimer in ts, so we can share the	523	* Recycle the hrtimer in ts, so we can share the
524	* hrtimer_forward with the highres code.	524	* hrtimer_forward with the highres code.
525	*/	525	*/
526	hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);	526	hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
527	/* Get the next period */	527	/* Get the next period */
528	next = tick_init_jiffy_update();	528	next = tick_init_jiffy_update();
529		529
530	for (;;) {	530	for (;;) {
531	ts->sched_timer.expires = next;	531	ts->sched_timer.expires = next;
532	if (!tick_program_event(next, 0))	532	if (!tick_program_event(next, 0))
533	break;	533	break;
534	next = ktime_add(next, tick_period);	534	next = ktime_add(next, tick_period);
535	}	535	}
536	local_irq_enable();	536	local_irq_enable();
537		537
538	printk(KERN_INFO "Switched to NOHz mode on CPU #%d\n",	538	printk(KERN_INFO "Switched to NOHz mode on CPU #%d\n",
539	smp_processor_id());	539	smp_processor_id());
540	}	540	}
541		541
542	#else	542	#else
543		543
544	static inline void tick_nohz_switch_to_nohz(void) { }	544	static inline void tick_nohz_switch_to_nohz(void) { }
545		545
546	#endif /* NO_HZ */	546	#endif /* NO_HZ */
547		547
548	/*	548	/*
549	* High resolution timer specific code	549	* High resolution timer specific code
550	*/	550	*/
551	#ifdef CONFIG_HIGH_RES_TIMERS	551	#ifdef CONFIG_HIGH_RES_TIMERS
552	/*	552	/*
553	* We rearm the timer until we get disabled by the idle code.	553	* We rearm the timer until we get disabled by the idle code.
554	* Called with interrupts disabled and timer->base->cpu_base->lock held.	554	* Called with interrupts disabled and timer->base->cpu_base->lock held.
555	*/	555	*/
556	static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)	556	static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
557	{	557	{
558	struct tick_sched *ts =	558	struct tick_sched *ts =
559	container_of(timer, struct tick_sched, sched_timer);	559	container_of(timer, struct tick_sched, sched_timer);
560	struct pt_regs *regs = get_irq_regs();	560	struct pt_regs *regs = get_irq_regs();
561	ktime_t now = ktime_get();	561	ktime_t now = ktime_get();
562	int cpu = smp_processor_id();	562	int cpu = smp_processor_id();
563		563
564	#ifdef CONFIG_NO_HZ	564	#ifdef CONFIG_NO_HZ
565	/*	565	/*
566	* Check if the do_timer duty was dropped. We don't care about	566	* Check if the do_timer duty was dropped. We don't care about
567	* concurrency: This happens only when the cpu in charge went	567	* concurrency: This happens only when the cpu in charge went
568	* into a long sleep. If two cpus happen to assign themself to	568	* into a long sleep. If two cpus happen to assign themself to
569	* this duty, then the jiffies update is still serialized by	569	* this duty, then the jiffies update is still serialized by
570	* xtime_lock.	570	* xtime_lock.
571	*/	571	*/
572	if (unlikely(tick_do_timer_cpu == -1))	572	if (unlikely(tick_do_timer_cpu == -1))
573	tick_do_timer_cpu = cpu;	573	tick_do_timer_cpu = cpu;
574	#endif	574	#endif
575		575
576	/* Check, if the jiffies need an update */	576	/* Check, if the jiffies need an update */
577	if (tick_do_timer_cpu == cpu)	577	if (tick_do_timer_cpu == cpu)
578	tick_do_update_jiffies64(now);	578	tick_do_update_jiffies64(now);
579		579
580	/*	580	/*
581	* Do not call, when we are not in irq context and have	581	* Do not call, when we are not in irq context and have
582	* no valid regs pointer	582	* no valid regs pointer
583	*/	583	*/
584	if (regs) {	584	if (regs) {
585	/*	585	/*
586	* When we are idle and the tick is stopped, we have to touch	586	* When we are idle and the tick is stopped, we have to touch
587	* the watchdog as we might not schedule for a really long	587	* the watchdog as we might not schedule for a really long
588	* time. This happens on complete idle SMP systems while	588	* time. This happens on complete idle SMP systems while
589	* waiting on the login prompt. We also increment the "start of	589	* waiting on the login prompt. We also increment the "start of
590	* idle" jiffy stamp so the idle accounting adjustment we do	590	* idle" jiffy stamp so the idle accounting adjustment we do
591	* when we go busy again does not account too much ticks.	591	* when we go busy again does not account too much ticks.
592	*/	592	*/
593	if (ts->tick_stopped) {	593	if (ts->tick_stopped) {
594	touch_softlockup_watchdog();	594	touch_softlockup_watchdog();
595	ts->idle_jiffies++;	595	ts->idle_jiffies++;
596	}	596	}
597	update_process_times(user_mode(regs));	597	update_process_times(user_mode(regs));
598	profile_tick(CPU_PROFILING);	598	profile_tick(CPU_PROFILING);
599	}	599	}
600		600
601	/* Do not restart, when we are in the idle loop */	601	/* Do not restart, when we are in the idle loop */
602	if (ts->tick_stopped)	602	if (ts->tick_stopped)
603	return HRTIMER_NORESTART;	603	return HRTIMER_NORESTART;
604		604
605	hrtimer_forward(timer, now, tick_period);	605	hrtimer_forward(timer, now, tick_period);
606		606
607	return HRTIMER_RESTART;	607	return HRTIMER_RESTART;
608	}	608	}
609		609
610	/**	610	/**
611	* tick_setup_sched_timer - setup the tick emulation timer	611	* tick_setup_sched_timer - setup the tick emulation timer
612	*/	612	*/
613	void tick_setup_sched_timer(void)	613	void tick_setup_sched_timer(void)
614	{	614	{
615	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);	615	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
616	ktime_t now = ktime_get();	616	ktime_t now = ktime_get();
617	u64 offset;	617	u64 offset;
618		618
619	/*	619	/*
620	* Emulate tick processing via per-CPU hrtimers:	620	* Emulate tick processing via per-CPU hrtimers:
621	*/	621	*/
622	hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);	622	hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
623	ts->sched_timer.function = tick_sched_timer;	623	ts->sched_timer.function = tick_sched_timer;
624	ts->sched_timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;	624	ts->sched_timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;
625		625
626	/* Get the next period (per cpu) */	626	/* Get the next period (per cpu) */
627	ts->sched_timer.expires = tick_init_jiffy_update();	627	ts->sched_timer.expires = tick_init_jiffy_update();
628	offset = ktime_to_ns(tick_period) >> 1;	628	offset = ktime_to_ns(tick_period) >> 1;
629	do_div(offset, num_possible_cpus());	629	do_div(offset, num_possible_cpus());
630	offset *= smp_processor_id();	630	offset *= smp_processor_id();
631	ts->sched_timer.expires = ktime_add_ns(ts->sched_timer.expires, offset);	631	ts->sched_timer.expires = ktime_add_ns(ts->sched_timer.expires, offset);
632		632
633	for (;;) {	633	for (;;) {
634	hrtimer_forward(&ts->sched_timer, now, tick_period);	634	hrtimer_forward(&ts->sched_timer, now, tick_period);
635	hrtimer_start(&ts->sched_timer, ts->sched_timer.expires,	635	hrtimer_start(&ts->sched_timer, ts->sched_timer.expires,
636	HRTIMER_MODE_ABS);	636	HRTIMER_MODE_ABS);
637	/* Check, if the timer was already in the past */	637	/* Check, if the timer was already in the past */
638	if (hrtimer_active(&ts->sched_timer))	638	if (hrtimer_active(&ts->sched_timer))
639	break;	639	break;
640	now = ktime_get();	640	now = ktime_get();
641	}	641	}
642		642
643	#ifdef CONFIG_NO_HZ	643	#ifdef CONFIG_NO_HZ
644	if (tick_nohz_enabled)	644	if (tick_nohz_enabled)
645	ts->nohz_mode = NOHZ_MODE_HIGHRES;	645	ts->nohz_mode = NOHZ_MODE_HIGHRES;
646	#endif	646	#endif
647	}	647	}
648		648
649	void tick_cancel_sched_timer(int cpu)	649	void tick_cancel_sched_timer(int cpu)
650	{	650	{
651	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);	651	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
652		652
653	if (ts->sched_timer.base)	653	if (ts->sched_timer.base)
654	hrtimer_cancel(&ts->sched_timer);	654	hrtimer_cancel(&ts->sched_timer);
655		655
656	ts->nohz_mode = NOHZ_MODE_INACTIVE;	656	ts->nohz_mode = NOHZ_MODE_INACTIVE;
657	}	657	}
658	#endif /* HIGH_RES_TIMERS */	658	#endif /* HIGH_RES_TIMERS */
659		659
660	/**	660	/**
661	* Async notification about clocksource changes	661	* Async notification about clocksource changes
662	*/	662	*/
663	void tick_clock_notify(void)	663	void tick_clock_notify(void)
664	{	664	{
665	int cpu;	665	int cpu;
666		666
667	for_each_possible_cpu(cpu)	667	for_each_possible_cpu(cpu)
668	set_bit(0, &per_cpu(tick_cpu_sched, cpu).check_clocks);	668	set_bit(0, &per_cpu(tick_cpu_sched, cpu).check_clocks);
669	}	669	}
670		670
671	/*	671	/*
672	* Async notification about clock event changes	672	* Async notification about clock event changes
673	*/	673	*/
674	void tick_oneshot_notify(void)	674	void tick_oneshot_notify(void)
675	{	675	{
676	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);	676	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
677		677
678	set_bit(0, &ts->check_clocks);	678	set_bit(0, &ts->check_clocks);
679	}	679	}
680		680
681	/**	681	/**
682	* Check, if a change happened, which makes oneshot possible.	682	* Check, if a change happened, which makes oneshot possible.
683	*	683	*
684	* Called cyclic from the hrtimer softirq (driven by the timer	684	* Called cyclic from the hrtimer softirq (driven by the timer
685	* softirq) allow_nohz signals, that we can switch into low-res nohz	685	* softirq) allow_nohz signals, that we can switch into low-res nohz
686	* mode, because high resolution timers are disabled (either compile	686	* mode, because high resolution timers are disabled (either compile
687	* or runtime).	687	* or runtime).
688	*/	688	*/
689	int tick_check_oneshot_change(int allow_nohz)	689	int tick_check_oneshot_change(int allow_nohz)
690	{	690	{
691	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);	691	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
692		692
693	if (!test_and_clear_bit(0, &ts->check_clocks))	693	if (!test_and_clear_bit(0, &ts->check_clocks))
694	return 0;	694	return 0;
695		695
696	if (ts->nohz_mode != NOHZ_MODE_INACTIVE)	696	if (ts->nohz_mode != NOHZ_MODE_INACTIVE)
697	return 0;	697	return 0;
698		698
699	if (!timekeeping_valid_for_hres() \|\| !tick_is_oneshot_available())	699	if (!timekeeping_valid_for_hres() \|\| !tick_is_oneshot_available())
700	return 0;	700	return 0;
701		701
702	if (!allow_nohz)	702	if (!allow_nohz)
703	return 1;	703	return 1;
704		704
705	tick_nohz_switch_to_nohz();	705	tick_nohz_switch_to_nohz();
706	return 0;	706	return 0;
707	}	707	}
708		708

kernel/timer.c

Diff comments View file @ b845b51

 /*
  *  linux/kernel/timer.c
  *
  *  Kernel internal timers, basic process system calls
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  *  1997-01-28  Modified by Finn Arne Gangstad to make timers scale better.
  *
  *  1997-09-10  Updated NTP code according to technical memorandum Jan '96
  *              "A Kernel Model for Precision Timekeeping" by Dave Mills
  *  1998-12-24  Fixed a xtime SMP race (we need the xtime_lock rw spinlock to
  *              serialize accesses to xtime/lost_ticks).
  *                              Copyright (C) 1998  Andrea Arcangeli
  *  1999-03-10  Improved NTP compatibility by Ulrich Windl
  *  2002-05-31	Move sys_sysinfo here and make its locking sane, Robert Love
  *  2000-10-05  Implemented scalable SMP per-CPU timer handling.
  *                              Copyright (C) 2000, 2001, 2002  Ingo Molnar
  *              Designed by David S. Miller, Alexey Kuznetsov and Ingo Molnar
  */
 #include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/percpu.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/pid_namespace.h>
 #include <linux/notifier.h>
 #include <linux/thread_info.h>
 #include <linux/time.h>
 #include <linux/jiffies.h>
 #include <linux/posix-timers.h>
 #include <linux/cpu.h>
 #include <linux/syscalls.h>
 #include <linux/delay.h>
 #include <linux/tick.h>
 #include <linux/kallsyms.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 #include <asm/div64.h>
 #include <asm/timex.h>
 #include <asm/io.h>
 u64 jiffies_64 __cacheline_aligned_in_smp = INITIAL_JIFFIES;
 EXPORT_SYMBOL(jiffies_64);
 /*
  * per-CPU timer vector definitions:
  */
 #define TVN_BITS (CONFIG_BASE_SMALL ? 4 : 6)
 #define TVR_BITS (CONFIG_BASE_SMALL ? 6 : 8)
 #define TVN_SIZE (1 << TVN_BITS)
 #define TVR_SIZE (1 << TVR_BITS)
 #define TVN_MASK (TVN_SIZE - 1)
 #define TVR_MASK (TVR_SIZE - 1)
 struct tvec {
 	struct list_head vec[TVN_SIZE];
 };
 struct tvec_root {
 	struct list_head vec[TVR_SIZE];
 };
 struct tvec_base {
 	spinlock_t lock;
 	struct timer_list *running_timer;
 	unsigned long timer_jiffies;
 	struct tvec_root tv1;
 	struct tvec tv2;
 	struct tvec tv3;
 	struct tvec tv4;
 	struct tvec tv5;
 } ____cacheline_aligned;
 struct tvec_base boot_tvec_bases;
 EXPORT_SYMBOL(boot_tvec_bases);
 static DEFINE_PER_CPU(struct tvec_base *, tvec_bases) = &boot_tvec_bases;
 /*
  * Note that all tvec_bases are 2 byte aligned and lower bit of
  * base in timer_list is guaranteed to be zero. Use the LSB for
  * the new flag to indicate whether the timer is deferrable
  */
 #define TBASE_DEFERRABLE_FLAG		(0x1)
 /* Functions below help us manage 'deferrable' flag */
 static inline unsigned int tbase_get_deferrable(struct tvec_base *base)
 {
 	return ((unsigned int)(unsigned long)base & TBASE_DEFERRABLE_FLAG);
 }
 static inline struct tvec_base *tbase_get_base(struct tvec_base *base)
 {
 	return ((struct tvec_base *)((unsigned long)base & ~TBASE_DEFERRABLE_FLAG));
 }
 static inline void timer_set_deferrable(struct timer_list *timer)
 {
 	timer->base = ((struct tvec_base *)((unsigned long)(timer->base) |
 				       TBASE_DEFERRABLE_FLAG));
 }
 static inline void
 timer_set_base(struct timer_list *timer, struct tvec_base *new_base)
 {
 	timer->base = (struct tvec_base *)((unsigned long)(new_base) |
 				      tbase_get_deferrable(timer->base));
 }
 /**
  * __round_jiffies - function to round jiffies to a full second
  * @j: the time in (absolute) jiffies that should be rounded
  * @cpu: the processor number on which the timeout will happen
  *
  * __round_jiffies() rounds an absolute time in the future (in jiffies)
  * up or down to (approximately) full seconds. This is useful for timers
  * for which the exact time they fire does not matter too much, as long as
  * they fire approximately every X seconds.
  *
  * By rounding these timers to whole seconds, all such timers will fire
  * at the same time, rather than at various times spread out. The goal
  * of this is to have the CPU wake up less, which saves power.
  *
  * The exact rounding is skewed for each processor to avoid all
  * processors firing at the exact same time, which could lead
  * to lock contention or spurious cache line bouncing.
  *
  * The return value is the rounded version of the @j parameter.
  */
 unsigned long __round_jiffies(unsigned long j, int cpu)
 {
 	int rem;
 	unsigned long original = j;
 	/*
 	 * We don't want all cpus firing their timers at once hitting the
 	 * same lock or cachelines, so we skew each extra cpu with an extra
 	 * 3 jiffies. This 3 jiffies came originally from the mm/ code which
 	 * already did this.
 	 * The skew is done by adding 3*cpunr, then round, then subtract this
 	 * extra offset again.
 	 */
 	j += cpu * 3;
 	rem = j % HZ;
 	/*
 	 * If the target jiffie is just after a whole second (which can happen
 	 * due to delays of the timer irq, long irq off times etc etc) then
 	 * we should round down to the whole second, not up. Use 1/4th second
 	 * as cutoff for this rounding as an extreme upper bound for this.
 	 */
 	if (rem < HZ/4) /* round down */
 		j = j - rem;
 	else /* round up */
 		j = j - rem + HZ;
 	/* now that we have rounded, subtract the extra skew again */
 	j -= cpu * 3;
 	if (j <= jiffies) /* rounding ate our timeout entirely; */
 		return original;
 	return j;
 }
 EXPORT_SYMBOL_GPL(__round_jiffies);
 /**
  * __round_jiffies_relative - function to round jiffies to a full second
  * @j: the time in (relative) jiffies that should be rounded
  * @cpu: the processor number on which the timeout will happen
  *
  * __round_jiffies_relative() rounds a time delta  in the future (in jiffies)
  * up or down to (approximately) full seconds. This is useful for timers
  * for which the exact time they fire does not matter too much, as long as
  * they fire approximately every X seconds.
  *
  * By rounding these timers to whole seconds, all such timers will fire
  * at the same time, rather than at various times spread out. The goal
  * of this is to have the CPU wake up less, which saves power.
  *
  * The exact rounding is skewed for each processor to avoid all
  * processors firing at the exact same time, which could lead
  * to lock contention or spurious cache line bouncing.
  *
  * The return value is the rounded version of the @j parameter.
  */
 unsigned long __round_jiffies_relative(unsigned long j, int cpu)
 {
 	/*
 	 * In theory the following code can skip a jiffy in case jiffies
 	 * increments right between the addition and the later subtraction.
 	 * However since the entire point of this function is to use approximate
 	 * timeouts, it's entirely ok to not handle that.
 	 */
 	return  __round_jiffies(j + jiffies, cpu) - jiffies;
 }
 EXPORT_SYMBOL_GPL(__round_jiffies_relative);
 /**
  * round_jiffies - function to round jiffies to a full second
  * @j: the time in (absolute) jiffies that should be rounded
  *
  * round_jiffies() rounds an absolute time in the future (in jiffies)
  * up or down to (approximately) full seconds. This is useful for timers
  * for which the exact time they fire does not matter too much, as long as
  * they fire approximately every X seconds.
  *
  * By rounding these timers to whole seconds, all such timers will fire
  * at the same time, rather than at various times spread out. The goal
  * of this is to have the CPU wake up less, which saves power.
  *
  * The return value is the rounded version of the @j parameter.
  */
 unsigned long round_jiffies(unsigned long j)
 {
 	return __round_jiffies(j, raw_smp_processor_id());
 }
 EXPORT_SYMBOL_GPL(round_jiffies);
 /**
  * round_jiffies_relative - function to round jiffies to a full second
  * @j: the time in (relative) jiffies that should be rounded
  *
  * round_jiffies_relative() rounds a time delta  in the future (in jiffies)
  * up or down to (approximately) full seconds. This is useful for timers
  * for which the exact time they fire does not matter too much, as long as
  * they fire approximately every X seconds.
  *
  * By rounding these timers to whole seconds, all such timers will fire
  * at the same time, rather than at various times spread out. The goal
  * of this is to have the CPU wake up less, which saves power.
  *
  * The return value is the rounded version of the @j parameter.
  */
 unsigned long round_jiffies_relative(unsigned long j)
 {
 	return __round_jiffies_relative(j, raw_smp_processor_id());
 }
 EXPORT_SYMBOL_GPL(round_jiffies_relative);
 static inline void set_running_timer(struct tvec_base *base,
 					struct timer_list *timer)
 {
 #ifdef CONFIG_SMP
 	base->running_timer = timer;
 #endif
 }
 static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)
 {
 	unsigned long expires = timer->expires;
 	unsigned long idx = expires - base->timer_jiffies;
 	struct list_head *vec;
 	if (idx < TVR_SIZE) {
 		int i = expires & TVR_MASK;
 		vec = base->tv1.vec + i;
 	} else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
 		int i = (expires >> TVR_BITS) & TVN_MASK;
 		vec = base->tv2.vec + i;
 	} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
 		int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
 		vec = base->tv3.vec + i;
 	} else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
 		int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
 		vec = base->tv4.vec + i;
 	} else if ((signed long) idx < 0) {
 		/*
 		 * Can happen if you add a timer with expires == jiffies,
 		 * or you set a timer to go off in the past
 		 */
 		vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK);
 	} else {
 		int i;
 		/* If the timeout is larger than 0xffffffff on 64-bit
 		 * architectures then we use the maximum timeout:
 		 */
 		if (idx > 0xffffffffUL) {
 			idx = 0xffffffffUL;
 			expires = idx + base->timer_jiffies;
 		}
 		i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
 		vec = base->tv5.vec + i;
 	}
 	/*
 	 * Timers are FIFO:
 	 */
 	list_add_tail(&timer->entry, vec);
 }
 #ifdef CONFIG_TIMER_STATS
 void __timer_stats_timer_set_start_info(struct timer_list *timer, void *addr)
 {
 	if (timer->start_site)
 		return;
 	timer->start_site = addr;
 	memcpy(timer->start_comm, current->comm, TASK_COMM_LEN);
 	timer->start_pid = current->pid;
 }
 static void timer_stats_account_timer(struct timer_list *timer)
 {
 	unsigned int flag = 0;
 	if (unlikely(tbase_get_deferrable(timer->base)))
 		flag |= TIMER_STATS_FLAG_DEFERRABLE;
 	timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
 				 timer->function, timer->start_comm, flag);
 }
 #else
 static void timer_stats_account_timer(struct timer_list *timer) {}
 #endif
 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS
 static struct debug_obj_descr timer_debug_descr;
 /*
  * fixup_init is called when:
  * - an active object is initialized
  */
 static int timer_fixup_init(void *addr, enum debug_obj_state state)
 {
 	struct timer_list *timer = addr;
 	switch (state) {
 	case ODEBUG_STATE_ACTIVE:
 		del_timer_sync(timer);
 		debug_object_init(timer, &timer_debug_descr);
 		return 1;
 	default:
 		return 0;
 	}
 }
 /*
  * fixup_activate is called when:
  * - an active object is activated
  * - an unknown object is activated (might be a statically initialized object)
  */
 static int timer_fixup_activate(void *addr, enum debug_obj_state state)
 {
 	struct timer_list *timer = addr;
 	switch (state) {
 	case ODEBUG_STATE_NOTAVAILABLE:
 		/*
 		 * This is not really a fixup. The timer was
 		 * statically initialized. We just make sure that it
 		 * is tracked in the object tracker.
 		 */
 		if (timer->entry.next == NULL &&
 		    timer->entry.prev == TIMER_ENTRY_STATIC) {
 			debug_object_init(timer, &timer_debug_descr);
 			debug_object_activate(timer, &timer_debug_descr);
 			return 0;
 		} else {
 			WARN_ON_ONCE(1);
 		}
 		return 0;
 	case ODEBUG_STATE_ACTIVE:
 		WARN_ON(1);
 	default:
 		return 0;
 	}
 }
 /*
  * fixup_free is called when:
  * - an active object is freed
  */
 static int timer_fixup_free(void *addr, enum debug_obj_state state)
 {
 	struct timer_list *timer = addr;
 	switch (state) {
 	case ODEBUG_STATE_ACTIVE:
 		del_timer_sync(timer);
 		debug_object_free(timer, &timer_debug_descr);
 		return 1;
 	default:
 		return 0;
 	}
 }
 static struct debug_obj_descr timer_debug_descr = {
 	.name		= "timer_list",
 	.fixup_init	= timer_fixup_init,
 	.fixup_activate	= timer_fixup_activate,
 	.fixup_free	= timer_fixup_free,
 };
 static inline void debug_timer_init(struct timer_list *timer)
 {
 	debug_object_init(timer, &timer_debug_descr);
 }
 static inline void debug_timer_activate(struct timer_list *timer)
 {
 	debug_object_activate(timer, &timer_debug_descr);
 }
 static inline void debug_timer_deactivate(struct timer_list *timer)
 {
 	debug_object_deactivate(timer, &timer_debug_descr);
 }
 static inline void debug_timer_free(struct timer_list *timer)
 {
 	debug_object_free(timer, &timer_debug_descr);
 }
 static void __init_timer(struct timer_list *timer);
 void init_timer_on_stack(struct timer_list *timer)
 {
 	debug_object_init_on_stack(timer, &timer_debug_descr);
 	__init_timer(timer);
 }
 EXPORT_SYMBOL_GPL(init_timer_on_stack);
 void destroy_timer_on_stack(struct timer_list *timer)
 {
 	debug_object_free(timer, &timer_debug_descr);
 }
 EXPORT_SYMBOL_GPL(destroy_timer_on_stack);
 #else
 static inline void debug_timer_init(struct timer_list *timer) { }
 static inline void debug_timer_activate(struct timer_list *timer) { }
 static inline void debug_timer_deactivate(struct timer_list *timer) { }
 #endif
 static void __init_timer(struct timer_list *timer)
 {
 	timer->entry.next = NULL;
 	timer->base = __raw_get_cpu_var(tvec_bases);
 #ifdef CONFIG_TIMER_STATS
 	timer->start_site = NULL;
 	timer->start_pid = -1;
 	memset(timer->start_comm, 0, TASK_COMM_LEN);
 #endif
 }
 /**
  * init_timer - initialize a timer.
  * @timer: the timer to be initialized
  *
  * init_timer() must be done to a timer prior calling *any* of the
  * other timer functions.
  */
 void init_timer(struct timer_list *timer)
 {
 	debug_timer_init(timer);
 	__init_timer(timer);
 }
 EXPORT_SYMBOL(init_timer);
 void init_timer_deferrable(struct timer_list *timer)
 {
 	init_timer(timer);
 	timer_set_deferrable(timer);
 }
 EXPORT_SYMBOL(init_timer_deferrable);
 static inline void detach_timer(struct timer_list *timer,
 				int clear_pending)
 {
 	struct list_head *entry = &timer->entry;
 	debug_timer_deactivate(timer);
 	__list_del(entry->prev, entry->next);
 	if (clear_pending)
 		entry->next = NULL;
 	entry->prev = LIST_POISON2;
 }
 /*
  * We are using hashed locking: holding per_cpu(tvec_bases).lock
  * means that all timers which are tied to this base via timer->base are
  * locked, and the base itself is locked too.
  *
  * So __run_timers/migrate_timers can safely modify all timers which could
  * be found on ->tvX lists.
  *
  * When the timer's base is locked, and the timer removed from list, it is
  * possible to set timer->base = NULL and drop the lock: the timer remains
  * locked.
  */
 static struct tvec_base *lock_timer_base(struct timer_list *timer,
 					unsigned long *flags)
 	__acquires(timer->base->lock)
 {
 	struct tvec_base *base;
 	for (;;) {
 		struct tvec_base *prelock_base = timer->base;
 		base = tbase_get_base(prelock_base);
 		if (likely(base != NULL)) {
 			spin_lock_irqsave(&base->lock, *flags);
 			if (likely(prelock_base == timer->base))
 				return base;
 			/* The timer has migrated to another CPU */
 			spin_unlock_irqrestore(&base->lock, *flags);
 		}
 		cpu_relax();
 	}
 }
 int __mod_timer(struct timer_list *timer, unsigned long expires)
 {
 	struct tvec_base *base, *new_base;
 	unsigned long flags;
 	int ret = 0;
 	timer_stats_timer_set_start_info(timer);
 	BUG_ON(!timer->function);
 	base = lock_timer_base(timer, &flags);
 	if (timer_pending(timer)) {
 		detach_timer(timer, 0);
 		ret = 1;
 	}
 	debug_timer_activate(timer);
 	new_base = __get_cpu_var(tvec_bases);
 	if (base != new_base) {
 		/*
 		 * We are trying to schedule the timer on the local CPU.
 		 * However we can't change timer's base while it is running,
 		 * otherwise del_timer_sync() can't detect that the timer's
 		 * handler yet has not finished. This also guarantees that
 		 * the timer is serialized wrt itself.
 		 */
 		if (likely(base->running_timer != timer)) {
 			/* See the comment in lock_timer_base() */
 			timer_set_base(timer, NULL);
 			spin_unlock(&base->lock);
 			base = new_base;
 			spin_lock(&base->lock);
 			timer_set_base(timer, base);
 		}
 	}
 	timer->expires = expires;
 	internal_add_timer(base, timer);
 	spin_unlock_irqrestore(&base->lock, flags);
 	return ret;
 }
 EXPORT_SYMBOL(__mod_timer);
 /**
  * add_timer_on - start a timer on a particular CPU
  * @timer: the timer to be added
  * @cpu: the CPU to start it on
  *
  * This is not very scalable on SMP. Double adds are not possible.
  */
 void add_timer_on(struct timer_list *timer, int cpu)
 {
 	struct tvec_base *base = per_cpu(tvec_bases, cpu);
 	unsigned long flags;
 	timer_stats_timer_set_start_info(timer);
 	BUG_ON(timer_pending(timer) || !timer->function);
 	spin_lock_irqsave(&base->lock, flags);
 	timer_set_base(timer, base);
 	debug_timer_activate(timer);
 	internal_add_timer(base, timer);
 	/*
 	 * Check whether the other CPU is idle and needs to be
 	 * triggered to reevaluate the timer wheel when nohz is
 	 * active. We are protected against the other CPU fiddling
 	 * with the timer by holding the timer base lock. This also
 	 * makes sure that a CPU on the way to idle can not evaluate
 	 * the timer wheel.
 	 */
 	wake_up_idle_cpu(cpu);
 	spin_unlock_irqrestore(&base->lock, flags);
 }
 /**
  * mod_timer - modify a timer's timeout
  * @timer: the timer to be modified
  * @expires: new timeout in jiffies
  *
  * mod_timer() is a more efficient way to update the expire field of an
  * active timer (if the timer is inactive it will be activated)
  *
  * mod_timer(timer, expires) is equivalent to:
  *
  *     del_timer(timer); timer->expires = expires; add_timer(timer);
  *
  * Note that if there are multiple unserialized concurrent users of the
  * same timer, then mod_timer() is the only safe way to modify the timeout,
  * since add_timer() cannot modify an already running timer.
  *
  * The function returns whether it has modified a pending timer or not.
  * (ie. mod_timer() of an inactive timer returns 0, mod_timer() of an
  * active timer returns 1.)
  */
 int mod_timer(struct timer_list *timer, unsigned long expires)
 {
 	BUG_ON(!timer->function);
 	timer_stats_timer_set_start_info(timer);
 	/*
 	 * This is a common optimization triggered by the
 	 * networking code - if the timer is re-modified
 	 * to be the same thing then just return:
 	 */
 	if (timer->expires == expires && timer_pending(timer))
 		return 1;
 	return __mod_timer(timer, expires);
 }
 EXPORT_SYMBOL(mod_timer);
 /**
  * del_timer - deactive a timer.
  * @timer: the timer to be deactivated
  *
  * del_timer() deactivates a timer - this works on both active and inactive
  * timers.
  *
  * The function returns whether it has deactivated a pending timer or not.
  * (ie. del_timer() of an inactive timer returns 0, del_timer() of an
  * active timer returns 1.)
  */
 int del_timer(struct timer_list *timer)
 {
 	struct tvec_base *base;
 	unsigned long flags;
 	int ret = 0;
 	timer_stats_timer_clear_start_info(timer);
 	if (timer_pending(timer)) {
 		base = lock_timer_base(timer, &flags);
 		if (timer_pending(timer)) {
 			detach_timer(timer, 1);
 			ret = 1;
 		}
 		spin_unlock_irqrestore(&base->lock, flags);
 	}
 	return ret;
 }
 EXPORT_SYMBOL(del_timer);
 #ifdef CONFIG_SMP
 /**
  * try_to_del_timer_sync - Try to deactivate a timer
  * @timer: timer do del
  *
  * This function tries to deactivate a timer. Upon successful (ret >= 0)
  * exit the timer is not queued and the handler is not running on any CPU.
  *
  * It must not be called from interrupt contexts.
  */
 int try_to_del_timer_sync(struct timer_list *timer)
 {
 	struct tvec_base *base;
 	unsigned long flags;
 	int ret = -1;
 	base = lock_timer_base(timer, &flags);
 	if (base->running_timer == timer)
 		goto out;
 	ret = 0;
 	if (timer_pending(timer)) {
 		detach_timer(timer, 1);
 		ret = 1;
 	}
 out:
 	spin_unlock_irqrestore(&base->lock, flags);
 	return ret;
 }
 EXPORT_SYMBOL(try_to_del_timer_sync);
 /**
  * del_timer_sync - deactivate a timer and wait for the handler to finish.
  * @timer: the timer to be deactivated
  *
  * This function only differs from del_timer() on SMP: besides deactivating
  * the timer it also makes sure the handler has finished executing on other
  * CPUs.
  *
  * Synchronization rules: Callers must prevent restarting of the timer,
  * otherwise this function is meaningless. It must not be called from
  * interrupt contexts. The caller must not hold locks which would prevent
  * completion of the timer's handler. The timer's handler must not call
  * add_timer_on(). Upon exit the timer is not queued and the handler is
  * not running on any CPU.
  *
  * The function returns whether it has deactivated a pending timer or not.
  */
 int del_timer_sync(struct timer_list *timer)
 {
 	for (;;) {
 		int ret = try_to_del_timer_sync(timer);
 		if (ret >= 0)
 			return ret;
 		cpu_relax();
 	}
 }
 EXPORT_SYMBOL(del_timer_sync);
 #endif
 static int cascade(struct tvec_base *base, struct tvec *tv, int index)
 {
 	/* cascade all the timers from tv up one level */
 	struct timer_list *timer, *tmp;
 	struct list_head tv_list;
 	list_replace_init(tv->vec + index, &tv_list);
 	/*
 	 * We are removing _all_ timers from the list, so we
 	 * don't have to detach them individually.
 	 */
 	list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
 		BUG_ON(tbase_get_base(timer->base) != base);
 		internal_add_timer(base, timer);
 	}
 	return index;
 }
 #define INDEX(N) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)
 /**
  * __run_timers - run all expired timers (if any) on this CPU.
  * @base: the timer vector to be processed.
  *
  * This function cascades all vectors and executes all expired timer
  * vectors.
  */
 static inline void __run_timers(struct tvec_base *base)
 {
 	struct timer_list *timer;
 	spin_lock_irq(&base->lock);
 	while (time_after_eq(jiffies, base->timer_jiffies)) {
 		struct list_head work_list;
 		struct list_head *head = &work_list;
 		int index = base->timer_jiffies & TVR_MASK;
 		/*
 		 * Cascade timers:
 		 */
 		if (!index &&
 			(!cascade(base, &base->tv2, INDEX(0))) &&
 				(!cascade(base, &base->tv3, INDEX(1))) &&
 					!cascade(base, &base->tv4, INDEX(2)))
 			cascade(base, &base->tv5, INDEX(3));
 		++base->timer_jiffies;
 		list_replace_init(base->tv1.vec + index, &work_list);
 		while (!list_empty(head)) {
 			void (*fn)(unsigned long);
 			unsigned long data;
 			timer = list_first_entry(head, struct timer_list,entry);
 			fn = timer->function;
 			data = timer->data;
 			timer_stats_account_timer(timer);
 			set_running_timer(base, timer);
 			detach_timer(timer, 1);
 			spin_unlock_irq(&base->lock);
 			{
 				int preempt_count = preempt_count();
 				fn(data);
 				if (preempt_count != preempt_count()) {
 					printk(KERN_ERR "huh, entered %p "
 					       "with preempt_count %08x, exited"
 					       " with %08x?\n",
 					       fn, preempt_count,
 					       preempt_count());
 					BUG();
 				}
 			}
 			spin_lock_irq(&base->lock);
 		}
 	}
 	set_running_timer(base, NULL);
 	spin_unlock_irq(&base->lock);
 }
 #ifdef CONFIG_NO_HZ
 /*
  * Find out when the next timer event is due to happen. This
  * is used on S/390 to stop all activity when a cpus is idle.
  * This functions needs to be called disabled.
  */
 static unsigned long __next_timer_interrupt(struct tvec_base *base)
 {
 	unsigned long timer_jiffies = base->timer_jiffies;
 	unsigned long expires = timer_jiffies + NEXT_TIMER_MAX_DELTA;
 	int index, slot, array, found = 0;
 	struct timer_list *nte;
 	struct tvec *varray[4];
 	/* Look for timer events in tv1. */
 	index = slot = timer_jiffies & TVR_MASK;
 	do {
 		list_for_each_entry(nte, base->tv1.vec + slot, entry) {
 			if (tbase_get_deferrable(nte->base))
 				continue;
 			found = 1;
 			expires = nte->expires;
 			/* Look at the cascade bucket(s)? */
 			if (!index || slot < index)
 				goto cascade;
 			return expires;
 		}
 		slot = (slot + 1) & TVR_MASK;
 	} while (slot != index);
 cascade:
 	/* Calculate the next cascade event */
 	if (index)
 		timer_jiffies += TVR_SIZE - index;
 	timer_jiffies >>= TVR_BITS;
 	/* Check tv2-tv5. */
 	varray[0] = &base->tv2;
 	varray[1] = &base->tv3;
 	varray[2] = &base->tv4;
 	varray[3] = &base->tv5;
 	for (array = 0; array < 4; array++) {
 		struct tvec *varp = varray[array];
 		index = slot = timer_jiffies & TVN_MASK;
 		do {
 			list_for_each_entry(nte, varp->vec + slot, entry) {
 				found = 1;
 				if (time_before(nte->expires, expires))
 					expires = nte->expires;
 			}
 			/*
 			 * Do we still search for the first timer or are
 			 * we looking up the cascade buckets ?
 			 */
 			if (found) {
 				/* Look at the cascade bucket(s)? */
 				if (!index || slot < index)
 					break;
 				return expires;
 			}
 			slot = (slot + 1) & TVN_MASK;
 		} while (slot != index);
 		if (index)
 			timer_jiffies += TVN_SIZE - index;
 		timer_jiffies >>= TVN_BITS;
 	}
 	return expires;
 }
 /*
  * Check, if the next hrtimer event is before the next timer wheel
  * event:
  */
 static unsigned long cmp_next_hrtimer_event(unsigned long now,
 					    unsigned long expires)
 {
 	ktime_t hr_delta = hrtimer_get_next_event();
 	struct timespec tsdelta;
 	unsigned long delta;
 	if (hr_delta.tv64 == KTIME_MAX)
 		return expires;
 	/*
 	 * Expired timer available, let it expire in the next tick
 	 */
 	if (hr_delta.tv64 <= 0)
 		return now + 1;
 	tsdelta = ktime_to_timespec(hr_delta);
 	delta = timespec_to_jiffies(&tsdelta);
 	/*
 	 * Limit the delta to the max value, which is checked in
 	 * tick_nohz_stop_sched_tick():
 	 */
 	if (delta > NEXT_TIMER_MAX_DELTA)
 		delta = NEXT_TIMER_MAX_DELTA;
 	/*
 	 * Take rounding errors in to account and make sure, that it
 	 * expires in the next tick. Otherwise we go into an endless
 	 * ping pong due to tick_nohz_stop_sched_tick() retriggering
 	 * the timer softirq
 	 */
 	if (delta < 1)
 		delta = 1;
 	now += delta;
 	if (time_before(now, expires))
 		return now;
 	return expires;
 }
 /**
  * get_next_timer_interrupt - return the jiffy of the next pending timer
  * @now: current time (in jiffies)
  */
 unsigned long get_next_timer_interrupt(unsigned long now)
 {
 	struct tvec_base *base = __get_cpu_var(tvec_bases);
 	unsigned long expires;
 	spin_lock(&base->lock);
 	expires = __next_timer_interrupt(base);
 	spin_unlock(&base->lock);
 	if (time_before_eq(expires, now))
 		return now;
 	return cmp_next_hrtimer_event(now, expires);
 }
 #endif
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
 void account_process_tick(struct task_struct *p, int user_tick)
 {
 	cputime_t one_jiffy = jiffies_to_cputime(1);
 	if (user_tick) {
 		account_user_time(p, one_jiffy);
 		account_user_time_scaled(p, cputime_to_scaled(one_jiffy));
 	} else {
 		account_system_time(p, HARDIRQ_OFFSET, one_jiffy);
 		account_system_time_scaled(p, cputime_to_scaled(one_jiffy));
 	}
 }
 #endif
 /*
  * Called from the timer interrupt handler to charge one tick to the current
  * process.  user_tick is 1 if the tick is user time, 0 for system.
  */
 void update_process_times(int user_tick)
 {
 	struct task_struct *p = current;
 	int cpu = smp_processor_id();
 	/* Note: this timer irq context must be accounted for as well. */
 	account_process_tick(p, user_tick);
 	run_local_timers();
 	if (rcu_pending(cpu))
 		rcu_check_callbacks(cpu, user_tick);
+	printk_tick();
 	scheduler_tick();
 	run_posix_cpu_timers(p);
 }
 /*
  * Nr of active tasks - counted in fixed-point numbers
  */
 static unsigned long count_active_tasks(void)
 {
 	return nr_active() * FIXED_1;
 }
 /*
  * Hmm.. Changed this, as the GNU make sources (load.c) seems to
  * imply that avenrun[] is the standard name for this kind of thing.
  * Nothing else seems to be standardized: the fractional size etc
  * all seem to differ on different machines.
  *
  * Requires xtime_lock to access.
  */
 unsigned long avenrun[3];
 EXPORT_SYMBOL(avenrun);
 /*
  * calc_load - given tick count, update the avenrun load estimates.
  * This is called while holding a write_lock on xtime_lock.
  */
 static inline void calc_load(unsigned long ticks)
 {
 	unsigned long active_tasks; /* fixed-point */
 	static int count = LOAD_FREQ;
 	count -= ticks;
 	if (unlikely(count < 0)) {
 		active_tasks = count_active_tasks();
 		do {
 			CALC_LOAD(avenrun[0], EXP_1, active_tasks);
 			CALC_LOAD(avenrun[1], EXP_5, active_tasks);
 			CALC_LOAD(avenrun[2], EXP_15, active_tasks);
 			count += LOAD_FREQ;
 		} while (count < 0);
 	}
 }
 /*
  * This function runs timers and the timer-tq in bottom half context.
  */
 static void run_timer_softirq(struct softirq_action *h)
 {
 	struct tvec_base *base = __get_cpu_var(tvec_bases);
 	hrtimer_run_pending();
 	if (time_after_eq(jiffies, base->timer_jiffies))
 		__run_timers(base);
 }
 /*
  * Called by the local, per-CPU timer interrupt on SMP.
  */
 void run_local_timers(void)
 {
 	hrtimer_run_queues();
 	raise_softirq(TIMER_SOFTIRQ);
 	softlockup_tick();
 }
 /*
  * Called by the timer interrupt. xtime_lock must already be taken
  * by the timer IRQ!
  */
 static inline void update_times(unsigned long ticks)
 {
 	update_wall_time();
 	calc_load(ticks);
 }
 /*
  * The 64-bit jiffies value is not atomic - you MUST NOT read it
  * without sampling the sequence number in xtime_lock.
  * jiffies is defined in the linker script...
  */
 void do_timer(unsigned long ticks)
 {
 	jiffies_64 += ticks;
 	update_times(ticks);
 }
 #ifdef __ARCH_WANT_SYS_ALARM
 /*
  * For backwards compatibility?  This can be done in libc so Alpha
  * and all newer ports shouldn't need it.
  */
 asmlinkage unsigned long sys_alarm(unsigned int seconds)
 {
 	return alarm_setitimer(seconds);
 }
 #endif
 #ifndef __alpha__
 /*
  * The Alpha uses getxpid, getxuid, and getxgid instead.  Maybe this
  * should be moved into arch/i386 instead?
  */
 /**
  * sys_getpid - return the thread group id of the current process
  *
  * Note, despite the name, this returns the tgid not the pid.  The tgid and
  * the pid are identical unless CLONE_THREAD was specified on clone() in
  * which case the tgid is the same in all threads of the same group.
  *
  * This is SMP safe as current->tgid does not change.
  */
 asmlinkage long sys_getpid(void)
 {
 	return task_tgid_vnr(current);
 }
 /*
  * Accessing ->real_parent is not SMP-safe, it could
  * change from under us. However, we can use a stale
  * value of ->real_parent under rcu_read_lock(), see
  * release_task()->call_rcu(delayed_put_task_struct).
  */
 asmlinkage long sys_getppid(void)
 {
 	int pid;
 	rcu_read_lock();
 	pid = task_tgid_vnr(current->real_parent);
 	rcu_read_unlock();
 	return pid;
 }
 asmlinkage long sys_getuid(void)
 {
 	/* Only we change this so SMP safe */
 	return current->uid;
 }
 asmlinkage long sys_geteuid(void)
 {
 	/* Only we change this so SMP safe */
 	return current->euid;
 }
 asmlinkage long sys_getgid(void)
 {
 	/* Only we change this so SMP safe */
 	return current->gid;
 }
 asmlinkage long sys_getegid(void)
 {
 	/* Only we change this so SMP safe */
 	return  current->egid;
 }
 #endif
 static void process_timeout(unsigned long __data)
 {
 	wake_up_process((struct task_struct *)__data);
 }
 /**
  * schedule_timeout - sleep until timeout
  * @timeout: timeout value in jiffies
  *
  * Make the current task sleep until @timeout jiffies have
  * elapsed. The routine will return immediately unless
  * the current task state has been set (see set_current_state()).
  *
  * You can set the task state as follows -
  *
  * %TASK_UNINTERRUPTIBLE - at least @timeout jiffies are guaranteed to
  * pass before the routine returns. The routine will return 0
  *
  * %TASK_INTERRUPTIBLE - the routine may return early if a signal is
  * delivered to the current task. In this case the remaining time
  * in jiffies will be returned, or 0 if the timer expired in time
  *
  * The current task state is guaranteed to be TASK_RUNNING when this
  * routine returns.
  *
  * Specifying a @timeout value of %MAX_SCHEDULE_TIMEOUT will schedule
  * the CPU away without a bound on the timeout. In this case the return
  * value will be %MAX_SCHEDULE_TIMEOUT.
  *
  * In all cases the return value is guaranteed to be non-negative.
  */
 signed long __sched schedule_timeout(signed long timeout)
 {
 	struct timer_list timer;
 	unsigned long expire;
 	switch (timeout)
 	{
 	case MAX_SCHEDULE_TIMEOUT:
 		/*
 		 * These two special cases are useful to be comfortable
 		 * in the caller. Nothing more. We could take
 		 * MAX_SCHEDULE_TIMEOUT from one of the negative value
 		 * but I' d like to return a valid offset (>=0) to allow
 		 * the caller to do everything it want with the retval.
 		 */
 		schedule();
 		goto out;
 	default:
 		/*
 		 * Another bit of PARANOID. Note that the retval will be
 		 * 0 since no piece of kernel is supposed to do a check
 		 * for a negative retval of schedule_timeout() (since it
 		 * should never happens anyway). You just have the printk()
 		 * that will tell you if something is gone wrong and where.
 		 */
 		if (timeout < 0) {
 			printk(KERN_ERR "schedule_timeout: wrong timeout "
 				"value %lx\n", timeout);
 			dump_stack();
 			current->state = TASK_RUNNING;
 			goto out;
 		}
 	}
 	expire = timeout + jiffies;
 	setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
 	__mod_timer(&timer, expire);
 	schedule();
 	del_singleshot_timer_sync(&timer);
 	/* Remove the timer from the object tracker */
 	destroy_timer_on_stack(&timer);
 	timeout = expire - jiffies;
  out:
 	return timeout < 0 ? 0 : timeout;
 }
 EXPORT_SYMBOL(schedule_timeout);
 /*
  * We can use __set_current_state() here because schedule_timeout() calls
  * schedule() unconditionally.
  */
 signed long __sched schedule_timeout_interruptible(signed long timeout)
 {
 	__set_current_state(TASK_INTERRUPTIBLE);
 	return schedule_timeout(timeout);
 }
 EXPORT_SYMBOL(schedule_timeout_interruptible);
 signed long __sched schedule_timeout_killable(signed long timeout)
 {
 	__set_current_state(TASK_KILLABLE);
 	return schedule_timeout(timeout);
 }
 EXPORT_SYMBOL(schedule_timeout_killable);
 signed long __sched schedule_timeout_uninterruptible(signed long timeout)
 {
 	__set_current_state(TASK_UNINTERRUPTIBLE);
 	return schedule_timeout(timeout);
 }
 EXPORT_SYMBOL(schedule_timeout_uninterruptible);
 /* Thread ID - the internal kernel "pid" */
 asmlinkage long sys_gettid(void)
 {
 	return task_pid_vnr(current);
 }
 /**
  * do_sysinfo - fill in sysinfo struct
  * @info: pointer to buffer to fill
  */
 int do_sysinfo(struct sysinfo *info)
 {
 	unsigned long mem_total, sav_total;
 	unsigned int mem_unit, bitcount;
 	unsigned long seq;
 	memset(info, 0, sizeof(struct sysinfo));
 	do {
 		struct timespec tp;
 		seq = read_seqbegin(&xtime_lock);
 		/*
 		 * This is annoying.  The below is the same thing
 		 * posix_get_clock_monotonic() does, but it wants to
 		 * take the lock which we want to cover the loads stuff
 		 * too.
 		 */
 		getnstimeofday(&tp);
 		tp.tv_sec += wall_to_monotonic.tv_sec;
 		tp.tv_nsec += wall_to_monotonic.tv_nsec;
 		monotonic_to_bootbased(&tp);
 		if (tp.tv_nsec - NSEC_PER_SEC >= 0) {
 			tp.tv_nsec = tp.tv_nsec - NSEC_PER_SEC;
 			tp.tv_sec++;
 		}
 		info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0);
 		info->loads[0] = avenrun[0] << (SI_LOAD_SHIFT - FSHIFT);
 		info->loads[1] = avenrun[1] << (SI_LOAD_SHIFT - FSHIFT);
 		info->loads[2] = avenrun[2] << (SI_LOAD_SHIFT - FSHIFT);
 		info->procs = nr_threads;
 	} while (read_seqretry(&xtime_lock, seq));
 	si_meminfo(info);
 	si_swapinfo(info);
 	/*
 	 * If the sum of all the available memory (i.e. ram + swap)
 	 * is less than can be stored in a 32 bit unsigned long then
 	 * we can be binary compatible with 2.2.x kernels.  If not,
 	 * well, in that case 2.2.x was broken anyways...
 	 *
 	 *  -Erik Andersen <andersee@debian.org>
 	 */
 	mem_total = info->totalram + info->totalswap;
 	if (mem_total < info->totalram || mem_total < info->totalswap)
 		goto out;
 	bitcount = 0;
 	mem_unit = info->mem_unit;
 	while (mem_unit > 1) {
 		bitcount++;
 		mem_unit >>= 1;
 		sav_total = mem_total;
 		mem_total <<= 1;
 		if (mem_total < sav_total)
 			goto out;
 	}
 	/*
 	 * If mem_total did not overflow, multiply all memory values by
 	 * info->mem_unit and set it to 1.  This leaves things compatible
 	 * with 2.2.x, and also retains compatibility with earlier 2.4.x
 	 * kernels...
 	 */
 	info->mem_unit = 1;
 	info->totalram <<= bitcount;
 	info->freeram <<= bitcount;
 	info->sharedram <<= bitcount;
 	info->bufferram <<= bitcount;
 	info->totalswap <<= bitcount;
 	info->freeswap <<= bitcount;
 	info->totalhigh <<= bitcount;
 	info->freehigh <<= bitcount;
 out:
 	return 0;
 }
 asmlinkage long sys_sysinfo(struct sysinfo __user *info)
 {
 	struct sysinfo val;
 	do_sysinfo(&val);
 	if (copy_to_user(info, &val, sizeof(struct sysinfo)))
 		return -EFAULT;
 	return 0;
 }
 static int __cpuinit init_timers_cpu(int cpu)
 {
 	int j;
 	struct tvec_base *base;
 	static char __cpuinitdata tvec_base_done[NR_CPUS];
 	if (!tvec_base_done[cpu]) {
 		static char boot_done;
 		if (boot_done) {
 			/*
 			 * The APs use this path later in boot
 			 */
 			base = kmalloc_node(sizeof(*base),
 						GFP_KERNEL | __GFP_ZERO,
 						cpu_to_node(cpu));
 			if (!base)
 				return -ENOMEM;
 			/* Make sure that tvec_base is 2 byte aligned */
 			if (tbase_get_deferrable(base)) {
 				WARN_ON(1);
 				kfree(base);
 				return -ENOMEM;
 			}
 			per_cpu(tvec_bases, cpu) = base;
 		} else {
 			/*
 			 * This is for the boot CPU - we use compile-time
 			 * static initialisation because per-cpu memory isn't
 			 * ready yet and because the memory allocators are not
 			 * initialised either.
 			 */
 			boot_done = 1;
 			base = &boot_tvec_bases;
 		}
 		tvec_base_done[cpu] = 1;
 	} else {
 		base = per_cpu(tvec_bases, cpu);
 	}
 	spin_lock_init(&base->lock);
 	for (j = 0; j < TVN_SIZE; j++) {
 		INIT_LIST_HEAD(base->tv5.vec + j);
 		INIT_LIST_HEAD(base->tv4.vec + j);
 		INIT_LIST_HEAD(base->tv3.vec + j);
 		INIT_LIST_HEAD(base->tv2.vec + j);
 	}
 	for (j = 0; j < TVR_SIZE; j++)
 		INIT_LIST_HEAD(base->tv1.vec + j);
 	base->timer_jiffies = jiffies;
 	return 0;
 }
 #ifdef CONFIG_HOTPLUG_CPU
 static void migrate_timer_list(struct tvec_base *new_base, struct list_head *head)
 {
 	struct timer_list *timer;
 	while (!list_empty(head)) {
 		timer = list_first_entry(head, struct timer_list, entry);
 		detach_timer(timer, 0);
 		timer_set_base(timer, new_base);
 		internal_add_timer(new_base, timer);
 	}
 }
 static void __cpuinit migrate_timers(int cpu)
 {
 	struct tvec_base *old_base;
 	struct tvec_base *new_base;
 	int i;
 	BUG_ON(cpu_online(cpu));
 	old_base = per_cpu(tvec_bases, cpu);
 	new_base = get_cpu_var(tvec_bases);
 	local_irq_disable();
 	spin_lock(&new_base->lock);
 	spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
 	BUG_ON(old_base->running_timer);
 	for (i = 0; i < TVR_SIZE; i++)
 		migrate_timer_list(new_base, old_base->tv1.vec + i);
 	for (i = 0; i < TVN_SIZE; i++) {
 		migrate_timer_list(new_base, old_base->tv2.vec + i);
 		migrate_timer_list(new_base, old_base->tv3.vec + i);
 		migrate_timer_list(new_base, old_base->tv4.vec + i);
 		migrate_timer_list(new_base, old_base->tv5.vec + i);
 	}
 	spin_unlock(&old_base->lock);
 	spin_unlock(&new_base->lock);
 	local_irq_enable();
 	put_cpu_var(tvec_bases);
 }
 #endif /* CONFIG_HOTPLUG_CPU */
 static int __cpuinit timer_cpu_notify(struct notifier_block *self,
 				unsigned long action, void *hcpu)
 {
 	long cpu = (long)hcpu;
 	switch(action) {
 	case CPU_UP_PREPARE:
 	case CPU_UP_PREPARE_FROZEN:
 		if (init_timers_cpu(cpu) < 0)
 			return NOTIFY_BAD;
 		break;
 #ifdef CONFIG_HOTPLUG_CPU
 	case CPU_DEAD:
 	case CPU_DEAD_FROZEN:
 		migrate_timers(cpu);
 		break;
 #endif
 	default:
 		break;
 	}
 	return NOTIFY_OK;
 }
 static struct notifier_block __cpuinitdata timers_nb = {
 	.notifier_call	= timer_cpu_notify,
 };
 void __init init_timers(void)
 {
 	int err = timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE,
 				(void *)(long)smp_processor_id());
 	init_timer_stats();
 	BUG_ON(err == NOTIFY_BAD);
 	register_cpu_notifier(&timers_nb);
 	open_softirq(TIMER_SOFTIRQ, run_timer_softirq);
 }
 /**
  * msleep - sleep safely even with waitqueue interruptions
  * @msecs: Time in milliseconds to sleep for
  */
 void msleep(unsigned int msecs)
 {
 	unsigned long timeout = msecs_to_jiffies(msecs) + 1;
 	while (timeout)
 		timeout = schedule_timeout_uninterruptible(timeout);
 }
 EXPORT_SYMBOL(msleep);
 /**
  * msleep_interruptible - sleep waiting for signals
  * @msecs: Time in milliseconds to sleep for
  */
 unsigned long msleep_interruptible(unsigned int msecs)
 {
 	unsigned long timeout = msecs_to_jiffies(msecs) + 1;
 	while (timeout && !signal_pending(current))
 		timeout = schedule_timeout_interruptible(timeout);
 	return jiffies_to_msecs(timeout);
 }
 EXPORT_SYMBOL(msleep_interruptible);