Comment fonctionne une interface graphique Linux au niveau le plus bas?
J'essaie essentiellement de comprendre comment on irait faire une interface graphique d'une grève absolue sans rien que le noyau Linux et la programmation en C.
Je ne cherche pas à créer un environnement de bureau d'interface graphique à partir de zéro, mais je voudrais créer des applications de bureau et dans ma recherche de connaissances, toutes les informations que j'ai pu trouver sont sur les API d'interface graphique et des outils à outils. J'aimerais savoir, à tout le moins pour ma compréhension des principes fondamentaux de la façon dont la GUI Linux est faite, comment l'on irait faire un environnement d'interface graphique ou une application d'interface graphique sans utiliser d'API ni de sautille à outils.
Je me demande si par exemple:
les API et les outils à outils existants fonctionnent via des appels système vers le noyau (et le noyau est responsable au niveau le plus bas pour la construction d'une image d'interface graphique en pixels ou quelque chose).
ces boîtes à outils effectuent des syscalls qui passent simplement des informations aux pilotes d'écran (y a-t-il un format standard pour l'envoi de ces informations que tous les pilotes d'écran respectent ou font des API d'interface graphique doivent pouvoir émettre ces informations dans plusieurs formats en fonction de l'écran/pilote spécifique? ) Et aussi si cela est grossièrement vrai, le noyau Linux brut envoie-t-il généralement simplement des informations à l'écran sous la forme de caractères 8 bits?
Je veux juste vraiment comprendre ce qui se passe entre le noyau Linux et ce que je vois sur mon écran (flux de contrôle/information via des logiciels et du matériel si vous le savez, quel format les informations prend, etc.). Je comprendrais énormément une explication détaillée, je crois comprendre que cela pourrait être une Dousie à expliquer suffisamment de détails, mais je pense qu'une telle explication serait une excellente ressource pour d'autres personnes curieuses et apprenantes. Pour le contexte, je suis un étudiant SCI de 3ème année qui a récemment lancé la programmation en C pour le cours de programmation de mon système et j'ai un intermédiaire (ou je la décrire) de la compréhension de Linux et de la programmation. Encore merci à quiconque m'aide !!!
Comment ça marche (gnu/linux + x11)
Aperçu
Il ressemble à quelque chose comme ça (ne s'appuie pas à l'échelle)
┌───────────────────────────────────────────────┐
│ User │
│ ┌─────────────────────────────────────────┤
│ │ Application │
│ │ ┌──────────┬─────┬─────┬─────┤
│ │ │ ... │ SDL │ GTK │ QT │
│ │ ├──────────┴─────┴─────┴─────┤
│ │ │ xLib │
│ │ ├────────────────────────────┤
├─────┴───┬────────┴──┐ X11 │
│ Gnu │ Libraries │ Server │
│ Tools │ │ │
├─────────┘ │ │
├─────────────────────┤ │
│ Linux (kernel) │ │
├─────────────────────┴─────────────────────────┤
│ Hardware │
└───────────────────────────────────────────────┘
Nous voyons du diagramme que X11 parle principalement du matériel. Cependant, il doit parler via le noyau, pour avoir d'abord accès à ce matériel.
Je suis un peu brumeux sur le détail (et je pense que cela a changé depuis que je l'ai examiné de la dernière fois). Il y a un appareil /dev/mem Cela donne accès à l'ensemble de la mémoire (je pense que la mémoire physique), car la plupart du matériel graphique est mappée de mémoire mappée, ce fichier (voir tout est un fichier) peut être utilisé pour y accéder. X11 ouvrirait le fichier (le noyau utilise des autorisations de fichier pour voir si elle peut le faire), puis x11 utilise mmap _ _ pour mapper le fichier dans la mémoire virtuelle (ce qui ressemble à une mémoire), la mémoire ressemble à la mémoire. Après mmap, le noyau n'est pas impliqué.
X11 doit savoir sur les différents matériels graphiques, car il l'accède directement à la mémoire.
(Cela peut avoir des modifications, en particulier le modèle de sécurité, ne peut plus donner accès à [~ # ~] tout [~ # ~ ~] de la mémoire.)
Linux
En bas, Linux (le noyau): une petite partie du système. Il fournit accès au matériel et implémente la sécurité.
Gnou
Ensuite, GNU (bibliothèques; Bash; Outils: LS, etc; C compilateur C, etc.). La plupart du système d'exploitation.
X11 SERVER (E.G. X.ORG)
Ensuite, X11 (ou Wayland, ou ...), le sous-système GUI de base. Cela fonctionne dans la terre utilisateur (en dehors du noyau): il s'agit simplement d'un autre processus, avec quelques privilèges. Le noyau ne s'implique pas, sauf pour donner accès au matériel. Et fournir une communication inter-processus, de sorte que d'autres processus puissent parler avec le serveur X11.
X11 Bibliothèque
Une simple abstraction pour vous permettre d'écrire du code pour X11.
Bibliothèques d'interface graphique
Les bibliothèques telles que QT, GTK, SDL, sont ensuite - elles facilitent l'utilisation du X11 et de travailler sur d'autres systèmes tels que Wayland, Windows ou MacOS.
Applications
Les applications reposent sur les bibliothèques.
Quelques points d'entrée de bas niveau, pour la programmation
xlib
Utiliser XLIB, c'est un bon moyen d'apprendre sur X11. Cependant, faites-en une lecture sur X11 en premier.
Sdl
SDL vous donnera un accès de bas niveau, directement aux avions bit-plans pour vous tirer directement.
Aller plus bas
Si vous voulez aller plus bas, alors je ne suis pas sûr des bonnes options de courant, mais voici quelques idées.
- Obtenez un ancien amiga ou un simulateur. Et une bonne documentation. par exemple. https://archive.org/details/amiga_system_programers_guide_1988_abacus/mode/2up (J'avais 2 livres, celui-ci et similaire).
- Regardez ce qui peut être fait sur un PI de framboise. Je n'ai pas regardé ça.
Liens
X11
https://fr.wikipedia.org/wiki/x_window_system
Façons modernes
Écrire cela a mon intérêt, alors j'avais un coup d'œil à ce que le moyen rapide moderne de le faire est. Voici quelques liens:
https://blogs.igalia.com/itoral/2014/07/29/a-brief-introduction-a-the-linux-graphics-stack/
la réponse de Ctrl-Alt-Delor vous donne un bon aperçu de l'architecture générale. Pour une approche plus pratique, je vous donne une réponse concernant "rien que le noyau Linux et la programmation en C".
J'aime écrire directement sur le tampon de l'image de temps en temps. Le pilote de périphérique TARED-TAFFER fera tous les fastidieux proche du matériel "Comment cela finira-t-il finalement sur un écran" des choses pour vous. Vous pouvez le faire tout de suite avec une coquille racine:
echo -n -e '\x00\x00\xFF' > /dev/fb0
Il définit le tout premier pixel (en haut à gauche) au rouge sur ma trametbuffer 32 bits:
Vous pouvez totalement le faire de l'intérieur C en ouvrant/dev/fb0 et en écriture d'octets. La cartographie de la mémoire peut devenir votre ami. Cela ne fonctionne que sans un serveur X ni dans une console virtuelle. Appuyez sur CTRL + ALT + F1 pour y accéder.
PS: visualiser des données aléatoires telles que votre mouvement de souris peut également être amusant:
cat /dev/input/mouse0 > /dev/fb0
PPS: Veuillez également noter que pratiquement toutes les applications de bureau réel du monde réel veulent un accès plus direct au matériel pour certaines choses fantaisistes telles que l'accélération matérielle pour le dessin, le rendu 3D et la vidéo. Le simple dispositif de tampon de cadre ne fera rien de tout cela.
Je recommanderais fortement de commencer par NCurses .
Contrairement à des systèmes graphiques plus complexes, il repose uniquement sur le texte, il n'est donc pas nécessaire de vous enliser dans les détails des pilotes d'écran et des bibliothèques graphiques. Toutefois, les principes de base de la mise en place de Windows sur un écran, se concentrent sur Windows, etc., maintiennent toujours true. Et vous pouvez toujours faire des dessins, au niveau des blocs de caractères uniques et ASCII art.
Bien sûr, vous construisez toujours cela au-dessus d'une bibliothèque, mais c'est une bibliothèque que vous pouvez facilement comprendre. Et plus que cela, c'est une bibliothèque où le code source est librement disponible, assez bien documenté, et pas trop impénétrable si vous souhaitez le lire. Vous pouvez même la modifier vous-même si vous le souhaitez. Ou vous pouvez regarder toutes les fonctions de la bibliothèque de là pour trouver ce que l'API doit être, et l'écrire vous-même de zéro en fonction de cette conception.
Sunos 5 avait la bibliothèque de la DGA, qui fournissait des adaptateurs indépendants indépendants aux différents adaptateurs Graphics CG [3,6,14], TCX ou LEO, qui était également la chose qui a également été prise en charge de Doom sur le SPARC Machines.
cG6 était 8 bits, généralement utilisé en X11 comme un pseudocolore visuel, mais il pourrait également fournir une truecolor 8 bits tandis que le TCX et LEO sont un tampon d'affichage 3D accéléré de 24 bits (pseudocolor = un octet dans Videoram est un index dans un grand Tableau qui donne une valeur 3x8 RGB, le contenu de la table peut être modifié facilement.) La CG3 avait à peu près la même capacité, mais elle n'a pas été accélérée (les concepteurs CG6 ont commencé par la suite une autre ferme ... Nvidia.)
Les derniers dispositifs tels que le PGX basé sur ATI Rage Pro Chipset ne pouvaient pas supporter le truecolor et le pseudocolor en même temps, que les premiers ont fait. Cela a forcé un utilisateur à choisir entre anciennes applications écrites pour le modèle pseudocolor (ou mettre à niveau le SO si possible) et ne exécutant que des applications orientées Truecolor.
Le pseudocolor existait essentiellement parce que Videoram était terriblement coûteux au milieu des années 80 à 1992. Un affichage de couleur qui supportait une résolution de type de poste de travail utilisable était également assez cher (le soleil 2 de 1984 noir et blanc avait une résolution de 1152x864 tandis qu'un MG1 de 1989 avait 1600x1280 mais B & W.)
J'écris cela parce que je veux montrer les différentes exigences que X11 a dû soutenir.