#!/usr/bin/env python3 # # Copyright (C) 2009 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import argparse import sys from uffd_gc_utils import should_enable_uffd_gc # Usage: post_process_props.py file.prop [disallowed_key, ...] # Disallowed keys are removed from the property file, if present # See PROP_VALUE_MAX in system_properties.h. # The constant in system_properties.h includes the terminating NUL, # so we decrease the value by 1 here. PROP_VALUE_MAX = 91 # Put the modifications that you need to make into the */build.prop into this # function. def mangle_build_prop(prop_list, kernel_version_file_for_uffd_gc): # If ro.debuggable is 1, then enable adb on USB by default # (this is for userdebug builds) if prop_list.get_value("ro.debuggable") == "1": val = prop_list.get_value("persist.sys.usb.config") if "adb" not in val: if val == "": val = "adb" else: val = val + ",adb" prop_list.put("persist.sys.usb.config", val) if prop_list.get_value("ro.dalvik.vm.enable_uffd_gc") == "default": assert kernel_version_file_for_uffd_gc != "" enable_uffd_gc = should_enable_uffd_gc(kernel_version_file_for_uffd_gc) prop_list.put("ro.dalvik.vm.enable_uffd_gc", "true" if enable_uffd_gc else "false") def validate_grf_props(prop_list): """Validate GRF properties if exist. If ro.board.first_api_level is defined, check if its value is valid. Returns: True if the GRF properties are valid. """ grf_api_level = prop_list.get_value("ro.board.first_api_level") board_api_level = prop_list.get_value("ro.board.api_level") if grf_api_level and board_api_level: grf_api_level = int(grf_api_level) board_api_level = int(board_api_level) if board_api_level < grf_api_level: sys.stderr.write("error: ro.board.api_level(%d) must not be less than " "ro.board.first_api_level(%d)\n" % (board_api_level, grf_api_level)) return False return True def validate(prop_list): """Validate the properties. If the value of a sysprop exceeds the max limit (91), it's an error, unless the sysprop is a read-only one. Checks if there is no optional prop assignments. Returns: True if nothing is wrong. """ check_pass = True for p in prop_list.get_all_props(): if len(p.value) > PROP_VALUE_MAX and not p.name.startswith("ro."): check_pass = False sys.stderr.write("error: %s cannot exceed %d bytes: " % (p.name, PROP_VALUE_MAX)) sys.stderr.write("%s (%d)\n" % (p.value, len(p.value))) if p.is_optional(): check_pass = False sys.stderr.write("error: found unresolved optional prop assignment:\n") sys.stderr.write(str(p) + "\n") return check_pass def override_optional_props(prop_list, allow_dup=False): """Override a?=b with a=c, if the latter exists Overriding is done by deleting a?=b When there are a?=b and a?=c, then only the last one survives When there are a=b and a=c, then it's an error. Returns: True if the override was successful """ success = True for name in prop_list.get_all_names(): props = prop_list.get_props(name) optional_props = [p for p in props if p.is_optional()] overriding_props = [p for p in props if not p.is_optional()] if len(overriding_props) > 1: # duplicated props are allowed when the all have the same value if all(overriding_props[0].value == p.value for p in overriding_props): for p in optional_props: p.delete("overridden by %s" % str(overriding_props[0])) continue # or if dup is explicitly allowed for compat reason if allow_dup: # this could left one or more optional props unresolved. # Convert them into non-optional because init doesn't understand ?= # syntax for p in optional_props: p.optional = False continue success = False sys.stderr.write("error: found duplicate sysprop assignments:\n") for p in overriding_props: sys.stderr.write("%s\n" % str(p)) elif len(overriding_props) == 1: for p in optional_props: p.delete("overridden by %s" % str(overriding_props[0])) else: if len(optional_props) > 1: for p in optional_props[:-1]: p.delete("overridden by %s" % str(optional_props[-1])) # Make the last optional one as non-optional optional_props[-1].optional = False return success class Prop: def __init__(self, name, value, optional=False, comment=None): self.name = name.strip() self.value = value.strip() if comment != None: self.comments = [comment] else: self.comments = [] self.optional = optional @staticmethod def from_line(line): line = line.rstrip('\n') if line.startswith("#"): return Prop("", "", comment=line) elif "?=" in line: name, value = line.split("?=", 1) return Prop(name, value, optional=True) elif "=" in line: name, value = line.split("=", 1) return Prop(name, value, optional=False) else: # don't fail on invalid line # TODO(jiyong) make this a hard error return Prop("", "", comment=line) def is_comment(self): return bool(self.comments and not self.name) def is_optional(self): return (not self.is_comment()) and self.optional def make_as_comment(self): # Prepend "#" to the last line which is the prop assignment if not self.is_comment(): assignment = str(self).rsplit("\n", 1)[-1] self.comments.append("#" + assignment) self.name = "" self.value = "" def delete(self, reason): self.comments.append("# Removed by post_process_props.py because " + reason) self.make_as_comment() def __str__(self): assignment = [] if not self.is_comment(): operator = "?=" if self.is_optional() else "=" assignment.append(self.name + operator + self.value) return "\n".join(self.comments + assignment) class PropList: def __init__(self, filename): with open(filename) as f: self.props = [Prop.from_line(l) for l in f.readlines() if l.strip() != ""] def get_all_props(self): return [p for p in self.props if not p.is_comment()] def get_all_names(self): return set([p.name for p in self.get_all_props()]) def get_props(self, name): return [p for p in self.get_all_props() if p.name == name] def get_value(self, name): # Caution: only the value of the first sysprop having the name is returned. return next((p.value for p in self.props if p.name == name), "") def put(self, name, value): # Note: when there is an optional prop for the name, its value isn't changed. # Instead a new non-optional prop is appended, which will override the # optional prop. Otherwise, the new value might be overridden by an existing # non-optional prop of the same name. index = next((i for i,p in enumerate(self.props) if p.name == name and not p.is_optional()), -1) if index == -1: self.props.append(Prop(name, value, comment="# Auto-added by post_process_props.py")) else: self.props[index].comments.append( "# Value overridden by post_process_props.py. Original value: %s" % self.props[index].value) self.props[index].value = value def write(self, filename): with open(filename, 'w+') as f: for p in self.props: f.write(str(p) + "\n") def main(argv): parser = argparse.ArgumentParser(description="Post-process build.prop file") parser.add_argument("--allow-dup", dest="allow_dup", action="store_true", default=False) parser.add_argument("filename") parser.add_argument("disallowed_keys", metavar="KEY", type=str, nargs="*") parser.add_argument("--sdk-version", type=int, required=True) parser.add_argument("--kernel-version-file-for-uffd-gc", required=True) args = parser.parse_args() if not args.filename.endswith("/build.prop"): sys.stderr.write("bad command line: " + str(argv) + "\n") sys.exit(1) props = PropList(args.filename) mangle_build_prop(props, args.kernel_version_file_for_uffd_gc) if not override_optional_props(props, args.allow_dup): sys.exit(1) if not validate_grf_props(props): sys.exit(1) if not validate(props): sys.exit(1) # Drop any disallowed keys for key in args.disallowed_keys: for p in props.get_props(key): p.delete("%s is a disallowed key" % key) props.write(args.filename) if __name__ == "__main__": main(sys.argv)