This is the mail archive of the gcc-prs@gcc.gnu.org mailing list for the GCC project.
| Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
|---|---|---|
| Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |
| Other format: | [Raw text] | |
>Number: 5775
>Category: c
>Synopsis: Compilation stops abruptly
>Confidential: no
>Severity: serious
>Priority: medium
>Responsible: unassigned
>State: open
>Class: sw-bug
>Submitter-Id: net
>Arrival-Date: Mon Feb 25 05:06:01 PST 2002
>Closed-Date:
>Last-Modified:
>Originator: N. Varadarajan
>Release: unknown-1.0
>Organization:
>Environment:
PowerPC Linux. RPX Lite board hosting MPC 850/823
>Description:
We booted the RPX Lite with the Linux Kernel 2.4.7
and we tried to compile the Linux source tree in that target
When doing a make zImage it proceeded and stopped after
sometime with the following message
gcc -D__KERNEL__ -I/home/root/kernel/kernel/include -Wall
-Wstrict-prototypes -Wno-trigraphs -O2 -fno-strict-aliasing
-fno-common -fomit-frame-pointer -D__powerpc__ -fsigned-char -msoft-float -pipe -ffixed-r2 -Wno-uninitialized
-mmultiple -mstring -mcpu=860 -msoft-float -g3 -c -o panic.o
panic.c
panic.c: In function `panic':
panic.c:109: Internal compiler error in `float_signal', at toplev.c:2418
Please submit a full bug report.
output of gcc -v
Reading specs from /opt/lib/gcc-lib/powerpc-linux/2.95.2/specs
gcc version 2.95.2 19991024 (release)
Please note that this is not a cross-compiler.
I have attached the pre-processor's output file
A similar kind of bug-report has been filed for x86 by
Terushi Arakawa
>How-To-Repeat:
Just compile the kernel as described above
>Fix:
>Release-Note:
>Audit-Trail:
>Unformatted:
>sig[4*i+3]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; b3 = b->sig[4*i+3]; r->sig[4*i+0] = (( a0 ) & ( b0 )) ; r->sig[4*i+1] = (( a1 ) & ( b1 )) ; r->sig[4*i+2] = (( a2 ) & ( b2 )) ; r->sig[4*i+3] = (( a3 ) & ( b3 )) ; } swi tch ((64 / 32 ) % 4) { case 3: a0 = a->sig[4*i+0]; a1 = a->sig[4*i+1]; a2 = a->sig[4*i+2]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; r->sig[4*i+0] = (( a0 ) & ( b0 )) ; r->sig[4*i+1] = (( a1 ) & ( b1 )) ; r->sig[4*i+2] = (( a2 ) & ( b2 )) ; break; case 2: a0 = a->sig[4*i+0]; a1 = a->sig[4*i+1]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; r->sig[4*i+0] = (( a0 ) & ( b0 )) ; r->sig[4*i+1] = (( a1 ) & ( b1 )) ; break; case 1: a0 = a->sig[4*i+0]; b0 = b->sig[4*i+0]; r->sig[4*i +0] = (( a0 ) & ( b0 )) ; break; } }
#define _sig_nand(x,y) ((x) & ~(y))
static inline void signandsets (sigset_t *r, const sigset_t *a, const sigset_t *b) { unsigned long a0, a1, a2, a3, b0, b1, b2, b3; unsigned long i; for (i = 0; i < (64 / 32 ) /4; ++i) { a0 = a->sig[4*i+0]; a1 = a->sig[4*i+1]; a2 = a->sig[4*i+2]; a3 = a ->sig[4*i+3]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; b3 = b->sig[4*i+3]; r->sig[4*i+0] = (( a0 ) & ~( b0 )) ; r->sig[4*i+1] = (( a1 ) & ~( b1 )) ; r->sig[4*i+2] = (( a2 ) & ~( b2 )) ; r->sig[4*i+3] = (( a3 ) & ~( b3 )) ; } switch ((64 / 32 ) % 4) { case 3: a0 = a->sig[4*i+0]; a1 = a->sig[4*i+1]; a2 = a->sig[4*i+2]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; r->sig[4*i+0] = (( a0 ) & ~( b0 )) ; r->sig[4*i+1] = (( a1 ) & ~( b1 )) ; r->sig[4*i+2] = (( a2 ) & ~( b2 )) ; break; case 2: a0 = a->sig[4*i+0]; a1 = a->sig[4*i+1]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; r->sig[4*i+0] = (( a0 ) & ~( b0 )) ; r->sig[4*i+1] = (( a1 ) & ~( b1 )) ; break; case 1: a0 = a->sig[4*i+0]; b0 = b->sig[4*i+0]; r->sig[4*i+0] = (( a0 ) & ~( b0 )) ; break; } }
#undef _SIG_SET_BINOP
#undef _sig_or
#undef _sig_and
#undef _sig_nand
#define _SIG_SET_OP(name, op) static inline void name(sigset_t *set) { unsigned long i; for (i = 0; i < _NSIG_WORDS/4; ++i) { set->sig[4*i+0] = op(set->sig[4*i+0]); set->sig[4*i+1] = op(set->sig[4*i+1]); set->sig[4*i+2] = op(set->sig[4*i+2]); set->sig[4* i+3] = op(set->sig[4*i+3]); } switch (_NSIG_WORDS % 4) { case 3: set->sig[4*i+2] = op(set->sig[4*i+2]); case 2: set->sig[4*i+1] = op(set->sig[4*i+1]); case 1: set->sig[4*i+0] = op(set->sig[4*i+0]); } }
# 149 "/home/root/kernel/kernel/include/linux/signal.h"
#define _sig_not(x) (~(x))
static inline void signotset (sigset_t *set) { unsigned long i; for (i = 0; i < (64 / 32 ) /4; ++i) { set->sig[4*i+0] = (~( set->sig[4*i+0] )) ; set->sig[4*i+1] = (~( set->sig[4*i+1] )) ; set->sig[4*i+2] = (~( set->sig[4*i+2] )) ; set->sig[4*i+3] = (~( set->sig[4*i+3] )) ; } switch ((64 / 32 ) % 4) { case 3: set->sig[4*i+2] = (~( set->sig[4*i+2] )) ; case 2: set->sig[4*i+1] = (~( set->sig[4*i+1] )) ; case 1: set->sig[4*i+0] = (~( set->sig[4*i+0] )) ; } }
#undef _SIG_SET_OP
#undef _sig_not
static inline void sigemptyset(sigset_t *set)
{
switch ((64 / 32 ) ) {
default:
memset(set, 0, sizeof(sigset_t));
break;
case 2: set->sig[1] = 0;
case 1: set->sig[0] = 0;
break;
}
}
static inline void sigfillset(sigset_t *set)
{
switch ((64 / 32 ) ) {
default:
memset(set, -1, sizeof(sigset_t));
break;
case 2: set->sig[1] = -1;
case 1: set->sig[0] = -1;
break;
}
}
extern char * render_sigset_t(sigset_t *set, char *buffer);
static inline void sigaddsetmask(sigset_t *set, unsigned long mask)
{
set->sig[0] |= mask;
}
static inline void sigdelsetmask(sigset_t *set, unsigned long mask)
{
set->sig[0] &= ~mask;
}
static inline int sigtestsetmask(sigset_t *set, unsigned long mask)
{
return (set->sig[0] & mask) != 0;
}
static inline void siginitset(sigset_t *set, unsigned long mask)
{
set->sig[0] = mask;
switch ((64 / 32 ) ) {
default:
memset(&set->sig[1], 0, sizeof(long)*((64 / 32 ) -1));
break;
case 2: set->sig[1] = 0;
case 1: ;
}
}
static inline void siginitsetinv(sigset_t *set, unsigned long mask)
{
set->sig[0] = ~mask;
switch ((64 / 32 ) ) {
default:
memset(&set->sig[1], -1, sizeof(long)*((64 / 32 ) -1));
break;
case 2: set->sig[1] = -1;
case 1: ;
}
}
static inline void init_sigpending(struct sigpending *sig)
{
sigemptyset(&sig->signal);
sig->head = ((void *)0) ;
sig->tail = &sig->head;
}
extern long do_sigpending(void *, unsigned long);
# 29 "/home/root/kernel/kernel/include/linux/sched-defs.h" 2
# 1 "/home/root/kernel/kernel/include/linux/securebits.h" 1
#define _LINUX_SECUREBITS_H 1
#define SECUREBITS_DEFAULT 0x00000000
extern unsigned securebits;
#define SECURE_NOROOT 0
#define SECURE_NO_SETUID_FIXUP 2
#define issecure(X) ( (1 << (X+1)) & SECUREBITS_DEFAULT ? (1 << (X)) & SECUREBITS_DEFAULT : (1 << (X)) & securebits )
# 30 "/home/root/kernel/kernel/include/linux/sched-defs.h" 2
# 1 "/home/root/kernel/kernel/include/linux/fs_struct-defs.h" 1
#define _LINUX_FS_STRUCT_DEFS_H
struct fs_struct {
atomic_t count;
mutex_t lock;
int umask;
struct dentry * root, * pwd, * altroot;
struct vfsmount * rootmnt, * pwdmnt, * altrootmnt;
};
#define INIT_FS { ATOMIC_INIT(1), RW_LOCK_UNLOCKED, 0022, NULL, NULL, NULL, NULL, NULL, NULL }
extern void exit_fs(struct task_struct *);
extern void set_fs_altroot(void);
struct fs_struct *copy_fs_struct(struct fs_struct *old);
void put_fs_struct(struct fs_struct *fs);
# 31 "/home/root/kernel/kernel/include/linux/sched-defs.h" 2
#define IRQ_PRIORITY CONFIG_POSIX_PRIOS-2
#define SQ_PRIORITY CONFIG_POSIX_PRIOS-1
#define SOFTIRQ_PRIORITY CONFIG_POSIX_PRIOS-3
#define CSIGNAL 0x000000ff
#define CLONE_VM 0x00000100
#define CLONE_FS 0x00000200
#define CLONE_FILES 0x00000400
#define CLONE_SIGHAND 0x00000800
#define CLONE_PID 0x00001000
#define CLONE_PTRACE 0x00002000
#define CLONE_VFORK 0x00004000
#define CLONE_PARENT 0x00008000
#define CLONE_THREAD 0x00010000
#define CLONE_SIGNAL (CLONE_SIGHAND | CLONE_THREAD)
extern unsigned long avenrun[];
#define FSHIFT 11
#define FIXED_1 (1<<FSHIFT)
#define LOAD_FREQ (5*HZ)
#define EXP_1 1884
#define EXP_5 2014
#define EXP_15 2037
#define CALC_LOAD(load,exp,n) load *= exp; load += n*(FIXED_1-exp); load >>= FSHIFT;
#define CT_TO_SECS(x) ((long)((x) / ktimer_freq))
#define CT_TO_USECS(x) ((long)((((x) % ktimer_freq) * 1000000)/ktimer_freq))
#define OLD_CT_TO_SECS(x) ((x) / HZ)
#define OLD_CT_TO_USECS(x) (((x) % HZ) * 1000000/HZ)
extern int nr_running, nr_threads;
extern int last_pid;
# 1 "/home/root/kernel/kernel/include/linux/param.h" 1
#define _LINUX_PARAM_H
# 91 "/home/root/kernel/kernel/include/linux/sched-defs.h" 2
# 1 "/home/root/kernel/kernel/include/linux/resource.h" 1
#define _LINUX_RESOURCE_H
#define RUSAGE_SELF 0
#define RUSAGE_CHILDREN (-1)
#define RUSAGE_BOTH (-2)
struct rusage {
struct timeval ru_utime;
struct timeval ru_stime;
long ru_maxrss;
long ru_ixrss;
long ru_idrss;
long ru_isrss;
long ru_minflt;
long ru_majflt;
long ru_nswap;
long ru_inblock;
long ru_oublock;
long ru_msgsnd;
long ru_msgrcv;
long ru_nsignals;
long ru_nvcsw;
long ru_nivcsw;
};
struct rlimit {
unsigned long rlim_cur;
unsigned long rlim_max;
};
#define PRIO_MIN (-20)
#define PRIO_MAX 20
#define PRIO_PROCESS 0
#define PRIO_PGRP 1
#define PRIO_USER 2
# 1 "/home/root/kernel/kernel/include/asm/resource.h" 1
#define _PPC_RESOURCE_H
#define RLIMIT_CPU 0
#define RLIMIT_FSIZE 1
#define RLIMIT_DATA 2
#define RLIMIT_STACK 3
#define RLIMIT_CORE 4
#define RLIMIT_RSS 5
#define RLIMIT_NPROC 6
#define RLIMIT_NOFILE 7
#define RLIMIT_MEMLOCK 8
#define RLIMIT_AS 9
#define RLIMIT_LOCKS 10
#define RLIM_NLIMITS 11
#define RLIM_INFINITY (~0UL)
#define INIT_RLIMITS { { RLIM_INFINITY, RLIM_INFINITY }, { RLIM_INFINITY, RLIM_INFINITY }, { RLIM_INFINITY, RLIM_INFINITY }, { _STK_LIM, RLIM_INFINITY }, { 0, RLIM_INFINITY }, { RLIM_INFINITY, RLIM_INFINITY }, { 0, 0 }, { INR_OPEN, INR_OPEN }, { RLIM_INFINITY, RLIM_INFINITY }, { RLIM_INFINITY, RLIM_INFINITY }, { RLIM_INFINITY, RLIM_INFINITY }, }
# 44 "/home/root/kernel/kernel/include/asm/resource.h"
# 56 "/home/root/kernel/kernel/include/linux/resource.h" 2
# 92 "/home/root/kernel/kernel/include/linux/sched-defs.h" 2
# 1 "/home/root/kernel/kernel/include/linux/timer.h" 1
#define _LINUX_TIMER_H
struct timer_list {
struct list_head list;
unsigned long expires;
unsigned long data;
void (*function)(unsigned long);
};
extern void add_timer(struct timer_list * timer);
extern int del_timer(struct timer_list * timer);
extern int del_timer_sync(struct timer_list * timer);
extern void sync_timers(void);
int mod_timer(struct timer_list *timer, unsigned long expires);
extern void it_real_fn(unsigned long);
static inline void init_timer(struct timer_list * timer)
{
timer->list.next = timer->list.prev = ((void *)0) ;
}
static inline int timer_pending (const struct timer_list * timer)
{
return timer->list.next != ((void *)0) ;
}
#define time_after(a,b) ((long)(b) - (long)(a) < 0)
#define time_before(a,b) time_after(b,a)
#define time_after_eq(a,b) ((long)(a) - (long)(b) >= 0)
#define time_before_eq(a,b) time_after_eq(b,a)
# 93 "/home/root/kernel/kernel/include/linux/sched-defs.h" 2
# 1 "/home/root/kernel/kernel/include/asm/processor.h" 1
# 705 "/home/root/kernel/kernel/include/asm/processor.h"
# 95 "/home/root/kernel/kernel/include/linux/sched-defs.h" 2
#define TASK_RUNNING 0
#define TASK_INTERRUPTIBLE 1
#define TASK_UNINTERRUPTIBLE 2
#define TASK_ZOMBIE 4
#define TASK_STOPPED 8
#define __set_task_state(tsk, state_value) do { (tsk)->state = (state_value); } while (0)
#define set_task_state(tsk, state_value) __set_task_state((tsk), (state_value))
#define __set_current_state(state_value) do { current->state = (state_value); } while (0)
#define set_current_state(state_value) __set_current_state(state_value)
#define SCHED_OTHER 0
#define SCHED_FIFO 1
#define SCHED_RR 2
#define SCHED_YIELD 0x10
struct sched_param {
int sched_priority;
};
struct completion;
extern mutex_t tasklist_lock;
extern mutex_t mmlist_lock;
extern void sched_init(void);
extern void init_idle(void);
extern void show_state(void);
extern void cpu_init (void);
extern void trap_init(void);
extern void update_process_times(int user);
extern void update_one_process(struct task_struct *p, unsigned long user,
unsigned long system, int cpu);
#define MAX_SCHEDULE_TIMEOUT LONG_MAX
extern signed long schedule_timeout(signed long timeout) ;
void schedule(void);
void preempt(void);
extern int schedule_task(struct tq_struct *task);
extern void flush_scheduled_tasks(void);
extern int start_context_thread(void);
extern int current_is_keventd(void);
#define NR_OPEN_DEFAULT BITS_PER_LONG
struct files_struct {
atomic_t count;
mutex_t file_lock;
int max_fds;
int max_fdset;
int next_fd;
struct file ** fd;
fd_set *close_on_exec;
fd_set *open_fds;
fd_set close_on_exec_init;
fd_set open_fds_init;
struct file * fd_array[32 ];
};
#define INIT_FILES { count: ATOMIC_INIT(1), file_lock: RW_LOCK_UNLOCKED, max_fds: NR_OPEN_DEFAULT, max_fdset: __FD_SETSIZE, next_fd: 0, fd: &init_files.fd_array[0], close_on_exec: &init_files.close_on_exec_init, open_fds: &init_files.open_fds_init, clo se_on_exec_init: { { 0, } }, open_fds_init: { { 0, } }, fd_array: { NULL, } }
# 205 "/home/root/kernel/kernel/include/linux/sched-defs.h"
#define MAX_MAP_COUNT (65536)
#define AVL_MIN_MAP_COUNT 32
struct mm_struct {
struct vm_area_struct * mmap;
struct vm_area_struct * mmap_avl;
struct vm_area_struct * mmap_cache;
pgd_t * pgd;
atomic_t mm_users;
atomic_t mm_count;
int map_count;
struct rw_semaphore mmap_sem;
mutex_t page_table_lock;
struct list_head mmlist;
unsigned long start_code, end_code, start_data, end_data;
unsigned long start_brk, brk, start_stack;
unsigned long arg_start, arg_end, env_start, env_end;
unsigned long rss, total_vm, locked_vm;
unsigned long def_flags;
unsigned long cpu_vm_mask;
unsigned long swap_address;
unsigned dumpable:1;
mm_context_t context;
struct task_struct *notify_mmdrop;
};
extern int mmlist_nr;
#define INIT_MM(name) { mmap: &init_mmap, mmap_avl: NULL, mmap_cache: NULL, pgd: swapper_pg_dir, mm_users: ATOMIC_INIT(2), mm_count: ATOMIC_INIT(1), map_count: 1, mmap_sem: __RWSEM_INITIALIZER(name.mmap_sem), page_table_lock: SPIN_LOCK_UNLOCKED, mmlist : LIST_HEAD_INIT(name.mmlist), }
# 260 "/home/root/kernel/kernel/include/linux/sched-defs.h"
struct signal_struct {
atomic_t count;
struct k_sigaction action[64 ];
mutex_t siglock;
};
#define INIT_SIGNALS { count: ATOMIC_INIT(1), action: { {{0,}}, }, siglock: SPIN_LOCK_UNLOCKED }
struct user_struct {
atomic_t __count;
atomic_t processes;
atomic_t files;
struct user_struct *next, **pprev;
uid_t uid;
};
#define get_current_user() ({ struct user_struct *__user = current->user; atomic_inc(&__user->__count); __user; })
extern struct user_struct root_user;
#define INIT_USER (&root_user)
typedef struct sched_ops {
void (*add)(struct task_struct *p, int cpu);
void (*add_head)(struct task_struct *p, int cpu);
void (*del)(struct task_struct *p, int cpu);
void (*charge)(struct task_struct *p, long time);
void (*yield)(struct task_struct *p, int cpu);
} sched_ops;
typedef struct sched_context {
struct task_struct *owner;
struct list_head sched_node;
struct list_head lent_to_node;
int queue_pos;
int last_prio;
struct task_struct *next_for_pi, *prev_for_pi;
struct task_struct *proc;
const sched_ops *sched_ops;
} __attribute__((aligned(64))) sched_context;
typedef struct task_struct {
volatile long state;
unsigned long flags;
int sigpending;
mm_segment_t addr_limit;
struct exec_domain *exec_domain;
volatile long need_resched;
unsigned long ptrace;
unsigned long wchan;
unsigned long last_time;
unsigned long user_time, system_time;
int processor;
int lock_depth;
int bh_lock_depth;
unsigned long time_start;
unsigned long partial_jiffy;
int nice;
int policy, rt_priority;
int max_priority;
long time_left, slice;
unsigned int last_replenish;
unsigned int last_local_replenish;
int bound_cpu;
int timeshare_cpu;
int runnable;
volatile int has_cpu;
const sched_ops *sched_ops;
sched_context context[1 ];
struct task_struct *lender;
struct list_head lent_to;
int last_sched_queue;
int queue_num;
int context_queue_num;
ktimer *sleep_tmr;
struct mm_struct *mm;
unsigned long sleep_time;
struct task_struct *next_task, *prev_task;
struct mm_struct *active_mm;
struct linux_binfmt *binfmt;
int exit_code, exit_signal;
int pdeath_signal;
unsigned long personality;
int did_exec:1;
pid_t pid;
pid_t pgrp;
pid_t tty_old_pgrp;
pid_t session;
pid_t tgid;
int leader;
struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
struct list_head thread_group;
struct task_struct *pidhash_next;
struct task_struct **pidhash_pprev;
wait_queue_head_t wait_chldexit;
struct completion *vfork_done;
struct sigqueue sq_prof, sq_virt;
unsigned long it_real_value, it_prof_value, it_virt_value;
unsigned long it_real_incr, it_prof_incr, it_virt_incr;
struct timer_list real_timer;
struct kernel_tms times;
unsigned long start_time;
cpu_tick_data_t per_cpu_utime[1 ], per_cpu_stime[1 ];
unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
int swappable:1;
uid_t uid,euid,suid,fsuid;
gid_t gid,egid,sgid,fsgid;
int ngroups;
gid_t groups[32 ];
kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
int keep_capabilities:1;
struct user_struct *user;
struct rlimit rlim[11 ];
unsigned short used_math;
char comm[16];
int link_count;
struct tty_struct *tty;
unsigned int locks;
struct sem_undo *semundo;
struct sem_queue *semsleeping;
struct thread_struct thread;
struct fs_struct *fs;
struct files_struct *files;
mutex_t sigmask_lock;
struct signal_struct *sig;
sigset_t blocked;
struct sigpending pending;
unsigned long sas_ss_sp;
size_t sas_ss_size;
int (*notifier)(void *priv);
void *notifier_data;
sigset_t *notifier_mask;
u32 parent_exec_id;
u32 self_exec_id;
mutex_t alloc_lock;
struct posix_timer **posix_timers;
int num_posix_timers;
mutex_t *lock_blocked;
struct task_struct *next_for_lock, *prev_for_lock;
int lock_type;
mutex_list_t *locks_held;
int mutex_abort;
int brlock_cpu;
int brlock_count;
int dying;
mutex_t exit_lock;
int usedfpu;
int preempted;
int dequeued;
int named;
struct rk_resource_set *rk_resource_set;
struct list_head rk_proclist;
int periodicType;
struct timespec period;
struct ktimer *period_timer;
struct ktimer *deadline_timer;
struct timespec last_start;
struct timespec startTime;
struct list_head tx_siglist;
struct list_head rx_siglist;
mutex_t siglist_lock;
int rk_inherit;
struct list_head rs_sock_list;
mutex_t socklist_lock;
int cpu_reserve_active;
int sysno;
} task_struct;
#define PF_ALIGNWARN 0x00000001
#define PF_STARTING 0x00000002
#define PF_EXITING 0x00000004
#define PF_FORKNOEXEC 0x00000040
#define PF_SUPERPRIV 0x00000100
#define PF_DUMPCORE 0x00000200
#define PF_SIGNALED 0x00000400
#define PF_MEMALLOC 0x00000800
#define PF_NOPREEMPT 0x08000000
#define PF_IRQHANDLER 0x10000000
#define PT_PTRACED 0x00000001
#define PT_TRACESYS 0x00000002
#define PT_DTRACE 0x00000004
#define PT_TRACESYSGOOD 0x00000008
#define _STK_LIM (8*1024*1024)
#define DEF_NICE 0
#define INIT_TASK(tsk) { state: 0, flags: 0, sigpending: 0, addr_limit: KERNEL_DS, exec_domain: &default_exec_domain, lock_depth: -1, nice: DEF_NICE, policy: SCHED_OTHER, bound_cpu: SHARED_QUEUE, has_cpu: 1, slice: DEF_SLICE, mm: NULL, active _mm: &init_mm, next_task: &tsk, prev_task: &tsk, p_opptr: &tsk, p_pptr: &tsk, thread_group: LIST_HEAD_INIT(tsk.thread_group), wait_chldexit: __WAIT_QUEUE_HEAD_INITIALIZER(tsk.wait_chldexit), real_timer: { function: it_real_fn }, cap_effective: CAP _INIT_EFF_SET, cap_inheritable: CAP_INIT_INH_SET, cap_permitted: CAP_FULL_SET, keep_capabilities: 0, rlim: INIT_RLIMITS, user: INIT_USER, comm: "swapper", thread: INIT_THREAD, fs: &init_fs, files: &init_files, sigmask_lock: SPIN_LOCK_UNLOCKED, sig : &init_signals, pending: { NULL, &tsk.pending.head, {{0}}}, blocked: {{0}}, alloc_lock: SPIN_LOCK_UNLOCKED, }
# 688 "/home/root/kernel/kernel/include/linux/sched-defs.h"
#define INIT_TASK_SIZE 2048*sizeof(long)
union task_union {
struct task_struct task;
unsigned long stack[2048*sizeof(long) /sizeof(long)];
};
# 4 "/home/root/kernel/kernel/include/linux/sched.h" 2
# 1 "/home/root/kernel/kernel/include/linux/mutex.h" 1
#define __LINUX_MUTEX_H
# 1 "/home/root/kernel/kernel/include/asm/current.h" 1
# 13 "/home/root/kernel/kernel/include/asm/current.h"
# 8 "/home/root/kernel/kernel/include/linux/mutex.h" 2
# 1 "/home/root/kernel/kernel/include/asm/bitops.h" 1
# 376 "/home/root/kernel/kernel/include/asm/bitops.h"
# 9 "/home/root/kernel/kernel/include/linux/mutex.h" 2
# 1 "/home/root/kernel/kernel/include/linux/measure.h" 1
#define __MEASURE_H
#define measure_gettimeofday(do) do_gettimeofday(do)
#define TIMEVAL struct timeval
# 1 "/home/root/kernel/kernel/include/linux/unistd.h" 1
#define _LINUX_UNISTD_H_
extern int errno;
# 1 "/home/root/kernel/kernel/include/asm/unistd.h" 1
#define _ASM_PPC_UNISTD_H_
#define __NR_exit 1
#define __NR_fork 2
#define __NR_read 3
#define __NR_write 4
#define __NR_open 5
#define __NR_close 6
#define __NR_waitpid 7
#define __NR_creat 8
#define __NR_link 9
#define __NR_unlink 10
#define __NR_execve 11
#define __NR_chdir 12
#define __NR_time 13
#define __NR_mknod 14
#define __NR_chmod 15
#define __NR_lchown 16
#define __NR_break 17
#define __NR_oldstat 18
#define __NR_lseek 19
#define __NR_getpid 20
#define __NR_mount 21
#define __NR_umount 22
#define __NR_setuid 23
#define __NR_getuid 24
#define __NR_stime 25
#define __NR_ptrace 26
#define __NR_alarm 27
#define __NR_oldfstat 28
#define __NR_pause 29
#define __NR_utime 30
#define __NR_stty 31
#define __NR_gtty 32
#define __NR_access 33
#define __NR_nice 34
#define __NR_ftime 35
#define __NR_sync 36
#define __NR_kill 37
#define __NR_rename 38
#define __NR_mkdir 39
#define __NR_rmdir 40
#define __NR_dup 41
#define __NR_pipe 42
#define __NR_times 43
#define __NR_prof 44
#define __NR_brk 45
#define __NR_setgid 46
#define __NR_getgid 47
#define __NR_signal 48
#define __NR_geteuid 49
#define __NR_getegid 50
#define __NR_acct 51
#define __NR_umount2 52
#define __NR_lock 53
#define __NR_ioctl 54
#define __NR_fcntl 55
#define __NR_mpx 56
#define __NR_setpgid 57
#define __NR_ulimit 58
#define __NR_oldolduname 59
#define __NR_umask 60
#define __NR_chroot 61
#define __NR_ustat 62
#define __NR_dup2 63
#define __NR_getppid 64
#define __NR_getpgrp 65
#define __NR_setsid 66
#define __NR_sigaction 67
#define __NR_sgetmask 68
#define __NR_ssetmask 69
#define __NR_setreuid 70
#define __NR_setregid 71
#define __NR_sigsuspend 72
#define __NR_sigpending 73
#define __NR_sethostname 74
#define __NR_setrlimit 75
#define __NR_getrlimit 76
#define __NR_getrusage 77
#define __NR_gettimeofday 78
#define __NR_settimeofday 79
#define __NR_getgroups 80
#define __NR_setgroups 81
#define __NR_select 82
#define __NR_symlink 83
#define __NR_oldlstat 84
#define __NR_readlink 85
#define __NR_uselib 86
#define __NR_swapon 87
#define __NR_reboot 88
#define __NR_readdir 89
#define __NR_mmap 90
#define __NR_munmap 91
#define __NR_truncate 92
#define __NR_ftruncate 93
#define __NR_fchmod 94
#define __NR_fchown 95
#define __NR_getpriority 96
#define __NR_setpriority 97
#define __NR_profil 98
#define __NR_statfs 99
#define __NR_fstatfs 100
#define __NR_ioperm 101
#define __NR_socketcall 102
#define __NR_syslog 103
#define __NR_setitimer 104
#define __NR_getitimer 105
#define __NR_stat 106
#define __NR_lstat 107
#define __NR_fstat 108
#define __NR_olduname 109
#define __NR_iopl 110
#define __NR_vhangup 111
#define __NR_idle 112
#define __NR_vm86 113
#define __NR_wait4 114
#define __NR_swapoff 115
#define __NR_sysinfo 116
#define __NR_ipc 117
#define __NR_fsync 118
#define __NR_sigreturn 119
#define __NR_clone 120
#define __NR_setdomainname 121
#define __NR_uname 122
#define __NR_modify_ldt 123
#define __NR_adjtimex 124
#define __NR_mprotect 125
#define __NR_sigprocmask 126
#define __NR_create_module 127
#define __NR_init_module 128
#define __NR_delete_module 129
#define __NR_get_kernel_syms 130
#define __NR_quotactl 131
#define __NR_getpgid 132
#define __NR_fchdir 133
#define __NR_bdflush 134
#define __NR_sysfs 135
#define __NR_personality 136
#define __NR_afs_syscall 137
#define __NR_setfsuid 138
#define __NR_setfsgid 139
#define __NR__llseek 140
#define __NR_getdents 141
#define __NR__newselect 142
#define __NR_flock 143
#define __NR_msync 144
#define __NR_readv 145
#define __NR_writev 146
#define __NR_getsid 147
#define __NR_fdatasync 148
#define __NR__sysctl 149
#define __NR_mlock 150
#define __NR_munlock 151
#define __NR_mlockall 152
#define __NR_munlockall 153
#define __NR_sched_setparam 154
#define __NR_sched_getparam 155
#define __NR_sched_setscheduler 156
#define __NR_sched_getscheduler 157
#define __NR_sched_yield 158
#define __NR_sched_get_priority_max 159
#define __NR_sched_get_priority_min 160
#define __NR_sched_rr_get_interval 161
#define __NR_nanosleep 162
#define __NR_mremap 163
#define __NR_setresuid 164
#define __NR_getresuid 165
#define __NR_query_module 166
#define __NR_poll 167
#define __NR_nfsservctl 168
#define __NR_setresgid 169
#define __NR_getresgid 170
#define __NR_prctl 171
#define __NR_rt_sigreturn 172
#define __NR_rt_sigaction 173
#define __NR_rt_sigprocmask 174
#define __NR_rt_sigpending 175
#define __NR_rt_sigtimedwait 176
#define __NR_rt_sigqueueinfo 177
#define __NR_rt_sigsuspend 178
#define __NR_pread 179
#define __NR_pwrite 180
#define __NR_chown 181
#define __NR_getcwd 182
#define __NR_capget 183
#define __NR_capset 184
#define __NR_sigaltstack 185
#define __NR_sendfile 186
#define __NR_getpmsg 187
#define __NR_putpmsg 188
#define __NR_vfork 189
#define __NR_ugetrlimit 190
#define __NR_mmap2 192
#define __NR_truncate64 193
#define __NR_ftruncate64 194
#define __NR_stat64 195
#define __NR_lstat64 196
#define __NR_fstat64 197
#define __NR_pciconfig_read 198
#define __NR_pciconfig_write 199
#define __NR_pciconfig_iobase 200
#define __NR_multiplexer 201
#define __NR_getdents64 202
#define __NR_pivot_root 203
#define __NR_fcntl64 204
#define __NR_madvise 205
#define __NR_mincore 206
#define __NR_sched_rr_set_interval 398
#define __NR_setname 399
#define __NR_measure_register 400
#define __NR_measure_getinfo 401
#define __NR_rk_resource_set_create 402
#define __NR_rk_resource_set_destroy 403
#define __NR_rk_resource_set_attach_process 404
#define __NR_rk_resource_set_detach_process 405
#define __NR_rk_reserve_create 406
#define __NR_rk_reserve_delete 407
#define __NR_rk_reserve_ctl 408
#define __NR_timer_create 411
#define __NR_timer_delete 412
#define __NR_timer_settime 413
#define __NR_timer_gettime 414
#define __NR_timer_getoverrun 415
#define __NR_rk_resource_sets_get_num 416
#define __NR_rk_resource_sets_get_list 417
#define __NR_rk_reserves_get_num 418
#define __NR_rk_reserves_get_list 419
#define __NR_rk_reserve_get_attr 420
#define __NR_rk_reserves_set_scheduling_policy 421
#define __NR_rk_reserves_get_scheduling_policy 422
#define __NR_rt_make_periodic 423
#define __NR_rt_wait_for_start_time 424
#define __NR_rt_wait_for_next_period 425
#define __NR_rt_process_get_period 426
#define __NR_rt_get_clock_frequency 427
#define __NR_rk_resource_set_get_name 428
#define __NR_rk_resource_set_get_rsv 429
#define __NR_rt_process_set_period 430
#define __NR_rk_resource_set_get_num_procs 431
#define __NR_rk_resource_set_get_proclist 432
#define __NR_rk_inherit_mode 433
#define __NR_rt_mutex_create 434
#define __NR_rt_mutex_destroy 435
#define __NR_rt_mutex_trylock 436
#define __NR_rt_mutex_lock 437
#define __NR_rt_mutex_unlock 438
#define __NR_rk_resource_set_set_name 439
#define __NR_rk_proc_get_rset 440
#define __NR_rk_signal 441
#define __NR_rk_resource_set_attach_socket 442
#define __NR_rk_resource_set_detach_socket 443
#define __NR_rt_set_prio_ceiling 444
#define __NR(n) #n
#define __syscall_return(type) return (__sc_err & 0x10000000 ? errno = __sc_ret, __sc_ret = -1 : 0), (type) __sc_ret
#define __syscall_clobbers "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
#define _syscall0(type,name) type name(void) { unsigned long __sc_ret, __sc_err; { register unsigned long __sc_0 __asm__ ("r0"); register unsigned long __sc_3 __asm__ ("r3"); __sc_0 = __NR_##name; __asm__ __volatile__ ("sc \n\t" "mfcr %1 " : "=&r" (__sc_3), "=&r" (__sc_0) : "0" (__sc_3), "1" (__sc_0) : __syscall_clobbers); __sc_ret = __sc_3; __sc_err = __sc_0; } __syscall_return (type); }
# 298 "/home/root/kernel/kernel/include/asm/unistd.h"
#define _syscall1(type,name,type1,arg1) type name(type1 arg1) { unsigned long __sc_ret, __sc_err; { register unsigned long __sc_0 __asm__ ("r0"); register unsigned long __sc_3 __asm__ ("r3"); __sc_3 = (unsigned long) (arg1); __sc_0 = __NR_##name; __asm__ __volatile__ ("sc \n\t" "mfcr %1 " : "=&r" (__sc_3), "=&r" (__sc_0) : "0" (__sc_3), "1" (__sc_0) : __syscall_clobbers); __sc_ret = __sc_3; __sc_err = __sc_0; } __syscall_return (type); }
# 320 "/home/root/kernel/kernel/include/asm/unistd.h"
#define _syscall2(type,name,type1,arg1,type2,arg2) type name(type1 arg1, type2 arg2) { unsigned long __sc_ret, __sc_err; { register unsigned long __sc_0 __asm__ ("r0"); register unsigned long __sc_3 __asm__ ("r3"); register unsigned long __sc_4 __asm__ ( "r4"); __sc_3 = (unsigned long) (arg1); __sc_4 = (unsigned long) (arg2); __sc_0 = __NR_##name; __asm__ __volatile__ ("sc \n\t" "mfcr %1 " : "=&r" (__sc_3), "=&r" (__sc_0) : "0" (__sc_3), "1" (__sc_0), "r" (__sc_4) : __syscall_clobber s); __sc_ret = __sc_3; __sc_err = __sc_0; } __syscall_return (type); }
# 345 "/home/root/kernel/kernel/include/asm/unistd.h"
#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) type name(type1 arg1, type2 arg2, type3 arg3) { unsigned long __sc_ret, __sc_err; { register unsigned long __sc_0 __asm__ ("r0"); register unsigned long __sc_3 __asm__ ("r3"); register unsigne d long __sc_4 __asm__ ("r4"); register unsigned long __sc_5 __asm__ ("r5"); __sc_3 = (unsigned long) (arg1); __sc_4 = (unsigned long) (arg2); __sc_5 = (unsigned long) (arg3); __sc_0 = __NR_##name; __asm__ __volatile__ ("sc \n\t" "mfcr %1 " : "=&r" (__sc_3), "=&r" (__sc_0) : "0" (__sc_3), "1" (__sc_0), "r" (__sc_4), "r" (__sc_5) : __syscall_clobbers); __sc_ret = __sc_3; __sc_err = __sc_0; } __syscall_return (type); }
# 373 "/home/root/kernel/kernel/include/asm/unistd.h"
#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { unsigned long __sc_ret, __sc_err; { register unsigned long __sc_0 __asm__ ("r0"); register unsigned long __sc_3 __asm__ ( "r3"); register unsigned long __sc_4 __asm__ ("r4"); register unsigned long __sc_5 __asm__ ("r5"); register unsigned long __sc_6 __asm__ ("r6"); __sc_3 = (unsigned long) (arg1); __sc_4 = (unsigned long) (arg2); __sc_5 = (unsigned long) (arg3); __sc_6 = ( unsigned long) (arg4); __sc_0 = __NR_##name; __asm__ __volatile__ ("sc \n\t" "mfcr %1 " : "=&r" (__sc_3), "=&r" (__sc_0) : "0" (__sc_3), "1" (__sc_0), "r" (__sc_4), "r" (__sc_5), "r" (__sc_6) : __syscall_clobbers); __sc_ret = __s c_3; __sc_err = __sc_0; } __syscall_return (type); }
# 404 "/home/root/kernel/kernel/include/asm/unistd.h"
#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5) type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) { unsigned long __sc_ret, __sc_err; { register unsigned long __sc_0 __asm__ ("r0"); register unsigne d long __sc_3 __asm__ ("r3"); register unsigned long __sc_4 __asm__ ("r4"); register unsigned long __sc_5 __asm__ ("r5"); register unsigned long __sc_6 __asm__ ("r6"); register unsigned long __sc_7 __asm__ ("r7"); __sc_3 = (unsigned long) (arg1); __sc_4 = (unsigned long) (arg2); __sc_5 = (unsigned long) (arg3); __sc_6 = (unsigned long) (arg4); __sc_7 = (unsigned long) (arg5); __sc_0 = __NR_##name; __asm__ __volatile__ ("sc \n\t" "mfcr %1 " : "=&r" (__sc_3), "=&r" (__sc_0) : "0" (__sc_3) , "1" (__sc_0), "r" (__sc_4), "r" (__sc_5), "r" (__sc_6), "r" (__sc_7) : __syscall_clobbers); __sc_ret = __sc_3; __sc_err = __sc_0; } __syscall_return (type); }
# 438 "/home/root/kernel/kernel/include/asm/unistd.h"
# 473 "/home/root/kernel/kernel/include/asm/unistd.h"
# 9 "/home/root/kernel/kernel/include/linux/unistd.h" 2
# 19 "/home/root/kernel/kernel/include/linux/measure.h" 2
# 1 "/home/root/kernel/kernel/include/rk/rkmod.h" 1
#define RK_RKMOD_H
# 1 "/home/root/kernel/kernel/include/linux/timespec.h" 1
#define _TIMESPEC_H_
#define NANOSEC_PER_SEC (1000000000L)
#define USEC_PER_SEC (1000000L)
#define timespec_zero(time) { (time).tv_sec = 0; (time).tv_nsec = 0; }
#define timespec_add_nsec(result, nanos) do { if (((result).tv_nsec += (nanos)) >= NANOSEC_PER_SEC) { (result).tv_nsec -= NANOSEC_PER_SEC; (result).tv_sec++; } } while (0)
#define timespec_add(result, addend) do { (result).tv_nsec += (addend).tv_nsec; (result).tv_sec += (addend).tv_sec; if ((result).tv_nsec >= NANOSEC_PER_SEC) { (result).tv_nsec -= NANOSEC_PER_SEC; (result).tv_sec++; } } while (0)
#define timespec_sub(result, subtrahend) do { if ((result).tv_nsec >= (subtrahend).tv_nsec) { (result).tv_nsec -= (subtrahend).tv_nsec; (result).tv_sec -= (subtrahend).tv_sec; } else { (result).tv_nsec += NANOSEC_PER_SEC; (result).tv_nsec -= (subtrahend) .tv_nsec; (result).tv_sec -= (subtrahend).tv_sec + 1; } } while (0)
# 35 "/home/root/kernel/kernel/include/linux/timespec.h"
#define timespec_set(time, newtime) do { (time).tv_sec = (newtime).tv_sec; (time).tv_nsec = (newtime).tv_nsec; } while (0)
#define timespec_cmp(time1, time2) (((time1).tv_sec < (time2).tv_sec) || (((time1).tv_sec == (time2).tv_sec) && ((time1).tv_nsec <= (time2).tv_nsec)))
#define timespec_ge(time1, time2) (((time1).tv_sec > (time2).tv_sec) || (((time1).tv_sec == (time2).tv_sec) && ((time1).tv_nsec >= (time2).tv_nsec)))
#define timespec_gt(time1, time2) (((time1).tv_sec > (time2).tv_sec) || (((time1).tv_sec == (time2).tv_sec) && ((time1).tv_nsec > (time2).tv_nsec)))
#define timespec_le(time1, time2) (((time1).tv_sec < (time2).tv_sec) || (((time1).tv_sec == (time2).tv_sec) && ((time1).tv_nsec <= (time2).tv_nsec)))
#define timespec_lt(time1, time2) (((time1).tv_sec < (time2).tv_sec) || (((time1).tv_sec == (time2).tv_sec) && ((time1).tv_nsec < (time2).tv_nsec)))
#define timespec_eq(time1,time2) (((time1).tv_sec == (time2).tv_sec) && ((time1).tv_nsec == (time2).tv_nsec))
#define timespec_min(time1,time2) (timespec_le((time1),(time2)) ? (time1) : (time2))
#define timespec_max(time1,time2) (timespec_ge((time1),(time2)) ? (time1) : (time2))
#define timespec_ne(time1,time2) (((time1).tv_sec != (time2).tv_sec) || ((time1).tv_nsec != (time2).tv_nsec))
#define timespec_nonzero(time) ((time).tv_nsec || (time).tv_sec)
#define timespec_valid(time) ((time).tv_sec >= 0 && (time).tv_nsec >= 0 && (time).tv_nsec <= NANOSEC_PER_SEC)
#define timespec2micro(time) (((time).tv_sec * USEC_PER_SEC) + ((time).tv_nsec / 1000))
#define timespec2nano(time) ((((unsigned long long)(time).tv_sec) * NANOSEC_PER_SEC) + ((time).tv_nsec))
#define nano2timespec(nanos, ts) do { ts.tv_sec = nanos / NANOSEC_PER_SEC; ts.tv_nsec = nanos - ts.tv_sec * NANOSEC_PER_SEC; } while (0)
# 34 "/home/root/kernel/kernel/include/rk/rkmod.h" 2
# 1 "/home/root/kernel/kernel/include/rk/rk.h" 1
#define RK_RK_H
# 51 "/home/root/kernel/kernel/include/rk/rk.h"
#define RK_TIMESYS_GRP 500
# 70 "/home/root/kernel/kernel/include/rk/rk.h"
#define NULL_RK_TIMER ((rk_timer_t)0)
#define NULL_RESOURCE_SET ((rk_resource_set_t)0)
#define NULL_RESERVE ((rk_reserve_t)0)
enum rk_reserve_mode
{
RSV_HARD =0x1,
RSV_FIRM =0x2,
RSV_SOFT =0x4,
};
typedef enum rk_reserve_mode rk_reserve_mode_t;
struct rk_reserve_param {
rk_reserve_mode_t sch_mode;
rk_reserve_mode_t enf_mode;
rk_reserve_mode_t rep_mode;
};
typedef struct rk_reserve_param rk_reserve_param_data_t;
typedef struct rk_reserve_param *rk_reserve_param_t;
struct cpu_reserve_attr {
struct timespec compute_time;
struct timespec period;
struct timespec deadline;
struct timespec blocking_time;
struct timespec start_time;
rk_reserve_param_data_t reserve_type;
int processor;
};
typedef struct cpu_reserve_attr cpu_reserve_attr_data_t;
typedef struct cpu_reserve_attr *cpu_reserve_attr_t;
#define RK_IFNAMSIZ 16
struct net_reserve_attr {
size_t amount;
struct timespec net_time;
struct timespec period;
struct timespec deadline;
struct timespec blocking_time;
struct timespec start_time;
rk_reserve_param_data_t reserve_type;
size_t buffer_space;
char dev_name[16 ];
};
typedef struct net_reserve_attr net_reserve_attr_data_t;
typedef struct net_reserve_attr *net_reserve_attr_t;
enum rk_reserve_type
{
RSV_NULL =0x0,
RSV_CPU =0x1,
RSV_NET,
RSV_NETR,
RSV_FS,
RSV_MEM,
RSV_DEV,
};
typedef enum rk_reserve_type rk_reserve_type_t;
#define RK_NAME_LEN 16
#define RSET_NAME_LEN RK_NAME_LEN
#define RATE_MONOTONIC 0
#define DEADLINE_MONOTONIC 1
#define NUM_CPU_RESERVE_POLICIES (DEADLINE_MONOTONIC + 1)
#define RK_ANY_CPU (-1)
#define RK_RSV_ENFORCE 1
#define RK_DEADLINE_MISSED 2
#define RT_MIN_PERIOD (struct timespec){0, 20000}
# 270 "/home/root/kernel/kernel/include/rk/rk.h"
# 37 "/home/root/kernel/kernel/include/rk/rkmod.h" 2
typedef unsigned long long * cpu_tick_t;
#define NANOSEC 1000000000L
#define MICROSEC 1000000L
#define RK_FALSE 0
#define RK_TRUE 1
#define RK_HISTORY_SIZE 32
#define LINUX_TIMESHARE_PRIORITY 0
#define LINUX_REALTIME_PRIORITY 256
enum rt_process_type
{
APERIODIC =0x1,
PERIODIC =0x2,
SPORADIC =0x4,
};
typedef enum rt_process_type rt_process_type_t;
enum rk_reserve_state
{
RSV_IS_NULL =0x0,
RSV_IS_RUNNING =0x1,
RSV_IS_DEPLETED =0x10,
RSV_IS_STARTING = 0x100,
RSV_IS_DYING = 0x200,
};
typedef enum rk_reserve_state rk_reserve_state_t;
# 92 "/home/root/kernel/kernel/include/rk/rkmod.h"
typedef struct rk_resource_set *rk_resource_set_t;
typedef struct rk_reserve *rk_reserve_t;
extern mutex_t rslist_lock;
extern mutex_t tasklist_lock;
extern old_rwlock_t rk_lock;
struct rk_resource_set {
char rs_name[16 ];
char rs_destructible;
struct list_head rs_list;
struct list_head rs_task_list;
int num_tasks;
rk_reserve_t cpu_rsv;
rk_reserve_t net_rsv;
rk_reserve_t netr_rsv;
struct proc_dir_entry *rs_proc_dir;
};
struct rk_reserve_ops {
int (*destroy) (rk_reserve_t);
void (*start_account) (rk_reserve_t);
void (*stop_account) (rk_reserve_t, cpu_tick_t);
void (*replenish) (rk_reserve_t, cpu_tick_t);
void (*enforce) (rk_reserve_t);
void (*attach)(rk_reserve_t, struct task_struct *);
void (*detach)(rk_reserve_t, struct task_struct *);
int (*get_history)(rk_reserve_t, char *);
int (*read_proc) (rk_reserve_t, char *);
};
struct rk_reserve {
rk_resource_set_t rsv_rs;
rk_reserve_type_t rsv_type;
rk_reserve_state_t rsv_state;
struct rk_reserve_ops * rsv_ops;
void * rsv_rsv;
ktimer *rsv_replenish_tmr;
rk_reserve_param_data_t rsv_reserve_param;
struct list_head siglist;
struct proc_dir_entry *rsv_proc_entry;
struct proc_dir_entry *rsv_proc_history;
};
typedef unsigned long cpu_capacity_t;
typedef unsigned long long cpu_capacity_quad_t;
struct cpu_reserve {
rk_reserve_t rsv;
struct list_head cpu_list;
cpu_tick_data_t cpu_period_used_ticks;
cpu_tick_data_t cpu_period_start_ticks;
cpu_tick_data_t cpu_period_available_ticks;
struct wait_queue *depleted_wait;
cpu_tick_data_t * cpu_period_prev_used_ticks;
cpu_capacity_t cpu_max_utilization;
cpu_capacity_t cpu_min_utilization;
struct {
unsigned long total_count;
cpu_capacity_quad_t total_utils;
} cpu_average;
cpu_reserve_attr_data_t cpu_res_attr;
cpu_tick_data_t cpu_time_ticks;
int cpu_priority_index;
cpu_tick_data_t cpu_period_ticks;
cpu_capacity_t cpu_capacity;
};
typedef struct cpu_reserve * cpu_reserve_t;
#define NULL_CPU_RESERVE ((cpu_reserve_t)0)
#define BOUND_CPU(crsv) ((crsv)->cpu_res_attr.processor)
struct rk_cpu_data_struct {
volatile int in_intr;
cpu_reserve_t current_cpu_reserve;
struct list_head cpu_list;
cpu_capacity_t current_capacity;
ktimer *enforce_tmr;
struct task_struct *current_task;
};
struct rk_signal_struct {
rk_reserve_t rsv;
struct list_head tx_list;
struct task_struct *task;
struct list_head rx_list;
sigevent_t ev;
struct sigqueue *sq;
};
typedef struct rk_signal_struct rk_signal_t;
extern struct rk_cpu_data_struct rk_cpu_data[1 ];
extern struct list_head rk_resource_set_root;
struct task_struct;
extern int (*rk_timer_interrupt_hook)(void);
extern void (*rk_kernel_intr_in_hook)(void);
extern void (*rk_restore_all_hook)(struct pt_regs regs);
extern int (*rk_ret_with_reschedule_hook)(struct pt_regs regs);
extern void (*rk_schedule_hook)(struct task_struct *, struct task_struct *);
extern void (*rt_adjbaseprio_hook)(struct task_struct *, int);
extern void (*rk_task_cleanup_hook)(struct task_struct *);
extern void (*rk_fork_hook)(struct task_struct *);
# 256 "/home/root/kernel/kernel/include/rk/rkmod.h"
#define CAPACITY_INT(x) ((x)/100)
#define CAPACITY_FRAC(x) ((x)-(x/100)*100)
#define INT2CAPACITY(x) ((x)*10000)
#define CAPACITY2INT(x) ((x)/10000)
#define PERCENT2CAPACITY(x) ((x)*100)
#define CAPACITY_OF(c,t) (INT2CAPACITY(c)/(t))
#define TICK2JIFFIES(tick) tick2jiffies(tick, &cpu_tick_at_last_jiffy)
#define TICK2JIFFIES2(tick,last) tick2jiffies(tick,last)
#define bzero(p,s) memset(p, 0, s)
#define rk_debug(f, a...)
extern int rk_count;
void rk_inc_use_count(void);
void rk_dec_use_count(void);
#define PERMISSION_CHECK_DISABLED
#define rk_capable() RK_TRUE
# 298 "/home/root/kernel/kernel/include/rk/rkmod.h"
static inline void
rs_proc_list_apply(struct list_head *proc_list_head,
void (*func)(struct task_struct *p, int arg), int arg)
{
struct list_head *proc_list = proc_list_head->next;
struct task_struct *p;
while (proc_list != proc_list_head) {
p = (( struct task_struct *)((char *)( proc_list )-(unsigned long)(&(( struct task_struct *)0)-> rk_proclist ))) ;
func(p, arg);
proc_list = proc_list->next;
}
}
static inline void
rs_reserve_apply(struct list_head *proc_list_head,
void (*func)(rk_reserve_t rsv, struct task_struct *p), rk_reserve_t rsv)
{
struct list_head *proc_list = proc_list_head->next;
struct task_struct *p;
while (proc_list != proc_list_head) {
p = (( struct task_struct *)((char *)( proc_list )-(unsigned long)(&(( struct task_struct *)0)-> rk_proclist ))) ;
func(rsv, p);
proc_list = proc_list->next;
}
}
static inline int ceiling(unsigned long dividend, unsigned long divider)
{
int quotient;
quotient = dividend / divider;
if (divider * quotient == dividend) return(quotient);
else return(++quotient);
}
static inline int
timespec_ceiling(struct timespec dividend, struct timespec divider)
{
int quotient = 1;
struct timespec divider1;
divider1 = divider;
while (((( dividend ).tv_sec > ( divider1 ).tv_sec) || ((( dividend ).tv_sec == ( divider1 ).tv_sec) && (( dividend ).tv_nsec > ( divider1 ).tv_nsec))) ) {
do { ( divider1 ).tv_nsec += ( divider ).tv_nsec; ( divider1 ).tv_sec += ( divider ).tv_sec; if (( divider1 ).tv_nsec >= (1000000000L) ) { ( divider1 ).tv_nsec -= (1000000000L) ; ( divider1 ).tv_sec++; } } while (0) ;
quotient++;
}
return(quotient);
}
static inline int
efficient_timespec_ceil(struct timespec dividend, struct timespec divider)
{
unsigned long dividend_microsecs, divider_microsecs;
if ((divider.tv_sec == 0) && (divider.tv_nsec == 0)) {
return -1;
}
if ((dividend.tv_sec >= 1000) || (divider.tv_sec >= 1000) ){
return(timespec_ceiling(dividend, divider));
}
#define MICROSECS_PER_SECOND 1000000
dividend_microsecs = (dividend.tv_sec % 1000) * 1000000 +
(dividend.tv_nsec / 1000);
divider_microsecs = (divider.tv_sec % 1000) * 1000000 +
(divider.tv_nsec / 1000);
return(ceiling(dividend_microsecs, divider_microsecs));
}
static inline struct timespec
timespec_mult(struct timespec multiplicand, int multiplier)
{
struct timespec result;
result.tv_sec = 0;
result.tv_nsec = 0;
do {
do { ( result ).tv_nsec += ( multiplicand ).tv_nsec; ( result ).tv_sec += ( multiplicand ).tv_sec; if (( result ).tv_nsec >= (1000000000L) ) { ( result ).tv_nsec -= (1000000000L) ; ( result ).tv_sec++; } } while (0) ;
} while (--multiplier);
return(result);
}
#define MIN_RK_SYSCALL 402
#define MAX_RK_SYSCALL 443
int rk_valid_rs(rk_resource_set_t);
int rk_valid_rsv(rk_reserve_t);
int resource_set_attach_process(rk_resource_set_t, task_struct *tsk);
int resource_set_detach_process(rk_resource_set_t, task_struct *tsk);
int rk_resource_set_attach_reserve(rk_resource_set_t, rk_reserve_t);
void rk_resource_set_detach_reserve(rk_resource_set_t, rk_reserve_t);
rk_resource_set_t rk_resource_set_create(char *name);
rk_reserve_t rk_reserve_create(struct timespec);
extern int rk_reserve_destroy(rk_reserve_t);
void reserve_send_signal(rk_reserve_t rsv, int type);
int call_cpu_reserve_create(rk_resource_set_t, rk_reserve_t *, void *);
int cpu_reserve_create(rk_resource_set_t, rk_reserve_t *, cpu_reserve_attr_t);
int call_cpu_reserve_ctl(rk_resource_set_t, void *);
int cpu_reserve_ctl(rk_resource_set_t, cpu_reserve_attr_t);
int cpu_reserve_delete(rk_resource_set_t rs);
int rk_cpu_reserves_get_num(void);
int rk_cpu_reserves_get_list(rk_reserve_t *, int);
int rk_cpu_reserves_get_scheduling_policy(void);
int rk_cpu_reserves_set_scheduling_policy(int);
int rk_cpu_reserve_get_attr(rk_reserve_t, void *);
void cpu_reserve_init(void);
void rt_mutex_init(void);
void rk_init(void);
void rk_enable_schedule_cpu(void);
void rk_disable_schedule_cpu(void);
void rk_enable_isr(void);
void rk_disable_isr(void);
int rk_ret_with_reschedule(struct pt_regs regs);
void rk_restore_all(struct pt_regs regs);
void rk_proc_rs_create(rk_resource_set_t);
void rk_proc_rs_destroy(rk_resource_set_t);
void rk_proc_reserve_create(rk_reserve_t);
void rk_proc_reserve_destroy(rk_reserve_t);
void rk_proc_cleanup(void);
void rk_reserve_signals_cleanup(rk_reserve_t);
rk_resource_set_t sys_rk_resource_set_create(char *name);
int sys_rk_resource_set_destroy(rk_resource_set_t rs);
int sys_rk_resource_set_attach_process(rk_resource_set_t rs, pid_t pid);
int sys_rk_resource_set_detach_process(rk_resource_set_t rs, pid_t pid);
int sys_rk_resource_sets_get_num(void);
int sys_rk_resource_sets_get_list(rk_resource_set_t *rs, int size);
int sys_rk_resource_set_get_proclist(rk_resource_set_t, pid_t *, int);
int sys_rk_resource_set_get_num_procs(rk_resource_set_t rs);
int sys_rk_resource_set_get_name(rk_resource_set_t rs, char * name);
int sys_rk_resource_set_set_name(rk_resource_set_t rs, char *name);
rk_reserve_t sys_rk_resource_set_get_rsv(rk_resource_set_t, rk_reserve_type_t);
int sys_rk_reserve_create(rk_resource_set_t, rk_reserve_type_t,
rk_reserve_t *, void *);
int sys_rk_reserve_delete(rk_resource_set_t rs, rk_reserve_type_t type);
int sys_rk_reserve_ctl(rk_resource_set_t, rk_reserve_type_t, void *);
int sys_rk_reserves_get_num(rk_reserve_type_t type);
int sys_rk_reserves_get_list(rk_reserve_t *, int, rk_reserve_type_t);
int sys_rk_reserve_get_attr(rk_reserve_t, void *, rk_reserve_type_t);
int sys_rk_reserves_get_scheduling_policy(rk_reserve_type_t type);
int sys_rk_reserves_set_scheduling_policy(int policy, rk_reserve_type_t type);
int sys_rk_signal(pid_t pid, void *data, int type, sigevent_t *evp);
rk_resource_set_t sys_rk_proc_get_rset(pid_t pid);
int sys_rt_make_periodic(struct timespec *_period, struct timespec *_start);
int sys_rt_wait_for_next_period(void);
int sys_rt_process_get_period(int pid, struct timespec *period);
int sys_rt_process_set_period(int pid, struct timespec *period);
unsigned long sys_rt_get_clock_frequency(void);
void sys_rk_inherit_mode(int mode);
# 22 "/home/root/kernel/kernel/include/linux/measure.h" 2
#define MEASURE_BEGIN 0
#define MEASURE_SLICE 1
#define MEASURE_END 2
#define MEASURE_INTERRUPT 3
#define MEASURE_IRQ 4
#define MEASURE_SOFTIRQ 5
#define MEASURE_SD 6
#define MEASURE_CS 7
#define MEASURE_DELAY 8
#define MEASURE_STACK 9
#define MEASURE_NEWPROCESS 100
#define MEASURE_ENDPROCESS 101
#define MEASURE_SYSCALL 102
#define MEASURE_CONTEXTSWAP_TO 103
#define MEASURE_USER_EVENT 104
#define MEASURE_EXEC 105
#define MEASURE_CRES_CREATE 110
#define MEASURE_CRES_DESTROY 111
#define MEASURE_CRES_SWAPTO 114
#define MEASURE_NRES_CREATE 115
#define MEASURE_NRES_DESTROY 116
#define MEASURE_NRES_SWAPTO 117
#define MEASURE_MUT_CREATE 120
#define MEASURE_MUT_DESTROY 121
#define MEASURE_MUT_LOCK 122
#define MEASURE_MUT_UNLOCK 123
#define MEASURE_MUTEX_BLOCKING 124
#define MEASURE_MUTEX_TRYLOCK_FAILED 125
#define MEASURE_RSET_CREATE 130
#define MEASURE_RSET_DESTROY 131
#define MEASURE_RSET_ATTACH 132
#define MEASURE_RSET_DETACH 133
#define MEASURE_RT_PER_START 140
#define MEASURE_RT_PER_NEXT 141
#define MEASURE_DISCARDED_DATA 142
#define MEASURE_NRRES_CREATE 143
#define MEASURE_NRRES_DESTROY 144
#define MEASURE_NRRES_SWAPTO 145
#define MEASURE_CHANGE_PRIORITY 146
#define MEASURE_MAKE_PERIODIC 147
#define MEASURE_CHANGE_PERIOD 148
#define MEASURE_RESERVE_CTL 149
#define MEASURE_CUSTOM_MIN 300
#define MEASURE_CUSTOM_MAX 500
#define MEASURE_OFF 0
#define MEASURE_ON 1
#define MEASURE_REGISTER_SYS 2
#define MEASURE_UNREGISTER_SYS 3
#define MEASURE_THRESHOLD 6
#define MEASURE_SET_IRQ 7
#define MEASURE_CLEAR_IRQ 8
#define MEASURE_GET_IRQ 9
#define MEASURE_MONITOR_INTERRUPT 10
#define MEASURE_MONITOR_PAGEFAULT 11
#define MEASURE_MONITOR_SOFTIRQ 12
#define MEASURE_MONITOR_SCHEDULE 13
#define MEASURE_MONITOR_CS 14
#define MEASURE_MONITOR_CONTEXTSWAP 15
#define MEASURE_MONITOR_NEWPROCESS 16
#define MEASURE_MONITOR_ENDPROCESS 17
#define MEASURE_NUM_CPUS 18
#define MEASURE_USER 19
#define MEASURE_LOG_MASK 21
#define MEASURE_GET_LOG_MASK 22
#define MUTEX_FAMILY_EVENT 0x000001
#define PROCESS_FAMILY_EVENT 0x000002
#define RESERVE_FAMILY_EVENT 0x000004
#define RESOURCE_FAMILY_EVENT 0x000008
#define PERIOD_FAMILY_EVENT 0x000010
#define PRIORITY_FAMILY_EVENT 0x000020
typedef struct {
unsigned int flags;
pid_t pid;
unsigned long data;
unsigned long data2;
unsigned long long measure;
} MEASURE;
#define MEASURE_MAX_ENTRY 10000
int sys_measure_register(int pid,int cmd,unsigned long data);
int sys_measure_getinfo(MEASURE *buf,int no_seg);
#define measure_user(flag) measure_register(-1,MEASURE_USER_EVENT,flag)
typedef struct {
int (*reg)(int pid,int cmd,unsigned long data);
int (*getinfo)(MEASURE *, int no_seg);
void (*contextswap)(int pid);
void (*newprocess)(int pid);
void (*endprocess)(int pid);
void (*exec)(int pid);
void (*syscall)(int pid, int no);
void (*event)(int pid, unsigned int type, unsigned long data);
void (*mutex_create)(int id);
void (*mutex_destroy)(int id);
void (*mutex_lock)(int id, int pid);
void (*mutex_unlock)(int id, int pid);
void (*mutex_block)(int id, int pid);
void (*mutex_trylockfail)(int id, int pid);
void (*new_reserve)(rk_reserve_t rsv);
void (*end_reserve)(rk_reserve_t rsv);
void (*rsv_swapto)(rk_reserve_t rsv, rk_reserve_type_t type);
void (*resource_create)(rk_resource_set_t id);
void (*resource_destroy)(rk_resource_set_t id);
void (*resource_attach)(rk_resource_set_t id);
void (*resource_detach)(rk_resource_set_t id);
void (*period_start)(int pid);
void (*next_period)(int pid);
void (*ctl_reserve)(rk_reserve_t rsv);
void (*change_priority)(int pid, int priority);
void (*make_periodic) (int pid,struct timespec *period,
struct timespec *start);
void (*change_period) (int pid, struct timespec *period);
} MeasureOp;
extern MeasureOp *current_measure_hook;
# 201 "/home/root/kernel/kernel/include/linux/measure.h"
extern inline void measure_contextswap(int newpid)
{
if (current_measure_hook && current_measure_hook->contextswap)
current_measure_hook->contextswap(newpid);
}
extern inline void measure_newprocess(int newpid)
{
if (current_measure_hook && current_measure_hook->newprocess)
current_measure_hook->newprocess(newpid);
}
extern inline void measure_endprocess(int pid)
{
if (current_measure_hook && current_measure_hook->endprocess)
current_measure_hook->endprocess(pid);
}
extern inline void measure_exec(int pid)
{
if (current_measure_hook && current_measure_hook->exec)
current_measure_hook->exec(pid);
}
extern inline void measure_event(int pid, unsigned int type, unsigned long data)
{
if (current_measure_hook && current_measure_hook->event)
current_measure_hook->event(pid,type,data);
}
extern inline void measure_mutex_block(int pid, int id)
{
if(current_measure_hook && current_measure_hook->mutex_block)
current_measure_hook->mutex_block(pid, id);
}
extern inline void measure_mutex_trylockfail(int pid, int id)
{
if(current_measure_hook && current_measure_hook->mutex_trylockfail)
current_measure_hook->mutex_trylockfail(pid, id);
}
extern inline void measure_change_priority(int pid, int priority)
{
if (current_measure_hook && current_measure_hook->change_priority)
current_measure_hook->change_priority(pid,priority);
}
extern inline void measure_make_periodic(int pid, struct timespec *period,
struct timespec *start)
{
if (current_measure_hook && current_measure_hook->make_periodic)
current_measure_hook->make_periodic(pid,period,start);
}
extern inline void measure_change_period(int pid, struct timespec *period)
{
if (current_measure_hook && current_measure_hook->change_period)
current_measure_hook->change_period(pid,period);
}
extern inline void measure_newreserve(rk_reserve_t rsv)
{
if (current_measure_hook && current_measure_hook->new_reserve)
current_measure_hook->new_reserve(rsv);
}
extern inline void measure_endreserve(rk_reserve_t rsv)
{
if (current_measure_hook && current_measure_hook->end_reserve)
current_measure_hook->end_reserve(rsv);
}
extern inline void measure_reserve_swapto(rk_reserve_t cpu, rk_reserve_type_t type)
{
if (current_measure_hook && current_measure_hook->rsv_swapto)
current_measure_hook->rsv_swapto(cpu,type);
}
extern inline void measure_mutex_create(int id)
{
if (current_measure_hook && current_measure_hook->mutex_create)
current_measure_hook->mutex_create(id);
}
extern inline void measure_mutex_destroy(int id)
{
if (current_measure_hook && current_measure_hook->mutex_destroy)
current_measure_hook->mutex_destroy(id);
}
extern inline void measure_mutex_lock(int id, int pid)
{
if (current_measure_hook && current_measure_hook->mutex_lock)
current_measure_hook->mutex_lock(id,pid);
}
extern inline void measure_mutex_unlock(int id, int pid)
{
if (current_measure_hook && current_measure_hook->mutex_unlock)
current_measure_hook->mutex_unlock(id,pid);
}
extern inline void measure_resource_create(rk_resource_set_t id)
{
if (current_measure_hook && current_measure_hook->resource_create)
current_measure_hook->resource_create(id);
}
extern inline void measure_resource_destroy(rk_resource_set_t id)
{
if (current_measure_hook && current_measure_hook->resource_destroy)
current_measure_hook->resource_destroy(id);
}
extern inline void measure_resource_attach(rk_resource_set_t id)
{
if (current_measure_hook && current_measure_hook->resource_attach)
current_measure_hook->resource_attach(id);
}
extern inline void measure_resource_detach(rk_resource_set_t id)
{
if (current_measure_hook && current_measure_hook->resource_detach)
current_measure_hook->resource_detach(id);
}
extern inline void measure_period_start(int pid)
{
if (current_measure_hook && current_measure_hook->period_start)
current_measure_hook->period_start(pid);
}
extern inline void measure_next_period(int pid)
{
if (current_measure_hook && current_measure_hook->next_period)
current_measure_hook->next_period(pid);
}
# 16 "/home/root/kernel/kernel/include/linux/mutex.h" 2
extern old_spinlock_t mutex_lock;
typedef struct user_mutex_t {
struct user_mutex_t *next;
int id;
int uid;
int gid;
mutex_t mtx;
int ceiling, ceiling_policy;
atomic_t count;
} user_mutex_t;
typedef struct {
task_struct *head[1 ];
task_struct *tail[1 ];
struct list_head node;
} mutex_sched;
#define mutex_is_locked(x) ((x)->state != MUTEX_UNLOCKED)
#define mutex_unlock_wait(x) do { if (mutex_is_locked(x)) { write_lock(x); write_unlock(x); } } while (0)
void do_read_lock(mutex_t *lock);
void do_write_lock(mutex_t *lock);
void do_unlock(mutex_t *lock);
extern int sched_init_done;
static inline mutex_list_t *get_mutex_list_slot(mutex_t *lock)
{
mutex_list_t *node;
for (node = lock->owners; node->proc; node++);
return node;
}
static inline void link_mutex_list(task_struct *p, mutex_list_t *node,
mutex_t *lock)
{
node->proc = p;
node->next = p->locks_held;
node->prev = ((void *)0) ;
node->mutex = lock;
if (p->locks_held)
p->locks_held->prev = node;
p->locks_held = node;
}
static inline mutex_list_t *unlink_mutex_list(task_struct *p, mutex_t *lock)
{
mutex_list_t *node = p->locks_held;
while (node) {
if (node->mutex == lock)
break;
node = node->next;
}
if (node->prev)
node->prev->next = node->next;
else
p->locks_held = node->next;
if (node->next)
node->next->prev = node->prev;
node->proc = ((void *)0) ;
return node;
}
# 131 "/home/root/kernel/kernel/include/linux/mutex.h"
static inline int mutex_trylock(mutex_t *lock)
{
unsigned long flags;
int ret = 0;
do { ({__save_flags_ptr((unsigned long *)& flags ) ;__cli();}) ; (void)( &mutex_lock ) ; } while (0) ;
if (lock->state == 0 ) {
lock->state = 1 ;
ret = 1;
link_mutex_list(current, lock->owners, lock);
if (lock->proto == 2 ) {
extern void (*recalc_prio_hook)(task_struct *p);
if (recalc_prio_hook)
recalc_prio_hook(current);
}
}
do { (void)( &mutex_lock ) ; __restore_flags( flags ) ; } while (0) ;
return ret;
}
void bust_spinlocks(void);
static inline void read_lock(mutex_t *lock)
{
unsigned long flags;
# 176 "/home/root/kernel/kernel/include/linux/mutex.h"
do { ({__save_flags_ptr((unsigned long *)& flags ) ;__cli();}) ; (void)( &mutex_lock ) ; } while (0) ;
if (lock->state != 1 && lock->num_readers != (16) &&
!lock->blocked_head)
{
mutex_list_t *node;
node = get_mutex_list_slot(lock);
link_mutex_list(current, node, lock);
lock->num_readers++;
lock->state = 2 ;
do { (void)( &mutex_lock ) ; __restore_flags( flags ) ; } while (0) ;
} else {
do_read_lock(lock);
__restore_flags( flags ) ;
}
}
static inline void read_unlock_nosched(mutex_t *lock)
{
unsigned long flags;
do { ({__save_flags_ptr((unsigned long *)& flags ) ;__cli();}) ; (void)( &mutex_lock ) ; } while (0) ;
lock->num_readers--;
if (!lock->blocked_head) {
extern void (*recalc_prio_hook)(task_struct *p);
unlink_mutex_list(current, lock);
if (recalc_prio_hook)
recalc_prio_hook(current);
if (!lock->num_readers)
lock->state = 0 ;
} else {
do_unlock(lock);
}
do { (void)( &mutex_lock ) ; __restore_flags( flags ) ; } while (0) ;
}
static inline void read_unlock(mutex_t *lock)
{
read_unlock_nosched(lock);
if (current->need_resched)
preempt();
}
static inline void write_lock(mutex_t *lock)
{
unsigned long flags;
# 251 "/home/root/kernel/kernel/include/linux/mutex.h"
do { ({__save_flags_ptr((unsigned long *)& flags ) ;__cli();}) ; (void)( &mutex_lock ) ; } while (0) ;
if (lock->state == 0 ) {
lock->state = 1 ;
if (lock->umtx)
measure_mutex_lock(lock->umtx->id, current->pid);
link_mutex_list(current, lock->owners, lock);
do { (void)( &mutex_lock ) ; __restore_flags( flags ) ; } while (0) ;
} else {
do_write_lock(lock);
__restore_flags( flags ) ;
}
}
static inline void write_unlock_nosched(mutex_t *lock)
{
unsigned long flags;
do { ({__save_flags_ptr((unsigned long *)& flags ) ;__cli();}) ; (void)( &mutex_lock ) ; } while (0) ;
if (!lock->blocked_head) {
lock->state = 0 ;
unlink_mutex_list(current, lock);
} else {
do_unlock(lock);
}
do { (void)( &mutex_lock ) ; __restore_flags( flags ) ; } while (0) ;
}
static inline void write_unlock(mutex_t *lock)
{
write_unlock_nosched(lock);
if (current->need_resched)
preempt();
}
#define spin_lock_irq write_lock
#define spin_unlock_irq write_unlock
#define spin_lock_bh write_lock
#define spin_unlock_bh write_unlock
#define read_lock_irq read_lock
#define read_unlock_irq read_unlock
#define write_lock_irq write_lock
#define write_unlock_irq write_unlock
#define read_lock_bh read_lock
#define read_unlock_bh read_unlock
#define write_lock_bh write_lock
#define write_unlock_bh write_unlock
#define read_lock_irqsave(lock, flags) do { read_lock(lock); (void)flags; } while (0)
#define read_unlock_irqrestore(lock, flags) do { read_unlock(lock); (void)flags; } while (0)
#define write_lock_irqsave(lock, flags) do { write_lock(lock); (void)flags; } while (0)
#define write_unlock_irqrestore(lock, flags) do { write_unlock(lock); (void)flags; } while (0)
#define spin_lock_irqsave write_lock_irqsave
#define spin_unlock_irqrestore write_unlock_irqrestore
int alloc_mutex_sched(void);
void free_mutex_sched(void);
void mutex_sched_init(void);
# 7 "/home/root/kernel/kernel/include/linux/sched.h" 2
# 1 "/home/root/kernel/kernel/include/linux/fs.h" 1
#define __LINUX_FS_H
# 1 "/home/root/kernel/kernel/include/linux/dcache.h" 1
#define __LINUX_DCACHE_H
extern mutex_t dcache_lock;
static __inline__ void d_drop(struct dentry * dentry)
{
write_lock (&dcache_lock);
list_del(&dentry->d_hash);
do { ( &dentry->d_hash )->next = ( &dentry->d_hash ); ( &dentry->d_hash )->prev = ( &dentry->d_hash ); } while (0) ;
write_unlock (&dcache_lock);
}
static __inline__ int dname_external(struct dentry *d)
{
return d->d_name.name != d->d_iname;
}
extern void d_instantiate(struct dentry *, struct inode *);
extern void d_delete(struct dentry *);
extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
extern void shrink_dcache_sb(struct super_block *);
extern void shrink_dcache_parent(struct dentry *);
extern int d_invalidate(struct dentry *);
#define shrink_dcache() prune_dcache(0)
struct zone_struct;
extern void shrink_dcache_memory(int, unsigned int);
extern void prune_dcache(int);
extern void shrink_icache_memory(int, int);
extern void prune_icache(int);
extern struct dentry * d_alloc_root(struct inode *);
extern void d_genocide(struct dentry *);
extern struct dentry *d_find_alias(struct inode *);
extern void d_prune_aliases(struct inode *);
extern int have_submounts(struct dentry *);
extern void d_rehash(struct dentry *);
static __inline__ void d_add(struct dentry * entry, struct inode * inode)
{
d_instantiate(entry, inode);
d_rehash(entry);
}
extern void d_move(struct dentry *, struct dentry *);
extern struct dentry * d_lookup(struct dentry *, struct qstr *);
extern int d_validate(struct dentry *, struct dentry *);
extern char * __d_path(struct dentry *, struct vfsmount *, struct dentry *,
struct vfsmount *, char *, int);
static __inline__ struct dentry * dget(struct dentry *dentry)
{
if (dentry) {
if (! (( &dentry->d_count )->counter) )
do { bust_spinlocks (); printk("kernel BUG at %s:%d!\n", "/home/root/kernel/kernel/include/linux/dcache.h", 127); __asm__ __volatile__(".long 0x0"); } while (0) ;
((void) atomic_inc_return(( &dentry->d_count ))) ;
}
return dentry;
}
extern struct dentry * dget_locked(struct dentry *);
static __inline__ int d_unhashed(struct dentry *dentry)
{
return list_empty(&dentry->d_hash);
}
extern void dput(struct dentry *);
static __inline__ int d_mountpoint(struct dentry *dentry)
{
return dentry->d_mounted;
}
extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
# 5 "/home/root/kernel/kernel/include/linux/fs.h" 2
static inline struct dentry *lock_parent(struct dentry *dentry)
{
struct dentry *dir = dget(dentry->d_parent);
down(&dir->d_inode->i_sem);
return dir;
}
static inline struct dentry *get_parent(struct dentry *dentry)
{
return dget(dentry->d_parent);
}
static inline void unlock_dir(struct dentry *dir)
{
up(&dir->d_inode->i_sem);
dput(dir);
}
static inline void double_down(struct semaphore *s1, struct semaphore *s2)
{
if (s1 != s2) {
if ((unsigned long) s1 < (unsigned long) s2) {
struct semaphore *tmp = s2;
s2 = s1; s1 = tmp;
}
down(s1);
}
down(s2);
}
static inline void triple_down(struct semaphore *s1,
struct semaphore *s2,
struct semaphore *s3)
{
if (s1 != s2) {
if ((unsigned long) s1 < (unsigned long) s2) {
if ((unsigned long) s1 < (unsigned long) s3) {
struct semaphore *tmp = s3;
s3 = s1; s1 = tmp;
}
if ((unsigned long) s1 < (unsigned long) s2) {
struct semaphore *tmp = s2;
s2 = s1; s1 = tmp;
}
} else {
if ((unsigned long) s1 < (unsigned long) s3) {
struct semaphore *tmp = s3;
s3 = s1; s1 = tmp;
}
if ((unsigned long) s2 < (unsigned long) s3) {
struct semaphore *tmp = s3;
s3 = s2; s2 = tmp;
}
}
down(s1);
} else if ((unsigned long) s2 < (unsigned long) s3) {
struct semaphore *tmp = s3;
s3 = s2; s2 = tmp;
}
down(s2);
down(s3);
}
static inline void double_up(struct semaphore *s1, struct semaphore *s2)
{
up(s1);
if (s1 != s2)
up(s2);
}
static inline void triple_up(struct semaphore *s1,
struct semaphore *s2,
struct semaphore *s3)
{
up(s1);
if (s1 != s2)
up(s2);
up(s3);
}
static inline void double_lock(struct dentry *d1, struct dentry *d2)
{
double_down(&d1->d_inode->i_sem, &d2->d_inode->i_sem);
}
static inline void double_unlock(struct dentry *d1, struct dentry *d2)
{
double_up(&d1->d_inode->i_sem,&d2->d_inode->i_sem);
dput(d1);
dput(d2);
}
# 8 "/home/root/kernel/kernel/include/linux/sched.h" 2
# 1 "/home/root/kernel/kernel/include/linux/fs_struct.h" 1
#define _LINUX_FS_STRUCT_H
static inline void set_fs_root(struct fs_struct *fs,
struct vfsmount *mnt,
struct dentry *dentry)
{
struct dentry *old_root;
struct vfsmount *old_rootmnt;
write_lock(&fs->lock);
old_root = fs->root;
old_rootmnt = fs->rootmnt;
fs->rootmnt = mntget(mnt);
fs->root = dget(dentry);
write_unlock(&fs->lock);
if (old_root) {
dput(old_root);
mntput(old_rootmnt);
}
}
static inline void set_fs_pwd(struct fs_struct *fs,
struct vfsmount *mnt,
struct dentry *dentry)
{
struct dentry *old_pwd;
struct vfsmount *old_pwdmnt;
write_lock(&fs->lock);
old_pwd = fs->pwd;
old_pwdmnt = fs->pwdmnt;
fs->pwdmnt = mntget(mnt);
fs->pwd = dget(dentry);
write_unlock(&fs->lock);
if (old_pwd) {
dput(old_pwd);
mntput(old_pwdmnt);
}
}
# 9 "/home/root/kernel/kernel/include/linux/sched.h" 2
extern union task_union init_task_union;
extern struct mm_struct init_mm;
extern struct task_struct *init_tasks[1 ];
#define PIDHASH_SZ (4096 >> 2)
extern struct task_struct *pidhash[(4096 >> 2) ];
#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))
static inline void hash_pid(struct task_struct *p)
{
struct task_struct **htable = &pidhash[(((( p->pid ) >> 8) ^ ( p->pid )) & ((4096 >> 2) - 1)) ];
if((p->pidhash_next = *htable) != ((void *)0) )
(*htable)->pidhash_pprev = &p->pidhash_next;
*htable = p;
p->pidhash_pprev = htable;
}
static inline void unhash_pid(struct task_struct *p)
{
if(p->pidhash_next)
p->pidhash_next->pidhash_pprev = p->pidhash_pprev;
*p->pidhash_pprev = p->pidhash_next;
}
static inline struct task_struct *find_task_by_pid(int pid)
{
struct task_struct *p, **htable = &pidhash[(((( pid ) >> 8) ^ ( pid )) & ((4096 >> 2) - 1)) ];
for(p = *htable; p && p->pid != pid; p = p->pidhash_next)
;
return p;
}
extern struct user_struct * alloc_uid(uid_t);
extern void free_uid(struct user_struct *);
# 1 "/home/root/kernel/kernel/include/asm/current.h" 1
# 13 "/home/root/kernel/kernel/include/asm/current.h"
# 54 "/home/root/kernel/kernel/include/linux/sched.h" 2
extern unsigned long volatile jiffies;
extern unsigned long itimer_ticks;
extern unsigned long itimer_next;
extern struct timeval xtime;
extern void do_timer(void);
extern unsigned int * prof_buffer;
extern unsigned long prof_len;
extern unsigned long prof_shift;
#define CURRENT_TIME (xtime.tv_sec)
extern void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr) ;
extern void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr) ;
extern void sleep_on(wait_queue_head_t *q) ;
extern long sleep_on_timeout(wait_queue_head_t *q,
signed long timeout) ;
extern void interruptible_sleep_on(wait_queue_head_t *q) ;
extern long interruptible_sleep_on_timeout(wait_queue_head_t *q,
signed long timeout) ;
extern int wake_up_process(struct task_struct * tsk) ;
extern void wake_up_mutex(struct task_struct *tsk) ;
#define wake_up(x) __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1)
#define wake_up_nr(x, nr) __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, nr)
#define wake_up_all(x) __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 0)
#define wake_up_sync(x) __wake_up_sync((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1)
#define wake_up_sync_nr(x, nr) __wake_up_sync((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, nr)
#define wake_up_interruptible(x) __wake_up((x),TASK_INTERRUPTIBLE, 1)
#define wake_up_interruptible_nr(x, nr) __wake_up((x),TASK_INTERRUPTIBLE, nr)
#define wake_up_interruptible_all(x) __wake_up((x),TASK_INTERRUPTIBLE, 0)
#define wake_up_interruptible_sync(x) __wake_up_sync((x),TASK_INTERRUPTIBLE, 1)
#define wake_up_interruptible_sync_nr(x) __wake_up_sync((x),TASK_INTERRUPTIBLE, nr)
long sys_wait4(pid_t pid,unsigned int * stat_addr, int options, struct rusage * ru);
extern int in_group_p(gid_t);
extern int in_egroup_p(gid_t);
extern void proc_caches_init(void);
extern void flush_signals(struct task_struct *);
extern void flush_signal_handlers(struct task_struct *);
extern int dequeue_signal(sigset_t *, siginfo_t *);
extern void block_all_signals(int (*notifier)(void *priv), void *priv,
sigset_t *mask);
extern void unblock_all_signals(void);
extern int send_sig_info(int, struct siginfo *, struct task_struct *);
extern int force_sig_info(int, struct siginfo *, struct task_struct *);
extern int kill_pg_info(int, struct siginfo *, pid_t);
extern int kill_sl_info(int, struct siginfo *, pid_t);
extern int kill_proc_info(int, struct siginfo *, pid_t);
extern void notify_parent(struct task_struct *, int);
extern void do_notify_parent(struct task_struct *, int);
extern void force_sig(int, struct task_struct *);
extern int send_sig(int, struct task_struct *, int);
extern int kill_pg(pid_t, int, int);
extern int kill_sl(pid_t, int, int);
extern int kill_proc(pid_t, int, int);
extern int do_sigaction(int, const struct k_sigaction *, struct k_sigaction *);
extern int do_sigaltstack(const stack_t *, stack_t *, unsigned long);
static inline int signal_pending(struct task_struct *p)
{
return (p->sigpending != 0);
}
static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
{
unsigned long ready;
long i;
switch ((64 / 32 ) ) {
default:
for (i = (64 / 32 ) , ready = 0; --i >= 0 ;)
ready |= signal->sig[i] &~ blocked->sig[i];
break;
case 4: ready = signal->sig[3] &~ blocked->sig[3];
ready |= signal->sig[2] &~ blocked->sig[2];
ready |= signal->sig[1] &~ blocked->sig[1];
ready |= signal->sig[0] &~ blocked->sig[0];
break;
case 2: ready = signal->sig[1] &~ blocked->sig[1];
ready |= signal->sig[0] &~ blocked->sig[0];
break;
case 1: ready = signal->sig[0] &~ blocked->sig[0];
}
return ready != 0;
}
static inline void recalc_sigpending(struct task_struct *t)
{
t->sigpending = has_pending_signals(&t->pending.signal, &t->blocked);
}
static inline int on_sig_stack(unsigned long sp)
{
return (sp - current->sas_ss_sp < current->sas_ss_size);
}
static inline int sas_ss_flags(unsigned long sp)
{
return (current->sas_ss_size == 0 ? 2
: on_sig_stack(sp) ? 1 : 0);
}
extern int request_irq(unsigned int irq,
void (*handler)(int, void *, struct pt_regs *),
unsigned long flags,
const char *device,
void *dev_id);
extern void free_irq(unsigned int irq, void *dev_id);
static inline int suser(void)
{
if (! ( (1 << ( 0 +1)) & 0x00000000 ? (1 << ( 0 )) & 0x00000000 : (1 << ( 0 )) & securebits ) && current->euid == 0) {
current->flags |= 0x00000100 ;
return 1;
}
return 0;
}
static inline int fsuser(void)
{
if (! ( (1 << ( 0 +1)) & 0x00000000 ? (1 << ( 0 )) & 0x00000000 : (1 << ( 0 )) & securebits ) && current->fsuid == 0) {
current->flags |= 0x00000100 ;
return 1;
}
return 0;
}
static inline int capable(int cap)
{
if ((( current->cap_effective ) & (1 << ( cap )) ) )
{
current->flags |= 0x00000100 ;
return 1;
}
return 0;
}
extern struct mm_struct * mm_alloc(void);
extern struct mm_struct * start_lazy_tlb(void);
extern void end_lazy_tlb(struct mm_struct *mm);
extern inline void __mmdrop(struct mm_struct *) ;
extern inline void __mmdrop_lazy(struct mm_struct *) ;
static inline void mmdrop(struct mm_struct * mm)
{
__mmdrop(mm);
}
static inline void mmdrop_lazy(struct mm_struct * mm)
{
if ((atomic_dec_return(( &mm->mm_count )) == 0) )
__mmdrop_lazy(mm);
}
extern void mmput(struct mm_struct *);
extern void mm_release(void);
extern struct file ** alloc_fd_array(int);
extern int expand_fd_array(struct files_struct *, int nr);
extern void free_fd_array(struct file **, int);
extern fd_set *alloc_fdset(int);
extern int expand_fdset(struct files_struct *, int nr);
extern void free_fdset(fd_set *, int);
extern int copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
extern void flush_thread(void);
extern void exit_thread(void);
extern void exit_mm(struct task_struct *);
extern void exit_files(struct task_struct *);
extern void exit_sighand(struct task_struct *);
extern void daemonize(void);
extern int do_execve(char *, char **, char **, struct pt_regs *);
extern int do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long);
extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait) ;
extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait) ;
extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait) ;
#define __wait_event(wq, condition) do { wait_queue_t __wait; init_waitqueue_entry(&__wait, current); add_wait_queue(&wq, &__wait); for (;;) { set_current_state(TASK_UNINTERRUPTIBLE); if (condition) break; schedule(); } current->state = TASK_RUNNING; rem ove_wait_queue(&wq, &__wait); } while (0)
# 303 "/home/root/kernel/kernel/include/linux/sched.h"
#define wait_event(wq, condition) do { if (condition) break; __wait_event(wq, condition); } while (0)
#define __wait_event_interruptible(wq, condition, ret) do { wait_queue_t __wait; init_waitqueue_entry(&__wait, current); add_wait_queue(&wq, &__wait); for (;;) { set_current_state(TASK_INTERRUPTIBLE); if (condition) break; if (!signal_pending(current)) { schedule(); continue; } ret = -ERESTARTSYS; break; } current->state = TASK_RUNNING; remove_wait_queue(&wq, &__wait); } while (0)
# 331 "/home/root/kernel/kernel/include/linux/sched.h"
#define wait_event_interruptible(wq, condition) ({ int __ret = 0; if (!(condition)) __wait_event_interruptible(wq, condition, __ret); __ret; })
#define REMOVE_LINKS(p) do { (p)->next_task->prev_task = (p)->prev_task; (p)->prev_task->next_task = (p)->next_task; if ((p)->p_osptr) (p)->p_osptr->p_ysptr = (p)->p_ysptr; if ((p)->p_ysptr) (p)->p_ysptr->p_osptr = (p)->p_osptr; else (p)->p_pptr->p_cptr = (p)->p_osptr; } while (0)
# 350 "/home/root/kernel/kernel/include/linux/sched.h"
#define SET_LINKS(p) do { (p)->next_task = &init_task; (p)->prev_task = init_task.prev_task; init_task.prev_task->next_task = (p); init_task.prev_task = (p); (p)->p_ysptr = NULL; if (((p)->p_osptr = (p)->p_pptr->p_cptr) != NULL) (p)->p_osptr->p_ysptr = p ; (p)->p_pptr->p_cptr = p; } while (0)
# 361 "/home/root/kernel/kernel/include/linux/sched.h"
#define for_each_task(p) for (p = &init_task ; (p = p->next_task) != &init_task ; )
#define next_thread(p) list_entry((p)->thread_group.next, struct task_struct, thread_group)
#define task_on_runqueue(p) (p->runnable)
static inline void unhash_process(struct task_struct *p)
{
if (( p ->runnable) ) do { bust_spinlocks (); printk("kernel BUG at %s:%d!\n", "/home/root/kernel/kernel/include/linux/sched.h", 372); __asm__ __volatile__(".long 0x0"); } while (0) ;
write_lock (&tasklist_lock);
nr_threads--;
unhash_pid(p);
do { ( p )->next_task->prev_task = ( p )->prev_task; ( p )->prev_task->next_task = ( p )->next_task; if (( p )->p_osptr) ( p )->p_osptr->p_ysptr = ( p )->p_ysptr; if (( p )->p_ysptr) ( p )->p_ysptr->p_osptr = ( p )->p_osptr; else ( p )->p_pptr->p_cptr = ( p )->p_osptr; } while (0) ;
list_del(&p->thread_group);
write_unlock (&tasklist_lock);
}
static inline void task_lock(struct task_struct *p)
{
write_lock (&p->alloc_lock);
}
static inline void task_unlock(struct task_struct *p)
{
write_unlock (&p->alloc_lock);
}
static inline char * d_path(struct dentry *dentry, struct vfsmount *vfsmnt,
char *buf, int buflen)
{
char *res;
struct vfsmount *rootmnt;
struct dentry *root;
read_lock(¤t->fs->lock);
rootmnt = mntget(current->fs->rootmnt);
root = dget(current->fs->root);
read_unlock(¤t->fs->lock);
write_lock (&dcache_lock);
res = __d_path(dentry, vfsmnt, root, rootmnt, buf, buflen);
write_unlock (&dcache_lock);
dput(root);
mntput(rootmnt);
return res;
}
void rt_setscheduler(task_struct *p, int prio, int policy, int cpu);
void update_time(void);
void send_signal_queue(struct sigqueue *q);
int adj_num_sigqueues(int adj);
void withdraw_signal_queue(struct sigqueue *q);
int try_to_wake_up(task_struct *p, int sync);
void timeshare_sched_give_time(task_struct *to, task_struct *from);
void timeshare_sched_init_proc(task_struct *p);
void timeshare_sched_init(void);
void posix_rt_sched_init(void);
void bind_cpu(task_struct *p, int cpu);
extern old_spinlock_t sched_lock;
extern mutex_t sigqueue_exit_lock;
extern old_spinlock_t sigqueue_state_lock;
extern task_struct *cli_owner;
extern mutex_t kthread_sem_lock;
extern struct semaphore kthread_sem;
static inline void check_resched(void)
{
if (!is_local_irq_enabled())
do { bust_spinlocks (); printk("kernel BUG at %s:%d!\n", "/home/root/kernel/kernel/include/linux/sched.h", 433); __asm__ __volatile__(".long 0x0"); } while (0) ;
if (current->need_resched && !(current->flags & 0x08000000 ))
preempt();
}
#define preempt_disable(flags) do { flags = current->flags; current->flags |= PF_NOPREEMPT; } while (0)
#define preempt_restore(flags) do { current->flags = flags; check_resched(); } while (0)
static inline void del_from_runqueue(task_struct *p)
{
# 466 "/home/root/kernel/kernel/include/linux/sched.h"
if (p->context[0].owner)
p->context[0].sched_ops->del(p, 0);
p->runnable = 0;
}
static inline void add_to_runqueue(task_struct *p)
{
# 491 "/home/root/kernel/kernel/include/linux/sched.h"
if (p->context[0].owner)
p->context[0].owner->sched_ops->add(p, 0);
p->runnable = 1;
}
static inline void add_to_runqueue_head(task_struct *p)
{
# 516 "/home/root/kernel/kernel/include/linux/sched.h"
if (p->context[0].owner)
p->context[0].owner->sched_ops->add_head(p, 0);
p->runnable = 1;
}
# 12 "panic.c" 2
# 1 "/home/root/kernel/kernel/include/linux/delay.h" 1
#define _LINUX_DELAY_H
extern unsigned long loops_per_jiffy;
# 1 "/home/root/kernel/kernel/include/asm/delay.h" 1
#define _PPC_DELAY_H
extern unsigned long loops_per_jiffy;
#define __MAX_UDELAY 1000000
extern void __delay(unsigned int loops);
extern __inline__ void __const_udelay(unsigned int secs)
{
unsigned int loops;
__asm__("mulhwu %0,%1,%2" : "=r" (loops) :
"r" (secs), "r" (loops_per_jiffy));
__delay(loops * 100 );
}
extern __inline__ void __udelay(unsigned int usecs)
{
__const_udelay(usecs * 4294);
}
extern void __bad_udelay(void);
#define udelay(n) (__builtin_constant_p(n)? ((n) > __MAX_UDELAY? __bad_udelay(): __const_udelay((n) * 4294u)) : __udelay(n))
# 12 "/home/root/kernel/kernel/include/linux/delay.h" 2
#define MAX_UDELAY_MS 5
#define mdelay(n) ( (__builtin_constant_p(n) && (n)<=MAX_UDELAY_MS) ? udelay((n)*1000) : ({unsigned long msec=(n); while (msec--) udelay(1000);}))
# 13 "panic.c" 2
# 1 "/home/root/kernel/kernel/include/linux/reboot.h" 1
#define _LINUX_REBOOT_H
#define LINUX_REBOOT_MAGIC1 0xfee1dead
#define LINUX_REBOOT_MAGIC2 672274793
#define LINUX_REBOOT_MAGIC2A 85072278
#define LINUX_REBOOT_MAGIC2B 369367448
#define LINUX_REBOOT_CMD_RESTART 0x01234567
#define LINUX_REBOOT_CMD_HALT 0xCDEF0123
#define LINUX_REBOOT_CMD_CAD_ON 0x89ABCDEF
#define LINUX_REBOOT_CMD_CAD_OFF 0x00000000
#define LINUX_REBOOT_CMD_POWER_OFF 0x4321FEDC
#define LINUX_REBOOT_CMD_RESTART2 0xA1B2C3D4
# 1 "/home/root/kernel/kernel/include/linux/notifier.h" 1
#define _LINUX_NOTIFIER_H
struct notifier_block
{
int (*notifier_call)(struct notifier_block *self, unsigned long, void *);
struct notifier_block *next;
int priority;
};
extern int notifier_chain_register(struct notifier_block **list, struct notifier_block *n);
extern int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n);
extern int notifier_call_chain(struct notifier_block **n, unsigned long val, void *v);
#define NOTIFY_DONE 0x0000
#define NOTIFY_OK 0x0001
#define NOTIFY_STOP_MASK 0x8000
#define NOTIFY_BAD (NOTIFY_STOP_MASK|0x0002)
#define NETDEV_UP 0x0001
#define NETDEV_DOWN 0x0002
#define NETDEV_REBOOT 0x0003
#define NETDEV_CHANGE 0x0004
#define NETDEV_REGISTER 0x0005
#define NETDEV_UNREGISTER 0x0006
#define NETDEV_CHANGEMTU 0x0007
#define NETDEV_CHANGEADDR 0x0008
#define NETDEV_GOING_DOWN 0x0009
#define NETDEV_CHANGENAME 0x000A
#define SYS_DOWN 0x0001
#define SYS_RESTART SYS_DOWN
#define SYS_HALT 0x0002
#define SYS_POWER_OFF 0x0003
# 35 "/home/root/kernel/kernel/include/linux/reboot.h" 2
extern int register_reboot_notifier(struct notifier_block *);
extern int unregister_reboot_notifier(struct notifier_block *);
extern void machine_restart(char *cmd);
extern void machine_halt(void);
extern void machine_power_off(void);
# 14 "panic.c" 2
# 1 "/home/root/kernel/kernel/include/linux/init.h" 1
#define _LINUX_INIT_H
typedef int (*initcall_t)(void);
typedef void (*exitcall_t)(void);
extern initcall_t __initcall_start, __initcall_end;
#define __initcall(fn) static initcall_t __initcall_##fn __init_call = fn
#define __exitcall(fn) static exitcall_t __exitcall_##fn __exit_call = fn
struct kernel_param {
const char *str;
int (*setup_func)(char *);
};
extern struct kernel_param __setup_start, __setup_end;
#define __setup(str, fn) static char __setup_str_##fn[] __initdata = str; static struct kernel_param __setup_##fn __attribute__((unused)) __initsetup = { __setup_str_##fn, fn }
#define __init __attribute__ ((__section__ (".text.init")))
#define __exit __attribute__ ((unused, __section__(".text.exit")))
#define __initdata __attribute__ ((__section__ (".data.init")))
#define __exitdata __attribute__ ((unused, __section__ (".data.exit")))
#define __initsetup __attribute__ ((unused,__section__ (".setup.init")))
#define __init_call __attribute__ ((unused,__section__ (".initcall.init")))
#define __exit_call __attribute__ ((unused,__section__ (".exitcall.exit")))
#define __INIT .section ".text.init","ax"
#define __FINIT .previous
#define __INITDATA .section ".data.init","aw"
#define module_init(x) __initcall(x);
#define module_exit(x) __exitcall(x);
# 144 "/home/root/kernel/kernel/include/linux/init.h"
#define __devinit
#define __devinitdata
#define __devexit
#define __devexitdata
# 16 "panic.c" 2
# 1 "/home/root/kernel/kernel/include/linux/sysrq.h" 1
struct pt_regs;
struct kbd_struct;
struct tty_struct;
void handle_sysrq(int, struct pt_regs *, struct kbd_struct *, struct tty_struct *);
extern int emergency_sync_scheduled;
#define EMERG_SYNC 1
#define EMERG_REMOUNT 2
void do_emergency_sync(void);
#define CHECK_EMERGENCY_SYNC if (emergency_sync_scheduled) do_emergency_sync();
# 17 "panic.c" 2
# 1 "/home/root/kernel/kernel/include/linux/interrupt.h" 1
#define _LINUX_INTERRUPT_H
# 1 "/home/root/kernel/kernel/include/linux/spinlock.h" 1
# 9 "/home/root/kernel/kernel/include/linux/interrupt.h" 2
# 1 "/home/root/kernel/kernel/include/asm/bitops.h" 1
# 376 "/home/root/kernel/kernel/include/asm/bitops.h"
# 11 "/home/root/kernel/kernel/include/linux/interrupt.h" 2
struct irqaction {
void (*handler)(int, void *, struct pt_regs *);
unsigned long flags;
unsigned long mask;
const char *name;
void *dev_id;
struct irqaction *next;
};
enum {
TIMER_BH = 0,
TQUEUE_BH,
DIGI_BH,
SERIAL_BH,
RISCOM8_BH,
SPECIALIX_BH,
AURORA_BH,
ESP_BH,
SCSI_BH,
IMMEDIATE_BH,
CYCLADES_BH,
CM206_BH,
JS_BH,
MACSERIAL_BH,
ISICOM_BH
};
# 1 "/home/root/kernel/kernel/include/asm/hardirq.h" 1
#define __ASM_HARDIRQ_H
# 1 "/home/root/kernel/kernel/include/asm/smp.h" 1
#define _PPC_SMP_H
# 65 "/home/root/kernel/kernel/include/asm/smp.h"
# 9 "/home/root/kernel/kernel/include/asm/hardirq.h" 2
typedef struct {
unsigned long __softirq_pending;
unsigned int __local_irq_count;
unsigned int __local_bh_count;
unsigned int __syscall_count;
struct task_struct * __ksoftirqd_task;
unsigned int __last_jiffy_stamp;
} __attribute__((__aligned__(16 ))) irq_cpustat_t;
# 1 "/home/root/kernel/kernel/include/linux/irq_cpustat.h" 1
#define __irq_cpustat_h
extern irq_cpustat_t irq_stat[];
#define __IRQ_STAT(cpu, member) ((void)(cpu), irq_stat[0].member)
extern int global_softirq_active, global_softirq_mask;
#define softirq_pending(cpu) __IRQ_STAT((cpu), __softirq_pending)
#define local_irq_count(cpu) __IRQ_STAT((cpu), __local_irq_count)
#define local_bh_count(cpu) __IRQ_STAT((cpu), __local_bh_count)
#define syscall_count(cpu) __IRQ_STAT((cpu), __syscall_count)
#define ksoftirqd_task(cpu) __IRQ_STAT((cpu), __ksoftirqd_task)
#define nmi_count(cpu) __IRQ_STAT((cpu), __nmi_count)
# 26 "/home/root/kernel/kernel/include/asm/hardirq.h" 2
#define last_jiffy_stamp(cpu) __IRQ_STAT((cpu), __last_jiffy_stamp)
# 57 "/home/root/kernel/kernel/include/asm/hardirq.h"
#define in_interrupt() (local_irq_count(0))
#define in_irq() (in_interrupt() || (current->flags & PF_IRQHANDLER))
#define hardirq_trylock(cpu) (local_irq_count(cpu) == 0)
#define hardirq_endlock(cpu) do { } while (0)
#define irq_enter(cpu, irq) (local_irq_count(cpu)++)
#define irq_exit(cpu, irq) (local_irq_count(cpu)--)
static inline int irqs_running (void)
{
int i;
for (i = 0; i < 1 ; i++) {
if (((void)( ( ({ (void) i ; 0; }) ) ), irq_stat[0]. __local_irq_count ) )
return 1;
}
return 0;
}
# 135 "/home/root/kernel/kernel/include/asm/hardirq.h"
extern void synchronize_irq(void);
# 46 "/home/root/kernel/kernel/include/linux/interrupt.h" 2
# 1 "/home/root/kernel/kernel/include/asm/softirq.h" 1
#define __ASM_SOFTIRQ_H
# 1 "/home/root/kernel/kernel/include/asm/hardirq.h" 1
# 139 "/home/root/kernel/kernel/include/asm/hardirq.h"
# 9 "/home/root/kernel/kernel/include/asm/softirq.h" 2
# 1 "/home/root/kernel/kernel/include/linux/spinlock.h" 1
# 10 "/home/root/kernel/kernel/include/asm/softirq.h" 2
#define __cpu_raise_softirq(cpu, nr) set_bit(nr, &softirq_pending(cpu))
extern mutex_t softirq_lock;
static inline void local_bh_disable(void)
{
}
static inline void local_bh_enable(void)
{
}
#define in_softirq() (current->bh_lock_depth)
# 47 "/home/root/kernel/kernel/include/linux/interrupt.h" 2
enum
{
HI_SOFTIRQ=0,
NET_TX_SOFTIRQ,
NET_RX_SOFTIRQ,
TASKLET_SOFTIRQ
};
struct softirq_action
{
void (*action)(struct softirq_action *, int cpu);
void *data;
};
extern void open_softirq(int nr, void (*action)(struct softirq_action*, int cpu), void *data);
extern void softirq_init(void);
extern void cpu_raise_softirq(unsigned int cpu, unsigned int nr) ;
extern void raise_softirq(unsigned int nr) ;
struct tasklet_struct
{
struct tasklet_struct *next;
unsigned long state;
atomic_t count;
void (*func)(unsigned long);
unsigned long data;
wait_queue_head_t wait;
};
#define DECLARE_TASKLET(name, func, data) struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data, __WAIT_QUEUE_HEAD_INITIALIZER(name.wait) }
#define DECLARE_TASKLET_DISABLED(name, func, data) struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data, __WAIT_QUEUE_HEAD_INITIALIZER(name.wait) }
enum
{
TASKLET_STATE_SCHED,
TASKLET_STATE_RUN,
TASKLET_STATE_PENDING
};
struct tasklet_head
{
struct tasklet_struct *list;
} __attribute__ ((__aligned__(16 )));
extern struct tasklet_head tasklet_vec[1 ];
extern struct tasklet_head tasklet_hi_vec[1 ];
#define tasklet_trylock(t) (!test_and_set_bit(TASKLET_STATE_RUN, &(t)->state))
#define tasklet_unlock(t) do { smp_mb__before_clear_bit(); clear_bit(TASKLET_STATE_RUN, &(t)->state); } while(0)
extern void tasklet_schedule(struct tasklet_struct *t);
extern void tasklet_hi_schedule(struct tasklet_struct *t);
static inline void tasklet_disable_nosync(struct tasklet_struct *t)
{
((void) atomic_inc_return(( &t->count ))) ;
}
void tasklet_sync(struct tasklet_struct *t);
static inline void tasklet_disable(struct tasklet_struct *t)
{
tasklet_disable_nosync(t);
tasklet_sync(t);
}
static inline void tasklet_enable(struct tasklet_struct *t)
{
if ((atomic_dec_return(( &t->count )) == 0) &&
test_bit(TASKLET_STATE_PENDING, &t->state))
tasklet_schedule(t);
}
static inline void tasklet_hi_enable(struct tasklet_struct *t)
{
if ((atomic_dec_return(( &t->count )) == 0) &&
test_bit(TASKLET_STATE_PENDING, &t->state))
tasklet_hi_schedule(t);
}
#define tasklet_kill(t) tasklet_disable(t)
extern void tasklet_init(struct tasklet_struct *t,
void (*func)(unsigned long),
unsigned long data);
# 185 "/home/root/kernel/kernel/include/linux/interrupt.h"
#define SMP_TIMER_NAME(name) name
#define SMP_TIMER_DEFINE(name, task)
extern struct tasklet_struct bh_task_vec[];
extern mutex_t global_bh_lock;
static inline void mark_bh(int nr)
{
tasklet_hi_schedule(bh_task_vec+nr);
}
extern void init_bh(int nr, void (*routine)(void));
extern void remove_bh(int nr);
extern unsigned long probe_irq_on(void);
extern int probe_irq_off(unsigned long);
extern unsigned int probe_irq_mask(unsigned long);
# 18 "panic.c" 2
void sys_sync(void);
extern void unblank_console(void);
int panic_timeout;
struct notifier_block *panic_notifier_list;
static int __attribute__ ((__section__ (".text.init"))) panic_setup(char *str)
{
panic_timeout = simple_strtoul(str, ((void *)0) , 0);
return 1;
}
static char __setup_str_panic_setup [] __attribute__ ((__section__ (".data.init"))) = "panic=" ; static struct kernel_param __setup_panic_setup __attribute__((unused)) __attribute__ ((unused,__section__ (".setup.init"))) = { __setup_str_panic_setup , panic_setup } ;
void panic(const char * fmt, ...)
{
static char buf[1024];
va_list args;
(__builtin_next_arg ( fmt ), __builtin_memcpy (( args ), __builtin_saveregs (), sizeof(__gnuc_va_list)) ) ;
vsprintf(buf, fmt, args);
((void)0) ;
printk("<0>" "Kernel panic: %s\n",buf);
if ((((void)( ( 0 ) ), irq_stat[0]. __local_irq_count ) ) )
printk("<0>" "In interrupt handler - not syncing\n");
else if (!current->pid)
printk("<0>" "In idle task - not syncing\n");
else
sys_sync();
unblank_console();
notifier_call_chain(&panic_notifier_list, 0, ((void *)0) );
if (panic_timeout > 0)
{
printk("<0>" "Rebooting in %d seconds..",panic_timeout);
( (__builtin_constant_p( panic_timeout*1000 ) && ( panic_timeout*1000 )<= 5 ) ? (__builtin_constant_p( ( panic_timeout*1000 )*1000 )? (( ( panic_timeout*1000 )*1000 ) > 1000000 ? __bad_udelay(): __const_udelay(( ( panic_timeout*1000 )*1000 ) * 4294u)) : __udelay( ( panic_timeout*1000 )*1000 )) : ({unsigned long msec=( panic_timeout*1000 ); while (msec--) (__builtin_constant_p( 1000 )? (( 1000 ) > 1000000 ? __bad_udelay(): __const_udelay(( 1000 ) * 4294u)) : __udelay( 1000 )) ;})) ;
machine_restart(((void *)0) );
}
if (! (((void)( ( 0 ) ), irq_stat[0]. __local_irq_count ) ) ) {
__global_sti() ;
for(;;) {
if (emergency_sync_scheduled) do_emergency_sync();
}
} else {
__cli();
for(;;);
}
}
----gnatsweb-attachment----
Content-Type: text/plain; name="panic.i"
Content-Disposition: inline; filename="panic.i"
# 0 "panic.c"
#define __BASE_FILE__ "panic.c"
# 0 "panic.c"
#define __VERSION__ "2.95.2 19991024 (release)"
# 0 "panic.c"
#define __SIZE_TYPE__ unsigned int
# 0 "panic.c"
#define __PTRDIFF_TYPE__ int
# 0 "panic.c"
#define __WCHAR_TYPE__ long int
# 0 "panic.c"
#define __DATE__ "Feb 25 2002"
# 0 "panic.c"
#define __TIME__ "18:10:05"
# 0 "panic.c"
#define __STDC__ 1
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 0 "panic.c"
# 1 "panic.c"
# 1 "/home/root/kernel/kernel/include/linux/config.h" 1
#define _LINUX_CONFIG_H
# 1 "/home/root/kernel/kernel/include/linux/autoconf.h" 1
#define AUTOCONF_INCLUDED
#define CONFIG_RWSEM_XCHGADD_ALGORITHM 1
#define CONFIG_EXPERIMENTAL 1
#define CONFIG_MODULES 1
#define CONFIG_MODVERSIONS 1
#define CONFIG_KMOD 1
#define CONFIG_PPC 1
#define CONFIG_8xx 1
#define CONFIG_SERIAL_CONSOLE 1
#define CONFIG_RPXLITE 1
#define CONFIG_NET 1
#define CONFIG_SYSCTL 1
#define CONFIG_SYSVIPC 1
#define CONFIG_KCORE_ELF 1
#define CONFIG_BINFMT_ELF 1
#define CONFIG_KERNEL_ELF 1
#define CONFIG_BINFMT_MISC_MODULE 1
#define CONFIG_HOTPLUG 1
#define CONFIG_PPC_RTC 1
#define CONFIG_CMDLINE_BOOL 1
#define CONFIG_CMDLINE "console=ttyS0,9600 root=/dev/nfs nfsroot=192.168.201.86:/rpx_root ip=192.168.201.87:192.168.201.86:192.168.201.86:255.255.255.0:asdf::"
#define CONFIG_POSIX_PRIOS (511)
#define CONFIG_RK 1
#define CONFIG_PRIO_INHERIT 1
#define CONFIG_MAX_READERS (16)
#define CONFIG_PIP_KERNEL_LOCKS 1
#define CONFIG_USER_SYS_TIMES 1
#define CONFIG_MEASURE 1
#define CONFIG_BLK_DEV_RAM 1
#define CONFIG_BLK_DEV_RAM_SIZE (4096)
#define CONFIG_PACKET 1
#define CONFIG_NETLINK 1
#define CONFIG_NETFILTER 1
#define CONFIG_UNIX 1
#define CONFIG_INET 1
#define CONFIG_IP_MULTICAST 1
#define CONFIG_IP_PNP 1
#define CONFIG_SYN_COOKIES 1
#define CONFIG_IP_NF_CONNTRACK_MODULE 1
#define CONFIG_IP_NF_FTP_MODULE 1
#define CONFIG_IP_NF_IPTABLES_MODULE 1
#define CONFIG_IP_NF_MATCH_LIMIT_MODULE 1
#define CONFIG_IP_NF_MATCH_MAC_MODULE 1
#define CONFIG_IP_NF_MATCH_MARK_MODULE 1
#define CONFIG_IP_NF_MATCH_MULTIPORT_MODULE 1
#define CONFIG_IP_NF_MATCH_TOS_MODULE 1
#define CONFIG_IP_NF_MATCH_TCPMSS_MODULE 1
#define CONFIG_IP_NF_MATCH_STATE_MODULE 1
#define CONFIG_IP_NF_MATCH_UNCLEAN_MODULE 1
#define CONFIG_IP_NF_MATCH_OWNER_MODULE 1
#define CONFIG_IP_NF_FILTER_MODULE 1
#define CONFIG_IP_NF_TARGET_REJECT_MODULE 1
#define CONFIG_IP_NF_TARGET_MIRROR_MODULE 1
#define CONFIG_IP_NF_NAT_MODULE 1
#define CONFIG_IP_NF_NAT_NEEDED 1
#define CONFIG_IP_NF_TARGET_MASQUERADE_MODULE 1
#define CONFIG_IP_NF_TARGET_REDIRECT_MODULE 1
#define CONFIG_IP_NF_NAT_FTP_MODULE 1
#define CONFIG_IP_NF_TARGET_TCPMSS_MODULE 1
#define CONFIG_IP_NF_COMPAT_IPCHAINS_MODULE 1
#define CONFIG_NETDEVICES 1
#define CONFIG_NET_ETHERNET 1
#define CONFIG_PPP 1
#define CONFIG_PPP_MULTILINK 1
#define CONFIG_PPP_ASYNC 1
#define CONFIG_PPP_DEFLATE 1
#define CONFIG_UNIX98_PTYS 1
#define CONFIG_UNIX98_PTY_COUNT (256)
#define CONFIG_HFS_FS_MODULE 1
#define CONFIG_FAT_FS_MODULE 1
#define CONFIG_MSDOS_FS_MODULE 1
#define CONFIG_VFAT_FS_MODULE 1
#define CONFIG_PROC_FS 1
#define CONFIG_DEVFS_FS 1
#define CONFIG_DEVPTS_FS 1
#define CONFIG_NFS_FS 1
#define CONFIG_NFS_V3 1
#define CONFIG_ROOT_NFS 1
#define CONFIG_NFSD 1
#define CONFIG_NFSD_V3 1
#define CONFIG_SUNRPC 1
#define CONFIG_LOCKD 1
#define CONFIG_LOCKD_V4 1
#define CONFIG_MSDOS_PARTITION 1
#define CONFIG_NLS 1
#define CONFIG_NLS_DEFAULT "iso8859-1"
#define CONFIG_NLS_ISO8859_1_MODULE 1
#define CONFIG_SCC_ENET 1
#define CONFIG_SCC2_ENET 1
#define CONFIG_USB 1
#define CONFIG_USB_DEVICEFS 1
#define CONFIG_USB_SERIAL_MODULE 1
#define CONFIG_USB_SERIAL_VISOR_MODULE 1
#define CONFIG_MAGIC_SYSRQ 1
# 4 "/home/root/kernel/kernel/include/linux/config.h" 2
# 11 "panic.c" 2
# 1 "/home/root/kernel/kernel/include/linux/sched.h" 1
#define _LINUX_SCHED_H
# 1 "/home/root/kernel/kernel/include/linux/sched-defs.h" 1
#define _LINUX_SCHED_DEFS_H
# 1 "/home/root/kernel/kernel/include/asm/param.h" 1
#define _ASM_PPC_PARAM_H
#define HZ 100
#define EXEC_PAGESIZE 4096
#define NGROUPS 32
#define NOGROUP (-1)
#define MAXHOSTNAMELEN 64
#define CLOCKS_PER_SEC 100
#define DEF_SLICE 0x80000
#define SLICE_BITS 21
# 4 "/home/root/kernel/kernel/include/linux/sched-defs.h" 2
extern unsigned long event;
# 1 "/home/root/kernel/kernel/include/linux/binfmts.h" 1
#define _LINUX_BINFMTS_H
# 1 "/home/root/kernel/kernel/include/linux/ptrace.h" 1
#define _LINUX_PTRACE_H
#define PTRACE_TRACEME 0
#define PTRACE_PEEKTEXT 1
#define PTRACE_PEEKDATA 2
#define PTRACE_PEEKUSR 3
#define PTRACE_POKETEXT 4
#define PTRACE_POKEDATA 5
#define PTRACE_POKEUSR 6
#define PTRACE_CONT 7
#define PTRACE_KILL 8
#define PTRACE_SINGLESTEP 9
#define PTRACE_ATTACH 0x10
#define PTRACE_DETACH 0x11
#define PTRACE_SYSCALL 24
# 1 "/home/root/kernel/kernel/include/asm/ptrace.h" 1
#define _PPC_PTRACE_H
struct pt_regs {
unsigned long gpr[32];
unsigned long nip;
unsigned long msr;
unsigned long orig_gpr3;
unsigned long ctr;
unsigned long link;
unsigned long xer;
unsigned long ccr;
unsigned long mq;
unsigned long trap;
unsigned long dar;
unsigned long dsisr;
unsigned long result;
};
#define STACK_FRAME_OVERHEAD 16
#define __SIGNAL_FRAMESIZE 64
#define instruction_pointer(regs) ((regs)->nip)
#define user_mode(regs) (((regs)->msr & MSR_PR) != 0)
#define PT_R0 0
#define PT_R1 1
#define PT_R2 2
#define PT_R3 3
#define PT_R4 4
#define PT_R5 5
#define PT_R6 6
#define PT_R7 7
#define PT_R8 8
#define PT_R9 9
#define PT_R10 10
#define PT_R11 11
#define PT_R12 12
#define PT_R13 13
#define PT_R14 14
#define PT_R15 15
#define PT_R16 16
#define PT_R17 17
#define PT_R18 18
#define PT_R19 19
#define PT_R20 20
#define PT_R21 21
#define PT_R22 22
#define PT_R23 23
#define PT_R24 24
#define PT_R25 25
#define PT_R26 26
#define PT_R27 27
#define PT_R28 28
#define PT_R29 29
#define PT_R30 30
#define PT_R31 31
#define PT_NIP 32
#define PT_MSR 33
#define PT_ORIG_R3 34
#define PT_CTR 35
#define PT_LNK 36
#define PT_XER 37
#define PT_CCR 38
#define PT_MQ 39
#define PT_FPR0 48
#define PT_FPR31 (PT_FPR0 + 2*31)
#define PT_FPSCR (PT_FPR0 + 2*32 + 1)
# 24 "/home/root/kernel/kernel/include/linux/ptrace.h" 2
# 4 "/home/root/kernel/kernel/include/linux/binfmts.h" 2
# 1 "/home/root/kernel/kernel/include/linux/capability.h" 1
#define _LINUX_CAPABILITY_H
# 1 "/home/root/kernel/kernel/include/linux/types.h" 1
#define _LINUX_TYPES_H
# 1 "/home/root/kernel/kernel/include/linux/posix_types.h" 1
#define _LINUX_POSIX_TYPES_H
# 1 "/home/root/kernel/kernel/include/linux/stddef.h" 1
#define _LINUX_STDDEF_H
#define NULL ((void *)0)
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 4 "/home/root/kernel/kernel/include/linux/posix_types.h" 2
#define __NFDBITS (8 * sizeof(unsigned long))
#define __FD_SETSIZE 1024
#define __FDSET_LONGS (__FD_SETSIZE/__NFDBITS)
#define __FDELT(d) ((d) / __NFDBITS)
#define __FDMASK(d) (1UL << ((d) % __NFDBITS))
typedef struct {
unsigned long fds_bits [(1024 / (8 * sizeof(unsigned long)) ) ];
} __kernel_fd_set;
typedef void (*__kernel_sighandler_t)(int);
typedef int __kernel_key_t;
# 1 "/home/root/kernel/kernel/include/asm/posix_types.h" 1
#define _PPC_POSIX_TYPES_H
typedef unsigned int __kernel_dev_t;
typedef unsigned int __kernel_ino_t;
typedef unsigned int __kernel_mode_t;
typedef unsigned short __kernel_nlink_t;
typedef long __kernel_off_t;
typedef int __kernel_pid_t;
typedef unsigned int __kernel_uid_t;
typedef unsigned int __kernel_gid_t;
typedef unsigned int __kernel_size_t;
typedef int __kernel_ssize_t;
typedef long __kernel_ptrdiff_t;
typedef long __kernel_time_t;
typedef long __kernel_suseconds_t;
typedef long __kernel_clock_t;
typedef int __kernel_daddr_t;
typedef char * __kernel_caddr_t;
typedef short __kernel_ipc_pid_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;
typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;
typedef unsigned int __kernel_old_uid_t;
typedef unsigned int __kernel_old_gid_t;
typedef long long __kernel_loff_t;
typedef struct {
int val[2];
} __kernel_fsid_t;
# 54 "/home/root/kernel/kernel/include/asm/posix_types.h"
static __inline__ void __FD_SET(unsigned long fd, __kernel_fd_set *fdsetp)
{
unsigned long _tmp = fd / (8 * sizeof(unsigned long)) ;
unsigned long _rem = fd % (8 * sizeof(unsigned long)) ;
fdsetp->fds_bits[_tmp] |= (1UL<<_rem);
}
static __inline__ void __FD_CLR(unsigned long fd, __kernel_fd_set *fdsetp)
{
unsigned long _tmp = fd / (8 * sizeof(unsigned long)) ;
unsigned long _rem = fd % (8 * sizeof(unsigned long)) ;
fdsetp->fds_bits[_tmp] &= ~(1UL<<_rem);
}
static __inline__ int __FD_ISSET(unsigned long fd, __kernel_fd_set *p)
{
unsigned long _tmp = fd / (8 * sizeof(unsigned long)) ;
unsigned long _rem = fd % (8 * sizeof(unsigned long)) ;
return (p->fds_bits[_tmp] & (1UL<<_rem)) != 0;
}
static __inline__ void __FD_ZERO(__kernel_fd_set *p)
{
unsigned int *tmp = (unsigned int *)p->fds_bits;
int i;
if (__builtin_constant_p((1024 / (8 * sizeof(unsigned long)) ) )) {
switch ((1024 / (8 * sizeof(unsigned long)) ) ) {
case 8:
tmp[0] = 0; tmp[1] = 0; tmp[2] = 0; tmp[3] = 0;
tmp[4] = 0; tmp[5] = 0; tmp[6] = 0; tmp[7] = 0;
return;
}
}
i = (1024 / (8 * sizeof(unsigned long)) ) ;
while (i) {
i--;
*tmp = 0;
tmp++;
}
}
# 46 "/home/root/kernel/kernel/include/linux/posix_types.h" 2
# 8 "/home/root/kernel/kernel/include/linux/types.h" 2
# 1 "/home/root/kernel/kernel/include/asm/types.h" 1
#define _PPC_TYPES_H
typedef __signed__ char __s8;
typedef unsigned char __u8;
typedef __signed__ short __s16;
typedef unsigned short __u16;
typedef __signed__ int __s32;
typedef unsigned int __u32;
typedef __signed__ long long __s64;
typedef unsigned long long __u64;
typedef struct {
__u32 u[4];
} __attribute((aligned(16))) __vector128;
typedef signed char s8;
typedef unsigned char u8;
typedef signed short s16;
typedef unsigned short u16;
typedef signed int s32;
typedef unsigned int u32;
typedef signed long long s64;
typedef unsigned long long u64;
typedef __vector128 vector128;
#define BITS_PER_LONG 32
typedef u32 dma_addr_t;
typedef unsigned short umode_t;
typedef long long cpu_tick_data_t;
# 9 "/home/root/kernel/kernel/include/linux/types.h" 2
typedef __kernel_fd_set fd_set;
typedef __kernel_dev_t dev_t;
typedef __kernel_ino_t ino_t;
typedef __kernel_mode_t mode_t;
typedef __kernel_nlink_t nlink_t;
typedef __kernel_off_t off_t;
typedef __kernel_pid_t pid_t;
typedef __kernel_daddr_t daddr_t;
typedef __kernel_key_t key_t;
typedef __kernel_suseconds_t suseconds_t;
typedef __kernel_uid32_t uid_t;
typedef __kernel_gid32_t gid_t;
typedef __kernel_uid16_t uid16_t;
typedef __kernel_gid16_t gid16_t;
typedef __kernel_loff_t loff_t;
#define _SIZE_T
typedef __kernel_size_t size_t;
#define _SSIZE_T
typedef __kernel_ssize_t ssize_t;
#define _PTRDIFF_T
typedef __kernel_ptrdiff_t ptrdiff_t;
#define _TIME_T
typedef __kernel_time_t time_t;
#define _CLOCK_T
typedef __kernel_clock_t clock_t;
#define _CADDR_T
typedef __kernel_caddr_t caddr_t;
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
typedef unsigned char unchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
#define __BIT_TYPES_DEFINED__
typedef __u8 u_int8_t;
typedef __s8 int8_t;
typedef __u16 u_int16_t;
typedef __s16 int16_t;
typedef __u32 u_int32_t;
typedef __s32 int32_t;
typedef __u8 uint8_t;
typedef __u16 uint16_t;
typedef __u32 uint32_t;
typedef __u64 uint64_t;
typedef __u64 u_int64_t;
typedef __s64 int64_t;
struct ustat {
__kernel_daddr_t f_tfree;
__kernel_ino_t f_tinode;
char f_fname[6];
char f_fpack[6];
};
# 16 "/home/root/kernel/kernel/include/linux/capability.h" 2
# 1 "/home/root/kernel/kernel/include/linux/fs-defs.h" 1
#define _LINUX_FS_DEFS_H
# 1 "/home/root/kernel/kernel/include/linux/linkage.h" 1
#define _LINUX_LINKAGE_H
#define CPP_ASMLINKAGE
#define asmlinkage CPP_ASMLINKAGE
#define SYMBOL_NAME_STR(X) #X
#define SYMBOL_NAME(X) X
#define SYMBOL_NAME_LABEL(X) X##:
#define __ALIGN .align 4,0x90
#define __ALIGN_STR ".align 4,0x90"
# 61 "/home/root/kernel/kernel/include/linux/linkage.h"
# 10 "/home/root/kernel/kernel/include/linux/fs-defs.h" 2
# 1 "/home/root/kernel/kernel/include/linux/limits.h" 1
#define _LINUX_LIMITS_H
#define NR_OPEN 1024
#define NGROUPS_MAX 32
#define ARG_MAX 131072
#define CHILD_MAX 999
#define OPEN_MAX 256
#define LINK_MAX 127
#define MAX_CANON 255
#define MAX_INPUT 255
#define NAME_MAX 255
#define PATH_MAX 4095
#define PIPE_BUF 4096
#define RTSIG_MAX 32
# 11 "/home/root/kernel/kernel/include/linux/fs-defs.h" 2
# 1 "/home/root/kernel/kernel/include/linux/wait.h" 1
#define _LINUX_WAIT_H
#define WNOHANG 0x00000001
#define WUNTRACED 0x00000002
#define __WNOTHREAD 0x20000000
#define __WALL 0x40000000
#define __WCLONE 0x80000000
# 1 "/home/root/kernel/kernel/include/linux/kernel.h" 1
#define _LINUX_KERNEL_H
# 1 "/opt/lib/gcc-lib/powerpc-linux/2.95.2/include/stdarg.h" 1 3
#define _STDARG_H
#define _ANSI_STDARG_H_
# 1 "/opt/lib/gcc-lib/powerpc-linux/2.95.2/include/va-ppc.h" 1 3
#define __GNUC_VA_LIST
#define _SYS_VA_LIST_H
#define __va_overflow(AP) (AP)->overflow_arg_area
typedef struct __va_list_tag {
unsigned char gpr;
unsigned char fpr;
char *overflow_arg_area;
char *reg_save_area;
} __va_list[1], __gnuc_va_list[1];
#define __VA_PPC_H__
typedef struct {
long __gp_save[8];
double __fp_save[8];
} __va_regsave_t;
#define __VA_FP_REGSAVE(AP,OFS,TYPE) ((TYPE *) (void *) (&(((__va_regsave_t *) (AP)->reg_save_area)->__fp_save[OFS])))
#define __VA_GP_REGSAVE(AP,OFS,TYPE) ((TYPE *) (void *) (&(((__va_regsave_t *) (AP)->reg_save_area)->__gp_save[OFS])))
#define __va_start_common(AP, FAKE) __builtin_memcpy ((AP), __builtin_saveregs (), sizeof(__gnuc_va_list))
#define va_start(AP,LASTARG) (__builtin_next_arg (LASTARG), __va_start_common (AP, 0))
#define __va_float_p(TYPE) 0
#define __va_aggregate_p(TYPE) (__builtin_classify_type(*(TYPE *)0) >= 12)
#define __va_size(TYPE) ((sizeof(TYPE) + sizeof (long) - 1) / sizeof (long))
extern void __va_arg_type_violation(void) __attribute__((__noreturn__));
#define va_arg(AP,TYPE) __extension__ (*({ register TYPE *__ptr; if (__va_float_p (TYPE) && sizeof (TYPE) < 16) { unsigned char __fpr = (AP)->fpr; if (__fpr < 8) { __ptr = __VA_FP_REGSAVE (AP, __fpr, TYPE); (AP)->fpr = __fpr + 1; } else if (sizeof (TYPE) == 8) { unsigned long __addr = (unsigned long) (__va_overflow (AP)); __ptr = (TYPE *)((__addr + 7) & -8); __va_overflow (AP) = (char *)(__ptr + 1); } else { __va_arg_type_violation (); } } else if (__va_aggregate_p (TYPE) || __va_float_p (TYPE)) { unsigned char __gpr = (AP)->gpr; if (__gpr < 8) { __ptr = * __VA_GP_REGSAVE (AP, __gpr, TYPE *); (AP)->gpr = __gpr + 1; } else { TYPE **__pptr = (TYPE **) (__va_overflow (AP)); __ptr = * __pptr; __va_overflow (AP) = (char *) (__pptr + 1); } } else { if (sizeof (TYPE) == 8) { unsigned char __gpr = (AP)->gpr; if (__gpr < 7) { __gpr += __gpr & 1; __ptr = __VA_GP_REGSAVE (AP, __gpr, TYPE); (AP)->gpr = __gpr + 2; } else { unsigned long __addr = (unsigned long) (__va_overflow (AP)); __ptr = (TYPE *)((__addr + 7) & -8); (AP)->gpr = 8; __va_overflow (AP) = (char *)(__ptr + 1); } } else if (sizeof (TYPE) == 4) { unsigned char __gpr = (AP)->gpr; if (__gpr < 8) { __ptr = __VA_GP_REGSAVE (AP, __gpr, TYPE); (AP)->gpr = __gpr + 1; } else { __ptr = (TYPE *) __va_overflow (AP); __va_overflow (AP) = (char *)(__ptr + 1); } } else { __va_arg_type_violation (); } } __ptr; }))
# 192 "/opt/lib/gcc-lib/powerpc-linux/2.95.2/include/va-ppc.h" 3
#define va_end(AP) ((void)0)
#define __va_copy(dest, src) *(dest) = *(src)
# 255 "/opt/lib/gcc-lib/powerpc-linux/2.95.2/include/va-ppc.h" 3
# 42 "/opt/lib/gcc-lib/powerpc-linux/2.95.2/include/stdarg.h" 2 3
# 131 "/opt/lib/gcc-lib/powerpc-linux/2.95.2/include/stdarg.h" 3
# 175 "/opt/lib/gcc-lib/powerpc-linux/2.95.2/include/stdarg.h" 3
typedef __gnuc_va_list va_list;
#define _VA_LIST_
#define _VA_LIST
#define _VA_LIST_DEFINED
#define _VA_LIST_T_H
# 10 "/home/root/kernel/kernel/include/linux/kernel.h" 2
#define barrier() __asm__ __volatile__("": : :"memory")
#define INT_MAX ((int)(~0U>>1))
#define INT_MIN (-INT_MAX - 1)
#define UINT_MAX (~0U)
#define LONG_MAX ((long)(~0UL>>1))
#define LONG_MIN (-LONG_MAX - 1)
#define ULONG_MAX (~0UL)
#define STACK_MAGIC 0xdeadbeef
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#define KERN_EMERG "<0>"
#define KERN_ALERT "<1>"
#define KERN_CRIT "<2>"
#define KERN_ERR "<3>"
#define KERN_WARNING "<4>"
#define KERN_NOTICE "<5>"
#define KERN_INFO "<6>"
#define KERN_DEBUG "<7>"
#define NORET_TYPE
#define ATTRIB_NORET __attribute__((noreturn))
#define NORET_AND noreturn,
#define FASTCALL(x) x
struct semaphore;
extern struct notifier_block *panic_notifier_list;
void panic(const char * fmt, ...)
__attribute__ ((noreturn, format (printf, 1, 2)));
void do_exit(long error_code)
__attribute__((noreturn)) ;
void up_and_exit(struct semaphore *, long)
__attribute__((noreturn)) ;
extern int abs(int);
extern unsigned long simple_strtoul(const char *,char **,unsigned int);
extern long simple_strtol(const char *,char **,unsigned int);
extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
extern long long simple_strtoll(const char *,char **,unsigned int);
extern int sprintf(char * buf, const char * fmt, ...);
extern int vsprintf(char *buf, const char *, va_list);
extern int get_option(char **str, int *pint);
extern char *get_options(char *str, int nints, int *ints);
extern unsigned long long memparse(char *ptr, char **retptr);
extern void dev_probe_lock(void);
extern void dev_probe_unlock(void);
extern int session_of_pgrp(int pgrp);
int printk(const char * fmt, ...)
__attribute__ ((format (printf, 1, 2)));
extern int console_loglevel;
static inline void console_silent(void)
{
console_loglevel = 0;
}
static inline void console_verbose(void)
{
if (console_loglevel)
console_loglevel = 15;
}
#define pr_debug(fmt,arg...) do { } while (0)
#define pr_info(fmt,arg...) printk(KERN_INFO fmt,##arg)
#define NIPQUAD(addr) ((unsigned char *)&addr)[0], ((unsigned char *)&addr)[1], ((unsigned char *)&addr)[2], ((unsigned char *)&addr)[3]
#define HIPQUAD(addr) ((unsigned char *)&addr)[3], ((unsigned char *)&addr)[2], ((unsigned char *)&addr)[1], ((unsigned char *)&addr)[0]
#define SI_LOAD_SHIFT 16
struct sysinfo {
long uptime;
unsigned long loads[3];
unsigned long totalram;
unsigned long freeram;
unsigned long sharedram;
unsigned long bufferram;
unsigned long totalswap;
unsigned long freeswap;
unsigned short procs;
unsigned short pad;
unsigned long totalhigh;
unsigned long freehigh;
unsigned int mem_unit;
char _f[20-2*sizeof(long)-sizeof(int)];
};
# 14 "/home/root/kernel/kernel/include/linux/wait.h" 2
# 1 "/home/root/kernel/kernel/include/linux/list.h" 1
#define _LINUX_LIST_H
struct list_head {
struct list_head *next, *prev;
};
#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) struct list_head name = LIST_HEAD_INIT(name)
#define INIT_LIST_HEAD(ptr) do { (ptr)->next = (ptr); (ptr)->prev = (ptr); } while (0)
static __inline__ void __list_add(struct list_head * new,
struct list_head * prev,
struct list_head * next)
{
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;
}
static __inline__ void list_add(struct list_head *new, struct list_head *head)
{
__list_add(new, head, head->next);
}
static __inline__ void list_add_tail(struct list_head *new, struct list_head *head)
{
__list_add(new, head->prev, head);
}
static __inline__ void __list_del(struct list_head * prev,
struct list_head * next)
{
next->prev = prev;
prev->next = next;
}
static __inline__ void list_del(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
}
static __inline__ void list_del_init(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
do { ( entry )->next = ( entry ); ( entry )->prev = ( entry ); } while (0) ;
}
static __inline__ int list_empty(struct list_head *head)
{
return head->next == head;
}
static __inline__ void list_splice(struct list_head *list, struct list_head *head)
{
struct list_head *first = list->next;
if (first != list) {
struct list_head *last = list->prev;
struct list_h