-->
</sect1>
</chapter>
-<!-- Needs ksyms to list additional exported symbols, but no specific doc.
- docproc do not care about sgml commants.
-!Dkernel/ksyms.c
--->
</book>
_not_ exported using EXPORT_SYMBOL.
!D<filename> is used to name additional files to search for functions
-exported using EXPORT_SYMBOL. For example many symbols are only exported
-in kernel/ksyms.c, therefore kernel-api.sgml include this file with !D.
+exported using EXPORT_SYMBOL.
!F<filename> <function [functions...]> is replaced by the
documentation, in <filename>, for the functions listed.
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/init_task.h>
struct mm_struct init_mm = INIT_MM(init_mm);
struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_mm);
+EXPORT_SYMBOL(init_task);
+
union thread_union init_thread_union
__attribute__((section(".data.init_thread")))
= { INIT_THREAD_INFO(init_task) };
#include <linux/config.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel_stat.h>
#include <linux/signal.h>
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
void
free_irq(unsigned int irq, void *dev_id)
{
}
}
+EXPORT_SYMBOL(free_irq);
+
int
show_interrupts(struct seq_file *p, void *v)
{
return val;
}
+EXPORT_SYMBOL(probe_irq_on);
+
/*
* Return a mask of triggered interrupts (this
* can handle only legacy ISA interrupts).
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
#ifdef CONFIG_SMP
void synchronize_irq(unsigned int irq)
{
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
common_shutdown(LINUX_REBOOT_CMD_RESTART, restart_cmd);
}
+EXPORT_SYMBOL(machine_restart);
+
void
machine_halt(void)
{
common_shutdown(LINUX_REBOOT_CMD_HALT, NULL);
}
+EXPORT_SYMBOL(machine_halt);
+
void
machine_power_off(void)
{
common_shutdown(LINUX_REBOOT_CMD_POWER_OFF, NULL);
}
+EXPORT_SYMBOL(machine_power_off);
+
/* Used by sysrq-p, among others. I don't believe r9-r15 are ever
saved in the context it's used. */
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/kernel_stat.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/threads.h>
unsigned long cpu_present_mask;
cpumask_t cpu_online_map;
+EXPORT_SYMBOL(cpu_online_map);
+
/* cpus reported in the hwrpb */
static unsigned long hwrpb_cpu_present_mask __initdata = 0;
*/
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
extern unsigned long wall_jiffies; /* kernel/timer.c */
static int set_rtc_mmss(unsigned long);
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int
do_settimeofday(struct timespec *tv)
{
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
/*
* In order to set the CMOS clock precisely, set_rtc_mmss has to be
show_stack(NULL, NULL);
}
+EXPORT_SYMBOL(dump_stack);
+
void
die_if_kernel(char * str, struct pt_regs *regs, long err, unsigned long *r9_15)
{
* Rick Gorton <rick.gorton@alpha-processor.com>
*/
+#include <linux/module.h>
#include <linux/string.h>
#include <asm/byteorder.h>
return result;
}
+EXPORT_SYMBOL(csum_partial);
+
/*
* this routine is used for miscellaneous IP-like checksums, mainly
* in icmp.c
* linux/arch/arm/kernel/init_task.c
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/init.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial thread structure.
*
* All other task structs will be allocated on slabs in fork.c
*/
struct task_struct init_task = INIT_TASK(init_task);
+
+EXPORT_SYMBOL(init_task);
*/
#include <linux/config.h>
#include <linux/kernel_stat.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
/**
* free_irq - free an interrupt
* @irq: Interrupt line to free
}
}
+EXPORT_SYMBOL(free_irq);
+
static DECLARE_MUTEX(probe_sem);
/* Start the interrupt probing. Unlike other architectures,
return irqs;
}
+EXPORT_SYMBOL(probe_irq_on);
+
unsigned int probe_irq_mask(unsigned long irqs)
{
unsigned int mask = 0, i;
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
void __init init_irq_proc(void)
{
}
hlt_counter++;
}
+EXPORT_SYMBOL(disable_hlt);
+
void enable_hlt(void)
{
hlt_counter--;
}
+EXPORT_SYMBOL(enable_hlt);
+
static int __init nohlt_setup(char *__unused)
{
hlt_counter = 1;
{
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
if (pm_power_off)
pm_power_off();
}
+EXPORT_SYMBOL(machine_power_off);
+
void machine_restart(char * __unused)
{
/*
while (1);
}
+EXPORT_SYMBOL(machine_restart);
+
void show_regs(struct pt_regs * regs)
{
unsigned long flags;
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
extern unsigned long wall_jiffies;
/* this needs a better home */
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, sec = tv->tv_sec;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
static struct irqaction timer_irq = {
.name = "timer",
.flags = SA_INTERRUPT,
#endif
}
+EXPORT_SYMBOL(dump_stack);
+
void show_stack(struct task_struct *tsk, unsigned long *sp)
{
unsigned long fp;
*
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/init.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial thread structure.
*
* All other task structs will be allocated on slabs in fork.c
*/
struct task_struct init_task = INIT_TASK(init_task);
+
+EXPORT_SYMBOL(init_task);
* Naturally it's not a 1:1 relation, but there are similarities.
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/ptrace.h>
#include <linux/kernel_stat.h>
#include <linux/signal.h>
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
/**
* free_irq - free an interrupt
* @irq: Interrupt line to free
spin_unlock_irqrestore(&irq_controller_lock, flags);
}
+EXPORT_SYMBOL(free_irq);
+
/* Start the interrupt probing. Unlike other architectures,
* we don't return a mask of interrupts from probe_irq_on,
* but return the number of interrupts enabled for the probe.
return irqs;
}
+EXPORT_SYMBOL(probe_irq_on);
+
/*
* Possible return values:
* >= 0 - interrupt number
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
void __init init_irq_proc(void)
{
}
#include <stdarg.h>
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
hlt_counter++;
}
+EXPORT_SYMBOL(disable_hlt);
+
void enable_hlt(void)
{
hlt_counter--;
}
+EXPORT_SYMBOL(enable_hlt);
+
static int __init nohlt_setup(char *__unused)
{
hlt_counter = 1;
leds_event(led_halted);
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
leds_event(led_halted);
pm_power_off();
}
+EXPORT_SYMBOL(machine_power_off);
+
void machine_restart(char * __unused)
{
/*
while (1);
}
+EXPORT_SYMBOL(machine_restart);
+
void show_regs(struct pt_regs * regs)
{
unsigned long flags;
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
extern unsigned long wall_jiffies;
/* this needs a better home */
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
do_timer(regs);
dump_mem("Stack: ", sp, 8192+(unsigned long)tsk->thread_info);
}
+EXPORT_SYMBOL(dump_stack);
+
void dump_stack(void)
{
#ifdef CONFIG_DEBUG_ERRORS
*/
#include <net/checksum.h>
+#include <net/module.h>
#undef PROFILE_CHECKSUM
BITOFF;
return(sum);
}
+
+EXPORT_SYMBOL(csum_partial);
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/ptrace.h>
#include <linux/kernel_stat.h>
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int
probe_irq_off(unsigned long x)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
/*
* Initial irq handlers.
*/
kfree(action);
return retval;
}
+
+EXPORT_SYMBOL(request_irq);
void free_irq(unsigned int irq, void *dev_id)
{
printk("Trying to free free IRQ%d\n",irq);
}
+EXPORT_SYMBOL(free_irq);
+
void weird_irq(void)
{
local_irq_disable();
#include <asm/atomic.h>
#include <asm/pgtable.h>
#include <asm/uaccess.h>
+#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/fs_struct.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial thread structure.
*
*/
struct task_struct init_task = INIT_TASK(init_task);
-
+EXPORT_SYMBOL(init_task);
/*
* The hlt_counter, disable_hlt and enable_hlt is just here as a hook if
hlt_counter++;
}
+EXPORT_SYMBOL(disable_hlt);
+
void enable_hlt(void)
{
hlt_counter--;
}
+
+EXPORT_SYMBOL(enable_hlt);
/*
* The following aren't currently used.
hard_reset_now();
}
+EXPORT_SYMBOL(machine_restart);
+
/*
* Similar to machine_power_off, but don't shut off power. Add code
* here to freeze the system for e.g. post-mortem debug purpose when
{
}
+EXPORT_SYMBOL(machine_halt);
+
/* If or when software power-off is implemented, add code here. */
void machine_power_off(void)
{
}
+EXPORT_SYMBOL(machine_power_off);
+
/*
* When a process does an "exec", machine state like FPU and debug
* registers need to be reset. This is a hook function for that.
#include <asm/rtc.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/param.h>
#include <linux/jiffies.h>
#include <linux/bcd.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
int have_rtc; /* used to remember if we have an RTC or not */;
#define TICK_SIZE tick
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
unsigned long flags;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
/*
* BUG: This routine does not handle hour overflow properly; it just
show_stack(NULL, NULL);
}
+EXPORT_SYMBOL(dump_stack);
+
void __init
trap_init(void)
{
* linux/arch/h8300/kernel/init_task.c
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial task structure.
*
__asm__(".align 4");
struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_task);
/*
* Initial thread structure.
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
__asm__("jmp @@0");
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt(void)
{
local_irq_disable();
for (;;);
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
local_irq_disable();
for (;;);
}
+EXPORT_SYMBOL(machine_power_off);
+
void show_regs(struct pt_regs * regs)
{
printk("\n");
#include <linux/config.h> /* CONFIG_HEARTBEAT */
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64;
+EXPORT_SYMBOL(jiffies_64);
+
static inline void do_profile (unsigned long pc)
{
if (prof_buffer && current->pid) {
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
write_sequnlock_irq(&xtime_lock);
return 0;
}
+
+EXPORT_SYMBOL(do_settimeofday);
of the assembly has to go. */
#include <net/checksum.h>
+#include <net/module.h>
static inline unsigned short from32to16(unsigned long x)
{
return result;
}
+EXPORT_SYMBOL(csum_partial);
+
/*
* this routine is used for miscellaneous IP-like checksums, mainly
* in icmp.c
* Copyright 1999 D. Jeff Dionne <jeff@rt-control.com>
*/
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
return 0;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
if (irq >= NR_IRQS) {
}
}
+EXPORT_SYMBOL(free_irq);
+
/*
* Do we need these probe functions on the m68k?
*/
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off (unsigned long irqs)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
void enable_irq(unsigned int irq)
{
if (irq >= EXT_IRQ0 && irq <= EXT_IRQ5) {
* Copyright 1999 D. Jeff Dionne <jeff@rt-control.com>
*/
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
return 0;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
if (irq >= NR_IRQS)
}
}
+EXPORT_SYMBOL(free_irq);
+
unsigned long probe_irq_on (void)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off (unsigned long irqs)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
void enable_irq(unsigned int irq)
{
if (irq >= EXT_IRQ0 && irq <= EXT_IRQ15)
#if defined(CONFIG_X86_SPEEDSTEP_SMI) || defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
EXPORT_SYMBOL(ist_info);
#endif
+
+EXPORT_SYMBOL(csum_partial);
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial thread structure.
*
*/
struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_task);
+
/*
* per-CPU TSS segments. Threads are completely 'soft' on Linux,
* no more per-task TSS's. The TSS size is kept cacheline-aligned
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/ioport.h>
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
/**
* free_irq - free an interrupt
* @irq: Interrupt line to free
}
}
+EXPORT_SYMBOL(free_irq);
+
/*
* IRQ autodetection code..
*
return val;
}
+EXPORT_SYMBOL(probe_irq_on);
+
/*
* Return a mask of triggered interrupts (this
* can handle only legacy ISA interrupts).
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
/* this was setup_x86_irq but it seems pretty generic */
int setup_irq(unsigned int irq, struct irqaction * new)
{
hlt_counter++;
}
+EXPORT_SYMBOL(disable_hlt);
+
void enable_hlt(void)
{
hlt_counter--;
}
+EXPORT_SYMBOL(enable_hlt);
+
/*
* We use this if we don't have any better
* idle routine..
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/interrupt.h>
machine_real_restart(jump_to_bios, sizeof(jump_to_bios));
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt(void)
{
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
if (pm_power_off)
pm_power_off();
}
+EXPORT_SYMBOL(machine_power_off);
+
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
unsigned long cpu_khz; /* Detected as we calibrate the TSC */
extern unsigned long wall_jiffies;
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, sec = tv->tv_sec;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
static int set_rtc_mmss(unsigned long nowtime)
{
int retval;
show_trace(current, &stack);
}
+EXPORT_SYMBOL(dump_stack);
+
void show_registers(struct pt_regs *regs)
{
int i;
-
+#include <linux/module.h>
#include <linux/smp.h>
#include <linux/delay.h>
#include <linux/platform.h>
outb(PIIX4_RESET_VAL, PIIX4_RESET_PORT);
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_power_off(void)
{
unsigned short pm_status;
outl(PIIX_SPECIAL_STOP, 0xCFC);
}
+EXPORT_SYMBOL(machine_power_off);
+
void machine_halt(void)
{
}
+
+EXPORT_SYMBOL(machine_halt);
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
}
}
+EXPORT_SYMBOL(machine_restart);
+
void
mca_nmi_hook(void)
{
machine_power_off();
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
if (pm_power_off)
pm_power_off();
}
+
+EXPORT_SYMBOL(machine_power_off);
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/kernel.h>
pte_t *kmap_pte;
pgprot_t kmap_prot;
+EXPORT_SYMBOL(kmap_prot);
+EXPORT_SYMBOL(kmap_pte);
+
#define kmap_get_fixmap_pte(vaddr) \
pte_offset_kernel(pmd_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr))
#include <linux/init.h>
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial task structure.
*
.task = INIT_TASK(init_task_mem.s.task),
.thread_info = INIT_THREAD_INFO(init_task_mem.s.task)
}};
+
+EXPORT_SYMBOL(init_task);
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/ioport.h>
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
/**
* free_irq - free an interrupt
* @irq: Interrupt line to free
}
}
+EXPORT_SYMBOL(free_irq);
+
/*
* IRQ autodetection code..
*
return val;
}
+EXPORT_SYMBOL(probe_irq_on);
+
/**
* probe_irq_mask - scan a bitmap of interrupt lines
* @val: mask of interrupts to consider
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
int setup_irq(unsigned int irq, struct irqaction * new)
{
int shared = 0;
show_stack(NULL, NULL);
}
+EXPORT_SYMBOL(dump_stack);
+
void
show_regs (struct pt_regs *regs)
{
#include <linux/init.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/profile.h>
#include <linux/sched.h>
#include <linux/time.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
#define TIME_KEEPER_ID 0 /* smp_processor_id() of time-keeper */
#ifdef CONFIG_IA64_DEBUG_IRQ
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
void
do_gettimeofday (struct timeval *tv)
{
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
/*
* The profiling function is SMP safe. (nothing can mess
* around with "current", and the profiling counters are
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/kernel_stat.h>
return mach_request_irq(irq, handler, flags, devname, dev_id);
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
mach_free_irq(irq, dev_id);
}
+EXPORT_SYMBOL(free_irq);
+
int sys_request_irq(unsigned int irq,
irqreturn_t (*handler)(int, void *, struct pt_regs *),
unsigned long flags, const char *devname, void *dev_id)
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off (unsigned long irqs)
{
#ifdef CONFIG_Q40
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
static void dummy_enable_irq(unsigned int irq)
{
printk("calling uninitialized enable_irq()\n");
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
union thread_union init_thread_union
__attribute__((section(".data.init_task"), aligned(THREAD_SIZE)))
= { INIT_THREAD_INFO(init_task) };
/* initial task structure */
struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_task);
asmlinkage void ret_from_fork(void);
for (;;);
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt(void)
{
if (mach_halt)
for (;;);
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
if (mach_power_off)
for (;;);
}
+EXPORT_SYMBOL(machine_power_off);
+
void show_regs(struct pt_regs * regs)
{
printk("\n");
#include <linux/config.h> /* CONFIG_HEARTBEAT */
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
static inline int set_rtc_mmss(unsigned long nowtime)
{
if (mach_set_clock_mmss)
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, sec = tv->tv_sec;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
/*
* Scheduler clock - returns current time in ns units.
*/
show_trace(&stack);
}
+EXPORT_SYMBOL(dump_stack);
+
void bad_super_trap (struct frame *fp)
{
console_verbose();
* linux/arch/m68knommu/kernel/init_task.c
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial task structure.
*
__asm__(".align 4");
struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_task);
/*
* Initial thread structure.
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/kernel.h>
for (;;);
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt(void)
{
if (mach_halt)
for (;;);
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
if (mach_power_off)
for (;;);
}
+EXPORT_SYMBOL(machine_power_off);
+
void show_regs(struct pt_regs * regs)
{
printk("\n");
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
extern unsigned long wall_jiffies;
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, sec = tv->tv_sec;
write_sequnlock_irq(&xtime_lock);
return 0;
}
+
+EXPORT_SYMBOL(do_settimeofday);
of the assembly has to go. */
#include <net/checksum.h>
+#include <net/module.h>
static inline unsigned short from32to16(unsigned long x)
{
return result;
}
+EXPORT_SYMBOL(csum_partial);
+
/*
* this routine is used for miscellaneous IP-like checksums, mainly
* in icmp.c
* for more details.
*/
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/sched.h>
return 0;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
if (irq >= NR_IRQS) {
irq_list[irq].devname = NULL;
}
+EXPORT_SYMBOL(free_irq);
+
int sys_request_irq(unsigned int irq,
irqreturn_t (*handler)(int, void *, struct pt_regs *),
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off (unsigned long irqs)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
asmlinkage void process_int(unsigned long vec, struct pt_regs *fp)
{
if (vec >= VEC_INT1 && vec <= VEC_INT7) {
* Copyright 1999 D. Jeff Dionne <jeff@rt-control.com>
*/
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
return 0;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
if (irq >= NR_IRQS) {
IMR |= 1<<irq;
}
+EXPORT_SYMBOL(free_irq);
+
int show_interrupts(struct seq_file *p, void *v)
{
int i;
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
return 0;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
if (irq >= INTERNAL_IRQS) {
*(volatile unsigned long *)0xfffff304 |= 1<<irq;
}
+EXPORT_SYMBOL(free_irq);
+
#if 0
/*
* Enable/disable a particular machine specific interrupt source.
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/kernel_stat.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/types.h>
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
struct irqaction * action, **p;
printk("Trying to free free IRQ%d\n",irq);
}
+EXPORT_SYMBOL(free_irq);
+
unsigned long probe_irq_on (void)
{
/* TODO */
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off (unsigned long irqs)
{
/* TODO */
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
static void write_err_interrupt(int irq, void *dev_id, struct pt_regs * regs)
{
#include <linux/errno.h>
#include <linux/init.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
} while (read_seqretry(&xtime_lock, seq));
}
+EXPORT_SYMBOL(do_gettimeofday);
+
void do_settimeofday(struct timeval *tv)
{
write_seqlock_irq(&xtime_lock);
time_esterror = NTP_PHASE_LIMIT;
write_sequnlock_irq(&xtime_lock);
}
+
+EXPORT_SYMBOL(do_settimeofday);
*
*/
#include <linux/bcd.h>
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/init.h>
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
void do_settimeofday(struct timeval *tv)
{
write_seqlock_irq(&xtime_lock);
write_sequnlock_irq(&xtime_lock);
}
+EXPORT_SYMBOL(do_settimeofday);
+
/*
* In order to set the CMOS clock precisely, set_rtc_mmss has to be
* called 500 ms after the second nowtime has started, because when
*/
#include <linux/init.h>
#include <linux/kernel_stat.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
void do_settimeofday(struct timeval *tv)
{
write_seqlock_irq(&xtime_lock);
write_sequnlock_irq(&xtime_lock);
}
+EXPORT_SYMBOL(do_settimeofday);
+
/*
* There are a lot of conceptually broken versions of the MIPS timer interrupt
* handler floating around. This one is rather different, but the algorithm
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init_task.h>
#include <linux/fs.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial thread structure.
*
* All other task structs will be allocated on slabs in fork.c
*/
struct task_struct init_task = INIT_TASK(init_task);
+
+EXPORT_SYMBOL(init_task);
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
/**
* free_irq - free an interrupt
* @irq: Interrupt line to free
}
}
+EXPORT_SYMBOL(free_irq);
+
/*
* IRQ autodetection code..
*
return val;
}
+EXPORT_SYMBOL(probe_irq_on);
+
/*
* Return a mask of triggered interrupts (this
* can handle only legacy ISA interrupts).
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
/* this was setup_x86_irq but it seems pretty generic */
int setup_irq(unsigned int irq, struct irqaction * new)
{
* Copyright (C) 2001 MIPS Technologies, Inc.
*/
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/reboot.h>
#include <asm/reboot.h>
_machine_restart(command);
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt(void)
{
_machine_halt();
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
_machine_power_off();
}
+
+EXPORT_SYMBOL(machine_power_off);
int __cpu_number_map[NR_CPUS];
int __cpu_logical_map[NR_CPUS];
+EXPORT_SYMBOL(cpu_online_map);
+
/* These are defined by the board-specific code. */
/*
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
/*
* forward reference
*/
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, sec = tv->tv_sec;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
/*
* Gettimeoffset routines. These routines returns the time duration
show_trace(current, &stack);
}
+EXPORT_SYMBOL(dump_stack);
+
void show_code(unsigned int *pc)
{
long i;
*/
#include <linux/config.h>
#include <linux/init.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/kernel.h>
pte_t *kmap_pte;
pgprot_t kmap_prot;
+EXPORT_SYMBOL(kmap_prot);
+EXPORT_SYMBOL(kmap_pte);
+
#define kmap_get_fixmap_pte(vaddr) \
pte_offset_kernel(pmd_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr))
*/
#include <linux/config.h>
#include <linux/init.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/kernel.h>
pte_t *kmap_pte;
pgprot_t kmap_prot;
+EXPORT_SYMBOL(kmap_prot);
+EXPORT_SYMBOL(kmap_pte);
+
#define kmap_get_fixmap_pte(vaddr) \
pte_offset_kernel(pmd_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr))
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/seq_file.h>
#include <asm/pdc.h>
int split_tlb;
int dcache_stride;
int icache_stride;
+EXPORT_SYMBOL(dcache_stride);
struct pdc_cache_info cache_info;
#ifndef CONFIG_PA20
flush_instruction_cache_local();
flush_data_cache_local();
}
+EXPORT_SYMBOL(flush_cache_all_local);
/* flushes EVERYTHING (tlb & cache) */
flush_cache_all();
flush_tlb_all();
}
+EXPORT_SYMBOL(flush_all_caches);
void
update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t pte)
}
}
+EXPORT_SYMBOL(__flush_dcache_page);
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial task structure.
*
*
* All other task structs will be allocated on slabs in fork.c
*/
+EXPORT_SYMBOL(init_task);
+
__asm__(".data");
struct task_struct init_task = INIT_TASK(init_task);
#include <linux/eisa.h>
#include <linux/errno.h>
#include <linux/init.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/types.h>
#include <linux/ioport.h>
return 0;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
struct irqaction *action, **p;
printk(KERN_ERR "Trying to free free IRQ%d\n",irq);
}
+EXPORT_SYMBOL(free_irq);
+
#ifdef CONFIG_SMP
void synchronize_irq(unsigned int irqnum)
return val;
}
+EXPORT_SYMBOL(probe_irq_on);
+
/*
* Return the one interrupt that triggered (this can
* handle any interrupt source).
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
unsigned int probe_irq_mask(unsigned long irqs)
{
return 0;
EXPORT_SYMBOL(flush_kernel_dcache_page);
EXPORT_SYMBOL(flush_data_cache_local);
EXPORT_SYMBOL(flush_kernel_icache_range_asm);
-EXPORT_SYMBOL(__flush_dcache_page);
EXPORT_SYMBOL(flush_all_caches);
EXPORT_SYMBOL(dcache_stride);
EXPORT_SYMBOL(flush_cache_all_local);
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/personality.h>
#include <linux/ptrace.h>
#include <linux/sched.h>
hlt_counter++;
}
+EXPORT_SYMBOL(disable_hlt);
+
void enable_hlt(void)
{
hlt_counter--;
}
+EXPORT_SYMBOL(enable_hlt);
+
void default_idle(void)
{
barrier();
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt(void)
{
/*
*/
}
+EXPORT_SYMBOL(machine_halt);
+
/*
* This routine is called from sys_reboot to actually turn off the
KERN_EMERG "Please power this system off now.");
}
+EXPORT_SYMBOL(machine_power_off);
+
/*
* Create a kernel thread
#include <linux/slab.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/interrupt.h>
cpumask_t cpu_online_map = CPU_MASK_NONE; /* Bitmap of online CPUs */
#define IS_LOGGED_IN(cpunum) (cpu_isset(cpunum, cpu_online_map))
+EXPORT_SYMBOL(cpu_online_map);
+
int smp_num_cpus = 1;
int smp_threads_ready = 0;
unsigned long cache_decay_ticks;
static int max_cpus = -1; /* Command line */
cpumask_t cpu_present_mask;
+EXPORT_SYMBOL(cpu_present_mask);
+
struct smp_call_struct {
void (*func) (void *info);
void *info;
*/
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
/* xtime and wall_jiffies keep wall-clock time */
extern unsigned long wall_jiffies;
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int
do_settimeofday (struct timespec *tv)
{
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
/*
* XXX: We can do better than this.
* Returns nanoseconds
show_trace(current, &stack);
}
+EXPORT_SYMBOL(dump_stack);
#ifndef __LP64__
static int kstack_depth_to_print = 64 * 4;
return result;
}
+EXPORT_SYMBOL(csum_partial);
+
/*
* copy while checksumming, otherwise like csum_partial
*/
*/
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/threads.h>
#include <linux/kernel_stat.h>
#include <linux/signal.h>
return;
}
+EXPORT_SYMBOL(free_irq);
+
int request_irq(unsigned int irq,
irqreturn_t (*handler)(int, void *, struct pt_regs *),
unsigned long irqflags, const char * devname, void *dev_id)
return 0;
}
+EXPORT_SYMBOL(request_irq);
+
/*
* Generic enable/disable code: this just calls
* down into the PIC-specific version for the actual
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off (unsigned long irqs)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
unsigned int probe_irq_mask(unsigned long irqs)
{
return 0;
show_stack(current, NULL);
}
+EXPORT_SYMBOL(dump_stack);
+
void show_stack(struct task_struct *tsk, unsigned long *stack)
{
unsigned long sp, stack_top, prev_sp, ret;
ppc_md.restart(cmd);
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_power_off(void)
{
ppc_md.power_off();
}
+EXPORT_SYMBOL(machine_power_off);
+
void machine_halt(void)
{
ppc_md.halt();
}
+EXPORT_SYMBOL(machine_halt);
+
void (*pm_power_off)(void) = machine_power_off;
#ifdef CONFIG_TAU
#include <linux/config.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/smp_lock.h>
int smp_hw_index[NR_CPUS];
struct thread_info *secondary_ti;
+EXPORT_SYMBOL(cpu_online_map);
+
/* SMP operations for this machine */
static struct smp_ops_t *smp_ops;
/* XXX false sharing with below? */
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
unsigned long disarm_decr[NR_CPUS];
extern struct timezone sys_tz;
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, new_sec = tv->tv_sec;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
/* This function is only called on the boot processor */
void __init time_init(void)
{
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#ifdef CONFIG_HIGHMEM
pte_t *kmap_pte;
pgprot_t kmap_prot;
+
+EXPORT_SYMBOL(kmap_prot);
+EXPORT_SYMBOL(kmap_pte);
#endif
void MMU_init(void);
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/stddef.h>
#include <linux/init.h>
#include <linux/sched.h>
}
#endif
}
+
+EXPORT_SYMBOL(request_irq);
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial thread structure.
*
* All other task structs will be allocated on slabs in fork.c
*/
struct task_struct init_task = INIT_TASK(init_task);
+
+EXPORT_SYMBOL(init_task);
*/
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/threads.h>
#include <linux/kernel_stat.h>
#include <linux/signal.h>
return 0;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
request_irq(irq, NULL, 0, NULL, dev_id);
}
+EXPORT_SYMBOL(free_irq);
+
/*
* Generic enable/disable code: this just calls
* down into the PIC-specific version for the actual
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off (unsigned long irqs)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
unsigned int probe_irq_mask(unsigned long irqs)
{
return 0;
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/kernel.h>
show_stack(current, (unsigned long *)_get_SP());
}
+EXPORT_SYMBOL(dump_stack);
+
void show_trace_task(struct task_struct *tsk)
{
show_stack(tsk, (unsigned long *)tsk->thread.ksp);
{
ppc_md.restart(cmd);
}
+
+EXPORT_SYMBOL(machine_restart);
void machine_power_off(void)
{
ppc_md.power_off();
}
+
+EXPORT_SYMBOL(machine_power_off);
void machine_halt(void)
{
ppc_md.halt();
}
+EXPORT_SYMBOL(machine_halt);
+
unsigned long ppc_proc_freq;
unsigned long ppc_tb_freq;
#include <linux/config.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/smp_lock.h>
/* initialised so it doesn't end up in bss */
cpumask_t cpu_online_map = CPU_MASK_NONE;
+EXPORT_SYMBOL(cpu_online_map);
+
static struct smp_ops_t *smp_ops;
static volatile unsigned int cpu_callin_map[NR_CPUS];
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
/* keep track of when we need to update the rtc */
time_t last_rtc_update;
extern int piranha_simulator;
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, new_sec = tv->tv_sec;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
/*
* This function is a copy of the architecture independent function
* but which calls do_settimeofday rather than setting the xtime
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial thread structure.
*
*/
struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_task);
*/
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
_machine_restart(command);
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt(void)
{
_machine_halt();
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
_machine_power_off();
}
+EXPORT_SYMBOL(machine_power_off);
+
/*
* Setup function called from init/main.c just after the banner
* was printed.
cpumask_t cpu_possible_map;
unsigned long cache_decay_ticks = 0;
+EXPORT_SYMBOL(cpu_online_map);
+
/*
* Reboot, halt and power_off routines for SMP.
*/
*/
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
static ext_int_info_t ext_int_info_timer;
static u64 init_timer_cc;
static u64 jiffies_timer_cc;
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, sec = tv->tv_sec;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
#ifndef CONFIG_ARCH_S390X
static inline __u32
show_stack(0, 0);
}
+EXPORT_SYMBOL(dump_stack);
+
void show_registers(struct pt_regs *regs)
{
mm_segment_t old_fs;
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial thread structure.
*
* All other task structs will be allocated on slabs in fork.c
*/
struct task_struct init_task = INIT_TASK(init_task);
+
+EXPORT_SYMBOL(init_task);
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/ptrace.h>
#include <linux/errno.h>
#include <linux/kernel_stat.h>
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
irq_desc_t *desc;
}
}
+EXPORT_SYMBOL(free_irq);
+
static DECLARE_MUTEX(probe_sem);
/*
return val;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off(unsigned long val)
{
int i, irq_found, nr_irqs;
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
int setup_irq(unsigned int irq, struct irqaction * new)
{
int shared = 0;
* This file handles the architecture-dependent parts of process handling..
*/
+#include <linux/module.h>
#include <linux/unistd.h>
#include <linux/mm.h>
#include <linux/elfcore.h>
hlt_counter++;
}
+EXPORT_SYMBOL(disable_hlt);
+
void enable_hlt(void)
{
hlt_counter--;
}
+EXPORT_SYMBOL(enable_hlt);
+
void default_idle(void)
{
/* endless idle loop with no priority at all */
"mov.l @%1, %0" : : "r" (0x10000000), "r" (0x80000001));
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt(void)
{
while (1)
asm volatile("sleep" : : : "memory");
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
}
+EXPORT_SYMBOL(machine_power_off);
+
void show_regs(struct pt_regs * regs)
{
printk("\n");
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
/* XXX: Can we initialize this in a routine somewhere? Dreamcast doesn't want
* these routines anywhere... */
#ifdef CONFIG_SH_RTC
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, sec = tv->tv_sec;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
/* last time the RTC clock got updated */
static long last_rtc_update;
show_stack(NULL, NULL);
}
+EXPORT_SYMBOL(dump_stack);
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init_task.h>
struct mm_struct init_mm = INIT_MM(init_mm);
struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_mm);
+EXPORT_SYMBOL(init_task);
+
/* .text section in head.S is aligned at 8k boundary and this gets linked
* right after that so that the init_thread_union is aligned properly as well.
* If this is not aligned on a 8k boundry, then you should change code
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
#include <linux/errno.h>
restore_flags(flags);
}
+EXPORT_SYMBOL(free_irq);
+
#ifdef CONFIG_SMP
/* Who has the global irq brlock */
return 0;
}
+EXPORT_SYMBOL(request_irq);
+
/* We really don't need these at all on the Sparc. We only have
* stubs here because they are exported to modules.
*/
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off(unsigned long mask)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
/* djhr
* This could probably be made indirect too and assigned in the CPU
* bits of the code. That would be much nicer I think and would also
#include <stdarg.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
panic("Halt failed!");
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_restart(char * cmd)
{
char *p;
panic("Reboot failed!");
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_power_off(void)
{
#ifdef CONFIG_SUN_AUXIO
machine_halt();
}
+EXPORT_SYMBOL(machine_power_off);
+
static spinlock_t sparc_backtrace_lock = SPIN_LOCK_UNLOCKED;
void __show_backtrace(unsigned long fp)
EXPORT_SYMBOL(svr4_getcontext);
EXPORT_SYMBOL(_sigpause_common);
-/* Should really be in linux/kernel/ksyms.c */
EXPORT_SYMBOL(dump_thread);
/* prom symbols */
*/
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
spinlock_t rtc_lock = SPIN_LOCK_UNLOCKED;
enum sparc_clock_type sp_clock_typ;
spinlock_t mostek_lock = SPIN_LOCK_UNLOCKED;
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
int ret;
return ret;
}
+EXPORT_SYMBOL(do_settimeofday);
+
static int sbus_do_settimeofday(struct timespec *tv)
{
time_t wtm_sec, sec = tv->tv_sec;
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/kernel.h>
pte_t *kmap_pte;
pgprot_t kmap_prot;
+EXPORT_SYMBOL(kmap_prot);
+EXPORT_SYMBOL(kmap_pte);
+
/* These are set in {srmmu,sun4c}_paging_init() */
unsigned long fix_kmap_begin;
unsigned long fix_kmap_end;
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/* .text section in head.S is aligned at 2 page boundary and this gets linked
* right after that so that the init_thread_union is aligned properly as well.
* We really don't need this special alignment like the Intel does, but
*
* All other task structs will be allocated on slabs in fork.c
*/
+EXPORT_SYMBOL(init_task);
+
__asm__(".data");
struct task_struct init_task = INIT_TASK(init_task);
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
#include <linux/errno.h>
return -ENOMEM;
}
+EXPORT_SYMBOL(request_irq);
+
void free_irq(unsigned int irq, void *dev_id)
{
struct irqaction *action;
spin_unlock_irqrestore(&irq_action_lock, flags);
}
+EXPORT_SYMBOL(free_irq);
+
#ifdef CONFIG_SMP
void synchronize_irq(unsigned int irq)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off(unsigned long mask)
{
return 0;
}
+EXPORT_SYMBOL(probe_irq_off);
+
#ifdef CONFIG_SMP
static int retarget_one_irq(struct irqaction *p, int goal_cpu)
{
#include <linux/config.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/signal.h>
machine_halt();
}
+EXPORT_SYMBOL(machine_power_off);
+
#ifdef CONFIG_PCI
static int powerd(void *__unused)
{
#include <stdarg.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/kallsyms.h>
panic("Halt failed!");
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_alt_power_off(void)
{
if (!serial_console && prom_palette)
panic("Reboot failed!");
}
+EXPORT_SYMBOL(machine_restart);
+
static void show_regwindow32(struct pt_regs *regs)
{
struct reg_window32 *rw;
EXPORT_SYMBOL(_sigpause_common);
EXPORT_SYMBOL(verify_compat_iovec);
-/* Should really be in linux/kernel/ksyms.c */
EXPORT_SYMBOL(dump_thread);
EXPORT_SYMBOL(dump_fpu);
EXPORT_SYMBOL(pte_alloc_one_kernel);
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
static unsigned long mstk48t08_regs = 0UL;
static unsigned long mstk48t59_regs = 0UL;
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
/* Ok, my cute asm atomicity trick doesn't work anymore.
* There are just too many variables that need to be protected
* now (both members of xtime, wall_jiffies, et al.)
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
static int set_rtc_mmss(unsigned long nowtime)
{
int real_seconds, real_minutes, chip_minutes;
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/sched.h> /* for jiffies */
#include <linux/kernel.h>
#include <linux/kallsyms.h>
show_stack(current, ksp);
}
+EXPORT_SYMBOL(dump_stack);
+
void die_if_kernel(char *str, struct pt_regs *regs)
{
static int die_counter;
#include "asm/uaccess.h"
#include "linux/errno.h"
+#include "linux/module.h"
extern unsigned int arch_csum_partial(const char *buff, int len, int sum);
return(arch_csum_partial(buff, len, sum));
}
+EXPORT_SYMBOL(csum_partial);
+
unsigned int csum_partial_copy_to(const char *src, char *dst, int len,
int sum, int *err_ptr)
{
#include "linux/config.h"
#include "linux/mm.h"
+#include "linux/module.h"
#include "linux/sched.h"
#include "linux/init_task.h"
#include "linux/version.h"
static struct files_struct init_files = INIT_FILES;
static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial task structure.
*
struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_task);
+
/*
* Initial thread structure.
*
#include "linux/config.h"
#include "linux/kernel.h"
+#include "linux/module.h"
#include "linux/smp.h"
#include "linux/irq.h"
#include "linux/kernel_stat.h"
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
int um_request_irq(unsigned int irq, int fd, int type,
void (*handler)(int, void *, struct pt_regs *),
unsigned long irqflags, const char * devname,
}
}
+EXPORT_SYMBOL(free_irq);
+
/* These are initialized by sysctl_init, which is called from init/main.c */
static struct proc_dir_entry * root_irq_dir;
static struct proc_dir_entry * irq_dir [NR_IRQS];
return(0);
}
+EXPORT_SYMBOL(probe_irq_on);
+
int probe_irq_off(unsigned long val)
{
return(0);
}
+EXPORT_SYMBOL(probe_irq_off);
+
static unsigned int startup_SIGIO_irq(unsigned int irq)
{
return(0);
*/
#include "linux/config.h"
+#include "linux/module.h"
#include "linux/types.h"
#include "linux/mm.h"
#include "linux/fs.h"
pte_t *kmap_pte;
pgprot_t kmap_prot;
+EXPORT_SYMBOL(kmap_prot);
+EXPORT_SYMBOL(kmap_pte);
+
#define kmap_get_fixmap_pte(vaddr) \
pte_offset_kernel(pmd_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr))
panic("enable_hlt");
}
+EXPORT_SYMBOL(enable_hlt);
+
void disable_hlt(void)
{
panic("disable_hlt");
}
+EXPORT_SYMBOL(disable_hlt);
+
extern int signal_frame_size;
void *um_kmalloc(int size)
* Licensed under the GPL
*/
+#include "linux/module.h"
#include "linux/sched.h"
#include "user_util.h"
#include "kern_util.h"
CHOOSE_MODE(reboot_tt(), reboot_skas());
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_power_off(void)
{
do_uml_exitcalls();
CHOOSE_MODE(halt_tt(), halt_skas());
}
+EXPORT_SYMBOL(machine_power_off);
+
void machine_halt(void)
{
machine_power_off();
}
+EXPORT_SYMBOL(machine_halt);
+
/*
* Overrides for Emacs so that we follow Linus's tabbing style.
* Emacs will notice this stuff at the end of the file and automatically
#ifdef CONFIG_SMP
#include "linux/sched.h"
+#include "linux/module.h"
#include "linux/threads.h"
#include "linux/interrupt.h"
#include "linux/err.h"
/* CPU online map, set by smp_boot_cpus */
unsigned long cpu_online_map = cpumask_of_cpu(0);
+EXPORT_SYMBOL(cpu_online_map);
+
/* Per CPU bogomips and other parameters
* The only piece used here is the ipi pipe, which is set before SMP is
* started and never changed.
show_trace(&stack);
}
+EXPORT_SYMBOL(dump_stack);
+
void show_trace_task(struct task_struct *tsk)
{
unsigned long esp = PT_REGS_SP(&tsk->thread.regs);
#include <sys/time.h>
#include <signal.h>
#include <errno.h>
+#include "linux/module.h"
#include "user_util.h"
#include "kern_util.h"
#include "user.h"
time_unlock(flags);
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
struct timeval now;
time_unlock(flags);
}
+EXPORT_SYMBOL(do_settimeofday);
+
void idle_sleep(int secs)
{
struct timespec ts;
*/
#include "linux/kernel.h"
+#include "linux/module.h"
#include "linux/unistd.h"
#include "linux/stddef.h"
#include "linux/spinlock.h"
u64 jiffies_64;
+EXPORT_SYMBOL(jiffies_64);
+
int hz(void)
{
return(HZ);
#include <linux/config.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/init.h>
#include <linux/bootmem.h>
#include <linux/major.h>
asm ("jmp r0"); /* Jump to the reset vector. */
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt (void)
{
#ifdef CONFIG_RESET_GUARD
asm ("halt; nop; nop; nop; nop; nop");
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off (void)
{
machine_halt ();
}
+EXPORT_SYMBOL(machine_power_off);
+
/* Called before configuring an on-chip UART. */
void anna_uart_pre_configure (unsigned chan, unsigned cflags, unsigned baud)
{
#include <linux/config.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/init.h>
#include <linux/bootmem.h>
#include <linux/major.h>
asm ("jmp r0"); /* Jump to the reset vector. */
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt (void)
{
#ifdef CONFIG_RESET_GUARD
asm ("halt; nop; nop; nop; nop; nop");
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off (void)
{
machine_halt ();
}
+EXPORT_SYMBOL(machine_power_off);
+
/* Called before configuring an on-chip UART. */
void as85ep1_uart_pre_configure (unsigned chan, unsigned cflags, unsigned baud)
{
{
show_stack (0, 0);
}
+
+EXPORT_SYMBOL(dump_stack);
#include <linux/config.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/swap.h>
}
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_restart (char *__unused)
{
machine_halt ();
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_power_off (void)
{
machine_halt ();
}
+EXPORT_SYMBOL(machine_power_off);
+
\f
/* Interrupts */
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM (init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial task structure.
*
*/
struct task_struct init_task = INIT_TASK (init_task);
+EXPORT_SYMBOL(init_task);
+
/*
* Initial thread structure.
*
*/
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/irq.h>
#include <linux/init.h>
#include <linux/interrupt.h>
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
/**
* free_irq - free an interrupt
* @irq: Interrupt line to free
}
}
+EXPORT_SYMBOL(free_irq);
+
/*
* IRQ autodetection code..
*
return val;
}
+EXPORT_SYMBOL(probe_irq_on);
+
/*
* Return a mask of triggered interrupts (this
* can handle only legacy ISA interrupts).
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
/* this was setup_x86_irq but it seems pretty generic */
int setup_irq(unsigned int irq, struct irqaction * new)
{
#include <linux/init.h>
#include <linux/irq.h>
#include <linux/fs.h>
+#include <linux/module.h>
#include <asm/machdep.h>
#include <asm/v850e_uart.h>
asm ("jmp r0"); /* Jump to the reset vector. */
}
+EXPORT_SYMBOL(machine_restart);
+
/* This says `HALt.' in LEDese. */
static unsigned char halt_leds_msg[] = { 0x76, 0x77, 0x38, 0xF8 };
asm ("halt; nop; nop; nop; nop; nop");
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off (void)
{
machine_halt ();
}
+EXPORT_SYMBOL(machine_power_off);
+
\f
/* Animated LED display for timer tick. */
#include <linux/config.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/swap.h>
V850_SIM_SYSCALL (exit, 0);
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt (void)
{
V850_SIM_SYSCALL (write, 1, "HALT\n", 5);
V850_SIM_SYSCALL (exit, 0);
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off (void)
{
V850_SIM_SYSCALL (write, 1, "POWER OFF\n", 10);
V850_SIM_SYSCALL (exit, 0);
}
+EXPORT_SYMBOL(machine_power_off);
+
\f
/* Load data from a file called NAME into ram. The address and length
of the data image are returned in ADDR and LEN. */
#include <linux/config.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/swap.h>
for (;;) {}
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_restart (char *__unused)
{
machine_halt ();
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_power_off (void)
{
machine_halt ();
}
+
+EXPORT_SYMBOL(machine_power_off);
#include <linux/config.h> /* CONFIG_HEARTBEAT */
#include <linux/errno.h>
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/param.h>
#include <linux/string.h>
#include <linux/mm.h>
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
#define TICK_SIZE (tick_nsec / 1000)
static inline void do_profile (unsigned long pc)
tv->tv_usec = usec;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
int do_settimeofday(struct timespec *tv)
{
if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
static int timer_dev_id;
static struct irqaction timer_irqaction = {
timer_interrupt,
* $Id: checksum.c,v 1.1 2002/09/28 14:58:40 gerg Exp $
*/
#include <net/checksum.h>
+#include <linux/module.h>
#include <linux/types.h>
#include <asm/byteorder.h>
#include <asm/string.h>
return result;
}
+EXPORT_SYMBOL(csum_partial);
+
/*
* copy while checksumming, otherwise like csum_partial
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/init_task.h>
static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
struct mm_struct init_mm = INIT_MM(init_mm);
+EXPORT_SYMBOL(init_mm);
+
/*
* Initial task structure.
*
*/
struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_task);
/*
* per-CPU TSS segments. Threads are completely 'soft' on Linux,
* no more per-task TSS's. The TSS size is kept cacheline-aligned
#include <linux/config.h>
#include <linux/errno.h>
+#include <linux/module.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/ioport.h>
return retval;
}
+EXPORT_SYMBOL(request_irq);
+
/**
* free_irq - free an interrupt
* @irq: Interrupt line to free
}
}
+EXPORT_SYMBOL(free_irq);
+
/*
* IRQ autodetection code..
*
return val;
}
+EXPORT_SYMBOL(probe_irq_on);
+
/*
* Return a mask of triggered interrupts (this
* can handle only legacy ISA interrupts).
return irq_found;
}
+EXPORT_SYMBOL(probe_irq_off);
+
/* this was setup_x86_irq but it seems pretty generic */
int setup_irq(unsigned int irq, struct irqaction * new)
{
hlt_counter++;
}
+EXPORT_SYMBOL(disable_hlt);
+
void enable_hlt(void)
{
hlt_counter--;
}
+EXPORT_SYMBOL(enable_hlt);
+
/*
* We use this if we don't have any better
* idle routine..
/* Various gunk just to reboot the machine. */
+#include <linux/module.h>
#include <linux/reboot.h>
#include <linux/init.h>
#include <linux/smp.h>
}
}
+EXPORT_SYMBOL(machine_restart);
+
void machine_halt(void)
{
}
+EXPORT_SYMBOL(machine_halt);
+
void machine_power_off(void)
{
if (pm_power_off)
pm_power_off();
}
+
+EXPORT_SYMBOL(machine_power_off);
u64 jiffies_64 = INITIAL_JIFFIES;
+EXPORT_SYMBOL(jiffies_64);
+
extern int using_apic_timer;
spinlock_t rtc_lock = SPIN_LOCK_UNLOCKED;
tv->tv_usec = usec % 1000000;
}
+EXPORT_SYMBOL(do_gettimeofday);
+
/*
* settimeofday() first undoes the correction that gettimeofday would do
* on the time, and then saves it. This is ugly, but has been like this for
return 0;
}
+EXPORT_SYMBOL(do_settimeofday);
+
/*
* In order to set the CMOS clock precisely, set_rtc_mmss has to be called 500
* ms after the second nowtime has started, because when nowtime is written
show_trace(&dummy);
}
+EXPORT_SYMBOL(dump_stack);
+
void show_registers(struct pt_regs *regs)
{
int i;
return add32_with_carry(do_csum(buff, len), sum);
}
+EXPORT_SYMBOL(csum_partial);
+
/*
* this routine is used for miscellaneous IP-like checksums, mainly
* in icmp.c
return ret;
}
+EXPORT_SYMBOL(register_blkdev);
+
/* todo: make void - error printk here */
int unregister_blkdev(unsigned int major, const char *name)
{
return ret;
}
+EXPORT_SYMBOL(unregister_blkdev);
+
static struct kobj_map *bdev_map;
/*
kobj_map(bdev_map, dev, range, module, probe, lock, data);
}
+EXPORT_SYMBOL(blk_register_region);
+
void blk_unregister_region(dev_t dev, unsigned long range)
{
kobj_unmap(bdev_map, dev, range);
}
-EXPORT_SYMBOL(blk_register_region);
EXPORT_SYMBOL(blk_unregister_region);
static struct kobject *exact_match(dev_t dev, int *part, void *data)
return disk;
}
+EXPORT_SYMBOL(alloc_disk);
+
struct kobject *get_disk(struct gendisk *disk)
{
struct module *owner;
}
+EXPORT_SYMBOL(get_disk);
+
void put_disk(struct gendisk *disk)
{
if (disk)
kobject_put(&disk->kobj);
}
-EXPORT_SYMBOL(alloc_disk);
-EXPORT_SYMBOL(get_disk);
EXPORT_SYMBOL(put_disk);
void set_device_ro(struct block_device *bdev, int flag)
bdev->bd_disk->policy = flag;
}
+EXPORT_SYMBOL(set_device_ro);
+
void set_disk_ro(struct gendisk *disk, int flag)
{
int i;
if (disk->part[i]) disk->part[i]->policy = flag;
}
+EXPORT_SYMBOL(set_disk_ro);
+
int bdev_read_only(struct block_device *bdev)
{
if (!bdev)
return bdev->bd_disk->policy;
}
+EXPORT_SYMBOL(bdev_read_only);
+
int invalidate_partition(struct gendisk *disk, int index)
{
int res = 0;
return res;
}
-EXPORT_SYMBOL(bdev_read_only);
-EXPORT_SYMBOL(set_device_ro);
-EXPORT_SYMBOL(set_disk_ro);
EXPORT_SYMBOL(invalidate_partition);
unsigned long blk_max_low_pfn, blk_max_pfn;
+EXPORT_SYMBOL(blk_max_low_pfn);
+EXPORT_SYMBOL(blk_max_pfn);
+
/* Amount of time in which a process may batch requests */
#define BLK_BATCH_TIME (HZ/50UL)
q->prep_rq_fn = pfn;
}
+EXPORT_SYMBOL(blk_queue_prep_rq);
+
/**
* blk_queue_merge_bvec - set a merge_bvec function for queue
* @q: queue
q->merge_bvec_fn = mbfn;
}
+EXPORT_SYMBOL(blk_queue_merge_bvec);
+
/**
* blk_queue_make_request - define an alternate make_request function for a device
* @q: the request queue for the device to be affected
blk_queue_activity_fn(q, NULL, NULL);
}
+EXPORT_SYMBOL(blk_queue_make_request);
+
/**
* blk_queue_bounce_limit - set bounce buffer limit for queue
* @q: the request queue for the device
last_q = q;
}
+EXPORT_SYMBOL(blk_queue_bounce_limit);
/**
* blk_queue_max_sectors - set max sectors for a request for this queue
q->max_sectors = max_sectors;
}
+EXPORT_SYMBOL(blk_queue_max_sectors);
+
/**
* blk_queue_max_phys_segments - set max phys segments for a request for this queue
* @q: the request queue for the device
q->max_phys_segments = max_segments;
}
+EXPORT_SYMBOL(blk_queue_max_phys_segments);
+
/**
* blk_queue_max_hw_segments - set max hw segments for a request for this queue
* @q: the request queue for the device
q->max_hw_segments = max_segments;
}
+EXPORT_SYMBOL(blk_queue_max_hw_segments);
+
/**
* blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
* @q: the request queue for the device
q->max_segment_size = max_size;
}
+EXPORT_SYMBOL(blk_queue_max_segment_size);
+
/**
* blk_queue_hardsect_size - set hardware sector size for the queue
* @q: the request queue for the device
q->hardsect_size = size;
}
+EXPORT_SYMBOL(blk_queue_hardsect_size);
+
/*
* Returns the minimum that is _not_ zero, unless both are zero.
*/
t->hardsect_size = max(t->hardsect_size,b->hardsect_size);
}
+EXPORT_SYMBOL(blk_queue_stack_limits);
+
/**
* blk_queue_segment_boundary - set boundary rules for segment merging
* @q: the request queue for the device
q->seg_boundary_mask = mask;
}
+EXPORT_SYMBOL(blk_queue_segment_boundary);
+
/**
* blk_queue_dma_alignment - set dma length and memory alignment
* @q: the request queue for the device
q->dma_alignment = mask;
}
+EXPORT_SYMBOL(blk_queue_dma_alignment);
+
/**
* blk_queue_find_tag - find a request by its tag and queue
*
return bqt->tag_index[tag];
}
+EXPORT_SYMBOL(blk_queue_find_tag);
+
/**
* blk_queue_free_tags - release tag maintenance info
* @q: the request queue for the device
q->queue_flags &= ~(1 << QUEUE_FLAG_QUEUED);
}
+EXPORT_SYMBOL(blk_queue_free_tags);
+
static int
init_tag_map(request_queue_t *q, struct blk_queue_tag *tags, int depth)
{
return -ENOMEM;
}
+EXPORT_SYMBOL(blk_queue_init_tags);
+
/**
* blk_queue_resize_tags - change the queueing depth
* @q: the request queue for the device
bqt->busy--;
}
+EXPORT_SYMBOL(blk_queue_end_tag);
+
/**
* blk_queue_start_tag - find a free tag and assign it
* @q: the request queue for the device
return 0;
}
+EXPORT_SYMBOL(blk_queue_start_tag);
+
/**
* blk_queue_invalidate_tags - invalidate all pending tags
* @q: the request queue for the device
}
}
+EXPORT_SYMBOL(blk_queue_invalidate_tags);
+
static char *rq_flags[] = {
"REQ_RW",
"REQ_FAILFAST",
}
}
+EXPORT_SYMBOL(blk_dump_rq_flags);
+
void blk_recount_segments(request_queue_t *q, struct bio *bio)
{
struct bio_vec *bv, *bvprv = NULL;
return 0;
}
+EXPORT_SYMBOL(blk_phys_contig_segment);
+
int blk_hw_contig_segment(request_queue_t *q, struct bio *bio,
struct bio *nxt)
{
return 0;
}
+EXPORT_SYMBOL(blk_hw_contig_segment);
+
/*
* map a request to scatterlist, return number of sg entries setup. Caller
* must make sure sg can hold rq->nr_phys_segments entries
return nsegs;
}
+EXPORT_SYMBOL(blk_rq_map_sg);
+
/*
* the standard queue merge functions, can be overridden with device
* specific ones if so desired
}
}
+EXPORT_SYMBOL(blk_plug_device);
+
/*
* remove the queue from the plugged list, if present. called with
* queue lock held and interrupts disabled.
return 0;
}
+EXPORT_SYMBOL(blk_remove_plug);
+
/*
* remove the plug and let it rip..
*/
spin_unlock_irq(q->queue_lock);
}
+EXPORT_SYMBOL(generic_unplug_device);
+
static void blk_unplug_work(void *data)
{
request_queue_t *q = data;
schedule_work(&q->unplug_work);
}
+EXPORT_SYMBOL(blk_start_queue);
+
/**
* blk_stop_queue - stop a queue
* @q: The &request_queue_t in question
set_bit(QUEUE_FLAG_STOPPED, &q->queue_flags);
}
+EXPORT_SYMBOL(blk_stop_queue);
+
/**
* blk_run_queue - run a single device queue
* @q: The queue to run
spin_unlock_irqrestore(q->queue_lock, flags);
}
+EXPORT_SYMBOL(blk_run_queue);
+
/**
* blk_run_queues - fire all plugged queues
*
spin_unlock_irq(&blk_plug_lock);
}
+EXPORT_SYMBOL(blk_run_queues);
+
/**
* blk_cleanup_queue: - release a &request_queue_t when it is no longer needed
* @q: the request queue to be released
kfree(q);
}
+EXPORT_SYMBOL(blk_cleanup_queue);
+
static int blk_init_free_list(request_queue_t *q)
{
struct request_list *rl = &q->rq;
return q;
}
+EXPORT_SYMBOL(blk_alloc_queue);
+
/**
* blk_init_queue - prepare a request queue for use with a block device
* @rfn: The function to be called to process requests that have been
out_init:
kfree(q);
return NULL;
-
}
+EXPORT_SYMBOL(blk_init_queue);
+
int blk_get_queue(request_queue_t *q)
{
if (!test_bit(QUEUE_FLAG_DEAD, &q->queue_flags)) {
return 1;
}
+EXPORT_SYMBOL(blk_get_queue);
+
static inline void blk_free_request(request_queue_t *q, struct request *rq)
{
elv_put_request(q, rq);
return rq;
}
+
+EXPORT_SYMBOL(blk_get_request);
+
/**
* blk_requeue_request - put a request back on queue
* @q: request queue where request should be inserted
elv_requeue_request(q, rq);
}
+EXPORT_SYMBOL(blk_requeue_request);
+
/**
* blk_insert_request - insert a special request in to a request queue
* @q: request queue where request should be inserted
spin_unlock_irqrestore(q->queue_lock, flags);
}
+EXPORT_SYMBOL(blk_insert_request);
+
void drive_stat_acct(struct request *rq, int nr_sectors, int new_io)
{
int rw = rq_data_dir(rq);
}
}
+EXPORT_SYMBOL(blk_put_request);
+
/**
* blk_congestion_wait - wait for a queue to become uncongested
* @rw: READ or WRITE
finish_wait(wqh, &wait);
}
+EXPORT_SYMBOL(blk_congestion_wait);
+
/*
* Has to be called with the request spinlock acquired
*/
spin_unlock_irqrestore(q->queue_lock, flags);
}
+EXPORT_SYMBOL(blk_attempt_remerge);
+
/*
* Non-locking blk_attempt_remerge variant.
*/
attempt_back_merge(q, rq);
}
+EXPORT_SYMBOL(__blk_attempt_remerge);
+
static int __make_request(request_queue_t *q, struct bio *bio)
{
struct request *req, *freereq = NULL;
} while (ret);
}
+EXPORT_SYMBOL(generic_make_request);
+
/**
* submit_bio: submit a bio to the block device layer for I/O
* @rw: whether to %READ or %WRITE, or maybe to %READA (read ahead)
return 1;
}
+EXPORT_SYMBOL(submit_bio);
+
/**
* blk_rq_next_segment
* @rq: the request being processed
return 1;
}
+EXPORT_SYMBOL(process_that_request_first);
+
void blk_recalc_rq_segments(struct request *rq)
{
struct bio *bio;
return __end_that_request_first(req, uptodate, nr_sectors << 9);
}
+EXPORT_SYMBOL(end_that_request_first);
+
/**
* end_that_request_chunk - end I/O on a request
* @req: the request being processed
return __end_that_request_first(req, uptodate, nr_bytes);
}
+EXPORT_SYMBOL(end_that_request_chunk);
+
/*
* queue lock must be held
*/
complete(waiting);
}
+EXPORT_SYMBOL(end_that_request_last);
+
void end_request(struct request *req, int uptodate)
{
if (!end_that_request_first(req, uptodate, req->hard_cur_sectors)) {
}
}
+EXPORT_SYMBOL(end_request);
+
void blk_rq_bio_prep(request_queue_t *q, struct request *rq, struct bio *bio)
{
/* first three bits are identical in rq->flags and bio->bi_rw */
rq->cbio = rq->bio = rq->biotail = bio;
}
+EXPORT_SYMBOL(blk_rq_bio_prep);
+
void blk_rq_prep_restart(struct request *rq)
{
struct bio *bio;
rq->current_nr_sectors = rq->hard_cur_sectors;
}
+EXPORT_SYMBOL(blk_rq_prep_restart);
+
int kblockd_schedule_work(struct work_struct *work)
{
return queue_work(kblockd_workqueue, work);
kobject_put(&disk->kobj);
}
}
-
-
-EXPORT_SYMBOL(process_that_request_first);
-EXPORT_SYMBOL(end_that_request_first);
-EXPORT_SYMBOL(end_that_request_chunk);
-EXPORT_SYMBOL(end_that_request_last);
-EXPORT_SYMBOL(end_request);
-EXPORT_SYMBOL(blk_init_queue);
-EXPORT_SYMBOL(blk_cleanup_queue);
-EXPORT_SYMBOL(blk_get_queue);
-EXPORT_SYMBOL(blk_alloc_queue);
-EXPORT_SYMBOL(blk_queue_make_request);
-EXPORT_SYMBOL(blk_queue_bounce_limit);
-EXPORT_SYMBOL(generic_make_request);
-EXPORT_SYMBOL(generic_unplug_device);
-EXPORT_SYMBOL(blk_plug_device);
-EXPORT_SYMBOL(blk_remove_plug);
-EXPORT_SYMBOL(blk_attempt_remerge);
-EXPORT_SYMBOL(__blk_attempt_remerge);
-EXPORT_SYMBOL(blk_max_low_pfn);
-EXPORT_SYMBOL(blk_max_pfn);
-EXPORT_SYMBOL(blk_queue_max_sectors);
-EXPORT_SYMBOL(blk_queue_max_phys_segments);
-EXPORT_SYMBOL(blk_queue_max_hw_segments);
-EXPORT_SYMBOL(blk_queue_max_segment_size);
-EXPORT_SYMBOL(blk_queue_hardsect_size);
-EXPORT_SYMBOL(blk_queue_stack_limits);
-EXPORT_SYMBOL(blk_queue_segment_boundary);
-EXPORT_SYMBOL(blk_queue_dma_alignment);
-EXPORT_SYMBOL(blk_rq_map_sg);
-EXPORT_SYMBOL(blk_dump_rq_flags);
-EXPORT_SYMBOL(submit_bio);
-EXPORT_SYMBOL(blk_phys_contig_segment);
-EXPORT_SYMBOL(blk_hw_contig_segment);
-EXPORT_SYMBOL(blk_get_request);
-EXPORT_SYMBOL(blk_put_request);
-EXPORT_SYMBOL(blk_insert_request);
-EXPORT_SYMBOL(blk_requeue_request);
-
-EXPORT_SYMBOL(blk_queue_prep_rq);
-EXPORT_SYMBOL(blk_queue_merge_bvec);
-
-EXPORT_SYMBOL(blk_queue_find_tag);
-EXPORT_SYMBOL(blk_queue_init_tags);
-EXPORT_SYMBOL(blk_queue_free_tags);
-EXPORT_SYMBOL(blk_queue_start_tag);
-EXPORT_SYMBOL(blk_queue_end_tag);
-EXPORT_SYMBOL(blk_queue_invalidate_tags);
-
-EXPORT_SYMBOL(blk_start_queue);
-EXPORT_SYMBOL(blk_stop_queue);
-EXPORT_SYMBOL(blk_run_queue);
-EXPORT_SYMBOL(blk_run_queues);
-
-EXPORT_SYMBOL(blk_rq_bio_prep);
-EXPORT_SYMBOL(blk_rq_prep_restart);
spin_unlock_irqrestore(&batch_lock, flags);
}
+EXPORT_SYMBOL(batch_entropy_store);
+
/*
* Flush out the accumulated entropy operations, adding entropy to the passed
* store (normally random_state). If that store has enough entropy, alternate
}
}
+EXPORT_SYMBOL(add_keyboard_randomness);
+
void add_mouse_randomness(__u32 mouse_data)
{
add_timer_randomness(&mouse_timer_state, mouse_data);
}
+EXPORT_SYMBOL(add_mouse_randomness);
+
void add_interrupt_randomness(int irq)
{
if (irq >= NR_IRQS || irq_timer_state[irq] == 0)
add_timer_randomness(irq_timer_state[irq], 0x100+irq);
}
+EXPORT_SYMBOL(add_interrupt_randomness);
+
void add_disk_randomness(struct gendisk *disk)
{
if (!disk || !disk->random)
add_timer_randomness(disk->random, 0x100+MKDEV(disk->major, disk->first_minor));
}
+EXPORT_SYMBOL(add_disk_randomness);
+
/******************************************************************
*
* Hash function definition
"random driver initialization\n");
}
+EXPORT_SYMBOL(get_random_bytes);
+
/*********************************************************************
*
* Functions to interface with Linux
uuid_out[8] = (uuid_out[8] & 0x3F) | 0x80;
}
+EXPORT_SYMBOL(generate_random_uuid);
+
/********************************************************************
*
* Sysctl interface
return seq;
}
+EXPORT_SYMBOL(secure_tcp_sequence_number);
+
/* The code below is shamelessly stolen from secure_tcp_sequence_number().
* All blames to Andrey V. Savochkin <saw@msu.ru>.
*/
return (cookie - tmp[17]) & COOKIEMASK; /* Leaving the data behind */
}
#endif
-
-
-
-EXPORT_SYMBOL(add_keyboard_randomness);
-EXPORT_SYMBOL(add_mouse_randomness);
-EXPORT_SYMBOL(add_interrupt_randomness);
-EXPORT_SYMBOL(add_disk_randomness);
-EXPORT_SYMBOL(batch_entropy_store);
-EXPORT_SYMBOL(generate_random_uuid);
-
.c_cc = INIT_C_CC
};
+EXPORT_SYMBOL(tty_std_termios);
+
LIST_HEAD(tty_drivers); /* linked list of tty drivers */
struct tty_ldisc ldiscs[NR_LDISCS]; /* line disc dispatch table */
schedule_delayed_work(&tty->flip.work, 1);
}
+EXPORT_SYMBOL(tty_flip_buffer_push);
+
/*
* This subroutine initializes a tty structure.
*/
return 0;
}
+EXPORT_SYMBOL(tty_register_driver);
+
/*
* Called by a tty driver to unregister itself.
*/
return 0;
}
+EXPORT_SYMBOL(tty_unregister_driver);
+
/*
* Initialize the console device. This is called *early*, so
remove_wait_queue(&tty->write_wait, &wait);
}
+EXPORT_SYMBOL(tty_wait_until_sent);
+
static void unset_locked_termios(struct termios *termios,
struct termios *old,
struct termios *locked)
#endif
EXPORT_SYMBOL(noautodma);
+EXPORT_SYMBOL(ide_bus_type);
int (*ide_probe)(void);
**
** struct kernel_stat kstat
**
- ** is not marked as an exported symbol in the file
- **
- ** kernel/ksyms.c
+ ** is not marked as an exported symbol
**
** As a consequence, using this driver as KLM is not possible
** and any access of the structure kernel_stat via the
spinlock_t dcache_lock __cacheline_aligned_in_smp = SPIN_LOCK_UNLOCKED;
seqlock_t rename_lock __cacheline_aligned_in_smp = SEQLOCK_UNLOCKED;
+EXPORT_SYMBOL(dcache_lock);
+
static kmem_cache_t *dentry_cache;
/*
* linux/fs/nfsd/vfs.c
*
* File operations used by nfsd. Some of these have been ripped from
- * other parts of the kernel because they weren't in ksyms.c, others
+ * other parts of the kernel because they weren't exported, others
* are partial duplicates with added or changed functionality.
*
* Note that several functions dget() the dentry upon which they want
#ifndef _ROOT_DEV_H_
#define _ROOT_DEV_H_
+#include <linux/major.h>
+
enum {
Root_NFS = MKDEV(UNNAMED_MAJOR, 255),
Root_RAM0 = MKDEV(RAMDISK_MAJOR, 0),
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/ctype.h>
#include <linux/fd.h>
/* this is initialized in init/main.c */
dev_t ROOT_DEV;
+EXPORT_SYMBOL(ROOT_DEV);
+
static int __init load_ramdisk(char *str)
{
rd_doload = simple_strtol(str,NULL,0) & 3;
#define __KERNEL_SYSCALLS__
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/kernel.h>
still work even if initially too large, it will just take slightly longer */
unsigned long loops_per_jiffy = (1<<12);
+#ifndef __ia64__
+EXPORT_SYMBOL(loops_per_jiffy);
+#endif
+
/* This is the number of bits of precision for the loops_per_jiffy. Each
bit takes on average 1.5/HZ seconds. This (like the original) is a little
better than 1% */
#ifdef __GENERIC_PER_CPU
unsigned long __per_cpu_offset[NR_CPUS];
+EXPORT_SYMBOL(__per_cpu_offset);
+
static void __init setup_per_cpu_areas(void)
{
unsigned long size, i;
*/
#include <linux/compile.h>
+#include <linux/module.h>
#include <linux/uts.h>
#include <linux/utsname.h>
#include <linux/version.h>
.domainname = UTS_DOMAINNAME,
};
+EXPORT_SYMBOL(system_utsname);
+
const char *linux_banner =
"Linux version " UTS_RELEASE " (" LINUX_COMPILE_BY "@"
LINUX_COMPILE_HOST ") (" LINUX_COMPILER ") " UTS_VERSION "\n";
obj-$(CONFIG_GENERIC_ISA_DMA) += dma.o
obj-$(CONFIG_SMP) += cpu.o
obj-$(CONFIG_UID16) += uid16.o
-obj-$(CONFIG_MODULES) += ksyms.o module.o
+obj-$(CONFIG_MODULES) += module.o
obj-$(CONFIG_KALLSYMS) += kallsyms.o
obj-$(CONFIG_PM) += power/
obj-$(CONFIG_BSD_PROCESS_ACCT) += acct.o
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/security.h>
#include <asm/uaccess.h>
unsigned securebits = SECUREBITS_DEFAULT; /* systemwide security settings */
kernel_cap_t cap_bset = CAP_INIT_EFF_SET;
+EXPORT_SYMBOL(securebits);
+EXPORT_SYMBOL(cap_bset);
+
/*
* This global lock protects task->cap_* for all tasks including current.
* Locking rule: acquire this prior to tasklist_lock.
reparent_to_init();
}
+EXPORT_SYMBOL(daemonize);
+
static inline void close_files(struct files_struct * files)
{
int i, j;
__exit_fs(tsk);
}
+EXPORT_SYMBOL_GPL(exit_fs);
+
/*
* Turn us into a lazy TLB process if we
* aren't already..
__exit_mm(tsk);
}
+EXPORT_SYMBOL(exit_mm);
+
static inline void choose_new_parent(task_t *p, task_t *reaper, task_t *child_reaper)
{
/*
do_exit(code);
}
+EXPORT_SYMBOL(complete_and_exit);
+
asmlinkage long sys_exit(int error_code)
{
do_exit((error_code&0xff)<<8);
return pid_task(tmp, PIDTYPE_TGID);
}
+EXPORT_SYMBOL(next_thread);
+
/*
* Take down every thread in the group. This is called by fatal signals
* as well as by sys_exit_group (below).
rwlock_t tasklist_lock __cacheline_aligned = RW_LOCK_UNLOCKED; /* outer */
+EXPORT_SYMBOL(tasklist_lock);
+
int nr_processes(void)
{
int cpu;
spin_unlock_irqrestore(&q->lock, flags);
}
+EXPORT_SYMBOL(add_wait_queue);
+
void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait)
{
unsigned long flags;
spin_unlock_irqrestore(&q->lock, flags);
}
+EXPORT_SYMBOL(add_wait_queue_exclusive);
+
void remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait)
{
unsigned long flags;
spin_unlock_irqrestore(&q->lock, flags);
}
+EXPORT_SYMBOL(remove_wait_queue);
+
void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
{
unsigned long flags;
spin_unlock_irqrestore(&q->lock, flags);
}
+EXPORT_SYMBOL(prepare_to_wait);
+
void
prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)
{
spin_unlock_irqrestore(&q->lock, flags);
}
+EXPORT_SYMBOL(prepare_to_wait_exclusive);
+
void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
{
unsigned long flags;
}
}
+EXPORT_SYMBOL(finish_wait);
+
int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync)
{
int ret = default_wake_function(wait, mode, sync);
return ret;
}
+EXPORT_SYMBOL(autoremove_wake_function);
+
void __init fork_init(unsigned long mempages)
{
#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
return __copy_fs_struct(old);
}
+EXPORT_SYMBOL_GPL(copy_fs_struct);
+
static inline int copy_fs(unsigned long clone_flags, struct task_struct * tsk)
{
if (clone_flags & CLONE_FS) {
+++ /dev/null
-/*
- * Herein lies all the functions/variables that are "exported" for linkage
- * with dynamically loaded kernel modules.
- * Jon.
- *
- * - Stacked module support and unified symbol table added (June 1994)
- * - External symbol table support added (December 1994)
- * - Versions on symbols added (December 1994)
- * by Bjorn Ekwall <bj0rn@blox.se>
- */
-
-#include <linux/config.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/blkdev.h>
-#include <linux/cdrom.h>
-#include <linux/kernel_stat.h>
-#include <linux/vmalloc.h>
-#include <linux/sys.h>
-#include <linux/utsname.h>
-#include <linux/interrupt.h>
-#include <linux/ioport.h>
-#include <linux/serial.h>
-#include <linux/delay.h>
-#include <linux/random.h>
-#include <linux/reboot.h>
-#include <linux/pagemap.h>
-#include <linux/sysctl.h>
-#include <linux/hdreg.h>
-#include <linux/skbuff.h>
-#include <linux/genhd.h>
-#include <linux/blkpg.h>
-#include <linux/swap.h>
-#include <linux/pagevec.h>
-#include <linux/ctype.h>
-#include <linux/file.h>
-#include <linux/console.h>
-#include <linux/poll.h>
-#include <linux/mmzone.h>
-#include <linux/mm.h>
-#include <linux/capability.h>
-#include <linux/highuid.h>
-#include <linux/uio.h>
-#include <linux/tty.h>
-#include <linux/in6.h>
-#include <linux/binfmts.h>
-#include <linux/namei.h>
-#include <linux/buffer_head.h>
-#include <linux/root_dev.h>
-#include <linux/percpu.h>
-#include <linux/smp_lock.h>
-#include <linux/dnotify.h>
-#include <linux/mount.h>
-#include <linux/ptrace.h>
-#include <linux/time.h>
-#include <linux/backing-dev.h>
-#include <linux/percpu_counter.h>
-#include <asm/checksum.h>
-
-#if defined(CONFIG_PROC_FS)
-#include <linux/proc_fs.h>
-#endif
-#ifdef CONFIG_KMOD
-#include <linux/kmod.h>
-#endif
-
-extern struct timezone sys_tz;
-
-extern int panic_timeout;
-
-/* process memory management */
-EXPORT_SYMBOL(do_mmap_pgoff);
-EXPORT_SYMBOL(do_munmap);
-EXPORT_SYMBOL(do_brk);
-EXPORT_SYMBOL(exit_mm);
-EXPORT_SYMBOL_GPL(exit_fs);
-EXPORT_SYMBOL_GPL(copy_fs_struct);
-
-/* internal kernel memory management */
-EXPORT_SYMBOL(__alloc_pages);
-EXPORT_SYMBOL(__get_free_pages);
-EXPORT_SYMBOL(get_zeroed_page);
-EXPORT_SYMBOL(__page_cache_release);
-EXPORT_SYMBOL(__pagevec_lru_add);
-EXPORT_SYMBOL(__free_pages);
-EXPORT_SYMBOL(free_pages);
-EXPORT_SYMBOL(num_physpages);
-EXPORT_SYMBOL(kmem_find_general_cachep);
-EXPORT_SYMBOL(kmem_cache_create);
-EXPORT_SYMBOL(kmem_cache_destroy);
-EXPORT_SYMBOL(kmem_cache_shrink);
-EXPORT_SYMBOL(kmem_cache_alloc);
-EXPORT_SYMBOL(kmem_cache_free);
-EXPORT_SYMBOL(kmem_cache_size);
-EXPORT_SYMBOL(set_shrinker);
-EXPORT_SYMBOL(remove_shrinker);
-EXPORT_SYMBOL(malloc_sizes);
-EXPORT_SYMBOL(__kmalloc);
-EXPORT_SYMBOL(kfree);
-#ifdef CONFIG_SMP
-EXPORT_SYMBOL(__alloc_percpu);
-EXPORT_SYMBOL(free_percpu);
-EXPORT_SYMBOL(percpu_counter_mod);
-#endif
-EXPORT_SYMBOL(vfree);
-EXPORT_SYMBOL(__vmalloc);
-EXPORT_SYMBOL(vmalloc);
-EXPORT_SYMBOL(vmalloc_32);
-EXPORT_SYMBOL(vmap);
-EXPORT_SYMBOL(vunmap);
-EXPORT_SYMBOL(vmalloc_to_page);
-EXPORT_SYMBOL(remap_page_range);
-#ifndef CONFIG_DISCONTIGMEM
-EXPORT_SYMBOL(contig_page_data);
-EXPORT_SYMBOL(mem_map);
-EXPORT_SYMBOL(max_mapnr);
-#endif
-EXPORT_SYMBOL(high_memory);
-EXPORT_SYMBOL(vmtruncate);
-EXPORT_SYMBOL(find_vma);
-EXPORT_SYMBOL(get_unmapped_area);
-EXPORT_SYMBOL(init_mm);
-EXPORT_SYMBOL(blk_queue_bounce);
-EXPORT_SYMBOL(blk_congestion_wait);
-#ifdef CONFIG_HIGHMEM
-EXPORT_SYMBOL(kmap_high);
-EXPORT_SYMBOL(kunmap_high);
-EXPORT_SYMBOL(highmem_start_page);
-EXPORT_SYMBOL(kmap_prot);
-EXPORT_SYMBOL(kmap_pte);
-#endif
-#ifdef HASHED_PAGE_VIRTUAL
-EXPORT_SYMBOL(page_address);
-#endif
-EXPORT_SYMBOL(get_user_pages);
-
-/* filesystem internal functions */
-EXPORT_SYMBOL(dcache_lock);
-EXPORT_SYMBOL(invalidate_inode_pages);
-EXPORT_SYMBOL_GPL(invalidate_inode_pages2);
-EXPORT_SYMBOL(truncate_inode_pages);
-EXPORT_SYMBOL(file_ra_state_init);
-EXPORT_SYMBOL(ROOT_DEV);
-EXPORT_SYMBOL(read_cache_pages);
-EXPORT_SYMBOL(mark_page_accessed);
-
-/* for stackable file systems (lofs, wrapfs, cryptfs, etc.) */
-EXPORT_SYMBOL(lock_page);
-
-/* device registration */
-EXPORT_SYMBOL(register_blkdev);
-EXPORT_SYMBOL(unregister_blkdev);
-EXPORT_SYMBOL(tty_register_driver);
-EXPORT_SYMBOL(tty_unregister_driver);
-EXPORT_SYMBOL(tty_std_termios);
-
-/* block device driver support */
-EXPORT_SYMBOL_GPL(default_backing_dev_info);
-
-/* tty routines */
-EXPORT_SYMBOL(tty_wait_until_sent);
-EXPORT_SYMBOL(tty_flip_buffer_push);
-
-/* interrupt handling */
-EXPORT_SYMBOL(request_irq);
-EXPORT_SYMBOL(free_irq);
-
-/* waitqueue handling */
-EXPORT_SYMBOL(add_wait_queue);
-EXPORT_SYMBOL(add_wait_queue_exclusive);
-EXPORT_SYMBOL(remove_wait_queue);
-EXPORT_SYMBOL(prepare_to_wait);
-EXPORT_SYMBOL(prepare_to_wait_exclusive);
-EXPORT_SYMBOL(finish_wait);
-EXPORT_SYMBOL(autoremove_wake_function);
-
-/* The notion of irq probe/assignment is foreign to S/390 */
-
-#if !defined(CONFIG_ARCH_S390)
-EXPORT_SYMBOL(probe_irq_on);
-EXPORT_SYMBOL(probe_irq_off);
-#endif
-
-#ifdef CONFIG_SMP
-EXPORT_SYMBOL(del_timer_sync);
-#endif
-EXPORT_SYMBOL(del_timer);
-EXPORT_SYMBOL(mod_timer);
-EXPORT_SYMBOL(__mod_timer);
-
-#ifdef HAVE_DISABLE_HLT
-EXPORT_SYMBOL(disable_hlt);
-EXPORT_SYMBOL(enable_hlt);
-#endif
-
-/* resource handling */
-EXPORT_SYMBOL(request_resource);
-EXPORT_SYMBOL(release_resource);
-EXPORT_SYMBOL(allocate_resource);
-EXPORT_SYMBOL(__request_region);
-EXPORT_SYMBOL(__check_region);
-EXPORT_SYMBOL(__release_region);
-EXPORT_SYMBOL(ioport_resource);
-EXPORT_SYMBOL(iomem_resource);
-
-/* process management */
-EXPORT_SYMBOL(complete_and_exit);
-EXPORT_SYMBOL(schedule_timeout);
-#if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
-EXPORT_SYMBOL(kernel_flag);
-#endif
-EXPORT_SYMBOL(jiffies);
-EXPORT_SYMBOL(jiffies_64);
-EXPORT_SYMBOL(xtime);
-EXPORT_SYMBOL(xtime_lock);
-EXPORT_SYMBOL(do_gettimeofday);
-EXPORT_SYMBOL(do_settimeofday);
-#if (BITS_PER_LONG < 64)
-EXPORT_SYMBOL(get_jiffies_64);
-#endif
-#if !defined(__ia64__)
-EXPORT_SYMBOL(loops_per_jiffy);
-#endif
-
-/* misc */
-EXPORT_SYMBOL(panic);
-EXPORT_SYMBOL(panic_notifier_list);
-EXPORT_SYMBOL(panic_timeout);
-EXPORT_SYMBOL(sprintf);
-EXPORT_SYMBOL(snprintf);
-EXPORT_SYMBOL(sscanf);
-EXPORT_SYMBOL(vsprintf);
-EXPORT_SYMBOL(vsnprintf);
-EXPORT_SYMBOL(vsscanf);
-EXPORT_SYMBOL(simple_strtoull);
-EXPORT_SYMBOL(simple_strtoul);
-EXPORT_SYMBOL(simple_strtol);
-EXPORT_SYMBOL(system_utsname); /* UTS data */
-EXPORT_SYMBOL(uts_sem); /* UTS semaphore */
-EXPORT_SYMBOL(machine_restart);
-EXPORT_SYMBOL(machine_halt);
-EXPORT_SYMBOL(machine_power_off);
-EXPORT_SYMBOL(_ctype);
-EXPORT_SYMBOL(secure_tcp_sequence_number);
-EXPORT_SYMBOL(get_random_bytes);
-EXPORT_SYMBOL(securebits);
-EXPORT_SYMBOL(cap_bset);
-EXPORT_SYMBOL(daemonize);
-EXPORT_SYMBOL(csum_partial); /* for networking and md */
-
-/* Miscellaneous access points */
-EXPORT_SYMBOL(si_meminfo);
-
-/* Added to make file system as module */
-EXPORT_SYMBOL(sys_tz);
-
-#ifdef CONFIG_UID16
-EXPORT_SYMBOL(overflowuid);
-EXPORT_SYMBOL(overflowgid);
-#endif
-EXPORT_SYMBOL(fs_overflowuid);
-EXPORT_SYMBOL(fs_overflowgid);
-
-/* library functions */
-EXPORT_SYMBOL(strnicmp);
-EXPORT_SYMBOL(strspn);
-EXPORT_SYMBOL(strsep);
-
-/* software interrupts */
-EXPORT_SYMBOL(tasklet_init);
-EXPORT_SYMBOL(tasklet_kill);
-EXPORT_SYMBOL(do_softirq);
-EXPORT_SYMBOL(raise_softirq);
-EXPORT_SYMBOL(open_softirq);
-EXPORT_SYMBOL(raise_softirq_irqoff);
-EXPORT_SYMBOL(__tasklet_schedule);
-EXPORT_SYMBOL(__tasklet_hi_schedule);
-
-/* init task, for moving kthread roots - ought to export a function ?? */
-EXPORT_SYMBOL(init_task);
-
-EXPORT_SYMBOL(tasklist_lock);
-EXPORT_SYMBOL(find_task_by_pid);
-EXPORT_SYMBOL(next_thread);
-#if defined(CONFIG_SMP) && defined(__GENERIC_PER_CPU)
-EXPORT_SYMBOL(__per_cpu_offset);
-#endif
-
-/* debug */
-EXPORT_SYMBOL(dump_stack);
-EXPORT_SYMBOL(ptrace_notify);
-EXPORT_SYMBOL(console_printk);
-
-EXPORT_SYMBOL(current_kernel_time);
* to indicate a major problem.
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/reboot.h>
int panic_on_oops;
int tainted;
+EXPORT_SYMBOL(panic_timeout);
+
struct notifier_block *panic_notifier_list;
+EXPORT_SYMBOL(panic_notifier_list);
+
static int __init panic_setup(char *str)
{
panic_timeout = simple_strtoul(str, NULL, 0);
;
}
+EXPORT_SYMBOL(panic);
+
/**
* print_tainted - return a string to represent the kernel taint state.
*
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/bootmem.h>
return pid_task(pid->task_list.next, PIDTYPE_PID);
}
+EXPORT_SYMBOL(find_task_by_pid);
+
/*
* This function switches the PIDs if a non-leader thread calls
* sys_execve() - this must be done without releasing the PID.
DEFAULT_CONSOLE_LOGLEVEL, /* default_console_loglevel */
};
+EXPORT_SYMBOL(console_printk);
+
int oops_in_progress;
/*
* to continually duplicate across every architecture.
*/
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/mm.h>
recalc_sigpending();
spin_unlock_irq(¤t->sighand->siglock);
}
+
+EXPORT_SYMBOL(ptrace_notify);
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/ioport.h>
.flags = IORESOURCE_IO,
};
+EXPORT_SYMBOL(ioport_resource);
+
struct resource iomem_resource = {
.name = "PCI mem",
.start = 0UL,
.flags = IORESOURCE_MEM,
};
+EXPORT_SYMBOL(iomem_resource);
+
static rwlock_t resource_lock = RW_LOCK_UNLOCKED;
#ifdef CONFIG_PROC_FS
return conflict ? -EBUSY : 0;
}
+EXPORT_SYMBOL(request_resource);
+
int release_resource(struct resource *old)
{
int retval;
return retval;
}
+EXPORT_SYMBOL(release_resource);
+
/*
* Find empty slot in the resource tree given range and alignment.
*/
return err;
}
+EXPORT_SYMBOL(allocate_resource);
+
/*
* This is compatibility stuff for IO resources.
*
return res;
}
+EXPORT_SYMBOL(__request_region);
+
int __deprecated __check_region(struct resource *parent, unsigned long start, unsigned long n)
{
struct resource * res;
return 0;
}
+EXPORT_SYMBOL(__check_region);
+
void __release_region(struct resource *parent, unsigned long start, unsigned long n)
{
struct resource **p;
printk(KERN_WARNING "Trying to free nonexistent resource <%08lx-%08lx>\n", start, end);
}
+EXPORT_SYMBOL(__release_region);
+
/*
* Called from init/main.c to reserve IO ports.
*/
* Don't use in new code.
*/
spinlock_t kernel_flag __cacheline_aligned_in_smp = SPIN_LOCK_UNLOCKED;
+
+EXPORT_SYMBOL(kernel_flag);
#endif
static void kstat_init_cpu(int cpu)
local_irq_restore(flags);
}
+EXPORT_SYMBOL(do_softirq);
+
void local_bh_enable(void)
{
__local_bh_enable();
wakeup_softirqd();
}
+EXPORT_SYMBOL(raise_softirq_irqoff);
+
void raise_softirq(unsigned int nr)
{
unsigned long flags;
local_irq_restore(flags);
}
+EXPORT_SYMBOL(raise_softirq);
+
void open_softirq(int nr, void (*action)(struct softirq_action*), void *data)
{
softirq_vec[nr].data = data;
softirq_vec[nr].action = action;
}
+EXPORT_SYMBOL(open_softirq);
/* Tasklets */
struct tasklet_head
local_irq_restore(flags);
}
+EXPORT_SYMBOL(__tasklet_schedule);
+
void __tasklet_hi_schedule(struct tasklet_struct *t)
{
unsigned long flags;
local_irq_restore(flags);
}
+EXPORT_SYMBOL(__tasklet_hi_schedule);
+
static void tasklet_action(struct softirq_action *a)
{
struct tasklet_struct *list;
t->data = data;
}
+EXPORT_SYMBOL(tasklet_init);
+
void tasklet_kill(struct tasklet_struct *t)
{
if (in_interrupt())
clear_bit(TASKLET_STATE_SCHED, &t->state);
}
+EXPORT_SYMBOL(tasklet_kill);
static void tasklet_init_cpu(int cpu)
{
int overflowuid = DEFAULT_OVERFLOWUID;
int overflowgid = DEFAULT_OVERFLOWGID;
+#ifdef CONFIG_UID16
+EXPORT_SYMBOL(overflowuid);
+EXPORT_SYMBOL(overflowgid);
+#endif
+
/*
* the same as above, but for filesystems which can only store a 16-bit
* UID and GID. as such, this is needed on all architectures
int fs_overflowuid = DEFAULT_FS_OVERFLOWUID;
int fs_overflowgid = DEFAULT_FS_OVERFLOWUID;
+EXPORT_SYMBOL(fs_overflowuid);
+EXPORT_SYMBOL(fs_overflowgid);
+
/*
* this indicates whether you can reboot with ctrl-alt-del: the default is yes
*/
return 0;
}
+EXPORT_SYMBOL(notifier_chain_register);
+
/**
* notifier_chain_unregister - Remove notifier from a notifier chain
* @nl: Pointer to root list pointer
return -ENOENT;
}
+EXPORT_SYMBOL(notifier_chain_unregister);
+
/**
* notifier_call_chain - Call functions in a notifier chain
* @n: Pointer to root pointer of notifier chain
return ret;
}
+EXPORT_SYMBOL(notifier_call_chain);
+
/**
* register_reboot_notifier - Register function to be called at reboot time
* @nb: Info about notifier function to be called
return notifier_chain_register(&reboot_notifier_list, nb);
}
+EXPORT_SYMBOL(register_reboot_notifier);
+
/**
* unregister_reboot_notifier - Unregister previously registered reboot notifier
* @nb: Hook to be unregistered
return notifier_chain_unregister(&reboot_notifier_list, nb);
}
+EXPORT_SYMBOL(unregister_reboot_notifier);
+
asmlinkage long sys_ni_syscall(void)
{
return -ENOSYS;
return retval;
}
+EXPORT_SYMBOL(in_group_p);
+
int in_egroup_p(gid_t grp)
{
int retval = 1;
return retval;
}
+EXPORT_SYMBOL(in_egroup_p);
+
DECLARE_RWSEM(uts_sem);
+EXPORT_SYMBOL(uts_sem);
+
asmlinkage long sys_newuname(struct new_utsname __user * name)
{
int errno = 0;
}
return error;
}
-
-EXPORT_SYMBOL(notifier_chain_register);
-EXPORT_SYMBOL(notifier_chain_unregister);
-EXPORT_SYMBOL(notifier_call_chain);
-EXPORT_SYMBOL(register_reboot_notifier);
-EXPORT_SYMBOL(unregister_reboot_notifier);
-EXPORT_SYMBOL(in_group_p);
-EXPORT_SYMBOL(in_egroup_p);
* (Even though the technical memorandum forbids it)
*/
+#include <linux/module.h>
#include <linux/timex.h>
#include <linux/errno.h>
#include <linux/smp_lock.h>
*/
struct timezone sys_tz;
+EXPORT_SYMBOL(sys_tz);
+
#if !defined(__alpha__) && !defined(__ia64__)
/*
return now;
}
+EXPORT_SYMBOL(current_kernel_time);
+
#if (BITS_PER_LONG < 64)
u64 get_jiffies_64(void)
{
} while (read_seqretry(&xtime_lock, seq));
return ret;
}
+
+EXPORT_SYMBOL(get_jiffies_64);
#endif
+
+EXPORT_SYMBOL(jiffies);
*/
#include <linux/kernel_stat.h>
+#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/percpu.h>
#include <linux/init.h>
return ret;
}
+EXPORT_SYMBOL(__mod_timer);
+
/***
* add_timer_on - start a timer on a particular CPU
* @timer: the timer to be added
return __mod_timer(timer, expires);
}
+EXPORT_SYMBOL(mod_timer);
+
/***
* del_timer - deactive a timer.
* @timer: the timer to be deactivated
return 1;
}
+EXPORT_SYMBOL(del_timer);
+
#ifdef CONFIG_SMP
/***
* del_timer_sync - deactivate a timer and wait for the handler to finish.
return ret;
}
-#endif
+EXPORT_SYMBOL(del_timer_sync);
+#endif
static int cascade(tvec_base_t *base, tvec_t *tv, int index)
{
struct timespec xtime __attribute__ ((aligned (16)));
struct timespec wall_to_monotonic __attribute__ ((aligned (16)));
+EXPORT_SYMBOL(xtime);
+
/* Don't completely fail for HZ > 500. */
int tickadj = 500/HZ ? : 1; /* microsecs */
*/
#ifndef ARCH_HAVE_XTIME_LOCK
seqlock_t xtime_lock __cacheline_aligned_in_smp = SEQLOCK_UNLOCKED;
+
+EXPORT_SYMBOL(xtime_lock);
#endif
/*
return timeout < 0 ? 0 : timeout;
}
+EXPORT_SYMBOL(schedule_timeout);
+
/* Thread ID - the internal kernel "pid" */
asmlinkage long sys_gettid(void)
{
*/
#include <linux/ctype.h>
+#include <linux/module.h>
unsigned char _ctype[] = {
_C,_C,_C,_C,_C,_C,_C,_C, /* 0-7 */
_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L, /* 224-239 */
_L,_L,_L,_L,_L,_L,_L,_P,_L,_L,_L,_L,_L,_L,_L,_L}; /* 240-255 */
-
+EXPORT_SYMBOL(_ctype);
printk(KERN_NOTICE
"This architecture does not implement dump_stack()\n");
}
+
+EXPORT_SYMBOL(dump_stack);
-
+#include <linux/module.h>
#include <linux/percpu_counter.h>
#include <linux/sched.h>
fbc->counters[cpu].count = count;
put_cpu();
}
+
+EXPORT_SYMBOL(percpu_counter_mod);
}
return (int)c1 - (int)c2;
}
+
+EXPORT_SYMBOL(strnicmp);
#endif
#ifndef __HAVE_ARCH_STRCPY
return count;
}
+
+EXPORT_SYMBOL(strspn);
#endif
/**
return sbegin;
}
+
+EXPORT_SYMBOL(strsep);
#endif
#ifndef __HAVE_ARCH_MEMSET
*/
#include <stdarg.h>
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
return result;
}
+EXPORT_SYMBOL(simple_strtoul);
+
/**
* simple_strtol - convert a string to a signed long
* @cp: The start of the string
return simple_strtoul(cp,endp,base);
}
+EXPORT_SYMBOL(simple_strtol);
+
/**
* simple_strtoull - convert a string to an unsigned long long
* @cp: The start of the string
return result;
}
+EXPORT_SYMBOL(simple_strtoull);
+
/**
* simple_strtoll - convert a string to a signed long long
* @cp: The start of the string
return str-buf;
}
+EXPORT_SYMBOL(vsnprintf);
+
/**
* snprintf - Format a string and place it in a buffer
* @buf: The buffer to place the result into
return i;
}
+EXPORT_SYMBOL(snprintf);
+
/**
* vsprintf - Format a string and place it in a buffer
* @buf: The buffer to place the result into
return vsnprintf(buf, 0xFFFFFFFFUL, fmt, args);
}
+EXPORT_SYMBOL(vsprintf);
/**
* sprintf - Format a string and place it in a buffer
return i;
}
+EXPORT_SYMBOL(sprintf);
+
/**
* vsscanf - Unformat a buffer into a list of arguments
* @buf: input buffer
return num;
}
+EXPORT_SYMBOL(vsscanf);
+
/**
* sscanf - Unformat a buffer into a list of arguments
* @buf: input buffer
va_end(args);
return i;
}
+
+EXPORT_SYMBOL(sscanf);
}
EXPORT_SYMBOL(unlock_page);
+EXPORT_SYMBOL(lock_page);
/*
* End writeback against a page.
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/swap.h>
#include <linux/bio.h>
#include <linux/pagemap.h>
return (void*) vaddr;
}
+EXPORT_SYMBOL(kmap_high);
+
void kunmap_high(struct page *page)
{
unsigned long vaddr;
wake_up(&pkmap_map_wait);
}
+EXPORT_SYMBOL(kunmap_high);
+
#define POOL_SIZE 64
static __init int init_emergency_pool(void)
__blk_queue_bounce(q, bio_orig, pool);
}
+EXPORT_SYMBOL(blk_queue_bounce);
+
#if defined(HASHED_PAGE_VIRTUAL)
#define PA_HASH_ORDER 7
return ret;
}
+EXPORT_SYMBOL(page_address);
+
void set_page_address(struct page *page, void *virtual)
{
unsigned long flags;
/* use the per-pgdat data instead for discontigmem - mbligh */
unsigned long max_mapnr;
struct page *mem_map;
+
+EXPORT_SYMBOL(max_mapnr);
+EXPORT_SYMBOL(mem_map);
#endif
unsigned long num_physpages;
void * high_memory;
struct page *highmem_start_page;
+EXPORT_SYMBOL(num_physpages);
+EXPORT_SYMBOL(highmem_start_page);
+EXPORT_SYMBOL(high_memory);
+
/*
* We special-case the C-O-W ZERO_PAGE, because it's such
* a common occurrence (no need to read the page to know
return i;
}
+EXPORT_SYMBOL(get_user_pages);
+
static void zeromap_pte_range(pte_t * pte, unsigned long address,
unsigned long size, pgprot_t prot)
{
return error;
}
+EXPORT_SYMBOL(remap_page_range);
+
/*
* Establish a new mapping:
* - flush the old one
return -EFBIG;
}
+EXPORT_SYMBOL(vmtruncate);
+
/*
* Primitive swap readahead code. We simply read an aligned block of
* (1 << page_cluster) entries in the swap area. This method is chosen
}
return page;
}
+
+EXPORT_SYMBOL(vmalloc_to_page);
return error;
}
+EXPORT_SYMBOL(do_mmap_pgoff);
+
/* Get an address range which is currently unmapped.
* For shmat() with addr=0.
*
return arch_get_unmapped_area(file, addr, len, pgoff, flags);
}
+EXPORT_SYMBOL(get_unmapped_area);
+
/* Look up the first VMA which satisfies addr < vm_end, NULL if none. */
struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr)
{
return vma;
}
+EXPORT_SYMBOL(find_vma);
+
/* Same as find_vma, but also return a pointer to the previous VMA in *pprev. */
struct vm_area_struct *
find_vma_prev(struct mm_struct *mm, unsigned long addr,
return 0;
}
+EXPORT_SYMBOL(do_munmap);
+
asmlinkage long sys_munmap(unsigned long addr, size_t len)
{
int ret;
return addr;
}
+EXPORT_SYMBOL(do_brk);
+
/* Build the RB tree corresponding to the VMA list. */
void build_mmap_rb(struct mm_struct * mm)
{
return page;
}
+EXPORT_SYMBOL(__alloc_pages);
+
/*
* Common helper functions.
*/
return (unsigned long) page_address(page);
}
+EXPORT_SYMBOL(__get_free_pages);
+
unsigned long get_zeroed_page(unsigned int gfp_mask)
{
struct page * page;
return 0;
}
+EXPORT_SYMBOL(get_zeroed_page);
+
void __pagevec_free(struct pagevec *pvec)
{
int i = pagevec_count(pvec);
}
}
+EXPORT_SYMBOL(__free_pages);
+
void free_pages(unsigned long addr, unsigned int order)
{
if (addr != 0) {
}
}
+EXPORT_SYMBOL(free_pages);
+
/*
* Total amount of free (allocatable) RAM:
*/
return sum;
}
+
EXPORT_SYMBOL(nr_free_pages);
unsigned int nr_used_zone_pages(void)
val->mem_unit = PAGE_SIZE;
}
+EXPORT_SYMBOL(si_meminfo);
+
#ifdef CONFIG_NUMA
void si_meminfo_node(struct sysinfo *val, int nid)
{
static bootmem_data_t contig_bootmem_data;
struct pglist_data contig_page_data = { .bdata = &contig_bootmem_data };
+EXPORT_SYMBOL(contig_page_data);
+
void __init free_area_init(unsigned long *zones_size)
{
free_area_init_node(0, &contig_page_data, NULL, zones_size,
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/backing-dev.h>
#include <linux/pagevec.h>
.state = 0,
};
+EXPORT_SYMBOL_GPL(default_backing_dev_info);
+
/*
* Initialise a struct file's readahead state
*/
ra->ra_pages = mapping->backing_dev_info->ra_pages;
}
+EXPORT_SYMBOL(file_ra_state_init);
+
/*
* Return max readahead size for this inode in number-of-pages.
*/
return ret;
}
+EXPORT_SYMBOL(read_cache_pages);
+
static int read_pages(struct address_space *mapping, struct file *filp,
struct list_head *pages, unsigned nr_pages)
{
#undef CACHE
};
+EXPORT_SYMBOL(malloc_sizes);
+
/* Must match cache_sizes above. Out of line to keep cache footprint low. */
static struct cache_names {
char *name;
return cachep;
}
+EXPORT_SYMBOL(kmem_cache_create);
+
static inline void check_irq_off(void)
{
#if DEBUG
return __cache_shrink(cachep);
}
+EXPORT_SYMBOL(kmem_cache_shrink);
+
/**
* kmem_cache_destroy - delete a cache
* @cachep: the cache to destroy
return 0;
}
+EXPORT_SYMBOL(kmem_cache_destroy);
+
/* Get the memory for a slab management obj. */
static inline struct slab* alloc_slabmgmt (kmem_cache_t *cachep,
void *objp, int colour_off, int local_flags)
return __cache_alloc(cachep, flags);
}
+EXPORT_SYMBOL(kmem_cache_alloc);
+
/**
* kmalloc - allocate memory
* @size: how many bytes of memory are required.
return NULL;
}
+EXPORT_SYMBOL(__kmalloc);
+
#ifdef CONFIG_SMP
/**
* __alloc_percpu - allocate one copy of the object for every present
kfree(pdata);
return NULL;
}
+
+EXPORT_SYMBOL(__alloc_percpu);
#endif
/**
local_irq_restore(flags);
}
+EXPORT_SYMBOL(kmem_cache_free);
+
/**
* kfree - free previously allocated memory
* @objp: pointer returned by kmalloc.
local_irq_restore(flags);
}
+EXPORT_SYMBOL(kfree);
+
#ifdef CONFIG_SMP
/**
* free_percpu - free previously allocated percpu memory
kfree(p->ptrs[i]);
}
}
+
+EXPORT_SYMBOL(free_percpu);
#endif
unsigned int kmem_cache_size(kmem_cache_t *cachep)
return obj_reallen(cachep);
}
+EXPORT_SYMBOL(kmem_cache_size);
+
kmem_cache_t * kmem_find_general_cachep (size_t size, int gfpflags)
{
struct cache_sizes *csizep = malloc_sizes;
return (gfpflags & GFP_DMA) ? csizep->cs_dmacachep : csizep->cs_cachep;
}
+EXPORT_SYMBOL(kmem_find_general_cachep);
+
struct ccupdate_struct {
kmem_cache_t *cachep;
struct array_cache *new[NR_CPUS];
}
}
+EXPORT_SYMBOL(mark_page_accessed);
+
/**
* lru_cache_add: add a page to the page lists
* @page: the page to add
free_hot_page(page);
}
+EXPORT_SYMBOL(__page_cache_release);
+
/*
* Batched page_cache_release(). Decrement the reference count on all the
* passed pages. If it fell to zero then remove the page from the LRU and
pagevec_reinit(pvec);
}
+EXPORT_SYMBOL(__pagevec_lru_add);
+
void __pagevec_lru_add_active(struct pagevec *pvec)
{
int i;
#include <linux/kernel.h>
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/pagemap.h>
#include <linux/pagevec.h>
#include <linux/buffer_head.h> /* grr. try_to_release_page,
}
}
+EXPORT_SYMBOL(truncate_inode_pages);
+
/**
* invalidate_mapping_pages - Invalidate all the unlocked pages of one inode
* @mapping: the address_space which holds the pages to invalidate
return invalidate_mapping_pages(mapping, 0, ~0UL);
}
+EXPORT_SYMBOL(invalidate_inode_pages);
+
/**
* invalidate_inode_pages2 - remove all unmapped pages from an address_space
* @mapping - the address_space
cond_resched();
}
}
+
+EXPORT_SYMBOL_GPL(invalidate_inode_pages2);
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/highmem.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
__vunmap(addr, 1);
}
+EXPORT_SYMBOL(vfree);
+
/**
* vunmap - release virtual mapping obtained by vmap()
*
__vunmap(addr, 0);
}
+EXPORT_SYMBOL(vunmap);
+
/**
* vmap - map an array of pages into virtually contiguous space
*
return area->addr;
}
+EXPORT_SYMBOL(vmap);
+
/**
* __vmalloc - allocate virtually contiguous memory
*
return NULL;
}
+EXPORT_SYMBOL(__vmalloc);
+
/**
* vmalloc - allocate virtually contiguous memory
*
return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
}
+EXPORT_SYMBOL(vmalloc);
+
/**
* vmalloc_32 - allocate virtually contiguous memory (32bit addressable)
*
return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL);
}
+EXPORT_SYMBOL(vmalloc_32);
+
long vread(char *buf, char *addr, unsigned long count)
{
struct vm_struct *tmp;
*/
#include <linux/mm.h>
+#include <linux/module.h>
#include <linux/slab.h>
#include <linux/kernel_stat.h>
#include <linux/swap.h>
return shrinker;
}
+EXPORT_SYMBOL(set_shrinker);
+
/*
* Remove one
*/
up(&shrinker_sem);
kfree(shrinker);
}
+
+EXPORT_SYMBOL(remove_shrinker);
#define SHRINK_BATCH 128
/*
projects / linux / commitdiff