ProbeVue in Action: Identifizieren eines Abstürzenden Prozesses

Kürzlich meldete unser Monitoring ein volles /var-Filesystem auf einem unserer Systeme. Schnell war herausgefunden das Core-Files im Verzeichnis /var/adm/core das Filesystem gefüllt hatten. Es stellte sich schnell heraus das alle Core-Files von Perl stammten. Allerdings konnte anhand der Core-Files nicht festgestellt werden welches Perl-Skript den Absturz von Perl verursacht hatte. Ein Blick auf die Zeitstempel der Core-Files ließ leider kein Muster erkennen:

-bash-4.4$ ls -ltr /var/adm/core
total 2130240
drwxr-xr-x    2 root     system          256 Jan 29 10:20 lost+found/
-rw-------    1 root     system    100137039 Jun 26 04:51 core.22610328.26025105.Z
-rw-------    1 root     system     99054991 Jun 26 06:21 core.21102892.26042104.Z
-rw-------    1 root     system     99068916 Jun 26 08:06 core.18153840.26060607.Z
-rw-------    1 root     system    100132866 Jun 26 08:21 core.19005848.26062105.Z
-rw-------    1 root     system     97986020 Jun 26 16:36 core.15270246.26143608.Z
-rw-------    1 root     system     99208958 Jun 26 22:21 core.22675838.26202106.Z
-rw-------    1 root     system     97557063 Jun 27 01:06 core.5505292.26230604.Z
-rw-------    1 root     system     98962499 Jun 27 10:06 core.8257960.27080603.Z
-rw-------    1 root     system     99804173 Jun 27 14:51 core.18940202.27125107.Z
-rw-------    1 root     system     99633676 Jun 28 03:21 core.17563960.28012107.Z
-rw-------    1 root     system     99116032 Jun 28 19:06 core.8651210.28170608.Z
-bash-4.4$

Auch die Einträge im Error Report lieferten keine Informationen um welches Perl-Skript es sich hier handelt und auf welchem Wege dieses gestartet wurde.

 

-bash-4.4$ sudo errpt -j A924A5FC –a
...
---------------------------------------------------------------------------
LABEL:          CORE_DUMP
IDENTIFIER:     A924A5FC

Date/Time:       Wed May 29 15:21:25 CEST 2019
Sequence Number: 17548
Machine Id:      XXXXXXXXXXXX
Node Id:         XXXXXXXX
Class:           S
Type:            PERM
WPAR:            Global
Resource Name:   SYSPROC        

Description
SOFTWARE PROGRAM ABNORMALLY TERMINATED

Probable Causes
SOFTWARE PROGRAM

User Causes
USER GENERATED SIGNAL

        Recommended Actions
        CORRECT THEN RETRY

Failure Causes
SOFTWARE PROGRAM

        Recommended Actions
        RERUN THE APPLICATION PROGRAM
        IF PROBLEM PERSISTS THEN DO THE FOLLOWING
        CONTACT APPROPRIATE SERVICE REPRESENTATIVE

Detail Data
SIGNAL NUMBER
         11
USER'S PROCESS ID:
              13369662
FILE SYSTEM SERIAL NUMBER
           1
INODE NUMBER
                 69639
CORE FILE NAME
/var/adm/core/core.13369662.29132106
PROGRAM NAME
perl
STACK EXECUTION DISABLED
           0
COME FROM ADDRESS REGISTER

PROCESSOR ID
  hw_fru_id: 1
  hw_cpu_id: 19

ADDITIONAL INFORMATION

Unable to generate symptom string.
Too many stack elements.
-bash-4.4$

Die einzige Information, die sich entnehmen ließ, war das die Prozesse mit dem Signal 11 (SIGSEGV) beendet wurden, also aufgrund eines Zugriffs auf eine ungültige Speicher-Adresse.

Es stellte sich die Frage: wie kann ermittelt werden um welches Perl-Skript es sich handelt und auf welchem Wege es gestartet wird.

Dies sollte sich eigentlich mit Hilfe von ProbeVue herausfinden lassen.

Es bot sich der sysproc-Provider an, der im Falle eines Exits eines Prozesses ein Event generiert. Über die spezielle built-in Variable __exitinfo werden genauere Informationen zum Exit, wie Exit-Status oder die Signal-Nummer die den Prozess beendet hat bereitgestellt. Damit lässt sich schon einmal die folgende Probe schreiben:

1: @@sysproc:exit:*
2: when ( __exitinfo->signo == 11 )
3: {
4:         printf( "%llu:  %s\n" , __pid , __pname );
5:         ptree(10);
6: }

Die 6 Zeilen seien hier kurz erklärt:

  1. Der Probe-Point: Provider ist sysproc, Event is exit, * bedeutet beliebiger Prozeß
  2. Durch Verwendung des obigen Prädikats wird der nachfolgende Action Block nur ausgeführt, wenn der Prozeß mit dem Signal 11 (SIGSEGV) beendet wurde.
  3. Start des Action Blocks.
  4. Ausgeben der PID und des Programm-Namens des Prozesses.
  5. Die Funktion ptree gibt den Vater, Großvater usw. (bis 10 Ebenen) des Prozesses aus.
  6. Hier endet der Action Block.

Leider lassen sich hier keine Argumente auflisten, mit denen das Programm gestartet wurde, was in unserem Falle mit Perl den Namen des Skriptes geliefert hätte. Aber immerhin bekommt man über die Funktion ptree heraus auf welchem Wege das Programm aufgerufen wurde, was in manchen Fällen schon ausreicht um das Programm dann letztlich zu identifizieren.

Wir hätten zur Identifikation gerne noch die Information über die Argumente mit denen Perl aufgerufen wurde. Diese Information liefert der syscall-Provider für den System-Call execve mit dem das Programm letztlich gestartet wird. Der Probe-Point ist damit syscall:*:execve:entry, da beim Eintritt in die Funktion die Argumente bekannt sind. Die Signatur von execve für ProbeVue sieht dann so aus:

int execve( char* , struct arg_t* args , char* );

Hierbei ist das erste Argument (wird von ProbeVue als __arg1 bereitgestellt) der Programm-Name. Das zweite Argument ist eine Struktur mit den gesuchten Argumenten (bereitgestellt über __arg2). Über das dritte Argumente hat man Zugriff auf Environment-Variablen, was aber in unserem Falle nicht von Bedeutung ist. Die Struktur struct arg_t sieht für 5 Argumente so aus:

struct arg_t
{
        union
        {
                char* arg[5];
                int num[5];
        } u;
};

Diese Struktur und die Signatur von execve müssen im ProbeVue-Skript deklariert werden, bevor man diese benutzen kann.

Beim Zugriff auf die Argumente ergibt sich dann noch ein kleines weiteres Problem: wenn der Action Block für unsere Probe angesprochen wird, sind wir im Kernel-Modus, die Argumente selber sind aber Adressen im User-Mode des Prozesses. Die Daten (in diesem Falle Zeichenketten) müssen aus dem User-Adreß-Raum herauskopiert werden. Dies erledigt die Funktion get_userstring.

Wir lassen uns bei jedem execve die PID, den Programm-Namen, das Kommando und bis zu 5 Argumente ausgeben. Dies ist im folgenden Programm implementiert:

#! /usr/bin/probevue

struct arg_t
{
        union
        {
                char* arg[5];
                int num[5];
        } u;
};

int execve( char* , struct arg_t* args , char* );

@@syscall:*:execve:entry
{
        __auto String command[128];
        __auto String argument[128];
        __auto struct arg_t argv;
        copy_userdata( __arg2 , argv );
        command = get_userstring( __arg1 , -1 );
        argument = get_userstring( argv.u.arg[0] , -1 );
        printf( "%llu: %s called execve(%s) with arguments: %s " , __pid , __pname , command , argument )
;
        if ( argv.u.num[1] != 0 )
        {
                argument = get_userstring( argv.u.arg[1] , -1 );
                printf( "%s " , argument );
                if ( argv.u.num[2] != 0 )
                {
                        argument = get_userstring( argv.u.arg[2] , -1 );
                        printf( "%s " , argument );
                        if ( argv.u.num[3] != 0 )
                        {
                                argument = get_userstring( argv.u.arg[3] , -1 );
                                printf( "%s " , argument );
                                if ( argv.u.num[4] != 0 )
                                {
                                        argument = get_userstring( argv.u.arg[4] , -1 );
                                        printf( "%s " , argument );
                                }
                        }
                }
        }
        printf( "\n" );
}

@@sysproc:exit:*
when ( __exitinfo->signo == 11 )
{
        printf( "%llu:  %s\n" , __pid , __pname );
        ptree(10);
}

Das Skript haben wir capture_segv.e genannt und ausführbar gemacht.

In der Theorie sollte das Programm nach dem Start alle startenden Programme mit PID, Namen und bis zu 5 Argumenten ausgeben. Außerdem erfolgt eine Ausgabe wenn ein Prozess mit dem Signal 11 (SIGSEGV) abgebrochen wird. Die entsprechende PID kann man dann weiter oben in der Ausgabe suchen und damit das Programm mit Argumenten identifizieren.

Leider ergibt sich in der Praxis das folgende kleine Problem: wenn ein Programm nach dem execve sehr schnell beendet wird, bevor ProbeVue mit get_userstring die Argumente kopieren kann, kommt es bei get_userstring zu einem Zugriff auf eine nicht mehr existierende Adresse und das ProbeVue Skript wird abgebrochen. Wir haben dies umgangen, indem wir das ProbeVue Skript einfach über eine Endlos-Schleife immer wieder starten:

# while true; do ./capture_segv.e >>/tmp/wait_for_segv ; done

Wir haben das ProbeVue Skript dann einige Stunden laufen lassen, bis es dann wieder zu einem Core-File von Perl kam. Die Datei /tmp/wait_for_segv enthielt ca 23.000 Zeilen! Wir haben hier nur die relevanten Zeilen aufgelistet:

# cat /tmp/wait_for_segv
…
8651210: ksh called execve(xxxx_hacheck.pl) with arguments: xxxx_hacheck.pl -c
8651210: ksh called execve(/var/opt/OV/bin/instrumentation/xxxx_hacheck.pl) with arguments: xxxx_hacheck
.pl -c
20054518: ksh called execve(/bin/proc2mon.pl) with arguments: proc2mon.pl
…
8651210:  perl

     PID              CMD
       1              init
                        |
                        V
9634196              ovcd
                        |
                        V
9765232              opcacta
                        |
                        V
8651210              perl    <=======
…

Man sieht das Perl über das Programm opcacta gestartet wurde, welches selbst von ovcd gestartet wurde. Diese Prozesse gehören zu HP OpenView das hier im Einsatz ist. Weiter oben in der Ausgabe kann man sehen das das Perl-Skript /var/opt/OV/bin/instrumentation/xxxx_hacheck.pl gestartet wurde. Damit haben wir das Skript gefunden das die vielen Core-Files erzeugt.

Das Skript wurde erst kürzlich geschrieben und muß offensichtlich noch einmal untersucht und überarbeitet werden.

Mit Hilfe von ProbeVue hat ein kurzes Skript und einige Stunden Warten ausgereicht um die Ursache des Problems zu finden! ProbeVue ist aber nicht nur bei der Untersuchung von Problemen nützlich; auch beim Performance Monitoring erweist sich ProbeVue als extrem hilfreich.

 

Resourcen von nicht aktivierten LPARs und Memory Affinity

Wird eine LPAR heruntergefahren, werden nicht automatisch die Resourcen, wie Prozessoren, Speicher und I/O-Slots, der LPAR freigegeben. Die Resourcen bleiben weiterhin der LPAR zugeordnet und werden dann beim nächsten Aktivieren (mit der aktuellen Konfiguration) wiederverwendet. Im ersten Teil des Beitrags Resourcen von nicht aktivierten LPARs hatten wir uns dies schon angeschaut.

(Hinweis: In den Beispiel-Ausgaben benutzen wir die Version 1.4 des LPAR-Tools, zeigen aber in allen Fällen die unterliegenden Kommandos auf der HMC Kommandozeile. Man kann also alles auch ohne die Verwendung des LPAR-Tools ausprobieren.)

Die Beispiel LPAR lpar1 wurde heruntergefahren, belegt aber aktuell immer noch 100 GB Speicher:

linux $ lpar status lpar1
NAME   LPAR_ID  LPAR_ENV  STATE          PROFILE   SYNC  RMC       PROCS  PROC_UNITS  MEM     OS_VERSION
lpar1  39       aixlinux  Not Activated  standard  0     inactive  1      0.2         102400  Unknown
linux $

Auf der zugehörigen HMC hmc01 wurden die folgenden Kommandos für die Ausgabe oben ausgeführt:

hmc01: lssyscfg -r lpar -m ms09 --filter lpar_names=lpar1
hmc01: lshwres -r mem -m ms09 --level lpar --filter lpar_names=lpar1
hmc01: lshwres -r proc -m ms09 --level lpar --filter lpar_names=lpar1

Wie die Ausgabe zeigt, hat die LPAR lpar1 noch ihre Resourcen (Prozessoren, Memory, I/O-Adapter) alloziert.

Um zu verstehen warum beim Deaktivieren einer LPAR die Resourcen nicht frei gegeben werden, muss man sich den „Memory Affinity Score“ anschauen:

linux $ lpar lsmemopt lpar1
             LPAR_SCORE  
LPAR_NAME  CURR  PREDICTED
lpar1      100   0
linux $

HMC Kommandozeile:

hmc01: lsmemopt -m ms09 -r lpar -o currscore –filter lpar_names=lpar1

Der Memory Affinity Score beschreibt wie nahe sich Prozessoren und Memory sind, je näher, desto besser ist der Durchsatz auf den Speicher.  Das Kommando oben gibt mit einem Wert zwischen 1 und 100 an, wie groß die Affinität zwischen Prozessoren und LPARs ist. Unsere LPAR lpar1 hat aktuell einen Wert von 100, das heißt die bestmögliche Affinität von Speicher und Prozessoren. Würden beim Deaktivieren einer LPAR die Resourcen freigegeben, dann würde die LPAR erst einmal diesen Memory Affinity Score verlieren. Beim nächsten Aktivieren der LPAR hängt es dann von dem dann verfügbaren Speicher und Prozessoren ab wie gut die Memory Affinität dann ist. Wir geben einmal die Resourcen frei:

linux $ lpar -d rmprocs lpar1 1
linux $

HMC Kommandozeile:

hmc01: chhwres -m ms09 -r proc  -o r -p lpar1 --procs 1

Es wird nun kein Score mehr angegeben, da der LPAR keine Resourcen mehr zugeordnet sind:

linux $ lpar lsmemopt lpar1
             LPAR_SCORE  
LPAR_NAME  CURR  PREDICTED
lpar1      none  none
linux $

HMC Kommandozeile:

hmc01: lsmemopt -m ms09 -r lpar -o currscore –filter lpar_names=lpar1

Nun lassen wir die Resourcen neu zuweisen und Schauen welchen Einfluß dies auf die Memory Affinität hat:

linux $ lpar applyprof lpar1 standard
linux $

HMC Kommandozeile:

hmc01: chsyscfg -r lpar -m ms09 -o apply -p lpar1 -n standard

Wir ermitteln erneut den Memory Affinity Score:

linux $ lpar lsmemopt lpar1
             LPAR_SCORE  
LPAR_NAME  CURR  PREDICTED
lpar1      53    0
linux $

HMC Kommandozeile:

hmc01: lsmemopt -m ms09 -r lpar -o currscore –filter lpar_names=lpar1

Der Score ist jetzt nur noch bei 53, die Performance der LPAR ist damit schlechter geworden. Ob und wie stark sich dies dann auch bemerkbar macht, hängt dann letztlich von den Applikationen auf der LPAR ab.

Das die Resourcen beim Deaktivieren einer LPAR nicht freigegeben werden, garantiert also beim nächsten Aktivieren (mit der aktuellen Konfiguration) das die Memory Affinität gleich bleibt und damit die Performance die Gleiche sein sollte.

Gibt man die Resourcen einer LPAR frei (manuell oder automatisch), dann muß man sich im Klaren sein das dies Auswirkungen auf die LPAR hat, wenn sie später wieder aktiviert wird, da dann die Resourcen neu zugewiesen werden und sich ein schlechterer (möglicherweise aber auch ein besserer) Memory Affinity Score ergeben kann.

Umgekehrt kann man vor dem Aktivieren einer neuen LPAR aber auch durch Freigeben von Resourcen dafür sorgen das es eine gute Chance für einen hohen Memory Affinity Score für die neue LPAR gibt.

(Hinweis: die Resource Verteilung kann zur Laufzeit mit Hilfe des Dynamic Plattform Optimizers DPO geändert und verbessert werden. DPO wird ab POWER8 unterstützt.)

 

Resourcen von nicht aktivierten LPARs

Wird eine LPAR heruntergefahren, werden Resourcen, wie Prozessoren, Speicher und I/O-Slots, der LPAR nicht automatisch freigegeben. Die Resourcen bleiben weiterhin der LPAR zugeordnet und werden dann beim nächsten Aktivieren (mit der aktuellen Konfiguration) wiederverwendet.

Im Artikel soll gezeigt werden wie das automatische Freigeben der Resourcen erfolgt und falls gewünscht, wie man manuell Resourcen einer nicht aktivierten LPAR freigeben kann.

(Hinweis: In den Beispiel-Ausgaben benutzen wir die Version 1.4 des LPAR-Tools, zeigen aber in allen Fällen die unterliegenden Kommandos auf der HMC Kommandozeile. Man kann also alles auch ohne die Verwendung des LPAR-Tools ausprobieren.)

Die Beispiel LPAR lpar1 wurde heruntergefahren, belegt aber aktuell immer noch 100 GB Speicher:

linux $ lpar status lpar1
NAME   LPAR_ID  LPAR_ENV  STATE          PROFILE   SYNC  RMC       PROCS  PROC_UNITS  MEM     OS_VERSION
lpar1  39       aixlinux  Not Activated  standard  0     inactive  1      0.2         102400  Unknown
linux $

Auf der zugehörigen HMC hmc01 wurden die folgenden Kommandos für die Ausgabe oben ausgeführt:

hmc01: lssyscfg -r lpar -m ms09 --filter lpar_names=lpar1
hmc01: lshwres -r mem -m ms09 --level lpar --filter lpar_names=lpar1
hmc01: lshwres -r proc -m ms09 --level lpar --filter lpar_names=lpar1

Das Attribut resource_config einer LPAR gibt an, ob die LPAR aktuell Resourcen alloziert hat (resource_config=1) oder nicht (resource_config=0):

linux $ lpar status -F resource_config lpar1
1
linux $

Entsprechend auf der HMC Kommandozeile:

hmc01: lssyscfg -r lpar -m ms09 --filter lpar_names=lpar1 –F resource_config

Die von einer nicht aktivierten LPAR allozierten Resourcen können auf 2 verschiedenen Wegen freigegeben werden:

  1. Automatisch: Die belegten Resourcen werden von einer anderen LPAR benötigt, z.B. weil Speicher dynamisch erweitert wird oder eine LPAR aktiviert wird, die nicht ausreichend Resourcen besitzt. In diesem Fall werden einer deaktivierten LPAR automatisch Resourcen weggenommen. Wir zeigen dies weiter unten anhand eines Beispiels.
  2. Manuell: Die allozierten Resourcen werden vom Administrator explizit frei gegeben. Auch dies zeigen wir nachfolgend in einem Beispiel.

Zunächst zeigen wir ein Beispiel bei dem einer nicht aktivierten LPAR automatisch Resourcen weggenommen werden.

Das Managed System ms09 besitzt aktuell noch ca 36 GB freien Speicher:

linux $ ms lsmem ms09
NAME  INSTALLED  FIRMWARE  CONFIGURABLE  AVAIL  MEM_REGION_SIZE
ms09  786432     33792     786432        36352  256
linux $

HMC-Kommandozeile:

hmc01: lshwres -r mem -m ms09 --level sys

Wir starten eine LPAR (lpar2) die mit 100 GB RAM konfiguriert wurde. Das Managed System besitzt nur 36 GB RAM und ist daher gezwungen inaktiven LPARs Resourcen wegzunehmen um die benötigten 100 GB zur Verfügung stellen zu können. Wir starten lpar2 mit dem Profil standard und schauen uns die Speicherverhältnisse an:

linux $ lpar activate -b sms -p standard lpar2
linux $

HMC-Kommandozeile:

hmc01: chsysstate -m ms09 -r lpar -o on -n lpar2 -b sms -f standard

Übersicht über die Speicherverhältnisse von lpar1 und lpar2:

linux $ lpar status lpar\*
NAME   LPAR_ID  LPAR_ENV  STATE          PROFILE   SYNC  RMC       PROCS  PROC_UNITS  MEM     OS_VERSION
lpar1  4        aixlinux  Not Activated  standard  0     inactive  1      0.2         60160   Unknown
lpar2  8        aixlinux  Open Firmware  standard  0     inactive  1      0.2         102400  Unknown
linux $ ms lsmem ms09
NAME  INSTALLED  FIRMWARE  CONFIGURABLE  AVAIL  MEM_REGION_SIZE
ms09  786432     35584     786432        0      256
linux $

HMC-Kommandozeile:

hmc01: lssyscfg -r lpar -m ms09
hmc01: lshwres -r mem -m ms09 --level lpar
hmc01: lshwres -r proc -m ms09 --level lpar
hmc01: lshwres -r mem -m ms09 --level sys

Die LPAR lpar2 hat 100 GB RAM, das Managed System hat keinen freien Speicher mehr und der LPAR lpar1 zugewiesene Speicher wurde auf ca 60 GB reduziert. Allozierte Resourcen von nicht aktivierten LPARs werden bei Bedarf also automatisch weggenommen und anderen LPARs zugewiesen.

Man kann aber auch die Resourcen manuell freigeben. Dies soll hier auch noch kurz gezeigt werden. Wir reduzieren den Speicher von LPAR lpar1 um 20 GB:

linux $ lpar -d rmmem lpar1 20480
linux $

HMC Kommandozeile:

hmc01: chhwres -m ms09 -r mem  -o r -p lpar1 -q 20480

Wie angegeben wurde der zugewiesene Speicher um 20 GB reduziert:

linux $ lpar status lpar\*
NAME   LPAR_ID  LPAR_ENV  STATE          PROFILE   SYNC  RMC       PROCS  PROC_UNITS  MEM     OS_VERSION
lpar1  4        aixlinux  Not Activated  standard  0     inactive  1      0.2         39680   Unknown
lpar2  8        aixlinux  Open Firmware  standard  0     inactive  1      0.2         102400  Unknown
linux $ ms lsmem ms09
NAME  INSTALLED  FIRMWARE  CONFIGURABLE  AVAIL  MEM_REGION_SIZE
ms09  786432     35584     786432        20480  256
linux $

HMC-Kommandozeile:

hmc01: lssyscfg -r lpar -m ms09
hmc01: lshwres -r mem -m ms09 --level lpar
hmc01: lshwres -r proc -m ms09 --level lpar
hmc01: lshwres -r mem -m ms09 --level sys

Die 20 GB stehen dem Managed System sofort wieder als freier Speicher zur Verfügung. Nimmt man den kompletten Speicher oder alle Prozessoren (oder Prozessor-Units) weg, dann werden alle Resourcen einer inaktiven LPAR wieder freigegeben:

linux $ lpar -d rmmem lpar1 39680
linux $

HMC Kommandozeile:

hmc01: chhwres -m ms09 -r mem  -o r -p lpar1 -q 39680

Hier die resultierenden Speicherverhältnisse:

linux $ lpar status lpar\*
NAME   LPAR_ID  LPAR_ENV  STATE          PROFILE   SYNC  RMC       PROCS  PROC_UNITS  MEM     OS_VERSION
lpar1  4        aixlinux  Not Activated  standard  0     inactive  0      0.0         0       Unknown
lpar2  8        aixlinux  Open Firmware  standard  0     inactive  1      0.2         102400  Unknown
linux $ ms lsmem ms09
NAME        INSTALLED  FIRMWARE  CONFIGURABLE  AVAIL  MEM_REGION_SIZE
ms09  786432     31232     786432        64512  256
linux $

HMC Kommandozeile:

hmc01: lssyscfg -r lpar -m ms09
hmc01: lshwres -r mem -m ms09 --level lpar
hmc01: lshwres -r proc -m ms09 --level lpar
hmc01: lshwres -r mem -m ms09 --level sys

Die LPAR lpar1 hat nun 0 Prozessoren, 0.0 Prozessor-Units und 0 MB Speicher! Außerdem hat nun das Attribut resource_config den Wert 0 und gibt damit an das die LPAR keine konfigurierten Resourcen mehr besitzt!

linux $ lpar status -F resource_config lpar1
0
linux $

HMC Kommandozeile:

hmc01: lssyscfg -r lpar -m ms09 --filter lpar_names=lpar1 –F resource_config

Es stellt sich abschließend die Frage warum man unter Umständen Resourcen manuell freigeben sollte, wenn diese vom Managed System bei Bedarf doch automatisch freigegeben werden?

Dieser Frage gehen wir in einem zweiten Artikel nach.