diff options
Diffstat (limited to 'libc/tools')
| -rw-r--r-- | libc/tools/bionic_utils.py | 306 | ||||
| -rwxr-xr-x | libc/tools/checksyscalls.py | 175 | ||||
| -rwxr-xr-x | libc/tools/genserv.py | 76 | ||||
| -rwxr-xr-x | libc/tools/gensyscalls.py | 506 |
4 files changed, 1063 insertions, 0 deletions
diff --git a/libc/tools/bionic_utils.py b/libc/tools/bionic_utils.py new file mode 100644 index 0000000..65ff042 --- /dev/null +++ b/libc/tools/bionic_utils.py @@ -0,0 +1,306 @@ +# common python utility routines for the Bionic tool scripts + +import sys, os, commands, string + +# support Bionic architectures, add new ones as appropriate +# +bionic_archs = [ "arm", "x86" ] + +# basic debugging trace support +# call D_setlevel to set the verbosity level +# and D(), D2(), D3(), D4() to add traces +# +verbose = 1 + +def D(msg): + global verbose + if verbose > 0: + print msg + +def D2(msg): + global verbose + if verbose >= 2: + print msg + +def D3(msg): + global verbose + if verbose >= 3: + print msg + +def D4(msg): + global verbose + if verbose >= 4: + print msg + +def D_setlevel(level): + global verbose + verbose = level + + +def find_dir_of(path): + '''return the directory name of 'path', or "." if there is none''' + # remove trailing slash + if len(path) > 1 and path[-1] == '/': + path = path[:-1] + + # find parent directory name + d = os.path.dirname(path) + if d == "": + return "." + else: + return d + +# other stuff +# +# +def find_file_from_upwards(from_path,target_file): + """find a file in the current directory or its parents. if 'from_path' is None, + seach from the current program's directory""" + path = from_path + if path == None: + path = find_dir_of(sys.argv[0]) + D("this script seems to be located in: %s" % path) + + while 1: + if path == "": + path = "." + + file = path + "/" + target_file + D("probing "+file) + + if os.path.isfile(file): + D("found %s in %s" % (target_file, path)) + return file + + if path == ".": + break + + path = os.path.dirname(path) + + path = "" + while 1: + path = "../" + path + file = path + target_file + D("probing "+file) + + if os.path.isfile(file): + D("found %s in %s" % (target_file, path)) + return file + + + return None + +def find_bionic_root(): + '''find the root of the Bionic source tree. we check for the SYSCALLS.TXT file + from the location of the current program's directory.''' + + # note that we can't use find_file_from_upwards() since we can't use os.path.abspath + # that's because in some cases the p4 client is in a symlinked directory, and this + # function will return the real path instead, which later creates problems when + # p4 commands are issued + # + file = find_file_from_upwards(None, "SYSCALLS.TXT") + if file: + return os.path.dirname(file) + else: + return None + +def find_kernel_headers(): + """try to find the directory containing the kernel headers for this machine""" + status, version = commands.getstatusoutput( "uname -r" ) # get Linux kernel version + if status != 0: + D("could not execute 'uname -r' command properly") + return None + + # get rid of the "-xenU" suffix that is found in Xen virtual machines + if len(version) > 5 and version[-5:] == "-xenU": + version = version[:-5] + + path = "/usr/src/linux-headers-" + version + D("probing %s for kernel headers" % (path+"/include")) + ret = os.path.isdir( path ) + if ret: + D("found kernel headers in: %s" % (path + "/include")) + return path + return None + + +# parser for the SYSCALLS.TXT file +# +class SysCallsTxtParser: + def __init__(self): + self.syscalls = [] + self.lineno = 0 + + def E(msg): + print "%d: %s" % (self.lineno, msg) + + def parse_line(self, line): + """ parse a syscall spec line. + + line processing, format is + return type func_name[:syscall_name[:call_id]] ( [paramlist] ) (syscall_number[,syscall_number_x86])|stub + """ + pos_lparen = line.find('(') + E = self.E + if pos_lparen < 0: + E("missing left parenthesis in '%s'" % line) + return + + pos_rparen = line.rfind(')') + if pos_rparen < 0 or pos_rparen <= pos_lparen: + E("missing or misplaced right parenthesis in '%s'" % line) + return + + return_type = line[:pos_lparen].strip().split() + if len(return_type) < 2: + E("missing return type in '%s'" % line) + return + + syscall_func = return_type[-1] + return_type = string.join(return_type[:-1],' ') + call_id = -1 + + pos_colon = syscall_func.find(':') + if pos_colon < 0: + syscall_name = syscall_func + else: + if pos_colon == 0 or pos_colon+1 >= len(syscall_func): + E("misplaced colon in '%s'" % line) + return + + # now find if there is a call_id for a dispatch-type syscall + # after the optional 2nd colon + pos_colon2 = syscall_func.find(':', pos_colon + 1) + if pos_colon2 < 0: + syscall_name = syscall_func[pos_colon+1:] + syscall_func = syscall_func[:pos_colon] + else: + if pos_colon2+1 >= len(syscall_func): + E("misplaced colon2 in '%s'" % line) + return + syscall_name = syscall_func[(pos_colon+1):pos_colon2] + call_id = int(syscall_func[pos_colon2+1:]) + syscall_func = syscall_func[:pos_colon] + + if pos_rparen > pos_lparen+1: + syscall_params = line[pos_lparen+1:pos_rparen].split(',') + params = string.join(syscall_params,',') + else: + syscall_params = [] + params = "void" + + number = line[pos_rparen+1:].strip() + if number == "stub": + syscall_id = -1 + syscall_id2 = -1 + else: + try: + if number[0] == '#': + number = number[1:].strip() + numbers = string.split(number,',') + syscall_id = int(numbers[0]) + syscall_id2 = syscall_id + if len(numbers) > 1: + syscall_id2 = int(numbers[1]) + except: + E("invalid syscall number in '%s'" % line) + return + + t = { "id" : syscall_id, + "id2" : syscall_id2, + "cid" : call_id, + "name" : syscall_name, + "func" : syscall_func, + "params" : syscall_params, + "decl" : "%-15s %s (%s);" % (return_type, syscall_func, params) } + + self.syscalls.append(t) + + def parse_file(self, file_path): + D2("parse_file: %s" % file_path) + fp = open(file_path) + for line in fp.xreadlines(): + self.lineno += 1 + line = line.strip() + if not line: continue + if line[0] == '#': continue + self.parse_line(line) + + fp.close() + + +class Output: + def __init__(self,out=sys.stdout): + self.out = out + + def write(self,msg): + self.out.write(msg) + + def writeln(self,msg): + self.out.write(msg) + self.out.write("\n") + +class StringOutput: + def __init__(self): + self.line = "" + + def write(self,msg): + self.line += msg + D2("write '%s'" % msg) + + def writeln(self,msg): + self.line += msg + '\n' + D2("write '%s\\n'"% msg) + + def get(self): + return self.line + + +def create_file_path(path): + dirs = [] + while 1: + parent = os.path.dirname(path) + if parent == "/": + break + dirs.append(parent) + path = parent + + dirs.reverse() + for dir in dirs: + #print "dir %s" % dir + if os.path.isdir(dir): + continue + os.mkdir(dir) + +def walk_source_files(paths,callback,args,excludes=[]): + """recursively walk a list of paths and files, only keeping the source files in directories""" + for path in paths: + if not os.path.isdir(path): + callback(path,args) + else: + for root, dirs, files in os.walk(path): + #print "w-- %s (ex: %s)" % (repr((root,dirs)), repr(excludes)) + if len(excludes): + for d in dirs[:]: + if d in excludes: + dirs.remove(d) + for f in files: + r, ext = os.path.splitext(f) + if ext in [ ".h", ".c", ".cpp", ".S" ]: + callback( "%s/%s" % (root,f), args ) + +def cleanup_dir(path): + """create a directory if needed, and ensure that it is totally empty + by removing any existing content in it""" + if not os.path.exists(path): + os.mkdir(path) + else: + for root, dirs, files in os.walk(path, topdown=False): + if root.endswith("kernel_headers/"): + # skip 'kernel_headers' + continue + for name in files: + os.remove(os.path.join(root, name)) + for name in dirs: + os.rmdir(os.path.join(root, name)) diff --git a/libc/tools/checksyscalls.py b/libc/tools/checksyscalls.py new file mode 100755 index 0000000..9edb390 --- /dev/null +++ b/libc/tools/checksyscalls.py @@ -0,0 +1,175 @@ +#!/usr/bin/python +# +# this tool is used to check that the syscall numbers that are in +# SYSCALLS.TXT correspond to those found in the Linux kernel sources +# for the arm and i386 architectures +# + +import sys, re, string, os, commands +from bionic_utils import * + +# change this if necessary +syscalls_txt = "SYSCALLS.TXT" + +def usage(): + print "usage: checksyscalls [options] [kernel_headers_rootdir]" + print " options: -v enable verbose mode" + sys.exit(1) + + +linux_root = None +syscalls_file = None + +def parse_command_line(args): + global linux_root, syscalls_file, verbose + + program = args[0] + args = args[1:] + while len(args) > 0 and args[0][0] == "-": + option = args[0][1:] + args = args[1:] + + if option == "v": + D_setlevel(1) + else: + usage() + + if len(args) > 2: + usage() + + if len(args) == 0: + linux_root = find_kernel_headers() + if linux_root == None: + print "could not locate this system kernel headers root directory, please" + print "specify one when calling this program, i.e. 'checksyscalls <headers-directory>'" + sys.exit(1) + print "using the following kernel headers root: '%s'" % linux_root + else: + linux_root = args[0] + if not os.path.isdir(linux_root): + print "the directory '%s' does not exist. aborting\n" % headers_root + sys.exit(1) + +parse_command_line(sys.argv) + +syscalls_file = find_file_from_upwards(None, syscalls_txt) +if not syscalls_file: + print "could not locate the %s file. Aborting" % syscalls_txt + sys.exit(1) + +print "parsing %s" % syscalls_file + +# read the syscalls description file +# + +parser = SysCallsTxtParser() +parser.parse_file(syscalls_file) +syscalls = parser.syscalls + +re_nr_line = re.compile( r"#define __NR_(\w*)\s*\(__NR_SYSCALL_BASE\+\s*(\w*)\)" ) +re_nr_clock_line = re.compile( r"#define __NR_(\w*)\s*\(__NR_timer_create\+(\w*)\)" ) +re_arm_nr_line = re.compile( r"#define __ARM_NR_(\w*)\s*\(__ARM_NR_BASE\+\s*(\w*)\)" ) +re_x86_line = re.compile( r"#define __NR_(\w*)\s*([0-9]*)" ) + +# now read the Linux arm header +def process_nr_line(line,dict): + + m = re_nr_line.match(line) + if m: + dict[m.group(1)] = int(m.group(2)) + return + + m = re_nr_clock_line.match(line) + if m: + dict[m.group(1)] = int(m.group(2)) + 259 + return + + m = re_arm_nr_line.match(line) + if m: + #print "%s = %s" % (m.group(1), m.group(2)) + dict["ARM_"+m.group(1)] = int(m.group(2)) + 0x0f0000 + return + + m = re_x86_line.match(line) + if m: + # try block because the ARM header has some #define _NR_XXXXX /* nothing */ + try: + #print "%s = %s" % (m.group(1), m.group(2)) + dict[m.group(1)] = int(m.group(2)) + except: + pass + return + + +def process_header(header_file,dict): + fp = open(header_file) + D("reading "+header_file) + for line in fp.xreadlines(): + line = line.strip() + if not line: continue + process_nr_line(line,dict) + fp.close() + +arm_dict = {} +x86_dict = {} + + +# remove trailing slash and '/include' from the linux_root, if any +if linux_root[-1] == '/': + linux_root = linux_root[:-1] + +if len(linux_root) > 8 and linux_root[-8:] == '/include': + linux_root = linux_root[:-8] + +arm_unistd = linux_root + "/include/asm-arm/unistd.h" +if not os.path.exists(arm_unistd): + print "WEIRD: could not locate the ARM unistd.h header file" + print "tried searching in '%s'" % arm_unistd + print "maybe using a different set of kernel headers might help" + sys.exit(1) + +# on recent kernels, asm-i386 and asm-x64_64 have been merged into asm-x86 +# with two distinct unistd_32.h and unistd_64.h definition files. +# take care of this here +# +x86_unistd = linux_root + "/include/asm-i386/unistd.h" +if not os.path.exists(x86_unistd): + x86_unistd1 = x86_unistd + x86_unistd = linux_root + "/include/asm-x86/unistd_32.h" + if not os.path.exists(x86_unistd): + print "WEIRD: could not locate the i386/x86 unistd.h header file" + print "tried searching in '%s' and '%s'" % (x86_unistd1, x86_unistd) + print "maybe using a different set of kernel headers might help" + sys.exit(1) + +process_header( linux_root+"/include/asm-arm/unistd.h", arm_dict ) +process_header( x86_unistd, x86_dict ) + +# now perform the comparison +errors = 0 +for sc in syscalls: + sc_name = sc["name"] + sc_id = sc["id"] + if sc_id >= 0: + if not arm_dict.has_key(sc_name): + print "arm syscall %s not defined !!" % sc_name + errors += 1 + elif arm_dict[sc_name] != sc_id: + print "arm syscall %s should be %d instead of %d !!" % (sc_name, arm_dict[sc_name], sc_id) + errors += 1 + +for sc in syscalls: + sc_name = sc["name"] + sc_id2 = sc["id2"] + if sc_id2 >= 0: + if not x86_dict.has_key(sc_name): + print "x86 syscall %s not defined !!" % sc_name + errors += 1 + elif x86_dict[sc_name] != sc_id2: + print "x86 syscall %s should be %d instead of %d !!" % (sc_name, x86_dict[sc_name], sc_id2) + errors += 1 + +if errors == 0: + print "congratulations, everything's fine !!" +else: + print "correct %d errors !!" % errors diff --git a/libc/tools/genserv.py b/libc/tools/genserv.py new file mode 100755 index 0000000..e37d28f --- /dev/null +++ b/libc/tools/genserv.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python +# + +import sys, os, string, re + +def usage(): + print """\ + usage: genserv < /etc/services > netbsd/net/services.h + + this program is used to generate the hard-coded internet service list for the + Bionic C library. +""" + +re_service = re.compile(r"([\d\w\-_]+)\s+(\d+)/(tcp|udp)(.*)") +re_alias = re.compile(r"([\d\w\-_]+)(.*)") + +class Service: + def __init__(self,name,port,proto): + self.name = name + self.port = port + self.proto = proto + self.aliases = [] + + def add_alias(self,alias): + self.aliases.append(alias) + + def __str__(self): + result = "\\%0o%s" % (len(self.name),self.name) + result += "\\%0o\\%0o" % (((self.port >> 8) & 255), self.port & 255) + if self.proto == "tcp": + result += "t" + else: + result += "u" + + result += "\\%0o" % len(self.aliases) + for alias in self.aliases: + result += "\\%0o%s" % (len(alias), alias) + + return result + +def parse(f): + result = [] # list of Service objects + for line in f.xreadlines(): + if len(line) > 0 and line[-1] == "\n": + line = line[:-1] + if len(line) > 0 and line[-1] == "\r": + line = line[:-1] + + line = string.strip(line) + if len(line) == 0 or line[0] == "#": + continue + + m = re_service.match(line) + if m: + service = Service( m.group(1), int(m.group(2)), m.group(3) ) + rest = string.strip(m.group(4)) + + while 1: + m = re_alias.match(rest) + if not m: + break + service.add_alias(m.group(1)) + rest = string.strip(m.group(2)) + + result.append(service) + + return result + +services = parse(sys.stdin) +line = '/* generated by genserv.py - do not edit */\nstatic const char _services[] = "\\\n' +for s in services: + line += str(s)+"\\\n" +line += '\\0";\n' +print line + + diff --git a/libc/tools/gensyscalls.py b/libc/tools/gensyscalls.py new file mode 100755 index 0000000..530e565 --- /dev/null +++ b/libc/tools/gensyscalls.py @@ -0,0 +1,506 @@ +#!/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" ] + +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 <sys/linux-syscalls.h> + + .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 <sys/linux-syscalls.h> + + .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 <sys/linux-syscalls.h> + + +%(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 +""" + + +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 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 + + + 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" ); + + 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") + } + + 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 ) + + + 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() |