void board_read_group(const char *cmd) { char buf[16]; snprintf(buf, sizeof(buf), "EGROUP%c", *cmd); choose_board_t cbrd; memset(&cbrd, 0, sizeof(cbrd)); cbrd.prefix = sysconf_str(buf); cbrd.newflag = DEFINE(DEF_NEWPOST); cbrd.parent = -1; choose_board(&cbrd); }
void output_ptreg_defines(void) { COMMENT("MIPS pt_regs offsets."); OFFSET(PT_R0, pt_regs, regs[0]); OFFSET(PT_R1, pt_regs, regs[1]); OFFSET(PT_R2, pt_regs, regs[2]); OFFSET(PT_R3, pt_regs, regs[3]); OFFSET(PT_R4, pt_regs, regs[4]); OFFSET(PT_R5, pt_regs, regs[5]); OFFSET(PT_R6, pt_regs, regs[6]); OFFSET(PT_R7, pt_regs, regs[7]); OFFSET(PT_R8, pt_regs, regs[8]); OFFSET(PT_R9, pt_regs, regs[9]); OFFSET(PT_R10, pt_regs, regs[10]); OFFSET(PT_R11, pt_regs, regs[11]); OFFSET(PT_R12, pt_regs, regs[12]); OFFSET(PT_R13, pt_regs, regs[13]); OFFSET(PT_R14, pt_regs, regs[14]); OFFSET(PT_R15, pt_regs, regs[15]); OFFSET(PT_R16, pt_regs, regs[16]); OFFSET(PT_R17, pt_regs, regs[17]); OFFSET(PT_R18, pt_regs, regs[18]); OFFSET(PT_R19, pt_regs, regs[19]); OFFSET(PT_R20, pt_regs, regs[20]); OFFSET(PT_R21, pt_regs, regs[21]); OFFSET(PT_R22, pt_regs, regs[22]); OFFSET(PT_R23, pt_regs, regs[23]); OFFSET(PT_R24, pt_regs, regs[24]); OFFSET(PT_R25, pt_regs, regs[25]); OFFSET(PT_R26, pt_regs, regs[26]); OFFSET(PT_R27, pt_regs, regs[27]); OFFSET(PT_R28, pt_regs, regs[28]); OFFSET(PT_R29, pt_regs, regs[29]); OFFSET(PT_R30, pt_regs, regs[30]); OFFSET(PT_R31, pt_regs, regs[31]); OFFSET(PT_LO, pt_regs, lo); OFFSET(PT_HI, pt_regs, hi); #ifdef CONFIG_CPU_HAS_SMARTMIPS OFFSET(PT_ACX, pt_regs, acx); #endif OFFSET(PT_EPC, pt_regs, cp0_epc); OFFSET(PT_BVADDR, pt_regs, cp0_badvaddr); OFFSET(PT_STATUS, pt_regs, cp0_status); OFFSET(PT_CAUSE, pt_regs, cp0_cause); #ifdef CONFIG_CPU_CAVIUM_OCTEON OFFSET(PT_MPL, pt_regs, mpl); OFFSET(PT_MTP, pt_regs, mtp); #endif /* CONFIG_CPU_CAVIUM_OCTEON */ DEFINE(PT_SIZE, sizeof(struct pt_regs)); BLANK(); }
static void init_dbg(void) { l_debug_mode = 0; DEFINE("%debug-macro-compiler", MAKE_INT(DBG_COMPILER)); DEFINE("%debug-macro-matcher", MAKE_INT(DBG_MATCHER)); DEFINE("%debug-macro-transcriptor", MAKE_INT(DBG_TRANSCRIPTOR)); DEFINE("%debug-macro-funcall", MAKE_INT(DBG_FUNCALL)); DEFINE("%debug-macro-pvar", MAKE_INT(DBG_PVAR)); DEFINE("%debug-macro-return", MAKE_INT(DBG_RETURN)); DEFINE("%debug-macro-unwrap", MAKE_INT(DBG_UNWRAP)); DEFINE("%debug-macro-expander", MAKE_INT(DBG_EXPANDER)); scm_register_funcs(dbg_funcs); }
int main(void) { // Memory layout values DEFINE(CYGMEM_REGION_sdram, CYGMEM_REGION_sdram); DEFINE(CYGMEM_REGION_sdram_SIZE, CYGMEM_REGION_sdram_SIZE); DEFINE(CYGMEM_REGION_devs, CYGMEM_REGION_devs); DEFINE(CYGMEM_REGION_devs_SIZE, CYGMEM_REGION_devs_SIZE); DEFINE(CYGMEM_REGION_sram, CYGMEM_REGION_sram); DEFINE(CYGMEM_REGION_sram_SIZE, CYGMEM_REGION_sram_SIZE); DEFINE(CYGMEM_REGION_flash, CYGMEM_REGION_flash); DEFINE(CYGMEM_REGION_flash_SIZE, CYGMEM_REGION_flash_SIZE); return 0; }
void output_task_defines(void) { COMMENT("MIPS task_struct offsets."); OFFSET(TASK_STATE, task_struct, state); OFFSET(TASK_THREAD_INFO, task_struct, stack); OFFSET(TASK_FLAGS, task_struct, flags); OFFSET(TASK_MM, task_struct, mm); OFFSET(TASK_PID, task_struct, pid); #if defined(CONFIG_CC_STACKPROTECTOR) OFFSET(TASK_STACK_CANARY, task_struct, stack_canary); #endif DEFINE(TASK_STRUCT_SIZE, sizeof(struct task_struct)); BLANK(); }
//PROCESSLINE Function void PROCESSLINE() { int i; for(i=0;i<namcount;i++) //till the total no. of macros if(!strcmp(opcode,mynamtab[i].name)) //if opcode matches in the NAMTAB { EXPAND();return; //then expand } { if(!strcmp(opcode,"MACRO")) //if "MACRO" keyword is encountered DEFINE(); //then define else fprintf(expanded,"%s",line); //otherwise copy it into the expanded file } }//end processline
void asm_offsets(void) { OFFSET(TASK_THREAD_INFO, task_struct, stack); OFFSET(THREAD_PC, task_struct, thread.pc); OFFSET(THREAD_SP, task_struct, thread.sp); #ifdef CONFIG_FRAME_POINTER OFFSET(THREAD_FP, task_struct, thread.fp); #endif /* CONFIG_FRAME_POINTER */ OFFSET(TI_FLAGS, thread_info, flags); DEFINE(PT_SIZE, sizeof(struct pt_regs)); OFFSET(PT_ZERO, pt_regs, zero); OFFSET(PT_RA, pt_regs, ra); OFFSET(PT_FP, pt_regs, s[0]); OFFSET(PT_S0, pt_regs, s[0]); OFFSET(PT_S1, pt_regs, s[1]); OFFSET(PT_S2, pt_regs, s[2]); OFFSET(PT_S3, pt_regs, s[3]); OFFSET(PT_S4, pt_regs, s[4]); OFFSET(PT_S5, pt_regs, s[5]); OFFSET(PT_S6, pt_regs, s[6]); OFFSET(PT_S7, pt_regs, s[7]); OFFSET(PT_S8, pt_regs, s[8]); OFFSET(PT_S9, pt_regs, s[9]); OFFSET(PT_S10, pt_regs, s[10]); OFFSET(PT_S11, pt_regs, s[11]); OFFSET(PT_SP, pt_regs, sp); OFFSET(PT_TP, pt_regs, tp); OFFSET(PT_V0, pt_regs, v[0]); OFFSET(PT_V1, pt_regs, v[1]); OFFSET(PT_A0, pt_regs, a[0]); OFFSET(PT_A1, pt_regs, a[1]); OFFSET(PT_A2, pt_regs, a[2]); OFFSET(PT_A3, pt_regs, a[3]); OFFSET(PT_A4, pt_regs, a[4]); OFFSET(PT_A5, pt_regs, a[5]); OFFSET(PT_A6, pt_regs, a[6]); OFFSET(PT_A7, pt_regs, a[7]); OFFSET(PT_A8, pt_regs, a[8]); OFFSET(PT_A9, pt_regs, a[9]); OFFSET(PT_A10, pt_regs, a[10]); OFFSET(PT_A11, pt_regs, a[11]); OFFSET(PT_A12, pt_regs, a[12]); OFFSET(PT_A13, pt_regs, a[13]); OFFSET(PT_STATUS, pt_regs, status); OFFSET(PT_EPC, pt_regs, epc); OFFSET(PT_BADVADDR, pt_regs, badvaddr); OFFSET(PT_CAUSE, pt_regs, cause); }
static int load_pager(void) { int pager = 0; if (DEFINE(DEF_FRIENDCALL)) { pager |= FRIEND_PAGER; } if (currentuser.flags[0] & PAGER_FLAG) { pager |= ALL_PAGER; pager |= FRIEND_PAGER; } if (DEFINE(DEF_FRIENDMSG)) { pager |= FRIENDMSG_PAGER; } if (DEFINE(DEF_ALLMSG)) { pager |= ALLMSG_PAGER; pager |= FRIENDMSG_PAGER; } if (DEFINE(DEF_LOGOFFMSG)) { pager |= LOGOFFMSG_PAGER; } return pager; }
int foo(void) { DEFINE(AOFF_task_thread, offsetof(struct task_struct, thread)); BLANK(); /* XXX This is the stuff for sclow.S, kill it. */ DEFINE(AOFF_task_pid, offsetof(struct task_struct, pid)); DEFINE(AOFF_task_uid, offsetof(struct task_struct, uid)); DEFINE(AOFF_task_gid, offsetof(struct task_struct, gid)); DEFINE(AOFF_task_euid, offsetof(struct task_struct, euid)); DEFINE(AOFF_task_egid, offsetof(struct task_struct, egid)); /* DEFINE(THREAD_INFO, offsetof(struct task_struct, stack)); */ DEFINE(ASIZ_task_uid, sizeof(current->uid)); DEFINE(ASIZ_task_gid, sizeof(current->gid)); DEFINE(ASIZ_task_euid, sizeof(current->euid)); DEFINE(ASIZ_task_egid, sizeof(current->egid)); BLANK(); DEFINE(AOFF_thread_fork_kpsr, offsetof(struct thread_struct, fork_kpsr)); BLANK(); DEFINE(AOFF_mm_context, offsetof(struct mm_struct, context)); /* DEFINE(NUM_USER_SEGMENTS, TASK_SIZE>>28); */ return 0; }
static void prepare (void) { /* Flags. */ MUSCLE_INSERT_BOOL ("debug_flag", debug_flag); MUSCLE_INSERT_BOOL ("defines_flag", defines_flag); MUSCLE_INSERT_BOOL ("error_verbose_flag", error_verbose); MUSCLE_INSERT_BOOL ("locations_flag", locations_flag); MUSCLE_INSERT_BOOL ("pure_flag", pure_parser); MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag); /* File names. */ MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy"); #define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "") DEFINE (dir_prefix); DEFINE (parser_file_name); DEFINE (spec_defines_file); DEFINE (spec_file_prefix); DEFINE (spec_graph_file); DEFINE (spec_name_prefix); DEFINE (spec_outfile); DEFINE (spec_verbose_file); #undef DEFINE /* User Code. */ obstack_1grow (&pre_prologue_obstack, 0); obstack_1grow (&post_prologue_obstack, 0); muscle_insert ("pre_prologue", obstack_finish (&pre_prologue_obstack)); muscle_insert ("post_prologue", obstack_finish (&post_prologue_obstack)); /* Find the right skeleton file. */ if (!skeleton) { if (glr_parser || nondeterministic_parser) skeleton = "glr.c"; else skeleton = "yacc.c"; } /* About the skeletons. */ { char const *pkgdatadir = getenv ("BISON_PKGDATADIR"); MUSCLE_INSERT_STRING ("pkgdatadir", pkgdatadir ? pkgdatadir : PKGDATADIR); MUSCLE_INSERT_C_STRING ("skeleton", skeleton); } }
void common(void) { BLANK(); OFFSET(TI_flags, thread_info, flags); OFFSET(TI_status, thread_info, status); OFFSET(TI_addr_limit, thread_info, addr_limit); OFFSET(TI_preempt_count, thread_info, preempt_count); OFFSET(TI_preempt_lazy_count, thread_info, preempt_lazy_count); BLANK(); OFFSET(crypto_tfm_ctx_offset, crypto_tfm, __crt_ctx); BLANK(); OFFSET(pbe_address, pbe, address); OFFSET(pbe_orig_address, pbe, orig_address); OFFSET(pbe_next, pbe, next); #ifdef CONFIG_PARAVIRT BLANK(); OFFSET(PARAVIRT_enabled, pv_info, paravirt_enabled); OFFSET(PARAVIRT_PATCH_pv_cpu_ops, paravirt_patch_template, pv_cpu_ops); OFFSET(PARAVIRT_PATCH_pv_irq_ops, paravirt_patch_template, pv_irq_ops); OFFSET(PV_IRQ_irq_disable, pv_irq_ops, irq_disable); OFFSET(PV_IRQ_irq_enable, pv_irq_ops, irq_enable); OFFSET(PV_CPU_iret, pv_cpu_ops, iret); OFFSET(PV_CPU_irq_enable_sysexit, pv_cpu_ops, irq_enable_sysexit); OFFSET(PV_CPU_read_cr0, pv_cpu_ops, read_cr0); OFFSET(PV_MMU_read_cr2, pv_mmu_ops, read_cr2); #endif #ifdef CONFIG_XEN BLANK(); OFFSET(XEN_vcpu_info_mask, vcpu_info, evtchn_upcall_mask); OFFSET(XEN_vcpu_info_pending, vcpu_info, evtchn_upcall_pending); #endif BLANK(); OFFSET(BP_scratch, boot_params, scratch); OFFSET(BP_loadflags, boot_params, hdr.loadflags); OFFSET(BP_hardware_subarch, boot_params, hdr.hardware_subarch); OFFSET(BP_version, boot_params, hdr.version); OFFSET(BP_kernel_alignment, boot_params, hdr.kernel_alignment); OFFSET(BP_pref_address, boot_params, hdr.pref_address); OFFSET(BP_code32_start, boot_params, hdr.code32_start); BLANK(); DEFINE(PTREGS_SIZE, sizeof(struct pt_regs)); }
void output_ptreg_defines(void) { COMMENT("MIPS pt_regs offsets."); OFFSET(PT_R0, pt_regs, regs[0]); OFFSET(PT_R1, pt_regs, regs[1]); OFFSET(PT_R2, pt_regs, regs[2]); OFFSET(PT_R3, pt_regs, regs[3]); OFFSET(PT_R4, pt_regs, regs[4]); OFFSET(PT_R5, pt_regs, regs[5]); OFFSET(PT_R6, pt_regs, regs[6]); OFFSET(PT_R7, pt_regs, regs[7]); OFFSET(PT_R8, pt_regs, regs[8]); OFFSET(PT_R9, pt_regs, regs[9]); OFFSET(PT_R10, pt_regs, regs[10]); OFFSET(PT_R11, pt_regs, regs[11]); OFFSET(PT_R12, pt_regs, regs[12]); OFFSET(PT_R13, pt_regs, regs[13]); OFFSET(PT_R14, pt_regs, regs[14]); OFFSET(PT_R15, pt_regs, regs[15]); OFFSET(PT_R16, pt_regs, regs[16]); OFFSET(PT_R17, pt_regs, regs[17]); OFFSET(PT_R18, pt_regs, regs[18]); OFFSET(PT_R19, pt_regs, regs[19]); OFFSET(PT_R20, pt_regs, regs[20]); OFFSET(PT_R21, pt_regs, regs[21]); OFFSET(PT_R22, pt_regs, regs[22]); OFFSET(PT_R23, pt_regs, regs[23]); OFFSET(PT_R24, pt_regs, regs[24]); OFFSET(PT_R25, pt_regs, regs[25]); OFFSET(PT_R26, pt_regs, regs[26]); OFFSET(PT_R27, pt_regs, regs[27]); OFFSET(PT_R28, pt_regs, regs[28]); OFFSET(PT_R29, pt_regs, regs[29]); OFFSET(PT_R30, pt_regs, regs[30]); OFFSET(PT_R31, pt_regs, regs[31]); OFFSET(PT_LO, pt_regs, lo); OFFSET(PT_HI, pt_regs, hi); OFFSET(PT_EPC, pt_regs, cp0_epc); OFFSET(PT_BVADDR, pt_regs, cp0_badvaddr); OFFSET(PT_STATUS, pt_regs, cp0_status); OFFSET(PT_CAUSE, pt_regs, cp0_cause); DEFINE(PT_SIZE, sizeof(struct pt_regs)); BLANK(); }
int main(void) { OFFSET(S_X0, pt_regs, regs[0]); OFFSET(S_X1, pt_regs, regs[1]); OFFSET(S_X2, pt_regs, regs[2]); OFFSET(S_X3, pt_regs, regs[3]); OFFSET(S_X4, pt_regs, regs[4]); OFFSET(S_X5, pt_regs, regs[5]); OFFSET(S_X6, pt_regs, regs[6]); OFFSET(S_X7, pt_regs, regs[7]); OFFSET(S_LR, pt_regs, regs[30]); OFFSET(S_SP, pt_regs, sp); OFFSET(S_PC, pt_regs, pc); OFFSET(S_PSTATE, pt_regs, pstate); OFFSET(S_ORIG_X0, pt_regs, orig_x0); OFFSET(S_SYSCALLNO, pt_regs, syscallno); DEFINE(S_FRAME_SIZE, sizeof(struct pt_regs)); return 0; }
int main(void) { DEFINE(TSK_ACTIVE_MM, offsetof(struct task_struct, active_mm)); BLANK(); DEFINE(VMA_VM_MM, offsetof(struct vm_area_struct, vm_mm)); DEFINE(VMA_VM_FLAGS, offsetof(struct vm_area_struct, vm_flags)); BLANK(); DEFINE(VM_EXEC, VM_EXEC); BLANK(); BLANK(); DEFINE(PAGE_PRESENT, _PAGE_PRESENT); DEFINE(PAGE_READONLY, _PAGE_READONLY); DEFINE(PAGE_NOT_USER, _PAGE_NOT_USER); DEFINE(PAGE_OLD, _PAGE_OLD); DEFINE(PAGE_CLEAN, _PAGE_CLEAN); BLANK(); DEFINE(PAGE_SZ, PAGE_SIZE); BLANK(); DEFINE(SYS_ERROR0, 0x9f0000); return 0; }
static int choose_board_read(choose_t *cp) { choose_board_t *cbrd = cp->data; board_data_t *ptr = cbrd->brds + cp->cur; if (ptr->flag & BOARD_DIR_FLAG) { int parent = cbrd->parent; const char *prefix = cbrd->prefix; bool recursive = cbrd->recursive; bool goodbrd = cbrd->goodbrd; int cur = cp->cur; cbrd->parent = ptr->pos; cbrd->prefix = NULL; cbrd->recursive = true; cbrd->goodbrd = (ptr->flag & BOARD_CUSTOM_FLAG) ? true : false; choose_board(cbrd); cbrd->parent = parent; cbrd->prefix = prefix; cbrd->recursive = recursive; cbrd->goodbrd = goodbrd; cp->cur = cur; } else { brc_initial(currentuser.userid, ptr->name); changeboard(&currbp, currboard, ptr->name); memcpy(currBM, ptr->BM, BM_LEN - 1); char buf[STRLEN]; if (DEFINE(DEF_FIRSTNEW)) { setbdir(buf, currboard); int tmp = unread_position(buf, ptr); int page = tmp - t_lines / 2; getkeep(buf, page > 1 ? page : 1, tmp + 1); } board_read(); brc_zapbuf(cbrd->zapbuf + ptr->pos); ptr->total = -1; currBM[0] = '\0'; } return FULLUPDATE; }
int main(void) { DEFINE(TASK_STATE, offsetof(struct task_struct, state)); DEFINE(TASK_FLAGS, offsetof(struct task_struct, flags)); DEFINE(TASK_PTRACE, offsetof(struct task_struct, ptrace)); DEFINE(TASK_BLOCKED, offsetof(struct task_struct, blocked)); DEFINE(TASK_THREAD, offsetof(struct task_struct, thread)); DEFINE(TASK_THREAD_INFO, offsetof(struct task_struct, stack)); DEFINE(TASK_MM, offsetof(struct task_struct, mm)); DEFINE(TASK_ACTIVE_MM, offsetof(struct task_struct, active_mm)); DEFINE(CPUSTAT_SOFTIRQ_PENDING, offsetof(irq_cpustat_t, __softirq_pending)); DEFINE(THREAD_KSP, offsetof(struct thread_struct, ksp)); DEFINE(THREAD_USP, offsetof(struct thread_struct, usp)); DEFINE(THREAD_CCR, offsetof(struct thread_struct, ccr)); DEFINE(LER0, offsetof(struct pt_regs, er0) - sizeof(long)); DEFINE(LER1, offsetof(struct pt_regs, er1) - sizeof(long)); DEFINE(LER2, offsetof(struct pt_regs, er2) - sizeof(long)); DEFINE(LER3, offsetof(struct pt_regs, er3) - sizeof(long)); DEFINE(LER4, offsetof(struct pt_regs, er4) - sizeof(long)); DEFINE(LER5, offsetof(struct pt_regs, er5) - sizeof(long)); DEFINE(LER6, offsetof(struct pt_regs, er6) - sizeof(long)); DEFINE(LORIG, offsetof(struct pt_regs, orig_er0) - sizeof(long)); DEFINE(LCCR, offsetof(struct pt_regs, ccr) - sizeof(long)); DEFINE(LVEC, offsetof(struct pt_regs, vector) - sizeof(long)); #if defined(__H8300S__) DEFINE(LEXR, offsetof(struct pt_regs, exr) - sizeof(long)); #endif DEFINE(LRET, offsetof(struct pt_regs, pc) - sizeof(long)); DEFINE(PT_PTRACED, PT_PTRACED); return 0; }
int main(void) { DEFINE(GENERATED_GD_RELOC_OFF, offsetof(gd_t, reloc_off)); DEFINE(GENERATED_SC520_PAR0, offsetof(struct sc520_mmcr, par[0])); DEFINE(GENERATED_SC520_PAR1, offsetof(struct sc520_mmcr, par[1])); DEFINE(GENERATED_SC520_PAR2, offsetof(struct sc520_mmcr, par[2])); DEFINE(GENERATED_SC520_PAR3, offsetof(struct sc520_mmcr, par[3])); DEFINE(GENERATED_SC520_PAR4, offsetof(struct sc520_mmcr, par[4])); DEFINE(GENERATED_SC520_PAR5, offsetof(struct sc520_mmcr, par[5])); DEFINE(GENERATED_SC520_PAR6, offsetof(struct sc520_mmcr, par[6])); DEFINE(GENERATED_SC520_PAR7, offsetof(struct sc520_mmcr, par[7])); DEFINE(GENERATED_SC520_PAR8, offsetof(struct sc520_mmcr, par[8])); DEFINE(GENERATED_SC520_PAR9, offsetof(struct sc520_mmcr, par[9])); DEFINE(GENERATED_SC520_PAR10, offsetof(struct sc520_mmcr, par[10])); DEFINE(GENERATED_SC520_PAR11, offsetof(struct sc520_mmcr, par[11])); DEFINE(GENERATED_SC520_PAR12, offsetof(struct sc520_mmcr, par[12])); DEFINE(GENERATED_SC520_PAR13, offsetof(struct sc520_mmcr, par[13])); DEFINE(GENERATED_SC520_PAR14, offsetof(struct sc520_mmcr, par[14])); DEFINE(GENERATED_SC520_PAR15, offsetof(struct sc520_mmcr, par[15])); return 0; }
static void user_login(void) { char fname[STRLEN]; // SYSOP gets all permission bits when login. if (strcmp(currentuser.userid, "SYSOP") == 0) { currentuser.userlevel = ~0; substitut_record(PASSFILE, ¤tuser, sizeof(currentuser), usernum); } fromhost[sizeof(fromhost) - 1] = 0; //added by iamfat 2004.01.05 to avoid overflow log_usies("ENTER", fromhost, ¤tuser); SpecialID(currentuser.userid, fromhost, sizeof(fromhost)); u_enter(); report("Enter", currentuser.userid); #ifdef USE_NOTEPAD notepad_init(); if (strcmp(currentuser.userid, "guest") != 0) { if (DEFINE(DEF_NOTEPAD)) { int noteln; if (lastnote> currentuser.notedate) currentuser.noteline = 0; noteln = countln("etc/notepad"); if (currentuser.noteline == 0) { shownotepad(); } else if ((noteln - currentuser.noteline)> 0) { screen_move(0, 0); ansimore2("etc/notepad", NA, 0, noteln - currentuser.noteline + 1); terminal_getchar(); screen_clear(); } currentuser.noteline = noteln; write_defnotepad(); } } #endif if (show_statshm("etc/hotspot", 0)) { screen_flush(); pressanykey(); } if ((vote_flag(NULL, '\0', 2 /* 检查读过新的Welcome 没 */) == 0)) { if (dashf("Welcome")) { ansimore("Welcome", YEA); vote_flag(NULL, 'R', 2 /* 写入读过新的Welcome */); } } else { ansimore("Welcome2", YEA); } show_statshm("0Announce/bbslist/day", 1); screen_flush(); screen_move_clear(-2); if (currentuser.numlogins < 1) { currentuser.numlogins = 0; //% prints("\033[1;36m☆ 这是您第 \033[33m1\033[36m 次拜访本站,请记住今天吧。\n"); prints("\033[1;36m\xa1\xee \xd5\xe2\xca\xc7\xc4\xfa\xb5\xda \033[33m1\033[36m \xb4\xce\xb0\xdd\xb7\xc3\xb1\xbe\xd5\xbe\xa3\xac\xc7\xeb\xbc\xc7\xd7\xa1\xbd\xf1\xcc\xec\xb0\xc9\xa1\xa3\n"); //% prints("☆ 您第一次连入本站的时间为 \033[33m%s\033[m ", format_time(time(NULL), TIME_FORMAT_ZH)); prints("\xa1\xee \xc4\xfa\xb5\xda\xd2\xbb\xb4\xce\xc1\xac\xc8\xeb\xb1\xbe\xd5\xbe\xb5\xc4\xca\xb1\xbc\xe4\xce\xaa \033[33m%s\033[m ", format_time(fb_time(), TIME_FORMAT_ZH)); } else { prints( //% "\033[1;36m☆ 这是您第 \033[33m%d\033[36m 次拜访本站,上次您是从 \033[33m%s\033[36m 连往本站。\n", "\033[1;36m\xa1\xee \xd5\xe2\xca\xc7\xc4\xfa\xb5\xda \033[33m%d\033[36m \xb4\xce\xb0\xdd\xb7\xc3\xb1\xbe\xd5\xbe\xa3\xac\xc9\xcf\xb4\xce\xc4\xfa\xca\xc7\xb4\xd3 \033[33m%s\033[36m \xc1\xac\xcd\xf9\xb1\xbe\xd5\xbe\xa1\xa3\n", currentuser.numlogins + 1, currentuser.lasthost); //% prints("☆ 上次连线时间为 \033[33m%s\033[m ", format_time(currentuser.lastlogin, TIME_FORMAT_ZH)); prints("\xa1\xee \xc9\xcf\xb4\xce\xc1\xac\xcf\xdf\xca\xb1\xbc\xe4\xce\xaa \033[33m%s\033[m ", format_time(currentuser.lastlogin, TIME_FORMAT_ZH)); } terminal_getchar(); setuserfile(fname, BADLOGINFILE); if (ansimore(fname, NA) != -1) { //% if (askyn("您要删除以上密码输入错误的记录吗", NA, NA) == YEA) if (askyn("\xc4\xfa\xd2\xaa\xc9\xbe\xb3\xfd\xd2\xd4\xc9\xcf\xc3\xdc\xc2\xeb\xca\xe4\xc8\xeb\xb4\xed\xce\xf3\xb5\xc4\xbc\xc7\xc2\xbc\xc2\xf0", NA, NA) == YEA) unlink(fname); } set_safe_record(); tui_check_uinfo(¤tuser); strlcpy(currentuser.lasthost, fromhost, sizeof(currentuser.lasthost)); if (login_start_time - currentuser.lastlogin >= 20 * 60 || !strcmp(currentuser.userid, "guest") || currentuser.numlogins < 100) { currentuser.numlogins++; } session_basic_info_t *res = get_my_sessions(); update_user_stay(¤tuser, true, session_basic_info_count(res) > 1); session_basic_info_clear(res); #ifdef ALLOWGAME if (currentuser.money> 1000000) { currentuser.nummedals += currentuser.money / 10000; currentuser.money %= 1000000; } if ((signed int) (currentuser.money - currentuser.bet) < -4990 && currentuser.numlogins < 10 && currentuser.numposts < 10 && currentuser.nummedals == 0) currentuser.money += 1000; #endif if (currentuser.firstlogin == 0) { currentuser.firstlogin = time(NULL) - 7 * 86400; } substitut_record(PASSFILE, ¤tuser, sizeof(currentuser), usernum); extern char currmaildir[]; setmdir(currmaildir, currentuser.userid); check_register_info(); }
void start_client(void) { extern char currmaildir[]; initialize_mdb(); #ifndef ENABLE_SSH initialize_db(); #endif initialize_convert_env(); system_init(); if (setjmp(byebye)) { system_abort(); } strlcpy(BoardName, BBSNAME, sizeof(BoardName)); if (login_query() == -1) { terminal_flush(); sleep(3); exit(1); } #ifndef ENABLE_SSH screen_negotiate_size(); #endif // ENABLE_SSH screen_init(0); user_login(); setmdir(currmaildir, currentuser.userid); RMSG = NA; screen_clear(); editor_restore(); #ifdef TALK_LOG tlog_recover(); #endif if (strcmp(currentuser.userid, "guest")) { if (check_maxmail()) pressanykey(); screen_move(9, 0); screen_clrtobot(); if (!DEFINE(DEF_NOLOGINSEND)) if (session_visible()) login_msg(); screen_clear(); set_numofsig(); } active_board_init(false); fill_date(); if (DEFINE(DEF_LOGFRIEND) && session_count_online_followed(!HAS_PERM(PERM_SEECLOAK)) > 0) show_online_followings(); menu_load("menu.img"); while (1) { if (DEFINE(DEF_NORMALSCR)) menu_loop("TOPMENU"); else menu_loop("TOPMENU2"); Goodbye(); } }
int main(void) { /* thread struct on stack */ DEFINE(THREAD_SHIFT, THREAD_SHIFT); DEFINE(THREAD_SIZE, THREAD_SIZE); DEFINE(TI_FLAGS, offsetof(struct thread_info, flags)); DEFINE(TI_PREEMPT, offsetof(struct thread_info, preempt_count)); DEFINE(TI_SC_NOERR, offsetof(struct thread_info, syscall_noerror)); /* task_struct->thread */ DEFINE(THREAD, offsetof(struct task_struct, thread)); DEFINE(PT_REGS, offsetof(struct thread_struct, regs)); DEFINE(THREAD_FPEXC_MODE, offsetof(struct thread_struct, fpexc_mode)); DEFINE(THREAD_FPR0, offsetof(struct thread_struct, fpr[0])); DEFINE(THREAD_FPSCR, offsetof(struct thread_struct, fpscr)); DEFINE(KSP, offsetof(struct thread_struct, ksp)); DEFINE(KSP_VSID, offsetof(struct thread_struct, ksp_vsid)); #ifdef CONFIG_ALTIVEC DEFINE(THREAD_VR0, offsetof(struct thread_struct, vr[0])); DEFINE(THREAD_VRSAVE, offsetof(struct thread_struct, vrsave)); DEFINE(THREAD_VSCR, offsetof(struct thread_struct, vscr)); DEFINE(THREAD_USED_VR, offsetof(struct thread_struct, used_vr)); #endif /* CONFIG_ALTIVEC */ DEFINE(MM, offsetof(struct task_struct, mm)); DEFINE(AUDITCONTEXT, offsetof(struct task_struct, audit_context)); /* naca */ DEFINE(PACA, offsetof(struct naca_struct, paca)); DEFINE(DCACHEL1LINESIZE, offsetof(struct systemcfg, dCacheL1LineSize)); DEFINE(DCACHEL1LOGLINESIZE, offsetof(struct naca_struct, dCacheL1LogLineSize)); DEFINE(DCACHEL1LINESPERPAGE, offsetof(struct naca_struct, dCacheL1LinesPerPage)); DEFINE(ICACHEL1LINESIZE, offsetof(struct systemcfg, iCacheL1LineSize)); DEFINE(ICACHEL1LOGLINESIZE, offsetof(struct naca_struct, iCacheL1LogLineSize)); DEFINE(ICACHEL1LINESPERPAGE, offsetof(struct naca_struct, iCacheL1LinesPerPage)); DEFINE(PLATFORM, offsetof(struct systemcfg, platform)); /* paca */ DEFINE(PACA_SIZE, sizeof(struct paca_struct)); DEFINE(PACAPACAINDEX, offsetof(struct paca_struct, paca_index)); DEFINE(PACAPROCSTART, offsetof(struct paca_struct, cpu_start)); DEFINE(PACAKSAVE, offsetof(struct paca_struct, kstack)); DEFINE(PACACURRENT, offsetof(struct paca_struct, __current)); DEFINE(PACASAVEDMSR, offsetof(struct paca_struct, saved_msr)); DEFINE(PACASTABREAL, offsetof(struct paca_struct, stab_real)); DEFINE(PACASTABVIRT, offsetof(struct paca_struct, stab_addr)); DEFINE(PACASTABRR, offsetof(struct paca_struct, stab_rr)); DEFINE(PACAR1, offsetof(struct paca_struct, saved_r1)); DEFINE(PACATOC, offsetof(struct paca_struct, kernel_toc)); DEFINE(PACAPROCENABLED, offsetof(struct paca_struct, proc_enabled)); DEFINE(PACASLBCACHE, offsetof(struct paca_struct, slb_cache)); DEFINE(PACASLBCACHEPTR, offsetof(struct paca_struct, slb_cache_ptr)); DEFINE(PACACONTEXTID, offsetof(struct paca_struct, context.id)); #ifdef CONFIG_HUGETLB_PAGE DEFINE(PACAHTLBSEGS, offsetof(struct paca_struct, context.htlb_segs)); #endif /* CONFIG_HUGETLB_PAGE */ DEFINE(PACADEFAULTDECR, offsetof(struct paca_struct, default_decr)); DEFINE(PACA_EXGEN, offsetof(struct paca_struct, exgen)); DEFINE(PACA_EXMC, offsetof(struct paca_struct, exmc)); DEFINE(PACA_EXSLB, offsetof(struct paca_struct, exslb)); DEFINE(PACA_EXDSI, offsetof(struct paca_struct, exdsi)); DEFINE(PACAEMERGSP, offsetof(struct paca_struct, emergency_sp)); DEFINE(PACALPPACA, offsetof(struct paca_struct, lppaca)); DEFINE(LPPACASRR0, offsetof(struct ItLpPaca, xSavedSrr0)); DEFINE(LPPACASRR1, offsetof(struct ItLpPaca, xSavedSrr1)); DEFINE(LPPACAANYINT, offsetof(struct ItLpPaca, xIntDword.xAnyInt)); DEFINE(LPPACADECRINT, offsetof(struct ItLpPaca, xIntDword.xFields.xDecrInt)); /* SLB shadow buffer */ DEFINE(SLBSHADOW_STACKVSID, offsetof(struct slb_shadow, save_area[SLB_NUM_BOLTED - 1].vsid)); DEFINE(SLBSHADOW_STACKESID, offsetof(struct slb_shadow, save_area[SLB_NUM_BOLTED - 1].esid)); /* RTAS */ DEFINE(RTASBASE, offsetof(struct rtas_t, base)); DEFINE(RTASENTRY, offsetof(struct rtas_t, entry)); /* Interrupt register frame */ DEFINE(STACK_FRAME_OVERHEAD, STACK_FRAME_OVERHEAD); DEFINE(SWITCH_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs)); /* 288 = # of volatile regs, int & fp, for leaf routines */ /* which do not stack a frame. See the PPC64 ABI. */ DEFINE(INT_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 288); /* Create extra stack space for SRR0 and SRR1 when calling prom/rtas. */ DEFINE(PROM_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 16); DEFINE(RTAS_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 16); DEFINE(GPR0, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[0])); DEFINE(GPR1, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[1])); DEFINE(GPR2, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[2])); DEFINE(GPR3, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[3])); DEFINE(GPR4, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[4])); DEFINE(GPR5, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[5])); DEFINE(GPR6, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[6])); DEFINE(GPR7, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[7])); DEFINE(GPR8, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[8])); DEFINE(GPR9, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[9])); DEFINE(GPR10, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[10])); DEFINE(GPR11, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[11])); DEFINE(GPR12, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[12])); DEFINE(GPR13, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[13])); /* * Note: these symbols include _ because they overlap with special * register names */ DEFINE(_NIP, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, nip)); DEFINE(_MSR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, msr)); DEFINE(_CTR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, ctr)); DEFINE(_LINK, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, link)); DEFINE(_CCR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, ccr)); DEFINE(_XER, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, xer)); DEFINE(_DAR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, dar)); DEFINE(_DSISR, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, dsisr)); DEFINE(ORIG_GPR3, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, orig_gpr3)); DEFINE(RESULT, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, result)); DEFINE(_TRAP, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, trap)); DEFINE(SOFTE, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, softe)); /* These _only_ to be used with {PROM,RTAS}_FRAME_SIZE!!! */ DEFINE(_SRR0, STACK_FRAME_OVERHEAD+sizeof(struct pt_regs)); DEFINE(_SRR1, STACK_FRAME_OVERHEAD+sizeof(struct pt_regs)+8); DEFINE(CLONE_VM, CLONE_VM); DEFINE(CLONE_UNTRACED, CLONE_UNTRACED); /* About the CPU features table */ DEFINE(CPU_SPEC_ENTRY_SIZE, sizeof(struct cpu_spec)); DEFINE(CPU_SPEC_PVR_MASK, offsetof(struct cpu_spec, pvr_mask)); DEFINE(CPU_SPEC_PVR_VALUE, offsetof(struct cpu_spec, pvr_value)); DEFINE(CPU_SPEC_FEATURES, offsetof(struct cpu_spec, cpu_features)); DEFINE(CPU_SPEC_SETUP, offsetof(struct cpu_spec, cpu_setup)); return 0; }
int main(void) { #ifdef CONFIG_PARAVIRT OFFSET(PV_CPU_usergs_sysret64, pv_cpu_ops, usergs_sysret64); OFFSET(PV_CPU_swapgs, pv_cpu_ops, swapgs); #ifdef CONFIG_DEBUG_ENTRY OFFSET(PV_IRQ_save_fl, pv_irq_ops, save_fl); #endif BLANK(); #endif #if defined(CONFIG_KVM_GUEST) && defined(CONFIG_PARAVIRT_SPINLOCKS) OFFSET(KVM_STEAL_TIME_preempted, kvm_steal_time, preempted); BLANK(); #endif #define ENTRY(entry) OFFSET(pt_regs_ ## entry, pt_regs, entry) ENTRY(bx); ENTRY(cx); ENTRY(dx); ENTRY(sp); ENTRY(bp); ENTRY(si); ENTRY(di); ENTRY(r8); ENTRY(r9); ENTRY(r10); ENTRY(r11); ENTRY(r12); ENTRY(r13); ENTRY(r14); ENTRY(r15); ENTRY(flags); BLANK(); #undef ENTRY #define ENTRY(entry) OFFSET(saved_context_ ## entry, saved_context, entry) ENTRY(cr0); ENTRY(cr2); ENTRY(cr3); ENTRY(cr4); ENTRY(cr8); ENTRY(gdt_desc); BLANK(); #undef ENTRY OFFSET(TSS_ist, tss_struct, x86_tss.ist); OFFSET(TSS_sp0, tss_struct, x86_tss.sp0); OFFSET(TSS_sp1, tss_struct, x86_tss.sp1); BLANK(); #ifdef CONFIG_CC_STACKPROTECTOR DEFINE(stack_canary_offset, offsetof(union irq_stack_union, stack_canary)); BLANK(); #endif DEFINE(__NR_syscall_max, sizeof(syscalls_64) - 1); DEFINE(NR_syscalls, sizeof(syscalls_64)); DEFINE(__NR_syscall_compat_max, sizeof(syscalls_ia32) - 1); DEFINE(IA32_NR_syscalls, sizeof(syscalls_ia32)); return 0; }
int main(void) { /* offsets into the task struct */ DEFINE(TASK_STATE, offsetof(struct task_struct, state)); DEFINE(TASK_FLAGS, offsetof(struct task_struct, flags)); DEFINE(TASK_PTRACE, offsetof(struct task_struct, ptrace)); DEFINE(TASK_BLOCKED, offsetof(struct task_struct, blocked)); DEFINE(TASK_THREAD, offsetof(struct task_struct, thread)); DEFINE(TASK_THREAD_INFO, offsetof(struct task_struct, stack)); DEFINE(TASK_MM, offsetof(struct task_struct, mm)); DEFINE(TASK_ACTIVE_MM, offsetof(struct task_struct, active_mm)); DEFINE(TASK_SIGPENDING, offsetof(struct task_struct, pending)); /* offsets into the irq_cpustat_t struct */ DEFINE(CPUSTAT_SOFTIRQ_PENDING, offsetof(irq_cpustat_t, __softirq_pending)); /* offsets into the thread struct */ DEFINE(THREAD_KSP, offsetof(struct thread_struct, ksp)); DEFINE(THREAD_USP, offsetof(struct thread_struct, usp)); DEFINE(THREAD_SR, offsetof(struct thread_struct, seqstat)); DEFINE(PT_SR, offsetof(struct thread_struct, seqstat)); DEFINE(THREAD_ESP0, offsetof(struct thread_struct, esp0)); DEFINE(THREAD_PC, offsetof(struct thread_struct, pc)); DEFINE(KERNEL_STACK_SIZE, THREAD_SIZE); /* offsets into the pt_regs */ DEFINE(PT_ORIG_P0, offsetof(struct pt_regs, orig_p0)); DEFINE(PT_ORIG_PC, offsetof(struct pt_regs, orig_pc)); DEFINE(PT_R0, offsetof(struct pt_regs, r0)); DEFINE(PT_R1, offsetof(struct pt_regs, r1)); DEFINE(PT_R2, offsetof(struct pt_regs, r2)); DEFINE(PT_R3, offsetof(struct pt_regs, r3)); DEFINE(PT_R4, offsetof(struct pt_regs, r4)); DEFINE(PT_R5, offsetof(struct pt_regs, r5)); DEFINE(PT_R6, offsetof(struct pt_regs, r6)); DEFINE(PT_R7, offsetof(struct pt_regs, r7)); DEFINE(PT_P0, offsetof(struct pt_regs, p0)); DEFINE(PT_P1, offsetof(struct pt_regs, p1)); DEFINE(PT_P2, offsetof(struct pt_regs, p2)); DEFINE(PT_P3, offsetof(struct pt_regs, p3)); DEFINE(PT_P4, offsetof(struct pt_regs, p4)); DEFINE(PT_P5, offsetof(struct pt_regs, p5)); DEFINE(PT_FP, offsetof(struct pt_regs, fp)); DEFINE(PT_USP, offsetof(struct pt_regs, usp)); DEFINE(PT_I0, offsetof(struct pt_regs, i0)); DEFINE(PT_I1, offsetof(struct pt_regs, i1)); DEFINE(PT_I2, offsetof(struct pt_regs, i2)); DEFINE(PT_I3, offsetof(struct pt_regs, i3)); DEFINE(PT_M0, offsetof(struct pt_regs, m0)); DEFINE(PT_M1, offsetof(struct pt_regs, m1)); DEFINE(PT_M2, offsetof(struct pt_regs, m2)); DEFINE(PT_M3, offsetof(struct pt_regs, m3)); DEFINE(PT_L0, offsetof(struct pt_regs, l0)); DEFINE(PT_L1, offsetof(struct pt_regs, l1)); DEFINE(PT_L2, offsetof(struct pt_regs, l2)); DEFINE(PT_L3, offsetof(struct pt_regs, l3)); DEFINE(PT_B0, offsetof(struct pt_regs, b0)); DEFINE(PT_B1, offsetof(struct pt_regs, b1)); DEFINE(PT_B2, offsetof(struct pt_regs, b2)); DEFINE(PT_B3, offsetof(struct pt_regs, b3)); DEFINE(PT_A0X, offsetof(struct pt_regs, a0x)); DEFINE(PT_A0W, offsetof(struct pt_regs, a0w)); DEFINE(PT_A1X, offsetof(struct pt_regs, a1x)); DEFINE(PT_A1W, offsetof(struct pt_regs, a1w)); DEFINE(PT_LC0, offsetof(struct pt_regs, lc0)); DEFINE(PT_LC1, offsetof(struct pt_regs, lc1)); DEFINE(PT_LT0, offsetof(struct pt_regs, lt0)); DEFINE(PT_LT1, offsetof(struct pt_regs, lt1)); DEFINE(PT_LB0, offsetof(struct pt_regs, lb0)); DEFINE(PT_LB1, offsetof(struct pt_regs, lb1)); DEFINE(PT_ASTAT, offsetof(struct pt_regs, astat)); DEFINE(PT_RESERVED, offsetof(struct pt_regs, reserved)); DEFINE(PT_RETS, offsetof(struct pt_regs, rets)); DEFINE(PT_PC, offsetof(struct pt_regs, pc)); DEFINE(PT_RETX, offsetof(struct pt_regs, retx)); DEFINE(PT_RETN, offsetof(struct pt_regs, retn)); DEFINE(PT_RETE, offsetof(struct pt_regs, rete)); DEFINE(PT_SEQSTAT, offsetof(struct pt_regs, seqstat)); DEFINE(PT_SYSCFG, offsetof(struct pt_regs, syscfg)); DEFINE(PT_IPEND, offsetof(struct pt_regs, ipend)); DEFINE(SIZEOF_PTREGS, sizeof(struct pt_regs)); DEFINE(PT_TEXT_ADDR, sizeof(struct pt_regs)); /* Needed by gdb */ DEFINE(PT_TEXT_END_ADDR, 4 + sizeof(struct pt_regs));/* Needed by gdb */ DEFINE(PT_DATA_ADDR, 8 + sizeof(struct pt_regs)); /* Needed by gdb */ DEFINE(PT_FDPIC_EXEC, 12 + sizeof(struct pt_regs)); /* Needed by gdb */ DEFINE(PT_FDPIC_INTERP, 16 + sizeof(struct pt_regs));/* Needed by gdb */ /* signal defines */ DEFINE(SIGSEGV, SIGSEGV); DEFINE(SIGTRAP, SIGTRAP); return 0; }
int main (void) { /* offsets into the task struct */ DEFINE (TASK_STATE, offsetof (struct task_struct, state)); DEFINE (TASK_FLAGS, offsetof (struct task_struct, flags)); DEFINE (TASK_PTRACE, offsetof (struct task_struct, ptrace)); DEFINE (TASK_BLOCKED, offsetof (struct task_struct, blocked)); DEFINE (TASK_THREAD, offsetof (struct task_struct, thread)); DEFINE (TASK_THREAD_INFO, offsetof (struct task_struct, thread_info)); DEFINE (TASK_MM, offsetof (struct task_struct, mm)); DEFINE (TASK_ACTIVE_MM, offsetof (struct task_struct, active_mm)); DEFINE (TASK_PID, offsetof (struct task_struct, pid)); /* offsets into the kernel_stat struct */ DEFINE (STAT_IRQ, offsetof (struct kernel_stat, irqs)); /* signal defines */ DEFINE (SIGSEGV, SIGSEGV); DEFINE (SEGV_MAPERR, SEGV_MAPERR); DEFINE (SIGTRAP, SIGTRAP); DEFINE (SIGCHLD, SIGCHLD); DEFINE (SIGILL, SIGILL); DEFINE (TRAP_TRACE, TRAP_TRACE); /* ptrace flag bits */ DEFINE (PT_PTRACED, PT_PTRACED); DEFINE (PT_DTRACE, PT_DTRACE); /* error values */ DEFINE (ENOSYS, ENOSYS); /* clone flag bits */ DEFINE (CLONE_VFORK, CLONE_VFORK); DEFINE (CLONE_VM, CLONE_VM); return 0; }
void output_kvm_defines(void) { COMMENT(" KVM/MIPS Specfic offsets. "); DEFINE(VCPU_ARCH_SIZE, sizeof(struct kvm_vcpu_arch)); OFFSET(VCPU_RUN, kvm_vcpu, run); OFFSET(VCPU_HOST_ARCH, kvm_vcpu, arch); OFFSET(VCPU_HOST_EBASE, kvm_vcpu_arch, host_ebase); OFFSET(VCPU_GUEST_EBASE, kvm_vcpu_arch, guest_ebase); OFFSET(VCPU_HOST_STACK, kvm_vcpu_arch, host_stack); OFFSET(VCPU_HOST_GP, kvm_vcpu_arch, host_gp); OFFSET(VCPU_HOST_CP0_BADVADDR, kvm_vcpu_arch, host_cp0_badvaddr); OFFSET(VCPU_HOST_CP0_CAUSE, kvm_vcpu_arch, host_cp0_cause); OFFSET(VCPU_HOST_EPC, kvm_vcpu_arch, host_cp0_epc); OFFSET(VCPU_HOST_ENTRYHI, kvm_vcpu_arch, host_cp0_entryhi); OFFSET(VCPU_GUEST_INST, kvm_vcpu_arch, guest_inst); OFFSET(VCPU_R0, kvm_vcpu_arch, gprs[0]); OFFSET(VCPU_R1, kvm_vcpu_arch, gprs[1]); OFFSET(VCPU_R2, kvm_vcpu_arch, gprs[2]); OFFSET(VCPU_R3, kvm_vcpu_arch, gprs[3]); OFFSET(VCPU_R4, kvm_vcpu_arch, gprs[4]); OFFSET(VCPU_R5, kvm_vcpu_arch, gprs[5]); OFFSET(VCPU_R6, kvm_vcpu_arch, gprs[6]); OFFSET(VCPU_R7, kvm_vcpu_arch, gprs[7]); OFFSET(VCPU_R8, kvm_vcpu_arch, gprs[8]); OFFSET(VCPU_R9, kvm_vcpu_arch, gprs[9]); OFFSET(VCPU_R10, kvm_vcpu_arch, gprs[10]); OFFSET(VCPU_R11, kvm_vcpu_arch, gprs[11]); OFFSET(VCPU_R12, kvm_vcpu_arch, gprs[12]); OFFSET(VCPU_R13, kvm_vcpu_arch, gprs[13]); OFFSET(VCPU_R14, kvm_vcpu_arch, gprs[14]); OFFSET(VCPU_R15, kvm_vcpu_arch, gprs[15]); OFFSET(VCPU_R16, kvm_vcpu_arch, gprs[16]); OFFSET(VCPU_R17, kvm_vcpu_arch, gprs[17]); OFFSET(VCPU_R18, kvm_vcpu_arch, gprs[18]); OFFSET(VCPU_R19, kvm_vcpu_arch, gprs[19]); OFFSET(VCPU_R20, kvm_vcpu_arch, gprs[20]); OFFSET(VCPU_R21, kvm_vcpu_arch, gprs[21]); OFFSET(VCPU_R22, kvm_vcpu_arch, gprs[22]); OFFSET(VCPU_R23, kvm_vcpu_arch, gprs[23]); OFFSET(VCPU_R24, kvm_vcpu_arch, gprs[24]); OFFSET(VCPU_R25, kvm_vcpu_arch, gprs[25]); OFFSET(VCPU_R26, kvm_vcpu_arch, gprs[26]); OFFSET(VCPU_R27, kvm_vcpu_arch, gprs[27]); OFFSET(VCPU_R28, kvm_vcpu_arch, gprs[28]); OFFSET(VCPU_R29, kvm_vcpu_arch, gprs[29]); OFFSET(VCPU_R30, kvm_vcpu_arch, gprs[30]); OFFSET(VCPU_R31, kvm_vcpu_arch, gprs[31]); OFFSET(VCPU_LO, kvm_vcpu_arch, lo); OFFSET(VCPU_HI, kvm_vcpu_arch, hi); OFFSET(VCPU_PC, kvm_vcpu_arch, pc); OFFSET(VCPU_COP0, kvm_vcpu_arch, cop0); OFFSET(VCPU_GUEST_KERNEL_ASID, kvm_vcpu_arch, guest_kernel_asid); OFFSET(VCPU_GUEST_USER_ASID, kvm_vcpu_arch, guest_user_asid); OFFSET(COP0_TLB_HI, mips_coproc, reg[MIPS_CP0_TLB_HI][0]); OFFSET(COP0_STATUS, mips_coproc, reg[MIPS_CP0_STATUS][0]); BLANK(); }
void output_mm_defines(void) { COMMENT("Size of struct page"); DEFINE(STRUCT_PAGE_SIZE, sizeof(struct page)); BLANK(); COMMENT("Linux mm_struct offsets."); OFFSET(MM_USERS, mm_struct, mm_users); OFFSET(MM_PGD, mm_struct, pgd); OFFSET(MM_CONTEXT, mm_struct, context); BLANK(); DEFINE(_PGD_T_SIZE, sizeof(pgd_t)); DEFINE(_PMD_T_SIZE, sizeof(pmd_t)); DEFINE(_PTE_T_SIZE, sizeof(pte_t)); BLANK(); DEFINE(_PGD_T_LOG2, PGD_T_LOG2); #ifndef __PAGETABLE_PMD_FOLDED DEFINE(_PMD_T_LOG2, PMD_T_LOG2); #endif DEFINE(_PTE_T_LOG2, PTE_T_LOG2); BLANK(); DEFINE(_PGD_ORDER, PGD_ORDER); #ifndef __PAGETABLE_PMD_FOLDED DEFINE(_PMD_ORDER, PMD_ORDER); #endif DEFINE(_PTE_ORDER, PTE_ORDER); BLANK(); DEFINE(_PMD_SHIFT, PMD_SHIFT); DEFINE(_PGDIR_SHIFT, PGDIR_SHIFT); BLANK(); DEFINE(_PTRS_PER_PGD, PTRS_PER_PGD); DEFINE(_PTRS_PER_PMD, PTRS_PER_PMD); DEFINE(_PTRS_PER_PTE, PTRS_PER_PTE); BLANK(); DEFINE(_PAGE_SHIFT, PAGE_SHIFT); DEFINE(_PAGE_SIZE, PAGE_SIZE); BLANK(); }
int main(void) { DEFINE(TSK_ACTIVE_MM, offsetof(struct task_struct, active_mm)); BLANK(); DEFINE(TI_FLAGS, offsetof(struct thread_info, flags)); DEFINE(TI_PREEMPT, offsetof(struct thread_info, preempt_count)); DEFINE(TI_ADDR_LIMIT, offsetof(struct thread_info, addr_limit)); DEFINE(TI_TASK, offsetof(struct thread_info, task)); DEFINE(TI_EXEC_DOMAIN, offsetof(struct thread_info, exec_domain)); DEFINE(TI_CPU, offsetof(struct thread_info, cpu)); DEFINE(TI_CPU_SAVE, offsetof(struct thread_info, cpu_context)); DEFINE(TI_USED_CP, offsetof(struct thread_info, used_cp)); #ifdef CONFIG_UNICORE_FPU_F64 DEFINE(TI_FPSTATE, offsetof(struct thread_info, fpstate)); #endif BLANK(); DEFINE(S_R0, offsetof(struct pt_regs, UCreg_00)); DEFINE(S_R1, offsetof(struct pt_regs, UCreg_01)); DEFINE(S_R2, offsetof(struct pt_regs, UCreg_02)); DEFINE(S_R3, offsetof(struct pt_regs, UCreg_03)); DEFINE(S_R4, offsetof(struct pt_regs, UCreg_04)); DEFINE(S_R5, offsetof(struct pt_regs, UCreg_05)); DEFINE(S_R6, offsetof(struct pt_regs, UCreg_06)); DEFINE(S_R7, offsetof(struct pt_regs, UCreg_07)); DEFINE(S_R8, offsetof(struct pt_regs, UCreg_08)); DEFINE(S_R9, offsetof(struct pt_regs, UCreg_09)); DEFINE(S_R10, offsetof(struct pt_regs, UCreg_10)); DEFINE(S_R11, offsetof(struct pt_regs, UCreg_11)); DEFINE(S_R12, offsetof(struct pt_regs, UCreg_12)); DEFINE(S_R13, offsetof(struct pt_regs, UCreg_13)); DEFINE(S_R14, offsetof(struct pt_regs, UCreg_14)); DEFINE(S_R15, offsetof(struct pt_regs, UCreg_15)); DEFINE(S_R16, offsetof(struct pt_regs, UCreg_16)); DEFINE(S_R17, offsetof(struct pt_regs, UCreg_17)); DEFINE(S_R18, offsetof(struct pt_regs, UCreg_18)); DEFINE(S_R19, offsetof(struct pt_regs, UCreg_19)); DEFINE(S_R20, offsetof(struct pt_regs, UCreg_20)); DEFINE(S_R21, offsetof(struct pt_regs, UCreg_21)); DEFINE(S_R22, offsetof(struct pt_regs, UCreg_22)); DEFINE(S_R23, offsetof(struct pt_regs, UCreg_23)); DEFINE(S_R24, offsetof(struct pt_regs, UCreg_24)); DEFINE(S_R25, offsetof(struct pt_regs, UCreg_25)); DEFINE(S_R26, offsetof(struct pt_regs, UCreg_26)); DEFINE(S_FP, offsetof(struct pt_regs, UCreg_fp)); DEFINE(S_IP, offsetof(struct pt_regs, UCreg_ip)); DEFINE(S_SP, offsetof(struct pt_regs, UCreg_sp)); DEFINE(S_LR, offsetof(struct pt_regs, UCreg_lr)); DEFINE(S_PC, offsetof(struct pt_regs, UCreg_pc)); DEFINE(S_PSR, offsetof(struct pt_regs, UCreg_asr)); DEFINE(S_OLD_R0, offsetof(struct pt_regs, UCreg_ORIG_00)); DEFINE(S_FRAME_SIZE, sizeof(struct pt_regs)); BLANK(); DEFINE(VMA_VM_MM, offsetof(struct vm_area_struct, vm_mm)); DEFINE(VMA_VM_FLAGS, offsetof(struct vm_area_struct, vm_flags)); BLANK(); DEFINE(VM_EXEC, VM_EXEC); BLANK(); DEFINE(PAGE_SZ, PAGE_SIZE); BLANK(); DEFINE(SYS_ERROR0, 0x9f0000); BLANK(); DEFINE(PBE_ADDRESS, offsetof(struct pbe, address)); DEFINE(PBE_ORIN_ADDRESS, offsetof(struct pbe, orig_address)); DEFINE(PBE_NEXT, offsetof(struct pbe, next)); DEFINE(SWSUSP_CPU, offsetof(struct swsusp_arch_regs, \ cpu_context)); #ifdef CONFIG_UNICORE_FPU_F64 DEFINE(SWSUSP_FPSTATE, offsetof(struct swsusp_arch_regs, \ fpstate)); #endif BLANK(); DEFINE(DMA_BIDIRECTIONAL, DMA_BIDIRECTIONAL); DEFINE(DMA_TO_DEVICE, DMA_TO_DEVICE); DEFINE(DMA_FROM_DEVICE, DMA_FROM_DEVICE); return 0; }
void output_signal_defined(void) { COMMENT("Linux signal numbers."); DEFINE(_SIGHUP, SIGHUP); DEFINE(_SIGINT, SIGINT); DEFINE(_SIGQUIT, SIGQUIT); DEFINE(_SIGILL, SIGILL); DEFINE(_SIGTRAP, SIGTRAP); DEFINE(_SIGIOT, SIGIOT); DEFINE(_SIGABRT, SIGABRT); DEFINE(_SIGFPE, SIGFPE); DEFINE(_SIGKILL, SIGKILL); DEFINE(_SIGBUS, SIGBUS); DEFINE(_SIGSEGV, SIGSEGV); DEFINE(_SIGSYS, SIGSYS); DEFINE(_SIGPIPE, SIGPIPE); DEFINE(_SIGALRM, SIGALRM); DEFINE(_SIGTERM, SIGTERM); DEFINE(_SIGUSR1, SIGUSR1); DEFINE(_SIGUSR2, SIGUSR2); DEFINE(_SIGCHLD, SIGCHLD); DEFINE(_SIGPWR, SIGPWR); DEFINE(_SIGWINCH, SIGWINCH); DEFINE(_SIGURG, SIGURG); DEFINE(_SIGIO, SIGIO); DEFINE(_SIGSTOP, SIGSTOP); DEFINE(_SIGTSTP, SIGTSTP); DEFINE(_SIGCONT, SIGCONT); DEFINE(_SIGTTIN, SIGTTIN); DEFINE(_SIGTTOU, SIGTTOU); DEFINE(_SIGVTALRM, SIGVTALRM); DEFINE(_SIGPROF, SIGPROF); DEFINE(_SIGXCPU, SIGXCPU); DEFINE(_SIGXFSZ, SIGXFSZ); BLANK(); }
int main(void) { DEFINE(GENERATED_IPQ_RESERVE_SIZE, sizeof(ipq_mem_reserve_t)); return 0; }
int main(void) { /* struct pt_regs */ DEFINE(PT_PC, offsetof (struct pt_regs, pc)); DEFINE(PT_PS, offsetof (struct pt_regs, ps)); DEFINE(PT_DEPC, offsetof (struct pt_regs, depc)); DEFINE(PT_EXCCAUSE, offsetof (struct pt_regs, exccause)); DEFINE(PT_EXCVADDR, offsetof (struct pt_regs, excvaddr)); DEFINE(PT_DEBUGCAUSE, offsetof (struct pt_regs, debugcause)); DEFINE(PT_WMASK, offsetof (struct pt_regs, wmask)); DEFINE(PT_LBEG, offsetof (struct pt_regs, lbeg)); DEFINE(PT_LEND, offsetof (struct pt_regs, lend)); DEFINE(PT_LCOUNT, offsetof (struct pt_regs, lcount)); DEFINE(PT_SAR, offsetof (struct pt_regs, sar)); DEFINE(PT_ICOUNTLEVEL, offsetof (struct pt_regs, icountlevel)); DEFINE(PT_SYSCALL, offsetof (struct pt_regs, syscall)); DEFINE(PT_AREG, offsetof (struct pt_regs, areg[0])); DEFINE(PT_AREG0, offsetof (struct pt_regs, areg[0])); DEFINE(PT_AREG1, offsetof (struct pt_regs, areg[1])); DEFINE(PT_AREG2, offsetof (struct pt_regs, areg[2])); DEFINE(PT_AREG3, offsetof (struct pt_regs, areg[3])); DEFINE(PT_AREG4, offsetof (struct pt_regs, areg[4])); DEFINE(PT_AREG5, offsetof (struct pt_regs, areg[5])); DEFINE(PT_AREG6, offsetof (struct pt_regs, areg[6])); DEFINE(PT_AREG7, offsetof (struct pt_regs, areg[7])); DEFINE(PT_AREG8, offsetof (struct pt_regs, areg[8])); DEFINE(PT_AREG9, offsetof (struct pt_regs, areg[9])); DEFINE(PT_AREG10, offsetof (struct pt_regs, areg[10])); DEFINE(PT_AREG11, offsetof (struct pt_regs, areg[11])); DEFINE(PT_AREG12, offsetof (struct pt_regs, areg[12])); DEFINE(PT_AREG13, offsetof (struct pt_regs, areg[13])); DEFINE(PT_AREG14, offsetof (struct pt_regs, areg[14])); DEFINE(PT_AREG15, offsetof (struct pt_regs, areg[15])); DEFINE(PT_WINDOWBASE, offsetof (struct pt_regs, windowbase)); DEFINE(PT_WINDOWSTART, offsetof(struct pt_regs, windowstart)); DEFINE(PT_SIZE, sizeof(struct pt_regs)); DEFINE(PT_AREG_END, offsetof (struct pt_regs, areg[XCHAL_NUM_AREGS])); DEFINE(PT_USER_SIZE, offsetof(struct pt_regs, areg[XCHAL_NUM_AREGS])); DEFINE(PT_XTREGS_OPT, offsetof(struct pt_regs, xtregs_opt)); DEFINE(XTREGS_OPT_SIZE, sizeof(xtregs_opt_t)); /* struct task_struct */ DEFINE(TASK_PTRACE, offsetof (struct task_struct, ptrace)); DEFINE(TASK_MM, offsetof (struct task_struct, mm)); DEFINE(TASK_ACTIVE_MM, offsetof (struct task_struct, active_mm)); DEFINE(TASK_PID, offsetof (struct task_struct, pid)); DEFINE(TASK_THREAD, offsetof (struct task_struct, thread)); DEFINE(TASK_THREAD_INFO, offsetof (struct task_struct, stack)); DEFINE(TASK_STRUCT_SIZE, sizeof (struct task_struct)); /* struct thread_info (offset from start_struct) */ DEFINE(THREAD_RA, offsetof (struct task_struct, thread.ra)); DEFINE(THREAD_SP, offsetof (struct task_struct, thread.sp)); DEFINE(THREAD_CPENABLE, offsetof (struct thread_info, cpenable)); #if XTENSA_HAVE_COPROCESSORS DEFINE(THREAD_XTREGS_CP0, offsetof (struct thread_info, xtregs_cp)); DEFINE(THREAD_XTREGS_CP1, offsetof (struct thread_info, xtregs_cp)); DEFINE(THREAD_XTREGS_CP2, offsetof (struct thread_info, xtregs_cp)); DEFINE(THREAD_XTREGS_CP3, offsetof (struct thread_info, xtregs_cp)); DEFINE(THREAD_XTREGS_CP4, offsetof (struct thread_info, xtregs_cp)); DEFINE(THREAD_XTREGS_CP5, offsetof (struct thread_info, xtregs_cp)); DEFINE(THREAD_XTREGS_CP6, offsetof (struct thread_info, xtregs_cp)); DEFINE(THREAD_XTREGS_CP7, offsetof (struct thread_info, xtregs_cp)); #endif DEFINE(THREAD_XTREGS_USER, offsetof (struct thread_info, xtregs_user)); DEFINE(XTREGS_USER_SIZE, sizeof(xtregs_user_t)); DEFINE(THREAD_CURRENT_DS, offsetof (struct task_struct, thread.current_ds)); /* struct mm_struct */ DEFINE(MM_USERS, offsetof(struct mm_struct, mm_users)); DEFINE(MM_PGD, offsetof (struct mm_struct, pgd)); DEFINE(MM_CONTEXT, offsetof (struct mm_struct, context)); /* struct page */ DEFINE(PAGE_FLAGS, offsetof(struct page, flags)); /* constants */ DEFINE(_CLONE_VM, CLONE_VM); DEFINE(_CLONE_UNTRACED, CLONE_UNTRACED); DEFINE(PG_ARCH_1, PG_arch_1); return 0; }
void foo(void) { DEFINE(IA64_TASK_SIZE, sizeof (struct task_struct)); DEFINE(IA64_THREAD_INFO_SIZE, sizeof (struct thread_info)); DEFINE(IA64_PT_REGS_SIZE, sizeof (struct pt_regs)); DEFINE(IA64_SWITCH_STACK_SIZE, sizeof (struct switch_stack)); DEFINE(IA64_SIGINFO_SIZE, sizeof (struct siginfo)); DEFINE(IA64_CPU_SIZE, sizeof (struct cpuinfo_ia64)); DEFINE(SIGFRAME_SIZE, sizeof (struct sigframe)); DEFINE(UNW_FRAME_INFO_SIZE, sizeof (struct unw_frame_info)); BLANK(); DEFINE(TI_FLAGS, offsetof(struct thread_info, flags)); DEFINE(TI_PRE_COUNT, offsetof(struct thread_info, preempt_count)); BLANK(); DEFINE(IA64_TASK_BLOCKED_OFFSET,offsetof (struct task_struct, blocked)); DEFINE(IA64_TASK_CLEAR_CHILD_TID_OFFSET,offsetof (struct task_struct, clear_child_tid)); DEFINE(IA64_TASK_GROUP_LEADER_OFFSET, offsetof (struct task_struct, group_leader)); DEFINE(IA64_TASK_PENDING_OFFSET,offsetof (struct task_struct, pending)); DEFINE(IA64_TASK_PID_OFFSET, offsetof (struct task_struct, pid)); DEFINE(IA64_TASK_REAL_PARENT_OFFSET, offsetof (struct task_struct, real_parent)); DEFINE(IA64_TASK_SIGHAND_OFFSET,offsetof (struct task_struct, sighand)); DEFINE(IA64_TASK_SIGNAL_OFFSET,offsetof (struct task_struct, signal)); DEFINE(IA64_TASK_TGID_OFFSET, offsetof (struct task_struct, tgid)); DEFINE(IA64_TASK_THREAD_KSP_OFFSET, offsetof (struct task_struct, thread.ksp)); DEFINE(IA64_TASK_THREAD_ON_USTACK_OFFSET, offsetof (struct task_struct, thread.on_ustack)); BLANK(); DEFINE(IA64_SIGHAND_SIGLOCK_OFFSET,offsetof (struct sighand_struct, siglock)); BLANK(); DEFINE(IA64_SIGNAL_GROUP_STOP_COUNT_OFFSET,offsetof (struct signal_struct, group_stop_count)); DEFINE(IA64_SIGNAL_SHARED_PENDING_OFFSET,offsetof (struct signal_struct, shared_pending)); BLANK(); DEFINE(IA64_PT_REGS_B6_OFFSET, offsetof (struct pt_regs, b6)); DEFINE(IA64_PT_REGS_B7_OFFSET, offsetof (struct pt_regs, b7)); DEFINE(IA64_PT_REGS_AR_CSD_OFFSET, offsetof (struct pt_regs, ar_csd)); DEFINE(IA64_PT_REGS_AR_SSD_OFFSET, offsetof (struct pt_regs, ar_ssd)); DEFINE(IA64_PT_REGS_R8_OFFSET, offsetof (struct pt_regs, r8)); DEFINE(IA64_PT_REGS_R9_OFFSET, offsetof (struct pt_regs, r9)); DEFINE(IA64_PT_REGS_R10_OFFSET, offsetof (struct pt_regs, r10)); DEFINE(IA64_PT_REGS_R11_OFFSET, offsetof (struct pt_regs, r11)); DEFINE(IA64_PT_REGS_CR_IPSR_OFFSET, offsetof (struct pt_regs, cr_ipsr)); DEFINE(IA64_PT_REGS_CR_IIP_OFFSET, offsetof (struct pt_regs, cr_iip)); DEFINE(IA64_PT_REGS_CR_IFS_OFFSET, offsetof (struct pt_regs, cr_ifs)); DEFINE(IA64_PT_REGS_AR_UNAT_OFFSET, offsetof (struct pt_regs, ar_unat)); DEFINE(IA64_PT_REGS_AR_PFS_OFFSET, offsetof (struct pt_regs, ar_pfs)); DEFINE(IA64_PT_REGS_AR_RSC_OFFSET, offsetof (struct pt_regs, ar_rsc)); DEFINE(IA64_PT_REGS_AR_RNAT_OFFSET, offsetof (struct pt_regs, ar_rnat)); DEFINE(IA64_PT_REGS_AR_BSPSTORE_OFFSET, offsetof (struct pt_regs, ar_bspstore)); DEFINE(IA64_PT_REGS_PR_OFFSET, offsetof (struct pt_regs, pr)); DEFINE(IA64_PT_REGS_B0_OFFSET, offsetof (struct pt_regs, b0)); DEFINE(IA64_PT_REGS_LOADRS_OFFSET, offsetof (struct pt_regs, loadrs)); DEFINE(IA64_PT_REGS_R1_OFFSET, offsetof (struct pt_regs, r1)); DEFINE(IA64_PT_REGS_R12_OFFSET, offsetof (struct pt_regs, r12)); DEFINE(IA64_PT_REGS_R13_OFFSET, offsetof (struct pt_regs, r13)); DEFINE(IA64_PT_REGS_AR_FPSR_OFFSET, offsetof (struct pt_regs, ar_fpsr)); DEFINE(IA64_PT_REGS_R15_OFFSET, offsetof (struct pt_regs, r15)); DEFINE(IA64_PT_REGS_R14_OFFSET, offsetof (struct pt_regs, r14)); DEFINE(IA64_PT_REGS_R2_OFFSET, offsetof (struct pt_regs, r2)); DEFINE(IA64_PT_REGS_R3_OFFSET, offsetof (struct pt_regs, r3)); DEFINE(IA64_PT_REGS_R16_OFFSET, offsetof (struct pt_regs, r16)); DEFINE(IA64_PT_REGS_R17_OFFSET, offsetof (struct pt_regs, r17)); DEFINE(IA64_PT_REGS_R18_OFFSET, offsetof (struct pt_regs, r18)); DEFINE(IA64_PT_REGS_R19_OFFSET, offsetof (struct pt_regs, r19)); DEFINE(IA64_PT_REGS_R20_OFFSET, offsetof (struct pt_regs, r20)); DEFINE(IA64_PT_REGS_R21_OFFSET, offsetof (struct pt_regs, r21)); DEFINE(IA64_PT_REGS_R22_OFFSET, offsetof (struct pt_regs, r22)); DEFINE(IA64_PT_REGS_R23_OFFSET, offsetof (struct pt_regs, r23)); DEFINE(IA64_PT_REGS_R24_OFFSET, offsetof (struct pt_regs, r24)); DEFINE(IA64_PT_REGS_R25_OFFSET, offsetof (struct pt_regs, r25)); DEFINE(IA64_PT_REGS_R26_OFFSET, offsetof (struct pt_regs, r26)); DEFINE(IA64_PT_REGS_R27_OFFSET, offsetof (struct pt_regs, r27)); DEFINE(IA64_PT_REGS_R28_OFFSET, offsetof (struct pt_regs, r28)); DEFINE(IA64_PT_REGS_R29_OFFSET, offsetof (struct pt_regs, r29)); DEFINE(IA64_PT_REGS_R30_OFFSET, offsetof (struct pt_regs, r30)); DEFINE(IA64_PT_REGS_R31_OFFSET, offsetof (struct pt_regs, r31)); DEFINE(IA64_PT_REGS_AR_CCV_OFFSET, offsetof (struct pt_regs, ar_ccv)); DEFINE(IA64_PT_REGS_F6_OFFSET, offsetof (struct pt_regs, f6)); DEFINE(IA64_PT_REGS_F7_OFFSET, offsetof (struct pt_regs, f7)); DEFINE(IA64_PT_REGS_F8_OFFSET, offsetof (struct pt_regs, f8)); DEFINE(IA64_PT_REGS_F9_OFFSET, offsetof (struct pt_regs, f9)); DEFINE(IA64_PT_REGS_F10_OFFSET, offsetof (struct pt_regs, f10)); DEFINE(IA64_PT_REGS_F11_OFFSET, offsetof (struct pt_regs, f11)); BLANK(); DEFINE(IA64_SWITCH_STACK_CALLER_UNAT_OFFSET, offsetof (struct switch_stack, caller_unat)); DEFINE(IA64_SWITCH_STACK_AR_FPSR_OFFSET, offsetof (struct switch_stack, ar_fpsr)); DEFINE(IA64_SWITCH_STACK_F2_OFFSET, offsetof (struct switch_stack, f2)); DEFINE(IA64_SWITCH_STACK_F3_OFFSET, offsetof (struct switch_stack, f3)); DEFINE(IA64_SWITCH_STACK_F4_OFFSET, offsetof (struct switch_stack, f4)); DEFINE(IA64_SWITCH_STACK_F5_OFFSET, offsetof (struct switch_stack, f5)); DEFINE(IA64_SWITCH_STACK_F12_OFFSET, offsetof (struct switch_stack, f12)); DEFINE(IA64_SWITCH_STACK_F13_OFFSET, offsetof (struct switch_stack, f13)); DEFINE(IA64_SWITCH_STACK_F14_OFFSET, offsetof (struct switch_stack, f14)); DEFINE(IA64_SWITCH_STACK_F15_OFFSET, offsetof (struct switch_stack, f15)); DEFINE(IA64_SWITCH_STACK_F16_OFFSET, offsetof (struct switch_stack, f16)); DEFINE(IA64_SWITCH_STACK_F17_OFFSET, offsetof (struct switch_stack, f17)); DEFINE(IA64_SWITCH_STACK_F18_OFFSET, offsetof (struct switch_stack, f18)); DEFINE(IA64_SWITCH_STACK_F19_OFFSET, offsetof (struct switch_stack, f19)); DEFINE(IA64_SWITCH_STACK_F20_OFFSET, offsetof (struct switch_stack, f20)); DEFINE(IA64_SWITCH_STACK_F21_OFFSET, offsetof (struct switch_stack, f21)); DEFINE(IA64_SWITCH_STACK_F22_OFFSET, offsetof (struct switch_stack, f22)); DEFINE(IA64_SWITCH_STACK_F23_OFFSET, offsetof (struct switch_stack, f23)); DEFINE(IA64_SWITCH_STACK_F24_OFFSET, offsetof (struct switch_stack, f24)); DEFINE(IA64_SWITCH_STACK_F25_OFFSET, offsetof (struct switch_stack, f25)); DEFINE(IA64_SWITCH_STACK_F26_OFFSET, offsetof (struct switch_stack, f26)); DEFINE(IA64_SWITCH_STACK_F27_OFFSET, offsetof (struct switch_stack, f27)); DEFINE(IA64_SWITCH_STACK_F28_OFFSET, offsetof (struct switch_stack, f28)); DEFINE(IA64_SWITCH_STACK_F29_OFFSET, offsetof (struct switch_stack, f29)); DEFINE(IA64_SWITCH_STACK_F30_OFFSET, offsetof (struct switch_stack, f30)); DEFINE(IA64_SWITCH_STACK_F31_OFFSET, offsetof (struct switch_stack, f31)); DEFINE(IA64_SWITCH_STACK_R4_OFFSET, offsetof (struct switch_stack, r4)); DEFINE(IA64_SWITCH_STACK_R5_OFFSET, offsetof (struct switch_stack, r5)); DEFINE(IA64_SWITCH_STACK_R6_OFFSET, offsetof (struct switch_stack, r6)); DEFINE(IA64_SWITCH_STACK_R7_OFFSET, offsetof (struct switch_stack, r7)); DEFINE(IA64_SWITCH_STACK_B0_OFFSET, offsetof (struct switch_stack, b0)); DEFINE(IA64_SWITCH_STACK_B1_OFFSET, offsetof (struct switch_stack, b1)); DEFINE(IA64_SWITCH_STACK_B2_OFFSET, offsetof (struct switch_stack, b2)); DEFINE(IA64_SWITCH_STACK_B3_OFFSET, offsetof (struct switch_stack, b3)); DEFINE(IA64_SWITCH_STACK_B4_OFFSET, offsetof (struct switch_stack, b4)); DEFINE(IA64_SWITCH_STACK_B5_OFFSET, offsetof (struct switch_stack, b5)); DEFINE(IA64_SWITCH_STACK_AR_PFS_OFFSET, offsetof (struct switch_stack, ar_pfs)); DEFINE(IA64_SWITCH_STACK_AR_LC_OFFSET, offsetof (struct switch_stack, ar_lc)); DEFINE(IA64_SWITCH_STACK_AR_UNAT_OFFSET, offsetof (struct switch_stack, ar_unat)); DEFINE(IA64_SWITCH_STACK_AR_RNAT_OFFSET, offsetof (struct switch_stack, ar_rnat)); DEFINE(IA64_SWITCH_STACK_AR_BSPSTORE_OFFSET, offsetof (struct switch_stack, ar_bspstore)); DEFINE(IA64_SWITCH_STACK_PR_OFFSET, offsetof (struct switch_stack, pr)); BLANK(); DEFINE(IA64_SIGCONTEXT_IP_OFFSET, offsetof (struct sigcontext, sc_ip)); DEFINE(IA64_SIGCONTEXT_AR_BSP_OFFSET, offsetof (struct sigcontext, sc_ar_bsp)); DEFINE(IA64_SIGCONTEXT_AR_FPSR_OFFSET, offsetof (struct sigcontext, sc_ar_fpsr)); DEFINE(IA64_SIGCONTEXT_AR_RNAT_OFFSET, offsetof (struct sigcontext, sc_ar_rnat)); DEFINE(IA64_SIGCONTEXT_AR_UNAT_OFFSET, offsetof (struct sigcontext, sc_ar_unat)); DEFINE(IA64_SIGCONTEXT_B0_OFFSET, offsetof (struct sigcontext, sc_br[0])); DEFINE(IA64_SIGCONTEXT_CFM_OFFSET, offsetof (struct sigcontext, sc_cfm)); DEFINE(IA64_SIGCONTEXT_FLAGS_OFFSET, offsetof (struct sigcontext, sc_flags)); DEFINE(IA64_SIGCONTEXT_FR6_OFFSET, offsetof (struct sigcontext, sc_fr[6])); DEFINE(IA64_SIGCONTEXT_PR_OFFSET, offsetof (struct sigcontext, sc_pr)); DEFINE(IA64_SIGCONTEXT_R12_OFFSET, offsetof (struct sigcontext, sc_gr[12])); DEFINE(IA64_SIGCONTEXT_RBS_BASE_OFFSET,offsetof (struct sigcontext, sc_rbs_base)); DEFINE(IA64_SIGCONTEXT_LOADRS_OFFSET, offsetof (struct sigcontext, sc_loadrs)); BLANK(); DEFINE(IA64_SIGPENDING_SIGNAL_OFFSET, offsetof (struct sigpending, signal)); BLANK(); DEFINE(IA64_SIGFRAME_ARG0_OFFSET, offsetof (struct sigframe, arg0)); DEFINE(IA64_SIGFRAME_ARG1_OFFSET, offsetof (struct sigframe, arg1)); DEFINE(IA64_SIGFRAME_ARG2_OFFSET, offsetof (struct sigframe, arg2)); DEFINE(IA64_SIGFRAME_HANDLER_OFFSET, offsetof (struct sigframe, handler)); DEFINE(IA64_SIGFRAME_SIGCONTEXT_OFFSET, offsetof (struct sigframe, sc)); BLANK(); /* for assembly files which can't include sched.h: */ DEFINE(IA64_CLONE_VFORK, CLONE_VFORK); DEFINE(IA64_CLONE_VM, CLONE_VM); BLANK(); DEFINE(IA64_CPUINFO_NSEC_PER_CYC_OFFSET, offsetof (struct cpuinfo_ia64, nsec_per_cyc)); DEFINE(IA64_CPUINFO_PTCE_BASE_OFFSET, offsetof (struct cpuinfo_ia64, ptce_base)); DEFINE(IA64_CPUINFO_PTCE_COUNT_OFFSET, offsetof (struct cpuinfo_ia64, ptce_count)); DEFINE(IA64_CPUINFO_PTCE_STRIDE_OFFSET, offsetof (struct cpuinfo_ia64, ptce_stride)); BLANK(); DEFINE(IA64_TIMESPEC_TV_NSEC_OFFSET, offsetof (struct timespec, tv_nsec)); DEFINE(CLONE_SETTLS_BIT, 19); #if CLONE_SETTLS != (1<<19) # error "CLONE_SETTLS_BIT incorrect, please fix" #endif BLANK(); DEFINE(IA64_MCA_CPU_MCA_STACK_OFFSET, offsetof (struct ia64_mca_cpu, mca_stack)); DEFINE(IA64_MCA_CPU_INIT_STACK_OFFSET, offsetof (struct ia64_mca_cpu, init_stack)); BLANK(); DEFINE(IA64_SAL_OS_STATE_OS_GP_OFFSET, offsetof (struct ia64_sal_os_state, os_gp)); DEFINE(IA64_SAL_OS_STATE_PROC_STATE_PARAM_OFFSET, offsetof (struct ia64_sal_os_state, proc_state_param)); DEFINE(IA64_SAL_OS_STATE_SAL_RA_OFFSET, offsetof (struct ia64_sal_os_state, sal_ra)); DEFINE(IA64_SAL_OS_STATE_SAL_GP_OFFSET, offsetof (struct ia64_sal_os_state, sal_gp)); DEFINE(IA64_SAL_OS_STATE_PAL_MIN_STATE_OFFSET, offsetof (struct ia64_sal_os_state, pal_min_state)); DEFINE(IA64_SAL_OS_STATE_OS_STATUS_OFFSET, offsetof (struct ia64_sal_os_state, os_status)); DEFINE(IA64_SAL_OS_STATE_CONTEXT_OFFSET, offsetof (struct ia64_sal_os_state, context)); DEFINE(IA64_SAL_OS_STATE_SIZE, sizeof (struct ia64_sal_os_state)); BLANK(); DEFINE(IA64_PMSA_GR_OFFSET, offsetof (struct pal_min_state_area_s, pmsa_gr)); DEFINE(IA64_PMSA_BANK1_GR_OFFSET, offsetof (struct pal_min_state_area_s, pmsa_bank1_gr)); DEFINE(IA64_PMSA_PR_OFFSET, offsetof (struct pal_min_state_area_s, pmsa_pr)); DEFINE(IA64_PMSA_BR0_OFFSET, offsetof (struct pal_min_state_area_s, pmsa_br0)); DEFINE(IA64_PMSA_RSC_OFFSET, offsetof (struct pal_min_state_area_s, pmsa_rsc)); DEFINE(IA64_PMSA_IIP_OFFSET, offsetof (struct pal_min_state_area_s, pmsa_iip)); DEFINE(IA64_PMSA_IPSR_OFFSET, offsetof (struct pal_min_state_area_s, pmsa_ipsr)); DEFINE(IA64_PMSA_IFS_OFFSET, offsetof (struct pal_min_state_area_s, pmsa_ifs)); DEFINE(IA64_PMSA_XIP_OFFSET, offsetof (struct pal_min_state_area_s, pmsa_xip)); BLANK(); /* used by fsys_gettimeofday in arch/ia64/kernel/fsys.S */ DEFINE(IA64_TIME_INTERPOLATOR_ADDRESS_OFFSET, offsetof (struct time_interpolator, addr)); DEFINE(IA64_TIME_INTERPOLATOR_SOURCE_OFFSET, offsetof (struct time_interpolator, source)); DEFINE(IA64_TIME_INTERPOLATOR_SHIFT_OFFSET, offsetof (struct time_interpolator, shift)); DEFINE(IA64_TIME_INTERPOLATOR_NSEC_OFFSET, offsetof (struct time_interpolator, nsec_per_cyc)); DEFINE(IA64_TIME_INTERPOLATOR_OFFSET_OFFSET, offsetof (struct time_interpolator, offset)); DEFINE(IA64_TIME_INTERPOLATOR_LAST_CYCLE_OFFSET, offsetof (struct time_interpolator, last_cycle)); DEFINE(IA64_TIME_INTERPOLATOR_LAST_COUNTER_OFFSET, offsetof (struct time_interpolator, last_counter)); DEFINE(IA64_TIME_INTERPOLATOR_JITTER_OFFSET, offsetof (struct time_interpolator, jitter)); DEFINE(IA64_TIME_INTERPOLATOR_MASK_OFFSET, offsetof (struct time_interpolator, mask)); DEFINE(IA64_TIME_SOURCE_CPU, TIME_SOURCE_CPU); DEFINE(IA64_TIME_SOURCE_MMIO64, TIME_SOURCE_MMIO64); DEFINE(IA64_TIME_SOURCE_MMIO32, TIME_SOURCE_MMIO32); DEFINE(IA64_TIMESPEC_TV_NSEC_OFFSET, offsetof (struct timespec, tv_nsec)); #ifdef CONFIG_XEN BLANK(); #define DEFINE_MAPPED_REG_OFS(sym, field) \ DEFINE(sym, (XMAPPEDREGS_OFS + offsetof(mapped_regs_t, field))) DEFINE_MAPPED_REG_OFS(XSI_PSR_I_ADDR_OFS, interrupt_mask_addr); DEFINE_MAPPED_REG_OFS(XSI_IPSR_OFS, ipsr); DEFINE_MAPPED_REG_OFS(XSI_IIP_OFS, iip); DEFINE_MAPPED_REG_OFS(XSI_IFS_OFS, ifs); DEFINE_MAPPED_REG_OFS(XSI_PRECOVER_IFS_OFS, precover_ifs); DEFINE_MAPPED_REG_OFS(XSI_ISR_OFS, isr); DEFINE_MAPPED_REG_OFS(XSI_IFA_OFS, ifa); DEFINE_MAPPED_REG_OFS(XSI_IIPA_OFS, iipa); DEFINE_MAPPED_REG_OFS(XSI_IIM_OFS, iim); DEFINE_MAPPED_REG_OFS(XSI_IHA_OFS, iha); DEFINE_MAPPED_REG_OFS(XSI_ITIR_OFS, itir); DEFINE_MAPPED_REG_OFS(XSI_PSR_IC_OFS, interrupt_collection_enabled); DEFINE_MAPPED_REG_OFS(XSI_BANKNUM_OFS, banknum); DEFINE_MAPPED_REG_OFS(XSI_BANK0_R16_OFS, bank0_regs[0]); DEFINE_MAPPED_REG_OFS(XSI_BANK1_R16_OFS, bank1_regs[0]); DEFINE_MAPPED_REG_OFS(XSI_B0NATS_OFS, vbnat); DEFINE_MAPPED_REG_OFS(XSI_B1NATS_OFS, vnat); #endif /* CONFIG_XEN */ }