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