p96705831
/
platform_build
forked from openkylin/platform_build
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use fs_config_generator.py to generate fs_config_files/dirs directly 

We want to remove target specific host tools and since
fs_config_generate is compiled with a target specific header file, we
instead remove fs_config_generate entirely and allow python to build
the fs_config_files/dirs files directly from config.fs files and
parsed C headers.

Test: associated unit tests and new end to end test
Test: aosp_sailfish, aosp_crosshatch build produces valid fs_config files
Test: aosp_cf_x86_phone build correctly produces empty fs_config files
Change-Id: Idbc63ff56c0979e1e4c17721371de9d9d02dc8ff
This commit is contained in:
Tom Cherry 2019-02-13 14:02:30 -08:00
parent 1a9f8356fd
commit 9d924f67d3
16 changed files with 518 additions and 723 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
tools/fs_config/Android.bp
View File

@ -21,43 +21,3 @@ cc_binary_host {
],
cflags: ["-Werror"],
}
// -----------------------------------------------------------------------------
// Unit tests.
// -----------------------------------------------------------------------------
test_c_flags = [
"-fstack-protector-all",
"-g",
"-Wall",
"-Wextra",
"-Werror",
"-fno-builtin",
"-DANDROID_FILESYSTEM_CONFIG=\"android_filesystem_config_test_data.h\"",
]
//#################################
// test executable
cc_test_host {
name: "fs_config_generate_test",
srcs: ["fs_config_generate.c"],
shared_libs: ["libcutils"],
cflags: test_c_flags,
relative_install_path: "fs_config-unit-tests",
no_named_install_directory: true,
gtest: false,
}
//#################################
// gTest tool
cc_test_host {
name: "fs_config-unit-tests",
cflags: test_c_flags + ["-DHOST"],
shared_libs: [
"liblog",
"libcutils",
"libbase",
],
srcs: ["fs_config_test.cpp"],
}

245
tools/fs_config/Android.mk
View File

@ -19,54 +19,14 @@ LOCAL_PATH := $(call my-dir)
# for generating the android_filesystem_config.h file.
#
# More information can be found in the README
ANDROID_FS_CONFIG_H := android_filesystem_config.h
ifneq ($(wildcard $(TARGET_DEVICE_DIR)/$(ANDROID_FS_CONFIG_H)),)
$(error Using $(ANDROID_FS_CONFIG_H) is deprecated, please use TARGET_FS_CONFIG_GEN instead)
ifneq ($(wildcard $(TARGET_DEVICE_DIR)/android_filesystem_config.h),)
$(error Using $(TARGET_DEVICE_DIR)/android_filesystem_config.h is deprecated, please use TARGET_FS_CONFIG_GEN instead)
endif
my_fs_config_h := $(LOCAL_PATH)/default/$(ANDROID_FS_CONFIG_H)
system_android_filesystem_config := system/core/include/private/android_filesystem_config.h
system_capability_header := bionic/libc/kernel/uapi/linux/capability.h
##################################
include $(CLEAR_VARS)
LOCAL_SRC_FILES := fs_config_generate.c
LOCAL_MODULE := fs_config_generate_$(TARGET_DEVICE)
LOCAL_MODULE_CLASS := EXECUTABLES
LOCAL_SHARED_LIBRARIES := libcutils
LOCAL_CFLAGS := -Werror -Wno-error=\#warnings
ifneq ($(TARGET_FS_CONFIG_GEN),)
# Generate the "generated_oem_aid.h" file
oem := $(local-generated-sources-dir)/generated_oem_aid.h
$(oem): PRIVATE_LOCAL_PATH := $(LOCAL_PATH)
$(oem): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(oem): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(oem): PRIVATE_CUSTOM_TOOL = $(PRIVATE_LOCAL_PATH)/fs_config_generator.py oemaid --aid-header=$(PRIVATE_ANDROID_FS_HDR) $(PRIVATE_TARGET_FS_CONFIG_GEN) > $@
$(oem): $(TARGET_FS_CONFIG_GEN) $(LOCAL_PATH)/fs_config_generator.py
$(transform-generated-source)
# Generate the fs_config header
gen := $(local-generated-sources-dir)/$(ANDROID_FS_CONFIG_H)
$(gen): PRIVATE_LOCAL_PATH := $(LOCAL_PATH)
$(gen): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(gen): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(gen): PRIVATE_CUSTOM_TOOL = $(PRIVATE_LOCAL_PATH)/fs_config_generator.py fsconfig --aid-header=$(PRIVATE_ANDROID_FS_HDR) $(PRIVATE_TARGET_FS_CONFIG_GEN) > $@
$(gen): $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(LOCAL_PATH)/fs_config_generator.py
$(transform-generated-source)
LOCAL_GENERATED_SOURCES := $(oem) $(gen)
my_fs_config_h := $(gen)
my_gen_oem_aid := $(oem)
gen :=
oem :=
endif
LOCAL_C_INCLUDES := $(dir $(my_fs_config_h)) $(dir $(my_gen_oem_aid))
include $(BUILD_HOST_EXECUTABLE)
fs_config_generate_bin := $(LOCAL_INSTALLED_MODULE)
# List of supported vendor, oem, odm, product and product_services Partitions
fs_config_generate_extra_partition_list := $(strip \
$(if $(BOARD_USES_VENDORIMAGE)$(BOARD_VENDORIMAGE_FILE_SYSTEM_TYPE),vendor) \
@ -129,12 +89,20 @@ LOCAL_MODULE := fs_config_dirs_system
LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_dirs
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_PARTITION_LIST := $(fs_config_generate_extra_partition_list)
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -D $(if $(PRIVATE_PARTITION_LIST), \
-P '$(subst $(space),$(comma),$(addprefix -,$(PRIVATE_PARTITION_LIST)))') \
-o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition system \
--all-partitions $(subst $(space),$(comma),$(PRIVATE_PARTITION_LIST)) \
--dirs \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
##################################
# Generate the system/etc/fs_config_files binary file for the target
@ -146,12 +114,20 @@ LOCAL_MODULE := fs_config_files_system
LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_files
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_PARTITION_LIST := $(fs_config_generate_extra_partition_list)
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -F $(if $(PRIVATE_PARTITION_LIST), \
-P '$(subst $(space),$(comma),$(addprefix -,$(PRIVATE_PARTITION_LIST)))') \
-o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition system \
--all-partitions $(subst $(space),$(comma),$(PRIVATE_PARTITION_LIST)) \
--files \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
ifneq ($(filter vendor,$(fs_config_generate_extra_partition_list)),)
##################################
@ -165,9 +141,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_dirs
LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -D -P vendor -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition vendor \
--dirs \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
##################################
# Generate the vendor/etc/fs_config_files binary file for the target
@ -180,9 +165,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_files
LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -F -P vendor -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition vendor \
--files \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
endif
@ -198,9 +192,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_dirs
LOCAL_MODULE_PATH := $(TARGET_OUT_OEM)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -D -P oem -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition oem \
--dirs \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
##################################
# Generate the oem/etc/fs_config_files binary file for the target
@ -213,9 +216,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_files
LOCAL_MODULE_PATH := $(TARGET_OUT_OEM)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -F -P oem -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition oem \
--files \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
endif
@ -231,9 +243,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_dirs
LOCAL_MODULE_PATH := $(TARGET_OUT_ODM)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -D -P odm -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition odm \
--dirs \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
##################################
# Generate the odm/etc/fs_config_files binary file for the target
@ -246,9 +267,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_files
LOCAL_MODULE_PATH := $(TARGET_OUT_ODM)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -F -P odm -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition odm \
--files \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
endif
@ -264,9 +294,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_dirs
LOCAL_MODULE_PATH := $(TARGET_OUT_PRODUCT)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -D -P product -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition product \
--dirs \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
##################################
# Generate the product/etc/fs_config_files binary file for the target
@ -279,10 +318,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_files
LOCAL_MODULE_PATH := $(TARGET_OUT_PRODUCT)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -F -P product -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition product \
--files \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
endif
ifneq ($(filter product_services,$(fs_config_generate_extra_partition_list)),)
@ -297,9 +344,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_dirs
LOCAL_MODULE_PATH := $(TARGET_OUT_PRODUCT_SERVICES)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -D -P product_services -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition product_services \
--dirs \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
##################################
# Generate the product_services/etc/fs_config_files binary file for the target
@ -312,10 +368,18 @@ LOCAL_MODULE_CLASS := ETC
LOCAL_INSTALLED_MODULE_STEM := fs_config_files
LOCAL_MODULE_PATH := $(TARGET_OUT_PRODUCT_SERVICES)/etc
include $(BUILD_SYSTEM)/base_rules.mk
$(LOCAL_BUILT_MODULE): $(fs_config_generate_bin)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_CAP_HDR := $(system_capability_header)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config) $(system_capability_header)
@mkdir -p $(dir $@)
$< -F -P product_services -o $@
$< fsconfig \
--aid-header $(PRIVATE_ANDROID_FS_HDR) \
--capability-header $(PRIVATE_ANDROID_CAP_HDR) \
--partition product_services \
--files \
--out_file $@ \
$(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null)
endif
##################################
@ -325,8 +389,21 @@ endif
ifneq ($(TARGET_FS_CONFIG_GEN),)
include $(CLEAR_VARS)
LOCAL_MODULE := oemaids_headers
LOCAL_EXPORT_C_INCLUDE_DIRS := $(dir $(my_gen_oem_aid))
LOCAL_EXPORT_C_INCLUDE_DEPS := $(my_gen_oem_aid)
LOCAL_MODULE_CLASS := ETC
# Generate the "generated_oem_aid.h" file
oem := $(local-generated-sources-dir)/generated_oem_aid.h
$(oem): PRIVATE_LOCAL_PATH := $(LOCAL_PATH)
$(oem): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
$(oem): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(oem): PRIVATE_CUSTOM_TOOL = $(PRIVATE_LOCAL_PATH)/fs_config_generator.py oemaid --aid-header=$(PRIVATE_ANDROID_FS_HDR) $(PRIVATE_TARGET_FS_CONFIG_GEN) > $@
$(oem): $(TARGET_FS_CONFIG_GEN) $(LOCAL_PATH)/fs_config_generator.py
$(transform-generated-source)
LOCAL_EXPORT_C_INCLUDE_DIRS := $(dir $(oem))
LOCAL_EXPORT_C_INCLUDE_DEPS := $(oem)
include $(BUILD_HEADER_LIBRARY)
endif
@ -342,15 +419,11 @@ LOCAL_VENDOR_MODULE := true
include $(BUILD_SYSTEM)/base_rules.mk
ifneq ($(TARGET_FS_CONFIG_GEN),)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
else
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := /dev/null
endif
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config)
@mkdir -p $(dir $@)
$(hide) $< passwd --required-prefix=vendor_ --aid-header=$(PRIVATE_ANDROID_FS_HDR) $(PRIVATE_TARGET_FS_CONFIG_GEN) > $@
$(hide) $< passwd --required-prefix=vendor_ --aid-header=$(PRIVATE_ANDROID_FS_HDR) $(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null) > $@
##################################
# Generate the vendor/etc/group text file for the target
@ -364,20 +437,12 @@ LOCAL_VENDOR_MODULE := true
include $(BUILD_SYSTEM)/base_rules.mk
ifneq ($(TARGET_FS_CONFIG_GEN),)
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := $(TARGET_FS_CONFIG_GEN)
else
$(LOCAL_BUILT_MODULE): PRIVATE_TARGET_FS_CONFIG_GEN := /dev/null
endif
$(LOCAL_BUILT_MODULE): PRIVATE_ANDROID_FS_HDR := $(system_android_filesystem_config)
$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/fs_config_generator.py $(TARGET_FS_CONFIG_GEN) $(system_android_filesystem_config)
@mkdir -p $(dir $@)
$(hide) $< group --required-prefix=vendor_ --aid-header=$(PRIVATE_ANDROID_FS_HDR) $(PRIVATE_TARGET_FS_CONFIG_GEN) > $@
$(hide) $< group --required-prefix=vendor_ --aid-header=$(PRIVATE_ANDROID_FS_HDR) $(or $(PRIVATE_TARGET_FS_CONFIG_GEN),/dev/null) > $@
system_android_filesystem_config :=
ANDROID_FS_CONFIG_H :=
my_fs_config_h :=
fs_config_generate_bin :=
my_gen_oem_aid :=
system_capability_header :=
fs_config_generate_extra_partition_list :=

64
tools/fs_config/android_filesystem_config_test_data.h
View File

@ -1,64 +0,0 @@
/*
* Copyright (C) 2017 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.
*/
#include <private/android_filesystem_config.h>
/* Test Data */
#undef NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_DIRS
#undef NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_FILES
static const struct fs_path_config android_device_dirs[] = {
{00555, AID_ROOT, AID_SYSTEM, 0, "system/etc"},
{00555, AID_ROOT, AID_SYSTEM, 0, "vendor/etc"},
{00555, AID_ROOT, AID_SYSTEM, 0, "oem/etc"},
{00555, AID_ROOT, AID_SYSTEM, 0, "odm/etc"},
{00555, AID_ROOT, AID_SYSTEM, 0, "product/etc"},
{00555, AID_ROOT, AID_SYSTEM, 0, "product_services/etc"},
{00755, AID_SYSTEM, AID_ROOT, 0, "system/oem/etc"},
{00755, AID_SYSTEM, AID_ROOT, 0, "system/odm/etc"},
{00755, AID_SYSTEM, AID_ROOT, 0, "system/vendor/etc"},
{00755, AID_SYSTEM, AID_ROOT, 0, "data/misc"},
{00755, AID_SYSTEM, AID_ROOT, 0, "oem/data/misc"},
{00755, AID_SYSTEM, AID_ROOT, 0, "odm/data/misc"},
{00755, AID_SYSTEM, AID_ROOT, 0, "vendor/data/misc"},
{00555, AID_SYSTEM, AID_ROOT, 0, "etc"},
};
static const struct fs_path_config android_device_files[] = {
{00444, AID_ROOT, AID_SYSTEM, 0, "system/etc/fs_config_dirs"},
{00444, AID_ROOT, AID_SYSTEM, 0, "vendor/etc/fs_config_dirs"},
{00444, AID_ROOT, AID_SYSTEM, 0, "oem/etc/fs_config_dirs"},
{00444, AID_ROOT, AID_SYSTEM, 0, "odm/etc/fs_config_dirs"},
{00444, AID_ROOT, AID_SYSTEM, 0, "product/etc/fs_config_dirs"},
{00444, AID_ROOT, AID_SYSTEM, 0, "product_services/etc/fs_config_dirs"},
{00444, AID_ROOT, AID_SYSTEM, 0, "system/etc/fs_config_files"},
{00444, AID_ROOT, AID_SYSTEM, 0, "vendor/etc/fs_config_files"},
{00444, AID_ROOT, AID_SYSTEM, 0, "oem/etc/fs_config_files"},
{00444, AID_ROOT, AID_SYSTEM, 0, "odm/etc/fs_config_files"},
{00444, AID_ROOT, AID_SYSTEM, 0, "product/etc/fs_config_files"},
{00444, AID_ROOT, AID_SYSTEM, 0, "product_services/etc/fs_config_files"},
{00644, AID_SYSTEM, AID_ROOT, 0, "system/vendor/etc/fs_config_dirs"},
{00644, AID_SYSTEM, AID_ROOT, 0, "system/oem/etc/fs_config_dirs"},
{00644, AID_SYSTEM, AID_ROOT, 0, "system/odm/etc/fs_config_dirs"},
{00644, AID_SYSTEM, AID_ROOT, 0, "system/vendor/etc/fs_config_files"},
{00644, AID_SYSTEM, AID_ROOT, 0, "system/oem/etc/fs_config_files"},
{00644, AID_SYSTEM, AID_ROOT, 0, "system/odm/etc/fs_config_files"},
{00644, AID_SYSTEM, AID_ROOT, 0, "system/product/etc/fs_config_files"},
{00644, AID_SYSTEM, AID_ROOT, 0, "system/product_services/etc/fs_config_files"},
{00644, AID_SYSTEM, AID_ROOT, 0, "etc/fs_config_files"},
{00666, AID_ROOT, AID_SYSTEM, 0, "data/misc/oem"},
};

37
tools/fs_config/default/android_filesystem_config.h
View File

@ -1,37 +0,0 @@
/*
* Copyright (C) 2015 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.
*/
/* This file is used to enhance the properties of the filesystem
** images generated by build tools (mkbootfs and mkyaffs2image) and
** by the device side of adb.
*/
/* Rules for directories.
** These rules are applied based on "first match", so they
** should start with the most specific path and work their
** way up to the root.
*/
#define NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_DIRS 1 /* opt out of specifying */
/* Rules for files.
** These rules are applied based on "first match", so they
** should start with the most specific path and work their
** way up to the root. Prefixes ending in * denotes wildcard
** and will allow partial matches.
*/
#define NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_FILES 1 /* opt out of specifying */

108
tools/fs_config/end_to_end_test/config.fs Normal file
View File

@ -0,0 +1,108 @@
# Copyright (C) 2018 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.
#
# This file is used to define the properties of the filesystem
# images generated by build tools (mkbootfs and mkyaffs2image) and
# by the device side of adb.
[AID_VENDOR_NEW_SERVICE]
value: 2900
[AID_VENDOR_NEW_SERVICE_TWO]
value:2902
[vendor/bin/service1]
mode: 0755
user: AID_SYSTEM
group: AID_VENDOR_NEW_SERVICE
caps: CHOWN DAC_OVERRIDE
[vendor/bin/service2]
mode: 0755
user: AID_VENDOR_NEW_SERVICE_TWO
group: AID_SYSTEM
caps: AUDIT_READ CHOWN SYS_ADMIN
[system/vendor/bin/service3]
mode: 0755
user: AID_SYSTEM
group: AID_SYSTEM
caps: AUDIT_READ CHOWN SYS_ADMIN
[vendor/dir/]
mode: 0755
user: AID_VENDOR_NEW_SERVICE_TWO
group: AID_SYSTEM
caps: 0
[system/vendor/dir2/]
mode: 0755
user: AID_VENDOR_NEW_SERVICE_TWO
group: AID_SYSTEM
caps: 0
[product/bin/service1]
mode: 0755
user: AID_SYSTEM
group: AID_SYSTEM
caps: 0x34
[product/bin/service2]
mode: 0755
user: AID_SYSTEM
group: AID_SYSTEM
caps: NET_BIND_SERVICE WAKE_ALARM
[system/product/bin/service3]
mode: 0755
user: AID_SYSTEM
group: AID_SYSTEM
caps: NET_BIND_SERVICE WAKE_ALARM
[product/dir/]
mode: 0755
user: AID_SYSTEM
group: AID_SYSTEM
caps: 0
[system/product/dir/]
mode: 0755
user: AID_SYSTEM
group: AID_SYSTEM
caps: 0
[system/bin/service]
mode: 0755
user: AID_SYSTEM
group: AID_RADIO
caps: NET_BIND_SERVICE
[system/dir/]
mode: 0755
user: AID_SYSTEM
group: AID_RADIO
caps: 0
[root_file]
mode: 0755
user: AID_SYSTEM
group: AID_RADIO
caps: 0
[root_dir/]
mode: 0755
user: AID_SYSTEM
group: AID_RADIO
caps: 0

BIN
tools/fs_config/end_to_end_test/product_fs_config_dirs Normal file
View File

Binary file not shown.

BIN
tools/fs_config/end_to_end_test/product_fs_config_files Normal file
View File

Binary file not shown.

76
tools/fs_config/end_to_end_test/run_test.sh Executable file
View File

@ -0,0 +1,76 @@
cd $ANDROID_BUILD_TOP/build/make/tools/fs_config/end_to_end_test
$ANDROID_BUILD_TOP/build/make/tools/fs_config/fs_config_generator.py fsconfig \
--aid-header $ANDROID_BUILD_TOP/system/core/include/private/android_filesystem_config.h \
--capability-header $ANDROID_BUILD_TOP/bionic/libc/kernel/uapi/linux/capability.h \
--partition system \
--all-partitions vendor,product \
--files \
--out_file result_system_fs_config_files \
./config.fs
diff system_fs_config_files result_system_fs_config_files 1>/dev/null && echo 'Success system_fs_config_files' ||
echo 'Fail: Mismatch between system_fs_config_files and result_system_fs_config_files'
$ANDROID_BUILD_TOP/build/make/tools/fs_config/fs_config_generator.py fsconfig \
--aid-header $ANDROID_BUILD_TOP/system/core/include/private/android_filesystem_config.h \
--capability-header $ANDROID_BUILD_TOP/bionic/libc/kernel/uapi/linux/capability.h \
--partition system \
--all-partitions vendor,product \
--dirs \
--out_file result_system_fs_config_dirs \
./config.fs
diff system_fs_config_dirs result_system_fs_config_dirs 1>/dev/null && echo 'Success system_fs_config_dirs' ||
echo 'Fail: Mismatch between system_fs_config_dirs and result_system_fs_config_dirs'
$ANDROID_BUILD_TOP/build/make/tools/fs_config/fs_config_generator.py fsconfig \
--aid-header $ANDROID_BUILD_TOP/system/core/include/private/android_filesystem_config.h \
--capability-header $ANDROID_BUILD_TOP/bionic/libc/kernel/uapi/linux/capability.h \
--partition vendor \
--files \
--out_file result_vendor_fs_config_files \
./config.fs
diff vendor_fs_config_files result_vendor_fs_config_files 1>/dev/null && echo 'Success vendor_fs_config_files' ||
echo 'Fail: Mismatch between vendor_fs_config_files and result_vendor_fs_config_files'
$ANDROID_BUILD_TOP/build/make/tools/fs_config/fs_config_generator.py fsconfig \
--aid-header $ANDROID_BUILD_TOP/system/core/include/private/android_filesystem_config.h \
--capability-header $ANDROID_BUILD_TOP/bionic/libc/kernel/uapi/linux/capability.h \
--partition vendor \
--dirs \
--out_file result_vendor_fs_config_dirs \
./config.fs
diff vendor_fs_config_dirs result_vendor_fs_config_dirs 1>/dev/null && echo 'Success vendor_fs_config_dirs' ||
echo 'Fail: Mismatch between vendor_fs_config_dirs and result_vendor_fs_config_dirs'
$ANDROID_BUILD_TOP/build/make/tools/fs_config/fs_config_generator.py fsconfig \
--aid-header $ANDROID_BUILD_TOP/system/core/include/private/android_filesystem_config.h \
--capability-header $ANDROID_BUILD_TOP/bionic/libc/kernel/uapi/linux/capability.h \
--partition product \
--files \
--out_file result_product_fs_config_files \
./config.fs
diff product_fs_config_files result_product_fs_config_files 1>/dev/null && echo 'Success product_fs_config_files' ||
echo 'Fail: Mismatch between product_fs_config_files and result_product_fs_config_files'
$ANDROID_BUILD_TOP/build/make/tools/fs_config/fs_config_generator.py fsconfig \
--aid-header $ANDROID_BUILD_TOP/system/core/include/private/android_filesystem_config.h \
--capability-header $ANDROID_BUILD_TOP/bionic/libc/kernel/uapi/linux/capability.h \
--partition product \
--dirs \
--out_file result_product_fs_config_dirs \
./config.fs
diff product_fs_config_dirs result_product_fs_config_dirs 1>/dev/null && echo 'Success product_fs_config_dirs' ||
echo 'Fail: Mismatch between product_fs_config_dirs and result_product_fs_config_dirs'
rm result_system_fs_config_files
rm result_system_fs_config_dirs
rm result_vendor_fs_config_files
rm result_vendor_fs_config_dirs
rm result_product_fs_config_files
rm result_product_fs_config_dirs

BIN
tools/fs_config/end_to_end_test/system_fs_config_dirs Normal file
View File

Binary file not shown.

BIN
tools/fs_config/end_to_end_test/system_fs_config_files Normal file
View File

Binary file not shown.

BIN
tools/fs_config/end_to_end_test/vendor_fs_config_dirs Normal file
View File

Binary file not shown.

BIN
tools/fs_config/end_to_end_test/vendor_fs_config_files Normal file
View File

Binary file not shown.

213
tools/fs_config/fs_config_generate.c
View File

@ -1,213 +0,0 @@
/*
* Copyright (C) 2015 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.
*/
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <private/android_filesystem_config.h>
/*
* This program expects android_device_dirs and android_device_files
* to be defined in the supplied android_filesystem_config.h file in
* the device/<vendor>/<product> $(TARGET_DEVICE_DIR). Then generates
* the binary format used in the /system/etc/fs_config_dirs and
* the /system/etc/fs_config_files to be used by the runtimes.
*/
#ifdef ANDROID_FILESYSTEM_CONFIG
#include ANDROID_FILESYSTEM_CONFIG
#else
#include "android_filesystem_config.h"
#endif
#ifdef NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_DIRS
static const struct fs_path_config android_device_dirs[] = { };
#endif
#ifdef NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_FILES
static const struct fs_path_config android_device_files[] = { };
#endif
static void usage() {
fprintf(stderr,
"Generate binary content for fs_config_dirs (-D) and fs_config_files (-F)\n"
"from device-specific android_filesystem_config.h override. Filter based\n"
"on a comma separated partition list (-P) whitelist or prefixed by a\n"
"minus blacklist. Partitions are identified as path references to\n"
"<partition>/ or system/<partition>/\n\n"
"Usage: fs_config_generate -D|-F [-P list] [-o output-file]\n");
}
/* If tool switches to C++, use android-base/macros.h array_size() */
#ifndef ARRAY_SIZE /* popular macro */
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#endif
int main(int argc, char** argv) {
const struct fs_path_config* pc;
const struct fs_path_config* end;
bool dir = false, file = false;
const char* partitions = NULL;
FILE* fp = stdout;
int opt;
static const char optstring[] = "DFP:ho:";
while ((opt = getopt(argc, argv, optstring)) != -1) {
switch (opt) {
case 'D':
if (file) {
fprintf(stderr, "Must specify only -D or -F\n");
usage();
exit(EXIT_FAILURE);
}
dir = true;
break;
case 'F':
if (dir) {
fprintf(stderr, "Must specify only -F or -D\n");
usage();
exit(EXIT_FAILURE);
}
file = true;
break;
case 'P':
if (partitions) {
fprintf(stderr, "Specify only one partition list\n");
usage();
exit(EXIT_FAILURE);
}
while (*optarg && isspace(*optarg)) ++optarg;
if (!optarg[0]) {
fprintf(stderr, "Partition list empty\n");
usage();
exit(EXIT_FAILURE);
}
if (!optarg[1]) {
fprintf(stderr, "Partition list too short \"%s\"\n", optarg);
usage();
exit(EXIT_FAILURE);
}
if ((optarg[0] == '-') && strchr(optstring, optarg[1]) && !optarg[2]) {
fprintf(stderr, "Partition list is a flag \"%s\"\n", optarg);
usage();
exit(EXIT_FAILURE);
}
partitions = optarg;
break;
case 'o':
if (fp != stdout) {
fprintf(stderr, "Specify only one output file\n");
usage();
exit(EXIT_FAILURE);
}
fp = fopen(optarg, "wb");
if (fp == NULL) {
fprintf(stderr, "Can not open \"%s\"\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 'h':
usage();
exit(EXIT_SUCCESS);
default:
usage();
exit(EXIT_FAILURE);
}
}
if (optind < argc) {
fprintf(stderr, "Unknown non-argument \"%s\"\n", argv[optind]);
usage();
exit(EXIT_FAILURE);
}
if (!file && !dir) {
fprintf(stderr, "Must specify either -F or -D\n");
usage();
exit(EXIT_FAILURE);
}
if (dir) {
pc = android_device_dirs;
end = &android_device_dirs[ARRAY_SIZE(android_device_dirs)];
} else {
pc = android_device_files;
end = &android_device_files[ARRAY_SIZE(android_device_files)];
}
for (; (pc < end) && pc->prefix; pc++) {
bool submit;
char buffer[512];
ssize_t len = fs_config_generate(buffer, sizeof(buffer), pc);
if (len < 0) {
fprintf(stderr, "Entry too large\n");
exit(EXIT_FAILURE);
}
submit = true;
if (partitions) {
char* partitions_copy = strdup(partitions);
char* arg = partitions_copy;
char* sv = NULL; /* Do not leave uninitialized, NULL is known safe. */
/* Deal with case all iterated partitions are blacklists with no match */
bool all_blacklist_but_no_match = true;
submit = false;
if (!partitions_copy) {
fprintf(stderr, "Failed to allocate a copy of %s\n", partitions);
exit(EXIT_FAILURE);
}
/* iterate through (officially) comma separated list of partitions */
while (!!(arg = strtok_r(arg, ",:; \t\n\r\f", &sv))) {
static const char system[] = "system/";
size_t plen;
bool blacklist = false;
if (*arg == '-') {
blacklist = true;
++arg;
} else {
all_blacklist_but_no_match = false;
}
plen = strlen(arg);
/* deal with evil callers */
while (arg[plen - 1] == '/') {
--plen;
}
/* check if we have <partition>/ or /system/<partition>/ */
if ((!strncmp(pc->prefix, arg, plen) && (pc->prefix[plen] == '/')) ||
(!strncmp(pc->prefix, system, strlen(system)) &&
!strncmp(pc->prefix + strlen(system), arg, plen) &&
(pc->prefix[strlen(system) + plen] == '/'))) {
all_blacklist_but_no_match = false;
/* we have a match !!! */
if (!blacklist) submit = true;
break;
}
arg = NULL;
}
free(partitions_copy);
if (all_blacklist_but_no_match) submit = true;
}
if (submit && (fwrite(buffer, 1, len, fp) != (size_t)len)) {
fprintf(stderr, "Write failure\n");
exit(EXIT_FAILURE);
}
}
fclose(fp);
return 0;
}

267
tools/fs_config/fs_config_generator.py
View File

@ -12,6 +12,7 @@ Further documentation can be found in the README.
import argparse
import ConfigParser
import ctypes
import re
import sys
import textwrap
@ -252,6 +253,46 @@ class FSConfig(object):
self.path, self.filename)
class CapabilityHeaderParser(object):
"""Parses capability.h file
Parses a C header file and extracts lines starting with #define CAP_<name>.
"""
_CAP_DEFINE = re.compile(r'\s*#define\s+(CAP_\S+)\s+(\S+)')
_SKIP_CAPS = ['CAP_LAST_CAP', 'CAP_TO_INDEX(x)', 'CAP_TO_MASK(x)']
def __init__(self, capability_header):
"""
Args:
capability_header (str): file name for the header file containing AID entries.
"""
self.caps = {}
with open(capability_header) as open_file:
self._parse(open_file)
def _parse(self, capability_file):
"""Parses a capability header file. Internal use only.
Args:
capability_file (file): The open capability header file to parse.
"""
for line in capability_file:
match = CapabilityHeaderParser._CAP_DEFINE.match(line)
if match:
cap = match.group(1)
value = match.group(2)
if not cap in self._SKIP_CAPS:
try:
self.caps[cap] = int(value, 0)
except ValueError:
sys.exit('Could not parse capability define "%s":"%s"'
% (cap, value))
class AIDHeaderParser(object):
"""Parses an android_filesystem_config.h file.
@ -728,9 +769,9 @@ class FSConfigFileParser(object):
try:
# test if string is int, if it is, use as is.
int(cap, 0)
tmp.append('(' + cap + ')')
tmp.append(cap)
except ValueError:
tmp.append('CAP_MASK_LONG(CAP_' + cap.upper() + ')')
tmp.append('CAP_' + cap.upper())
caps = tmp
@ -745,7 +786,7 @@ class FSConfigFileParser(object):
if len(mode) != 4:
sys.exit('Mode must be 3 or 4 characters, got: "%s"' % mode)
caps_str = '|'.join(caps)
caps_str = ','.join(caps)
entry = FSConfig(mode, user, group, caps_str, section_name, file_name)
if section_name[-1] == '/':
@ -903,41 +944,20 @@ class FSConfigGen(BaseGenerator):
Output is used in generating fs_config_files and fs_config_dirs.
"""
_GENERATED = textwrap.dedent("""\
/*
* THIS IS AN AUTOGENERATED FILE! DO NOT MODIFY
*/
""")
_INCLUDES = [
'<private/android_filesystem_config.h>', '"generated_oem_aid.h"'
]
_DEFINE_NO_DIRS = '#define NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_DIRS'
_DEFINE_NO_FILES = '#define NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_FILES'
_DEFAULT_WARNING = (
'#warning No device-supplied android_filesystem_config.h,'
' using empty default.')
_OPEN_FILE_STRUCT = (
'static const struct fs_path_config android_device_files[] = {')
_OPEN_DIR_STRUCT = (
'static const struct fs_path_config android_device_dirs[] = {')
_CLOSE_FILE_STRUCT = '};'
_GENERIC_DEFINE = "#define %s\t%s"
_FILE_COMMENT = '// Defined in file: \"%s\"'
def __init__(self, *args, **kwargs):
BaseGenerator.__init__(args, kwargs)
self._oem_parser = None
self._base_parser = None
self._friendly_to_aid = None
self._id_to_aid = None
self._capability_parser = None
self._partition = None
self._all_partitions = None
self._out_file = None
self._generate_files = False
self._generate_dirs = False
def add_opts(self, opt_group):
@ -950,11 +970,56 @@ class FSConfigGen(BaseGenerator):
help='An android_filesystem_config.h file'
' to parse AIDs and OEM Ranges from')
opt_group.add_argument(
'--capability-header',
required=True,
help='A capability.h file to parse capability defines from')
opt_group.add_argument(
'--partition',
required=True,
help='Partition to generate contents for')
opt_group.add_argument(
'--all-partitions',
help='Comma separated list of all possible partitions, used to'
' ignore these partitions when generating the output for the system partition'
)
opt_group.add_argument(
'--files', action='store_true', help='Output fs_config_files')
opt_group.add_argument(
'--dirs', action='store_true', help='Output fs_config_dirs')
opt_group.add_argument('--out_file', required=True, help='Output file')
def __call__(self, args):
self._capability_parser = CapabilityHeaderParser(
args['capability_header'])
self._base_parser = AIDHeaderParser(args['aid_header'])
self._oem_parser = FSConfigFileParser(args['fsconfig'],
self._base_parser.oem_ranges)
self._partition = args['partition']
self._all_partitions = args['all_partitions']
if self._partition == 'system' and self._all_partitions is None:
sys.exit(
'All other partitions must be provided if generating output'
' for the system partition')
self._out_file = args['out_file']
self._generate_files = args['files']
self._generate_dirs = args['dirs']
if self._generate_files and self._generate_dirs:
sys.exit('Only one of --files or --dirs can be provided')
if not self._generate_files and not self._generate_dirs:
sys.exit('One of --files or --dirs must be provided')
base_aids = self._base_parser.aids
oem_aids = self._oem_parser.aids
@ -984,53 +1049,105 @@ class FSConfigGen(BaseGenerator):
self._friendly_to_aid = oem_friendly
self._friendly_to_aid.update(base_friendly)
self._id_to_aid = {aid.identifier: aid for aid in base_aids}
self._id_to_aid.update({aid.identifier: aid for aid in oem_aids})
self._generate()
def _to_fs_entry(self, fs_config):
def _to_fs_entry(self, fs_config, out_file):
"""Converts an FSConfig entry to an fs entry.
Prints '{ mode, user, group, caps, "path" },'.
Writes the fs_config contents to the output file.
Calls sys.exit() on error.
Args:
fs_config (FSConfig): The entry to convert to
a valid C array entry.
fs_config (FSConfig): The entry to convert to write to file.
file (File): The file to write to.
"""
# Get some short names
mode = fs_config.mode
user = fs_config.user
group = fs_config.group
fname = fs_config.filename
caps = fs_config.caps
path = fs_config.path
emsg = 'Cannot convert friendly name "%s" to identifier!'
emsg = 'Cannot convert "%s" to identifier!'
# remap friendly names to identifier names
# convert mode from octal string to integer
mode = int(mode, 8)
# remap names to values
if AID.is_friendly(user):
if user not in self._friendly_to_aid:
sys.exit(emsg % user)
user = self._friendly_to_aid[user].identifier
user = self._friendly_to_aid[user].value
else:
if user not in self._id_to_aid:
sys.exit(emsg % user)
user = self._id_to_aid[user].value
if AID.is_friendly(group):
if group not in self._friendly_to_aid:
sys.exit(emsg % group)
group = self._friendly_to_aid[group].identifier
group = self._friendly_to_aid[group].value
else:
if group not in self._id_to_aid:
sys.exit(emsg % group)
group = self._id_to_aid[group].value
fmt = '{ %s, %s, %s, %s, "%s" },'
caps_dict = self._capability_parser.caps
expanded = fmt % (mode, user, group, caps, path)
caps_value = 0
print FSConfigGen._FILE_COMMENT % fname
print ' ' + expanded
try:
# test if caps is an int
caps_value = int(caps, 0)
except ValueError:
caps_split = caps.split(',')
for cap in caps_split:
if cap not in caps_dict:
sys.exit('Unkonwn cap "%s" found!' % cap)
caps_value += 1 << caps_dict[cap]
@staticmethod
def _gen_inc():
"""Generate the include header lines and print to stdout."""
for include in FSConfigGen._INCLUDES:
print '#include %s' % include
path_length_with_null = len(path) + 1
path_length_aligned_64 = (path_length_with_null + 7) & ~7
# 16 bytes of header plus the path length with alignment
length = 16 + path_length_aligned_64
length_binary = bytearray(ctypes.c_uint16(length))
mode_binary = bytearray(ctypes.c_uint16(mode))
user_binary = bytearray(ctypes.c_uint16(int(user, 0)))
group_binary = bytearray(ctypes.c_uint16(int(group, 0)))
caps_binary = bytearray(ctypes.c_uint64(caps_value))
path_binary = ctypes.create_string_buffer(path,
path_length_aligned_64).raw
out_file.write(length_binary)
out_file.write(mode_binary)
out_file.write(user_binary)
out_file.write(group_binary)
out_file.write(caps_binary)
out_file.write(path_binary)
def _emit_entry(self, fs_config):
"""Returns a boolean whether or not to emit the input fs_config"""
path = fs_config.path
if self._partition == 'system':
for skip_partition in self._all_partitions.split(','):
if path.startswith(skip_partition) or path.startswith(
'system/' + skip_partition):
return False
return True
else:
if path.startswith(
self._partition) or path.startswith('system/' +
self._partition):
return True
return False
def _generate(self):
"""Generates an OEM android_filesystem_config.h header file to stdout.
@ -1041,50 +1158,20 @@ class FSConfigGen(BaseGenerator):
entries.
aids ([AIDS]): A list of AID objects for Android Id entries.
"""
print FSConfigGen._GENERATED
print
FSConfigGen._gen_inc()
print
dirs = self._oem_parser.dirs
files = self._oem_parser.files
aids = self._oem_parser.aids
are_dirs = len(dirs) > 0
are_files = len(files) > 0
are_aids = len(aids) > 0
if self._generate_files:
with open(self._out_file, 'wb') as open_file:
for fs_config in files:
if self._emit_entry(fs_config):
self._to_fs_entry(fs_config, open_file)
if are_aids:
for aid in aids:
# use the preserved _path value
print FSConfigGen._FILE_COMMENT % aid.found
print FSConfigGen._GENERIC_DEFINE % (aid.identifier, aid.value)
print
if not are_dirs:
print FSConfigGen._DEFINE_NO_DIRS + '\n'
if not are_files:
print FSConfigGen._DEFINE_NO_FILES + '\n'
if not are_files and not are_dirs and not are_aids:
return
if are_files:
print FSConfigGen._OPEN_FILE_STRUCT
for fs_config in files:
self._to_fs_entry(fs_config)
print FSConfigGen._CLOSE_FILE_STRUCT
if are_dirs:
print FSConfigGen._OPEN_DIR_STRUCT
for dir_entry in dirs:
self._to_fs_entry(dir_entry)
print FSConfigGen._CLOSE_FILE_STRUCT
if self._generate_dirs:
with open(self._out_file, 'wb') as open_file:
for dir_entry in dirs:
if self._emit_entry(dir_entry):
self._to_fs_entry(dir_entry, open_file)
@generator('aidarray')

187
tools/fs_config/fs_config_test.cpp
View File

@ -1,187 +0,0 @@
/*
* Copyright (C) 2017 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.
*/
#include <stdio.h>
#include <sys/cdefs.h>
#include <string>
#include <vector>
#include <android-base/file.h>
#include <android-base/macros.h>
#include <android-base/strings.h>
#include <gtest/gtest.h>
#include <private/android_filesystem_config.h>
#include <private/fs_config.h>
#include "android_filesystem_config_test_data.h"
// must run test in the test directory
static const std::string fs_config_generate_command = "./fs_config_generate_test";
static std::string popenToString(const std::string command) {
std::string ret;
auto fp = popen(command.c_str(), "r");
if (fp) {
if (!android::base::ReadFdToString(fileno(fp), &ret)) ret = "";
pclose(fp);
}
return ret;
}
static void confirm(std::string&& data, const fs_path_config* config,
ssize_t num_config) {
auto pc = reinterpret_cast<const fs_path_config_from_file*>(data.c_str());
auto len = data.size();
ASSERT_TRUE(config != NULL);
ASSERT_LT(0, num_config);
while (len > 0) {
auto host_len = pc->len;
if (host_len > len) break;
EXPECT_EQ(config->mode, pc->mode);
EXPECT_EQ(config->uid, pc->uid);
EXPECT_EQ(config->gid, pc->gid);
EXPECT_EQ(config->capabilities, pc->capabilities);
EXPECT_STREQ(config->prefix, pc->prefix);
EXPECT_LT(0, num_config);
--num_config;
if (num_config >= 0) ++config;
pc = reinterpret_cast<const fs_path_config_from_file*>(
reinterpret_cast<const char*>(pc) + host_len);
len -= host_len;
}
EXPECT_EQ(0, num_config);
}
/* See local android_filesystem_config.h for test data */
TEST(fs_conf_test, dirs) {
confirm(popenToString(fs_config_generate_command + " -D"),
android_device_dirs, arraysize(android_device_dirs));
}
TEST(fs_conf_test, files) {
confirm(popenToString(fs_config_generate_command + " -F"),
android_device_files, arraysize(android_device_files));
}
static bool is_system(const char* prefix) {
return !android::base::StartsWith(prefix, "vendor/") &&
!android::base::StartsWith(prefix, "system/vendor/") &&
!android::base::StartsWith(prefix, "oem/") &&
!android::base::StartsWith(prefix, "system/oem/") &&
!android::base::StartsWith(prefix, "odm/") &&
!android::base::StartsWith(prefix, "system/odm/") &&
!android::base::StartsWith(prefix, "product/") &&
!android::base::StartsWith(prefix, "system/product/") &&
!android::base::StartsWith(prefix, "product_services/") &&
!android::base::StartsWith(prefix, "system/product_services/");
}
TEST(fs_conf_test, system_dirs) {
std::vector<fs_path_config> dirs;
auto config = android_device_dirs;
for (auto num = arraysize(android_device_dirs); num; --num) {
if (is_system(config->prefix)) {
dirs.emplace_back(*config);
}
++config;
}
confirm(popenToString(fs_config_generate_command + " -D -P -vendor,-oem,-odm,-product,-product_services"),
&dirs[0], dirs.size());
}
static void fs_conf_test_dirs(const std::string& partition_name) {
std::vector<fs_path_config> dirs;
auto config = android_device_dirs;
const auto str = partition_name + "/";
const auto alt_str = "system/" + partition_name + "/";
for (auto num = arraysize(android_device_dirs); num; --num) {
if (android::base::StartsWith(config->prefix, str) ||
android::base::StartsWith(config->prefix, alt_str)) {
dirs.emplace_back(*config);
}
++config;
}
confirm(popenToString(fs_config_generate_command + " -D -P " + partition_name),
&dirs[0], dirs.size());
}
TEST(fs_conf_test, vendor_dirs) {
fs_conf_test_dirs("vendor");
}
TEST(fs_conf_test, oem_dirs) {
fs_conf_test_dirs("oem");
}
TEST(fs_conf_test, odm_dirs) {
fs_conf_test_dirs("odm");
}
TEST(fs_conf_test, system_files) {
std::vector<fs_path_config> files;
auto config = android_device_files;
for (auto num = arraysize(android_device_files); num; --num) {
if (is_system(config->prefix)) {
files.emplace_back(*config);
}
++config;
}
confirm(popenToString(fs_config_generate_command + " -F -P -vendor,-oem,-odm,-product,-product_services"),
&files[0], files.size());
}
static void fs_conf_test_files(const std::string& partition_name) {
std::vector<fs_path_config> files;
auto config = android_device_files;
const auto str = partition_name + "/";
const auto alt_str = "system/" + partition_name + "/";
for (auto num = arraysize(android_device_files); num; --num) {
if (android::base::StartsWith(config->prefix, str) ||
android::base::StartsWith(config->prefix, alt_str)) {
files.emplace_back(*config);
}
++config;
}
confirm(popenToString(fs_config_generate_command + " -F -P " + partition_name),
&files[0], files.size());
}
TEST(fs_conf_test, vendor_files) {
fs_conf_test_files("vendor");
}
TEST(fs_conf_test, oem_files) {
fs_conf_test_files("oem");
}
TEST(fs_conf_test, odm_files) {
fs_conf_test_files("odm");
}
TEST(fs_conf_test, product_files) {
fs_conf_test_files("product");
}
TEST(fs_conf_test, product_services_files) {
fs_conf_test_files("product_services");
}

4
tools/fs_config/test_fs_config_generator.py
View File

@ -277,11 +277,11 @@ class Tests(unittest.TestCase):
self.assertEqual(fcap,
FSConfig('0777', 'AID_FOO', 'AID_SYSTEM',
'CAP_MASK_LONG(CAP_BLOCK_SUSPEND)',
'CAP_BLOCK_SUSPEND',
'/system/bin/file', temp_file.name))
self.assertEqual(dcap,
FSConfig('0777', 'AID_FOO', 'AID_SYSTEM', '(0)',
FSConfig('0777', 'AID_FOO', 'AID_SYSTEM', '0',
'/vendor/path/dir/', temp_file.name))
self.assertEqual(aid, AID('AID_OEM1', '0x1389', temp_file.name, '/vendor/bin/sh'))