From e772afd4bbf4acd16683e672f8e5f4a5f56f695d Mon Sep 17 00:00:00 2001 From: Peter Gerwinski <peter.gerwinski@hs-bochum.de> Date: Mon, 7 Jun 2021 10:07:16 +0200 Subject: [PATCH] Notizen und Beispiele 4.6.2021 --- 20210604/bs-20210604.txt | 114 +++++++++++++++++++++++++++++++++++++ 20210604/shm-1a.c | 10 ++++ 20210604/shm-1b.c | 13 +++++ 20210604/shm-1c.c | 14 +++++ 20210604/shm-2a.c | 11 ++++ 20210604/shm-2b.c | 14 +++++ 20210604/shm-3a.c | 14 +++++ 20210604/shm-3b.c | 15 +++++ 20210604/shm-4a.c | 14 +++++ 20210604/shm-4b.c | 14 +++++ 20210604/shm-5a.c | 14 +++++ 20210604/shm-5b.c | 14 +++++ 20210604/shm-6.txt | 35 ++++++++++++ 20210604/shm-6a.c | 19 +++++++ 20210604/shm-6c.c | 19 +++++++ 20210604/shm-6c.txt | 36 ++++++++++++ 20210604/shm-6d.txt | 40 +++++++++++++ 20210604/test-hardlink.txt | 0 20210604/test.txt | 0 19 files changed, 410 insertions(+) create mode 100644 20210604/bs-20210604.txt create mode 100644 20210604/shm-1a.c create mode 100644 20210604/shm-1b.c create mode 100644 20210604/shm-1c.c create mode 100644 20210604/shm-2a.c create mode 100644 20210604/shm-2b.c create mode 100644 20210604/shm-3a.c create mode 100644 20210604/shm-3b.c create mode 100644 20210604/shm-4a.c create mode 100644 20210604/shm-4b.c create mode 100644 20210604/shm-5a.c create mode 100644 20210604/shm-5b.c create mode 100644 20210604/shm-6.txt create mode 100644 20210604/shm-6a.c create mode 100644 20210604/shm-6c.c create mode 100644 20210604/shm-6c.txt create mode 100644 20210604/shm-6d.txt create mode 100644 20210604/test-hardlink.txt create mode 100644 20210604/test.txt diff --git a/20210604/bs-20210604.txt b/20210604/bs-20210604.txt new file mode 100644 index 0000000..66c4220 --- /dev/null +++ b/20210604/bs-20210604.txt @@ -0,0 +1,114 @@ +Ergänzung: Hauptspeicherverwaltung, 04.06.2021, 11:44:33 +======================================================== + +Gemeinsamer Speicherzugriff mehrerer Programme – Shared Memory +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Ein Programm kann Shared Memory anfordern +und wie eine Datei ansprechen: Name, read(), write(), close() + +Es ist möglich, diese "Datei" in einen Zeiger umzuwandeln. +Ab da kann ich auf den Shared Memory "normal" zugreifen. + +Es ist auch möglich, eine echte Datei in einen Zeiger umzuwandeln. +Ab da kann ich auf die Datei wie auf Speicher zugreifen. +Achtung: Die Datei muß mindestens 1 Byte groß sein. +Es ist nicht möglich, auf diese Weise die Länge der Datei zu ändern, +sondern ich kann dort nur Bytes überschreiben. + +Anwendungen: + + - Shared Memory: Kommunikation zwischen mehreren Programmen + + - Ganz andere Art, mit Dateien umzugehen, z.B.: + Eine Datei, die ein binär abgespeichertes Array enthält, + vom Programm aus als Array ansprechen. + + - Direktes Ansprechen von Speicherzellen über die Gerätedatei /dev/mem + + cassini/home/peter/bo/2021ss/bs/20210604> ls -l /dev/mem + crw-r----- 1 root kmem 1, 1 Apr 6 09:59 /dev/mem + + - Anwendung davon: Ansprechen der GPIOs auf Einplatinen-Computern, + z.B. Olimex oder Raspberry Pi + Nach einem mmap auf die Datei /dev/mem können wir + über einen Zeiger direkt physikalische Speicherzellen ansprechen. + +Literatur: +https://openbook.rheinwerk-verlag.de/linux_unix_programmierung/Kap18B-003.htm + + + Pause bis 13:45 Uhr + ******************* + + +13:17 Uhr: Ich muß *jetzt* zur Autowerkstatt. Für den Fall, daß ich +nicht rechtzeitig zurück bin, schaut Euch bitte schon mal die Seite +https://de.wikipedia.org/wiki/Meltdown_(Sicherheitslücke) an und +versucht, das dortige Beispielprogramm zu verstehen. Bis nachher! + +Die Meltdown-Sicherheitslücke, 04.06.2021, 14:23:55 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Sicherheitslücke: Der Prozessor liest mehrere Befehle im Voraus, +bevor er sie ausführt. Dadurch wird es möglich, Speicher ohne +Berechtigung auszulesen. + + ; rcx = kernel address + ; rbx = probe array + retry: + movzx rax, byte [rcx] ; Lädt den Inhalt der auszulesenden Speicherstelle in Register rax. + ; Das führt zu einer Ausnahmebehandlung. + ; Der folgende Code wird nur prozessorintern im Voraus ausgeführt. + shl rax, 12 ; Multipliziert den Inhalt des 64-bit Registers rax mit 4096, + ; so dass es nun eine Seitenadresse enthält, die vom Inhalt der + ; auszulesenden Speicherstelle abhängt. + jz retry ; Beginnt von vorn, wenn das Zero-Flag (und damit hier auch rax) + ; gleich 0 ist (Auch bei [rcx]=0 keine Endlosschleife, da aufgrund + ; der Ausnahmebehandlung die out-of-order Ausführung schließlich + ; abgebrochen wird). + mov rbx, qword [rbx + rax] ; Greift auf eine Speicherstelle auf der Seite zu, deren Index innerhalb + ; des probe arrays rbx in rax steht. Dies lädt eine Seite in den Cache, + ; deren Adresse vom Inhalt der auszulesenden Speicherstelle abhängt. + + Quelle: https://de.wikipedia.org/w/index.php?title=Meltdown_(Sicherheitsl%C3%BCcke)&oldid=210862049 + Autor: siehe https://de.wikipedia.org/w/index.php?title=Meltdown_(Sicherheitsl%C3%BCcke)&action=history + Lizenz: CC BY-SA 3.0 Unported + +Wir lesen eine nicht lesbare Speicherzelle und stürzen ab. +In den danach stehenden Befehlen verwenden wir den (nicht) +gelesenen Wert als Index für ein Array von Speicherseiten, +d.h., 4096-Byte-Blöcken. +Dadurch ordnet der Kernel dieser bislang rein virtuellen +Speicherseite physikalischen Speicher zu. +Wenn ich danach noch einmal auf dieselbe Speicherseite zugreife, +geschieht dies schneller, als wenn sie nicht im Voraus geladen +wäre. Ein zweiter Thread macht das und mißt die Zeit. + +Massenspeicherverwaltung, 04.06.2021, 14:59:19 +============================================== + +In speziellen Fällen können auch größere Blockgrößen sinnvoll sein: + + - wenn das Dateisystem vorwiegend mit eher großen Dateien genutzt wird + + - wenn der Datenträger physikalisch mit einer größeren Blockgröße arbeitet + --> Vermeidung mehrfachen Speicherns auf Flash-Speicher + +Das ext2-Dateisystem, 04.06.2021, 15:05:30 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Superblock: globale Informationen über das Dateisystem + +inode (Indexknoten): enthält alle Informationen über eine Datei + bis auf den Dateinamen und die eigentlichen Daten. + feste Größe + +15 Zeiger auf die Daten: + - 12 Zeiger direkt auf Datenblöcke + - 1 Zeiger auf einen Block mit 128 weiteren Zeigern + - 1 Zeiger auf einen Block mit 128 weiteren Zeigern auf jeweils 128 weitere Zeiger + - 1 Zeiger auf einen Block mit 128 weiteren Zeigern auf jeweils 128 weitere Zeiger auf jeweils 128 weitere Zeiger + - Bei sehr kleinen Dateien wird der Inhalt anstelle der Zeiger + direkt im inode gespeichert. + +Verzeichnis = spezielle Datei, repräsentiert durch einen inode + Einträge: Name --> inode + Hard Link = 2 Namen für denselben inode diff --git a/20210604/shm-1a.c b/20210604/shm-1a.c new file mode 100644 index 0000000..c404db3 --- /dev/null +++ b/20210604/shm-1a.c @@ -0,0 +1,10 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> + +int main (void) +{ + int shm = shm_open ("test", O_RDWR, 0666); + write (shm, "Hello, world!", 13); + return 0; +} diff --git a/20210604/shm-1b.c b/20210604/shm-1b.c new file mode 100644 index 0000000..de7774f --- /dev/null +++ b/20210604/shm-1b.c @@ -0,0 +1,13 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdio.h> + +int main (void) +{ + char buffer[42]; + int shm = shm_open ("test", O_RDONLY, 0444); + read (shm, buffer, 42); + printf ("%s\n", buffer); + return 0; +} diff --git a/20210604/shm-1c.c b/20210604/shm-1c.c new file mode 100644 index 0000000..ff6363e --- /dev/null +++ b/20210604/shm-1c.c @@ -0,0 +1,14 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdio.h> + +int main (void) +{ + char buffer[42]; + int shm = shm_open ("test", O_RDONLY, 0444); + lseek (shm, 0, SEEK_SET); + read (shm, buffer, 42); + printf ("%s\n", buffer); + return 0; +} diff --git a/20210604/shm-2a.c b/20210604/shm-2a.c new file mode 100644 index 0000000..8853eca --- /dev/null +++ b/20210604/shm-2a.c @@ -0,0 +1,11 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> + +int main (void) +{ + int shm = shm_open ("test", O_CREAT | O_RDWR, 0666); + write (shm, "Hello, world!", 14); + close (shm); + return 0; +} diff --git a/20210604/shm-2b.c b/20210604/shm-2b.c new file mode 100644 index 0000000..92ef091 --- /dev/null +++ b/20210604/shm-2b.c @@ -0,0 +1,14 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdio.h> + +int main (void) +{ + char buffer[42]; + int shm = shm_open ("test", O_RDONLY, 0444); + read (shm, buffer, 42); + close (shm); + printf ("%s\n", buffer); + return 0; +} diff --git a/20210604/shm-3a.c b/20210604/shm-3a.c new file mode 100644 index 0000000..b5273ec --- /dev/null +++ b/20210604/shm-3a.c @@ -0,0 +1,14 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdio.h> + +int main (void) +{ + int file = open ("test.txt", O_CREAT | O_RDWR, 0666); + printf ("file = %d\n", file); + lseek (file, 0, SEEK_SET); + write (file, "Hello, world!", 14); + close (file); + return 0; +} diff --git a/20210604/shm-3b.c b/20210604/shm-3b.c new file mode 100644 index 0000000..21f2d5d --- /dev/null +++ b/20210604/shm-3b.c @@ -0,0 +1,15 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdio.h> + +int main (void) +{ + char buffer[42]; + int file = open ("test.txt", O_RDONLY, 0444); + lseek (file, 0, SEEK_SET); + read (file, buffer, 42); + close (file); + printf ("%s\n", buffer); + return 0; +} diff --git a/20210604/shm-4a.c b/20210604/shm-4a.c new file mode 100644 index 0000000..00ddb67 --- /dev/null +++ b/20210604/shm-4a.c @@ -0,0 +1,14 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <string.h> + +int main (void) +{ + int shm = shm_open ("test", O_CREAT | O_RDWR, 0666); + char *buffer = mmap (NULL, 42, PROT_READ | PROT_WRITE, MAP_SHARED, shm, 0); + strcpy (buffer, "Hello, world!"); + munmap (buffer, 42); + close (shm); + return 0; +} diff --git a/20210604/shm-4b.c b/20210604/shm-4b.c new file mode 100644 index 0000000..34c4b6a --- /dev/null +++ b/20210604/shm-4b.c @@ -0,0 +1,14 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdio.h> + +int main (void) +{ + int shm = shm_open ("test", O_RDONLY, 0444); + char *buffer = mmap (NULL, 42, PROT_READ, MAP_SHARED, shm, 0); + printf ("%s\n", buffer); + munmap (buffer, 42); + close (shm); + return 0; +} diff --git a/20210604/shm-5a.c b/20210604/shm-5a.c new file mode 100644 index 0000000..8acc3dd --- /dev/null +++ b/20210604/shm-5a.c @@ -0,0 +1,14 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <string.h> + +int main (void) +{ + int file = open ("test.txt", O_CREAT | O_RDWR, 0666); + char *buffer = mmap (NULL, 42, PROT_READ | PROT_WRITE, MAP_SHARED, file, 0); + strcpy (buffer, "Hello, world!"); + munmap (buffer, 42); + close (file); + return 0; +} diff --git a/20210604/shm-5b.c b/20210604/shm-5b.c new file mode 100644 index 0000000..c31ba9b --- /dev/null +++ b/20210604/shm-5b.c @@ -0,0 +1,14 @@ +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdio.h> + +int main (void) +{ + int file = open ("test.txt", O_RDONLY, 0444); + char *buffer = mmap (NULL, 42, PROT_READ, MAP_SHARED, file, 0); + printf ("%s\n", buffer); + munmap (buffer, 42); + close (file); + return 0; +} diff --git a/20210604/shm-6.txt b/20210604/shm-6.txt new file mode 100644 index 0000000..6a7d035 --- /dev/null +++ b/20210604/shm-6.txt @@ -0,0 +1,35 @@ +cassini/home/peter/bo/2021ss/bs/20210604> cat shm-6a.c +#include <stdio.h> +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <string.h> + +int main (void) +{ + int file = open ("test.txt", O_CREAT | O_RDWR, 0666); + fprintf (stderr, "0\n"); + char *buffer = mmap (NULL, 42, PROT_READ | PROT_WRITE, MAP_SHARED, file, 0); + fprintf (stderr, "1\n"); + strcpy (buffer, "Hello, world!"); + fprintf (stderr, "2\n"); + munmap (buffer, 42); + fprintf (stderr, "3\n"); + close (file); + return 0; +} +cassini/home/peter/bo/2021ss/bs/20210604> ./shm-6a +0 +1 +Bus-Zugriffsfehler +cassini/home/peter/bo/2021ss/bs/20210604> ls -l test.txt +-rw-r--r-- 1 peter peter 0 Jun 4 12:20 test.txt +cassini/home/peter/bo/2021ss/bs/20210604> echo "Dies ist ein Test." > test.txt +cassini/home/peter/bo/2021ss/bs/20210604> ./shm-6a +0 +1 +2 +3 +cassini/home/peter/bo/2021ss/bs/20210604> cat test.txt +Hello, world!est. +cassini/home/peter/bo/2021ss/bs/20210604> diff --git a/20210604/shm-6a.c b/20210604/shm-6a.c new file mode 100644 index 0000000..45e883c --- /dev/null +++ b/20210604/shm-6a.c @@ -0,0 +1,19 @@ +#include <stdio.h> +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <string.h> + +int main (void) +{ + int file = open ("test.txt", O_CREAT | O_RDWR, 0666); + fprintf (stderr, "0\n"); + char *buffer = mmap (NULL, 42, PROT_READ | PROT_WRITE, MAP_SHARED, file, 0); + fprintf (stderr, "1\n"); + strcpy (buffer, "Hello, world!"); + fprintf (stderr, "2\n"); + munmap (buffer, 42); + fprintf (stderr, "3\n"); + close (file); + return 0; +} diff --git a/20210604/shm-6c.c b/20210604/shm-6c.c new file mode 100644 index 0000000..c4c5376 --- /dev/null +++ b/20210604/shm-6c.c @@ -0,0 +1,19 @@ +#include <stdio.h> +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <string.h> + +int main (void) +{ + int file = open ("test.txt", O_CREAT | O_RDWR, 0666); + fprintf (stderr, "0\n"); + char *buffer = mmap (NULL, 42, PROT_READ | PROT_WRITE, MAP_SHARED, file, 0); + fprintf (stderr, "1\n"); + strcpy (buffer, "Dies ist ein weiterer Test."); + fprintf (stderr, "2\n"); + munmap (buffer, 42); + fprintf (stderr, "3\n"); + close (file); + return 0; +} diff --git a/20210604/shm-6c.txt b/20210604/shm-6c.txt new file mode 100644 index 0000000..ec7436c --- /dev/null +++ b/20210604/shm-6c.txt @@ -0,0 +1,36 @@ +#include <stdio.h> +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <string.h> + +int main (void) +{ + int file = open ("test.txt", O_CREAT | O_RDWR, 0666); + fprintf (stderr, "0\n"); + char *buffer = mmap (NULL, 42, PROT_READ | PROT_WRITE, MAP_SHARED, file, 0); + fprintf (stderr, "1\n"); + strcpy (buffer, "Dies ist ein weiterer Test."); + fprintf (stderr, "2\n"); + munmap (buffer, 42); + fprintf (stderr, "3\n"); + close (file); + return 0; +} +cassini/home/peter/bo/2021ss/bs/20210604> gcc -Wall -O shm-6c.c -o shm-6c -lrt +cassini/home/peter/bo/2021ss/bs/20210604> ls -l test.txt +-rw-r--r-- 1 peter peter 19 Jun 4 12:21 test.txt +cassini/home/peter/bo/2021ss/bs/20210604> ./shm-6c +bs-20210604.txt shm-2a shm-3b shm-5a shm-6c +shm-1a shm-2a.c shm-3b.c shm-5a.c shm-6c.c +shm-1a.c shm-2b shm-4a shm-5b shm-6.txt +shm-1b shm-2b.c shm-4a.c shm-5b.c test.txt +shm-1b.c shm-3a shm-4b shm-6a +shm-1c.c shm-3a.c shm-4b.c shm-6a.c +cassini/home/peter/bo/2021ss/bs/20210604> ./shm-6c +0 +1 +2 +3 +cassini/home/peter/bo/2021ss/bs/20210604> cat test.txt +Dies ist ein weitercassini/home/peter/bo/2021ss/bs/20210604> diff --git a/20210604/shm-6d.txt b/20210604/shm-6d.txt new file mode 100644 index 0000000..88b33b2 --- /dev/null +++ b/20210604/shm-6d.txt @@ -0,0 +1,40 @@ +cassini/home/peter/bo/2021ss/bs/20210604> echo -e "x" > test.txt +cassini/home/peter/bo/2021ss/bs/20210604> ls -l test.txt +-rw-r--r-- 1 peter peter 2 Jun 4 12:31 test.txt +cassini/home/peter/bo/2021ss/bs/20210604> cat shm-6c.c +#include <stdio.h> +#include <sys/mman.h> +#include <fcntl.h> +#include <unistd.h> +#include <string.h> + +int main (void) +{ + int file = open ("test.txt", O_CREAT | O_RDWR, 0666); + fprintf (stderr, "0\n"); + char *buffer = mmap (NULL, 42, PROT_READ | PROT_WRITE, MAP_SHARED, file, 0); + fprintf (stderr, "1\n"); + strcpy (buffer, "Dies ist ein weiterer Test."); + fprintf (stderr, "2\n"); + munmap (buffer, 42); + fprintf (stderr, "3\n"); + close (file); + return 0; +} +cassini/home/peter/bo/2021ss/bs/20210604> ./shm-6c +0 +1 +2 +3 +cassini/home/peter/bo/2021ss/bs/20210604> cat test.txt +Dicassini/home/peter/bo/2021ss/bs/20210604> ls -l test.txt +-rw-r--r-- 1 peter peter 2 Jun 4 12:31 test.txt +cassini/home/peter/bo/2021ss/bs/20210604> rm test.txt +cassini/home/peter/bo/2021ss/bs/20210604> touch test.txt +cassini/home/peter/bo/2021ss/bs/20210604> ls -l test.txt +-rw-r--r-- 1 peter peter 0 Jun 4 12:31 test.txt +cassini/home/peter/bo/2021ss/bs/20210604> ./shm-6c +0 +1 +Bus-Zugriffsfehler +cassini/home/peter/bo/2021ss/bs/20210604> diff --git a/20210604/test-hardlink.txt b/20210604/test-hardlink.txt new file mode 100644 index 0000000..e69de29 diff --git a/20210604/test.txt b/20210604/test.txt new file mode 100644 index 0000000..e69de29 -- GitLab