400 lines
13 KiB
Python
Executable File
400 lines
13 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# ex:ts=4:sw=4:sts=4:et
|
|
# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
|
|
#
|
|
# Copyright (c) 2012, Intel Corporation.
|
|
# All rights reserved.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License version 2 as
|
|
# published by the Free Software Foundation.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along
|
|
# with this program; if not, write to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# DESCRIPTION
|
|
# 'yocto-kernel' is the Yocto BSP Tool that helps users manage kernel
|
|
# config options and patches for a Yocto BSP. Invoking it without any
|
|
# arguments will display help screens for the 'yocto-kernel' command
|
|
# and list the available 'yocto-kernel' subcommands. Invoking a
|
|
# subcommand without any arguments will likewise display help screens
|
|
# for the specified subcommand. Please use that interface for
|
|
# detailed help.
|
|
#
|
|
# AUTHORS
|
|
# Tom Zanussi <tom.zanussi (at] intel.com>
|
|
#
|
|
|
|
__version__ = "0.1.0"
|
|
|
|
import os
|
|
import sys
|
|
import optparse
|
|
import logging
|
|
|
|
scripts_path = os.path.abspath(os.path.dirname(os.path.abspath(sys.argv[0])))
|
|
lib_path = scripts_path + '/lib'
|
|
sys.path = sys.path + [lib_path]
|
|
|
|
from bsp.help import *
|
|
from bsp.kernel import *
|
|
|
|
|
|
def yocto_kernel_config_list_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for listing BSP config options. The
|
|
real work is done by bsp.kernel.yocto_kernel_config_list().
|
|
"""
|
|
logging.debug("yocto_kernel_config_list_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) != 1:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
yocto_kernel_config_list(scripts_path, args[0])
|
|
|
|
|
|
def yocto_kernel_config_add_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for adding BSP config items. The real work
|
|
is done by bsp.kernel.yocto_kernel_config_add().
|
|
"""
|
|
logging.debug("yocto_kernel_config_add_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) < 2:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
machine = args.pop(0)
|
|
yocto_kernel_config_add(scripts_path, machine, args)
|
|
|
|
|
|
def yocto_kernel_config_rm_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for removing BSP config items. The real
|
|
work is done by bsp.kernel.yocto_kernel_config_rm().
|
|
"""
|
|
logging.debug("yocto_kernel_config_rm_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) != 1:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
yocto_kernel_config_rm(scripts_path, args[0])
|
|
|
|
|
|
def yocto_kernel_patch_list_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for listing BSP (SRC_URI patches. The real
|
|
work is done by bsp.kernel.yocto_kernel_patch_list().
|
|
"""
|
|
logging.debug("yocto_kernel_patch_list_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) != 1:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
yocto_kernel_patch_list(scripts_path, args[0])
|
|
|
|
|
|
def yocto_kernel_patch_add_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for adding BSP patches. The real work is
|
|
done by bsp.kernel.yocto_kernel_patch_add().
|
|
"""
|
|
logging.debug("yocto_kernel_patch_add_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) < 2:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
machine = args.pop(0)
|
|
yocto_kernel_patch_add(scripts_path, machine, args)
|
|
|
|
|
|
def yocto_kernel_patch_rm_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for removing BSP patches. The real work is
|
|
done by bsp.kernel.yocto_kernel_patch_rm().
|
|
"""
|
|
logging.debug("yocto_kernel_patch_rm_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) != 1:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
yocto_kernel_patch_rm(scripts_path, args[0])
|
|
|
|
|
|
def yocto_kernel_feature_list_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for listing the BSP features that are being
|
|
used by the BSP. The real work is done by
|
|
bsp.kernel.yocto_kernel_feature_list().
|
|
"""
|
|
logging.debug("yocto_kernel_feature_list_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) != 1:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
yocto_kernel_feature_list(scripts_path, args[0])
|
|
|
|
|
|
def yocto_kernel_feature_add_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for adding the use of kernel features to a
|
|
BSP. The real work is done by bsp.kernel.yocto_kernel_feature_add().
|
|
"""
|
|
logging.debug("yocto_kernel_feature_add_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) < 2:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
machine = args.pop(0)
|
|
yocto_kernel_feature_add(scripts_path, machine, args)
|
|
|
|
|
|
def yocto_kernel_feature_rm_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for removing the use of kernel features from
|
|
a BSP. The real work is done by bsp.kernel.yocto_kernel_feature_rm().
|
|
"""
|
|
logging.debug("yocto_kernel_feature_rm_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) != 1:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
yocto_kernel_feature_rm(scripts_path, args[0])
|
|
|
|
|
|
def yocto_kernel_available_features_list_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for listing all the kernel features
|
|
available for use in a BSP. This includes the features present in
|
|
the meta branch(es) of the pointed-to repo(s) as well as the local
|
|
features added in recipe-space to the current BSP as well. The
|
|
real work is done by bsp.kernel.yocto_kernel_available_features_list().
|
|
"""
|
|
logging.debug("yocto_kernel_feature_available_features_list_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) != 1:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
yocto_kernel_available_features_list(scripts_path, args[0])
|
|
|
|
|
|
def yocto_kernel_feature_describe_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for listing the description of a specific
|
|
kernel feature available for use in a BSP. This includes the
|
|
features present in the meta branch(es) of the pointed-to repo(s)
|
|
as well as the local features added in recipe-space to the current
|
|
BSP as well. The real work is done by
|
|
bsp.kernel.yocto_kernel_feature_describe().
|
|
"""
|
|
logging.debug("yocto_kernel_feature_describe_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) != 2:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
yocto_kernel_feature_describe(scripts_path, args[0], args[1])
|
|
|
|
|
|
def yocto_kernel_feature_create_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for creating a recipe-space kernel feature
|
|
in a BSP. The real work is done by
|
|
bsp.kernel.yocto_kernel_feature_create().
|
|
"""
|
|
logging.debug("yocto_kernel_feature_create_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) < 4:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
machine = args.pop(0)
|
|
yocto_kernel_feature_create(scripts_path, machine, args)
|
|
|
|
|
|
def yocto_kernel_feature_destroy_subcommand(args, usage_str):
|
|
"""
|
|
Command-line handling for removing a recipe-space kernel feature
|
|
from a BSP. The real work is done by
|
|
bsp.kernel.yocto_kernel_feature_destroy().
|
|
"""
|
|
logging.debug("yocto_kernel_feature_destroy_subcommand")
|
|
|
|
parser = optparse.OptionParser(usage = usage_str)
|
|
|
|
(options, args) = parser.parse_args(args)
|
|
|
|
if len(args) != 2:
|
|
logging.error("Wrong number of arguments, exiting\n")
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
yocto_kernel_feature_destroy(scripts_path, args[0], args[1])
|
|
|
|
|
|
subcommands = {
|
|
"config-list": [yocto_kernel_config_list_subcommand,
|
|
yocto_kernel_config_list_usage,
|
|
yocto_kernel_config_list_help],
|
|
"config-add": [yocto_kernel_config_add_subcommand,
|
|
yocto_kernel_config_add_usage,
|
|
yocto_kernel_config_add_help],
|
|
"config-rm": [yocto_kernel_config_rm_subcommand,
|
|
yocto_kernel_config_rm_usage,
|
|
yocto_kernel_config_rm_help],
|
|
"patch-list": [yocto_kernel_patch_list_subcommand,
|
|
yocto_kernel_patch_list_usage,
|
|
yocto_kernel_patch_list_help],
|
|
"patch-add": [yocto_kernel_patch_add_subcommand,
|
|
yocto_kernel_patch_add_usage,
|
|
yocto_kernel_patch_add_help],
|
|
"patch-rm": [yocto_kernel_patch_rm_subcommand,
|
|
yocto_kernel_patch_rm_usage,
|
|
yocto_kernel_patch_rm_help],
|
|
"feature-list": [yocto_kernel_feature_list_subcommand,
|
|
yocto_kernel_feature_list_usage,
|
|
yocto_kernel_feature_list_help],
|
|
"feature-add": [yocto_kernel_feature_add_subcommand,
|
|
yocto_kernel_feature_add_usage,
|
|
yocto_kernel_feature_add_help],
|
|
"feature-rm": [yocto_kernel_feature_rm_subcommand,
|
|
yocto_kernel_feature_rm_usage,
|
|
yocto_kernel_feature_rm_help],
|
|
"features-list": [yocto_kernel_available_features_list_subcommand,
|
|
yocto_kernel_available_features_list_usage,
|
|
yocto_kernel_available_features_list_help],
|
|
"feature-describe": [yocto_kernel_feature_describe_subcommand,
|
|
yocto_kernel_feature_describe_usage,
|
|
yocto_kernel_feature_describe_help],
|
|
"feature-create": [yocto_kernel_feature_create_subcommand,
|
|
yocto_kernel_feature_create_usage,
|
|
yocto_kernel_feature_create_help],
|
|
"feature-destroy": [yocto_kernel_feature_destroy_subcommand,
|
|
yocto_kernel_feature_destroy_usage,
|
|
yocto_kernel_feature_destroy_help],
|
|
}
|
|
|
|
|
|
def start_logging(loglevel):
|
|
logging.basicConfig(filename = 'yocto-kernel.log', filemode = 'w', level=loglevel)
|
|
|
|
|
|
def main():
|
|
parser = optparse.OptionParser(version = "yocto-kernel version %s" % __version__,
|
|
usage = yocto_kernel_usage)
|
|
|
|
parser.disable_interspersed_args()
|
|
parser.add_option("-D", "--debug", dest = "debug", action = "store_true",
|
|
default = False, help = "output debug information")
|
|
|
|
(options, args) = parser.parse_args()
|
|
|
|
loglevel = logging.INFO
|
|
if options.debug:
|
|
loglevel = logging.DEBUG
|
|
start_logging(loglevel)
|
|
|
|
if len(args):
|
|
if args[0] == "help":
|
|
if len(args) == 1:
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
sc = 1
|
|
else:
|
|
sc = 0
|
|
|
|
if args[sc] == "config" or args[sc] == "patch" or \
|
|
args[sc] == "feature" or args[sc] == "features":
|
|
if len(args) < 2 + sc:
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
args[sc] += "-" + args[sc + 1]
|
|
args.pop(sc + 1)
|
|
|
|
invoke_subcommand(args, parser, yocto_kernel_help_usage, subcommands)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
ret = main()
|
|
except Exception:
|
|
ret = 1
|
|
import traceback
|
|
traceback.print_exc()
|
|
sys.exit(ret)
|