Les objets et services de système de fichiers ajoutés à la compilation ont souvent besoin des identifiants uniques, appelés identifiants Android (AID). Actuellement, de nombreuses ressources telles que les fichiers et les services utilisent inutilement des AID principaux (définis par Android) ; dans de nombreux vous pouvez utiliser les AID OEM (définis par l'OEM) à la place.
Les versions antérieures d'Android (Android 7.x et versions antérieures) étendaient les AID.
mécanisme à l'aide d'un android_filesystem_config.h spécifique à l'appareil
pour spécifier les capacités du système de fichiers et/ou les AID OEM personnalisés. Toutefois,
n'était pas intuitif, car il ne permettait pas d'utiliser de jolis noms pour les AID OEM,
vous obligeant à spécifier les valeurs numériques brutes pour les champs des utilisateurs et des groupes
moyen d'associer un nom convivial
à l'AID numérique.
Les versions plus récentes d'Android (Android 8.0 et versions ultérieures) prennent en charge une nouvelle méthode pour étendant les capacités des systèmes de fichiers. Cette nouvelle méthode est compatible avec suivantes:
- Plusieurs emplacements sources pour les fichiers de configuration configurations de compilation).
- Contrôle d'intégrité des valeurs d'AID OEM au moment de la compilation.
- Génération d'un en-tête d'AID OEM personnalisé pouvant être utilisé dans les fichiers sources en tant que nécessaires.
- Association d'un nom descriptif à la valeur réelle de l'AID OEM. Compatible Arguments de chaîne non numériques pour l'utilisateur et le groupe (par exemple, "foo") au lieu de « 2901 ».
Parmi les autres améliorations, citons la suppression de android_ids[].
d'un tableau
system/core/libcutils/include/private/android_filesystem_config.h Ce
existe désormais dans Bionic en tant que tableau généré entièrement privé, avec
des accesseurs avec getpwnam() et getgrnam(). (Il s'agit
l'effet secondaire de la production de binaires stables lors de la modification des AID principaux.) Pour
et un fichier README avec plus de détails, reportez-vous à
build/make/tools/fs_config
Ajouter des ID Android (AID)
Android 8.0 a supprimé le tableau android_ids[] de l'application Android
Projet Open Source (AOSP). Tous les noms compatibles avec les AID sont générés à partir de
l'/le/la system/core/libcutils/include/private/android_filesystem_config.h
lors de la génération du tableau android_ids[] Bionic. N'importe quelle valeur
Les define correspondant à AID_* sont récupérés par les outils.
et * devient le nom en minuscules.
Par exemple, dans private/android_filesystem_config.h:
#define AID_SYSTEM 1000
Devient:
- Nom descriptif: système
- uid: 1000
- gid: 1000
Pour ajouter un AID principal AOSP, il vous suffit d'ajouter #define au
android_filesystem_config.h. L'AID est
générées lors de la compilation et mises à la disposition des interfaces qui utilisent des groupes
. L'outil vérifie que le nouvel AID ne figure pas dans l'APP ou l'OEM.
plages ; les modifications apportées à ces plages
sont également prises en compte,
à reconfigurer en cas de modifications ou de nouvelles plages réservées par l'OEM.
Configurer les AID
Pour activer le nouveau mécanisme des AID, définissez TARGET_FS_CONFIG_GEN dans
BoardConfig.mk. Cette variable contient une liste de configurations
, ce qui vous permet d'ajouter des fichiers selon vos besoins.
Par convention, les fichiers de configuration utilisent le nom config.fs, mais dans
pratique, vous pouvez
utiliser n’importe quel nom. config.fs fichiers se trouvent dans
Python
Format INI ConfigParser et inclure une section en majuscules (pour configurer des
capacités système) et une section sur les AID (pour configurer les AID OEM).
Configurer la section des majuscules
<ph type="x-smartling-placeholder">La section des majuscules permet de définir fichier les fonctionnalités système sur les objets de système de fichiers de la compilation (le système de fichiers doivent également être compatibles avec cette fonctionnalité).
L'exécution d'un service stable en mode root sur Android entraîne
Compatibility Test Suite (CTS)
les exigences précédentes pour conserver une capacité lors de l'exécution
processus ou service implique la configuration de fonctionnalités, puis l'utilisation
setuid/setgid à un AID approprié pour qu'il s'exécute. Avec les majuscules, vous
peuvent ignorer ces exigences
et laisser le noyau le faire pour vous. Lorsque le contrôle est
transmis à main(), votre processus dispose déjà des capacités nécessaires
pour que votre service puisse utiliser un utilisateur et un groupe non racine (il s'agit
moyen de démarrer des services privilégiés).
La section caps utilise la syntaxe suivante:
| Section | Valeur | Définition |
|---|---|---|
[path] |
Chemin d'accès au système de fichiers à configurer. Un chemin d'accès se terminant par / est considéré comme un dir,
sinon il s'agit d'un fichier.
Si vous spécifiez plusieurs sections avec la même [path] dans des fichiers différents. Dans les versions 3.2 et ultérieures de Python, le
même fichier peut contenir des sections qui remplacent la section précédente ; en Python
3.2, il est défini en mode strict. |
|
mode |
Mode de fichier octal | Mode de fichier octal valide d'au moins trois chiffres. Si 3 est spécifié, il est précédé d'un 0, sinon le mode est utilisé tel quel. |
user |
AID_<utilisateur> | Soit le C define pour indiquer un AID valide, soit le nom descriptif
(par exemple, AID_RADIO et radio sont acceptés). À
définir un AID personnalisé, reportez-vous à la section Configurer
la section sur les AID. |
group |
AID_<groupe> | Identique à l'utilisateur. |
caps |
casquette* | Le nom tel qu'il est déclaré dans
bionic/libc/kernel/uapi/linux/capability.h
sans la balise CAP_ initiale. Vous pouvez utiliser plusieurs majuscules et minuscules. Les majuscules peuvent également être
les valeurs brutes:
<ph type="x-smartling-placeholder">
|
Pour obtenir un exemple d'utilisation, consultez la section Utilisation des fichiers fonctionnalités système.
Configurer la section AID
La section AID contient les AID OEM et utilise la syntaxe suivante:
| Section | Valeur | Définition |
|---|---|---|
[AID_<name>] |
<name> peut contenir des caractères du jeu de caractères
majuscules, chiffres et traits de soulignement. La version minuscule est utilisée
nom convivial. Le fichier d'en-tête généré pour l'inclusion du code utilise la syntaxe
AID_<name>
Si vous spécifiez plusieurs sections avec la même AID_<name> (non sensible à la casse avec les mêmes contraintes que
[path]).
<name> doit commencer par un nom de partition pour garantir
qu'il n'entre pas en conflit avec d'autres sources. |
|
value |
<nombre> | Une chaîne numérique de style C valide (hexadécimal, octal, binaire et décimal).
Spécifier plusieurs sections avec la même option de valeur est une erreur. Les options de valeur doivent être spécifiées dans la plage correspondant à la partition utilisée dans <name>. La liste des partitions valides et leurs
est définie dans system/core/libcutils/include/private/android_filesystem_config.h.
Les options sont les suivantes:
<ph type="x-smartling-placeholder">
|
Pour obtenir des exemples d'utilisation, consultez la page Définir un OEM Noms des AID et Utiliser les AID OEM
Exemples d'utilisation
Les exemples suivants expliquent comment définir et utiliser un AID OEM activer les fonctionnalités du système de fichiers. Noms des AID OEM ([AID_name]) doit commencer par un nom de partition tel que vendor_" pour s'assurer qu'elles n'entrent pas en conflit les noms AOSP ou d'autres partitions.
Définir les noms des AID OEM
Pour définir un AID OEM, créez un fichier config.fs et définissez
la valeur de l'AID. Par exemple, dans device/x/y/config.fs, définissez le
suivantes:
[AID_VENDOR_FOO] value: 2900
Après avoir créé le fichier, définissez la variable TARGET_FS_CONFIG_GEN
et pointez dessus dans BoardConfig.mk. Par exemple, dans
device/x/y/BoardConfig.mk, définissez les valeurs suivantes:
TARGET_FS_CONFIG_GEN += device/x/y/config.fs
Votre AID personnalisé peut désormais être utilisé par le système dans son ensemble sur une nouvelle version.
Utiliser les AID OEM
Pour utiliser un AID OEM, dans votre code C, incluez oemaids_headers dans vos
Makefile, ajoutez #include "generated_oem_aid.h", puis commencez à utiliser le fichier
identifiants. Par exemple, dans my_file.c, ajoutez le code suivant:
#include "generated_oem_aid.h"
…
If (ipc->uid == AID_VENDOR_FOO) {
// Do something
...
Dans le fichier Android.bp associé, ajoutez ce qui suit:
header_libs: ["oemaids_headers"],
Si vous utilisez un fichier Android.mk, ajoutez les éléments suivants:
LOCAL_HEADER_LIBRARIES := oemaids_headers
Utilisez des noms descriptifs
Sous Android 9, vous pouvez utiliser le nom descriptif pour toutes qui prend en charge les noms AID. Exemple :
- Dans une commande
chowndesome/init.rc:chown vendor_foo /vendor/some/vendor_foo/file
- Dans une
servicedesome/init.rc:service vendor_foo /vendor/bin/foo_service user vendor_foo group vendor_foo
Comme le mappage interne du nom
à l'UID est effectué par
/vendor/etc/passwd et /vendor/etc/group, le fournisseur
doit être installée.
Associez des noms explicites
Android 9 permet d'associer un avec la valeur réelle de l'AID de l'OEM. Vous pouvez utiliser une chaîne non numérique des arguments pour l'utilisateur et le groupe, à savoir "vendor_foo" au lieu de « 2901 ».
Convertir des AID en noms descriptifs
Pour
AID OEM, Android 8.x nécessitait l'utilisation
oem_#### avec getpwnam et des fonctions similaires, comme
aux emplacements qui gèrent les recherches avec getpwnam (comme
init). Sous Android 9, vous pouvez :
utiliser les amis getpwnam et getgrnam dans Bionic pour
convertir des ID Android (AID) en noms conviviaux, et inversement.
Utiliser les fonctionnalités du système de fichiers
Pour activer les fonctionnalités du système de fichiers, créez une section des majuscules dans le fichier
config.fs. Par exemple, dans
device/x/y/config.fs, ajoutez la section suivante:
[system/bin/foo_service] mode: 0555 user: AID_VENDOR_FOO group: AID_SYSTEM caps: SYS_ADMIN | SYS_NICE<ph type="x-smartling-placeholder">
Après avoir créé le fichier, définissez TARGET_FS_CONFIG_GEN pour qu'il pointe vers
ce fichier dans BoardConfig.mk. Par exemple, dans
device/x/y/BoardConfig.mk, définissez les valeurs suivantes:
TARGET_FS_CONFIG_GEN += device/x/y/config.fs
Lorsque le service vendor_foo est exécuté, il démarre
avec les capacités CAP_SYS_ADMIN et CAP_SYS_NICE
sans les appels setuid et setgid. De plus, le
La règle SELinux du service vendor_foo n'est plus
requiert les capacités setuid et setgid, et peut être
supprimés.
Configurer les forçages (Android 6.x à 7.x)
Android 6.0 a déplacé fs_config et la structure associée
définitions
(system/core/include/private/android_filesystem_config.h) jusqu'à
system/core/libcutils/fs_config.c pour lesquelles ils peuvent être mis à jour
remplacés par des fichiers binaires installés dans
/system/etc/fs_config_dirs et
/system/etc/fs_config_files Utiliser la mise en correspondance et l'analyse séparées
des règles pour les répertoires et les fichiers (pouvant utiliser des expressions glob supplémentaires)
a permis à Android de gérer les répertoires et
les fichiers dans deux tables différentes.
Les définitions de structure en system/core/libcutils/fs_config.c ne sont pas
n'autorisait que la lecture à l'exécution des répertoires et des fichiers, mais l'hôte pouvait utiliser
les mêmes fichiers pendant la compilation pour construire des images de système de fichiers
${OUT}/system/etc/fs_config_dirs et
${OUT}/system/etc/fs_config_files
Alors que la méthode de forçage consistant à étendre le système de fichiers a été remplacée par le système de configuration modulaire introduit dans Android 8.0, vous pouvez toujours utiliser l'ancienne si vous le souhaitez. Les sections suivantes expliquent en détail comment générer et inclure de remplacer les fichiers et de configurer le système de fichiers.
Générer des fichiers de remplacement
Vous pouvez générer les fichiers binaires alignés
/system/etc/fs_config_dirs et
/system/etc/fs_config_files à l'aide de
fs_config_generate dans build/tools/fs_config. La
L'outil utilise une fonction de bibliothèque libcutils
(fs_config_generate()) pour gérer les exigences DAC dans une mémoire tampon
et définit des règles pour un fichier d'inclusion
afin d'institutionnaliser les règles DAC.
Pour l'utiliser, créez un fichier d'inclusion dans
device/vendor/device/android_filesystem_config.h
qui sert de forçage. Le fichier doit utiliser la méthode
Format structure fs_path_config défini dans
system/core/include/private/android_filesystem_config.h avec le
Initialisations de structure suivantes pour les symboles de répertoire et de fichier:
- Pour les répertoires, utilisez
android_device_dirs[]. - Pour les fichiers, utilisez
android_device_files[].
Lorsque vous n'utilisez pas android_device_dirs[] et
android_device_files[], vous pouvez définir
NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_DIRS et
NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_FILES (consultez les
exemple ci-dessous). Vous pouvez également spécifier le forçage
fichier utilisant TARGET_ANDROID_FILESYSTEM_CONFIG_H dans le tableau
configuration, avec le nom de base appliqué
android_filesystem_config.h
Inclure les fichiers de remplacement
Pour inclure des fichiers, assurez-vous que PRODUCT_PACKAGES inclut
fs_config_dirs et/ou fs_config_files pour qu'il puisse
installez-les dans /system/etc/fs_config_dirs et
/system/etc/fs_config_files, respectivement. Système de compilation
recherches de android_filesystem_config.h personnalisé dans
$(TARGET_DEVICE_DIR), où BoardConfig.mk existe.
Si ce fichier se trouve à un autre endroit, définir la variable de configuration de la carte
TARGET_ANDROID_FILESYSTEM_CONFIG_H pour pointer vers cet emplacement.
Configurer le système de fichiers
Pour configurer le système de fichiers sous Android 6.0 ou version ultérieure:
- Créer le
$(TARGET_DEVICE_DIR)/android_filesystem_config.h. - Ajoutez
fs_config_dirset/oufs_config_filesàPRODUCT_PACKAGESdans le fichier de configuration du tableau (par exemple,$(TARGET_DEVICE_DIR)/device.mk).
Exemple de remplacement
Cet exemple présente un correctif permettant de remplacer system/bin/glgps
pour ajouter la prise en charge des wakelocks
device/vendor/device. Gardez le
à l'esprit ce qui suit:
- Chaque entrée de structure correspond au mode, à l'UID, au gid, aux capacités et au nom.
system/core/include/private/android_filesystem_config.hcorrespond à inclus automatiquement pour fournir le fichier manifeste # (AID_ROOT,AID_SHELL,CAP_BLOCK_SUSPEND). - La section
android_device_files[]inclut une action permettant supprimer l'accès àsystem/etc/fs_config_dirslorsqu'il n'est pas spécifié, qui sert de protection supplémentaire DAC en cas de manque de contenu pour l'annuaire et les forçages. Cependant, cette protection est faible. si quelqu'un contrôle/system, ils peuvent généralement faire ce qu'ils veulent.
diff --git a/android_filesystem_config.h b/android_filesystem_config.h
new file mode 100644
index 0000000..874195f
--- /dev/null
+++ b/android_filesystem_config.h
@@ -0,0 +1,36 @@
+/*
+ * 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 define the properties of the file system
+** images generated by build tools (eg: mkbootfs) and
+** by the device side of adb.
+*/
+
+#define NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_DIRS
+/* static const struct fs_path_config android_device_dirs[] = { }; */
+
+/* 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.
+*/
+static const struct fs_path_config android_device_files[] = {
+ { 00755, AID_ROOT, AID_SHELL, (1ULL << CAP_BLOCK_SUSPEND),
"system/bin/glgps" },
+#ifdef NO_ANDROID_FILESYSTEM_CONFIG_DEVICE_DIRS
+ { 00000, AID_ROOT, AID_ROOT, 0, "system/etc/fs_config_dirs" },
+#endif
+};
diff --git a/device.mk b/device.mk
index 0c71d21..235c1a7 100644
--- a/device.mk
+++ b/device.mk
@@ -18,7 +18,8 @@ PRODUCT_PACKAGES := \
libwpa_client \
hostapd \
wpa_supplicant \
- wpa_supplicant.conf
+ wpa_supplicant.conf \
+ fs_config_files
ifeq ($(TARGET_PREBUILT_KERNEL),)
ifeq ($(USE_SVELTE_KERNEL), true)
Migrer des systèmes de fichiers à partir de versions antérieures
Lorsque vous migrez des systèmes de fichiers à partir d'Android 5.x ou version antérieure, gardez à l'esprit que Android 6.x
- Supprime certaines inclusions, structures et définitions intégrées.
- Nécessite une référence à
libcutilsau lieu de s'exécuter directement desystem/core/include/private/android_filesystem_config.h. Exécutables privés du fabricant de l’appareil qui dépendent desystem/code/include/private_filesystem_config.hpour le fichier ou structures de répertoires oufs_configdoit ajouterlibcutilsles dépendances de bibliothèque. - Nécessite une copie des branches privées du fabricant de l'appareil
system/core/include/private/android_filesystem_config.havec du contenu supplémentaire sur les cibles existantes vers lequel déplacerdevice/vendor/device/android_filesystem_config.h - Se réserve le droit d'appliquer les contrôles d'accès obligatoires SELinux aux éléments suivants :
des fichiers de configuration sur le système cible, les implémentations incluant
Les exécutables cibles utilisant
fs_config()doivent garantir l'accès.