diff --git a/20210604/bs-20210604.txt b/20210604/bs-20210604.txt new file mode 100644 index 0000000000000000000000000000000000000000..66c42207450821cc5674a05649657c5cb69b5a16 --- /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 0000000000000000000000000000000000000000..c404db3bdb22a6b0a0a1e30b47b4b2de0a048f12 --- /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 0000000000000000000000000000000000000000..de7774f79a26406bf5032f8d9a4fa543e35963fe --- /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 0000000000000000000000000000000000000000..ff6363eddfa2b6d26ae5c390f96306702afd60f8 --- /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 0000000000000000000000000000000000000000..8853ecaed14074e136a764fbdb868d5fe7a4baf3 --- /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 0000000000000000000000000000000000000000..92ef091a9f00a93ed834071bd425b5b60238c3ee --- /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 0000000000000000000000000000000000000000..b5273ec483618b33585ff78f70f419bdff149950 --- /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 0000000000000000000000000000000000000000..21f2d5d32d075a33bd94abeb9b69495d58b8c8a5 --- /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 0000000000000000000000000000000000000000..00ddb6790a669f3040dd7439c98c30d01227662d --- /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 0000000000000000000000000000000000000000..34c4b6ae3bebb451979307c61f3cfe66c5477f87 --- /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 0000000000000000000000000000000000000000..8acc3dde82d8d7f7c4fd77714a3f5f65b7aa2b96 --- /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 0000000000000000000000000000000000000000..c31ba9b27a39f587474632b0442cbc33d20206eb --- /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 0000000000000000000000000000000000000000..6a7d035151eb23eeee6ddba83232afe8e9485293 --- /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 0000000000000000000000000000000000000000..45e883c1f746de42bf8b2cfc0bcebb61e9c862e2 --- /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 0000000000000000000000000000000000000000..c4c537612a4d24d1b7bf20bb8c3f53a30c0a3322 --- /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 0000000000000000000000000000000000000000..ec7436ced4f38d6a9673af3df5382e64b119ca46 --- /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 0000000000000000000000000000000000000000..88b33b2192d4d917dd30c340c55cbc527164099c --- /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 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/20210604/test.txt b/20210604/test.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391