Sur ARM, pour effectuer un appel système, nous utilisons l'instruction svc (supervisor call) qui est l'équivalent

de int. De même, les registres n'ont pas le

même nom.

Le fait de générer des exécutables statiques permet de ne pas être lié à des bibliothèques système. Ainsi, ce type d'exécutable est généralement plus
portable. Mais comme l'exécutable embarque l'ensemble du code, au lieu de faire appel à des fonctions de bibliothèques partagées par l'ensemble des
applications, la taille de l'exécutable obtenu est généralement plus grande. Vous pouvez utiliser l'option -static de gcc lors de la compilation, pour générer
un exécutable statique.

Vous devez donc préciser où se trouvent les différentes librairies fournies avec la chaîne de compilation croisée. Dans notre cas, ces dépendances sont
dans le répertoire ~/Development-tools/tools/arm-bcm2708/arm-rpi-4.9.3-linux-gnueabihf/arm-linux-gnueabihf/sysroota
Rq: On ecrit une(01) bonne fois pour toute,le repertoire ou se trouve les differentes librairies fournies avec la chaine de compilation croisee.
Pour les ulterieurs utilisations, on ajout l'option-static a la fin .

Testons dans un environnement chroot:

chroot: c'est un des environnements de compilation croisee

Les systemes d'exploitation disponibles: Debian, Raspbian, ou Buildroot

-Liste des paquetages: liste des paquets ou services pour mettre en place une architecture donnee possible.

Vocabulaire:
chroot: c'est un environnement dans laquelle on peut installer des chaines de cross compilation et de gcc compatible a une architecture.
bash : interpreteur de commande nouveau fourni par chroot
stretch-crossdev : C'est un dossier qui enferme l'interpreteur bash et ou on a stocke l'environnement chroot
dpkg: pour lister les differentes architectures que j'ai ajoutee a mon environnement
crossbuild: une des paquetages d'un environnement.

Commande:
dpkg: pour lister les differentes architectures que j'ai ajoutee a mon environnement
pwd(Print Working Directory): pour trouver le repertoire du travail dans laquelles vous etes actuellement.
cd: change directory
ls: c'est pour voir le contenu d'un repertoire
cat( abreviation de concatenate): utilisee pour lister le contenu d'un fichier sur le resultat
standard, example cat fichier.txt
cp: pour copier les fichiers du repertoire actuel dans un autre repertoire
syntaxe: cp source file/ destination file
mv: deplacer les fichiers (rq: les arguments de mv sont similaire a ceux de cp)
mkdir:pour creer un nouveau repertoire.
rmdir: pour supprimer un repertoire.
touch:- pour creer un nouveau fichier vierge via la ligne de commande linux.
-si |le fichier existant, il fait le mis a jour du file's timestamp sans editer le fichier existant.
locate: utilisee pour localiser un fichier (rq: l'utilisation de l'argument -i rendra la commande insensible a la casse)
find:pour rechercher des fichiers et des repertoires.
rm: pour supprimer un dossier
grep:pour rechercher un mot-clé, une phrase ou un motif spécifique dans un fichier . Il a plusieurs options :
grep -Rw ‘/chemin/vers/recherche/’ -e ‘motif’
grep –exclude=*.csv -Rw ‘/chemin/vers/recherche’ -e ‘motif’
grep –exclude-dir={dir1,dir2,*_old} -Rw ‘/chemin/vers/recherche’ -e ‘motif’
find . – nom « *.php » -exec grep « motif » {} ;

sudo(SuperUser Do) :permet d'effectuer des taches qui necessitents des autorisations adminstratives ou de root.
df: pour obtenir un rapport sur l'utilisation de l'espace disque du systeme, indiquee en pourcentage et en Ko.
du(Disk Usage):pour verifier l'espace occupe par un fichier ou un repertoire
head: pour visualiser les premieres lignes de n'importe quel fichier texte.
tail:affichera les 10 dernieres ligne d'un fichier texte
diff:compare le contenu de 2 fichiers ligne par ligne.
tar:pour archiver plusieurs fichiers dans un tarball.
chmod: utilisée pour modifier les permissions de lecture, d’écriture et d’exécution des fichiers et des répertoires.
chown: permet de changer ou de transférer la propriété d’un fichier à un utilisateur spécifique. ex:chown linuxuser2 fichier.ext
jobs:affichera tous les jobs actuels avec leur statut.(Un job est essentiellement un processus qui est lancé par le shell.)
kill:pour arreter manuellement un programme qui ne repond pas.
ping:pour vérifier votre état de connectivité à un serveur.
wget:utilisee pour télécharger des fichiers sur Internet.Pour ce faire, il suffit de taper wget suivi du lien de téléchargement.
uname(UnixName): imprimera des informations détaillées sur votre système Linux comme le nom de la machine, le système d’exploitation, le noyau, etc.
top: affichera une liste des processus qui sont en cours d’exécution et la quantité de CPU utilisée par chaque processus.
history: pour revoir les commandes que vous avez entrées auparavant.
man: fournit les instructions sur la fonction de certaines commandes .
echo: pour déplacer certaines données dans un fichier.
zip: pour compresser vos fichiers dans une archive zip
unzip: pour extraire les fichiers zippés d’une archive zip.
hostname:pour connaitre le nom de votre hote/reseau.
useradd: utilisé pour créer un nouvel utilisateur
passwd: l’ajout d’un mot de passe au compte de cet utilisateur.
userdel: pour supprimer un utilisateur
shutdown: pour eteindre ou redemarrer votre machine .
tree: affiche la structure en arbre des fichiers contenus dans un fichier , syntaxe: tree directory

INSTALLEZ UNE CHAINE POUR ARM 32 Bits:

-On peut installer des chaines de compilation croisee dans votre environnement chroot.

------------------------------------------------------------
08-08-2022:

LIGNE DE COMMANDE AVANCEE :

▪Editing-vi: (vi ou visual):
-utilisee si necessaire en cas d'executable qui ne peut marcher sur une architecture, alors on a besoin de modifier le programme ou le fichier source
contenant le programme afin de lui faire marcher sur une architecture quelconque
vi: est un mode d'editeur de texte recent utile sur UNIX.
-Commande basique: vi <name> (ou vim <name>).
Pour entrer "Mode Normal" les commandes, on utilise Esc key :
+Cela nous permet d'ecrire: Esc->:w
+aussi pour quitter de vi ou vim par Esc->q :quit
+permet aussi d'inserer : i , de supprimer : d

▪Shell Interpreter Options:

-l'interpreteur shell manipule les commandes a partir d'un terminal( ou a partir d'un fichier script)
-Il existe Bourne shell(Original, abbr: sh) et Bash shell( cree comme remplacement de Bourne avec les caracteristiques venant de ksh et csh. )

▪Searching for files:

syntaxe: find . -name a_directory./a_directory
-searching content in group: on utilise la commande grep -r "Le contenu a chercher"

▪Wildcards(ou caracteres generiques) ,

-le caractere " * " : Il existe 3 objectifs d'utilisation de cette caractere generique.
-The pipe Character "|": permet d'envoyer la sortie d'une commande vers l'entree d'une autre commande.
-Le caractere ">": permet l'envoie de sortie d'une commande vers un nouveau fichier.
-Le caractere ">>": permet d'ajouter la sortie d'une commande vers un fichier existant ou nouveau.

▪Permission d'acces a un fichier:

-Controler comme un fichier peut etre utilise et par qui?
-Il existe 3 niveaux de permission tel que :User, Group and World(or everyone).
-Il existe un fichier de permission qui controle l'acces en ecriture ou lecture d'un fichier et d'utiliser des fichiers specifiques.
-pour voir l'info de permission : utiliser la commande "ls -l ".
-Les permissions sont reparties en fonction de l'utilisateur du fichier.
-NB: executer permissions typiquement non-accorde par defaut.
-pour changer les permissions de lecture, d'ecriture et l'execute permissions, on utilise chmod , exemple : chmod u+x fichier_a_lire (u:user account)
-Permissions peuvent etre specifies par des nombre octals tel que : 4=read, 2=write, 1=execute , ex: 742=> 7=4+2+1 ie rwx ; 4 ie r ; 2 ie w et 1 veut
dire execute

▪Remote access(acces a distance):

-Il existe +ieurs methodes de faire interagir 2 machines, mais on va en citer 3 : SSH, Connexion RDP, et connexion VNC.
NB: Qlq soit la méthode que vous utilisez, la recherche de l'adresse IP de votre système est requise presque dans tous les cas.
-On peut utiliser Secure shell (ssh) pour commander a distance une machine (y compris mon Virtual Machine).
-Il s'agit de faire interagir deux machines entre eux , afin de pouvoir commander a distance l'une des machine a l'aide de l'autre
-Exemple: cas de VM : on doit le configurer :
.protocole utilisee: TCP,
.Adresse IP de VM: 127.0.1.1
.Host Port: 2222 ( port 22 is the typical port used for ssh on linux systems
-on utilise scp pour transferer les fichiers dans/ou venant de mon VirtualMachine(VM).
ex: Transferer from Windows vers mon VM home directory, comme suit:
scp -p 2222 /C/Users/Aina/Downloads/ somefile.txt aina@127.0.1.1
-Normalement, on doit utiliser un environnement UNIX WSL ou MSYS2 sur windows(ie sur le cmd de Windows), par https://www.msys2.org/ (MSYS2)
ou par https://docs.microsoft.com/en-us/windows/wsl/install-win10

-Suite d'Acces a distance d'un systeme Windows dans Linux:

-Pour regarder le nom d'hote, on fait:
hostname -I
-Si on veut savoir l'addresse IP, commes suit:
ip address
 -Si mon systeme Linux dispose de +ieurs connexions, celles-ci seront repertoriees avec des prefixes.
Ex: une connexion Ethernet sera répertoriée à côté de eth0, si c'est sans fil, on cherche l'adresse IP répertoriée à côté de wlan0.
1ere technique: -Comment RDP de Windows a Linux?(RDP ou Remote Desktop)
-> .C'est la plus simple option, qui est aussi integre a Windows.
.Avant de commencer, on doit installer le logiciel xrdp sur Linux, comme suit
sudo apt install xrdp
.Puis doit commencer et activer XRDP service insur linux, comme suit:
sudo systemctl start xrdp
sudo systemctl enable xrdp
.Apres on doit ajouter l'user xrdp au groupe ssl-cert, comme suit:
sudo adduser xrdp ssl-cert
sudo systemctl restart xrdp
.Autoriser le port 3389 sur le Pare-Feu sur linux, comme suit:
sudo ufw allow 3389/tcp
.Consulter l'IP du machine Linux par la commande suivante:
ifconfig
.Pour passer de RDP Windows vers Linux, on execute le logiciel Remote Desktop sur Windows.
.Sur Windows, on va Ouvrir la connexion Remote Desktop et on connecte au machine Linux

2eme technique: Connecter a linux a partir de Windows avec VNC(Connexion reseau virtuelle):
-Pour l'utiliser, on devra installer un logiciel dedie a VNC , sur la machine Linux et sous Windows une application cliente.
-L'une des options les plus populaires pour se connecter à Linux via VNC est TightVNC.
-Apres avoir telecharger VNC pour Windows, on devra installer le tightvncserver sur ma machine Linux, comme suit:
sudo apt update
sudo apt install tightvncserver #installation de tightvncserver
sudo tightvncserver #executer + definition de mot de passe (au plus 8 caracteres).
NB: Lors de l'execution de tightvncserver, on verra une notification affichant le numero de port, on doit le noter.
-Une fois tout cela est faite, voici comment on va connecter a la machine Linux depuis Windows:
1)- Executer l'app TightVNC Viewer sous Windows
2)- Entrez l'adresse IP et le numero de port
3)- Cliquez sur Connexion
4)- Entrons le mot de passe qu'on a defini lorsqu on y est invite.

3eme technique: Acces a distance a Linux via SSH

-On a deux(02) options pour SSH sous Windows:
1)- SSH dans Windows PowerShell
2)- Telecharger l'outil Putty SSH

-1ere option : Accès à distance Linux avec SSH dans Windows PowerShell :
->Dans Windows PowerShell, on entre comme CLI:
ssh [IP_ADDRESS]
-> Lorsqu'on nous sommes invitee, acceptons le certificat.
->Entrons le nom d'utilisateur et le mot de passe .

▪Scripts:
-permet d'automatiser les commandes utilisees
-adapter les commandes pour different scenarios utilisant des arguments et les variables
-script enregistre les series d'operations et complete quelque partie unique basee sur les variables qui sont adaptee aux scripts soit via ligne de
commande arguments ou via variables mentionnee dans le script.
-Script c'est un fichier texte qu'on peut executer et lancer comme une commande .
-utilise pour eviter la redondance de ligne de commande
-parfois ils sont des fichiers qui se terminent par .sh(short for shell)
-Tous les scripts commencent tjrs par #!/bin/sh ou #!/bin/bash au debut du script qui est appelee : "shebang" , role c'est pour indiquer au shell quel
interpreteur shell utiliser
Rq: #!/bin/sh : est aussi le chemin pour aller vers the root file system, qui fait reference a Bourne shell

▪Scripts variables include:

-variable qui definie lui-meme
-variable passee dans le script en tant qu'argument: ex:
greeting=$1
echo "${greeting} world!" ;
./helloworldargs.sh hola
retourne hola worlds!

Rq: Voici quelques special variables scripts:

▪$* : c'est pour afficher tous les arguments de notre script en une seule fois .
▪$_: Revoir la sortie de la derniere commande passee.
▪$$: affiche le numero de processus du shell actuel.
▪$0: invoque le nom de script bash ou de la commande actuelle.
▪$1-$9 : les 9 premiers arguments to a script
▪$# : donne le nombre d'arguments passee aux scripts
▪$? : Verifier la bonne execution d'une commande:
-> Et si la commande s'est bien deroulee, la variable sera a 0
-> Sinon si la commande s'est mal passee alors elle sera a 1 ou 2

▪BASH Conditional if/else

-Conditionnal syntax for bash:
ex: if [-d "$WRITEDIR"] /* -d FILE : si FILE exists et il est une repertoire, donc la condition ici , c'est de tester si WRITEDIR is a directory or no */
then
echo " $WRITEDIR created"
else
exit 1
fi

▪Echecs de script et Code de sorties

-Scripts peuvent communiquer avec succes/ou echec a travers l'etat de sortie et la commande de sortie .
ex:
if [$? -eq 0]
then
echo "success"
exit 0
else
echo "failed: expected ${MATCHSTR in ${OUTPUTSTRING} but instead found"
exit 1
fi

+Execution de script:
On ecrit la ligne de commande suivante:
bash script.sh
Rq: Mais avant passer en exectutable, on doit activer la permission d'executer un fichier, comme suit
chmod +x script.h

10/08/2022:

-GitHub Classroom:
+On a ouvert le lien de master repository(depot) : voici le lien : https://github.com/cu-ecen-aeld/aesd-assignments
+Puis, on a liee le lien de master Git-repository contenant toutes les contenu du devoir a mon compte GitHub classroom, et pour pouvoir acceder a
cela, on entre dans ce lien: https://classroom.github.com/a/OTSBSmD0
Le nouveau Git-repository creee est vide, du coup, on devra le completer avec les contenu du master Git-repository.

https://docs.google.com/document/d/1MzDmZHpALwmnkAStSZQKY4TNuwKZdCRXw7zk62SciJM/edit*

▪YOCTO: est un open source collaboration qui aide les developpeurs a creer une Linux personnalisee base sur un systeme peu importe
l'architecture materiel.
-Le projet YOCTO fournit un ensemble flexible d'outils et une espace ouu les systemes embarques a l'echelle mondiale peuvent
partager les technologies, piles logicielles, les configurations, et les meilleures pratiques qui peuvent etre utilise pour creer du Linux images adaptees pour
l'embarque et appareil IoT, ou n'importe ouu la personnalisation Linux Os est demandee.

----------------------------------------------------192.168.1.195
192.168.56.1
DESKTOP-SH7QKNR

21/08/22:
Voici sont les choses qu'on demande pour le devoir1: Bash Scriptin basics:
+On doit completer le nouveau repository associe au devoir1 avec le contenu de Base assignement repository:
1-Installer Virtual Machine
2-Cloner le github repository cree from the github classroom link
3-Ajouter un controleur(remote) pour chercher la base de l'assignment , comme suit
git remote add assignments-base ou
Rq: Ne pas suivre les instructions sur la page de l'association github d'ajouter un README commit, voici le lien de la page https://github.com/cu-ecen-
aeld/aesd-assignments.git
4- "git fetch assignments-base ": cette commande
extrait le contenu localement et relier l'etat ancien a https://github.com/cu-ecen-aeld/aesd-assignments
5-"git merge assignments-base/master ":cette commande relie ma branche master avec la branche master de https://github.com/cu-ecen-
aeld/aesd-assignments
6-"git submodule update --int --recursive ": cette commande clone the assignment-autotest submodule et les git repositories imbriques

-On doit aussi installer et faire marcher l'automated testing pour mon assignment repository, pour faire cela on doit aller dans l'onglet Wiki
-Cela va me permettre d'utiliser un executeur(ou un debogueur, compilateur) de ma machine de verifier les commentaires que j'ai ecrit dans Github
Repository. Et verifie s'ils travaillent proprement et me donner des feedbacks s'il ya quelque chose qui ne fonctionne pas bien.
-Toutes les unites de test demandees, on peut les voir dans GitHub Actions et on peut executer une unite de script test si cette unite de test est
implemente proprement et completement dans Git repository adequate, cette execution de test est assure par la fonction test_validate
-Test_validate verifie juste si une assertion est vraie, cette fonction contient des valeurs par defaut codee difficilement

Rq:- Lorsqu'on Git quelque modules cela mis a jour recursivement et va cloner un repository(ou depot) et que toutes les contenus imbriques dans Git
repository va extraire toutes les contenus test dans mon repository
- Dans le 2eme devoir on va voir comment reutiliser une configuration executable precedente.
- Exemple d'assertion: unity assertion
-Dans le script de Test_validate_ username.c, on doit modifer une ligne de code afin de bien executer le script test :
->On a besoin de remplacer l'appel de fonction TEST_ASSERT_TRUE_MESSAGE(false,...)
par l'appel de fonction my_username() pour verifier ma com username
->On doit ajouter l'unity assertion tel que cela assure que les chaines de caracteres qu'on aura venant de la fonction username() correspond au
valeur de fichier de configuration de notre devoir(assignments)
->Et la valeur du fichier de configuration est la seule qu'on completera dans le conf/username.text file.
->dans le fichier de configuration conf, on remplacera juste le nom du fichier par your-github-username seulement
->puis, on verifiera si avec la fonction my_username(), on aura 2 valeurs qui sont egales .
->Alors, si ce dernier est satisfait, alors la fonction my_username est ecrite pour moi.
->Cela va avoir le malloc_username venant du fichier conf ecrit pour moi dans le Git.
->Ce malloc_username va avoir les valeurs venant du fichier de configuration pour l'username GitHub.
->Et puis, on appelera la fonction my_username() dans autotest-validate.c pour obtenir mon nom d'utilisateur (ou username) codee en materiel.
->Puis le test_validate_username.c a besoin d'avoir ce test_asser_equal_string_message pour verifier si les 2 chaines de caracteres sont egaux.
->Apres l'username va etre maintenant implemente dans le fichier autotest-validate.c donc on met a jour mon username dans autotest-
validate.c
->On doit verifer si le fichier conf et mon fichier c acceptent l'installation de mon username Github.
NB: L'username doit imperativement correpondre soit a mon fichier conf et soit a mon fichier c .
Rq: Toutes les bases de notre test unite sont mises en place . Alors pour avoir une reelle application simple, on va ajouter quelques test system,
->Alors on va ecrire "Finder app"
(tel que Finder apps va avoir un couple de scripts qui fait reelement quelques operations basiques avec la lecture et l'ecriture des fichiers et font des recherches
sur des fichiers
->Et les requirements (conditions) pour ce script sont decrits dans l'assignment document
->On va juste prendre des arguments d'execution pour le chemin vers un repertoire dans le file system et un text string.
->Ces arguments vont etre trouvees dans les fichiers dans le repertoire de file system.
->On a besoin de to exit avec the return value one error et imprimer les declaration si n'importe des parametres ci-dessus n'ont ete specifies.
->On devra quitter(exits) avec une valeur 1 erreur retourne et imprime le resultats si filesdir n'est pas represente dans le repertoire du fichier
systeme (file system)
-> On imprime le message "The number of files are X and the number of matching lines are Y" avec X: nbr de fichier et de tous les sous-
repertoires et Y: est le nbr de ligne correspondant aux fichiers respectifs trouves.
->Exemple invocation:
finder.sh /tmp/aesd/assignment1 linux => ie qu'on cherche des contenus dans le repertoire linux avec le chemin ci-dessus et le script Finder.SH
Commentaire: il ya quelques applications qu'on peut utiliser pour avoir l'information et l'afficher a traver mon Finder invocation=> alors il pouvait
etre invoquer
->Next, on doit ecrire un script shell called writer comme finder-app/writer.sh qui a les caracteristiques suivants:
1)- Accepte les arguments suivants:
i)- Le 1er argument est le chemin complet vers un fichier (including filename) sur le fichier systeme(filesystem) et cela va etre repere en bas
comme writefile
ii)- Le 2nd argument est le text string qu'on ecrira a l'interieur de ce fichier, reperee en bas comme writestr
2)-Quitte avec une valeur de retour 1 si error et imprimer le resultat (ou la declaration) si aucun argument ci-dessus ont etes specifies.
3)-Cree un nouveau fichier avec le nom et chemin writefile avec contenu writestr, en ecrasant n'importe quel fichier existant et creeant de chemin s'il
n'existe pas
i)-Quitte avec la valeur de retour et 1 si error, on imprime le statement (ou resultat) is le fichier ne peut pas etre cree.
Exemple:
writer.sh /tmp/aesd/assignment1 /sample.txt ios
=>Ici, On cree un fichier:
/tmp/aesd/assignment1/sample.txt avec contenu "ios"

->Puis, on execute le shell script finder-test-sh fourni avec les repository d'assignment github avec une legere modification indiquee en bas en
jaune .
Ce script:
a)- accepte les arguments suivants:
. le 1er argument est le nombre de fichiers a ecrire numfiles.
. le 2eme argument est la chaine a ecrire pour chaque fichier writestr
b)- Par defaut, on utilise numfiles 10 et writestr "AELD_IS_FUN" si les arguments respectives ne sont pas specifies.
c)- Cree une repertoire vide /tmp/aeld-data
d)-boucle pour creer des fichiers numfiles dans le repertoire /tmp/aeld-data en utilisant le script writer.sh avec writefile, le nom du 1er argument
/tmp/aeld-data/usernameX.txt ouu X est le nombre allant de 1 jusqu'a numfiles, username est le nom d'utilisateur trouvee dans conf/username.txt
and writestr est passee en 2eme argument
e)-Executer le script finder.sh avec filesdir installee dans /tmp/aeld-data et searchstr installee dans writestr
f)-Compare la sortie de script finder avec la sortie attendu "The number of files are numfiles and the number of matching lines are numfiles".
Imprime "success" si ca correspond ou "error" sinon .

->Maintenant, on teste notre implementation en utilisant le script shell finder-test.sh et assure tous les scripts passent.
a-Cela verifie l'implementation des scripts writer.sh et tester.sh passe les exigences.
24/08/22:
-Les executables dans les repertoires inclus dans $PATH sont parfois references en etant "in the path" de current shell.

-Voici les listes des variables shell dans le systeme:

$ cat /etc/shells
/bin/sh
/bin/bash
/sbin/nologin
/usr/bin/sh
/usr/bin/bash
/usr/sbin/nologin
/bin/tcsh
/bin/csh
/usr/bin/tmux
/bin/ksh
/bin/rksh
/bin/zsh

-Chercher la date et heure actuelle du systeme:

-> en utilisant la commande date, comme suit:
$ date

-Lister touts les processus en marche avec la commande ps (processus status): comme suit:
$ ps

-Le moyen le plus simple d’obtenir plus d’informations sur une commande ou un programme Linux particulier est d’utiliser la commande man suivie de
l’élément sur lequel vous souhaitez obtenir des informations, comme suit:
man <program or command>

LES VARIABLES:
-Lors de la définition d’une variable, nous laissons de côté le signe $, comme suit:
myvariable=Bonjour
-Pour lire la variable, on precede le nom de la variable par "$" .
-Les Autres Variables speciales:
$0 - Nom du script Bash.
$1 - $9 - Les 9 premiers arguments du script Bash. (Comme mentionné ci-dessus.)
$# - Combien d’arguments ont été transmis au script Bash.
$@ - Tous les arguments fournis au script Bash.
$? - L’état de sortie du processus le plus récemment exécuté.
$$ - L’ID de processus du script en cours.
$USER - Nom d’utilisateur de l’utilisateur exécutant le script.
$HOSTNAME - Nom d’hôte de la machine sur laquelle le script s’exécute.
$SECONDS : nombre de secondes écoulées depuis le démarrage du script.
$RANDOM - Renvoie un nombre aléatoire différent chaque fois qu’il est mentionné.
$LINENO - Renvoie le numéro de ligne actuel dans le script Bash.
Si vous tapez la commande env sur la ligne de commande, vous verrez un

LES OPERATEURS:
-eq : Elle renvoie true si les deux nombres sont égaux.
-lt : Elle renvoie true si un nombre est inférieur à un autre nombre.
-gt : Elle renvoie true si un nombre est plus grand qu’un autre nombre.
== : Elle renvoie true si les deux chaînes sont égales.
!: Elle renvoie true si les deux chaînes ne sont pas égales.
! : Il nie l’expression avec laquelle il est utilisé.

-NB: Notons bien que si on tape la commande env sur la CLI, on vera une liste d'autres variables auxquelles on peut egalement nous referer.

-Substitution de commande: nous permet de prendre la sortie d'une commande ou d'un programme (ce qui serait normalement imprime a l'ecran) et
de l'enregistrer comme valeur d'une variable. Pour ce faire, on place entre parenthes, précédé d’un signe $, par exemple:
myvar=$( ls /etc | wc -l )
echo Il y a $myvar entrées dans le répertoire /etc

26/08/22:
YOCTO Project:
Documents(A retenir):
-Le but c'est de s'initier comment configurer un Compilateur (ou Build) pour un hardware specifique.
-On utilise Yocto Project pour generer un reference Embedded OS appele Poky.
-On l'utilise generalement sur une distribution linux native, mais si la machine qui l'utilise pour generer de l'image (Build Host) n'est pas un systeme
linux native, alors on effectue des etapes necessaires en utilisant Cross Platforms (CROPS) et installer le conteneur Poky.

Reclamations:
-Par rapport au subdirectory dans la repository clone vers mon machine , on doit placer dans ce subidrectory : +le fichier texte CMakeLists.txt et +le
fichier code du logiciel

------------------------------------------------------------
30/08/22:
Concernant le script finder-test.sh dans finder-app:
-set -e :arrete l'execution d'un script si une commande ou un pipeline contient une erreur
-set -u : signale l'utilisation de variables non initialisees comme dans le script suivant :
' check_init.sh'
#!/bin/sh
set -u message=hello echo $mesage
-rm -rf :
NB: -L'espace supplementaire dans un env.variable peut entrainer la suppression du repertoire dans le script Bash.
-Les quotes dans "$WRITEDIR" signifie que la chaine entiere dans WRITEDIR est une seule chaine de caractere. Cette issue peut etre resolue en
utilisant un double square brackets as " [[ ]]" au lieu d'utiliser des quotes.

Rq: La variable d'env ou l'on met le chemin vers un repertoire specifique contenant +ieurs espaces, alors il sera considere comme un argument
multiple, comme:
$WRITEDIR="aesd/assignments/..."

31/08/22:
-less mon_fichier : syntaxe a faire pour afficher le contenu d'un fichier texte. Ceci, affiche le fichier texte page par page, pour quitter la lecture on pressera
sur "q"
-file fichier : affiche le type de donnee qu'un fichier contient

17/09/22:
-L’option -exec permet d’exécuter une commande avec le résultat de la sortie find

20/09/22:
-Combinaison de "Ctrl+Alt+T" :ouvre une fenetre de terminal .

23/09/22:
-Retouche effectuee, c'est au niveau de script finder.sh, j'ai effectuee un changement sur le texte a ecrire dans le fichier , et supprimer lorsque un nouveau
nombre de fichier est donnee comme argument pour le script

27/09/22:
INTRODUCTION TO SYSTEM PROGRAMMING

System Programming :
But: Introduce System Programming, Understand APIs and ABIs introduce POSIX .

-C'est quoi un System Software?

->il s'interface avec le kernel et le C library .
GUI, compiler, debugger, web server, database.
->Sa difference par rapport a Application Software: il n'utilise pas le haut niveau de librairies et utilise moins des details a propos de OS et hardware
abstrait .

-The Cornestones (pierres angulaires) de Programmation systeme sont:

->System Calls (syscalls) :
+Il s'agit d'appel de fonction de kernel(noyau) par l'espace utilisateur (read() write() ) . A peu pres, il y aura 300 appels systemes au total.
+De plus, il s'agit des sous-ensemble de 90% partages, implementee sur toutes les architectures sur Linux.
-> C library (libc) :
+GNU libc (glibc) embaler l'appels systems qui permet de faireun appel a partir de mon application C, et prend encharge le support et les
applications.
-> C Compiler/linker (toolchain) :
+GCC (GNU C Compiler)

-L'appel d'appels systemes (ou System Calls):

->Impossible de lier mon application d'espace utilisateur avec le noyau de linux pour de raison de security et de fiability.
-> Alors, Comment on va appeler le System Calls :
+ On utilise a "Trap (ou une piege)" typiquement une interruption logicielle.

-API (Application Programming Interface):

-> Il 'sagit d'une definition de la facon ou comment peut converser un logiciel avec un autre logiciel
->Un logiciel qui fournit un API s'agit d'une implementation de la definition de l'API.
->API assure la compatibilite des sources ie que lorsqu'on ecrit une code source une fois, et on peut le compiler vers un ARM ou sur un x86, meme sur
les differentes architectures. La source correspond avec la definition de l'API
ALORS, il pourra etre toujours recompiler et tourne toujours sur des differentes plateformes.
->Le code source reste portable a travers differentes plateformes/revisions materielles(hardware), exemple: fonctions librairies C comme printf(),
strcpy(), etc ...
sauf syscall 10 % architecture differencie mentionnee in previous slide.

-ABI (Application Binary Interface)

 ->Quelque chose qui est couvert par une interface d'application binaire qui est appelee conventions, bytes ordering ou register use.

-LINUX FILE SYSTEMS

->Linux Inode
-> Linux Directories
-> Linux Links
-> Linux Special FIles
-> Linux File Systems
-> Linux Blocks/Sectors

-LINUX PROCESSES AND THREADS

->Linux Processes
->Linux threads
->Linux Threads/Process and Memory
->Linux Signals
->Linux Interprocess Communication (IPC)

-LINUX USERS AND GROUPS

->Lorsqu'on veut creer un systeme d'image sur Linux, on doit donner notre username et notre mot de passe.
Et pour acceder a ce systeme, on doit se connecter avec notre username et notre mot de passe. Et l'authentification peut etre utilise pour mapper le
compte utilisateur specifique.
-> Toutes les comptes utilisateurs sont associees avec un User ID (uid)
=>Chaque process est associe avec l'UID de l'utilisateur en cours d'execution de process
=> Et /etc/passwd mappe username vers UIDs qui sont utilises dans le system Linux donne.
-> Caracteristiques:
=> UID 0 est pour l'utilisateur de demarrage (ou root user)
==>Et le root user peut faire presque n'importe quoi sur le systeme
=>Chaque utilisateur peut appartenir a un ou +ieurs groupes correspondant a Group IDs (gid)
==> Et /etc/group mappe le nom de groupe avec le gids
-Linux Permissions :
->La structure de permission est qu'on peut associer un fichier avec un utilisateur propre, groupe propre, ou autres (everyone)
->L'acces au utilisateur, groupe et autres(everyone), cela est fait a travers des bits specifiques pour read(r), Write(w) et execute(x) tel que :
Pour utilisateur:
Read(r): 8 ; Write(w):7 ; Execute(x):6 .
Pour Groupe:
Read(r): 5; Write(w):4 ; Execute(x):3 .
Pour Autres(everyone):
Read(r): 2 ; Write(w):1 ; Execute(x):0 .
-> et on peut masquer ces bits avec les valeurs octal donnees et on peut les ajouter pour permettre soit a l'utilisateur, groupe, autres (everyone), tel
qu'en valeurs octals, on a:
Pour utilisateur:
Read(r): 0400; Write(w):0200 ; Execute(x):0100 .
Pour Groupe:
Read(r): 040; Write(w):020 ; Execute(x):010 .
Pour Autres(everyone):
Read(r): 04 ; Write(w):02 ; Execute(x):01

ex: chmod 600 => permet l'acces en lecture et ecriture de l'utilisateur

-System Programming and Error Handling strategy

->errno : est le mecanisme de C library pour les rapports. Et il est charge d'indiquer les erreurs dans un script .
-> L'acces a errno est gere par errno.h
-> On utilisera l'API POSIX .
-> On a le script suivant :
FOPEN(3)

NAME
fopen, fdopen, freopen -stream open functions

DESCRIPTION
The fopen() function opens the file whose name is the string pointed to by pathname and associates a stream with it.

RETURN VALUE
Upon successful completion fopen(), fdopen() and freopen() return a FILE pointer. Otherwise, NULL is returned and errno is set to indicate the
error.

->Il a une liste de POSIX qui cherche les erreur et une erreur qui a ete trouve par exemple avec la commande file open appele ENOENT = qui veut dire
No such file or directory
->Si on veut essayer de mapper ces 2 nombres d'erreurs specifique qu'on affiche dans la valeur errno
->On peut utiliser errno Daschle et tu peux voir que ENOENT est representee par le nombre 2 dans la ligne.
-> Voici un exemple d'un simple programme qui essaie d'ouvrir un fichier non-existant :
int main() {
 const char *filename="non-existing-file.txt";
FILE *file=fopen (filename, "rb");
if (file == NULL )
{
fprintf(stderr, "Value of errno attempting to open file %s: %d\n" , filename, errno ) ;
perror ("perror returned") /* perror: utilisee pour reference les variables errno ex: "No Such File or Directory " mais il existe bcp de valeurs de
errno.

fprintf(stderr, "Error opening file %s: %s\n, filename, strerror(errno)) ; /*fonction strerror prend comme argument la variable errno reference par la
fonction perror
} else {
fclose(file);
}
return 0;
}
-> On a :
PERROR(3) Linux Programmer's Manual

NAME
perror - print a system error message.

DESCRIPTION
Le perror() fonction produit un message sur l'erreur standard decrivant l'erreur passe rencontree durant l'appel system ou la fonction librairie.

Remarques:
-La chose qu'on doit penser sur errno et error handling code est que la valeur de l'errno est modifiable comme un effet secondaire par quelques
fonctions d'API
qu'on appelle.
-errno peut etre changer entre le temps ouu on l'a appelee dans fopen et le temps est actuellement imprimee a traverrs pour perror.
->Comment peut-on fixer les erreurs ?
=> deplacer fpintf apres perror
=> Sauvegarder errno vers la variable locale.

->Threads partage les memes espaces memoires.

-> Et Une erreur dans un thread ne remplacerait-elle pas une erreur dans un 2eme thread.
=> Cela est geree pour nous par POSIX.
->Et normalement, si on utilise un Global qui serait etre le cas. Cependant, le standard positif specifie que errno est plus que juste un Global, c'est ce
qu'on utilise et on l'appelle "thread local storage".
->Alors on garantit de devoir separer la copie d'errno qui valide pour toutes threads qu'on utilise et sera seulement installee par le thread actuel qu'on
est en cours d'execution.

EMBEDDED LINUX TOOLCHAIN OVERVIEW :

->Toolchain: c'est un ensemble d'outils qui compile le code source vers executables qui peut tourner sur un appareil cible (target device).
->On a besoin aussi de toolchain pour construire(build) les autres 3 elements de Linux de systemes embarque comme: le bootloader, le kernel et le
root filesystem.
->Il devrait etre capable de compiler le code ecrit en assembleur, C et C++ puisque ces langages sont la base des open-sources packages.
->Lorsqu'on parle de toolchain, il s'agit de la combinaison d'un tas de composantes differentes, incluant : compiler, Linker, Run-time librairies, GCC or
Clang sont des options toolchains les plus probables.

->GNU Toolchains components:

Le standard GNU toolchains a trois(03) principales composantes:
=>Binutils: un ensemble d'utilites binaires incluant l'assembleur et le linker, il est disponible sur http://www.gnu.org/software/binutils/.

=>GNU Compiler Collection(GCC): Ce sont des compilateurs pour C et d'autres langage qui sont dependant de version de GCC, incluant C++,
Objective-C, Objective-C++, Java, Fortran, Ada and Go. Ils utilisent tous un commun back-end lequel produit un code assembleur qui est envoye vers
GNU assembler. Il est disponible sur http://gcc.gnu.org/

=> C Library: s'agit d'un API standardisee basee sur la specification ou definition de POSIX lequel est l'interface principale entre le systeme
d'exploitation kernel et les applications.

->Types de toolchain - Native Vs Cross toolchain .

En fonction des objectifs voulus, on distingue deux(02) types de toolchain:
=> Native: Ce toolchain marche sur le meme type de systeme, parfois le meme systeme actuel que les programmes qu'il genere. Cela est le cas usuel
pour les ordinateurs de bureau et les serveurs, et il est devenu populaire pour certain classe d'appareils embarques. Le Raspberry Pi executant Debian
pour l'ARM par exemple : possede des compilateurs natifs auto-heberges.

=>Cross: Ce toolchain tourne sur different type de systeme que la cible(target), permettant le developpement d'etre fait sur Un PC bureau rapide et
puis chargee sur la cible(target) embarque pour la phase de test. Et il fonctionne aussi sur une architecture differente de l'hote. La cross compilation est
caracterisee par la separation de host et target.
==>Pourquoi utiliser un cross toolchain?
+Notre Host est probablement plus puissant que le Target, Builds qui est rapide pour construire(build) a partir de la machine d'hote.
+On ne veut pas probablement inclure le development tools dans mon target image.
 ->Avoir cette compilation croisee configuree a partir de la machine d'hote qu'on a l'option d'utiliser la plupart des ressources d'hote comparee au target.

->Creer un environnement de native build a partir de zero n'est pas facile et integre la creation de cross compiler first pour demarrer
l'environnement de build sur le target et en utilisant cela pour construire(build) packages.

-> Setting Up a Toolchain

Il existe deux (02) options:
=>Option1: Faire ca manuellement par downloading/building/installing les composantes moi-meme
=>Option2: Utilise le systeme build pour generer Buildroot ou Yocto Project.

->Specifying Toolchain Targets

=>Pour GNU, une prefixe specifie le
toolchain target.
Ex for QEMU: aarch64-none-linux-gnu-gcc (toutes les prefixes specifient le target toolchain)
=>CPU est ARM 64 bits
=>Vendor Cela identifie le producteur de toolchain. Ex: inclure buildroot, poky, or juste inconnu.
=>Vendor est "none" (support a common set of ARM CPUs)
=>Kernel est "linux"
=> Systeme d'exploitation est GNU GCC

->Building a toolchain with ARM cross compiler :

=>Voici le lien pour acceder aux instruction d'installation de toolchain:
https://github.com/cu-ecen-aeld/aesd-assignments/wiki/installing-an-ARM-aarch64-developer-toolchain

-> bin: ou la repertoire binaire, dans laquelle on installe les outils

-> Etapes de cross compile :
=>exporter le chemin vers la repertoire binaire "bin" comme suit :
export PATH=$PATH:/usr/local/arm-cross-compiler/install/gcc-arm-10.2-2020.11-x86_64-aarch64-none-linux-gnu/bin
=>puis, on compile en croisee pour avoir un code objet, comme suit:
aarch64-none-linux-gnu-gcc -g -wall -c -o writer.o writer.c
=>ensuite, on veut consulter le contenu de fichier objet writer.o tel que :
file writer.o

-> Sysroot, library and header files

=> Sysroot est le root filesystem de mon (cross) toolchain
=> Alors, les fichiers qui vont etre la-dedans sont specifique au type de cible(target)
=> Alors, si on compile pour un type d'architecture ARM 64 bits "aarch64" , les fichiers qui sont localise dans cette repertoire vont tous etre le contenu
qui serait sur le host root file system si on fait une compilation nativement.
=> l'Hote sera les fichier binaire (bin)
=> la cible dans ce cas est "aarch64"
=>Toolchain depend de Sysroot alor Sysroot devra etre installe dans la partie d'installation de toolchain.
=> S'il ya des librairies, on a besoin de creer un lien dans le cadre de l'application, ces librairies seraient ici dans la repertoire sysroot
=>La plupart des fichiers sont necessaires pour compiler les programmes.
=> Les autres sont aussi neccessaires sur le target at runtime (environnement d'execution.).

->Sysroot Directories
=>lib directory va etre les objets partages pour C library et il s'agit de contenu qui va etre necessaire a etre installer sur le target(cible).
=>usr/lib directory est pour les librairies statiques, fichiers archives. Ceci est donc utilise dans le cadre des etapes compilees de la librairie C
=>usr/include directory est pour les Headers for librairies(par ex: <stdio.h>). C'est dans cette repertoir que le fichier va etre mapper lorsqu'on fait une
compilation croise
=>usr/(s)bin: c'est la ouu les programmes utiles pour le cross toolchain serait stockees (ou located). De plus, cela ferait partie des etapes de build ou
apres d'analyser la sortie de mon build et si tu as besoin de fonctionner(tourner) host tools qu'on connait la facon d'analyser ARM executables, c'est
laa(usr/bin) que ces fichiers seront situes dans votre sysroot .

->Sysroot library files

=>sysroot/lib directory contient les fichiers de librairies specifiques pour le toolchain lesquelles seront installee sur le target(dans notre cas sur
aarch64) meme lorsqu'on a construit(built) sur differentes architectures.
=>Remarques: Cette librairie ne va pas etre utilise ou utile pour mon x86 hosts.
=> Est-ce le aarch64-none-linux-gnu-gcc compilateur est dans le toolchain sysroot.
==>Non, car nous faisons du cross compilation.
==>Le aarch64-none-linux-gnu-gcc compilateur est dans mon host system filesystem (et il fonctionne par un systeme d'hote).
=>Other tools in the toolchain
==>NB: On utilise toutes les composantes de cross toolchain avec le meme prefixe reference pour gcc tel que :
aarch64-none-linux-gnu-XXXX

Voici les tools dans toolchain:

==>gcc, g++ -compiler
==>gdb -debugger (crossed debugger)
==>ld-linker
==> addr2line : convertisse adresse programme en filenames/numbers pour debug
==>objdump -desassemble les fichiers objets.
 ==>strip -supprime tables de debug ,- il rend petit aussi les fichiers binaire(bin), alors on peut utiliser une petite espace dans target
==>readelf -information addtionnel a propos de l'executable(code objet, location en memoire, map, etc)

->Static vs Dynamic Linking

=>gcc ou g++ se lie toujours avec glibc, the C library .
=>Static Linkage (Link avec gcc)
==>Toutes les fonctions de librairies et dependances sont depiler a partir d'archive et placee dans mon executable.
=>Dynamic Linkage
==> Mon executable ne possede pas de contenu glibc library
==> Au lieu de cela at runtime, il doit savoir ouu il peut trouver une copie de ce code localement et quand cela est chargee en memoire, le
contenu qu'il a besoin a partir de librairie sera accessible. Alors le benefit etant ici qu'on n'a pas besoin de separer la copie sur le disque pour toute
application qui utilise glibc, que presque toutes les applications vont utiliser. Ils peuvent tous utiliser un fichier partagee qui est placee dans un endroit de
file system, pas besoin de dupliquer cette copie de ce contenu sur le disque.

->Quand utiliser Static Linkage?

=> Lorsqu'on a relativement quelques applications (ou une seule application seulement) dans mon implementation de systeme embarquee
==> Il y a reellement un outil utile qui va etre utilise beaucoup dans ce cours appelee :Busybox
Rq: L'avantage d'utiliser de single application permet au dynamic linkage d'inclure le contenu directement et d'etre executee.
=>On a besoin de fonctionner une application avant que le root filesystem est disponible.
-> Quand notre full file root system n'est pas disponible?
=>Si on demarre(booting up) un appareil, et peut-etre tu ne pourrais pas acceder au contenu de file systeme car il a ete stocke sur un autre apareil qui
a besoin d'un driver specifique pour y acceder. Mais , on peut faire ca a travers un petit programme qui tourne au demarrage qui n'a pas encore l'acces au
full root file system, mais me permet de commencer quelque application qui me donne acces et charger le drivers appropries. => et dans ce cas que ces
applications auraient besoin d'etre static linked (liee statiquement) avec le contenu du full root file system qui n'est pas encore disponible.

->Shared library:
=> permet le partage des objets qui sont liees at runtime, lequel rend plus efficace a utiliser le stockge et la memoire systeme, de plus une copie qui a
besoin d'etre charge.
=> Il rend aussi facilement la mise a jour des fichiers de librairies sans avoir re-link toutes les programmes qui leur utilisent.
=>Le code objet pour shared library doit etre position-independent de sorte que l'editeur de liens d'executions(ou runtime linker) est libre de
localiser dans la memoire au next adresse libre.
=>pour faire une shared library : on ajoute le -fPIC parametre pour gcc, et puis lier(link) en utilisant l'option -shared, comme suit :
$ arm-cortex_a8-linux-gnueabihf-gcc -fPIC -c test1.c
$ arm-cortex_a8-linux-gnueabihf-gcc -fPIC -c test2.c
$ arm-cortex_a8-linux-gnueabihf-gcc -shared -o libtest.so test1.o
test2.o

=>Shared library Locations:

L'editeur de liens (ou Linker) verifie les shared librairies dans :
==> /lib, /lib64
==> /usr/lib, /usr/lib64
==> content of LD_LIBRARY_PATH

Logging and Syslog

->Printf Debugging: la sortie print est une des simples facons pour cibler et debug une application.
->L'appel de printf fonctionne mieux pour les programmes interactives.
->What about headless embedded systems?
=>On a besoin de quelques facons de stocker les information dans log files a travers quelques types de Framework logging comme Syslog et
syslogd(rsyslogd) .
==> Syslogd : -Il utilise les fichiers de configuration pour configurer logging qui est ecrit sur le file system, typiquement on trouvera ces log files
ecrit dans le repertoire var/log.
-Il manipule log messages a partir d'une application utilisant l'appel d'un API syslog().
->Syslog Usage : On va vraiment diviser le log messages en facilities et priorities.
on a : Facilities: log_user, log_daemon, log_local0 to, log_local7,...
Priorities: log_error, log_warning, log_info , log_debug ,...
->Comment syslog est configure?
=> log redirection dans Ubuntu VM se produit en fonction des regles dans /etc/rsyslog.d/*default.conf
ANNEXE:
MSYS2: est une plateforme de distribution et de developpement de logiciels qui permet de porter des logiciels du monde UNIX vers Microsoft
Windows.
WSL: permet d'executer des binaires linux sur Windows, en excluant certains appels du noyau et la quasi-totalite des apps graphiques.
LAN: Groupe d'appareils informatiques dans une zone localisee qui partagent generalement une connexion Internet centralisee.
Process: c'est un programme executable identifie par une unique identificateur de process, appele PID . Il peut etre court dans la duree, comme un
processus qui imprime des fichiers sur l'ecran, ou qu'ils tournent indefinitivement comme un programme monitor
File: c'est une collection de donnees qui se trouve dans un systeme de fichier appele chemin. Ce chemin sera typiquement une serie de mots( des noms
de repertoire) separes par des slashs('/") . Et aussi Files sont generalement crees par des utilisateurs avec des editeurs de texte, compilateur .

Directory(ou repertoire): c'est un type special de fichiers , il est l'equivalent de Dossier dans Windows pour maintenir les informations a propos des autres
fichiers .

Cmake: est un systeme de construction logicielle multiplateforme. Il permet de verifier les prerequis necessaires a la construction, de determiner les
dependances entre les #ts composants d'un projet pour planifier une construction ordonnee et adaptee a la plateforme.

Make et Cmake: sont des commandes distribues par un systeme d'exploitation UNIX avec un environnement SHELL

CMAKE_BUILD_TYPE: specifie le type de construction sur les generateurs a configuration unique

-------------------------------------------------------------

LINUX FROM THE BOOK