[PATCH 1/2] remove __init modifier from header declaration

[PATCH 1/2] remove __init modifier from header declaration

[Glauber de Oliveira Costa]

This patch removes the __init modifier from an extern function
declaration in acpi.h.

Besides not being strictly needed, it requires the inclusion of
linux/init.h, which is usually not even included directly, increasing
header mess by a lot.

Signed-off-by: Glauber de Oliveira Costa <gcosta@redhat.com>
---
 include/asm-x86/acpi.h |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

diff --git a/include/asm-x86/acpi.h b/include/asm-x86/acpi.h
index c477e57..2feb0c4 100644
--- a/include/asm-x86/acpi.h
+++ b/include/asm-x86/acpi.h
@@ -158,7 +158,7 @@ extern int acpi_scan_nodes(unsigned long start, unsigned long end);
 #ifdef CONFIG_X86_64
 # define NR_NODE_MEMBLKS (MAX_NUMNODES*2)
 #endif
-extern void __init acpi_fake_nodes(const struct bootnode *fake_nodes,
+extern void acpi_fake_nodes(const struct bootnode *fake_nodes,
 				   int num_nodes);
 #else
 static inline void acpi_fake_nodes(const struct bootnode *fake_nodes,
-- 
1.5.0.6

[PATCH 2/2] finish processor.h integration

[Glauber de Oliveira Costa]

What's left in processor_32.h and processor_64.h cannot be cleanly
integrated. However, it's just a couple of definitions. They are moved
to processor.h around ifdefs, and the original files are deleted. Note that
there's much less headers included in the final version.

Signed-off-by: Glauber de Oliveira Costa <gcosta@redhat.com>
---
 include/asm-x86/processor.h    |  128 +++++++++++++++++++++++++++++++++++++++-
 include/asm-x86/processor_32.h |   97 ------------------------------
 include/asm-x86/processor_64.h |   66 --------------------
 3 files changed, 126 insertions(+), 165 deletions(-)
 delete mode 100644 include/asm-x86/processor_32.h
 delete mode 100644 include/asm-x86/processor_64.h

diff --git a/include/asm-x86/processor.h b/include/asm-x86/processor.h
index 80c5002..decb740 100644
--- a/include/asm-x86/processor.h
+++ b/include/asm-x86/processor.h
@@ -11,6 +11,8 @@ struct mm_struct;
 #include <asm/percpu.h>
 #include <asm/system.h>
 #include <asm/percpu.h>
+#include <asm/msr.h>
+#include <asm/desc_defs.h>
 #include <linux/cpumask.h>
 #include <linux/cache.h>
 
@@ -275,7 +277,11 @@ union i387_union {
 	struct i387_soft_struct soft;
 };
 
-# include "processor_32.h"
+/*
+ * the following now lives in the per cpu area:
+ * extern	int cpu_llc_id[NR_CPUS];
+ */
+DECLARE_PER_CPU(u8, cpu_llc_id);
 #else
 struct i387_fxsave_struct {
 	u16	cwd;
@@ -295,7 +301,7 @@ union i387_union {
 	struct i387_fxsave_struct	fxsave;
 };
 
-# include "processor_64.h"
+DECLARE_PER_CPU(struct orig_ist, orig_ist);
 #endif
 
 extern void print_cpu_info(struct cpuinfo_x86 *);
@@ -778,6 +784,124 @@ static inline void prefetchw(const void *x)
 }
 
 #define spin_lock_prefetch(x)	prefetchw(x)
+#ifdef CONFIG_X86_32
+/*
+ * User space process size: 3GB (default).
+ */
+#define TASK_SIZE	(PAGE_OFFSET)
+
+#define INIT_THREAD  {							\
+	.sp0 = sizeof(init_stack) + (long)&init_stack,			\
+	.vm86_info = NULL,						\
+	.sysenter_cs = __KERNEL_CS,					\
+	.io_bitmap_ptr = NULL,						\
+	.fs = __KERNEL_PERCPU,						\
+}
+
+/*
+ * Note that the .io_bitmap member must be extra-big. This is because
+ * the CPU will access an additional byte beyond the end of the IO
+ * permission bitmap. The extra byte must be all 1 bits, and must
+ * be within the limit.
+ */
+#define INIT_TSS  {							\
+	.x86_tss = {							\
+		.sp0		= sizeof(init_stack) + (long)&init_stack, \
+		.ss0		= __KERNEL_DS,				\
+		.ss1		= __KERNEL_CS,				\
+		.io_bitmap_base	= INVALID_IO_BITMAP_OFFSET,		\
+	 },								\
+	.io_bitmap	= { [0 ... IO_BITMAP_LONGS] = ~0 },		\
+}
+
+#define start_thread(regs, new_eip, new_esp) do {		\
+	__asm__("movl %0,%%gs": :"r" (0));			\
+	regs->fs = 0;						\
+	set_fs(USER_DS);					\
+	regs->ds = __USER_DS;					\
+	regs->es = __USER_DS;					\
+	regs->ss = __USER_DS;					\
+	regs->cs = __USER_CS;					\
+	regs->ip = new_eip;					\
+	regs->sp = new_esp;					\
+} while (0)
+
+
+extern unsigned long thread_saved_pc(struct task_struct *tsk);
+
+#define THREAD_SIZE_LONGS      (THREAD_SIZE/sizeof(unsigned long))
+#define KSTK_TOP(info)                                                 \
+({                                                                     \
+       unsigned long *__ptr = (unsigned long *)(info);                 \
+       (unsigned long)(&__ptr[THREAD_SIZE_LONGS]);                     \
+})
+
+/*
+ * The below -8 is to reserve 8 bytes on top of the ring0 stack.
+ * This is necessary to guarantee that the entire "struct pt_regs"
+ * is accessable even if the CPU haven't stored the SS/ESP registers
+ * on the stack (interrupt gate does not save these registers
+ * when switching to the same priv ring).
+ * Therefore beware: accessing the ss/esp fields of the
+ * "struct pt_regs" is possible, but they may contain the
+ * completely wrong values.
+ */
+#define task_pt_regs(task)                                             \
+({                                                                     \
+       struct pt_regs *__regs__;                                       \
+       __regs__ = (struct pt_regs *)(KSTK_TOP(task_stack_page(task))-8); \
+       __regs__ - 1;                                                   \
+})
+
+#define KSTK_ESP(task) (task_pt_regs(task)->sp)
+
+#else
+/*
+ * User space process size. 47bits minus one guard page.
+ */
+#define TASK_SIZE64	(0x800000000000UL - 4096)
+
+/* This decides where the kernel will search for a free chunk of vm
+ * space during mmap's.
+ */
+#define IA32_PAGE_OFFSET ((current->personality & ADDR_LIMIT_3GB) ? \
+			   0xc0000000 : 0xFFFFe000)
+
+#define TASK_SIZE 		(test_thread_flag(TIF_IA32) ? \
+				 IA32_PAGE_OFFSET : TASK_SIZE64)
+#define TASK_SIZE_OF(child) 	((test_tsk_thread_flag(child, TIF_IA32)) ? \
+				  IA32_PAGE_OFFSET : TASK_SIZE64)
+
+#define INIT_THREAD  { \
+	.sp0 = (unsigned long)&init_stack + sizeof(init_stack) \
+}
+
+#define INIT_TSS  { \
+	.x86_tss.sp0 = (unsigned long)&init_stack + sizeof(init_stack) \
+}
+
+#define start_thread(regs, new_rip, new_rsp) do { 			     \
+	asm volatile("movl %0,%%fs; movl %0,%%es; movl %0,%%ds": :"r" (0));  \
+	load_gs_index(0);						     \
+	(regs)->ip = (new_rip);						     \
+	(regs)->sp = (new_rsp);						     \
+	write_pda(oldrsp, (new_rsp));					     \
+	(regs)->cs = __USER_CS;						     \
+	(regs)->ss = __USER_DS;						     \
+	(regs)->flags = 0x200;						     \
+	set_fs(USER_DS);						     \
+} while (0)
+
+/*
+ * Return saved PC of a blocked thread.
+ * What is this good for? it will be always the scheduler or ret_from_fork.
+ */
+#define thread_saved_pc(t) (*(unsigned long *)((t)->thread.sp - 8))
+
+#define task_pt_regs(tsk) ((struct pt_regs *)(tsk)->thread.sp0 - 1)
+#define KSTK_ESP(tsk) -1 /* sorry. doesn't work for syscall. */
+#endif /* CONFIG_X86_64 */
+
 /* This decides where the kernel will search for a free chunk of vm
  * space during mmap's.
  */
diff --git a/include/asm-x86/processor_32.h b/include/asm-x86/processor_32.h
deleted file mode 100644
index 0d6a430..0000000
--- a/include/asm-x86/processor_32.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (C) 1994 Linus Torvalds
- */
-
-#ifndef __ASM_I386_PROCESSOR_H
-#define __ASM_I386_PROCESSOR_H
-
-#include <asm/vm86.h>
-#include <asm/math_emu.h>
-#include <asm/segment.h>
-#include <asm/page.h>
-#include <asm/types.h>
-#include <asm/sigcontext.h>
-#include <asm/cpufeature.h>
-#include <asm/msr.h>
-#include <asm/system.h>
-#include <linux/threads.h>
-#include <linux/init.h>
-#include <asm/desc_defs.h>
-
-/*
- * the following now lives in the per cpu area:
- * extern	int cpu_llc_id[NR_CPUS];
- */
-DECLARE_PER_CPU(u8, cpu_llc_id);
-
-/*
- * User space process size: 3GB (default).
- */
-#define TASK_SIZE	(PAGE_OFFSET)
-
-#define INIT_THREAD  {							\
-	.sp0 = sizeof(init_stack) + (long)&init_stack,			\
-	.vm86_info = NULL,						\
-	.sysenter_cs = __KERNEL_CS,					\
-	.io_bitmap_ptr = NULL,						\
-	.fs = __KERNEL_PERCPU,						\
-}
-
-/*
- * Note that the .io_bitmap member must be extra-big. This is because
- * the CPU will access an additional byte beyond the end of the IO
- * permission bitmap. The extra byte must be all 1 bits, and must
- * be within the limit.
- */
-#define INIT_TSS  {							\
-	.x86_tss = {							\
-		.sp0		= sizeof(init_stack) + (long)&init_stack, \
-		.ss0		= __KERNEL_DS,				\
-		.ss1		= __KERNEL_CS,				\
-		.io_bitmap_base	= INVALID_IO_BITMAP_OFFSET,		\
-	 },								\
-	.io_bitmap	= { [ 0 ... IO_BITMAP_LONGS] = ~0 },		\
-}
-
-#define start_thread(regs, new_eip, new_esp) do {		\
-	__asm__("movl %0,%%gs": :"r" (0));			\
-	regs->fs = 0;						\
-	set_fs(USER_DS);					\
-	regs->ds = __USER_DS;					\
-	regs->es = __USER_DS;					\
-	regs->ss = __USER_DS;					\
-	regs->cs = __USER_CS;					\
-	regs->ip = new_eip;					\
-	regs->sp = new_esp;					\
-} while (0)
-
-
-extern unsigned long thread_saved_pc(struct task_struct *tsk);
-
-#define THREAD_SIZE_LONGS      (THREAD_SIZE/sizeof(unsigned long))
-#define KSTK_TOP(info)                                                 \
-({                                                                     \
-       unsigned long *__ptr = (unsigned long *)(info);                 \
-       (unsigned long)(&__ptr[THREAD_SIZE_LONGS]);                     \
-})
-
-/*
- * The below -8 is to reserve 8 bytes on top of the ring0 stack.
- * This is necessary to guarantee that the entire "struct pt_regs"
- * is accessable even if the CPU haven't stored the SS/ESP registers
- * on the stack (interrupt gate does not save these registers
- * when switching to the same priv ring).
- * Therefore beware: accessing the ss/esp fields of the
- * "struct pt_regs" is possible, but they may contain the
- * completely wrong values.
- */
-#define task_pt_regs(task)                                             \
-({                                                                     \
-       struct pt_regs *__regs__;                                       \
-       __regs__ = (struct pt_regs *)(KSTK_TOP(task_stack_page(task))-8); \
-       __regs__ - 1;                                                   \
-})
-
-#define KSTK_ESP(task) (task_pt_regs(task)->sp)
-
-#endif /* __ASM_I386_PROCESSOR_H */
diff --git a/include/asm-x86/processor_64.h b/include/asm-x86/processor_64.h
deleted file mode 100644
index 04ce823..0000000
--- a/include/asm-x86/processor_64.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 1994 Linus Torvalds
- */
-
-#ifndef __ASM_X86_64_PROCESSOR_H
-#define __ASM_X86_64_PROCESSOR_H
-
-#include <asm/segment.h>
-#include <asm/page.h>
-#include <asm/types.h>
-#include <asm/sigcontext.h>
-#include <asm/cpufeature.h>
-#include <linux/threads.h>
-#include <asm/msr.h>
-#include <asm/current.h>
-#include <asm/system.h>
-#include <linux/personality.h>
-#include <asm/desc_defs.h>
-
-/*
- * User space process size. 47bits minus one guard page.
- */
-#define TASK_SIZE64	(0x800000000000UL - 4096)
-
-/* This decides where the kernel will search for a free chunk of vm
- * space during mmap's.
- */
-#define IA32_PAGE_OFFSET ((current->personality & ADDR_LIMIT_3GB) ? 0xc0000000 : 0xFFFFe000)
-
-#define TASK_SIZE 		(test_thread_flag(TIF_IA32) ? IA32_PAGE_OFFSET : TASK_SIZE64)
-#define TASK_SIZE_OF(child) 	((test_tsk_thread_flag(child, TIF_IA32)) ? IA32_PAGE_OFFSET : TASK_SIZE64)
-
-
-
-DECLARE_PER_CPU(struct orig_ist, orig_ist);
-
-#define INIT_THREAD  { \
-	.sp0 = (unsigned long)&init_stack + sizeof(init_stack) \
-}
-
-#define INIT_TSS  { \
-	.x86_tss.sp0 = (unsigned long)&init_stack + sizeof(init_stack) \
-}
-
-#define start_thread(regs,new_rip,new_rsp) do { \
-	asm volatile("movl %0,%%fs; movl %0,%%es; movl %0,%%ds": :"r" (0));	 \
-	load_gs_index(0);							\
-	(regs)->ip = (new_rip);						 \
-	(regs)->sp = (new_rsp);						 \
-	write_pda(oldrsp, (new_rsp));						 \
-	(regs)->cs = __USER_CS;							 \
-	(regs)->ss = __USER_DS;							 \
-	(regs)->flags = 0x200;							 \
-	set_fs(USER_DS);							 \
-} while(0) 
-
-/*
- * Return saved PC of a blocked thread.
- * What is this good for? it will be always the scheduler or ret_from_fork.
- */
-#define thread_saved_pc(t) (*(unsigned long *)((t)->thread.sp - 8))
-
-#define task_pt_regs(tsk) ((struct pt_regs *)(tsk)->thread.sp0 - 1)
-#define KSTK_ESP(tsk) -1 /* sorry. doesn't work for syscall. */
-
-#endif /* __ASM_X86_64_PROCESSOR_H */
-- 
1.5.0.6

Re: [PATCH 2/2] finish processor.h integration

[Glauber de Oliveira Costa]

Glauber de Oliveira Costa wrote:
> What's left in processor_32.h and processor_64.h cannot be cleanly
> integrated. However, it's just a couple of definitions. They are moved
> to processor.h around ifdefs, and the original files are deleted. Note that
> there's much less headers included in the final version.
> 
> Signed-off-by: Glauber de Oliveira Costa <gcosta@redhat.com>
> ---
>  include/asm-x86/processor.h    |  128 +++++++++++++++++++++++++++++++++++++++-
>  include/asm-x86/processor_32.h |   97 ------------------------------
>  include/asm-x86/processor_64.h |   66 --------------------
>  3 files changed, 126 insertions(+), 165 deletions(-)
>  delete mode 100644 include/asm-x86/processor_32.h
>  delete mode 100644 include/asm-x86/processor_64.h
> 
> diff --git a/include/asm-x86/processor.h b/include/asm-x86/processor.h
> index 80c5002..decb740 100644
> --- a/include/asm-x86/processor.h
> +++ b/include/asm-x86/processor.h
> @@ -11,6 +11,8 @@ struct mm_struct;
>  #include <asm/percpu.h>
>  #include <asm/system.h>
>  #include <asm/percpu.h>
> +#include <asm/msr.h>
> +#include <asm/desc_defs.h>
>  #include <linux/cpumask.h>
>  #include <linux/cache.h>
>  
> @@ -275,7 +277,11 @@ union i387_union {
>  	struct i387_soft_struct soft;
>  };
>  
> -# include "processor_32.h"
> +/*
> + * the following now lives in the per cpu area:
> + * extern	int cpu_llc_id[NR_CPUS];
> + */
> +DECLARE_PER_CPU(u8, cpu_llc_id);
>  #else
>  struct i387_fxsave_struct {
>  	u16	cwd;
> @@ -295,7 +301,7 @@ union i387_union {
>  	struct i387_fxsave_struct	fxsave;
>  };
>  
> -# include "processor_64.h"
> +DECLARE_PER_CPU(struct orig_ist, orig_ist);
>  #endif
>  
>  extern void print_cpu_info(struct cpuinfo_x86 *);
> @@ -778,6 +784,124 @@ static inline void prefetchw(const void *x)
>  }
>  
>  #define spin_lock_prefetch(x)	prefetchw(x)
> +#ifdef CONFIG_X86_32
> +/*
> + * User space process size: 3GB (default).
> + */
> +#define TASK_SIZE	(PAGE_OFFSET)
> +
> +#define INIT_THREAD  {							\
> +	.sp0 = sizeof(init_stack) + (long)&init_stack,			\
> +	.vm86_info = NULL,						\
> +	.sysenter_cs = __KERNEL_CS,					\
> +	.io_bitmap_ptr = NULL,						\
> +	.fs = __KERNEL_PERCPU,						\
> +}
> +
> +/*
> + * Note that the .io_bitmap member must be extra-big. This is because
> + * the CPU will access an additional byte beyond the end of the IO
> + * permission bitmap. The extra byte must be all 1 bits, and must
> + * be within the limit.
> + */
> +#define INIT_TSS  {							\
> +	.x86_tss = {							\
> +		.sp0		= sizeof(init_stack) + (long)&init_stack, \
> +		.ss0		= __KERNEL_DS,				\
> +		.ss1		= __KERNEL_CS,				\
> +		.io_bitmap_base	= INVALID_IO_BITMAP_OFFSET,		\
> +	 },								\
> +	.io_bitmap	= { [0 ... IO_BITMAP_LONGS] = ~0 },		\
> +}
> +
> +#define start_thread(regs, new_eip, new_esp) do {		\
> +	__asm__("movl %0,%%gs": :"r" (0));			\
> +	regs->fs = 0;						\
> +	set_fs(USER_DS);					\
> +	regs->ds = __USER_DS;					\
> +	regs->es = __USER_DS;					\
> +	regs->ss = __USER_DS;					\
> +	regs->cs = __USER_CS;					\
> +	regs->ip = new_eip;					\
> +	regs->sp = new_esp;					\
> +} while (0)
> +
> +
> +extern unsigned long thread_saved_pc(struct task_struct *tsk);
> +
> +#define THREAD_SIZE_LONGS      (THREAD_SIZE/sizeof(unsigned long))
> +#define KSTK_TOP(info)                                                 \
> +({                                                                     \
> +       unsigned long *__ptr = (unsigned long *)(info);                 \
> +       (unsigned long)(&__ptr[THREAD_SIZE_LONGS]);                     \
> +})
> +
> +/*
> + * The below -8 is to reserve 8 bytes on top of the ring0 stack.
> + * This is necessary to guarantee that the entire "struct pt_regs"
> + * is accessable even if the CPU haven't stored the SS/ESP registers
> + * on the stack (interrupt gate does not save these registers
> + * when switching to the same priv ring).
> + * Therefore beware: accessing the ss/esp fields of the
> + * "struct pt_regs" is possible, but they may contain the
> + * completely wrong values.
> + */
> +#define task_pt_regs(task)                                             \
> +({                                                                     \
> +       struct pt_regs *__regs__;                                       \
> +       __regs__ = (struct pt_regs *)(KSTK_TOP(task_stack_page(task))-8); \
> +       __regs__ - 1;                                                   \
> +})
> +
> +#define KSTK_ESP(task) (task_pt_regs(task)->sp)
> +
> +#else
> +/*
> + * User space process size. 47bits minus one guard page.
> + */
> +#define TASK_SIZE64	(0x800000000000UL - 4096)
> +
> +/* This decides where the kernel will search for a free chunk of vm
> + * space during mmap's.
> + */
> +#define IA32_PAGE_OFFSET ((current->personality & ADDR_LIMIT_3GB) ? \
> +			   0xc0000000 : 0xFFFFe000)
> +
> +#define TASK_SIZE 		(test_thread_flag(TIF_IA32) ? \
> +				 IA32_PAGE_OFFSET : TASK_SIZE64)
> +#define TASK_SIZE_OF(child) 	((test_tsk_thread_flag(child, TIF_IA32)) ? \
> +				  IA32_PAGE_OFFSET : TASK_SIZE64)
> +
> +#define INIT_THREAD  { \
> +	.sp0 = (unsigned long)&init_stack + sizeof(init_stack) \
> +}
> +
> +#define INIT_TSS  { \
> +	.x86_tss.sp0 = (unsigned long)&init_stack + sizeof(init_stack) \
> +}
> +
> +#define start_thread(regs, new_rip, new_rsp) do { 			     \
> +	asm volatile("movl %0,%%fs; movl %0,%%es; movl %0,%%ds": :"r" (0));  \
> +	load_gs_index(0);						     \
> +	(regs)->ip = (new_rip);						     \
> +	(regs)->sp = (new_rsp);						     \
> +	write_pda(oldrsp, (new_rsp));					     \
> +	(regs)->cs = __USER_CS;						     \
> +	(regs)->ss = __USER_DS;						     \
> +	(regs)->flags = 0x200;						     \
> +	set_fs(USER_DS);						     \
> +} while (0)
> +
> +/*
> + * Return saved PC of a blocked thread.
> + * What is this good for? it will be always the scheduler or ret_from_fork.
> + */
> +#define thread_saved_pc(t) (*(unsigned long *)((t)->thread.sp - 8))
> +
> +#define task_pt_regs(tsk) ((struct pt_regs *)(tsk)->thread.sp0 - 1)
> +#define KSTK_ESP(tsk) -1 /* sorry. doesn't work for syscall. */
> +#endif /* CONFIG_X86_64 */
> +
>  /* This decides where the kernel will search for a free chunk of vm
>   * space during mmap's.
>   */
> diff --git a/include/asm-x86/processor_32.h b/include/asm-x86/processor_32.h
> deleted file mode 100644
> index 0d6a430..0000000
> --- a/include/asm-x86/processor_32.h
> +++ /dev/null
> @@ -1,97 +0,0 @@
> -/*
> - * Copyright (C) 1994 Linus Torvalds
> - */
> -
> -#ifndef __ASM_I386_PROCESSOR_H
> -#define __ASM_I386_PROCESSOR_H
> -
> -#include <asm/vm86.h>
> -#include <asm/math_emu.h>
> -#include <asm/segment.h>
> -#include <asm/page.h>
> -#include <asm/types.h>
> -#include <asm/sigcontext.h>
> -#include <asm/cpufeature.h>
> -#include <asm/msr.h>
> -#include <asm/system.h>
> -#include <linux/threads.h>
> -#include <linux/init.h>
> -#include <asm/desc_defs.h>
> -
> -/*
> - * the following now lives in the per cpu area:
> - * extern	int cpu_llc_id[NR_CPUS];
> - */
> -DECLARE_PER_CPU(u8, cpu_llc_id);
> -
> -/*
> - * User space process size: 3GB (default).
> - */
> -#define TASK_SIZE	(PAGE_OFFSET)
> -
> -#define INIT_THREAD  {							\
> -	.sp0 = sizeof(init_stack) + (long)&init_stack,			\
> -	.vm86_info = NULL,						\
> -	.sysenter_cs = __KERNEL_CS,					\
> -	.io_bitmap_ptr = NULL,						\
> -	.fs = __KERNEL_PERCPU,						\
> -}
> -
> -/*
> - * Note that the .io_bitmap member must be extra-big. This is because
> - * the CPU will access an additional byte beyond the end of the IO
> - * permission bitmap. The extra byte must be all 1 bits, and must
> - * be within the limit.
> - */
> -#define INIT_TSS  {							\
> -	.x86_tss = {							\
> -		.sp0		= sizeof(init_stack) + (long)&init_stack, \
> -		.ss0		= __KERNEL_DS,				\
> -		.ss1		= __KERNEL_CS,				\
> -		.io_bitmap_base	= INVALID_IO_BITMAP_OFFSET,		\
> -	 },								\
> -	.io_bitmap	= { [ 0 ... IO_BITMAP_LONGS] = ~0 },		\
> -}
> -
> -#define start_thread(regs, new_eip, new_esp) do {		\
> -	__asm__("movl %0,%%gs": :"r" (0));			\
> -	regs->fs = 0;						\
> -	set_fs(USER_DS);					\
> -	regs->ds = __USER_DS;					\
> -	regs->es = __USER_DS;					\
> -	regs->ss = __USER_DS;					\
> -	regs->cs = __USER_CS;					\
> -	regs->ip = new_eip;					\
> -	regs->sp = new_esp;					\
> -} while (0)
> -
> -
> -extern unsigned long thread_saved_pc(struct task_struct *tsk);
> -
> -#define THREAD_SIZE_LONGS      (THREAD_SIZE/sizeof(unsigned long))
> -#define KSTK_TOP(info)                                                 \
> -({                                                                     \
> -       unsigned long *__ptr = (unsigned long *)(info);                 \
> -       (unsigned long)(&__ptr[THREAD_SIZE_LONGS]);                     \
> -})
> -
> -/*
> - * The below -8 is to reserve 8 bytes on top of the ring0 stack.
> - * This is necessary to guarantee that the entire "struct pt_regs"
> - * is accessable even if the CPU haven't stored the SS/ESP registers
> - * on the stack (interrupt gate does not save these registers
> - * when switching to the same priv ring).
> - * Therefore beware: accessing the ss/esp fields of the
> - * "struct pt_regs" is possible, but they may contain the
> - * completely wrong values.
> - */
> -#define task_pt_regs(task)                                             \
> -({                                                                     \
> -       struct pt_regs *__regs__;                                       \
> -       __regs__ = (struct pt_regs *)(KSTK_TOP(task_stack_page(task))-8); \
> -       __regs__ - 1;                                                   \
> -})
> -
> -#define KSTK_ESP(task) (task_pt_regs(task)->sp)
> -
> -#endif /* __ASM_I386_PROCESSOR_H */
> diff --git a/include/asm-x86/processor_64.h b/include/asm-x86/processor_64.h
> deleted file mode 100644
> index 04ce823..0000000
> --- a/include/asm-x86/processor_64.h
> +++ /dev/null
> @@ -1,66 +0,0 @@
> -/*
> - * Copyright (C) 1994 Linus Torvalds
> - */
> -
> -#ifndef __ASM_X86_64_PROCESSOR_H
> -#define __ASM_X86_64_PROCESSOR_H
> -
> -#include <asm/segment.h>
> -#include <asm/page.h>
> -#include <asm/types.h>
> -#include <asm/sigcontext.h>
> -#include <asm/cpufeature.h>
> -#include <linux/threads.h>
> -#include <asm/msr.h>
> -#include <asm/current.h>
> -#include <asm/system.h>
> -#include <linux/personality.h>
> -#include <asm/desc_defs.h>
> -
> -/*
> - * User space process size. 47bits minus one guard page.
> - */
> -#define TASK_SIZE64	(0x800000000000UL - 4096)
> -
> -/* This decides where the kernel will search for a free chunk of vm
> - * space during mmap's.
> - */
> -#define IA32_PAGE_OFFSET ((current->personality & ADDR_LIMIT_3GB) ? 0xc0000000 : 0xFFFFe000)
> -
> -#define TASK_SIZE 		(test_thread_flag(TIF_IA32) ? IA32_PAGE_OFFSET : TASK_SIZE64)
> -#define TASK_SIZE_OF(child) 	((test_tsk_thread_flag(child, TIF_IA32)) ? IA32_PAGE_OFFSET : TASK_SIZE64)
> -
> -
> -
> -DECLARE_PER_CPU(struct orig_ist, orig_ist);
> -
> -#define INIT_THREAD  { \
> -	.sp0 = (unsigned long)&init_stack + sizeof(init_stack) \
> -}
> -
> -#define INIT_TSS  { \
> -	.x86_tss.sp0 = (unsigned long)&init_stack + sizeof(init_stack) \
> -}
> -
> -#define start_thread(regs,new_rip,new_rsp) do { \
> -	asm volatile("movl %0,%%fs; movl %0,%%es; movl %0,%%ds": :"r" (0));	 \
> -	load_gs_index(0);							\
> -	(regs)->ip = (new_rip);						 \
> -	(regs)->sp = (new_rsp);						 \
> -	write_pda(oldrsp, (new_rsp));						 \
> -	(regs)->cs = __USER_CS;							 \
> -	(regs)->ss = __USER_DS;							 \
> -	(regs)->flags = 0x200;							 \
> -	set_fs(USER_DS);							 \
> -} while(0) 
> -
> -/*
> - * Return saved PC of a blocked thread.
> - * What is this good for? it will be always the scheduler or ret_from_fork.
> - */
> -#define thread_saved_pc(t) (*(unsigned long *)((t)->thread.sp - 8))
> -
> -#define task_pt_regs(tsk) ((struct pt_regs *)(tsk)->thread.sp0 - 1)
> -#define KSTK_ESP(tsk) -1 /* sorry. doesn't work for syscall. */
> -
> -#endif /* __ASM_X86_64_PROCESSOR_H */

Okay, Ingo, this was a distraction of mine. As the patch was already 
ready, I just sent out after fixing, but you are obviously right, and it 
is not good even for changelog purposes. I'll send now a patch that 
includes all headers deleted from 64 and 32 bit, and in the future, 
remove the unused ones. The last patch is not needed, because we include 
init.h here, but it's not wrong, nevertheless.

Please forget this one, and apply the one I'll send following this message.

Re: [PATCH 1/2] remove __init modifier from header declaration

[Ingo Molnar]

* Glauber de Oliveira Costa <gcosta@redhat.com> wrote:

> This patch removes the __init modifier from an extern function 
> declaration in acpi.h.
> 
> Besides not being strictly needed, it requires the inclusion of 
> linux/init.h, which is usually not even included directly, increasing 
> header mess by a lot.

thanks, applied.

btw., people have been talking about reducing the include file mess for 
nearly a decade now, but it didnt get that much better - at least not in 
include/asm-x86/*.h. So include file dependency flattening patches would 
be more than welcome as well. (and unlike unification patches they have 
no expectation of being 100% perfect, so a natural ping-pong of fixes, 
until the changes are fully correct, would be natural.)

	Ingo

Re: [PATCH 1/2] remove __init modifier from header declaration

[Alexey Dobriyan]

On Wed, Dec 19, 2007 at 11:12:36AM +0100, Ingo Molnar wrote:
> * Glauber de Oliveira Costa <gcosta@redhat.com> wrote:
> 
> > This patch removes the __init modifier from an extern function 
> > declaration in acpi.h.
> > 
> > Besides not being strictly needed, it requires the inclusion of 
> > linux/init.h, which is usually not even included directly, increasing 
> > header mess by a lot.
> 
> thanks, applied.
> 
> btw., people have been talking about reducing the include file mess for 
> nearly a decade now,

Some of us are actually doing it. ;-)

> but it didnt get that much better - at least not in 
> include/asm-x86/*.h.

That's because hunting in include/linux/ is much more fruitful -- it
decreases amount of code after preprocessing for everyone. Below are
allyesconfig on x86_64 results for some kernels:

	$ wc ../*.i
	   79018171   229433654  2049266884 ../2.6.18.i
	   86568111   250674099  2245115663 ../2.6.19.i
	   85187296   247470579  2221334183 ../2.6.20.i		<===
	   88645422   242396928  2234855428 ../2.6.21.i
	   93897302   257990496  2377174442 ../2.6.22.i
	   98381373   268683402  2486321956 ../2.6.23.i

E.g. we can have ~1.07% decrease in cpp output despite ~126000 lines
added between .19 and .20.

> So include file dependency flattening patches would 
> be more than welcome as well.

Yup! Provided they're compile-tested sufficiently well.

> (and unlike unification patches they have 
> no expectation of being 100% perfect, so a natural ping-pong of fixes, 
> until the changes are fully correct, would be natural.)

That way you'll never clean anything especially during merge window. ;-)

Re: [PATCH 1/2] remove __init modifier from header declaration

[Ingo Molnar]

* Alexey Dobriyan <adobriyan@gmail.com> wrote:

> > thanks, applied.
> > 
> > btw., people have been talking about reducing the include file mess 
> > for nearly a decade now,
> 
> Some of us are actually doing it. ;-)

sorry, this was really not meant to slight your contributions in this 
area in any way :-) I'm just judging by the spaghetti still hanging 
around in asm-x86/*.h, and the 'fun' we have with paravirt and its type 
dependencies - and the periodic messups we have with macros. (and many 
macros are not inlines due to ugly dependencies.)

> > So include file dependency flattening patches would be more than 
> > welcome as well.
> 
> Yup! Provided they're compile-tested sufficiently well.

as long as it builds/boots on your box with a single convenient .config 
of yours, we can stick such patches into x86.git and work out all the 
build failures it might cause.

> > (and unlike unification patches they have no expectation of being 
> > 100% perfect, so a natural ping-pong of fixes, until the changes are 
> > fully correct, would be natural.)
> 
> That way you'll never clean anything especially during merge window. 
> ;-)

hm, what do you mean?

	Ingo