From 9d924f67d3a16c45d439e1c8d284e441e8041406 Mon Sep 17 00:00:00 2001 From: Tom Cherry Date: Wed, 13 Feb 2019 14:02:30 -0800 Subject: [PATCH] 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 --- tools/fs_config/Android.bp | 40 --- tools/fs_config/Android.mk | 245 ++++++++++------ .../android_filesystem_config_test_data.h | 64 ----- .../default/android_filesystem_config.h | 37 --- tools/fs_config/end_to_end_test/config.fs | 108 +++++++ .../end_to_end_test/product_fs_config_dirs | Bin 0 -> 72 bytes .../end_to_end_test/product_fs_config_files | Bin 0 -> 128 bytes tools/fs_config/end_to_end_test/run_test.sh | 76 +++++ .../end_to_end_test/system_fs_config_dirs | Bin 0 -> 64 bytes .../end_to_end_test/system_fs_config_files | Bin 0 -> 72 bytes .../end_to_end_test/vendor_fs_config_dirs | Bin 0 -> 72 bytes .../end_to_end_test/vendor_fs_config_files | Bin 0 -> 128 bytes tools/fs_config/fs_config_generate.c | 213 -------------- tools/fs_config/fs_config_generator.py | 267 ++++++++++++------ tools/fs_config/fs_config_test.cpp | 187 ------------ tools/fs_config/test_fs_config_generator.py | 4 +- 16 files changed, 518 insertions(+), 723 deletions(-) delete mode 100644 tools/fs_config/android_filesystem_config_test_data.h delete mode 100644 tools/fs_config/default/android_filesystem_config.h create mode 100644 tools/fs_config/end_to_end_test/config.fs create mode 100644 tools/fs_config/end_to_end_test/product_fs_config_dirs create mode 100644 tools/fs_config/end_to_end_test/product_fs_config_files create mode 100755 tools/fs_config/end_to_end_test/run_test.sh create mode 100644 tools/fs_config/end_to_end_test/system_fs_config_dirs create mode 100644 tools/fs_config/end_to_end_test/system_fs_config_files create mode 100644 tools/fs_config/end_to_end_test/vendor_fs_config_dirs create mode 100644 tools/fs_config/end_to_end_test/vendor_fs_config_files delete mode 100644 tools/fs_config/fs_config_generate.c delete mode 100644 tools/fs_config/fs_config_test.cpp diff --git a/tools/fs_config/Android.bp b/tools/fs_config/Android.bp index 797cfe228..19a4624d9 100644 --- a/tools/fs_config/Android.bp +++ b/tools/fs_config/Android.bp @@ -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"], -} diff --git a/tools/fs_config/Android.mk b/tools/fs_config/Android.mk index 4cff846ec..0e0b1dafb 100644 --- a/tools/fs_config/Android.mk +++ b/tools/fs_config/Android.mk @@ -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 := diff --git a/tools/fs_config/android_filesystem_config_test_data.h b/tools/fs_config/android_filesystem_config_test_data.h deleted file mode 100644 index c65d40682..000000000 --- a/tools/fs_config/android_filesystem_config_test_data.h +++ /dev/null @@ -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 - -/* 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"}, -}; diff --git a/tools/fs_config/default/android_filesystem_config.h b/tools/fs_config/default/android_filesystem_config.h deleted file mode 100644 index b7d936a7a..000000000 --- a/tools/fs_config/default/android_filesystem_config.h +++ /dev/null @@ -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 */ diff --git a/tools/fs_config/end_to_end_test/config.fs b/tools/fs_config/end_to_end_test/config.fs new file mode 100644 index 000000000..339e5aef8 --- /dev/null +++ b/tools/fs_config/end_to_end_test/config.fs @@ -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 diff --git a/tools/fs_config/end_to_end_test/product_fs_config_dirs b/tools/fs_config/end_to_end_test/product_fs_config_dirs new file mode 100644 index 0000000000000000000000000000000000000000..e69ad65d52d5cf42db661b0113e53381b3ca7794 GIT binary patch literal 72 tcmY#jc+2>L`2{lr6ciNYr<5j_=%-{B>4Stc(Bz9Ni%U{-_0g3v0051Y5#ay; literal 0 HcmV?d00001 diff --git a/tools/fs_config/end_to_end_test/product_fs_config_files b/tools/fs_config/end_to_end_test/product_fs_config_files new file mode 100644 index 0000000000000000000000000000000000000000..376a2a6b819e657bc1fb5aff90f5302fb4868035 GIT binary patch literal 128 zcmdO3c+2>L`318H0|XQl<)@S;m*^*D=IIxw7L{ctry7D}G@$AjSQr>MfP5_Kj6muP U(9{)I7MG;v>SIxE3{uVj0MFMW9smFU literal 0 HcmV?d00001 diff --git a/tools/fs_config/end_to_end_test/run_test.sh b/tools/fs_config/end_to_end_test/run_test.sh new file mode 100755 index 000000000..74022766c --- /dev/null +++ b/tools/fs_config/end_to_end_test/run_test.sh @@ -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 diff --git a/tools/fs_config/end_to_end_test/system_fs_config_dirs b/tools/fs_config/end_to_end_test/system_fs_config_dirs new file mode 100644 index 0000000000000000000000000000000000000000..3a95e40f4929efb017778497264a68aa7d5a83c2 GIT binary patch literal 64 qcmY#jc+2>L`6V+06ckq$m!#(Er(_oCgGCh3L`6V+06cpv>m&B)K=A=UT8Zdblh(K{=aY<^feo|(hesOA1S!Oa+Apm3~ B5XS%j literal 0 HcmV?d00001 diff --git a/tools/fs_config/end_to_end_test/vendor_fs_config_dirs b/tools/fs_config/end_to_end_test/vendor_fs_config_dirs new file mode 100644 index 0000000000000000000000000000000000000000..02dded79e4dc73c44a63885f3f444167e5143991 GIT binary patch literal 72 tcmY#jc*_{Z{eqbR3d&ORQu2%RQ!L`2{m0g8~pTFceo7m!#(Em!;;VlS7sib+7gL=PSRDYCCLrhl literal 0 HcmV?d00001 diff --git a/tools/fs_config/fs_config_generate.c b/tools/fs_config/fs_config_generate.c deleted file mode 100644 index dddd33174..000000000 --- a/tools/fs_config/fs_config_generate.c +++ /dev/null @@ -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 -#include -#include -#include -#include -#include - -#include - -/* - * This program expects android_device_dirs and android_device_files - * to be defined in the supplied android_filesystem_config.h file in - * the device// $(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" - "/ or system//\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 / or /system// */ - 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; -} diff --git a/tools/fs_config/fs_config_generator.py b/tools/fs_config/fs_config_generator.py index 18e6534c4..dccff928f 100755 --- a/tools/fs_config/fs_config_generator.py +++ b/tools/fs_config/fs_config_generator.py @@ -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_. + """ + + _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 = [ - '', '"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') diff --git a/tools/fs_config/fs_config_test.cpp b/tools/fs_config/fs_config_test.cpp deleted file mode 100644 index 916c615e2..000000000 --- a/tools/fs_config/fs_config_test.cpp +++ /dev/null @@ -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 -#include - -#include -#include - -#include -#include -#include -#include -#include -#include - -#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(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( - reinterpret_cast(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 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 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 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 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"); -} diff --git a/tools/fs_config/test_fs_config_generator.py b/tools/fs_config/test_fs_config_generator.py index 0bc5a809b..b7f173eb9 100755 --- a/tools/fs_config/test_fs_config_generator.py +++ b/tools/fs_config/test_fs_config_generator.py @@ -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'))