NLKD - Novell Linux Kernel Debugger

@@ -19,6 +19,25 @@ const char *kallsyms_lookup(unsigned lon
 			    unsigned long *offset,
 			    char **modname, char *namebuf);
 
+#ifdef CONFIG_MODULES
+
+#if defined(Elf_Shdr) && defined(Elf_Sym)
+char kallsyms_elf_type(const Elf_Sym *sym,
+		       const Elf_Shdr *sechdrs,
+		       const char *secstrings);
+#endif
+
+struct module;
+void module_init_done(struct module *);
+
+unsigned long kallsyms_find_symname(struct module *, const char *);
+
+const char *kallsyms_get_ksymbol(struct module *,
+                                 unsigned long addr,
+                                 unsigned long *size,
+                                 unsigned long *offset);
+#endif
+
 /* Replace "%s" in format with address, if found */
 extern void __print_symbol(const char *fmt, unsigned long address);
 

@@ -64,4 +83,12 @@ do {						\
 	__print_symbol(fmt, addr);		\
 } while(0)
 
+#if defined(CONFIG_KALLSYMS) && !defined(CONFIG_KALLSYMS_TRADITIONAL)
+void kallsyms_early_init(void);
+void kallsyms_init_done(void);
+#else
+#define kallsyms_early_init() ((void)0)
+#define kallsyms_init_done() ((void)0)
+#endif
+
 #endif /*_LINUX_KALLSYMS_H*/

@@ -39,6 +39,16 @@
   ALIGN; \
   name:
 
+#ifdef CONFIG_KALLSYMS
+#define ENDPROC(name) \
+  .type name, @function; \
+  END(name)
+#define END(name) \
+  .size name, .-name
+#else
+#define ENDPROC(name)
+#define END(name)
+#endif
 
 #endif
 

@@ -301,7 +301,14 @@ struct module
 	/* We keep the symbol and string tables for kallsyms. */
 	Elf_Sym *symtab;
 	unsigned long num_symtab;
-	char *strtab;
+	const char *strtab;
+
+# ifndef CONFIG_KALLSYMS_TRADITIONAL
+	/* And also the sections and their string table. */
+	Elf_Shdr *sections;
+	unsigned long num_sections;
+	const char *shstrtab;
+# endif
 
 	/* Section attributes */
 	struct module_sect_attrs *sect_attrs;

@@ -481,6 +481,7 @@ asmlinkage void __init start_kernel(void
 		   &unknown_bootoption);
 	sort_main_extable();
 	trap_init();
+	kallsyms_early_init();
 	rcu_init();
 	init_IRQ();
 	pidhash_init();

@@ -708,6 +709,7 @@ static int init(void * unused)
 	 * we're essentially up and running. Get rid of the
 	 * initmem segments and start the user-mode stuff..
 	 */
+	kallsyms_init_done();
 	free_initmem();
 	unlock_kernel();
 	system_state = SYSTEM_RUNNING;

467 lines not on this page · raw message

377 lines not on this page · raw message

@@ -43,7 +43,7 @@ FILE *debugfile;
 int cur_line = 1;
 char *cur_filename, *output_directory;
 
-int flag_debug, flag_dump_defs, flag_warnings;
+int flag_debug, flag_dump_defs, flag_warnings, flag_inline_asm;
 
 static int errors;
 static int nsyms;

@@ -457,8 +457,16 @@ export_symbol(const char *name)
       if (flag_dump_defs)
 	fputs(">\n", debugfile);
 
-      /* Used as a linker script. */
-      printf("__crc_%s = 0x%08lx ;\n", name, crc);
+      if (!flag_inline_asm)
+	{
+	  /* Used as a linker script. */
+	  printf("__crc_%s = 0x%08lx ;\n", name, crc);
+	}
+      else
+	{
+	  /* Used as inline assembly. */
+	  printf("__asm__(\".equiv __crc_%s, 0x%08lx\");\n", name, crc);
+	}
     }
 }
 

@@ -529,6 +537,7 @@ main(int argc, char **argv)
 
 #ifdef __GNU_LIBRARY__
   struct option long_opts[] = {
+    {"asm", 0, 0, 'a'},
     {"debug", 0, 0, 'd'},
     {"warnings", 0, 0, 'w'},
     {"quiet", 0, 0, 'q'},

@@ -538,13 +547,16 @@ main(int argc, char **argv)
     {0, 0, 0, 0}
   };
 
-  while ((o = getopt_long(argc, argv, "dwqVDk:p:",
+  while ((o = getopt_long(argc, argv, "adwqVDk:p:",
 			  &long_opts[0], NULL)) != EOF)
 #else  /* __GNU_LIBRARY__ */
-  while ((o = getopt(argc, argv, "dwqVDk:p:")) != EOF)
+  while ((o = getopt(argc, argv, "adwqVDk:p:")) != EOF)
 #endif /* __GNU_LIBRARY__ */
     switch (o)
       {
+      case 'a':
+	flag_inline_asm = 1;
+	break;
       case 'd':
 	flag_debug++;
 	break;

144 lines not on this page · raw message

Index: 2.6.14-nlkd/arch/i386/kernel/setup.c
===================================================================
@@ -1127,6 +1127,9 @@ static unsigned long __init setup_memory
 	}
 	printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
 		pages_to_mb(highend_pfn - highstart_pfn));
+	high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
+#else
+	high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
 #endif
 	printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
 			pages_to_mb(max_low_pfn));

Index: 2.6.14-nlkd/arch/i386/mm/init.c
===================================================================
@@ -560,12 +560,6 @@ void __init mem_init(void)
  
 	set_max_mapnr_init();
 
-#ifdef CONFIG_HIGHMEM
-	high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
-#else
-	high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
-#endif
-
 	/* this will put all low memory onto the freelists */
 	totalram_pages += free_all_bootmem();
 

Index: 2.6.14-nlkd/arch/i386/mm/ioremap.c
===================================================================
@@ -257,7 +257,8 @@ void iounmap(volatile void __iomem *addr
 	} 
 out_unlock:
 	write_unlock(&vmlist_lock);
-	kfree(p); 
+	if (p)
+		free_vm_area(p);
 }
 EXPORT_SYMBOL(iounmap);
 

Index: 2.6.14-nlkd/arch/i386/mm/pgtable.c
===================================================================
@@ -11,6 +11,7 @@
 #include <linux/smp.h>
 #include <linux/highmem.h>
 #include <linux/slab.h>
+#include <linux/bootmem.h>
 #include <linux/pagemap.h>
 #include <linux/spinlock.h>
 

@@ -148,7 +149,9 @@ void __set_fixmap (enum fixed_addresses 
 
 pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
 {
-	return (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
+	if (likely(totalram_pages))
+		return (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
+	return alloc_bootmem_pages(PAGE_SIZE);
 }
 
 struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)

Index: 2.6.14-nlkd/arch/x86_64/kernel/setup.c
===================================================================
@@ -566,6 +566,7 @@ void __init setup_arch(char **cmdline_p)
 	 * we are rounding upwards:
 	 */
 	end_pfn = e820_end_of_ram();
+	high_memory = (void *)__va(end_pfn * PAGE_SIZE - 1) + 1;
 
 	check_efer();
 

Index: 2.6.14-nlkd/arch/x86_64/mm/init.c
===================================================================
@@ -400,7 +400,6 @@ void __init mem_init(void)
 	max_low_pfn = end_pfn;
 	max_pfn = end_pfn;
 	num_physpages = end_pfn;
-	high_memory = (void *) __va(end_pfn * PAGE_SIZE);
 
 	/* clear the zero-page */
 	memset(empty_zero_page, 0, PAGE_SIZE);

Index: 2.6.14-nlkd/arch/x86_64/mm/ioremap.c
===================================================================
@@ -266,5 +266,6 @@ void iounmap(volatile void __iomem *addr
 	else if (p->flags >> 20)
 		ioremap_change_attr(p->phys_addr, p->size, 0);
 	write_unlock(&vmlist_lock);
-	kfree(p); 
+	if(p)
+		free_vm_area(p);
 }

Index: 2.6.14-nlkd/include/linux/vmalloc.h
===================================================================
@@ -8,6 +8,7 @@
 #define VM_IOREMAP	0x00000001	/* ioremap() and friends */
 #define VM_ALLOC	0x00000002	/* vmalloc() */
 #define VM_MAP		0x00000004	/* vmap()ed pages */
+#define VM_BOOTMEM	0x00000008	/* allocated from bootmem */
 /* bits [20..32] reserved for arch specific ioremap internals */
 
 /*

@@ -50,6 +51,7 @@ extern struct vm_struct *__get_vm_area(u
 					unsigned long start, unsigned long end);
 extern struct vm_struct *remove_vm_area(void *addr);
 extern struct vm_struct *__remove_vm_area(void *addr);
+extern void free_vm_area(struct vm_struct *area);
 extern int map_vm_area(struct vm_struct *area, pgprot_t prot,
 			struct page ***pages);
 extern void unmap_vm_area(struct vm_struct *area);

Index: 2.6.14-nlkd/mm/page_alloc.c
===================================================================
@@ -992,6 +992,15 @@ fastcall unsigned long get_zeroed_page(g
 {
 	struct page * page;
 
+	if (unlikely(!totalram_pages)) {
+		/* This exists solely for page table allocation; pages
+		   allocated this way must never be freed! */
+		void *address = alloc_bootmem_pages(PAGE_SIZE);
+
+		clear_page(address);
+		return (unsigned long) address;
+	}
+
 	/*
 	 * get_zeroed_page() returns a 32-bit address, which cannot represent
 	 * a highmem page

Index: 2.6.14-nlkd/mm/vmalloc.c
===================================================================
@@ -11,6 +11,7 @@
 #include <linux/module.h>
 #include <linux/highmem.h>
 #include <linux/slab.h>
+#include <linux/bootmem.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 

@@ -177,20 +178,24 @@ struct vm_struct *__get_vm_area(unsigned
 	}
 	addr = ALIGN(start, align);
 	size = PAGE_ALIGN(size);
-
-	area = kmalloc(sizeof(*area), GFP_KERNEL);
-	if (unlikely(!area))
-		return NULL;
-
-	if (unlikely(!size)) {
-		kfree (area);
+	if (unlikely(!size))
 		return NULL;
-	}
-
 	/*
 	 * We always allocate a guard page.
 	 */
 	size += PAGE_SIZE;
+	if (unlikely(!size))
+		return NULL;
+
+	BUG_ON(flags & VM_BOOTMEM);
+	if (likely(malloc_sizes->cs_cachep))
+		area = kmalloc(sizeof(*area), GFP_KERNEL);
+	else {
+		area = alloc_bootmem(sizeof(*area));
+		flags |= VM_BOOTMEM;
+	}
+	if (unlikely(!area))
+		return NULL;
 
 	write_lock(&vmlist_lock);
 	for (p = &vmlist; (tmp = *p) != NULL ;p = &tmp->next) {

@@ -225,7 +230,7 @@ found:
 
 out:
 	write_unlock(&vmlist_lock);
-	kfree(area);
+	free_vm_area(area);
 	if (printk_ratelimit())
 		printk(KERN_WARNING "allocation failed: out of vmalloc space - use vmalloc=<size> to increase size.\n");
 	return NULL;

@@ -286,6 +291,14 @@ struct vm_struct *remove_vm_area(void *a
 	return v;
 }
 
+void free_vm_area(struct vm_struct *area)
+{
+	if (likely(!(area->flags & VM_BOOTMEM)))
+		kfree(area);
+	else if (!malloc_sizes->cs_cachep)
+		free_bootmem(virt_to_phys(area), sizeof(*area));
+}
+
 void __vunmap(void *addr, int deallocate_pages)
 {
 	struct vm_struct *area;

@@ -322,7 +335,7 @@ void __vunmap(void *addr, int deallocate
 			kfree(area->pages);
 	}
 
-	kfree(area);
+	free_vm_area(area);
 	return;
 }
 

@@ -412,7 +425,7 @@ void *__vmalloc_area(struct vm_struct *a
 	area->pages = pages;
 	if (!area->pages) {
 		remove_vm_area(area->addr);
-		kfree(area);
+		free_vm_area(area);
 		return NULL;
 	}
 	memset(area->pages, 0, array_size);

Index: 2.6.14-nlkd/include/linux/cpu.h
===================================================================
@@ -42,6 +42,10 @@ struct notifier_block;
 extern int register_cpu_notifier(struct notifier_block *nb);
 extern void unregister_cpu_notifier(struct notifier_block *nb);
 
+#ifndef MODULE
+extern int cpu_notify(unsigned long);
+#endif
+
 int cpu_up(unsigned int cpu);
 
 #else

Index: 2.6.14-nlkd/include/linux/notifier.h
===================================================================
@@ -65,12 +65,14 @@ extern int notifier_call_chain(struct no
 
 #define NETLINK_URELEASE	0x0001	/* Unicast netlink socket released */
 
+#define CPU_ALIVE		0x0001 /* current CPU is alive */
 #define CPU_ONLINE		0x0002 /* CPU (unsigned)v is up */
 #define CPU_UP_PREPARE		0x0003 /* CPU (unsigned)v coming up */
 #define CPU_UP_CANCELED		0x0004 /* CPU (unsigned)v NOT coming up */
 #define CPU_DOWN_PREPARE	0x0005 /* CPU (unsigned)v going down */
 #define CPU_DOWN_FAILED		0x0006 /* CPU (unsigned)v NOT going down */
 #define CPU_DEAD		0x0007 /* CPU (unsigned)v dead */
+#define CPU_DYING		0x0008 /* current CPU dying */
 
 #endif /* __KERNEL__ */
 #endif /* _LINUX_NOTIFIER_H */

Index: 2.6.14-nlkd/kernel/cpu.c
===================================================================
@@ -41,6 +41,12 @@ void unregister_cpu_notifier(struct noti
 }
 EXPORT_SYMBOL(unregister_cpu_notifier);
 
+int cpu_notify(unsigned long event)
+{
+	return notifier_call_chain(&cpu_chain, event,
+	                           (void *)(long)smp_processor_id());
+}
+
 #ifdef CONFIG_HOTPLUG_CPU
 static inline void check_for_tasks(int cpu)
 {

Index: 2.6.14-nlkd/arch/i386/kernel/smpboot.c
===================================================================
@@ -486,6 +486,7 @@ static void __devinit start_secondary(vo
 	smp_callin();
 	while (!cpu_isset(smp_processor_id(), smp_commenced_mask))
 		rep_nop();
+	cpu_notify(CPU_ALIVE);
 	setup_secondary_APIC_clock();
 	if (nmi_watchdog == NMI_IO_APIC) {
 		disable_8259A_irq(0);

@@ -970,6 +971,7 @@ void cpu_exit_clear(void)
 	int cpu = raw_smp_processor_id();
 
 	idle_task_exit();
+	cpu_notify(CPU_DYING);
 
 	cpucount --;
 	cpu_uninit();

Index: 2.6.14-nlkd/arch/x86_64/kernel/process.c
===================================================================
@@ -164,6 +164,7 @@ DECLARE_PER_CPU(int, cpu_state);
 static inline void play_dead(void)
 {
 	idle_task_exit();
+	cpu_notify(CPU_DYING);
 	wbinvd();
 	mb();
 	/* Ack it */

Index: 2.6.14-nlkd/arch/x86_64/kernel/smpboot.c
===================================================================
@@ -40,7 +40,7 @@
 
 #include <linux/config.h>
 #include <linux/init.h>
-
+#include <linux/cpu.h>
 #include <linux/mm.h>
 #include <linux/kernel_stat.h>
 #include <linux/smp_lock.h>

@@ -479,6 +479,8 @@ void __cpuinit start_secondary(void)
 	/* otherwise gcc will move up the smp_processor_id before the cpu_init */
 	barrier();
 
+	cpu_notify(CPU_ALIVE);
+
 	Dprintk("cpu %d: setting up apic clock\n", smp_processor_id()); 	
 	setup_secondary_APIC_clock();
 

Index: 2.6.14-nlkd/include/linux/kernel.h
===================================================================
@@ -86,6 +86,7 @@ extern int cond_resched(void);
 	})
 
 extern struct notifier_block *panic_notifier_list;
+extern struct notifier_block *prepanic_notifier_list;
 extern long (*panic_blink)(long time);
 NORET_TYPE void panic(const char * fmt, ...)
 	__attribute__ ((NORET_AND format (printf, 1, 2)));

Index: 2.6.14-nlkd/kernel/panic.c
===================================================================
@@ -27,8 +27,10 @@ int tainted;
 EXPORT_SYMBOL(panic_timeout);
 
 struct notifier_block *panic_notifier_list;
+struct notifier_block *prepanic_notifier_list;
 
 EXPORT_SYMBOL(panic_notifier_list);
+EXPORT_SYMBOL(prepanic_notifier_list);
 
 static int __init panic_setup(char *str)
 {

@@ -76,6 +78,7 @@ NORET_TYPE void panic(const char * fmt, 
 	vsnprintf(buf, sizeof(buf), fmt, args);
 	va_end(args);
 	printk(KERN_EMERG "Kernel panic - not syncing: %s\n",buf);
+	notifier_call_chain(&prepanic_notifier_list, 0, buf);
 	bust_spinlocks(0);
 
 	/*

Index: 2.6.14-nlkd/include/linux/sched.h
===================================================================
@@ -34,6 +34,7 @@
 #include <linux/percpu.h>
 #include <linux/topology.h>
 #include <linux/seccomp.h>
+#include <linux/notifier.h>
 
 #include <linux/auxvec.h>	/* For AT_VECTOR_SIZE */
 

@@ -1109,6 +1110,11 @@ extern int do_execve(char *, char __user
 extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
 task_t *fork_idle(int);
 
+#define TASK_NEW 1
+#define TASK_DELETE 2
+
+extern struct notifier_block *task_notifier_list;
+
 extern void set_task_comm(struct task_struct *tsk, char *from);
 extern void get_task_comm(char *to, struct task_struct *tsk);
 

Index: 2.6.14-nlkd/kernel/fork.c
===================================================================
@@ -64,6 +64,9 @@ DEFINE_PER_CPU(unsigned long, process_co
 
 EXPORT_SYMBOL(tasklist_lock);
 
+struct notifier_block *task_notifier_list = NULL;
+EXPORT_SYMBOL(task_notifier_list);
+
 int nr_processes(void)
 {
 	int cpu;

@@ -108,6 +111,8 @@ EXPORT_SYMBOL(free_task);
 
 void __put_task_struct(struct task_struct *tsk)
 {
+	notifier_call_chain(&task_notifier_list, TASK_DELETE, tsk);
+
 	WARN_ON(!(tsk->exit_state & (EXIT_DEAD | EXIT_ZOMBIE)));
 	WARN_ON(atomic_read(&tsk->usage));
 	WARN_ON(tsk == current);

@@ -1279,6 +1284,8 @@ long do_fork(unsigned long clone_flags,
 			set_tsk_thread_flag(p, TIF_SIGPENDING);
 		}
 
+		notifier_call_chain(&task_notifier_list, TASK_NEW, p);
+
 		if (!(clone_flags & CLONE_STOPPED))
 			wake_up_new_task(p, clone_flags);
 		else

Index: 2.6.14-nlkd/kernel/module.c
===================================================================
@@ -1169,6 +1169,10 @@ static void cleanup_kallsyms(struct modu
 /* Free a module, remove from lists, etc (must hold module mutex). */
 static void free_module(struct module *mod)
 {
+	down(&notify_mutex);
+	notifier_call_chain(&module_notify_list, MODULE_STATE_GOING, mod);
+	up(&notify_mutex);
+
 	/* Delete from various lists */
 	stop_machine_run(__unlink_module, mod, NR_CPUS);
 	remove_sect_attrs(mod);

@@ -1999,9 +2003,13 @@ sys_init_module(void __user *umod,
                    buggy refcounters. */
 		mod->state = MODULE_STATE_GOING;
 		synchronize_sched();
-		if (mod->unsafe)
+		if (mod->unsafe) {
 			printk(KERN_ERR "%s: module is now stuck!\n",
 			       mod->name);
+			down(&notify_mutex);
+			notifier_call_chain(&module_notify_list, MODULE_STATE_GOING, mod);
+			up(&notify_mutex);
+		}
 		else {
 			module_put(mod);
 			down(&module_mutex);

Index: 2.6.14-nlkd/drivers/char/keyboard.c
===================================================================
@@ -39,6 +39,7 @@
 #include <linux/vt_kern.h>
 #include <linux/sysrq.h>
 #include <linux/input.h>
+#include <linux/kdebug.h>
 
 static void kbd_disconnect(struct input_handle *handle);
 extern void ctrl_alt_del(void);

@@ -153,6 +154,9 @@ static int sysrq_down;
 #endif
 static int sysrq_alt;
 
+struct notifier_block *kdebug_chain = NULL;
+EXPORT_SYMBOL(kdebug_chain);
+
 /*
  * Translation of scancodes to keycodes. We set them on only the first attached
  * keyboard - for per-keyboard setting, /dev/input/event is more useful.

@@ -1052,6 +1056,11 @@ static void kbd_keycode(unsigned int key
 
 	rep = (down == 2);
 
+	if (notify_kdebug(KDEBUG_KEYBOARD,
+	                  keycode | ((long)!down << (BITS_PER_LONG - 1)),
+	                  regs) == NOTIFY_STOP)
+		return;
+
 #ifdef CONFIG_MAC_EMUMOUSEBTN
 	if (mac_hid_mouse_emulate_buttons(1, keycode, down))
 		return;

Index: 2.6.14-nlkd/include/linux/kdebug.h
===================================================================
@@ -0,0 +1,27 @@
+#ifndef _KDEBUG_H
+#define _KDEBUG_H
+
+/*
+ * This notifier is to replace hardcoded entries in e.g. the keyboard
+ * driver used by kernel debuggers.
+ */
+#include <linux/notifier.h>
+
+struct pt_regs;
+
+struct kdebug_args {
+	struct pt_regs *regs;
+	long data;
+};
+
+extern struct notifier_block *kdebug_chain;
+
+#define KDEBUG_KEYBOARD 1
+
+static inline int notify_kdebug(unsigned long event, long data, struct pt_regs *regs)
+{
+	struct kdebug_args args = { .regs=regs, .data = data };
+	return notifier_call_chain(&kdebug_chain, event, &args);
+}
+
+#endif

Index: 2.6.14-nlkd/drivers/video/console/fbcon.c
===================================================================
@@ -107,7 +107,7 @@ enum {
 };
 
 struct display fb_display[MAX_NR_CONSOLES];
-static signed char con2fb_map[MAX_NR_CONSOLES];
+signed char con2fb_map[MAX_NR_CONSOLES];
 static signed char con2fb_map_boot[MAX_NR_CONSOLES];
 static int logo_height;
 static int logo_lines;

@@ -211,6 +211,16 @@ static inline int fbcon_is_inactive(stru
 		vc->vc_mode != KD_TEXT || ops->graphics);
 }
 
+static inline int fbcon_set_par(struct fb_info *info)
+{
+	if (info->fbops->fb_set_par) {
+		if (fb_notify_clients(FB_EVENT_PRE_MODE_CHANGE, info, &info->var) == NOTIFY_BAD)
+			return -EINVAL;
+		info->fbops->fb_set_par(info);
+	}
+	return 0;
+}
+
 static inline int get_color(struct vc_data *vc, struct fb_info *info,
 	      u16 c, int is_fg)
 {

@@ -623,15 +633,19 @@ static int con2fb_release_oldinfo(struct
 	return err;
 }
 
-static void con2fb_init_display(struct vc_data *vc, struct fb_info *info,
+static int con2fb_init_display(struct vc_data *vc, struct fb_info *info,
 				int unit, int show_logo)
 {
 	struct fbcon_ops *ops = info->fbcon_par;
 
 	ops->currcon = fg_console;
 
-	if (info->fbops->fb_set_par && !(ops->flags & FBCON_FLAGS_INIT))
-		info->fbops->fb_set_par(info);
+	if (!(ops->flags & FBCON_FLAGS_INIT)) {
+		int err = fbcon_set_par(info);
+
+		if (err)
+			return err;
+	}
 
 	ops->flags |= FBCON_FLAGS_INIT;
 	ops->graphics = 0;

@@ -652,6 +666,7 @@ static void con2fb_init_display(struct v
 	}
 
 	update_screen(vc_cons[fg_console].d);
+	return 0;
 }
 
 /**

@@ -708,7 +723,7 @@ static int set_con2fb_map(int unit, int 
  		if (!found)
  			fbcon_add_cursor_timer(info);
  		con2fb_map_boot[unit] = newidx;
- 		con2fb_init_display(vc, info, unit, show_logo);
+ 		err = con2fb_init_display(vc, info, unit, show_logo);
 	}
 
 	release_console_sem();

@@ -980,9 +995,8 @@ static void fbcon_init(struct vc_data *v
 	 * We need to do it in fbcon_init() to prevent screen corruption.
 	 */
 	if (CON_IS_VISIBLE(vc)) {
-		if (info->fbops->fb_set_par &&
-		    !(ops->flags & FBCON_FLAGS_INIT))
-			info->fbops->fb_set_par(info);
+		if (!(ops->flags & FBCON_FLAGS_INIT) && fbcon_set_par(info) != 0)
+			return;
 		ops->flags |= FBCON_FLAGS_INIT;
 	}
 

@@ -1988,8 +2002,8 @@ static int fbcon_switch(struct vc_data *
 	fb_set_var(info, &var);
 
 	if (old_info != NULL && old_info != info) {
-		if (info->fbops->fb_set_par)
-			info->fbops->fb_set_par(info);
+		if (fbcon_set_par(info) != 0)
+			return 0;
 		fbcon_del_cursor_timer(old_info);
 		fbcon_add_cursor_timer(info);
 	}

@@ -2848,6 +2862,12 @@ static const struct consw fb_con = {
 	.con_resize             = fbcon_resize,
 };
 
+int is_fb_con(const struct consw *con)
+{
+	return con == &fb_con;
+}
+EXPORT_SYMBOL(is_fb_con);
+
 static struct notifier_block fbcon_event_notifier = {
 	.notifier_call	= fbcon_event_notify,
 };

@@ -2892,4 +2912,6 @@ module_exit(fb_console_exit);
 
 #endif
 
+EXPORT_SYMBOL(con2fb_map);
+
 MODULE_LICENSE("GPL");

Index: 2.6.14-nlkd/drivers/video/console/fbcon.h
===================================================================
@@ -168,4 +168,7 @@ extern void fbcon_set_tileops(struct vc_
 #endif
 extern void fbcon_set_bitops(struct fbcon_ops *ops);
 
+extern int is_fb_con(const struct consw *);
+extern signed char con2fb_map[];
+
 #endif /* _VIDEO_FBCON_H */

Index: 2.6.14-nlkd/drivers/video/console/vgacon.c
===================================================================
@@ -114,6 +114,8 @@ static int 		vga_video_font_height;
 static int 		vga_scan_lines;
 static unsigned int 	vga_rolled_over = 0;
 
+static struct notifier_block *vga_notifier_list;
+
 static int __init no_scroll(char *str)
 {
 	/*

@@ -962,6 +964,9 @@ static int vgacon_adjust_height(struct v
 	outb_p(fsr, vga_video_port_val);
 	outb_p(0x12, vga_video_port_reg);	/* Vertical display limit */
 	outb_p(vde, vga_video_port_val);
+	notifier_call_chain(&vga_notifier_list,
+			    VGACON_EVENT_PRE_ADJUST_HEIGHT | (vga_font_is_default ? VGACON_MC_DEFAULT_FONT : 0),
+			    (void*)(long)rows);
 	spin_unlock_irq(&vga_lock);
 
 	for (i = 0; i < MAX_NR_CONSOLES; i++) {

@@ -1185,4 +1190,16 @@ const struct consw vga_con = {
 	.con_invert_region = vgacon_invert_region,
 };
 
+int vgacon_register_client(struct notifier_block *nb)
+{
+	return notifier_chain_register(&vga_notifier_list, nb);
+}
+EXPORT_SYMBOL(vgacon_register_client);
+
+int vgacon_unregister_client(struct notifier_block *nb)
+{
+	return notifier_chain_unregister(&vga_notifier_list, nb);
+}
+EXPORT_SYMBOL(vgacon_unregister_client);
+
 MODULE_LICENSE("GPL");

Index: 2.6.14-nlkd/drivers/video/fbmem.c
===================================================================
@@ -673,8 +673,17 @@ fb_set_var(struct fb_info *info, struct 
 
 		if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
 			struct fb_videomode mode;
+			struct fb_event event;
 			int err = 0;
 
+			event.info = info;
+			event.data = var;
+			if (notifier_call_chain(&fb_notifier_list,
+						FB_EVENT_PRE_MODE_CHANGE,
+						&event) == NOTIFY_BAD)
+				return -EINVAL;
+
+
 			info->var = *var;
 			if (info->fbops->fb_set_par)
 				info->fbops->fb_set_par(info);

@@ -690,7 +699,6 @@ fb_set_var(struct fb_info *info, struct 
 				err = fb_add_videomode(&mode, &info->modelist);
 
 			if (!err && (flags & FBINFO_MISC_USEREVENT)) {
-				struct fb_event event;
 				int evnt = (var->activate & FB_ACTIVATE_ALL) ?
 					FB_EVENT_MODE_CHANGE_ALL :
 					FB_EVENT_MODE_CHANGE;

@@ -1117,6 +1125,21 @@ int fb_unregister_client(struct notifier
 }
 
 /**
+ *	fb_notify_clients - notify all clients
+ *	@what: event type
+ *	@info: framebuffer affected
+ *	@data: event specific data
+ */
+int fb_notify_clients(unsigned long what, struct fb_info *info, void *data)
+{
+	struct fb_event event;
+
+	event.info = info;
+	event.data = data;
+	return notifier_call_chain(&fb_notifier_list, what, &event);
+}
+
+/**
  *	fb_set_suspend - low level driver signals suspend
  *	@info: framebuffer affected
  *	@state: 0 = resuming, !=0 = suspending

@@ -1321,6 +1344,7 @@ EXPORT_SYMBOL(fb_get_buffer_offset);
 EXPORT_SYMBOL(fb_set_suspend);
 EXPORT_SYMBOL(fb_register_client);
 EXPORT_SYMBOL(fb_unregister_client);
+EXPORT_SYMBOL(fb_notify_clients);
 EXPORT_SYMBOL(fb_get_options);
 EXPORT_SYMBOL(fb_new_modelist);
 

Index: 2.6.14-nlkd/include/linux/fb.h
===================================================================
@@ -475,6 +475,8 @@ struct fb_cursor_user {
  * Register/unregister for framebuffer events
  */
 
+/*	The resolution of the passed in fb_info is about to change */
+#define FB_EVENT_PRE_MODE_CHANGE	0x00
 /*	The resolution of the passed in fb_info about to change */ 
 #define FB_EVENT_MODE_CHANGE		0x01
 /*	The display on this fb_info is beeing suspended, no access to the

@@ -509,6 +511,7 @@ struct fb_event {
 
 extern int fb_register_client(struct notifier_block *nb);
 extern int fb_unregister_client(struct notifier_block *nb);
+extern int fb_notify_clients(unsigned long, struct fb_info *, void *);
 
 /*
  * Pixmap structure definition

Index: 2.6.14-nlkd/include/video/vga.h
===================================================================
@@ -19,6 +19,7 @@
 
 #include <linux/config.h>
 #include <linux/types.h>
+#include <linux/notifier.h>
 #include <asm/io.h>
 #ifndef CONFIG_AMIGA
 #include <asm/vga.h>

@@ -479,4 +480,12 @@ static inline void vga_mm_wattr (void __
         vga_mm_w (regbase, VGA_ATT_W, val);
 }
 
+#define VGACON_EVENT_PRE_ADJUST_HEIGHT 0x01
+
+#define VGACON_EVENT_FLAGS_MASK 0xff000000
+#define VGACON_MC_DEFAULT_FONT 0x80000000
+
+int vgacon_register_client(struct notifier_block *);
+int vgacon_unregister_client(struct notifier_block *);
+
 #endif /* __linux_video_vga_h__ */

Index: 2.6.14-nlkd/include/linux/jiffies.h
===================================================================
@@ -83,6 +83,11 @@
  */
 extern u64 __jiffy_data jiffies_64;
 extern unsigned long volatile __jiffy_data jiffies;
+#ifndef CONFIG_DEBUG_KERNEL
+# define debugger_jiffies 0
+#else
+extern u64 debugger_jiffies;
+#endif
 
 #if (BITS_PER_LONG < 64)
 u64 get_jiffies_64(void);

Index: 2.6.14-nlkd/kernel/timer.c
===================================================================
@@ -46,6 +46,10 @@ static void time_interpolator_update(lon
 #define time_interpolator_update(x)
 #endif
 
+#ifdef CONFIG_DEBUG_KERNEL
+u64 debugger_jiffies;
+#endif
+
 /*
  * per-CPU timer vector definitions:
  */

@@ -935,6 +939,28 @@ static inline void update_times(void)
 	ticks = jiffies - wall_jiffies;
 	if (ticks) {
 		wall_jiffies += ticks;
+#ifndef debugger_jiffies
+		if (ticks > 1
+		    && debugger_jiffies
+		    && jiffies_64 - debugger_jiffies > 1) {
+			u64 nsec64 = (u64)(ticks - 1) * tick_nsec;
+			unsigned long nsec = do_div(nsec64, NSEC_PER_SEC);
+			unsigned long sec = nsec64;
+
+			if (sec > 0
+			    && xtime.tv_nsec + nsec + tick_nsec < NSEC_PER_SEC) {
+				/* Make sure xtime.tv_nsec exceeds a second when
+				   checked (in update_wall_time). */
+				sec--;
+				nsec += NSEC_PER_SEC;
+			}
+			xtime.tv_sec += sec;
+			xtime.tv_nsec += nsec;
+			touch_softlockup_watchdog();
+			ticks = 1;
+		}
+		debugger_jiffies = 0;
+#endif
 		update_wall_time(ticks);
 	}
 	calc_load(ticks);

Index: 2.6.14-nlkd/arch/i386/kernel/timers/common.c
===================================================================
@@ -149,7 +149,7 @@ unsigned long read_timer_tsc(void)
 
 
 /* calculate cpu_khz */
-void init_cpu_khz(void)
+unsigned long init_cpu_khz(void)
 {
 	if (cpu_has_tsc) {
 		unsigned long tsc_quotient = calibrate_tsc();

@@ -166,7 +166,9 @@ void init_cpu_khz(void)
 				printk("Detected %u.%03u MHz processor.\n",
 					cpu_khz / 1000, cpu_khz % 1000);
 			}
+			return tsc_quotient;
 		}
 	}
+	return 0;
 }
 

Index: 2.6.14-nlkd/arch/i386/kernel/timers/timer_hpet.c
===================================================================
@@ -99,7 +99,7 @@ static unsigned long get_offset_hpet(voi
 static void mark_offset_hpet(void)
 {
 	unsigned long long this_offset, last_offset;
-	unsigned long offset;
+	unsigned long offset, lost_ticks = 0;
 
 	write_seqlock(&monotonic_lock);
 	last_offset = ((unsigned long long)last_tsc_high<<32)|last_tsc_low;

@@ -109,14 +109,34 @@ static void mark_offset_hpet(void)
 		offset = hpet_readl(HPET_T0_CMP) - hpet_tick;
 	else
 		offset = hpet_readl(HPET_COUNTER);
-	if (unlikely(((offset - hpet_last) >= (2*hpet_tick)) && (hpet_last != 0))) {
-		int lost_ticks = ((offset - hpet_last) / hpet_tick) - 1;
-		jiffies_64 += lost_ticks;
+	this_offset = ((unsigned long long)last_tsc_high<<32)|last_tsc_low;
+	if (unlikely(debugger_jiffies)) {
+		unsigned long long delta = this_offset - last_offset;
+		unsigned long lo, hi, lo1;
+
+#ifndef CONFIG_SMP
+		/* When the TSC gets reset during AP startup, the code below would
+		   incorrectly think we lost a huge amount of ticks. */
+		if (unlikely((long long)delta < 0))
+			delta = this_offset;
+#endif
+		ASM_MUL64_REG(hi /* dummy */, lo1, tsc_hpet_quotient, (unsigned long)delta);
+		ASM_MUL64_REG(lo, hi, tsc_hpet_quotient, (unsigned long)(delta >> 32));
+		__asm__("addl %3, %1\n\t"
+		        "adcl $0, %2"
+		        : "=A" (delta)
+		        : "a" (lo), "d" (hi), "rm" (lo1)
+		        : "flags");
+		do_div(delta, hpet_tick);
+		lost_ticks = delta;
 	}
+	else if (unlikely(((offset - hpet_last) >= (2*hpet_tick)) && (hpet_last != 0)))
+		lost_ticks = ((offset - hpet_last) / hpet_tick);
+	if (lost_ticks)
+		jiffies_64 += lost_ticks - 1;
 	hpet_last = offset;
 
 	/* update the monotonic base value */
-	this_offset = ((unsigned long long)last_tsc_high<<32)|last_tsc_low;
 	monotonic_base += cycles_2_ns(this_offset - last_offset);
 	write_sequnlock(&monotonic_lock);
 }

98 lines not on this page · raw message

150 lines not on this page · raw message

Index: 2.6.14-nlkd/include/asm-i386/timer.h
===================================================================
@@ -57,7 +57,7 @@ extern struct init_timer_opts timer_cycl
 
 extern unsigned long calibrate_tsc(void);
 extern unsigned long read_timer_tsc(void);
-extern void init_cpu_khz(void);
+extern unsigned long init_cpu_khz(void);
 extern int recalibrate_cpu_khz(void);
 #ifdef CONFIG_HPET_TIMER
 extern struct init_timer_opts timer_hpet_init;

Index: 2.6.14-nlkd/arch/x86_64/kernel/pmtimer.c
===================================================================
@@ -52,22 +52,53 @@ int pmtimer_mark_offset(void)
 {
 	static int first_run = 1;
 	unsigned long tsc;
-	u32 lost;
-
+	u32 lost, delta;
 	u32 tick = inl(pmtmr_ioport);
-	u32 delta;
+#ifdef debugger_jiffies
+# define delta64 delta
+#else
+	u64 delta64;
+#endif
+
+	rdtscll(tsc);
 
-	delta = cyc2us((tick - last_pmtmr_tick) & ACPI_PM_MASK);
+	if (likely(!debugger_jiffies)) {
+		delta = cyc2us((tick - last_pmtmr_tick) & ACPI_PM_MASK);
+#ifndef delta64
+		delta64 = delta;
+	}
+	else {
+# ifdef CONFIG_SMP
+		/* When the TSC gets reset during AP startup, the code below would
+		   incorrectly think we lost a huge amount of ticks. */
+		if (unlikely((long long)(tsc - vxtime.last_tsc) < 0))
+			delta64 = tsc;
+		else
+# endif
+			delta64 = tsc - vxtime.last_tsc;
+		__asm__("mulq %1\n\t"
+		        "shrdq $32, %%rdx, %0"
+		        : "+a" (delta64)
+		        : "rm" (vxtime.tsc_quot)
+		        : "rdx");
+		delta = (u32)delta64 ? (u32)delta64 - 1 : (offset_delay = 0);
+#endif
+	}
 
 	last_pmtmr_tick = tick;
 	monotonic_base += delta * NSEC_PER_USEC;
 
-	delta += offset_delay;
-
-	lost = delta / (USEC_PER_SEC / HZ);
-	offset_delay = delta % (USEC_PER_SEC / HZ);
+	if (likely(delta == delta64)) {
+		delta += offset_delay;
+		lost = delta / (USEC_PER_SEC / HZ);
+		offset_delay = delta % (USEC_PER_SEC / HZ);
+	}
+	else {
+		lost = (u32)(delta64 / (USEC_PER_SEC / HZ));
+		offset_delay = 0;
+	}
+#undef delta64
 
-	rdtscll(tsc);
 	vxtime.last_tsc = tsc - offset_delay * cpu_khz;
 
 	/* don't calculate delay for first run,

372 lines not on this page · raw message

Index: 2.6.14-nlkd/include/asm-x86_64/vsyscall.h
===================================================================
@@ -29,7 +29,10 @@ enum vsyscall_num {
 
 struct vxtime_data {
 	long hpet_address;	/* HPET base address */
-	int last;
+	union {
+		int last;
+		long last64;
+	};
 	unsigned long last_tsc;
 	long quot;
 	long tsc_quot;

@@ -37,7 +40,9 @@ struct vxtime_data {
 };
 
 #define hpet_readl(a)           readl((void *)fix_to_virt(FIX_HPET_BASE) + a)
+#define hpet_readq(a)           readq((void *)fix_to_virt(FIX_HPET_BASE) + a)
 #define hpet_writel(d,a)        writel(d, (void *)fix_to_virt(FIX_HPET_BASE) + a)
+#define hpet_writeq(d,a)        writeq(d, (void *)fix_to_virt(FIX_HPET_BASE) + a)
 
 /* vsyscall space (readonly) */
 extern struct vxtime_data __vxtime;

Index: 2.6.14-nlkd/arch/x86_64/kernel/asm-offsets.c
===================================================================
@@ -64,5 +64,10 @@ int main(void)
 	DEFINE(pbe_address, offsetof(struct pbe, address));
 	DEFINE(pbe_orig_address, offsetof(struct pbe, orig_address));
 	DEFINE(pbe_next, offsetof(struct pbe, next));
+	BLANK();
+	DEFINE(EXCEPTION_STACK_SIZE, EXCEPTION_STKSZ);
+#if DEBUG_STKSZ > EXCEPTION_STKSZ
+	DEFINE(DEBUG_IST, DEBUG_STACK);
+#endif
 	return 0;
 }

Index: 2.6.14-nlkd/arch/x86_64/kernel/setup64.c
===================================================================
@@ -146,7 +146,7 @@ void pda_init(int cpu)
 	pda->irqstackptr += IRQSTACKSIZE-64;
 } 
 
-char boot_exception_stacks[N_EXCEPTION_STACKS * EXCEPTION_STKSZ] 
+char boot_exception_stacks[(N_EXCEPTION_STACKS - 2) * EXCEPTION_STKSZ + DEBUG_STKSZ]
 __attribute__((section(".bss.page_aligned")));
 
 /* May not be marked __init: used by software suspend */

@@ -243,13 +243,27 @@ void __cpuinit cpu_init (void)
 	 */
 	for (v = 0; v < N_EXCEPTION_STACKS; v++) {
 		if (cpu) {
-			estacks = (char *)__get_free_pages(GFP_ATOMIC, 
-						   EXCEPTION_STACK_ORDER);
+			static const unsigned int order[N_EXCEPTION_STACKS] = {
+				[0 ... N_EXCEPTION_STACKS - 1] = EXCEPTION_STACK_ORDER,
+				[DEBUG_STACK - 1] = DEBUG_STACK_ORDER
+			};
+
+			estacks = (char *)__get_free_pages(GFP_ATOMIC, order[v]);
 			if (!estacks)
 				panic("Cannot allocate exception stack %ld %d\n",
 				      v, cpu); 
 		}
-		estacks += EXCEPTION_STKSZ;
+		switch (v + 1) {
+#if DEBUG_STKSZ > EXCEPTION_STKSZ
+		case DEBUG_STACK:
+			cpu_pda[cpu].debugstack = (unsigned long)estacks;
+			estacks += DEBUG_STKSZ;
+			break;
+#endif
+		default:
+			estacks += EXCEPTION_STKSZ;
+			break;
+		}
 		t->ist[v] = (unsigned long)estacks;
 	}
 

Index: 2.6.14-nlkd/arch/x86_64/kernel/traps.c
===================================================================
@@ -121,19 +121,31 @@ int printk_address(unsigned long address
 static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack,
 					unsigned *usedp, const char **idp)
 {
-	static const char ids[N_EXCEPTION_STACKS][8] = {
+	static char ids[][8] = {
 		[DEBUG_STACK - 1] = "#DB",
 		[NMI_STACK - 1] = "NMI",
 		[DOUBLEFAULT_STACK - 1] = "#DF",
 		[STACKFAULT_STACK - 1] = "#SS",
 		[MCE_STACK - 1] = "#MC",
+#if DEBUG_STKSZ > EXCEPTION_STKSZ
+		[N_EXCEPTION_STACKS ... N_EXCEPTION_STACKS + DEBUG_STKSZ / EXCEPTION_STKSZ - 2] = "#DB[?]"
+#endif
 	};
 	unsigned k;
 
 	for (k = 0; k < N_EXCEPTION_STACKS; k++) {
 		unsigned long end;
 
-		end = per_cpu(init_tss, cpu).ist[k];
+		switch (k + 1) {
+#if DEBUG_STKSZ > EXCEPTION_STKSZ
+		case DEBUG_STACK:
+			end = cpu_pda[cpu].debugstack + DEBUG_STKSZ;
+			break;
+#endif
+		default:
+			end = per_cpu(init_tss, cpu).ist[k];
+			break;
+		}
 		if (stack >= end)
 			continue;
 		if (stack >= end - EXCEPTION_STKSZ) {

@@ -143,6 +155,22 @@ static unsigned long *in_exception_stack
 			*idp = ids[k];
 			return (unsigned long *)end;
 		}
+#if DEBUG_STKSZ > EXCEPTION_STKSZ
+		if (k == DEBUG_STACK - 1 && stack >= end - DEBUG_STKSZ) {
+			unsigned j = N_EXCEPTION_STACKS - 1;
+
+			do {
+				++j;
+				end -= EXCEPTION_STKSZ;
+				ids[j][4] = '1' + (j - N_EXCEPTION_STACKS);
+			} while (stack < end - EXCEPTION_STKSZ);
+			if (*usedp & (1U << j))
+				break;
+			*usedp |= 1U << j;
+			*idp = ids[j];
+			return (unsigned long *)end;
+		}
+#endif
 	}
 	return NULL;
 }

@@ -652,6 +680,7 @@ asmlinkage void default_do_nmi(struct pt
 		io_check_error(reason, regs);
 }
 
+/* runs on IST stack. */
 asmlinkage void __kprobes do_int3(struct pt_regs * regs, long error_code)
 {
 	if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) == NOTIFY_STOP) {

@@ -942,7 +971,7 @@ void __init trap_init(void)
 	set_intr_gate(0,&divide_error);
 	set_intr_gate_ist(1,&debug,DEBUG_STACK);
 	set_intr_gate_ist(2,&nmi,NMI_STACK);
-	set_system_gate(3,&int3);
+	set_system_gate_ist(3,&int3,DEBUG_STACK); /* int3 can be called from all */
 	set_system_gate(4,&overflow);	/* int4 can be called from all */
 	set_intr_gate(5,&bounds);
 	set_intr_gate(6,&invalid_op);

Index: 2.6.14-nlkd/include/asm-x86_64/desc.h
===================================================================
@@ -111,6 +111,11 @@ static inline void set_system_gate(int n
 	_set_gate(&idt_table[nr], GATE_INTERRUPT, (unsigned long) func, 3, 0); 
 } 
 
+static inline void set_system_gate_ist(int nr, void *func, unsigned ist)
+{
+	_set_gate(&idt_table[nr], GATE_INTERRUPT, (unsigned long) func, 3, ist);
+}
+
 static inline void set_tssldt_descriptor(void *ptr, unsigned long tss, unsigned type, 
 					 unsigned size) 
 { 

Index: 2.6.14-nlkd/include/asm-x86_64/pda.h
===================================================================
@@ -12,6 +12,10 @@ struct x8664_pda {
 	unsigned long data_offset;	/* Per cpu data offset from linker address */
 	unsigned long kernelstack;  /* top of kernel stack for current */ 
 	unsigned long oldrsp; 	    /* user rsp for system call */
+#ifdef CONFIG_NLKD /* Better would be DEBUG_STKSZ > EXCEPTION_STKSZ, but
+                      this file can't include processor.h. */
+	unsigned long debugstack;   /* #DB/#BP stack. */
+#endif
         int irqcount;		    /* Irq nesting counter. Starts with -1 */  	
 	int cpunumber;		    /* Logical CPU number */
 	char *irqstackptr;	/* top of irqstack */

Index: 2.6.14-nlkd/include/asm-x86_64/processor.h
===================================================================
@@ -271,8 +271,10 @@ struct thread_struct {
 #define DEBUG_STACK 4 
 #define MCE_STACK 5
 #define N_EXCEPTION_STACKS 5  /* hw limit: 7 */
-#define EXCEPTION_STKSZ (PAGE_SIZE << EXCEPTION_STACK_ORDER)
 #define EXCEPTION_STACK_ORDER 0 
+#define EXCEPTION_STKSZ (PAGE_SIZE << EXCEPTION_STACK_ORDER)
+#define DEBUG_STACK_ORDER EXCEPTION_STACK_ORDER
+#define DEBUG_STKSZ (PAGE_SIZE << DEBUG_STACK_ORDER)
 
 #define start_thread(regs,new_rip,new_rsp) do { \
 	asm volatile("movl %0,%%fs; movl %0,%%es; movl %0,%%ds": :"r" (0));	 \

Index: 2.6.14-nlkd/include/asm-x86_64/calling.h
===================================================================
@@ -158,6 +158,17 @@
 	RESTORE_ARGS 0,\addskip
 	.endm
 
+#ifndef MODULE
+	.macro STACK_INVALID from, to
+# ifdef CONFIG_NLKD
+	.section __stack_invalid, "a", @progbits
+	.align 8
+	.quad \from, \to
+	.previous
+# endif
+ 	.endm
+#endif
+
 	.macro icebp
 	.byte 0xf1
 	.endm

Index: 2.6.14-nlkd/arch/x86_64/kernel/process.c
===================================================================
@@ -505,6 +505,10 @@ struct task_struct *__switch_to(struct t
 	int cpu = smp_processor_id();  
 	struct tss_struct *tss = &per_cpu(init_tss, cpu);
 
+	/* This must be done prior to examining TS_USEDFPU in the outgoing
+	   task (and perhaps setting CR0.TS), so that math_state_restore()
+	   will set TS_USEDFPU in the correct (new) task afterwards. */
+	write_pda(pcurrent, next_p);
 	unlazy_fpu(prev_p);
 
 	/*

@@ -564,11 +568,10 @@ struct task_struct *__switch_to(struct t
 	}
 
 	/* 
-	 * Switch the PDA context.
+	 * Switch the remaining PDA context.
 	 */
 	prev->userrsp = read_pda(oldrsp); 
 	write_pda(oldrsp, next->userrsp); 
-	write_pda(pcurrent, next_p); 
 	write_pda(kernelstack, (unsigned long)next_p->thread_info + THREAD_SIZE - PDA_STACKOFFSET);
 
 	/*

Index: 2.6.14-nlkd/arch/x86_64/ia32/ptrace32.c
===================================================================
@@ -88,22 +88,32 @@ static int putreg32(struct task_struct *
 		return -EIO;
 
 	case offsetof(struct user32, u_debugreg[0]):
+		if (enable_debugreg(child, 0, val) < 0)
+			return -EBUSY;
 		child->thread.debugreg0 = val;
 		break;
 
 	case offsetof(struct user32, u_debugreg[1]):
+		if (enable_debugreg(child, 1, val) < 0)
+			return -EBUSY;
 		child->thread.debugreg1 = val;
 		break;
 
 	case offsetof(struct user32, u_debugreg[2]):
+		if (enable_debugreg(child, 2, val) < 0)
+			return -EBUSY;
 		child->thread.debugreg2 = val;
 		break;
 
 	case offsetof(struct user32, u_debugreg[3]):
+		if (enable_debugreg(child, 3, val) < 0)
+			return -EBUSY;
 		child->thread.debugreg3 = val;
 		break;
 
 	case offsetof(struct user32, u_debugreg[6]):
+		if (enable_debugreg(child, 6, val) < 0)
+			return -EBUSY;
 		child->thread.debugreg6 = val;
 		break; 
 

@@ -112,8 +122,10 @@ static int putreg32(struct task_struct *
 		/* See arch/i386/kernel/ptrace.c for an explanation of
 		 * this awkward check.*/
 		for(i=0; i<4; i++)
-			if ((0x5454 >> ((val >> (16 + 4*i)) & 0xf)) & 1)
+			if ((0x5554 >> ((val >> (16 + 4*i)) & 0xf)) & 1)
 			       return -EIO;
+		if (enable_debugreg(child, 7, val) < 0)
+			return -EBUSY;
 		child->thread.debugreg7 = val; 
 		break; 
 		    

Index: 2.6.14-nlkd/arch/x86_64/kernel/process.c
===================================================================
@@ -50,6 +50,7 @@
 #include <asm/desc.h>
 #include <asm/proto.h>
 #include <asm/ia32.h>
+#include <asm/debugreg.h>
 
 asmlinkage extern void ret_from_fork(void);
 

@@ -346,6 +347,10 @@ void exit_thread(void)
 		t->io_bitmap_max = 0;
 		put_cpu();
 	}
+	if (me->thread.debugreg7) {
+		enable_debugreg(me, 7, 0);
+		me->thread.debugreg7 = 0;
+	}
 }
 
 void flush_thread(void)

@@ -363,6 +368,8 @@ void flush_thread(void)
 	if (t->flags & _TIF_ABI_PENDING)
 		t->flags ^= (_TIF_ABI_PENDING | _TIF_IA32);
 
+	if (tsk->thread.debugreg7)
+		enable_debugreg(tsk, 7, 0);
 	tsk->thread.debugreg0 = 0;
 	tsk->thread.debugreg1 = 0;
 	tsk->thread.debugreg2 = 0;

@@ -477,6 +484,13 @@ int copy_thread(int nr, unsigned long cl
 		if (err) 
 			goto out;
 	}
+
+	if (me->thread.debugreg7) {
+		p->thread.debugreg7 = 0;
+		enable_debugreg(p, 7, me->thread.debugreg7);
+		p->thread.debugreg7 = me->thread.debugreg7;
+	}
+
 	err = 0;
 out:
 	if (err && p->thread.io_bitmap_ptr) {

@@ -489,7 +503,7 @@ out:
 /*
  * This special macro can be used to load a debugging register
  */
-#define loaddebug(thread,r) set_debug(thread->debugreg ## r, r)
+#define loaddebug(thread,r) set_debugreg(thread->debugreg ## r, r)
 
 /*
  *	switch_to(x,y) should switch tasks from x to y.

Index: 2.6.14-nlkd/arch/x86_64/kernel/ptrace.c
===================================================================
@@ -433,42 +433,66 @@ asmlinkage long sys_ptrace(long request,
 		/* Disallows to set a breakpoint into the vsyscall */
 		case offsetof(struct user, u_debugreg[0]):
 			if (data >= TASK_SIZE_OF(child) - dsize) break;
+			if (enable_debugreg(child, 0, data) < 0) {
+				ret = -EBUSY;
+				break;
+			}
 			child->thread.debugreg0 = data;
 			ret = 0;
 			break;
 		case offsetof(struct user, u_debugreg[1]):
 			if (data >= TASK_SIZE_OF(child) - dsize) break;
+			if (enable_debugreg(child, 1, data) < 0) {
+				ret = -EBUSY;
+				break;
+			}
 			child->thread.debugreg1 = data;
 			ret = 0;
 			break;
 		case offsetof(struct user, u_debugreg[2]):
 			if (data >= TASK_SIZE_OF(child) - dsize) break;
+			if (enable_debugreg(child, 2, data) < 0) {
+				ret = -EBUSY;
+				break;
+			}
 			child->thread.debugreg2 = data;
 			ret = 0;
 			break;
 		case offsetof(struct user, u_debugreg[3]):
 			if (data >= TASK_SIZE_OF(child) - dsize) break;
+			if (enable_debugreg(child, 3, data) < 0) {
+				ret = -EBUSY;
+				break;
+			}
 			child->thread.debugreg3 = data;
 			ret = 0;
 			break;
 		case offsetof(struct user, u_debugreg[6]):
-				  if (data >> 32)
+			if (data >> 32)
 				break; 
+			if (enable_debugreg(child, 6, data) < 0) {
+				ret = -EBUSY;
+				break;
+			}
 			child->thread.debugreg6 = data;
 			ret = 0;
 			break;
 		case offsetof(struct user, u_debugreg[7]):
 			/* See arch/i386/kernel/ptrace.c for an explanation of
 			 * this awkward check.*/
-				  data &= ~DR_CONTROL_RESERVED;
-				  for(i=0; i<4; i++)
-					  if ((0x5454 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
+			data &= ~DR_CONTROL_RESERVED;
+			for(i=0; i<4; i++)
+				if ((0x5554 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
 					break;
 			if (i == 4) {
+				if (enable_debugreg(child, 7, data) < 0) {
+					ret = -EBUSY;
+					break;
+				}
 				child->thread.debugreg7 = data;
-			  ret = 0;
-		  }
-		  break;
+				ret = 0;
+			}
+			break;
 		}
 		break;
 	}

Index: 2.6.14-nlkd/arch/x86_64/kernel/setup64.c
===================================================================
@@ -25,6 +25,7 @@
 #include <asm/percpu.h>
 #include <asm/proto.h>
 #include <asm/sections.h>
+#include <asm/debugreg.h>
 
 char x86_boot_params[BOOT_PARAM_SIZE] __initdata = {0,};
 

@@ -289,12 +290,12 @@ void __cpuinit cpu_init (void)
 	 * Clear all 6 debug registers:
 	 */
 
-	set_debug(0UL, 0);
-	set_debug(0UL, 1);
-	set_debug(0UL, 2);
-	set_debug(0UL, 3);
-	set_debug(0UL, 6);
-	set_debug(0UL, 7);
+	set_debugreg(0UL, 0);
+	set_debugreg(0UL, 1);
+	set_debugreg(0UL, 2);
+	set_debugreg(0UL, 3);
+	set_debugreg(0UL, 6);
+	set_debugreg(0UL, 7);
 
 	fpu_init(); 
 }

Index: 2.6.14-nlkd/arch/x86_64/kernel/signal.c
===================================================================
@@ -29,6 +29,7 @@
 #include <asm/i387.h>
 #include <asm/proto.h>
 #include <asm/ia32_unistd.h>
+#include <asm/debugreg.h>
 
 /* #define DEBUG_SIG 1 */
 

@@ -439,8 +440,8 @@ int do_signal(struct pt_regs *regs, sigs
 		 * have been cleared if the watchpoint triggered
 		 * inside the kernel.
 		 */
-		if (current->thread.debugreg7)
-			set_debugreg(current->thread.debugreg7, 7);
+		if (unlikely(current->thread.debugreg7))
+			restore_debugreg();
 
 		/* Whee!  Actually deliver the signal.  */
 		return handle_signal(signr, &info, &ka, oldset, regs);

Index: 2.6.14-nlkd/arch/x86_64/kernel/suspend.c
===================================================================
@@ -13,6 +13,7 @@
 #include <asm/proto.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
+#include <asm/debugreg.h>
 
 struct saved_context saved_context;
 

Index: 2.6.14-nlkd/arch/x86_64/kernel/traps.c
===================================================================
@@ -784,7 +784,7 @@ asmlinkage void __kprobes do_debug(struc
 	info.si_addr = (void __user *)regs->rip;
 	force_sig_info(SIGTRAP, &info, tsk);	
 clear_dr7:
-	set_debugreg(0UL, 7);
+	disable_debugreg(regs, 7);
 	return;
 
 clear_TF_reenable:

54 lines not on this page · raw message

Index: 2.6.14-nlkd/include/asm-x86_64/processor.h
===================================================================
@@ -271,9 +271,22 @@ struct thread_struct {
 #define DEBUG_STACK 4 
 #define MCE_STACK 5
 #define N_EXCEPTION_STACKS 5  /* hw limit: 7 */
+
+#ifndef CONFIG_NLKD
 #define EXCEPTION_STACK_ORDER 0 
+#else
+#define EXCEPTION_STACK_ORDER 1
+#endif
 #define EXCEPTION_STKSZ (PAGE_SIZE << EXCEPTION_STACK_ORDER)
+
+#ifndef CONFIG_NLKD
 #define DEBUG_STACK_ORDER EXCEPTION_STACK_ORDER
+#else
+/* debug and breakpoint exceptions may nest 4 levels deep (minimum
+   requirement is 3 levels if handling exceptions from the debugger
+   should be possible, else 2 levels) */
+#define DEBUG_STACK_ORDER (EXCEPTION_STACK_ORDER + 2)
+#endif
 #define DEBUG_STKSZ (PAGE_SIZE << DEBUG_STACK_ORDER)
 
 #define start_thread(regs,new_rip,new_rsp) do { \

@@ -288,14 +301,6 @@ struct thread_struct {
 	set_fs(USER_DS);							 \
 } while(0) 
 
-#define get_debugreg(var, register)				\
-		__asm__("movq %%db" #register ", %0"		\
-			:"=r" (var))
-#define set_debugreg(value, register)			\
-		__asm__("movq %0,%%db" #register		\
-			: /* no output */			\
-			:"r" (value))
-
 struct task_struct;
 struct mm_struct;
 

Index: 2.6.14-nlkd/include/asm-x86_64/suspend.h
===================================================================
@@ -39,9 +39,7 @@ extern unsigned long saved_context_r12, 
 extern unsigned long saved_context_eflags;
 
 #define loaddebug(thread,register) \
-               __asm__("movq %0,%%db" #register  \
-                       : /* no output */ \
-                       :"r" ((thread)->debugreg##register))
+	set_debugreg((thread)->debugreg##register, register)
 
 extern void fix_processor_context(void);
 

Index: 2.6.14-nlkd/include/asm-x86_64/system.h
===================================================================
@@ -70,12 +70,6 @@ extern void load_gs_index(unsigned); 
 		".previous"			\
 		: :"r" (value), "r" (0))
 
-#define set_debug(value,register) \
-                __asm__("movq %0,%%db" #register  \
-		: /* no output */ \
-		:"r" ((unsigned long) value))
-
-
 #ifdef __KERNEL__
 struct alt_instr { 
 	__u8 *instr; 		/* original instruction */

Index: 2.6.14-nlkd/kernel/printk.c
===================================================================
@@ -1032,3 +1032,190 @@ int printk_ratelimit(void)
 				printk_ratelimit_burst);
 }
 EXPORT_SYMBOL(printk_ratelimit);
+
+#if defined(CONFIG_PRINTK) && defined(CONFIG_NLKD)
+# include <linux/ctype.h>
+# include <linux/nlkd.h>
+
+static int match(unsigned long start, unsigned long end, const char *pattern, size_t len)
+{
+	unsigned long stop;
+
+	start &= LOG_BUF_MASK;
+	stop = end &= LOG_BUF_MASK;
+	if (stop < start)
+		stop = log_buf_len;
+	for (;;) {
+		const char *p;
+
+		while (((end - start) & LOG_BUF_MASK) >= len
+		       && (p = memchr(log_buf + start, *pattern, stop - start)) != NULL) {
+			unsigned long where = p - log_buf;
+
+			if (len > stop - where
+			    ? !memcmp(p, pattern, stop - where)
+			      && !memcmp(p + (stop - where),
+			                 pattern + (stop - where),
+			                 len - (stop - where))
+			    : !memcmp(p, pattern, len))
+					return 1;
+			start = where + 1;
+		}
+		if (end >= start)
+			return 0;
+		start = 0;
+		stop = end;
+	}
+}
+
+static void do_mgrep(const char *pattern, long skip, long count)
+{
+	int backward = 1;
+	unsigned long line, cur;
+	size_t len = pattern ? strlen(pattern) : 0;
+
+	if (count == 0)
+		count = 5;
+	else if (count < 0) {
+		count = -count;
+		backward = 0;
+	}
+	if (skip < 0) {
+		skip = -skip;
+		backward = 0;
+	}
+#define LOG_IDX_MATCH(idx1, idx2) (!(((idx1) ^ (idx2)) & LOG_BUF_MASK))
+	if (backward) {
+		/* Search from end.  */
+		int end;
+
+		skip += count - 1;
+		line = log_end;
+		do {
+			for (cur = line - 1; !LOG_IDX_MATCH(cur, log_end) && LOG_BUF(cur) && LOG_BUF(cur) == '\n'; --cur)
+				;
+			for (; !(end = LOG_IDX_MATCH(cur, log_end) || !LOG_BUF(cur)) && LOG_BUF(cur) != '\n'; --cur)
+				;
+			if (len && !match(cur + 1, line, pattern, len))
+				++skip;
+			line = cur + 1;
+		} while (skip-- && !end);
+		if (++skip < count)
+			count -= skip;
+		else
+			count = 0;
+	}
+	else {
+		/* Search from start.  */
+		for (cur = LOG_BUF(log_end) ? log_end : 0; line = cur, skip; --skip) {
+			while (LOG_BUF(cur) != '\n')
+				if (!LOG_BUF(cur) || LOG_IDX_MATCH(++cur, log_end))
+					return;
+			while (LOG_BUF(cur) == '\n')
+				if (!LOG_BUF(cur) || LOG_IDX_MATCH(++cur, log_end))
+					return;
+			if (len && !match(line, cur, pattern, len))
+				++skip;
+		}
+	}
+	while (count) {
+		for (cur = line; LOG_BUF(cur) && LOG_BUF(cur) != '\n'; ++cur)
+			if (LOG_IDX_MATCH(cur + 1, 0)) {
+				for (cur = 0; LOG_BUF(cur) && LOG_BUF(cur) != '\n'; ++cur)
+					if (LOG_IDX_MATCH(cur + 1, line))
+						break;
+				break;
+			}
+		if(!len || match(line, cur, pattern, len)) {
+			if (cur < line) {
+				nlkdExtPrintf("%.*s", log_buf_len - (int)(line & LOG_BUF_MASK), &LOG_BUF(line));
+				nlkdExtPrintf("%.*s\n", (int)cur, log_buf);
+			}
+			else
+				nlkdExtPrintf("%.*s\n", (int)(cur - line), &LOG_BUF(line));
+			--count;
+		}
+		if (LOG_BUF(cur) != '\n')
+			break;
+		for (line = cur + 1; LOG_BUF(line) == '\n'; ++line)
+			;
+	}
+#undef LOG_IDX_MATCH
+}
+
+static char *skipComma(char *s) {
+	while (*s && isspace(*s))
+		++s;
+	if (*s == ';' || *s == ',')
+		++s;
+	while (*s && isspace(*s))
+		++s;
+	return s;
+}
+
+/*
+ * !dmesg [[<# to skip>;]<# of lines>]
+ */
+static void dbgxt_dmesg(void *pattern, const char *command) {
+	long skip = 0, count = 0;
+
+	if (!command)
+		return;
+	if (!pattern && *command == '?') {
+		nlkdExtOutputString("dmesg [[<# to skip>] <# of entries>]");
+		return;
+	}
+	if (*command) {
+		char *tail;
+
+		skip = simple_strtol(command, &tail, 0);
+		if (*(tail = skipComma(tail)))
+			count = simple_strtol(tail, NULL, 0);
+		else {
+			count = skip;
+			skip = 0;
+		}
+	}
+	do_mgrep(pattern, skip, count);
+}
+
+/*
+ * !mgrep <match string> [[<# to skip>];<# of lines>]
+ */
+static void dbgxt_mgrep(void *unused, const char *command) {
+	if (!command)
+		return;
+	if (!strcmp(command, "?")) {
+		nlkdExtOutputString("mgrep <match> [[<# to skip>] <# of entries>]");
+		return;
+	}
+	if (*command) {
+		char pattern[256], *dst;
+		char quote = strchr("\"\'", *command) != NULL ? *command++ : 0;
+
+		for (dst = pattern; *command && (quote ? *command != quote : !isspace(*command)); ++command)
+			if(dst < pattern + ARRAY_SIZE(pattern) - 1)
+				*dst++ = *command;
+		*dst = 0;
+		if (*command)
+			++command;
+		while (*command && isspace(*command))
+			++command;
+		dbgxt_dmesg((void *)pattern, command);
+	}
+}
+
+static THIS_MODULE_ID(printkModuleId);
+NLKD_EXTENSION(dmesg,
+	dbgxt_dmesg,
+	NULL,
+	printkModuleId,
+	"Display trace buffer records",
+	0);
+NLKD_EXTENSION(mgrep,
+	dbgxt_mgrep,
+	NULL,
+	printkModuleId,
+	"Grep trace buffer records",
+	0);
+#endif

Index: 2.6.14-nlkd/include/linux/epfs.h
===================================================================
@@ -0,0 +1,56 @@
+/*****************************************************************************
+ *
+ *   File Name:      epfs.h
+ *   Created by:     Jan Beulich
+ *   Date created:   28Apr2005
+ *
+ *   %version:       2 %
+ *   %derived_by:    jbeulich %
+ *   %date_modified: Mon Jun 27 04:48:22 2005 %
+ *
+ *****************************************************************************/
+/*****************************************************************************
+ *                                                                           *
+ * Copyright (c) 2005 Novell, Inc. All Rights Reserved.                      *
+ *                                                                           *
+ * This program is free software; you can redistribute it and/or             *
+ * modify it under the terms of version 2 of the GNU General Public License  *
+ * as published by the Free Software Foundation.                             *
+ *                                                                           *
+ * This program is distributed in the hope that it will be useful,           *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
+ * GNU General Public License for more details.                              *
+ *                                                                           *
+ * You should have received a copy of the GNU General Public License         *
+ * along with this program; if not, contact Novell, Inc.                     *
+ *                                                                           *
+ * To contact Novell about this file by physical or electronic mail,         *
+ * you may find current contact information at www.novell.com.               *
+ *                                                                           *
+ *****************************************************************************/
+/*****************************************************************************
+ *
+ *	File Description:
+ *
+ *****************************************************************************/
+#ifndef _LINUX_EPFS_H
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+
+#if defined(CONFIG_EARLY_PSEUDO_FS) && !defined(MODULE)
+# define EPFS_DECLARE(proto, retval) proto;
+#else
+# define EPFS_DECLARE(proto, retval) static inline proto { return retval; }
+#endif
+
+EPFS_DECLARE(int epfs_open(const char *name), -ENOSYS)
+EPFS_DECLARE(size_t epfs_get_size(int fd), ~(size_t)0)
+EPFS_DECLARE(size_t epfs_read(int fd, size_t pos, void *buf, size_t size), ~(size_t)0)
+EPFS_DECLARE(int epfs_close(int fd), -ENOSYS)
+
+#undef EPFS_DECLARE
+
+#endif /* _LINUX_EPFS_H */

151 lines not on this page · raw message

Index: 2.6.14-nlkd/include/asm-generic/bug.h
===================================================================
@@ -5,6 +5,44 @@
 #include <linux/config.h>
 
 #ifdef CONFIG_BUG
+
+# ifdef CONFIG_NLKD
+
+#  ifndef _LINUX_NLKD_H
+#   define _LINUX_NLKD_H
+#   include <linux/nlkd.h>
+#   undef _LINUX_NLKD_H
+#  endif
+
+#  ifdef HAVE_ARCH_BUG
+#   undef BUG
+#  else
+#   define HAVE_ARCH_BUG
+#  endif
+#  define BUG() nlkdAssert("BUG", __FILE__, __PRETTY_FUNCTION__, __LINE__)
+
+#  ifdef HAVE_ARCH_BUG_ON
+#   undef BUG_ON
+#  else
+#   define HAVE_ARCH_BUG_ON
+#  endif
+#  define BUG_ON(condition) (unlikely(condition) \
+		? nlkdAssert("!(" #condition ")", __FILE__, __PRETTY_FUNCTION__, __LINE__) \
+		: (void)0)
+
+#  ifdef HAVE_ARCH_WARN_ON
+#   undef WARN_ON
+#  else
+#   define HAVE_ARCH_WARN_ON
+#  endif
+#  define WARN_ON(condition) (unlikely(condition) \
+		? printk("Badness in %s at %s:%d\n", __PRETTY_FUNCTION__, __FILE__, __LINE__), \
+		  dump_stack(), \
+		  nlkdDebugEvent(DEBUG_EVENT_MESSAGE, #condition) \
+		: (void)0)
+
+# endif /* CONFIG_NLKD */
+
 #ifndef HAVE_ARCH_BUG
 #define BUG() do { \
 	printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__); \

Index: 2.6.14-nlkd/include/linux/sched.h
===================================================================
@@ -298,6 +298,10 @@ struct mm_struct {
 	/* Architecture-specific MM context */
 	mm_context_t context;
 
+#ifdef CONFIG_NLKD
+	struct cdeBPStruct_s *bpList;
+#endif
+
 	/* Token based thrashing protection. */
 	unsigned long swap_token_time;
 	char recent_pagein;

@@ -681,6 +685,10 @@ struct task_struct {
 
 	struct mm_struct *mm, *active_mm;
 
+#ifdef CONFIG_NLKD
+	struct cdeBPStruct_s *bpList;
+#endif
+
 /* task state */
 	struct linux_binfmt *binfmt;
 	long exit_state;

@@ -689,6 +697,9 @@ struct task_struct {
 	/* ??? */
 	unsigned long personality;
 	unsigned did_exec:1;
+#ifdef CONFIG_NLKD
+	unsigned kstep:1;         /* kernel-debugger single stepping this task */
+#endif
 	pid_t pid;
 	pid_t tgid;
 	/* 

Index: 2.6.14-nlkd/init/main.c
===================================================================
@@ -47,6 +47,7 @@
 #include <linux/rmap.h>
 #include <linux/mempolicy.h>
 #include <linux/key.h>
+#include <linux/nlkd.h>
 #include <net/sock.h>
 
 #include <asm/io.h>

@@ -482,6 +483,7 @@ asmlinkage void __init start_kernel(void
 	sort_main_extable();
 	trap_init();
 	kallsyms_early_init();
+	nlkd_init();
 	rcu_init();
 	init_IRQ();
 	pidhash_init();

@@ -709,6 +711,7 @@ static int init(void * unused)
 	 * we're essentially up and running. Get rid of the
 	 * initmem segments and start the user-mode stuff..
 	 */
+	nlkd_init_done();
 	kallsyms_init_done();
 	free_initmem();
 	unlock_kernel();

Index: 2.6.14-nlkd/kernel/exit.c
===================================================================
@@ -28,6 +28,7 @@
 #include <linux/cpuset.h>
 #include <linux/syscalls.h>
 #include <linux/signal.h>
+#include <linux/nlkd.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>

@@ -794,6 +795,7 @@ fastcall NORET_TYPE void do_exit(long co
 	struct task_struct *tsk = current;
 	int group_dead;
 
+	bp_list_clear(tsk);
 	profile_task_exit(tsk);
 
 	WARN_ON(atomic_read(&tsk->fs_excl));

Index: 2.6.14-nlkd/kernel/fork.c
===================================================================
@@ -42,6 +42,7 @@
 #include <linux/profile.h>
 #include <linux/rmap.h>
 #include <linux/acct.h>
+#include <linux/nlkd.h>
 
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>

@@ -337,6 +338,9 @@ static struct mm_struct * mm_init(struct
 
 	if (likely(!mm_alloc_pgd(mm))) {
 		mm->def_flags = 0;
+#if defined(CONFIG_CDE) || defined(CONFIG_CDE_MODULE)
+		mm->bpList = NULL;
+#endif
 		return mm;
 	}
 	free_mm(mm);

@@ -377,6 +381,7 @@ void fastcall __mmdrop(struct mm_struct 
 void mmput(struct mm_struct *mm)
 {
 	if (atomic_dec_and_test(&mm->mm_users)) {
+		bp_list_clear(mm);
 		exit_aio(mm);
 		exit_mmap(mm);
 		if (!list_empty(&mm->mmlist)) {

Index: 2.6.14-nlkd/kernel/power/swsusp.c
===================================================================
@@ -67,6 +67,7 @@
 #include <linux/highmem.h>
 #include <linux/bio.h>
 #include <linux/mount.h>
+#include <linux/nlkd.h>
 
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>

@@ -1044,6 +1045,7 @@ int swsusp_suspend(void)
 	/* Restore control flow magically appears here */
 	restore_processor_state();
 	BUG_ON (nr_copy_pages_check != nr_copy_pages);
+	bp_load();
 	restore_highmem();
 	device_power_up();
 	local_irq_enable();

@@ -1064,6 +1066,7 @@ int swsusp_resume(void)
          */
 	BUG_ON(!error);
 	restore_processor_state();
+	bp_load();
 	restore_highmem();
 	touch_softlockup_watchdog();
 	device_power_up();

Index: 2.6.14-nlkd/kernel/sched.c
===================================================================
@@ -47,6 +47,7 @@
 #include <linux/syscalls.h>
 #include <linux/times.h>
 #include <linux/acct.h>
+#include <linux/nlkd.h>
 #include <asm/tlb.h>
 
 #include <asm/unistd.h>

@@ -1568,12 +1569,17 @@ task_t * context_switch(runqueue_t *rq, 
 	struct mm_struct *mm = next->mm;
 	struct mm_struct *oldmm = prev->active_mm;
 
+	bp_list_disable(1, prev);
+
 	if (unlikely(!mm)) {
 		next->active_mm = oldmm;
 		atomic_inc(&oldmm->mm_count);
 		enter_lazy_tlb(oldmm, next);
-	} else
+	} else {
+		bp_list_disable(oldmm && oldmm != mm, oldmm);
 		switch_mm(oldmm, mm, next);
+		bp_list_enable(oldmm != mm, mm);
+	}
 
 	if (unlikely(!prev->mm)) {
 		prev->active_mm = NULL;

@@ -1584,6 +1590,8 @@ task_t * context_switch(runqueue_t *rq, 
 	/* Here we just switch the register state and the stack. */
 	switch_to(prev, next, prev);
 
+	bp_list_enable(1, current);
+
 	return prev;
 }
 

Index: 2.6.14-nlkd/arch/i386/kernel/cpu/common.c
===================================================================
@@ -7,6 +7,7 @@
 #include <linux/bootmem.h>
 #include <asm/semaphore.h>
 #include <asm/processor.h>
+#include <asm/debugreg.h>
 #include <asm/i387.h>
 #include <asm/msr.h>
 #include <asm/io.h>

Index: 2.6.14-nlkd/arch/i386/kernel/process.c
===================================================================
@@ -46,6 +46,7 @@
 #include <asm/io.h>
 #include <asm/ldt.h>
 #include <asm/processor.h>
+#include <asm/debugreg.h>
 #include <asm/i387.h>
 #include <asm/desc.h>
 #ifdef CONFIG_MATH_EMULATION

@@ -393,6 +394,10 @@ void exit_thread(void)
 		tss->io_bitmap_base = INVALID_IO_BITMAP_OFFSET;
 		put_cpu();
 	}
+	if (tsk->thread.debugreg[7]) {
+		enable_debugreg(tsk, 7, 0);
+		tsk->thread.debugreg[7] = 0;
+	}
 }
 
 void flush_thread(void)

@@ -406,6 +411,8 @@ void flush_thread(void)
 	 */
 	kprobe_flush_task(tsk);
 
+ 	if (tsk->thread.debugreg[7])
+		enable_debugreg(tsk, 7, 0);
 	memset(tsk->thread.debugreg, 0, sizeof(unsigned long)*8);
 	memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));	
 	/*

@@ -507,6 +514,12 @@ int copy_thread(int nr, unsigned long cl
 		desc->b = LDT_entry_b(&info);
 	}
 
+	if (tsk->thread.debugreg[7]) {
+		p->thread.debugreg[7] = 0;
+		enable_debugreg(p, 7, tsk->thread.debugreg[7]);
+		p->thread.debugreg[7] = tsk->thread.debugreg[7];
+	}
+
 	err = 0;
  out:
 	if (err && p->thread.io_bitmap_ptr) {

Index: 2.6.14-nlkd/arch/i386/kernel/ptrace.c
===================================================================
@@ -493,7 +493,7 @@ asmlinkage int sys_ptrace(long request, 
 			   *
 			   * Note that LENi == 0x10 is defined on x86_64 in long
 			   * mode (i.e. even for 32-bit userspace software, but
-			   * 64-bit kernel), so the x86_64 mask value is 0x5454.
+			   * 64-bit kernel), so the x86_64 mask value is 0x5554.
 			   * See the AMD manual no. 24593 (AMD64 System
 			   * Programming)*/
 

@@ -506,6 +506,11 @@ asmlinkage int sys_ptrace(long request, 
 
 			  addr -= (long) &dummy->u_debugreg;
 			  addr = addr >> 2;
+
+			  if (enable_debugreg(child, addr, data) < 0) {
+				  ret = -EBUSY;
+				  break;
+			  }
 			  child->thread.debugreg[addr] = data;
 			  ret = 0;
 		  }

Index: 2.6.14-nlkd/arch/i386/kernel/signal.c
===================================================================
@@ -25,6 +25,7 @@
 #include <asm/ucontext.h>
 #include <asm/uaccess.h>
 #include <asm/i387.h>
+#include <asm/debugreg.h>
 #include "sigframe.h"
 
 #define DEBUG_SIG 0

@@ -629,7 +630,7 @@ int fastcall do_signal(struct pt_regs *r
 		 * inside the kernel.
 		 */
 		if (unlikely(current->thread.debugreg[7])) {
-			set_debugreg(current->thread.debugreg[7], 7);
+			restore_debugreg();
 		}
 
 		/* Whee!  Actually deliver the signal.  */

Index: 2.6.14-nlkd/arch/i386/kernel/traps.c
===================================================================
@@ -774,7 +774,7 @@ fastcall void __kprobes do_debug(struct 
 	 * the signal is delivered.
 	 */
 clear_dr7:
-	set_debugreg(0, 7);
+	disable_debugreg(regs, 7);
 	return;
 
 debug_vm86: