def __init__(self): """Scan all the Kconfig files and create a Config object.""" # Define environment variables referenced from Kconfig os.environ['srctree'] = os.getcwd() os.environ['UBOOTVERSION'] = 'dummy' os.environ['KCONFIG_OBJDIR'] = '' self._conf = kconfiglib.Config()
def __init__(self, screen, cfgfile): self.screen = screen # Load the root Kconfig (this will load all sourced files also) self.conf = kconfiglib.Config(cfgfile) # Also load any existing generated configuration if os.path.exists(".config"): self.conf.load_config(".config") # Initialize curses screen curses.curs_set(0) # Create main menu main_menu = Menu(screen, "Top", self.conf.get_top_level_items()) main_menu.display() self.conf.write_config(".config")
def __init__(self): self.base_dir = os.environ.get("TOPDIR") self.output_dir = os.environ.get("O") self.package_dir = os.path.join(self.base_dir, self.package_dirname) self.config = kconfiglib.Config( os.path.join(self.base_dir, self.root_config), self.base_dir) self._deprecated = self.config.get_symbol(self.deprecated_symbol) self.gen_date = datetime.datetime.utcnow() self.br_version_full = os.environ.get("BR2_VERSION_FULL") if self.br_version_full and self.br_version_full.endswith("-git"): self.br_version_full = self.br_version_full[:-4] if not self.br_version_full: self.br_version_full = "undefined"
def __init__(self): self.base_dir = os.environ.get("TOPDIR") self.output_dir = os.environ.get("O") self.package_dir = os.path.join(self.base_dir, self.package_dirname) # The kconfiglib requires an environment variable named "srctree" to # load the configuration, so set it. os.environ.update({'srctree': self.base_dir}) self.config = kconfiglib.Config( os.path.join(self.base_dir, self.root_config)) self._deprecated = self.config.get_symbol(self.deprecated_symbol) self.gen_date = datetime.datetime.utcnow() self.br_version_full = os.environ.get("BR2_VERSION_FULL") if self.br_version_full and self.br_version_full.endswith("-git"): self.br_version_full = self.br_version_full[:-4] if not self.br_version_full: self.br_version_full = "undefined"
def write_wikified_sysctl_opts(kern_src_dir, out_file_name): """ Writes a categorized list of sysctl variables wrapped in MediaWiki links construct. Parameters: kern_src_dir (string) Absolute path to a kernel source directory (e.g. /usr/src/linux-3.2.48.) out_file_name (string) Path and file name or just the file name of the output file. The links point to anchors on the Grsecurity and PaX Configuration Options page. The links are written in alphabetical order by the sysctl variable. """ sysctl_opts = get_sysctl_opts(kern_src_dir) categorized_opts = get_categorized_sysctl_opts(sysctl_opts) kconfig_path = os.path.join(kern_src_dir, "security", "Kconfig") conf = kconfiglib.Config(kconfig_path, kern_src_dir) link_fmt = "* [[Grsecurity/Appendix/Grsecurity_and_PaX"\ "_Configuration_Options#{0}|{1}]]\n" with codecs.open(out_file_name, 'w', "utf-8") as f: f.write("| style=\"border:1px solid gray;\"|\n") for opt in categorized_opts[0]: symbol = conf.get_symbol(opt[1]) prompt = get_prompt(symbol) f.write(link_fmt.format(prompt, opt[0])) f.write("| style=\"border:1px solid gray;\"|\n") for opt in categorized_opts[1]: symbol = conf.get_symbol(opt[1]) prompt = get_prompt(symbol) f.write(link_fmt.format(prompt, opt[0])) f.write("| style=\"border:1px solid gray;\"|\n") for opt in categorized_opts[2]: symbol = conf.get_symbol(opt[1]) prompt = get_prompt(symbol) f.write(link_fmt.format(prompt, opt[0])) f.write("| style=\"border:1px solid gray;\"|\n") for opt in categorized_opts[3]: symbol = conf.get_symbol(opt[1]) prompt = get_prompt(symbol) f.write(link_fmt.format(prompt, opt[0]))
def update_defconfig(self): "Applies the configuration settings to the defconfig" os.environ['APPSDIR'] = '../apps' # TODO: fixme # load the Kconfig tree conf = kconfiglib.Config(os.path.join(self.nuttx_path, 'Kconfig'), base_dir=self.nuttx_path) # load our default defconfig conf.load_config(self.path_to_abs_target('nuttx/configs/$board/$target/defconfig')) for k in self.configs: # allow for variable names in the values of config entries # MANIFEST=$board-$target is the only case at the time of # writing. d = { '$board' : self.board, '$target' : self.target, } v = multiple_replace(d, str(self.configs[k])) print(k, v) try: conf.get_symbol(k).set_user_value(v) except AttributeError: print(k, v) # write the output conf.write_config(self.path_to_abs_target('nuttx/configs/$board/$target/defconfig'))
def write_wikified_kconfig(kern_src_dir, out_file_name): """ Create a MediaWiki-formatted version of the Kconfig file found in the kern_src_dir/security/ directory and write the output to the given file. Parameters: kern_src_dir (string) Absolute path to a kernel source directory (e.g. /usr/src/linux-3.2.48.) out_file_name (string) Path and file name or just the file name of the output file. """ security_kconfig = os.path.join(kern_src_dir, "security", "Kconfig") conf = kconfiglib.Config(security_kconfig, kern_src_dir) if conf is not None: for menu in conf.get_menus(): if menu.get_title() == "Grsecurity": with codecs.open(out_file_name, 'w', "utf-8") as f: sysctl_opts = get_sysctl_opts(kern_src_dir) write_wikified_item(f, sysctl_opts, menu, 1) break
os.environ["ARCH"] = arch os.environ["KERNELVERSION"] = version # Creating output_dir if not there. try: os.makedirs(output_dir) except OSError as exc: if exc.errno == errno.EEXIST and os.path.isdir(output_dir): pass else: raise ############################ # Loading the Kconfig tree # ############################ feature_model = kconfiglib.Config(kconfig_name, dirname) # Loading the allnoconfig # min_k_dict = {} if not debugging: min_k = open(min_k_file) min_k = [i.strip().split("=") for i in min_k] for key, value in min_k: min_k_dict[key] = value types = ["unknown", "bool", "tristate", "string", "hex", "int"] yesno = ['y', 'n'] # This will take all the features NOT in the allnoconfig, and randomize their # values. Many of the configurations will be invalid.
sys.exit(1) if not os.getenv("ARCH"): print("ERROR: arch must be set (via ARCH environment variable") sys.exit(1) kconf = ksrc + "/Kconfig" if not os.path.exists(kconf): print( "ERROR: kernel source directory '%s' does not contain a top level Kconfig file" % ksrc) sys.exit(1) # Create a Config object representing a Kconfig configuration. (Any number of # these can be created -- the library has no global state.) conf = kconfiglib.Config(kconf) # Load values from a .config file. conf.load_config(dotconfig) opt = conf[option] if show_summary: print(conf[option]) if show_vars: print("") print("Variables that depend on '%s':" % option) for sym in conf: if opt in sym.get_referenced_symbols():
def process_kconfig_file(kconfig_file, heading_level, breadcrumbs): if os.path.exists(kconfig_file): cfg = kconfiglib.Config(kconfig_file, print_warnings=True) print_menu_contents(None, cfg.get_top_level_items(), heading_level, breadcrumbs)
# Prints the names of all symbols that reference a particular symbol. (There's # also a method get_selected_symbols() for determining just selection # relations.) import kconfiglib import sys conf = kconfiglib.Config(sys.argv[1], sys.argv[2]) for sym in conf: print sym.get_name() + " " + str(sym.get_type())
import kconfiglib conf = kconfiglib.Config("linux-3.19/Kconfig_concat", "linux-3.19") # conf.load_config("/tmp/randconfigs/7") top = conf.get_top_level_items() syms = conf.get_symbols() print len(syms) for sym in syms: pass print len(syms)
formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('-s', '--subdir', action='store', dest='subdir', default="", help='sub directory to be scanned') parser.add_argument('-c', '--complete-log', action='store_true', dest='completelog', default=False, help='Prints all the kconfigs found') parser.add_argument('-e', '--exclude', action='append', dest='exclude', default=["doc", "sanity-out", "outdir"], help='Dirs to be excluded for verification') args = parser.parse_args() if args.completelog: print('sub dir = ', os.path.join(ugelisbase + args.subdir)) print('complete-log = ', args.completelog) print('exclude dirs = ', args.exclude) conf = kconfiglib.Config(os.path.join(ugelisbase, 'Kconfig')) search_config_in_file(os.path.join(ugelisbase + os.path.sep + args.subdir), conf.get_top_level_items(), args.completelog, args.exclude)
# Usage if len(sys.arg) < 4: print "Usage: python2 generate_n_filter.py <kernel dir> <arch> [-s]" print "" print "-s Will output all the string symbols and their possible values" # Setting system environment variables os.environ["SRCARCH"] = sys.argv[2] os.environ["ARCH"] = sys.argv[2] os.environ["KERNELVERSION"] = version # Loading the Kconfig tree feature_model = kconfiglib.Config(dirname+"/"+kconfig_name, dirname) types = ["unknown", "bool", "tristate", "string", "hex", "int"] def scramble(fm): output = {} choices_taken = [] for feature in fm: type = types[feature.type] ischoice = feature.is_choice_symbol() if ischoice: choice = feature.get_parent() choices = choice.get_symbols() rnd = random.randrange(len(choices)) if choice in choices_taken: value = "n"
def __init__(self, cloud_provider): self.cloud_provider = cloud_provider self.cloud_config = 'phase1/{}/Kconfig'.format(self.cloud_provider) self.conf = kc.Config() self.print_config = True
formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('-s', '--subdir', action='store', dest='subdir', default="", help='sub directory to be scanned') parser.add_argument('-c', '--complete-log', action='store_true', dest='completelog', default=False, help='Prints all the kconfigs found') parser.add_argument('-e', '--exclude', action='append', dest='exclude', default=["doc", "sanity-out", "outdir"], help='Dirs to be excluded for verification') args = parser.parse_args() if args.completelog: print('sub dir = ', os.path.join(zephyrbase + args.subdir)) print('complete-log = ', args.completelog) print('exclude dirs = ', args.exclude) conf = kconfiglib.Config(os.path.join(zephyrbase, 'Kconfig')) search_config_in_file(os.path.join(zephyrbase + os.path.sep + args.subdir), conf.get_top_level_items(), args.completelog, args.exclude)
The Kconfig files are distributed across the build directory tree. The files are organized based on their common characteristics and on what new symbols they add to the configuration menus. The configuration options' information below is extracted directly from :program:`Kconfig` using the :file:`~/doc/scripts/genrest/genrest.py` script. Click on the option name in the table below for detailed information about each option. Supported Options ***************** .. list-table:: Alphabetized Index of Configuration Options :header-rows: 1 * - Kconfig Symbol - Description """) conf = kconfiglib.Config(sys.argv[1]) print_items(conf.get_top_level_items(), sys.argv[2], 0) # print_items created separate .rst files for each configuration option as # well as filling itemIndex with all these options (and their descriptions). # Now we can print out the accumulated config symbols in alphabetic order. for item in sorted(itemIndex): f.write(itemIndex[item]) f.close()
# Usage: if len(sys.argv) < 3: print "Usage: python2 get_minimum.py <kernel dir> <arch>" sys.exit(0) # Setting system environment variables arch = sys.argv[2] dirname = sys.argv[1] os.environ["SRCARCH"] = arch os.environ["ARCH"] = arch os.environ["KERNELVERSION"] = dirname[6:] # Auto configuration kconfig_name = "Kconfig" allno = kconfiglib.Config(dirname + "/" + kconfig_name, dirname) allno.load_config(output_dir + arch + "_allnoconfig") def in_allno(name): if allno[name].get_user_value() != None: if allno[name].get_type() in [3, 4, 5]: if not allno[name].get_value() == "": return True if allno[name].get_type() in [1, 2]: if allno[name].get_value() == "y": return True return False for i in allno: