#!/usr/bin/python # # this tool is used to generate the syscall assmbler templates # to be placed into arch-x86/syscalls, as well as the content # of arch-x86/linux/_syscalls.h # import sys, os.path, glob, re, commands, filecmp, shutil from bionic_utils import * # set this to 1 if you want to generate thumb stubs gen_thumb_stubs = 0 # set this to 1 if you want to generate ARM EABI stubs gen_eabi_stubs = 1 # get the root Bionic directory, simply this script's dirname # bionic_root = find_bionic_root() if not bionic_root: print "could not find the Bionic root directory. aborting" sys.exit(1) if bionic_root[-1] != '/': bionic_root += "/" print "bionic_root is %s" % bionic_root # temp directory where we store all intermediate files bionic_temp = "/tmp/bionic_gensyscalls/" # all architectures, update as you see fit all_archs = [ "arm", "x86", "sh" ] def make_dir( path ): if not os.path.exists(path): parent = os.path.dirname(path) if parent: make_dir(parent) os.mkdir(path) def create_file( relpath ): dir = os.path.dirname( bionic_temp + relpath ) make_dir(dir) return open( bionic_temp + relpath, "w" ) # x86 assembler templates for each syscall stub # x86_header = """/* autogenerated by gensyscalls.py */ #include .text .type %(fname)s, @function .globl %(fname)s .align 4 %(fname)s: """ x86_registers = [ "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp" ] x86_call = """ movl $%(idname)s, %%eax int $0x80 cmpl $-129, %%eax jb 1f negl %%eax pushl %%eax call __set_errno addl $4, %%esp orl $-1, %%eax 1: """ x86_return = """ ret """ # ARM assembler templates for each syscall stub # arm_header = """/* autogenerated by gensyscalls.py */ #include .text .type %(fname)s, #function .globl %(fname)s .align 4 .fnstart %(fname)s: """ arm_call_default = arm_header + """\ swi #%(idname)s movs r0, r0 bxpl lr b __set_syscall_errno .fnend """ arm_call_long = arm_header + """\ .save {r4, r5, lr} stmfd sp!, {r4, r5, lr} ldr r4, [sp, #12] ldr r5, [sp, #16] swi # %(idname)s ldmfd sp!, {r4, r5, lr} movs r0, r0 bxpl lr b __set_syscall_errno .fnend """ arm_eabi_call_default = arm_header + """\ .save {r4, r7} stmfd sp!, {r4, r7} ldr r7, =%(idname)s swi #0 ldmfd sp!, {r4, r7} movs r0, r0 bxpl lr b __set_syscall_errno .fnend """ arm_eabi_call_long = arm_header + """\ mov ip, sp .save {r4, r5, r6, r7} stmfd sp!, {r4, r5, r6, r7} ldmfd ip, {r4, r5, r6} ldr r7, =%(idname)s swi #0 ldmfd sp!, {r4, r5, r6, r7} movs r0, r0 bxpl lr b __set_syscall_errno .fnend """ # ARM thumb assembler templates for each syscall stub # thumb_header = """/* autogenerated by gensyscalls.py */ .text .type %(fname)s, #function .globl %(fname)s .align 4 .thumb_func .fnstart #define __thumb__ #include %(fname)s: """ thumb_call_default = thumb_header + """\ .save {r7,lr} push {r7,lr} ldr r7, =%(idname)s swi #0 tst r0, r0 bmi 1f pop {r7,pc} 1: neg r0, r0 ldr r1, =__set_errno blx r1 pop {r7,pc} .fnend """ thumb_call_long = thumb_header + """\ .save {r4,r5,r7,lr} push {r4,r5,r7,lr} ldr r4, [sp,#16] ldr r5, [sp,#20] ldr r7, =%(idname)s swi #0 tst r0, r0 bmi 1f pop {r4,r5,r7,pc} 1: neg r0, r0 ldr r1, =__set_errno blx r1 pop {r4,r5,r7,pc} .fnend """ # SuperH assembler templates for each syscall stub # superh_header = """/* autogenerated by gensyscalls.py */ #include .text .type %(fname)s, @function .globl %(fname)s .align 4 %(fname)s: """ superh_call_default = """ /* invoke trap */ mov.l 0f, r3 /* trap num */ trapa #(%(numargs)s + 0x10) /* check return value */ cmp/pz r0 bt %(idname)s_end /* keep error number */ sts.l pr, @-r15 mov.l 1f, r1 jsr @r1 mov r0, r4 lds.l @r15+, pr %(idname)s_end: rts nop .align 2 0: .long %(idname)s 1: .long __set_syscall_errno """ superh_5args_header = """ /* get ready for additonal arg */ mov.l @r15, r0 """ superh_6args_header = """ /* get ready for additonal arg */ mov.l @r15, r0 mov.l @(4, r15), r1 """ superh_7args_header = """ /* get ready for additonal arg */ mov.l @r15, r0 mov.l @(4, r15), r1 mov.l @(8, r15), r2 """ class State: def __init__(self): self.old_stubs = [] self.new_stubs = [] self.other_files = [] self.syscalls = [] def x86_genstub(self, fname, numparams, idname): t = { "fname" : fname, "idname" : idname } result = x86_header % t stack_bias = 4 for r in range(numparams): result += " pushl " + x86_registers[r] + "\n" stack_bias += 4 for r in range(numparams): result += " mov %d(%%esp), %s" % (stack_bias+r*4, x86_registers[r]) + "\n" result += x86_call % t for r in range(numparams): result += " popl " + x86_registers[numparams-r-1] + "\n" result += x86_return return result def x86_genstub_cid(self, fname, numparams, idname, cid): # We'll ignore numparams here because in reality, if there is a # dispatch call (like a socketcall syscall) there are actually # only 2 arguments to the syscall and 2 regs we have to save: # %ebx <--- Argument 1 - The call id of the needed vectored # syscall (socket, bind, recv, etc) # %ecx <--- Argument 2 - Pointer to the rest of the arguments # from the original function called (socket()) t = { "fname" : fname, "idname" : idname } result = x86_header % t stack_bias = 4 # save the regs we need result += " pushl %ebx" + "\n" stack_bias += 4 result += " pushl %ecx" + "\n" stack_bias += 4 # set the call id (%ebx) result += " mov $%d, %%ebx" % (cid) + "\n" # set the pointer to the rest of the args into %ecx result += " mov %esp, %ecx" + "\n" result += " addl $%d, %%ecx" % (stack_bias) + "\n" # now do the syscall code itself result += x86_call % t # now restore the saved regs result += " popl %ecx" + "\n" result += " popl %ebx" + "\n" # epilog result += x86_return return result def arm_genstub(self,fname, flags, idname): t = { "fname" : fname, "idname" : idname } if flags: numargs = int(flags) if numargs > 4: return arm_call_long % t return arm_call_default % t def arm_eabi_genstub(self,fname, flags, idname): t = { "fname" : fname, "idname" : idname } if flags: numargs = int(flags) if numargs > 4: return arm_eabi_call_long % t return arm_eabi_call_default % t def thumb_genstub(self,fname, flags, idname): t = { "fname" : fname, "idname" : idname } if flags: numargs = int(flags) if numargs > 4: return thumb_call_long % t return thumb_call_default % t def superh_genstub(self, fname, flags, idname): numargs = int(flags) t = { "fname" : fname, "idname" : idname, "numargs" : numargs } superh_call = superh_header if flags: if numargs == 5: superh_call += superh_5args_header if numargs == 6: superh_call += superh_6args_header if numargs == 7: superh_call += superh_7args_header superh_call += superh_call_default return superh_call % t def process_file(self,input): parser = SysCallsTxtParser() parser.parse_file(input) self.syscalls = parser.syscalls parser = None for t in self.syscalls: syscall_func = t["func"] syscall_params = t["params"] syscall_name = t["name"] if t["id"] >= 0: if gen_thumb_stubs: t["asm-thumb"] = self.thumb_genstub(syscall_func,len(syscall_params),"__NR_"+syscall_name) else: if gen_eabi_stubs: t["asm-arm"] = self.arm_eabi_genstub(syscall_func,len(syscall_params),"__NR_"+syscall_name) else: t["asm-arm"] = self.arm_genstub(syscall_func,len(syscall_params),"__NR_"+syscall_name) if t["id2"] >= 0: if t["cid"] >= 0: t["asm-x86"] = self.x86_genstub_cid(syscall_func, len(syscall_params), "__NR_"+syscall_name, t["cid"]) else: t["asm-x86"] = self.x86_genstub(syscall_func,len(syscall_params),"__NR_"+syscall_name) elif t["cid"] >= 0: E("cid for dispatch syscalls is only supported for x86 in " "'%s'" % syscall_name) return if t["id3"] >= 0: t["asm-sh"] = self.superh_genstub(syscall_func,len(syscall_params),"__NR_"+syscall_name) def gen_NR_syscall(self,fp,name,id): fp.write( "#define __NR_%-25s (__NR_SYSCALL_BASE + %d)\n" % (name,id) ) # now dump the content of linux/_syscalls.h def gen_linux_syscalls_h(self): path = "include/sys/linux-syscalls.h" D( "generating "+path ) fp = create_file( path ) fp.write( "/* auto-generated by gensyscalls.py, do not touch */\n" ) fp.write( "#ifndef _BIONIC_LINUX_SYSCALLS_H_\n\n" ) fp.write( "#if !defined __ASM_ARM_UNISTD_H && !defined __ASM_I386_UNISTD_H\n" ) fp.write( "#if defined __arm__ && !defined __ARM_EABI__ && !defined __thumb__\n" ) fp.write( " # define __NR_SYSCALL_BASE 0x900000\n" ) fp.write( " #else\n" ) fp.write( " # define __NR_SYSCALL_BASE 0\n" ) fp.write( " #endif\n\n" ) # first, all common syscalls for sc in self.syscalls: sc_id = sc["id"] sc_id2 = sc["id2"] sc_name = sc["name"] if sc_id == sc_id2 and sc_id >= 0: self.gen_NR_syscall( fp, sc_name, sc_id ) # now, all arm-specific syscalls fp.write( "\n#ifdef __arm__\n" ); for sc in self.syscalls: sc_id = sc["id"] sc_id2 = sc["id2"] sc_name = sc["name"] if sc_id != sc_id2 and sc_id >= 0: self.gen_NR_syscall( fp, sc_name, sc_id ) fp.write( "#endif\n" ); gen_syscalls = {} # finally, all i386-specific syscalls fp.write( "\n#ifdef __i386__\n" ); for sc in self.syscalls: sc_id = sc["id"] sc_id2 = sc["id2"] sc_name = sc["name"] if sc_id != sc_id2 and sc_id2 >= 0 and sc_name not in gen_syscalls: self.gen_NR_syscall( fp, sc_name, sc_id2 ) gen_syscalls[sc_name] = True fp.write( "#endif\n" ); # all superh-specific syscalls fp.write( "\n#if defined(__SH3__) || defined(__SH4__) \n" ); for sc in self.syscalls: sc_id = sc["id"] sc_id2 = sc["id2"] sc_id3 = sc["id3"] sc_name = sc["name"] if sc_id2 != sc_id3 and sc_id3 >= 0: self.gen_NR_syscall( fp, sc_name, sc_id3 ) else: if sc_id != sc_id2 and sc_id2 >= 0: self.gen_NR_syscall( fp, sc_name, sc_id2 ) fp.write( "#endif\n" ); fp.write( "\n#endif\n" ) fp.write( "\n#endif /* _BIONIC_LINUX_SYSCALLS_H_ */\n" ); fp.close() self.other_files.append( path ) # now dump the content of linux/_syscalls.h def gen_linux_unistd_h(self): path = "include/sys/linux-unistd.h" D( "generating "+path ) fp = create_file( path ) fp.write( "/* auto-generated by gensyscalls.py, do not touch */\n" ) fp.write( "#ifndef _BIONIC_LINUX_UNISTD_H_\n\n" ); fp.write( "#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n" ) for sc in self.syscalls: fp.write( sc["decl"]+"\n" ) fp.write( "#ifdef __cplusplus\n}\n#endif\n" ) fp.write( "\n#endif /* _BIONIC_LINUX_UNISTD_H_ */\n" ); fp.close() self.other_files.append( path ) # now dump the contents of syscalls.mk def gen_arch_syscalls_mk(self, arch): path = "arch-%s/syscalls.mk" % arch D( "generating "+path ) fp = create_file( path ) fp.write( "# auto-generated by gensyscalls.py, do not touch\n" ) fp.write( "syscall_src := \n" ) arch_test = { "arm": lambda x: x.has_key("asm-arm") or x.has_key("asm-thumb"), "x86": lambda x: x.has_key("asm-x86"), "sh": lambda x: x.has_key("asm-sh") } for sc in self.syscalls: if arch_test[arch](sc): fp.write("syscall_src += arch-%s/syscalls/%s.S\n" % (arch, sc["func"])) fp.close() self.other_files.append( path ) # now generate each syscall stub def gen_syscall_stubs(self): for sc in self.syscalls: if sc.has_key("asm-arm") and 'arm' in all_archs: fname = "arch-arm/syscalls/%s.S" % sc["func"] D( ">>> generating "+fname ) fp = create_file( fname ) fp.write(sc["asm-arm"]) fp.close() self.new_stubs.append( fname ) if sc.has_key("asm-thumb") and 'arm' in all_archs: fname = "arch-arm/syscalls/%s.S" % sc["func"] D( ">>> generating "+fname ) fp = create_file( fname ) fp.write(sc["asm-thumb"]) fp.close() self.new_stubs.append( fname ) if sc.has_key("asm-x86") and 'x86' in all_archs: fname = "arch-x86/syscalls/%s.S" % sc["func"] D( ">>> generating "+fname ) fp = create_file( fname ) fp.write(sc["asm-x86"]) fp.close() self.new_stubs.append( fname ) if sc.has_key("asm-sh"): fname = "arch-sh/syscalls/%s.S" % sc["func"] D( ">>> generating "+fname ) fp = create_file( fname ) fp.write(sc["asm-sh"]) fp.close() self.new_stubs.append( fname ) def regenerate(self): D( "scanning for existing architecture-specific stub files" ) bionic_root_len = len(bionic_root) for arch in all_archs: arch_path = bionic_root + "arch-" + arch D( "scanning " + arch_path ) files = glob.glob( arch_path + "/syscalls/*.S" ) for f in files: self.old_stubs.append( f[bionic_root_len:] ) D( "found %d stub files" % len(self.old_stubs) ) if not os.path.exists( bionic_temp ): D( "creating %s" % bionic_temp ) os.mkdir( bionic_temp ) # D( "p4 editing source files" ) # for arch in all_archs: # commands.getoutput( "p4 edit " + arch + "/syscalls/*.S " ) # commands.getoutput( "p4 edit " + arch + "/syscalls.mk" ) # commands.getoutput( "p4 edit " + bionic_root + "include/sys/linux-syscalls.h" ) D( "re-generating stubs and support files" ) self.gen_linux_syscalls_h() for arch in all_archs: self.gen_arch_syscalls_mk(arch) self.gen_linux_unistd_h() self.gen_syscall_stubs() D( "comparing files" ) adds = [] edits = [] for stub in self.new_stubs + self.other_files: if not os.path.exists( bionic_root + stub ): # new file, P4 add it D( "new file: " + stub) adds.append( bionic_root + stub ) shutil.copyfile( bionic_temp + stub, bionic_root + stub ) elif not filecmp.cmp( bionic_temp + stub, bionic_root + stub ): D( "changed file: " + stub) edits.append( stub ) deletes = [] for stub in self.old_stubs: if not stub in self.new_stubs: D( "deleted file: " + stub) deletes.append( bionic_root + stub ) if adds: commands.getoutput("p4 add " + " ".join(adds)) if deletes: commands.getoutput("p4 delete " + " ".join(deletes)) if edits: commands.getoutput("p4 edit " + " ".join((bionic_root + file) for file in edits)) for file in edits: shutil.copyfile( bionic_temp + file, bionic_root + file ) D("ready to go !!") D_setlevel(1) state = State() state.process_file(bionic_root+"SYSCALLS.TXT") state.regenerate()