Construction du noyau

Cette section explique comment configurer la source de l’appareil, configurer la deviceinfo et le noyau, et le construire. Ce guide s’attend à ce que vous ayez une certaine connaissance de git , comme le clonage et la poussée, et la création de dépôt.

Configuration de votre environnement de construction

En supposant que vous avez déjà installé les outils spécifiés dans la section sur Configuration de l’environnement de construction, il y a juste quelques autres à ajouter avant que votre environnement de construction soit complet. Exécutez cette commande pour les ajouter :

sudo apt install bc bison build-essential \
ca-certificates cpio curl flex git kmod libssl-dev libtinfo5 python2 \
sudo unzip wget xz-utils img2simg jq

Si vous utilisez une distro basée sur RPM comme Mageia, vous lancerez :

sudo urpmi gcc make glibc-devel bc bison \
rootcerts cpio curl flex git kmod libopenssl-devel libncurses5 python3 \
unzip wget xz android-tools jq

Note

Certains noyaux plus anciens peuvent nécessiter Python 2 pour construire. Si votre distribution a abandonné Python 2, vous pouvez avoir besoin de l’installer manuellement.

Préparation et configuration d’une source d’appareil

Création de la source d’appareil

Clonez un dépôt à partir d’un équipement existant dans https://gitlab.com/ubports/porting. Idéalement choisissez un appareil ayant une version SoC/Android similaire comme base.

Assurez-vous d’obtenir le dépôt de l’appareil, pas le dépôt du noyau (vous l’obtiendrez dans la prochaine étape). Par exemple, pour le Fairphone 3, les dépôts sont appelés fairphone-fp3 et android_kernel_fairphone_sdm632.` Le premier est celui que vous voulez.

deviceinfo contient la configuration utilisée lors du processus de construction de périphérique (kernel, boot, dtb/dtbo si nécessaire + récupération sur les étapes de portage ultérieures). Pour réaliser votre propre deviceinfo, suivez le guide plus loin.

Obtenir le code source du noyau de l’appareil

La première chose à vérifier est si votre appareil a un port officiel ou non officiel LineageOS, car le porteur peut avoir déjà fait le nettoyage nécessaire des sources du noyau du fournisseur de périphérique ou incorporé des modules du noyau externes dans l’arbre du noyau, ce qui rend la vie plus facile pour nous.

Si ce n’est pas le cas, vérifiez si le fabricant de périphériques fournit le source du noyau : ASUS, Lenovo, Samsung, ZTE fournissent généralement des paquets de code source du noyau sur leur site Web. Motorola, Realme, OnePlus, Xiaomi mettent habituellement la source du noyau sur leur compte officiel GitHub.

Après avoir récupéré les sources du noyau, vous devez le téléverser ailleurs pour faire des modifications et des validations pour Ubuntu Touch. GitLab est préféré puisque lorsque vous obtiendrez le port installé dans l’organisation UBports, il peut être facilement copié à partir de là.

Vous devriez maintenant travailler avec deux dépôts : un dépôt d’appareil cloné, qui contient deviceinfo, et un dépôt de noyau, qui maintient / contiendra votre defconfig (voir ci-dessous).

Trouver la configuration correcte du noyau

Il y a deux façons de trouver votre configuration correcte du noyau, dont quelques-uns ci-dessous : 1. Obtenir votre configuration des périphérique à partir de /proc/config.gz 2. Obtenir votre defconfig dans la source du noyau

Obtenir votre configuration de l’appareil

Il est possible d’obtenir votre configuration actuelle du noyau depuis le périphérique, si la configuration est présente comme /proc/config.gz sur le périphérique. Pour la récupérer, copiez le fichier /proc/config.gz de votre appareil vers votre ordinateur. Ensuite, lancez zcat sur le fichier pour obtenir sa sortie. Gardez ceci comme .config dans votre source de noyau. Après cela, exécutez ARCH=<architecture de votre appareil> make savedefconfig, qui convertira votre config entièrement en une defconfig. Copier defconfig vers arch/<architecture de votre appareil>/configs/<your device's codename_defconfig.

Continuer à suivre le guide pour corriger votre configuration.

Mettre votre defconfig dans la source du noyau

Afin de trouver votre defconfig à partir de les sources du noyau, vous devrez le rechercher dans le répertoire arch/<architecture de votre appareil/configs. Ce defconfig peut être nommé de plusieurs façons, comme le code de <nom de code de votre appareil>_defconfig, ou quelque chose de bizarre comme k61v64_debug_defconfig. Si vous avez obtenu votre source de noyau d’un OEM, il comprend parfois un script build.sh qui référence le defconfig requis. Sinon, si vous avez votre source de noyau d’un endroit comme LineageOS, leur arbre de périphérique fait référence à la defconfig.

Après avoir trouvé votre defconfig, procédez avec le guide pour le patcher.

Appliquer des patchs minima à votre defconfig

Pour que Ubuntu Touch puisse démarrer avec succès, nous devons activer certaines configurations requises par l’OS. Commencez par naviguer dans votre répertoire de noyau, et dans l’architecture arch / <architecture de votre appareil>/configs, où vous devrez ajouter un nouveau fichier appelé halium.config. Dans ce fichier, ajouter le contenu suivant :

CONFIG_DEVTMPFS=y
CONFIG_FHANDLE=y
CONFIG_SYSVIPC=y
CONFIG_IPC_NS=y
CONFIG_NET_NS=y
CONFIG_PID_NS=y
CONFIG_USER_NS=y
CONFIG_UTS_NS=y
CONFIG_VT=y

Après cela, enregistrez et fermez ce fichier. Ajoutez le à votre dépot du noyau si vous le souhaitez, car ce nom de configuration sera ajouté dans deviceinfo.

A ce stade, vous avez presque terminé la configuration initiale du noyau, passer à configurer deviceinfo et construire.

Après avoir réussi à démarrer l’OS, vous pouvez passer à patcher le defconfig entièrement dans les étapes ultérieures.

Note : vous pouvez être intrigués par le fait que nous éditons un fichier séparé, halium.config, au lieu de <nom de code>_defconfig. Ces fichiers seront sélectionnés ensemble dans le deviceinfo, en les “fusionnant”. De cette façon, nous conservons les changements propres et lisibles.

Remplir votre deviceinfo

  • Nom complet de l’appareil, comme Redmi 9C ou Redmi Note 10S. Remplacer comme nécessaire.

deviceinfo_name="Redmi 9C"

  • Le nom du fabricant de l’appareil. Changez comme nécessaire.

deviceinfo_manufacturer="Xiaomi"

  • Le nom de code du téléphone. Ceci peut être obtenu par une recherche Internet comme : « <device name> codename ». Remplacez le nom de l’appareil avec le nom complet de votre téléphone. Remplacer le nom de code ci-dessous par le votre également.

deviceinfo_codename="angelica"

  • L’architecture de votre noyau. La plupart des appareils sortis après 2015 ont un processeur ARM64, mais certains appareils peuvent encore être armhf. Pour les appareils ARM64, définissez la configuration à « aarch64 ». Pour les appareils armhf, définissez la configuration à « armv7 ».

deviceinfo_arch="aarch64"

  • Cela définit le dépôt git où se trouve votre noyau. Vous devriez déjà avoir ce lien à portée de main si vous avez suivi la section 1, sinon recommencez. Remplacer le lien ci-dessous par le votre.

deviceinfo_kernel_source="https://github.com/muhammad23012009/android_kernel_xiaomi_dandelion"

  • La branche du noyau vient ensuite. Ceci peut être facilement obtenu en regardant l’onglet sous l’onglet Code sur GitHub ou l’onglet en haut à gauche dans GitLab. Remplacer le cas échéant.

deviceinfo_kernel_source_branch="halium10-new"

  • Defconfig est une partie essentielle du processus de compilation du noyau. En général vous pouvez trouver le defconfig dans vos sources du noyau, le chemin étant « arch/<architecture de votre appareil>/configs ». Le nom de la defconfig est souvent construit comme « <nom de code>_defconfig ». Après avoir trouvé votre defconfig, remplacez-le au besoin. Vous devez également ajouter halium.config dans ce champ, en raison de l’ajout des patchs de configuration du noyau ci-dessus. (Si vous ne trouvez toujours pas le defconfig se référer à la section « Trouver votre defconfig »)

deviceinfo_kernel_defconfig="angelica_defconfig halium.config"

  • La ligne de commande du noyau est un des éléments déterminants du démarrage du noyau. Elle a des paramètres spéciaux qui permettent au noyau de déterminer quelles caractéristiques doivent être activées et celles qui doivent être désactivées. Les systèmes de fichier racine Ubuntu Touch utilisent ainsi quelques paramètres essentiels au démarrage, plus précisément « console=tty0 ». Pour l’adapter à votre appareil, essayez d’extraire votre image de démarrage (section 8.3) et d’y récupérer la ligne de commande, ou de vous aider d’un arbre de périphérique LineageOS s’il est disponible. « console=tty0 » est indispensable pour la ligne de commande et ne doit jamais être enlevé. Le reste peut être supprimé ou ajusté à votre appareil. console=tty0 est indispensable au démarrage correct. systempart est ajouté si vous voulez démarrer votre systême de fichiers racine de votre partition système. Il est supposé pointer vers votre partition système.

deviceinfo_kernel_cmdline="console=tty0 bootopt=64S3,32N2,64N2 systempart=/dev/mapper/system"

  • Ajoutez ceci à votre deviceinfo si vous souhaitez compiler votre noyau avec clang. La plupart des appareils sortis avec et après Android 10 construisent leurs noyaux avec clang. Si vous ne voulez pas construire avec clang, enlevez cette entrée.

deviceinfo_kernel_clang_compile="true"

  • Nécessaire seulement si vous voulez utiliser LLD comme votre éditeur de liens et activer LTO. Pour la plupart des anciens noyaux LTO ne fonctionne pas. Si vous voulez l’utiliser, ajoutez cette entrée à votre deviceinfo, sinon omettez-la.

deviceinfo_kernel_use_lld="true"

  • Cette configuration vous permet de compiler votre noyau avec LLVM et LTO, si c’est possible. C’est un raccourci simple pour spécifier clang et ld.lld ensemble. Habituellement nécessaire par les appareils GKI. (Une fois activé, vous n’avez pas besoin de spécifier deviceinfo_kernel_use_lld)

deviceinfo_kernel_llvm_compile="true"

  • Utilisez ceci pour activer “dtc_ext” pour compiler vos dtb/dtbo’s. Utilisez seulement si vous savez ce que vous faites. Le compilateur par défaut fonctionne en général parfaitement.

deviceinfo_kernel_use_dtc_ext="true"

  • Utilisez cette option pour spécifier le nom d’image du noyau après la compilation du noyau. En général cette option est juste inutile, vous pouvez donc la retirer de votre deviceinfo. Si nécessaire, ajustez le nom d’image comme vous le souhaitez.

deviceinfo_kernel_image_name="Image.gz"

  • Pour spécifier votre algorithme de compression de disque mémoire vive, utilisez l’option ci-dessous. Il est défini à gzip par défaut. Sert principalement pour les appareils GKI.

deviceinfo_ramdisk_compression="lz4"

  • Ajoutez cette option pour spécifier votre version Halium. Halium 13 est le niveau maximal utilisable actuellement.

deviceinfo_halium_version="11"

  • Cette option définit la version d’en-tête d’image de démarrage. Elle doit impérativement être correcte, sinon votre appareil peut ne pas démarrer. Les appareils fonctionnant avec les versions Android ci-dessous 8 (Oreo) utiliser header 0, Android 9 (Pie) utilise la version 1, Android 10 utilise la version 2, et les appareils GKI utilisent la version 3/4 (selon la version Android utilisée, Android 12 avec GKI utilise la version 4).

deviceinfo_bootimg_header_version="2"

  • Utilisez cette option pour définir un dtb préconstruit que vous avez fourni. Le chemin est relatif au répertoire où vous éditez le fichier deviceinfo. Modifier le nom dtb en conséquence. Si votre version d’en-tête est supérieure ou égale à 3 (appareil GKI), cela inclura dtb dans votre vendor_boot.

deviceinfo_bootimg_prebuilt_dtb="mt6765.dtb"

  • Cette option utilise le dtb créé par votre noyau lors de la compilation, plusieurs dtb peuvent être spécifiés ici comme par exemple : « mediatek/mt6765.dtb mediatek/angelica.dtb » Le chemin dans lequel les scripts recherchent le dtb’s avec cette option activée est « KERNEL_OBJ/arch/<architecture>/boot/dts » où <architecture> sera soit arm64 ou arm selon ce que vous définissez dans deviceinfo_arch (aarch64 est arm64 en language du noyau) Si votre version d’en-tête est supérieure ou égale à 3 (appareil GKI), cela inclura dtb dans votre vendor_boot.

deviceinfo_dtb="mediatek/mt6765.dtb"

  • Sélectionnez ceci va construire une image DT que vous avez sélectionnée dans l’image de démarrage. Le chemin est relatif à votre répertoire courant dans lequel vous éditez deviceinfo. (Note : Ce n’est vraiment nécessaire que pour les appareils Samsung/Exynos.)

deviceinfo_bootimg_prebuilt_dt="exynos8890-dt.img"

  • Utilisez ceci pour installer un dtbo préconstruit dans vos OTAs et pour construire votre récupération avec ce dtbo s’il n’est pas déjà compilé. Le chemin est à nouveau relatif à votre répertoire de construction. Modifier comme désiré.

deviceinfo_prebuilt_dtbo="angelica-dtbo.img"

  • Dans le cas où vous ne voulez pas fournir l’image DTBO dans un OTA, ce choix ne supprimera le dtbo du paquet OTA, mais la récupération sera encore compilée avec ce dtbo, si le dtbo n’est pas déjà compilé.

deviceinfo_skip_dtbo_partition="true"

  • Si vous voulez compiler votre DTBO à partir du noyau, utilisez cette option pour sélectionner les fichiers dtbo compilés dans le répertoire de sortie du noyau. Le chemin dans lequel cette option sera recherchée est KERNEL_OBJ/arch/<architecture>/boot/dts. Plusieurs dtbo peuvent être fournis comme indiqué dans l’exemple. Adaptez les noms selon vos exigences. L’image dtbo résultante sera intégrée dans l’OTA si l’option skip_dtbo_partition n’est pas sélectionnée, et en tout cas la récupération sera également construite avec ce dtbo. Cette option est incompatible avec l’option dtbo préconstruite.

deviceinfo_dtbo="mediatek/galahad.dtbo mediatek/lancelot.dtbo"

  • Cela définira le nom de la carte mère dans votre image de démarrage, dont certains chargeurs de démarrage ont besoin pour démarrer l’image avec succès. Utilisez seulement cette option si votre image d’origine fabricant a ce drapeau défini dans son en-tête. Modifier comme vous le souhaitez si nécessaire.

deviceinfo_bootimg_board="EXYNOS4412"

  • Utilisez cette option pour étendre votre image de démarrage à une taille spécifique. C’est aussi nécessaire si vous voulez ajouter une image vbmeta ou suffixer un hachage à votre image. Ceci change la taille de votre image de démarrage. (Note : La taille est déclarée en octets).

deviceinfo_bootimg_partition_size="67713847"

  • Comme son nom l’indique. Réglez-le à vrai si votre appareil nécessite une image vbmeta ajoutée (Pas le cas pour la plupart des appareils avec une partition vbmeta dédiée.)

deviceinfo_bootimg_append_vbmeta="true"

  • Utilisez cette option lorsque vous voulez créer un recovery.img pour démarrer la récupération UBports (c’est seulement réellement nécessaire à la finalisation du port). En général, il vaut mieux omettre ceci au début de votre port et l’ajouter quand vous essayez de l’obtenir dans l’installateur. Positionner à vrai true construit la récupération et régler à faux ou omettre l’entrée entièrement empêchera sa génération.

deviceinfo_has_recovery_partition="true"

  • Utilisez ceci pour étendre votre image de récupération à une taille spécifique. Nécessaire aussi si vous voulez ajouter un suffixe de hachage à votre image. Ceci remplace la taille de votre image de récupération fabricant. (Ne fonctionnera que si vous construisez une image de récupération !)

deviceinfo_recovery_partition_size="67713847"

  • Ceci n’est vraiment nécessaire que pour certains vieux/nouveaux Samsung qui vérifient un suffixe « SEAndroid » sur leurs images de démarrage pour vérifier si elles sont officielles ou non. Si le chargeur ne le trouve pas, cela affiche une vilaine ligne rouge en haut de l’écran. L’ajout de cette chaîne à votre deviceinfo ajoutera cette chaîne à l’image de démarrage. (Attention ! l’utilisation sur d’autres appareils peut bloquer le démarrage de l’image !)

deviceinfo_bootimg_tailtype="SEAndroid"

  • Cette configuration détermine si les modules doivent être compilés et installés dans le système de fichier racine ou non. Ne pas mettre cette option se traduit par le comportement par défaut, c’est-à-dire que les modules sont compilés et installés dans l’image de fichiers racine. L’ajout de cette option à votre deviceinfo et le paramétrage à vrai (comme montré) désactivera la compilation des modules. Ce n’est vraiment nécessaire que si pour des fonctionnalités avancées.

deviceinfo_kernel_disable_modules="true"

  • Cette option installe tous les fichiers de superposition (dans overlay/directory) dans /system/opt/halium-overlay, donc en superposant les fichiers présents dans l’image de fichiers racine au lieu de les remplacer complètement. Ceci est nécessaire pour 20.04 et suivants, mais non applicable pour 16.04.

deviceinfo_use_overlaystore="true"

  • Cette option est principalement utilisée sur certains appareils Qualcomm. Ajouter ceci à votre deviceinfo combinera tous vos dtbo avec vos dtbs. Utilisez seulement si vous êtes sûr que vous en avez besoin.

deviceinfo_kernel_apply_overlay="true"

  • Ajoutez cette configuration à votre deviceinfo lorsque vous devez spécifier une taille fixe pour votre image de fichiers racine enregistrée dans l’image système. Vaut 3000M par défaut lorsque l’option n’est pas définie. Utilisez seulement si vous en avez besoin.

deviceinfo_system_partition_size="4000M"

  • Cette configuration n’est pertinente que pour les nouveaux appareils avec un stockage UFS

deviceinfo_rootfs_image_sector_size="4096"

  • Ensuite, il y a des décalages. Vous pouvez les ignorer si vous ne construisez que boot.img pour un appareil GKI, mais sont requis si vous voulez construire vendor_boot.img. Ces décalages s’appliqueront automatiquement à vendor_boot si votre version d’en-tête est supérieure ou égale à 3. Voici un guide pour les extraire :

Valeurs extraites du boot.img/vendor_boot.img fabricant

Pour que n’importe quel port démarre, certaines valeurs doivent être tirées du boot.img d’origine fabricant. D’abord, essayez d’obtenir votre firmware d’origine. Certains fabricants comme Samsung aiment chiffrer leurs firmwares, mais quelques outils sont disponibles pour les obtenir. D’autres comme Xiaomi fournissent le firmware, mais vous devez utiliser un moteur de recherche pour le trouver. Google eux fournissent des binaires de firmware complet facilement accessible. Pour faire court, vous devez au moins trouver votre firmware d’origine, et le boot.img. Une fois le boot.img acquis, suivez les étapes suivantes :

  • Faites un répertoire dans lequel vous stockez toutes vos données décompressées. Il peut être n’importe où, et peut avoir n’importe quel nom. Pour l’instant, nous l’appellerons « temp ».

  • Exécutez « mkdir ~/temp » pour créer le répertoire et « cd ~/temp » pour y aller.

  • Maintenant pour décompresser l’image de démarrage il existe plusieurs utilitaires. L’un d’eux est le script python fourni par Android. Pour l’instant, on va utiliser ça. Pour le télécharger dans votre répertoire de travail actuel lancez « wget https://raw.githubusercontent.com/LineageOS/android_system_tools_mkbootimg/lineage-19.1/unpack_bootimg.py » Ceci téléchargera le script unpack_bootimg.py, que vous utiliserez maintenant pour récupérer vos décalages noyau et d’autres valeurs similaires

  • Mettez votre boot.img dans le répertoire temp.

  • Maintenant, lancez le script. La syntaxe habituelle est « python3 unpack_bootimg.py –boot_img ascensionboot.img ou vendor_boot.img –out out » Cela décompressera l’image de démarrage, enregistrera les fichiers de sortie dans le répertoire de sortie, et imprimera également les décalages sur l’écran.

Un exemple de sortie pour boot.img ressemblera à ceci :

boot magic: ANDROID!

kernel_size: 11399060

kernel load address: 0x40080000

ramdisk size: 6576255

ramdisk load address: 0x51b00000

second bootloader size: 0

second bootloader load address: 0xc0ff0000

kernel tags load address: 0x47880000

page size: 2048

os version: 10.0.0

os patch level: None

boot image header version: 2

product name:

command line args: bootopt=64S3,32N2,64N2 buildvariant=user systempart=/dev/mapper/system:ro

Arguments supplémentaires de ligne de commande :

recovery dtbo size: 0

recovery dtbo offset: 0x0000000000000000

boot header size: 1660

dtb size: 216417

dtb address: 0x0000000047880000

alors que pour vendor_boot.img, ressemblera à ceci :

boot magic: VNDRBOOT

vendor boot image header version: 4

page size: 0x00001000

kernel load address: 0x10008000

ramdisk load address: 0x10000000

vendor ramdisk total size: 13685168

vendor command line args: bootconfig loop.max_part=7

kernel tags load address: 0x10000000

product name: SRPUK23A007

vendor boot image header size: 2128

dtb size: 231604

dtb address: 0x0000000011f00000

vendor ramdisk table size: 216

vendor bootconfig size: 28

  • Voilà où ça devient intéressant.

    • « kernel load address » est le décalage du noyau. La valeur après les deux points est ce dont vous avez besoin, par exemple, 0x40080000. Ce sera différent dans votre cas.

    • « ramdisk load address » sera votre décalage pour le disque en mémoire vive. Prennez la valeur suivante. Par exemple, 0x51b00000.

    • « second bootloader load address » est plutôt inutile pour les systèmes modernes. Mais si votre image de démarrage émet cette valeur, assurez-vous de l’utiliser. Par exemple, 0xc0ff0000.

    • « kernel tags load address » est une adresse spéciale. Il est utilisé pour les balises du noyau et dtb, mais dans certains cas, ces valeurs peuvent être différentes. Prenez aussi la valeur. Par exemple, 0x47880000.

    • « dtb address » est parfois la même que « kernel tags load address ». Mais si elle est différente, vous devriez l’utiliser pour dtb et tags pour les tags.

    • « taille de page » est nécessaire pour le disque en mémoire vive pour savoir ce que votre mémoire flash utilise pour les tailles de page. La valeur après les deux points est ce que vous utiliserez. Par exemple, 2048.

    • « os version » est la valeur qui détermine quelle version Android ce boot.img utilise. Certains chargeurs de démarrage l’utilisent. Par exemple, 10.0.

    • « os patch level » est similaire. Vous voudrez également récupérer cette valeur, par exemple, 2021-11.

    • « command line args » vont directement dans deviceinfo_kernel_cmdline. Assurez-vous de garder « console=tty0 » dedans. Aucun exemple ici :(

    • Si vous construisez vendor_boot, cette commande produira également un fichier bootconfig dans votre répertoire de sortie. Déplacez-le à la racine de votre source.

    • En dehors de ces valeurs mentionnées, vous pouvez éliminer tout le reste.

Maintenant, selon ce guide, saisissez vos décalages :

  • Mettez la valeur de « page size » dans cette configuration.

deviceinfo_flash_pagesize="2048"

  • Le décalage de base restera toujours 0x00000000.

deviceinfo_flash_offset_base="0x00000000"

  • Définissez ceci à partir de « kernel load address ».

deviceinfo_flash_offset_kernel="0x40080000"

  • Ceci obtient sa valeur de « ramdisk load address ».

deviceinfo_flash_offset_ramdisk="0x51b00000"

  • Bien que non indispensable, si vous avez obtenu sa valeur, remplissez-la à partir de « second bootloader load address ».

deviceinfo_flash_offset_second="0xc0ff0000"

  • Les étiquettes doivent être remplies à partir de « kernel tags load address ».

deviceinfo_flash_offset_tags="0x47880000"

  • Le décalage DTB vient de « second bootloader load address ».

deviceinfo_flash_offset_dtb="0x47880000"

  • Ceci vient de « os version ». Pas exactement requis, mais certains OEM l’imposent.

deviceinfo_bootimg_os_version="10.0"

  • Vous pouvez mettre la valeur « os patch level » ici.

deviceinfo_bootimg_os_patch_level="2021-11"

  • Si vous construisez un vendor_boot et que vous avez déplacé le fichier bootconfig à la racine de votre arbre, ajoutez ce qui suit :

deviceinfo_vendor_bootconfig_path="bootconfig"

Et comme ça, vous avez rempli votre deviceinfo correctement et peut maintenant continer avec le portage !

Construction, installation et lancement

Après avoir terminé votre deviceinfo et rempli tout le nécessaire, il est temps de passer à la partie principale, la construction. Pour cela il suffit de lancer : ./build.sh -b workdir`

Cela devrait télécharger tous les outils nécessaires, puis le noyau, et enfin construire tout. Ce processus peut prendre environ 5 à 50 minutes pour construire le noyau.

Après que votre noyau est construit, vous pouvez procéder à l’installation et le démarrer dans la prochaine étape.