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