diff --git a/block.c b/block.c
index d36eb75..61af50c 100644
--- a/block.c
+++ b/block.c
@@ -54,7 +54,8 @@
 #include <windows.h>
 #endif
 
-#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
+#define NOT_DONE 0x7fffffff /* zeigt an, dass eine Synchronisationsoperation
+                               stattfindet */
 
 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
     QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
@@ -70,7 +71,8 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
                              BlockDriverState *parent,
                              const BdrvChildRole *child_role, Error **errp);
 
-/* If non-zero, use only whitelisted block drivers */
+/* Ist diese Variable nicht null, dann werden nur whitegelistete Blocktreiber
+ * verwendet */
 static int use_bdrv_whitelist;
 
 static void bdrv_close(BlockDriverState *bs);
@@ -98,7 +100,7 @@ int is_windows_drive(const char *filename)
 size_t bdrv_opt_mem_align(BlockDriverState *bs)
 {
     if (!bs || !bs->drv) {
-        /* page size or 4k (hdd sector size) should be on the safe side */
+        /* Seitengröße oder 4k (HDD-Sektorengröße) sollte genügen */
         return MAX(4096, getpagesize());
     }
 
@@ -108,14 +110,14 @@ size_t bdrv_opt_mem_align(BlockDriverState *bs)
 size_t bdrv_min_mem_align(BlockDriverState *bs)
 {
     if (!bs || !bs->drv) {
-        /* page size or 4k (hdd sector size) should be on the safe side */
+        /* Seitengröße oder 4k (HDD-Sektorengröße) sollte genügen */
         return MAX(4096, getpagesize());
     }
 
     return bs->bl.min_mem_alignment;
 }
 
-/* check if the path starts with "<protocol>:" */
+/* Überprüfe, ob der Pfad mit "<Protokoll>:" beginnt */
 int path_has_protocol(const char *path)
 {
     const char *p;
@@ -136,7 +138,7 @@ int path_has_protocol(const char *path)
 int path_is_absolute(const char *path)
 {
 #ifdef _WIN32
-    /* specific case for names like: "\\.\d:" */
+    /* Sonderfall für Namen wie: "\\.\d:" */
     if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
         return 1;
     }
@@ -146,9 +148,9 @@ int path_is_absolute(const char *path)
 #endif
 }
 
-/* if filename is absolute, just copy it to dest. Otherwise, build a
-   path to it by considering it is relative to base_path. URL are
-   supported. */
+/* Ist der Dateiname absolut, kopiere ihn einfach nach dest. Ansonsten erstelle
+   einen Pfad zu ihm unter Berücksichtigung, dass er relativ zu base_path ist.
+   URLs werden unterstützt. */
 void path_combine(char *dest, int dest_size,
                   const char *base_path,
                   const char *filename)
@@ -271,7 +273,7 @@ static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
     const char **p;
 
     if (!whitelist_rw[0] && !whitelist_ro[0]) {
-        return 1;               /* no whitelist, anything goes */
+        return 1;               /* keine Whitelist, alles geht */
     }
 
     for (p = whitelist_rw; *p; p++) {
@@ -338,7 +340,7 @@ int bdrv_create(BlockDriver *drv, const char* filename,
     }
 
     if (qemu_in_coroutine()) {
-        /* Fast-path if already in coroutine context */
+        /* Abkürzung, wenn wir bereits im Koroutinenkontext sind */
         bdrv_create_co_entry(&cco);
     } else {
         co = qemu_coroutine_create(bdrv_create_co_entry);
@@ -381,10 +383,10 @@ int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
 }
 
 /**
- * Try to get @bs's logical and physical block size.
- * On success, store them in @bsz struct and return 0.
- * On failure return -errno.
- * @bs must not be empty.
+ * Versuchen Sie, @ der bs logischen und physischen Blockgröße.
+ * Bei Erfolg speichern sie in @bsz struct und 0 zurück.
+ * Bei einem Fehler Rückkehr -errno.
+ * @bs darf nicht leer sein.
  */
 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 {
@@ -398,10 +400,10 @@ int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 }
 
 /**
- * Try to get @bs's geometry (cyls, heads, sectors).
- * On success, store them in @geo struct and return 0.
- * On failure return -errno.
- * @bs must not be empty.
+ * Versuchen @ bs Geometrie zu erhalten (cyls, Köpfe, Sektoren).
+ * Bei Erfolg speichern sie in @geo struct und 0 zurück.
+ * Bei einem Fehler Rückkehr -errno.
+ * @bs darf nicht leer sein.
  */
 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
 {
@@ -415,15 +417,15 @@ int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
 }
 
 /*
- * Create a uniquely-named empty temporary file.
- * Return 0 upon success, otherwise a negative errno value.
+ * Erstellen Sie eine eindeutig benannte leere temporäre Datei.
+ * Return 0 bei Erfolg, sonst einen negativen Wert errno.
  */
 int get_tmp_filename(char *filename, int size)
 {
 #ifdef _WIN32
     char temp_dir[MAX_PATH];
-    /* GetTempFileName requires that its output buffer (4th param)
-       have length MAX_PATH or greater.  */
+    /* GetTempFileName erfordert, dass seine Ausgangspuffer (4 param)
+       haben Länge MAX_PATH oder höher.  */
     assert(size >= MAX_PATH);
     return (GetTempPath(MAX_PATH, temp_dir)
             && GetTempFileName(temp_dir, "qem", 0, filename)
@@ -451,8 +453,8 @@ int get_tmp_filename(char *filename, int size)
 }
 
 /*
- * Detect host devices. By convention, /dev/cdrom[N] is always
- * recognized as a host CDROM.
+ * Detect-Host-Geräte. Nach Konvention / dev / cdrom [N] ist immer
+ * als Host-CD-ROM erkannt.
  */
 static BlockDriver *find_hdev_driver(const char *filename)
 {
@@ -481,14 +483,14 @@ BlockDriver *bdrv_find_protocol(const char *filename,
     int len;
     const char *p;
 
-    /* TODO Drivers without bdrv_file_open must be specified explicitly */
+    /* TODO Treiber ohne bdrv_file_open muss explizit angegeben werden */
 
     /*
-     * XXX(hch): we really should not let host device detection
-     * override an explicit protocol specification, but moving this
-     * later breaks access to device names with colons in them.
-     * Thanks to the brain-dead persistent naming schemes on udev-
-     * based Linux systems those actually are quite common.
+     * XXX (HCH): Wir sollten wirklich nicht Host-Geräteerkennung lassen
+     * eine explizite Protokollspezifikation außer Kraft setzen, sondern
+     * bewegte diese später bricht den Zugriff auf Gerätenamen mit
+     * Doppelpunkten in ihnen. Dank der hirntot persistent Namensgebung auf
+     * udev-basierte Linux-Systeme diese sind eigentlich recht häufig.
      */
     drv1 = find_hdev_driver(filename);
     if (drv1) {
@@ -518,18 +520,18 @@ BlockDriver *bdrv_find_protocol(const char *filename,
 }
 
 /*
- * Guess image format by probing its contents.
- * This is not a good idea when your image is raw (CVE-2008-2004), but
- * we do it anyway for backward compatibility.
+ * Ratet mal, Bildformat, das von seinem Inhalt Sondieren.
+ * Dies ist keine gute Idee, wenn Ihr Bild roh (CVE-2008-2004), aber
+ * wir tun es trotzdem für die Abwärtskompatibilität.
  *
- * @buf         contains the image's first @buf_size bytes.
- * @buf_size    is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
- *              but can be smaller if the image file is smaller)
- * @filename    is its filename.
+ * @buf enthält die ersten @buf_size Bytes des Bildes.
+ * @buf_size ist die Puffergröße in Byte (in der Regel BLOCK_PROBE_BUF_SIZE,
+ *              kann aber kleiner sein, wenn die Bilddatei kleiner ist)
+ * @filename ist der Dateiname.
  *
- * For all block drivers, call the bdrv_probe() method to get its
- * probing score.
- * Return the first block driver with the highest probing score.
+ * Für alle Block Treiber, rufen Sie die bdrv_probe () -Methode seine erhalten
+ * Sondieren des Gastes.
+ * Bringen Sie den ersten Block Fahrer mit der höchsten Punktzahl Sondieren.
  */
 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
                             const char *filename)
@@ -557,7 +559,8 @@ static int find_image_format(BlockDriverState *bs, const char *filename,
     uint8_t buf[BLOCK_PROBE_BUF_SIZE];
     int ret = 0;
 
-    /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
+    /* Bringen Sie den rohen BlockDriver * zu scsi-generic-Geräte oder
+     * Leerfahrten */
     if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
         *pdrv = &bdrv_raw;
         return ret;
@@ -582,18 +585,19 @@ static int find_image_format(BlockDriverState *bs, const char *filename,
 }
 
 /**
- * Set the current 'total_sectors' value
- * Return 0 on success, -errno on error.
+ * Stellen Sie die aktuelle 'total_sectors' Wert
+ * Zurück 0 bei Erfolg, -errno auf Fehler.
  */
 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
 {
     BlockDriver *drv = bs->drv;
 
-    /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
+    /* Versuchen Sie nicht, DRV-> bdrv_getlength () auf scsi-generic-Geräte */
     if (bdrv_is_sg(bs))
         return 0;
 
-    /* query actual device if possible, otherwise just trust the hint */
+    /* abfragen eigentliche Gerät, wenn möglich, sonst nur den Hinweis
+     * vertrauen */
     if (drv->bdrv_getlength) {
         int64_t length = drv->bdrv_getlength(bs);
         if (length < 0) {
@@ -607,8 +611,9 @@ static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
 }
 
 /**
- * Combines a QDict of new block driver @options with any missing options taken
- * from @old_options, so that leaving out an option defaults to its old value.
+ * Kombiniert einen QDict neuer Blocktreiber @options mit irgendwelchen
+ * fehlenden Optionen genommen von @old_options, so dass eine Option
+ * standardmäßig auf seinen alten Wert auslassen.
  */
 static void bdrv_join_options(BlockDriverState *bs, QDict *options,
                               QDict *old_options)
@@ -621,16 +626,16 @@ static void bdrv_join_options(BlockDriverState *bs, QDict *options,
 }
 
 /**
- * Set open flags for a given discard mode
+ * Stellen Sie offene Flags für einen bestimmten Löschmodus
  *
- * Return 0 on success, -1 if the discard mode was invalid.
+ * Zurück bei Erfolg 0, -1, wenn der Löschmodus ungültig war.
  */
 int bdrv_parse_discard_flags(const char *mode, int *flags)
 {
     *flags &= ~BDRV_O_UNMAP;
 
     if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
-        /* do nothing */
+        /* nichts tun */
     } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
         *flags |= BDRV_O_UNMAP;
     } else {
@@ -641,9 +646,9 @@ int bdrv_parse_discard_flags(const char *mode, int *flags)
 }
 
 /**
- * Set open flags for a given cache mode
+ * Stellen Sie offene Flags für einen bestimmten Cache-Modus
  *
- * Return 0 on success, -1 if the cache mode was invalid.
+ * Zurück bei Erfolg 0, -1, wenn der Cache-Modus ungültig war.
  */
 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
 {
@@ -670,43 +675,45 @@ int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
 }
 
 /*
- * Returns the options and flags that a temporary snapshot should get, based on
- * the originally requested flags (the originally requested image will have
- * flags like a backing file)
+ * Gibt die Optionen und Flags, die eine temporäre Snapshot sollte, erhalten
+ * basierend auf die ursprünglich angeforderten Flags (die ursprünglich
+ * angeforderte Bild wird Flags wie eine Trägerdatei)
  */
 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
                                        int parent_flags, QDict *parent_options)
 {
     *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
 
-    /* For temporary files, unconditional cache=unsafe is fine */
+    /* Für temporäre Dateien, unbedingte cache = unsicher ist in Ordnung */
     qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
     qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
 }
 
 /*
- * Returns the options and flags that bs->file should get if a protocol driver
- * is expected, based on the given options and flags for the parent BDS
+ * Gibt die Optionen und Flags, die BS-> Datei sollte, wenn ein Protokolltreiber
+ * erhalten erwartet wird, basierend auf den angegebenen Optionen und Flags für
+ * die übergeordnete BDS
  */
 static void bdrv_inherited_options(int *child_flags, QDict *child_options,
                                    int parent_flags, QDict *parent_options)
 {
     int flags = parent_flags;
 
-    /* Enable protocol handling, disable format probing for bs->file */
+    /* Aktivieren Protokollverarbeitung, deaktivieren Format Sondieren für
+     * BS-> Datei */
     flags |= BDRV_O_PROTOCOL;
 
-    /* If the cache mode isn't explicitly set, inherit direct and no-flush from
-     * the parent. */
+    /* Wenn der Cache-Modus nicht explizit festgelegt wird, erben direkt und
+     * nicht bündig ab das Elternteil. */
     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
 
-    /* Our block drivers take care to send flushes and respect unmap policy,
-     * so we can default to enable both on lower layers regardless of the
-     * corresponding parent options. */
+    /* Unsere Block Fahrer kümmern Wallungen zu senden und unmap Bedingungen
+     * beachten, so können wir sowohl auf der unteren Schichten, unabhängig
+     * von der zu ermöglichen Standard entsprechenden Eltern Optionen. */
     flags |= BDRV_O_UNMAP;
 
-    /* Clear flags that only apply to the top layer */
+    /* Klare Flags, die nur auf die oberste Ebene anwenden */
     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
                BDRV_O_NO_IO);
 
@@ -718,9 +725,9 @@ const BdrvChildRole child_file = {
 };
 
 /*
- * Returns the options and flags that bs->file should get if the use of formats
- * (and not only protocols) is permitted for it, based on the given options and
- * flags for the parent BDS
+ * Gibt die Optionen und Flags, die BS-> Datei sollte, wenn die Verwendung von
+ * Formaten (Und nicht nur Protokolle) für die es zulässig ist, basierend auf
+ * den gegebenen Möglichkeiten und Flags für die Mutter BDS
  */
 static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
                                        int parent_flags, QDict *parent_options)
@@ -736,23 +743,24 @@ const BdrvChildRole child_format = {
 };
 
 /*
- * Returns the options and flags that bs->backing should get, based on the
- * given options and flags for the parent BDS
+ * Gibt die Optionen und Flags, die BS-> Unterstützung erhalten sollen, auf der
+ * Grundlage der angegebenen Optionen und Flags für die Eltern BDS
  */
 static void bdrv_backing_options(int *child_flags, QDict *child_options,
                                  int parent_flags, QDict *parent_options)
 {
     int flags = parent_flags;
 
-    /* The cache mode is inherited unmodified for backing files; except WCE,
-     * which is only applied on the top level (BlockBackend) */
+    /* Der Cache-Modus wird nicht modifizierten geerbt Dateien für die
+     * Sicherung; außer WCE, die nur auf der obersten Ebene angewendet wird
+     * (BlockBackend) */
     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
 
-    /* backing files always opened read-only */
+    /* Sichern von Dateien geöffnet immer schreibgeschützt */
     flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
 
-    /* snapshot=on is handled on the top layer */
+    /* snapshot = on wird auf der oberen Schicht gehandhabt */
     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
 
     *child_flags = flags;
@@ -767,13 +775,13 @@ static int bdrv_open_flags(BlockDriverState *bs, int flags)
     int open_flags = flags;
 
     /*
-     * Clear flags that are internal to the block layer before opening the
-     * image.
+     * Klare Flags, die vor dem Öffnen der am Block Layer intern sind
+     * Image.
      */
     open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
 
     /*
-     * Snapshots should be writable.
+     * Snapshots sollte beschreibbar sein.
      */
     if (flags & BDRV_O_TEMPORARY) {
         open_flags |= BDRV_O_RDWR;
@@ -819,27 +827,28 @@ static void bdrv_assign_node_name(BlockDriverState *bs,
         node_name = gen_node_name = id_generate(ID_BLOCK);
     } else if (!id_wellformed(node_name)) {
         /*
-         * Check for empty string or invalid characters, but not if it is
-         * generated (generated names use characters not available to the user)
+         * Überprüfen Sie, ob leere Zeichenfolge oder ungültige Zeichen, aber
+         * nicht, wenn es erzeugt (generierten Namen Zeichen nicht für den
+         * Benutzer verfügbar verwenden)
          */
         error_setg(errp, "Invalid node name");
         return;
     }
 
-    /* takes care of avoiding namespaces collisions */
+    /* kümmert sich Namespace-Kollisionen zu vermeiden */
     if (blk_by_name(node_name)) {
         error_setg(errp, "node-name=%s is conflicting with a device id",
                    node_name);
         goto out;
     }
 
-    /* takes care of avoiding duplicates node names */
+    /* kümmert sich um Duplikate Knotennamen zu vermeiden */
     if (bdrv_find_node(node_name)) {
         error_setg(errp, "Duplicate node name");
         goto out;
     }
 
-    /* copy node name into the bs and insert it into the graph list */
+    /* Kopieren Knotennamen in die bs und in der Grafik Liste einfügen */
     pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
     QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
 out:
@@ -870,14 +879,14 @@ static QemuOptsList bdrv_runtime_opts = {
             .type = QEMU_OPT_BOOL,
             .help = "Ignore flush requests",
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     },
 };
 
 /*
- * Common part for opening disk images and files
+ * Gemeinsame Teil für die Öffnung der Disk-Images und Dateien
  *
- * Removes all processed options from *options.
+ * Entfernt alle verarbeiteten Optionen * Optionen.
  */
 static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
                             QDict *options, Error **errp)
@@ -943,7 +952,8 @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
         goto fail_opts;
     }
 
-    assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
+    /* bdrv_new () und bdrv_close () machen es so */
+    assert(bs->copy_on_read == 0);
     if (bs->open_flags & BDRV_O_COPY_ON_READ) {
         if (!bs->read_only) {
             bdrv_enable_copy_on_read(bs);
@@ -964,10 +974,11 @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
     bs->drv = drv;
     bs->opaque = g_malloc0(drv->instance_size);
 
-    /* Apply cache mode options */
+    /* Anwenden Cache-Modus-Optionen */
     update_flags_from_options(&bs->open_flags, opts);
 
-    /* Open the image, either directly or using a protocol */
+    /* Öffnen Sie das Bild, entweder direkt oder unter Verwendung eines
+     * Protokolls */
     open_flags = bdrv_open_flags(bs, bs->open_flags);
     if (drv->bdrv_file_open) {
         assert(file == NULL);
@@ -1058,7 +1069,7 @@ static void parse_json_protocol(QDict *options, const char **pfilename,
     QDict *json_options;
     Error *local_err = NULL;
 
-    /* Parse json: pseudo-protocol */
+    /* Parse json: Pseudo-Protokoll */
     if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
         return;
     }
@@ -1069,18 +1080,18 @@ static void parse_json_protocol(QDict *options, const char **pfilename,
         return;
     }
 
-    /* Options given in the filename have lower priority than options
-     * specified directly */
+    /* Optionen im Dateinamen angegeben haben niedrigere Priorität als Optionen
+     * angegeben direkt */
     qdict_join(options, json_options, false);
     QDECREF(json_options);
     *pfilename = NULL;
 }
 
 /*
- * Fills in default options for opening images and converts the legacy
- * filename/flags pair to option QDict entries.
- * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
- * block driver has been specified explicitly.
+ * Füllt in Standardoptionen für Bilder öffnen und wandelt das Vermächtnis
+ * Dateiname / pair Flags Option QDict Einträge.
+ * Die BDRV_O_PROTOCOL Flagge in *flags werden entsprechend gesetzt oder
+ * gelöscht werden, wenn ein Block-Treiber wurde explizit angegeben.
  */
 static int bdrv_fill_options(QDict **options, const char *filename,
                              int *flags, Error **errp)
@@ -1098,8 +1109,8 @@ static int bdrv_fill_options(QDict **options, const char *filename,
             error_setg(errp, "Unknown driver '%s'", drvname);
             return -ENOENT;
         }
-        /* If the user has explicitly specified the driver, this choice should
-         * override the BDRV_O_PROTOCOL flag */
+        /* Wenn der Benutzer explizit den Fahrer festgelegt hat, sollte diese
+         * Wahl überschreiben die BDRV_O_PROTOCOL Flagge */
         protocol = drv->bdrv_file_open;
     }
 
@@ -1109,10 +1120,10 @@ static int bdrv_fill_options(QDict **options, const char *filename,
         *flags &= ~BDRV_O_PROTOCOL;
     }
 
-    /* Translate cache options from flags into options */
+    /* Übersetzen Cache-Optionen von Flaggen in Optionen */
     update_options_from_flags(*options, *flags);
 
-    /* Fetch the file name from the options QDict if necessary */
+    /* Holt den Dateinamen aus den Optionen QDict ggf. */
     if (protocol && filename) {
         if (!qdict_haskey(*options, "filename")) {
             qdict_put(*options, "filename", qstring_from_str(filename));
@@ -1124,7 +1135,7 @@ static int bdrv_fill_options(QDict **options, const char *filename,
         }
     }
 
-    /* Find the right block driver */
+    /* Finden Sie den richtigen Blocktreiber */
     filename = qdict_get_try_str(*options, "filename");
 
     if (!drvname && protocol) {
@@ -1144,7 +1155,7 @@ static int bdrv_fill_options(QDict **options, const char *filename,
 
     assert(drv || !protocol);
 
-    /* Driver-specific filename parsing */
+    /* Treiber-spezifischen Dateinamen Parsing */
     if (drv && drv->bdrv_parse_filename && parse_filename) {
         drv->bdrv_parse_filename(filename, *options, &local_err);
         if (local_err) {
@@ -1220,8 +1231,8 @@ void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
 }
 
 /*
- * Sets the backing file link of a BDS. A new reference is created; callers
- * which don't need their own reference any more must call bdrv_unref().
+ * Setzt die Trägerdatei Link eines BDS. Eine neue Referenz erstellt; Anrufer
+ * die ihre eigenen Referenz brauchen nicht mehr müssen nennen bdrv_unref ().
  */
 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
 {
@@ -1252,7 +1263,8 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
             backing_hd->drv ? backing_hd->drv->format_name : "");
 
     bdrv_op_block_all(backing_hd, bs->backing_blocker);
-    /* Otherwise we won't be able to commit due to check in bdrv_commit */
+    /* Sonst werden wir nicht wegen der Lage sein, zu begehen, in bdrv_commit
+     * zu überprüfen */
     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
                     bs->backing_blocker);
 out:
@@ -1260,14 +1272,14 @@ out:
 }
 
 /*
- * Opens the backing file for a BlockDriverState if not yet open
+ * Öffnet die Trägerdatei für eine BlockDriverState wenn noch nicht geöffnet
  *
- * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
- * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
- * itself, all options starting with "${bdref_key}." are considered part of the
- * BlockdevRef.
+ * bdref_key gibt den Schlüssel für die BlockdevRef das Bild in den Optionen
+ * QDict. Das QDict hat abgeflacht zu werden; Wenn daher die BlockdevRef eine
+ * QDict selbst, beginnend alle Optionen mit "$ {bdref_key}." Teil des gelten
+ * als BlockdevRef.
  *
- * TODO Can this be unified with bdrv_open_image()?
+ * TODO Kann dies mit bdrv_open_image vereinigt werden ()?
  */
 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
                            const char *bdref_key, Error **errp)
@@ -1285,7 +1297,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
         goto free_exit;
     }
 
-    /* NULL means an empty set of options */
+    /* NULL bedeutet eine leere Menge von Optionen */
     if (parent_options == NULL) {
         tmp_parent_options = qdict_new();
         parent_options = tmp_parent_options;
@@ -1336,8 +1348,8 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
         goto free_exit;
     }
 
-    /* Hook up the backing file link; drop our reference, bs owns the
-     * backing_hd reference now */
+    /* Schließen Sie die Unterstützung Dateilink; Drop unsere Referenz, bs
+     * besitzt die backing_hd Referenz jetzt */
     bdrv_set_backing_hd(bs, backing_hd);
     bdrv_unref(backing_hd);
 
@@ -1350,18 +1362,19 @@ free_exit:
 }
 
 /*
- * Opens a disk image whose options are given as BlockdevRef in another block
- * device's options.
+ * Öffnet ein Disk-Image, dessen Optionen gegeben werden als BlockdevRef in
+ * einem anderen Block Geräteoptionen.
  *
- * If allow_none is true, no image will be opened if filename is false and no
- * BlockdevRef is given. NULL will be returned, but errp remains unset.
+ * Wenn ALLOW_NONE wahr ist, wird kein Bild geöffnet, wenn Dateiname falsch ist
+ * und keine BlockdevRef gegeben. NULL wird zurückgegeben, aber Errp bleibt
+ * ungesetzt.
  *
- * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
- * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
- * itself, all options starting with "${bdref_key}." are considered part of the
- * BlockdevRef.
+ * bdrev_key gibt den Schlüssel für die BlockdevRef das Bild in den Optionen
+ * QDict. Das QDict hat abgeflacht zu werden; Wenn daher die BlockdevRef eine
+ * QDict selbst, beginnend alle Optionen mit "$ {bdref_key}." Teil des gelten
+ * als BlockdevRef.
  *
- * The BlockdevRef will be removed from the options QDict.
+ * Die BlockdevRef werden aus der Optionen QDict entfernt werden.
  */
 BdrvChild *bdrv_open_child(const char *filename,
                            QDict *options, const char *bdref_key,
@@ -1409,7 +1422,8 @@ done:
 static int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags,
                                      QDict *snapshot_options, Error **errp)
 {
-    /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
+    /* TODO: zusätzliches Byte ist ein Hack MAX_PATH Raum auf Windows zu
+     * gewährleisten. */
     char *tmp_filename = g_malloc0(PATH_MAX + 1);
     int64_t total_size;
     QemuOpts *opts = NULL;
@@ -1417,10 +1431,10 @@ static int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags,
     Error *local_err = NULL;
     int ret;
 
-    /* if snapshot, we create a temporary backing file and open it
-       instead of opening 'filename' directly */
+    /* wenn Snapshot erstellen wir eine temporäre Träger-Datei und öffnen Sie
+       sie anstelle der Öffnung "Dateiname" direkt */
 
-    /* Get the required size from the image */
+    /* Holen Sie die gewünschte Größe aus dem Bild */
     total_size = bdrv_getlength(bs);
     if (total_size < 0) {
         ret = total_size;
@@ -1428,7 +1442,7 @@ static int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags,
         goto out;
     }
 
-    /* Create the temporary image */
+    /* Erstellen Sie das temporäre Bild */
     ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not get temporary filename");
@@ -1446,7 +1460,7 @@ static int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags,
         goto out;
     }
 
-    /* Prepare options QDict for the temporary file */
+    /* Bereiten Sie Optionen QDict für die temporäre Datei */
     qdict_put(snapshot_options, "file.driver",
               qstring_from_str("file"));
     qdict_put(snapshot_options, "file.filename",
@@ -1473,19 +1487,22 @@ out:
 }
 
 /*
- * Opens a disk image (raw, qcow2, vmdk, ...)
+ * Öffnet ein Disk-Image (roh, qcow2, vmdk, ...)
  *
- * options is a QDict of options to pass to the block drivers, or NULL for an
- * empty set of options. The reference to the QDict belongs to the block layer
- * after the call (even on failure), so if the caller intends to reuse the
- * dictionary, it needs to use QINCREF() before calling bdrv_open.
+ * Optionen ist ein QDict von Optionen an die Blocktreiber zu passieren, oder
+ * NULL für eine leere Menge von Optionen. Der Verweis auf die QDict gehört
+ * zur Blockschicht nach dem Aufruf (auch bei Ausfall), so dass, wenn der
+ * Anrufer die wiederzuverwenden beabsichtigt Wörterbuch, braucht es QINCREF()
+ * zu verwenden, bevor bdrv_open aufrufen.
  *
- * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
- * If it is not NULL, the referenced BDS will be reused.
+ * Wenn *pbs NULL ist, wird ein neuer BDS mit einem Zeiger auf sie dort
+ * gespeichert erstellt werden. Wenn es nicht NULL ist, wird die referenzierten
+ * BDS wiederverwendet werden.
  *
- * The reference parameter may be used to specify an existing block device which
- * should be opened. If specified, neither options nor a filename may be given,
- * nor can an existing BDS be reused (that is, *pbs has to be NULL).
+ * Der Referenzparameter verwendet werden kann, eine bestehende Blockgerät
+ * angeben, welche sollte geöffnet werden. Wenn angegeben, kann weder Optionen
+ * noch ein Dateiname angegeben werden, noch kann eine bestehende BDS wieder
+ * verwendet werden (das heißt, *pbs hat NULL sein).
  */
 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
                              const char *reference, QDict *options, int flags,
@@ -1537,12 +1554,12 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
         bs = bdrv_new();
     }
 
-    /* NULL means an empty set of options */
+    /* NULL bedeutet eine leere Menge von Optionen */
     if (options == NULL) {
         options = qdict_new();
     }
 
-    /* json: syntax counts as explicit options, as if in the QDict */
+    /* json: Syntax gilt als explizite Optionen, als ob in der QDict */
     parse_json_protocol(options, &filename, &local_err);
     if (local_err) {
         ret = -EINVAL;
@@ -1566,7 +1583,7 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
     bs->options = options;
     options = qdict_clone_shallow(options);
 
-    /* Find the right image format driver */
+    /* Finden Sie das richtige Bildformat-Treiber */
     drvname = qdict_get_try_str(options, "driver");
     if (drvname) {
         drv = bdrv_find_format(drvname);
@@ -1585,7 +1602,7 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
         qdict_del(options, "backing");
     }
 
-    /* Open image file without format layer */
+    /* Bilddatei öffnen, ohne Format Schicht */
     if ((flags & BDRV_O_PROTOCOL) == 0) {
         if (flags & BDRV_O_RDWR) {
             flags |= BDRV_O_ALLOW_RDWR;
@@ -1607,7 +1624,7 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
         }
     }
 
-    /* Image format probing */
+    /* Bildformat Sondierung */
     bs->probed = !drv;
     if (!drv && file) {
         ret = find_image_format(file->bs, filename, &drv, &local_err);
@@ -1615,15 +1632,16 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
             goto fail;
         }
         /*
-         * This option update would logically belong in bdrv_fill_options(),
-         * but we first need to open bs->file for the probing to work, while
-         * opening bs->file already requires the (mostly) final set of options
-         * so that cache mode etc. can be inherited.
+         * Diese Option Update gehören würde logisch in bdrv_fill_options (),
+         * aber wir müssen zuerst öffnen BS-> Datei für die Arbeit Sondieren,
+         * während Öffnen BS-> erfordert Datei bereits die (meist) letzte Satz
+         * von Optionen so dass Cache-Modus usw. können vererbt werden.
          *
-         * Adding the driver later is somewhat ugly, but it's not an option
-         * that would ever be inherited, so it's correct. We just need to make
-         * sure to update both bs->options (which has the full effective
-         * options for bs) and options (which has file.* already removed).
+         * der Fahrer ist dann ein etwas hässlich, aber es ist keine Option
+         * dass immer vererbt werden würde, so ist es richtig. Wir müssen nur
+         * sicherstellen, Sie beide BS- zu aktualisieren> Optionen (was die
+         * vollständige effektive hat Optionen für bs) und Optionen (die Datei
+         * hat. * bereits entfernt).
          */
         qdict_put(bs->options, "driver", qstring_from_str(drv->format_name));
         qdict_put(options, "driver", qstring_from_str(drv->format_name));
@@ -1633,13 +1651,14 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
         goto fail;
     }
 
-    /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
+    /* BDRV_O_PROTOCOL muss genau dann, wenn ein Protokoll festgelegt werden BDS
+     * ist etwa geschaffen werden */
     assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
-    /* file must be NULL if a protocol BDS is about to be created
-     * (the inverse results in an error message from bdrv_open_common()) */
+    /* Datei muss NULL sein, wenn ein Protokoll BDS über erstellt werden soll,
+     * (Die inverse führt zu einer Fehlermeldung von bdrv_open_common ()) */
     assert(!(flags & BDRV_O_PROTOCOL) || !file);
 
-    /* Open the image */
+    /* Öffnen Sie das Bild */
     ret = bdrv_open_common(bs, file, options, &local_err);
     if (ret < 0) {
         goto fail;
@@ -1650,7 +1669,7 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
         file = NULL;
     }
 
-    /* If there is a backing file, use it */
+    /* Wenn es eine Trägerdatei ist, verwenden Sie es */
     if ((flags & BDRV_O_NO_BACKING) == 0) {
         ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
         if (ret < 0) {
@@ -1660,7 +1679,7 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
 
     bdrv_refresh_filename(bs);
 
-    /* Check if any unknown options were used */
+    /* Überprüfen Sie, ob alle unbekannten Optionen verwendet wurden */
     if (options && (qdict_size(options) != 0)) {
         const QDictEntry *entry = qdict_first(options);
         if (flags & BDRV_O_PROTOCOL) {
@@ -1682,7 +1701,7 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
         }
     } else if (!runstate_check(RUN_STATE_PRELAUNCH)
                && !runstate_check(RUN_STATE_INMIGRATE)
-               && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
+               && !runstate_check(RUN_STATE_PAUSED)) { /* HACKEN */
         error_setg(errp,
                    "Guest must be stopped for opening of encrypted image");
         ret = -EBUSY;
@@ -1692,8 +1711,8 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
     QDECREF(options);
     *pbs = bs;
 
-    /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
-     * temporary snapshot afterwards. */
+    /* Für Snapshot = on, eine temporäre qcow2 Overlay erstellen. bs Punkte
+     * auf die danach vorübergehende Snapshot. */
     if (snapshot_flags) {
         ret = bdrv_append_temp_snapshot(bs, snapshot_flags, snapshot_options,
                                         &local_err);
@@ -1715,9 +1734,10 @@ fail:
     QDECREF(options);
     bs->options = NULL;
     if (!*pbs) {
-        /* If *pbs is NULL, a new BDS has been created in this function and
-           needs to be freed now. Otherwise, it does not need to be closed,
-           since it has not really been opened yet. */
+        /* Wenn * pbs NULL ist, hat sich eine neue BDS in dieser Funktion
+           erstellt wurde und muss jetzt befreit werden. Andernfalls muss er
+           nicht geschlossen werden kann, da hat es noch nicht wirklich
+           geöffnet. */
         bdrv_unref(bs);
     }
     if (local_err) {
@@ -1726,7 +1746,7 @@ fail:
     return ret;
 
 close_and_fail:
-    /* See fail path, but now the BDS has to be always closed */
+    /* Siehe Pfad scheitern, aber jetzt hat der BDS immer geschlossen sein */
     if (*pbs) {
         bdrv_close(bs);
     } else {
@@ -1754,24 +1774,24 @@ typedef struct BlockReopenQueueEntry {
 } BlockReopenQueueEntry;
 
 /*
- * Adds a BlockDriverState to a simple queue for an atomic, transactional
- * reopen of multiple devices.
+ * Fügt eine BlockDriverState auf eine einfache Warteschlange für ein Atom,
+ * Transaktions- wieder öffnen mehrerer Geräte.
  *
- * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
- * already performed, or alternatively may be NULL a new BlockReopenQueue will
- * be created and initialized. This newly created BlockReopenQueue should be
- * passed back in for subsequent calls that are intended to be of the same
- * atomic 'set'.
+ * bs_queue kann entweder eine bestehende BlockReopenQueue sein, die
+ * QSIMPLE_INIT hatte bereits durchgeführt, oder alternativ wird eine neue
+ * BlockReopenQueue NULL sein erzeugt und initialisiert werden. Diese neu
+ * geschaffene BlockReopenQueue sollte in für nachfolgende Anrufe
+ * zurückgeführt, die aus dem gleichen sein sollen Atom-Set '.
  *
- * bs is the BlockDriverState to add to the reopen queue.
+ * bs ist die BlockDriverState zur Wiedereröffnung Warteschlange hinzuzufügen.
  *
- * options contains the changed options for the associated bs
- * (the BlockReopenQueue takes ownership)
+ * Optionen enthält die geänderten Optionen für den zugehörigen bs
+ * (Die BlockReopenQueue nimmt den Besitz)
  *
- * flags contains the open flags for the associated bs
+ * Fahnen enthält die offenen Fahnen für den zugehörigen bs
  *
- * returns a pointer to bs_queue, which is either the newly allocated
- * bs_queue, or the existing bs_queue being used.
+ * Gibt einen Zeiger auf bs_queue, die entweder die neu zugewiesenen
+ * bs_queue oder der bestehende bs_queue verwendet wird.
  *
  */
 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
@@ -1798,52 +1818,53 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
     }
 
     /*
-     * Precedence of options:
-     * 1. Explicitly passed in options (highest)
-     * 2. Set in flags (only for top level)
-     * 3. Retained from explicitly set options of bs
-     * 4. Inherited from parent node
-     * 5. Retained from effective options of bs
+     * Rangfolge der Optionen:
+     * 1. Explizit in den Optionen übergeben (höchste)
+     * 2. Stellen Sie in den Flaggen (nur für Top-Level)
+     * 3. von explizit Optionen von bs Rück
+     * 4. von übergeordneten Knoten geerbt
+     * 5. von effektiven Möglichkeiten der bs Rück
      */
 
     if (!parent_options) {
         /*
-         * Any setting represented by flags is always updated. If the
-         * corresponding QDict option is set, it takes precedence. Otherwise
-         * the flag is translated into a QDict option. The old setting of bs is
-         * not considered.
+         * Jede Einstellung, die durch Flags wird immer aktualisiert. wenn der
+         * entsprechende QDict Option gesetzt ist, es hat Vorrang. Andernfalls
+         * das Flag in eine QDict Option übersetzt. Die alte Einstellung von bs
+         * nicht bedacht.
          */
         update_options_from_flags(options, flags);
     }
 
-    /* Old explicitly set values (don't overwrite by inherited value) */
+    /* Alte explizit Werte (nicht überschreiben von geerbten Wert) */
     old_options = qdict_clone_shallow(bs->explicit_options);
     bdrv_join_options(bs, options, old_options);
     QDECREF(old_options);
 
     explicit_options = qdict_clone_shallow(options);
 
-    /* Inherit from parent node */
+    /* Vererben von Elternknoten */
     if (parent_options) {
         assert(!flags);
         role->inherit_options(&flags, options, parent_flags, parent_options);
     }
 
-    /* Old values are used for options that aren't set yet */
+    /* Alte Werte werden für Optionen eingesetzt, die noch nicht festgelegt */
     old_options = qdict_clone_shallow(bs->options);
     bdrv_join_options(bs, options, old_options);
     QDECREF(old_options);
 
-    /* bdrv_open() masks this flag out */
+    /* bdrv_open () Masken dieses Flag aus */
     flags &= ~BDRV_O_PROTOCOL;
 
     QLIST_FOREACH(child, &bs->children, next) {
         QDict *new_child_options;
         char *child_key_dot;
 
-        /* reopen can only change the options of block devices that were
-         * implicitly created and inherited options. For other (referenced)
-         * block devices, a syntax like "backing.foo" results in an error. */
+        /* wieder öffnen können nur die Optionen von Blockgeräte zu ändern,
+         * waren implizit Optionen erstellt und vererbt wird. Für andere
+         * (referenziert) Block-Geräte, eine Syntax wie "backing.foo" führt zu
+         * einem Fehler. */
         if (child->bs->inherits_from != bs) {
             continue;
         }
@@ -1876,18 +1897,18 @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
 }
 
 /*
- * Reopen multiple BlockDriverStates atomically & transactionally.
+ * Öffnen Sie erneut mehrere BlockDriverStates atomar & transaktionell.
  *
- * The queue passed in (bs_queue) must have been built up previous
- * via bdrv_reopen_queue().
+ * Die Warteschlange in (bs_queue) übergeben müssen vorherigen gebaut wurden
+ * bis via bdrv_reopen_queue ().
  *
- * Reopens all BDS specified in the queue, with the appropriate
- * flags.  All devices are prepared for reopen, and failure of any
- * device will cause all device changes to be abandonded, and intermediate
- * data cleaned up.
+ * Öffnet wieder alle BDS in der Warteschlange angegeben, mit dem
+ * entsprechenden Fahnen. Alle Geräte sind für den wieder öffnen vorbereitet
+ * und Ausfall einer Gerät alle Geräteänderungen bewirken abandonded werden,
+ * und Zwischen Daten bereinigt.
  *
- * If all devices prepare successfully, then the changes are committed
- * to all devices.
+ * Wenn alle Geräte erfolgreich vorbereiten, dann sind die Änderungen
+ * festgeschrieben an alle Geräte.
  *
  */
 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
@@ -1908,8 +1929,8 @@ int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
         bs_entry->prepared = true;
     }
 
-    /* If we reach this point, we have success and just need to apply the
-     * changes
+    /* Wenn wir diesen Punkt erreichen, haben wir Erfolg und müssen nur die
+     * anzuwenden Änderungen
      */
     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
         bdrv_reopen_commit(&bs_entry->state);
@@ -1932,7 +1953,8 @@ cleanup:
 }
 
 
-/* Reopen a single BlockDriverState with the specified flags. */
+/* Öffnen Sie erneut eine einzige BlockDriverState mit den angegebenen Flags.
+ */
 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
 {
     int ret = -1;
@@ -1948,20 +1970,21 @@ int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
 
 
 /*
- * Prepares a BlockDriverState for reopen. All changes are staged in the
- * 'opaque' field of the BDRVReopenState, which is used and allocated by
- * the block driver layer .bdrv_reopen_prepare()
+ * Bereitet ein BlockDriverState für wieder öffnen. Alle Änderungen werden in
+ * der Szene gesetzt "Opaque" Feld der BDRVReopenState, die verwendet wird, und
+ * zugeteilt durch die Blocktreiberschicht .bdrv_reopen_prepare ()
  *
- * bs is the BlockDriverState to reopen
- * flags are the new open flags
- * queue is the reopen queue
+ * bs ist die BlockDriverState wieder zu öffnen
+ * Flaggen sind die neuen offenen Fahnen
+ * Warteschlange ist die Warteschlange wieder öffnen
  *
- * Returns 0 on success, non-zero on error.  On error errp will be set
- * as well.
+ * Gibt 0 bei Erfolg, von Null auf Fehler. Bei einem Fehler Errp wird gesetzt
+ * auch.
  *
- * On failure, bdrv_reopen_abort() will be called to clean up any data.
- * It is the responsibility of the caller to then call the abort() or
- * commit() for any other BDS that have been left in a prepare() state
+ * Bei einem Fehler bdrv_reopen_abort () werden alle Daten zu bereinigen,
+ * aufgerufen werden. Es liegt in der Verantwortung des Anrufers, um dann den
+ * Abbruch () aufrufen oder commit () für alle anderen BDS, die in einem
+ * prepare () Zustand zurückgelassen wurden
  *
  */
 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
@@ -1977,7 +2000,7 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
     assert(reopen_state->bs->drv != NULL);
     drv = reopen_state->bs->drv;
 
-    /* Process generic block layer options */
+    /* Prozess generische Block-Layer-Optionen */
     opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
     qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
     if (local_err) {
@@ -1988,8 +2011,8 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
 
     update_flags_from_options(&reopen_state->flags, opts);
 
-    /* node-name and driver must be unchanged. Put them back into the QDict, so
-     * that they are checked at the end of this function. */
+    /* Knotenname und Fahrer muss nicht geändert. Setzen Sie sie wieder in die
+     * QDict, so dass sie am Ende dieser Funktion überprüft. */
     value = qemu_opt_get(opts, "node-name");
     if (value) {
         qdict_put(reopen_state->options, "node-name", qstring_from_str(value));
@@ -2000,8 +2023,8 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
         qdict_put(reopen_state->options, "driver", qstring_from_str(value));
     }
 
-    /* if we are to stay read-only, do not allow permission change
-     * to r/w */
+    /* wenn wir schreibgeschützt bleiben, erlauben keine Berechtigungsänderung
+     * zu r / w */
     if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
         reopen_state->flags & BDRV_O_RDWR) {
         error_setg(errp, "Node '%s' is read only",
@@ -2028,8 +2051,8 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
             goto error;
         }
     } else {
-        /* It is currently mandatory to have a bdrv_reopen_prepare()
-         * handler for each supported drv. */
+        /* Es ist derzeit zwingend eine bdrv_reopen_prepare zu haben ()
+         * Handler für jede unterstützte drv. */
         error_setg(errp, "Block format '%s' used by node '%s' "
                    "does not support reopening files", drv->format_name,
                    bdrv_get_device_or_node_name(reopen_state->bs));
@@ -2037,9 +2060,10 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
         goto error;
     }
 
-    /* Options that are not handled are only okay if they are unchanged
-     * compared to the old state. It is expected that some options are only
-     * used for the initial open, but not reopen (e.g. filename) */
+    /* Optionen, die nicht behandelt werden, sind nur in Ordnung, wenn sie
+     * unverändert sind im Vergleich zu den alten Zustand. Es wird erwartet,
+     * dass einige Optionen nur sind für die erste offen verwendet, aber wieder
+     * öffnen nicht (zum Beispiel Dateiname) */
     if (qdict_size(reopen_state->options)) {
         const QDictEntry *entry = qdict_first(reopen_state->options);
 
@@ -2065,9 +2089,9 @@ error:
 }
 
 /*
- * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
- * makes them final by swapping the staging BlockDriverState contents into
- * the active BlockDriverState contents.
+ * Entnimmt die inszenierten Änderungen für die Wiederaufnahme von
+ * bdrv_reopen_prepare () und sie endgültig macht, indem sie die Inszenierung
+ * BlockDriverState Inhalte tauschen in die aktiven BlockDriverState Inhalte.
  */
 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
 {
@@ -2077,12 +2101,12 @@ void bdrv_reopen_commit(BDRVReopenState *reopen_state)
     drv = reopen_state->bs->drv;
     assert(drv != NULL);
 
-    /* If there are any driver level actions to take */
+    /* Wenn es irgendwelche Treiber-Ebene Maßnahmen zu ergreifen, */
     if (drv->bdrv_reopen_commit) {
         drv->bdrv_reopen_commit(reopen_state);
     }
 
-    /* set BDS specific flags now */
+    /* set BDS jetzt spezifische Flags */
     QDECREF(reopen_state->bs->explicit_options);
 
     reopen_state->bs->explicit_options   = reopen_state->explicit_options;
@@ -2093,8 +2117,8 @@ void bdrv_reopen_commit(BDRVReopenState *reopen_state)
 }
 
 /*
- * Abort the reopen, and delete and free the staged changes in
- * reopen_state
+ * Abbruch der erneut öffnen und löschen und kostenlos die inszenierten
+ * Änderungen in reopen_state
  */
 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
 {
@@ -2118,14 +2142,15 @@ static void bdrv_close(BlockDriverState *bs)
 
     assert(!bs->job);
 
-    /* Disable I/O limits and drain all pending throttled requests */
+    /* Deaktivieren Sie E / A-Grenzen und Drain alle anstehenden gedrosselt
+     * Anfragen */
     if (bs->throttle_state) {
         bdrv_io_limits_disable(bs);
     }
 
-    bdrv_drained_begin(bs); /* complete I/O */
+    bdrv_drained_begin(bs); /* Ergänzen I / O */
     bdrv_flush(bs);
-    bdrv_drain(bs); /* in case flush left pending I/O */
+    bdrv_drain(bs); /* im Falle bündig links I anhängig / O */
 
     bdrv_release_named_dirty_bitmaps(bs);
     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
@@ -2148,8 +2173,8 @@ static void bdrv_close(BlockDriverState *bs)
         }
 
         QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
-            /* TODO Remove bdrv_unref() from drivers' close function and use
-             * bdrv_unref_child() here */
+            /* TODO entfernen bdrv_unref () von Fahrer Schließen-Funktion und
+             * Verwendung bdrv_unref_child () hier */
             if (child->bs->inherits_from == bs) {
                 child->bs->inherits_from = NULL;
             }
@@ -2185,14 +2210,14 @@ void bdrv_close_all(void)
     BlockDriverState *bs;
     AioContext *aio_context;
 
-    /* Drop references from requests still in flight, such as canceled block
-     * jobs whose AIO context has not been polled yet */
+    /* Drop-Referenzen von Anfragen noch im Flug, wie annulliert Block
+     * Jobs, deren AIO Zusammenhang wurde noch nicht abgefragt */
     bdrv_drain_all();
 
     blk_remove_all_bs();
     blockdev_close_all_bdrv_states();
 
-    /* Cancel all block jobs */
+    /* Brechen Sie alle Block Jobs */
     while (!QTAILQ_EMPTY(&all_bdrv_states)) {
         QTAILQ_FOREACH(bs, &all_bdrv_states, bs_list) {
             aio_context = bdrv_get_aio_context(bs);
@@ -2206,18 +2231,19 @@ void bdrv_close_all(void)
             aio_context_release(aio_context);
         }
 
-        /* All the remaining BlockDriverStates are referenced directly or
-         * indirectly from block jobs, so there needs to be at least one BDS
-         * directly used by a block job */
+        /* Alle übrigen BlockDriverStates referenziert direkt oder
+         * indirekt von Block Jobs, so muss mindestens ein BDS sein
+         * direkt durch einen Block Job verwendet */
         assert(bs);
     }
 }
 
-/* Fields that need to stay with the top-level BDS */
+/* Felder, die mit der Top-Level zu bleiben, müssen BDS */
 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
                                      BlockDriverState *bs_src)
 {
-    /* move some fields that need to stay attached to the device */
+    /* bewegen einige Felder, die mit dem Gerät zu bleiben angebracht brauchen
+     */
 }
 
 static void change_parent_backing_link(BlockDriverState *from,
@@ -2226,9 +2252,9 @@ static void change_parent_backing_link(BlockDriverState *from,
     BdrvChild *c, *next;
 
     if (from->blk) {
-        /* FIXME We bypass blk_set_bs(), so we need to make these updates
-         * manually. The root problem is not in this change function, but the
-         * existence of BlockDriverState.blk. */
+        /* FIXME umgehen Wir blk_set_bs (), so müssen wir diese Updates machen
+         * manuell. Das eigentliche Problem ist nicht in dieser
+         * Änderungsfunktion, aber die Existenz von BlockDriverState.blk. */
         to->blk = from->blk;
         from->blk = NULL;
     }
@@ -2261,20 +2287,20 @@ static void swap_feature_fields(BlockDriverState *bs_top,
 }
 
 /*
- * Add new bs contents at the top of an image chain while the chain is
- * live, while keeping required fields on the top layer.
+ * Neuen bs Inhalt an der Spitze einer Bildkette, während die Kette
+ * leben, während Pflichtfelder halten auf der obersten Ebene.
  *
- * This will modify the BlockDriverState fields, and swap contents
- * between bs_new and bs_top. Both bs_new and bs_top are modified.
+ * Dadurch werden die BlockDriverState Felder, und Swap-Inhalte ändern
+ * zwischen bs_new und bs_top. Sowohl bs_new und bs_top modifiziert.
  *
- * bs_new must not be attached to a BlockBackend.
+ * bs_new darf nicht zu einer BlockBackend befestigt werden.
  *
- * This function does not create any image files.
+ * Diese Funktion erzeugt keine Bilddateien.
  *
- * bdrv_append() takes ownership of a bs_new reference and unrefs it because
- * that's what the callers commonly need. bs_new will be referenced by the old
- * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
- * reference of its own, it must call bdrv_ref().
+ * bdrv_append () übernimmt den Besitz eines bs_new Referenz- und unrefs es,
+ * weil das ist, was die Anrufer häufig benötigen. bs_new wird durch die alte
+ * referenziert werden Eltern von bs_top nach bdrv_append () zurückkehrt. Wenn
+ * muss der Anrufer ein zu halten Bezug der eigenen, muss sie rufen bdrv_ref ().
  */
 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
 {
@@ -2284,14 +2310,14 @@ void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
     bdrv_ref(bs_top);
     change_parent_backing_link(bs_top, bs_new);
 
-    /* Some fields always stay on top of the backing file chain */
+    /* Einige Felder bleiben immer an der Spitze der Trägerdatei Kette */
     swap_feature_fields(bs_top, bs_new);
 
     bdrv_set_backing_hd(bs_new, bs_top);
     bdrv_unref(bs_top);
 
-    /* bs_new is now referenced by its new parents, we don't need the
-     * additional reference any more. */
+    /* bs_new wird nun von seinen neuen Eltern verwiesen, wir brauchen das nicht
+     * zusätzliche Referenz mehr. */
     bdrv_unref(bs_new);
 }
 
@@ -2303,20 +2329,23 @@ void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
     bdrv_ref(old);
 
     if (old->blk) {
-        /* As long as these fields aren't in BlockBackend, but in the top-level
-         * BlockDriverState, it's not possible for a BDS to have two BBs.
+        /* Solange diese Felder nicht in BlockBackend sind, aber in der obersten
+         * Ebene BlockDriverState, ist es nicht möglich, dass ein BDS zwei BBs
+         * zu haben.
          *
-         * We really want to copy the fields from old to new, but we go for a
-         * swap instead so that pointers aren't duplicated and cause trouble.
-         * (Also, bdrv_swap() used to do the same.) */
+         * Wir wollen wirklich die Felder von alten auf neue zu kopieren, aber
+         * wir gehen für ein tauschen stattdessen so, dass Zeiger nicht
+         * dupliziert werden und Probleme verursachen.
+         * (Auch bdrv_swap () verwendet, um das gleiche zu tun.) */
         assert(!new->blk);
         swap_feature_fields(old, new);
     }
     change_parent_backing_link(old, new);
 
-    /* Change backing files if a previously independent node is added to the
-     * chain. For active commit, we replace top by its own (indirect) backing
-     * file and don't do anything here so we don't build a loop. */
+    /* Ändern Sie die Sicherung von Dateien, wenn ein zuvor unabhängiger
+     * Knoten auf die hinzugefügt wird Kette. Für aktive verpflichten,
+     * ersetzen wir oben durch seine eigene (indirekt) Unterstützung Datei und
+     * tun nichts hier, so dass wir eine Schleife nicht bauen. */
     if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
         bdrv_set_backing_hd(new, backing_bs(old));
         bdrv_set_backing_hd(old, NULL);
@@ -2333,7 +2362,7 @@ static void bdrv_delete(BlockDriverState *bs)
 
     bdrv_close(bs);
 
-    /* remove from list, if necessary */
+    /* Von der Liste entfernen, falls erforderlich */
     if (bs->node_name[0] != '\0') {
         QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
     }
@@ -2343,11 +2372,11 @@ static void bdrv_delete(BlockDriverState *bs)
 }
 
 /*
- * Run consistency checks on an image
+ * Führen Sie Konsistenzprüfungen auf ein Bild,
  *
- * Returns 0 if the check could be completed (it doesn't mean that the image is
- * free of errors) or -errno when an internal error occurred. The results of the
- * check are stored in res.
+ * Gibt 0 zurück, wenn die Prüfung abgeschlossen werden konnte (es bedeutet
+ * nicht, dass das Bild fehlerfrei) oder -errno, wenn ein interner Fehler
+ * aufgetreten ist. Die Ergebnisse der Prüfung werden in res gespeichert.
  */
 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
 {
@@ -2364,7 +2393,7 @@ int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
 
 #define COMMIT_BUF_SECTORS 2048
 
-/* commit COW file into the raw image */
+/* KUH-Datei in das RAW-Bild begehen */
 int bdrv_commit(BlockDriverState *bs)
 {
     BlockDriver *drv = bs->drv;
@@ -2406,9 +2435,9 @@ int bdrv_commit(BlockDriverState *bs)
         goto ro_cleanup;
     }
 
-    /* If our top snapshot is larger than the backing file image,
-     * grow the backing file image if possible.  If not possible,
-     * we must return an error */
+    /* Wenn unsere Top-Snapshot ist größer als die Trägerdatei Bild,
+     * die Trägerdatei Bild, wenn möglich, zu wachsen. Falls dies nicht
+     * möglich, wir müssen einen Fehler zurück */
     if (length > backing_length) {
         ret = bdrv_truncate(bs->backing->bs, length);
         if (ret < 0) {
@@ -2418,8 +2447,9 @@ int bdrv_commit(BlockDriverState *bs)
 
     total_sectors = length >> BDRV_SECTOR_BITS;
 
-    /* qemu_try_blockalign() for bs will choose an alignment that works for
-     * bs->backing->bs as well, so no need to compare the alignment manually. */
+    /* qemu try_blockalign () für bs wird eine Ausrichtung wählen, die für
+     * Arbeiten BS-> Unterstützung-> bs als auch, so dass keine
+     * Notwendigkeit, die Ausrichtung manuell zu vergleichen. */
     buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
     if (buf == NULL) {
         ret = -ENOMEM;
@@ -2453,8 +2483,8 @@ int bdrv_commit(BlockDriverState *bs)
     }
 
     /*
-     * Make sure all data we wrote to the backing device is actually
-     * stable on disk.
+     * Stellen Sie sicher, dass alle Daten, die wir an der Trägereinrichtung
+     * schrieb tatsächlich ist stabil auf dem Datenträger.
      */
     if (bs->backing) {
         bdrv_flush(bs->backing->bs);
@@ -2465,7 +2495,7 @@ ro_cleanup:
     qemu_vfree(buf);
 
     if (ro) {
-        /* ignoring error return here */
+        /* ignorieren Fehler Rückkehr hier */
         bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
     }
 
@@ -2473,12 +2503,12 @@ ro_cleanup:
 }
 
 /*
- * Return values:
- * 0        - success
- * -EINVAL  - backing format specified, but no file
- * -ENOSPC  - can't update the backing file because no space is left in the
- *            image file header
- * -ENOTSUP - format driver doesn't support changing the backing file
+ * Rückgabewerte:
+ * 0 - Erfolg
+ * -EINVAL - Trägerformat angegeben, aber keine Datei
+ * -ENOSPC - Kann nicht die Unterstützung Datei aktualisiert werden, da kein
+ *           Platz mehr in der linken Seite Bild-Datei-Header
+ * -ENOTSUP - Format-Treiber unterstützt nicht die Unterstützung Datei ändern
  */
 int bdrv_change_backing_file(BlockDriverState *bs,
     const char *backing_file, const char *backing_fmt)
@@ -2486,7 +2516,7 @@ int bdrv_change_backing_file(BlockDriverState *bs,
     BlockDriver *drv = bs->drv;
     int ret;
 
-    /* Backing file format doesn't make sense without a backing file */
+    /* Dateiformat Sichern macht keinen Sinn, ohne Trägerdatei */
     if (backing_fmt && !backing_file) {
         return -EINVAL;
     }
@@ -2505,14 +2535,14 @@ int bdrv_change_backing_file(BlockDriverState *bs,
 }
 
 /*
- * Finds the image layer in the chain that has 'bs' as its backing file.
+ * Findet die Bildebene in der Kette, die 'bs' als Trägerdatei.
  *
- * active is the current topmost image.
+ * aktiv ist die aktuelle oberste Bild.
  *
- * Returns NULL if bs is not found in active's image chain,
- * or if active == bs.
+ * Gibt NULL zurück, wenn bs nicht im aktiven Image Kette gefunden,
+ * oder wenn aktiv == bs.
  *
- * Returns the bottommost base image if bs == NULL.
+ * Gibt die unterste Basis-Image, wenn bs == NULL.
  */
 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
                                     BlockDriverState *bs)
@@ -2524,39 +2554,39 @@ BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
     return active;
 }
 
-/* Given a BDS, searches for the base layer. */
+/* Bei einer BDS, sucht für die Basisschicht. */
 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
 {
     return bdrv_find_overlay(bs, NULL);
 }
 
 /*
- * Drops images above 'base' up to and including 'top', and sets the image
- * above 'top' to have base as its backing file.
+ * Drops Bilder oben "Basis" bis einschließlich "oben" und setzt das Bild
+ * oben "oben" Basis als Trägerdatei.
  *
- * Requires that the overlay to 'top' is opened r/w, so that the backing file
- * information in 'bs' can be properly updated.
+ * Erfordert, dass die Überlagerung "oben" r / w geöffnet wird, so dass die
+ * Trägerdatei Informationen in 'bs' können korrekt aktualisiert werden.
  *
- * E.g., this will convert the following chain:
- * bottom <- base <- intermediate <- top <- active
+ * Z. B. wird dies die folgende Kette umwandeln:
+ * unten <- base <- Zwischen <- nachp <- aktiv
  *
- * to
+ * nach
  *
- * bottom <- base <- active
+ * unten <- base <- aktiv
  *
- * It is allowed for bottom==base, in which case it converts:
+ * Es ist für den Boden == Basis erlaubt, wobei in diesem Fall wandelt:
  *
- * base <- intermediate <- top <- active
+ * Basis <- Zwischen <- top <- aktiv
  *
  * to
  *
- * base <- active
+ * Basis <- aktiv
  *
- * If backing_file_str is non-NULL, it will be used when modifying top's
- * overlay image metadata.
+ * Wenn backing_file_str nicht NULL ist, wird es verwendet werden, wenn oben
+ * die Modifizierung Overlay-Bild-Metadaten.
  *
- * Error conditions:
- *  if active == top, that is considered an error
+ * Fehlerbedingungen:
+ *  wenn aktiv == oben, ist, dass ein Fehler betrachtet
  *
  */
 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
@@ -2572,23 +2602,25 @@ int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
     new_top_bs = bdrv_find_overlay(active, top);
 
     if (new_top_bs == NULL) {
-        /* we could not find the image above 'top', this is an error */
+        /* wir konnten nicht das Bild oben "oben" zu finden, das ist ein Fehler
+         */
         goto exit;
     }
 
-    /* special case of new_top_bs->backing->bs already pointing to base - nothing
-     * to do, no intermediate images */
+    /* Sonderfall new_top_bs-> Unterstützung-> bs bereits auf Basis zeigt -
+     * nichts keine Zwischenbilder zu tun, */
     if (backing_bs(new_top_bs) == base) {
         ret = 0;
         goto exit;
     }
 
-    /* Make sure that base is in the backing chain of top */
+    /* Stellen Sie sicher, dass Basis ist in der Trägerkette von oben */
     if (!bdrv_chain_contains(top, base)) {
         goto exit;
     }
 
-    /* success - we can delete the intermediate states, and link top->base */
+    /* Erfolg - können wir die Zwischenzustände und verknüpfen
+     * Oberseite-> Basis löschen */
     backing_file_str = backing_file_str ? backing_file_str : base->filename;
     ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
                                    base->drv ? base->drv->format_name : "");
@@ -2603,7 +2635,7 @@ exit:
 }
 
 /**
- * Truncate file to 'offset' bytes (needed only for file protocols)
+ * Kürzt-Datei 'Offset' Bytes (nur erforderlich für Dateiprotokolle)
  */
 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
 {
@@ -2628,8 +2660,9 @@ int bdrv_truncate(BlockDriverState *bs, int64_t offset)
 }
 
 /**
- * Length of a allocated file in bytes. Sparse files are counted by actual
- * allocated space. Return < 0 if error or unknown.
+ * Länge einer zugeordneten Datei in Bytes. Sparse-Dateien werden von
+ * tatsächlichen gezählt zugewiesenen Platz. Zurück <0, wenn Fehler oder
+ * unbekannt ist.
  */
 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
 {
@@ -2647,7 +2680,7 @@ int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
 }
 
 /**
- * Return number of sectors on success, -errno on error.
+ * Zurück Anzahl der Sektoren auf Erfolg, -errno auf Fehler.
  */
 int64_t bdrv_nb_sectors(BlockDriverState *bs)
 {
@@ -2666,8 +2699,8 @@ int64_t bdrv_nb_sectors(BlockDriverState *bs)
 }
 
 /**
- * Return length in bytes on success, -errno on error.
- * The length is always a multiple of BDRV_SECTOR_SIZE.
+ * Zurück Länge in Bytes auf Erfolg, -errno auf Fehler.
+ * Die Länge ist immer ein Vielfaches von BDRV_SECTOR_SIZE.
  */
 int64_t bdrv_getlength(BlockDriverState *bs)
 {
@@ -2677,7 +2710,8 @@ int64_t bdrv_getlength(BlockDriverState *bs)
     return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
 }
 
-/* return 0 as number of sectors if no device present or error */
+/* return 0 als Anzahl von Sektoren, falls kein Gerät vorhanden ist oder Fehler
+ */
 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
 {
     int64_t nb_sectors = bdrv_nb_sectors(bs);
@@ -2734,7 +2768,7 @@ int bdrv_set_key(BlockDriverState *bs, const char *key)
     } else if (!bs->valid_key) {
         bs->valid_key = 1;
         if (bs->blk) {
-            /* call the change callback now, we skipped it on open */
+            /* rufen nun die Änderung Rückruf, wir ließen es auf offenen */
             blk_dev_change_media_cb(bs->blk, true);
         }
     }
@@ -2742,15 +2776,17 @@ int bdrv_set_key(BlockDriverState *bs, const char *key)
 }
 
 /*
- * Provide an encryption key for @bs.
- * If @key is non-null:
- *     If @bs is not encrypted, fail.
- *     Else if the key is invalid, fail.
- *     Else set @bs's key to @key, replacing the existing key, if any.
- * If @key is null:
- *     If @bs is encrypted and still lacks a key, fail.
- *     Else do nothing.
- * On failure, store an error object through @errp if non-null.
+ * Geben Sie einen Verschlüsselungsschlüssel für @bs.
+ * Wenn @key nicht null ist:
+ *     Wenn @bs nicht verschlüsselt ist, fehlschlagen.
+ *     Else, wenn der Schlüssel ungültig ist, fehlschlagen.
+ *     Else Set @ bs Schlüssel zum @key, den vorhandenen Schlüssel zu
+ *     ersetzen, falls vorhanden.
+ * Wenn @key ist null:
+ *     Wenn @bs verschlüsselt ist und es fehlt immer noch einen Schlüssel,
+ *     scheitern.
+ *     Else nichts zu tun.
+ * Bei einem Fehler speichern ein Fehlerobjekt durch @errp wenn nicht null ist.
  */
 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
 {
@@ -2813,7 +2849,7 @@ void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
     g_free(formats);
 }
 
-/* This function is to find a node in the bs graph */
+/* Diese Funktion ist ein Knoten in dem Graphen zu finden bs */
 BlockDriverState *bdrv_find_node(const char *node_name)
 {
     BlockDriverState *bs;
@@ -2828,7 +2864,8 @@ BlockDriverState *bdrv_find_node(const char *node_name)
     return NULL;
 }
 
-/* Put this QMP function here so it can access the static graph_bdrv_states. */
+/* Setzen Sie diese Funktion QMP hier so es die statischen graph_bdrv_states
+ * zugreifen können. */
 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
 {
     BlockDeviceInfoList *list, *entry;
@@ -2884,8 +2921,8 @@ BlockDriverState *bdrv_lookup_bs(const char *device,
     return NULL;
 }
 
-/* If 'base' is in the same chain as 'top', return true. Otherwise,
- * return false.  If either argument is NULL, return false. */
+/* Wenn "Basis" in der gleichen Kette wie "oben", return true. Andernfalls,
+ * return false. Wenn eines der Argumente NULL ist, return false. */
 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
 {
     while (top && top != base) {
@@ -2903,8 +2940,8 @@ BlockDriverState *bdrv_next_node(BlockDriverState *bs)
     return QTAILQ_NEXT(bs, node_list);
 }
 
-/* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
- * the monitor or attached to a BlockBackend */
+/* Iteriert über alle Top-Level-BlockDriverStates, das heißt BDSe, die von im
+ * Besitz der Monitor oder an einem BlockBackend */
 BlockDriverState *bdrv_next(BlockDriverState *bs)
 {
     if (!bs || bs->blk) {
@@ -2914,8 +2951,8 @@ BlockDriverState *bdrv_next(BlockDriverState *bs)
         }
     }
 
-    /* Ignore all BDSs that are attached to a BlockBackend here; they have been
-     * handled by the above block already */
+    /* Ignorieren Sie alle BDSe, die hier zu einem BlockBackend gebunden sind;
+     * Sie waren bereits durch den obigen Block behandelt */
     do {
         bs = bdrv_next_monitor_owned(bs);
     } while (bs && bs->blk);
@@ -2927,16 +2964,18 @@ const char *bdrv_get_node_name(const BlockDriverState *bs)
     return bs->node_name;
 }
 
-/* TODO check what callers really want: bs->node_name or blk_name() */
+/* TODO überprüfen, was Anrufer wirklich wollen: BS-> node_name oder
+ * blk_name () */
 const char *bdrv_get_device_name(const BlockDriverState *bs)
 {
     return bs->blk ? blk_name(bs->blk) : "";
 }
 
-/* This can be used to identify nodes that might not have a device
- * name associated. Since node and device names live in the same
- * namespace, the result is unambiguous. The exception is if both are
- * absent, then this returns an empty (non-null) string. */
+/* Dies kann verwendet werden, um Knoten zu identifizieren, die keine
+ * Vorrichtung haben könnte Namen zugeordnet ist. Da der Knoten und
+ * Gerätenamen leben in der gleichen Namensraum, das Ergebnis ist eindeutig.
+ * Die Ausnahme ist, wenn beide abwesend ist, gibt diese eine leere (nicht null)
+ * Zeichenfolge. */
 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
 {
     return bs->blk ? blk_name(bs->blk) : bs->node_name;
@@ -2956,8 +2995,8 @@ int bdrv_has_zero_init(BlockDriverState *bs)
 {
     assert(bs->drv);
 
-    /* If BS is a copy on write image, it is initialized to
-       the contents of the base image, which may not be zeroes.  */
+    /* Wenn BS eine Kopie auf Schreib Bild ist, wird es initialisiert
+       der Inhalt des Basisbildes, die Nullen nicht sein kann.  */
     if (bs->backing) {
         return 0;
     }
@@ -2965,7 +3004,7 @@ int bdrv_has_zero_init(BlockDriverState *bs)
         return bs->drv->bdrv_has_zero_init(bs);
     }
 
-    /* safe default */
+    /* sichere Standard */
     return 0;
 }
 
@@ -3102,10 +3141,10 @@ int bdrv_is_snapshot(BlockDriverState *bs)
     return !!(bs->open_flags & BDRV_O_SNAPSHOT);
 }
 
-/* backing_file can either be relative, or absolute, or a protocol.  If it is
- * relative, it must be relative to the chain.  So, passing in bs->filename
- * from a BDS as backing_file should not be done, as that may be relative to
- * the CWD rather than the chain. */
+/* backing_file kann entweder relativ sein, oder absolut, oder ein Protokoll.
+ * Wenn es sich um relativ, muss es an der Kette relativ sein. Also, vorbei in
+ * BS-> Dateiname von einem BDS als backing_file nicht getan werden sollte, so
+ * dass relativ sein kann die CWD anstatt die Kette. */
 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
         const char *backing_file)
 {
@@ -3128,26 +3167,27 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
 
     for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
 
-        /* If either of the filename paths is actually a protocol, then
-         * compare unmodified paths; otherwise make paths relative */
+        /* Wenn eine der Dateipfade tatsächlich ein Protokoll, dann
+         * vergleichen unmodifizierten Pfade; sonst machen Pfade relativ */
         if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
             if (strcmp(backing_file, curr_bs->backing_file) == 0) {
                 retval = curr_bs->backing->bs;
                 break;
             }
         } else {
-            /* If not an absolute filename path, make it relative to the current
-             * image's filename path */
+            /* Wenn kein absoluter Dateiname Pfad, machen es zum aktuellen
+             * relativen Bild des Dateipfad */
             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
                          backing_file);
 
-            /* We are going to compare absolute pathnames */
+            /* Wir werden absolute Pfadnamen zu vergleichen */
             if (!realpath(filename_tmp, filename_full)) {
                 continue;
             }
 
-            /* We need to make sure the backing filename we are comparing against
-             * is relative to the current image filename (or absolute) */
+            /* Wir müssen sicherstellen, dass die Unterstützung Dateinamen
+             * machen wir einen Vergleich gegen ist auf dem aktuellen
+             * Image-Dateinamen (oder absolute) relativ */
             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
                          curr_bs->backing_file);
 
@@ -3278,10 +3318,10 @@ int bdrv_inactivate_all(void)
 }
 
 /**************************************************************/
-/* removable device support */
+/* herausnehmbaren Geräteträger */
 
 /**
- * Return TRUE if the media is present
+ * TRUE zurück, wenn die Medien vorhanden ist,
  */
 bool bdrv_is_inserted(BlockDriverState *bs)
 {
@@ -3303,8 +3343,9 @@ bool bdrv_is_inserted(BlockDriverState *bs)
 }
 
 /**
- * Return whether the media changed since the last call to this
- * function, or -ENOTSUP if we don't know.  Most drivers don't know.
+ * Gibt zurück, ob die Medien seit dem letzten Aufruf dieser geändert
+ * Funktion oder -ENOTSUP, wenn wir nicht wissen. Die meisten Fahrer wissen
+ * es nicht.
  */
 int bdrv_media_changed(BlockDriverState *bs)
 {
@@ -3317,7 +3358,8 @@ int bdrv_media_changed(BlockDriverState *bs)
 }
 
 /**
- * If eject_flag is TRUE, eject the media. Otherwise, close the tray
+ * Wenn eject_flag TRUE ist, kann das Medium ausgeworfen. Andernfalls schließen
+ * Sie das Fach
  */
 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
 {
@@ -3336,8 +3378,8 @@ void bdrv_eject(BlockDriverState *bs, bool eject_flag)
 }
 
 /**
- * Lock or unlock the media (if it is locked, the user won't be able
- * to eject it manually).
+ * Sperren oder Entsperren der Medien (wenn es gesperrt ist, wird der Benutzer
+ * nicht in der Lage auszuwerfen es manuell).
  */
 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
 {
@@ -3350,15 +3392,15 @@ void bdrv_lock_medium(BlockDriverState *bs, bool locked)
     }
 }
 
-/* Get a reference to bs */
+/* Holen Sie sich ein Verweis auf bs */
 void bdrv_ref(BlockDriverState *bs)
 {
     bs->refcnt++;
 }
 
-/* Release a previously grabbed reference to bs.
- * If after releasing, reference count is zero, the BlockDriverState is
- * deleted. */
+/* Lassen Sie eine zuvor packte Bezug auf bs.
+ * Wenn nach dem Loslassen Referenzzählung gleich Null ist, ist die
+ * BlockDriverState gelöscht. */
 void bdrv_unref(BlockDriverState *bs)
 {
     if (!bs) {
@@ -3454,7 +3496,7 @@ void bdrv_img_create(const char *filename, const char *fmt,
     Error *local_err = NULL;
     int ret = 0;
 
-    /* Find driver and parse its options */
+    /* Finden Sie Treiber und analysieren seine Optionen */
     drv = bdrv_find_format(fmt);
     if (!drv) {
         error_setg(errp, "Unknown file format '%s'", fmt);
@@ -3481,11 +3523,11 @@ void bdrv_img_create(const char *filename, const char *fmt,
     create_opts = qemu_opts_append(create_opts, drv->create_opts);
     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
 
-    /* Create parameter list with default values */
+    /* Erstellen Parameterliste mit Standardwerten */
     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
 
-    /* Parse -o options */
+    /* Parse -o */
     if (options) {
         qemu_opts_do_parse(opts, options, NULL, &local_err);
         if (local_err) {
@@ -3544,7 +3586,7 @@ void bdrv_img_create(const char *filename, const char *fmt,
                 goto out;
             }
 
-            /* backing files always opened read-only */
+            /* Sichern von Dateien geöffnet immer schreibgeschützt */
             back_flags = flags;
             back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
 
@@ -3587,9 +3629,10 @@ void bdrv_img_create(const char *filename, const char *fmt,
     ret = bdrv_create(drv, filename, opts, &local_err);
 
     if (ret == -EFBIG) {
-        /* This is generally a better message than whatever the driver would
-         * deliver (especially because of the cluster_size_hint), since that
-         * is most probably not much different from "image too large". */
+        /* Dies ist im Allgemeinen eine bessere Nachricht als das, was der
+         * Fahrer würde liefern (vor allem wegen der cluster_size_hint), da
+         * dies ist höchstwahrscheinlich von "Bild zu groß" nicht viel anders.
+         */
         const char *cluster_size_hint = "";
         if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
             cluster_size_hint = " (try using a larger cluster size)";
@@ -3672,12 +3715,12 @@ void bdrv_attach_aio_context(BlockDriverState *bs,
 
 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
 {
-    bdrv_drain(bs); /* ensure there are no in-flight requests */
+    bdrv_drain(bs); /* sicherzustellen, dass keine in-flight-Anfragen sind */
 
     bdrv_detach_aio_context(bs);
 
-    /* This function executes in the old AioContext so acquire the new one in
-     * case it runs in a different thread.
+    /* Diese Funktion führt in der alten AioContext so die neue erwerben in
+     * Fall es läuft in einem anderen Thread.
      */
     aio_context_acquire(new_context);
     bdrv_attach_aio_context(bs, new_context);
@@ -3730,55 +3773,56 @@ int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
     return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
 }
 
-/* This function will be called by the bdrv_recurse_is_first_non_filter method
- * of block filter and by bdrv_is_first_non_filter.
- * It is used to test if the given bs is the candidate or recurse more in the
- * node graph.
+/* Diese Funktion wird von der bdrv_recurse_is_first_non_filter Methode
+ * aufgerufen werden, von Blockfilter und durch bdrv_is_first_non_filter.
+ * Es wird verwendet, um zu testen, ob die gegebenen bs der Bewerber oder
+ * Rekursion mehr in der ist Knoten Graphen.
  */
 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
                                       BlockDriverState *candidate)
 {
-    /* return false if basic checks fails */
+    /* return false wenn grundlegende Überprüfungen fehlschlägt */
     if (!bs || !bs->drv) {
         return false;
     }
 
-    /* the code reached a non block filter driver -> check if the bs is
-     * the same as the candidate. It's the recursion termination condition.
+    /* der Code erreicht einen nicht-Block-Filtertreiber -> überprüfen, ob die
+     * bs der gleiche wie der Kandidat. Es ist die Rekursion Abbruchbedingung.
      */
     if (!bs->drv->is_filter) {
         return bs == candidate;
     }
-    /* Down this path the driver is a block filter driver */
+    /* Auf diesem Weg ist der Fahrer ein Blockfiltertreiber */
 
-    /* If the block filter recursion method is defined use it to recurse down
-     * the node graph.
+    /* Wenn der Blockfilter Rekursion Verfahren Gebrauch definiert ist es
+     * rekursiv der Knoten Graphen.
      */
     if (bs->drv->bdrv_recurse_is_first_non_filter) {
         return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
     }
 
-    /* the driver is a block filter but don't allow to recurse -> return false
-     */
+    /* der Fahrer ist ein Filterblock aber nicht zulassen recurse ->
+     * return false */
     return false;
 }
 
-/* This function checks if the candidate is the first non filter bs down it's
- * bs chain. Since we don't have pointers to parents it explore all bs chains
- * from the top. Some filters can choose not to pass down the recursion.
+/* Diese Funktion überprüft, ob der Kandidat die ersten nicht-Filter bs ist
+ * nach unten, es ist bs Kette. Da wir es alle bs Ketten erkunden keine Hinweise
+ * auf die Eltern von oben. Einige Filter können wählen, nicht die Rekursion
+ * zu überliefern.
  */
 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
 {
     BlockDriverState *bs = NULL;
 
-    /* walk down the bs forest recursively */
+    /* Gehen Sie die bs Wald rekursiv */
     while ((bs = bdrv_next(bs)) != NULL) {
         bool perm;
 
-        /* try to recurse in this top level bs */
+        /* versuchen, in diesem Top-Level-bs recurse */
         perm = bdrv_recurse_is_first_non_filter(bs, candidate);
 
-        /* candidate is the first non filter */
+        /* Kandidat ist der erste nicht-Filter */
         if (perm) {
             return true;
         }
@@ -3806,10 +3850,10 @@ BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
         goto out;
     }
 
-    /* We don't want arbitrary node of the BDS chain to be replaced only the top
-     * most non filter in order to prevent data corruption.
-     * Another benefit is that this tests exclude backing files which are
-     * blocked by the backing blockers.
+    /* Wir wollen nicht willkürlich Knoten der BDS-Kette nur die Spitze ersetzt
+     * werden die meisten nicht-Filter, um Datenkorruption zu verhindern.
+     * Ein weiterer Vorteil ist, dass diese Tests Backup-Dateien ausschließen,
+     * die sind durch die Unterstützung Blocker blockiert.
      */
     if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
         error_setg(errp, "Only top most non filter can be replaced");
@@ -3833,7 +3877,7 @@ static bool append_open_options(QDict *d, BlockDriverState *bs)
     for (entry = qdict_first(bs->options); entry;
          entry = qdict_next(bs->options, entry))
     {
-        /* Exclude options for children */
+        /* Exclude-Optionen für Kinder */
         QLIST_FOREACH(child, &bs->children, next) {
             if (strstart(qdict_entry_key(entry), child->name, &p)
                 && (!*p || *p == '.'))
@@ -3845,7 +3889,7 @@ static bool append_open_options(QDict *d, BlockDriverState *bs)
             continue;
         }
 
-        /* And exclude all non-driver-specific options */
+        /* Und nicht enthalten alle nicht fahrerspezifische Optionen */
         for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
             if (!strcmp(qdict_entry_key(entry), desc->name)) {
                 break;
@@ -3863,17 +3907,19 @@ static bool append_open_options(QDict *d, BlockDriverState *bs)
     return found_any;
 }
 
-/* Updates the following BDS fields:
- *  - exact_filename: A filename which may be used for opening a block device
- *                    which (mostly) equals the given BDS (even without any
- *                    other options; so reading and writing must return the same
- *                    results, but caching etc. may be different)
- *  - full_open_options: Options which, when given when opening a block device
- *                       (without a filename), result in a BDS (mostly)
- *                       equalling the given one
- *  - filename: If exact_filename is set, it is copied here. Otherwise,
- *              full_open_options is converted to a JSON object, prefixed with
- *              "json:" (for use through the JSON pseudo protocol) and put here.
+/* Aktualisiert die folgenden BDS Felder:
+ *  - Exact_filename: Ein Dateiname, der zum Öffnen eines Blockgerät verwendet
+ *                    werden kann, die (meist) gleich der gegebenen BDS (auch
+ *                    ohne andere Optionen; so das Lesen und Schreiben müssen
+ *                    die gleiche Rückkehr Ergebnisse, aber Caching usw.
+ *                    können abweichen)
+ *  - Full_open_options: Optionen, die, wenn gegeben, wenn ein Blockgerät zu
+ *                       öffnen (Ohne Dateinamen), führen zu einer BDS
+ *                       (meistens) gleich der gegebenen
+ *  - Dateiname: Wenn exact_filename gesetzt ist, wird es hier kopiert.
+ *               Andernfalls, full_open_options ist mit einem JSON-Objekt
+ *               umgewandelt, mit dem Präfix "Json:" (zur Verwendung durch das
+ *               JSON Pseudo-Protokoll) und hier setzen.
  */
 void bdrv_refresh_filename(BlockDriverState *bs)
 {
@@ -3884,15 +3930,15 @@ void bdrv_refresh_filename(BlockDriverState *bs)
         return;
     }
 
-    /* This BDS's file name will most probably depend on its file's name, so
-     * refresh that first */
+    /* Dieser Dateiname des BDS wird höchstwahrscheinlich auf den Namen seiner
+     * Datei ab, so erfrischen, dass zuerst */
     if (bs->file) {
         bdrv_refresh_filename(bs->file->bs);
     }
 
     if (drv->bdrv_refresh_filename) {
-        /* Obsolete information is of no use here, so drop the old file name
-         * information before refreshing it */
+        /* Veraltete Informationen ist hier nichts, fallen so den alten
+         * Dateinamen Informationen, bevor es erfrischend */
         bs->exact_filename[0] = '\0';
         if (bs->full_open_options) {
             QDECREF(bs->full_open_options);
@@ -3904,7 +3950,8 @@ void bdrv_refresh_filename(BlockDriverState *bs)
         drv->bdrv_refresh_filename(bs, opts);
         QDECREF(opts);
     } else if (bs->file) {
-        /* Try to reconstruct valid information from the underlying file */
+        /* Versuchen Sie, gültige Informationen aus der zugrunde liegenden
+         * Datei rekonstruieren */
         bool has_open_options;
 
         bs->exact_filename[0] = '\0';
@@ -3916,16 +3963,18 @@ void bdrv_refresh_filename(BlockDriverState *bs)
         opts = qdict_new();
         has_open_options = append_open_options(opts, bs);
 
-        /* If no specific options have been given for this BDS, the filename of
-         * the underlying file should suffice for this one as well */
+        /* Wenn keine spezifischen Optionen wurden für diesen BDS, dem
+         * Dateinamen des angegebenen die zugrunde liegende Datei sollte auch
+         * für diese eine ausreichend */
         if (bs->file->bs->exact_filename[0] && !has_open_options) {
             strcpy(bs->exact_filename, bs->file->bs->exact_filename);
         }
-        /* Reconstructing the full options QDict is simple for most format block
-         * drivers, as long as the full options are known for the underlying
-         * file BDS. The full options QDict of that file BDS should somehow
-         * contain a representation of the filename, therefore the following
-         * suffices without querying the (exact_)filename of this BDS. */
+        /* die volle Optionen QDict Rekonstruieren ist einfach für die meisten
+         * Format-Block Fahrer, solange die vollen Möglichkeiten für die
+         * darunter liegende bekannt sind Datei BDS. Die voll Optionen QDict
+         * dieser BDS-Datei sollte irgendwie enthalten eine Darstellung der
+         * Dateiname, der daher die folgenden genügt, ohne die
+         * (exact_) Dateiname dieser BDS abfragen. */
         if (bs->file->bs->full_open_options) {
             qdict_put_obj(opts, "driver",
                           QOBJECT(qstring_from_str(drv->format_name)));
@@ -3938,12 +3987,12 @@ void bdrv_refresh_filename(BlockDriverState *bs)
             QDECREF(opts);
         }
     } else if (!bs->full_open_options && qdict_size(bs->options)) {
-        /* There is no underlying file BDS (at least referenced by BDS.file),
-         * so the full options QDict should be equal to the options given
-         * specifically for this block device when it was opened (plus the
-         * driver specification).
-         * Because those options don't change, there is no need to update
-         * full_open_options when it's already set. */
+        /* Es gibt keine zugrunde liegende Datei BDS (zumindest von BDS.file
+         * bezeichnet), so dass die volle Optionen QDict sollte gegeben zu den
+         * Optionen gleich speziell für diesen Block-Gerät, wenn es geöffnet
+         * wurde (plus Treiber-Spezifikation).
+         * Da diese Optionen nicht ändern, gibt es keine Notwendigkeit zu
+         * aktualisieren full_open_options, wenn es bereits gesetzt ist. */
 
         opts = qdict_new();
         append_open_options(opts, bs);
@@ -3951,12 +4000,13 @@ void bdrv_refresh_filename(BlockDriverState *bs)
                       QOBJECT(qstring_from_str(drv->format_name)));
 
         if (bs->exact_filename[0]) {
-            /* This may not work for all block protocol drivers (some may
-             * require this filename to be parsed), but we have to find some
-             * default solution here, so just include it. If some block driver
-             * does not support pure options without any filename at all or
-             * needs some special format of the options QDict, it needs to
-             * implement the driver-specific bdrv_refresh_filename() function.
+            /* Dies kann für alle Block Protokolltreiber nicht (einige können
+             * benötigen diese Dateinamen analysiert) werden, aber wir haben
+             * einige zu finden Standardlösung hier, so sind es eben. Wenn
+             * einige Blocktreiber unterstützt keine reine Optionen ohne
+             * Dateinamen überhaupt nicht oder braucht einige spezielle Format
+             * der Optionen QDict, muss es Umsetzung des treiberspezifische
+             * bdrv_refresh_filename () Funktion.
              */
             qdict_put_obj(opts, "filename",
                           QOBJECT(qstring_from_str(bs->exact_filename)));
diff --git a/block/blkdebug.c b/block/blkdebug.c
index 20d25bd..5084b58 100644
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -115,7 +115,7 @@ static QemuOptsList inject_error_opts = {
             .name = "immediately",
             .type = QEMU_OPT_BOOL,
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     },
 };
 
@@ -135,7 +135,7 @@ static QemuOptsList set_state_opts = {
             .name = "new_state",
             .type = QEMU_OPT_NUMBER,
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     },
 };
 
@@ -172,7 +172,7 @@ static int add_rule(void *opaque, QemuOpts *opts, Error **errp)
     BlkdebugEvent event;
     struct BlkdebugRule *rule;
 
-    /* Find the right event for the rule */
+    /* Finden Sie das richtige Ereignis für die Regel */
     event_name = qemu_opt_get(opts, "event");
     if (!event_name) {
         error_setg(errp, "Missing event name for rule");
@@ -182,7 +182,7 @@ static int add_rule(void *opaque, QemuOpts *opts, Error **errp)
         return -1;
     }
 
-    /* Set attributes common for all actions */
+    /* Set-Attribute, die für alle Aktionen */
     rule = g_malloc0(sizeof(*rule));
     *rule = (struct BlkdebugRule) {
         .event  = event,
@@ -190,7 +190,7 @@ static int add_rule(void *opaque, QemuOpts *opts, Error **errp)
         .state  = qemu_opt_get_number(opts, "state", 0),
     };
 
-    /* Parse action-specific options */
+    /* Parse aktionsspezifische Optionen */
     switch (d->action) {
     case ACTION_INJECT_ERROR:
         rule->options.inject.error = qemu_opt_get_number(opts, "errno", EIO);
@@ -211,7 +211,7 @@ static int add_rule(void *opaque, QemuOpts *opts, Error **errp)
         break;
     };
 
-    /* Add the rule */
+    /* Fügen Sie die Regel */
     QLIST_INSERT_HEAD(&s->rules[event], rule, next);
 
     return 0;
@@ -289,21 +289,22 @@ fail:
     return ret;
 }
 
-/* Valid blkdebug filenames look like blkdebug:path/to/config:path/to/image */
+/* Gültige blkdebug Dateinamen aussehen
+ * blkdebug: path / to / config: path / to / Bild */
 static void blkdebug_parse_filename(const char *filename, QDict *options,
                                     Error **errp)
 {
     const char *c;
 
-    /* Parse the blkdebug: prefix */
+    /* Analysieren Sie die blkdebug: Präfix */
     if (!strstart(filename, "blkdebug:", &filename)) {
-        /* There was no prefix; therefore, all options have to be already
-           present in the QDict (except for the filename) */
+        /* Es gab keinen Präfix; Daher haben alle Optionen bereits zu sein
+           in der QDict (mit Ausnahme der Dateiname) */
         qdict_put(options, "x-image", qstring_from_str(filename));
         return;
     }
 
-    /* Parse config file path */
+    /* Parse-Konfigurationsdateipfad */
     c = strchr(filename, ':');
     if (c == NULL) {
         error_setg(errp, "blkdebug requires both config file and image path");
@@ -316,7 +317,8 @@ static void blkdebug_parse_filename(const char *filename, QDict *options,
         qdict_put(options, "config", config_path);
     }
 
-    /* TODO Allow multi-level nesting and set file.filename here */
+    /* TODO zulassen Multi-Level-Verschachtelung und setzen file.filename hier
+     */
     filename = c + 1;
     qdict_put(options, "x-image", qstring_from_str(filename));
 }
@@ -340,7 +342,7 @@ static QemuOptsList runtime_opts = {
             .type = QEMU_OPT_SIZE,
             .help = "Required alignment in bytes",
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     },
 };
 
@@ -362,17 +364,17 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,
         goto out;
     }
 
-    /* Read rules from config file or command line options */
+    /* Lesen Sie Regeln aus Config-Datei oder Kommandozeilenoptionen */
     config = qemu_opt_get(opts, "config");
     ret = read_config(s, config, options, errp);
     if (ret) {
         goto out;
     }
 
-    /* Set initial state */
+    /* Stellen Sie Anfangszustand */
     s->state = 1;
 
-    /* Open the image file */
+    /* Öffnen Sie die Bilddatei */
     bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image",
                                bs, &child_file, false, &local_err);
     if (local_err) {
@@ -381,7 +383,7 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,
         goto out;
     }
 
-    /* Set request alignment */
+    /* Set Anfrage Ausrichtung */
     align = qemu_opt_get_size(opts, "align", bs->request_alignment);
     if (align > 0 && align < INT_MAX && !(align & (align - 1))) {
         bs->request_alignment = align;
@@ -546,12 +548,12 @@ static bool process_rule(BlockDriverState *bs, struct BlkdebugRule *rule,
 {
     BDRVBlkdebugState *s = bs->opaque;
 
-    /* Only process rules for the current state */
+    /* Nur Prozessregeln für den aktuellen Zustand */
     if (rule->state && rule->state != s->state) {
         return injected;
     }
 
-    /* Take the action */
+    /* Nehmen Sie die Aktion */
     switch (rule->action) {
     case ACTION_INJECT_ERROR:
         if (!injected) {
@@ -692,8 +694,8 @@ static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)
     }
 
     if (force_json && !bs->file->bs->full_open_options) {
-        /* The config file cannot be recreated, so creating a plain filename
-         * is impossible */
+        /* Die Konfigurationsdatei kann nicht neu erstellt werden, so dass eine
+         * einfache Dateinamen zu schaffen ist unmöglich */
         return;
     }
 
diff --git a/block/linux-aio.c b/block/linux-aio.c
index 805757e..09a94e6 100644
--- a/block/linux-aio.c
+++ b/block/linux-aio.c
@@ -17,12 +17,12 @@
 #include <libaio.h>
 
 /*
- * Queue size (per-device).
+ * Queue-Größe (pro Gerät).
  *
- * XXX: eventually we need to communicate this to the guest and/or make it
- *      tunable by the guest.  If we get more outstanding requests at a time
- *      than this we will get EAGAIN from io_submit which is communicated to
- *      the guest as an I/O error.
+ * XXX: schließlich müssen wir dies dem Gast zu kommunizieren und / oder es
+ *      machen abstimmbar durch den Gast. Wenn wir bekommen mehr ausstehenden
+ *      Anforderungen zu einer Zeit, als dies werden wir EAGAIN von io_submit
+ *      erhalten, die in Verbindung steht der Gast als I / O-Fehler.
  */
 #define MAX_EVENTS 128
 
@@ -50,10 +50,10 @@ struct qemu_laio_state {
     io_context_t ctx;
     EventNotifier e;
 
-    /* io queue for submit at batch */
+    /* io Warteschlange für auf Charge einreichen */
     LaioQueue io_q;
 
-    /* I/O completion processing */
+    /* I / O-Abschlussverarbeitung */
     QEMUBH *completion_bh;
     struct io_event events[MAX_EVENTS];
     int event_idx;
@@ -68,7 +68,7 @@ static inline ssize_t io_event_ret(struct io_event *ev)
 }
 
 /*
- * Completes an AIO request (calls the callback and frees the ACB).
+ * Vervollständigt ein AIO Anfrage (die Rückrufe und befreit den ACB).
  */
 static void qemu_laio_process_completion(struct qemu_laio_state *s,
     struct qemu_laiocb *laiocb)
@@ -80,7 +80,7 @@ static void qemu_laio_process_completion(struct qemu_laio_state *s,
         if (ret == laiocb->nbytes) {
             ret = 0;
         } else if (ret >= 0) {
-            /* Short reads mean EOF, pad with zeros. */
+            /* Kurz liest mittlere EOF, Pad mit Nullen. */
             if (laiocb->is_read) {
                 qemu_iovec_memset(laiocb->qiov, ret, 0,
                     laiocb->qiov->size - ret);
@@ -94,22 +94,23 @@ static void qemu_laio_process_completion(struct qemu_laio_state *s,
     qemu_aio_unref(laiocb);
 }
 
-/* The completion BH fetches completed I/O requests and invokes their
- * callbacks.
+/* Die Fertigstellung BH holt Anfragen E / A abgeschlossen und ruft ihre
+ * Rückrufe.
  *
- * The function is somewhat tricky because it supports nested event loops, for
- * example when a request callback invokes aio_poll().  In order to do this,
- * the completion events array and index are kept in qemu_laio_state.  The BH
- * reschedules itself as long as there are completions pending so it will
- * either be called again in a nested event loop or will be called after all
- * events have been completed.  When there are no events left to complete, the
- * BH returns without rescheduling.
+ * Die Funktion ist etwas schwierig, weil es verschachtelte Ereignisschleifen
+ * unterstützt, für Beispiel, wenn eine Anfrage Rückruf ruft aio_poll (). Um
+ * dies zu tun, die Fertigstellung Ereignisse Array und Index werden in
+ * qemu_laio_state gehalten. die BH Umplanungen selbst, solange es Ergänzungen
+ * anhängig sind, so wird es entweder in einer verschachtelten Ereignisschleife
+ * erneut aufgerufen werden oder wird nach all aufgerufen werden Ereignisse
+ * abgeschlossen sind. Wenn es links keine Ereignisse zu vervollständigen, die
+ * BH zurück, ohne Umschuldung.
  */
 static void qemu_laio_completion_bh(void *opaque)
 {
     struct qemu_laio_state *s = opaque;
 
-    /* Fetch more completion events when empty */
+    /* Fetch mehr Abschluss-Ereignisse, wenn leer */
     if (s->event_idx == s->event_max) {
         do {
             struct timespec ts = { 0 };
@@ -120,14 +121,15 @@ static void qemu_laio_completion_bh(void *opaque)
         s->event_idx = 0;
         if (s->event_max <= 0) {
             s->event_max = 0;
-            return; /* no more events */
+            return; /* nicht mehr Veranstaltungen */
         }
     }
 
-    /* Reschedule so nested event loops see currently pending completions */
+    /* Umplanen so verschachtelte Ereignisschleifen Zurzeit anstehenden Fertig
+     */
     qemu_bh_schedule(s->completion_bh);
 
-    /* Process completion events */
+    /* Prozess Abschluss Veranstaltungen */
     while (s->event_idx < s->event_max) {
         struct iocb *iocb = s->events[s->event_idx].obj;
         struct qemu_laiocb *laiocb =
@@ -165,7 +167,8 @@ static void laio_cancel(BlockAIOCB *blockacb)
     ret = io_cancel(laiocb->ctx->ctx, &laiocb->iocb, &event);
     laiocb->ret = -ECANCELED;
     if (ret != 0) {
-        /* iocb is not cancelled, cb will be called by the event loop later */
+        /* IOCB wird nicht abgebrochen, wird cb durch die Ereignisschleife
+         * später aufgerufen werden */
         return;
     }
 
@@ -263,7 +266,7 @@ BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd,
     case QEMU_AIO_READ:
         io_prep_preadv(iocbs, fd, qiov->iov, qiov->niov, offset);
 	break;
-    /* Currently Linux kernel does not support other operations */
+    /* Derzeit Linux-Kernel unterstützt keine anderen Operationen */
     default:
         fprintf(stderr, "%s: invalid AIO request type 0x%x.\n",
                         __func__, type);
diff --git a/block/qcow.c b/block/qcow.c
index 60ddb12..af3ea27 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -34,7 +34,7 @@
 #include "migration/migration.h"
 
 /**************************************************************/
-/* QEMU COW block driver with compression and encryption support */
+/* QEMU COW-Block-Treiber mit Kompression und Verschlüsselung */
 
 #define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
 #define QCOW_VERSION 1
@@ -50,7 +50,7 @@ typedef struct QCowHeader {
     uint64_t backing_file_offset;
     uint32_t backing_file_size;
     uint32_t mtime;
-    uint64_t size; /* in bytes */
+    uint64_t size; /* in Bytes */
     uint8_t cluster_bits;
     uint8_t l2_bits;
     uint16_t padding;
@@ -76,7 +76,7 @@ typedef struct BDRVQcowState {
     uint8_t *cluster_cache;
     uint8_t *cluster_data;
     uint64_t cluster_cache_offset;
-    QCryptoCipher *cipher; /* NULL if no key yet */
+    QCryptoCipher *cipher; /* NULL, wenn kein Schlüssel vorhanden */
     uint32_t crypt_method_header;
     CoMutex lock;
     Error *migration_blocker;
@@ -139,8 +139,8 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    /* l2_bits specifies number of entries; storing a uint64_t in each entry,
-     * so bytes = num_entries << 3. */
+    /* l2_bits gibt Anzahl der Einträge; eine uint64_t in jedem Eintrag zu
+     * speichern, so Bytes = num_entries << 3. */
     if (header.l2_bits < 9 - 3 || header.l2_bits > 16 - 3) {
         error_setg(errp, "L2 table size must be between 512 and 64k");
         ret = -EINVAL;
@@ -177,7 +177,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
     bs->total_sectors = header.size / 512;
     s->cluster_offset_mask = (1LL << (63 - s->cluster_bits)) - 1;
 
-    /* read the level 1 table */
+    /* Lesen Sie die Ebene 1 Tisch */
     shift = s->cluster_bits + s->l2_bits;
     if (header.size > UINT64_MAX - (1LL << shift)) {
         error_setg(errp, "Image too large");
@@ -211,7 +211,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
         be64_to_cpus(&s->l1_table[i]);
     }
 
-    /* alloc L2 cache (max. 64k * 16 * 8 = 8 MB) */
+    /* alloc L2-Cache (max. 64 k * 16 * 8 = 8 MB) */
     s->l2_cache =
         qemu_try_blockalign(bs->file->bs,
                             s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
@@ -224,7 +224,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
     s->cluster_data = g_malloc(s->cluster_size);
     s->cluster_cache_offset = -1;
 
-    /* read the backing file name */
+    /* Lesen Sie die Unterstützung Dateinamen */
     if (header.backing_file_offset != 0) {
         len = header.backing_file_size;
         if (len > 1023 || len >= sizeof(bs->backing_file)) {
@@ -240,7 +240,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
         bs->backing_file[len] = '\0';
     }
 
-    /* Disable migration when qcow images are used */
+    /* Deaktivieren Sie die Migration, wenn qcow Bilder verwendet werden */
     error_setg(&s->migration_blocker, "The qcow format used by node '%s' "
                "does not support live migration",
                bdrv_get_device_or_node_name(bs));
@@ -258,8 +258,8 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
 }
 
 
-/* We have nothing to do for QCOW reopen, stubs just return
- * success */
+/* Wir haben nichts für qcow wieder öffnen zu tun, Stubs nur zurückkehren
+ * Erfolg */
 static int qcow_reopen_prepare(BDRVReopenState *state,
                                BlockReopenQueue *queue, Error **errp)
 {
@@ -277,8 +277,8 @@ static int qcow_set_key(BlockDriverState *bs, const char *key)
     len = strlen(key);
     if (len > 16)
         len = 16;
-    /* XXX: we could compress the chars to 7 bits to increase
-       entropy */
+    /* XXX: wir konnten die Zeichen auf 7 Bit komprimieren zu erhöhen
+       Entropie */
     for(i = 0;i < len;i++) {
         keybuf[i] = key[i];
     }
@@ -292,18 +292,18 @@ static int qcow_set_key(BlockDriverState *bs, const char *key)
         &err);
 
     if (!s->cipher) {
-        /* XXX would be nice if errors in this method could
-         * be properly propagate to the caller. Would need
-         * the bdrv_set_key() API signature to be fixed. */
+        /* XXX wäre schön, wenn Fehler in diesem Verfahren könnte
+         * werden richtig an den Aufrufer propagieren. Würde brauchen
+         * die bdrv_set_key () API Signatur festgelegt werden. */
         error_free(err);
         return -1;
     }
     return 0;
 }
 
-/* The crypt function is compatible with the linux cryptoloop
-   algorithm for < 4 GB images. NOTE: out_buf == in_buf is
-   supported */
+/* Die Krypta Funktion ist kompatibel mit dem Linux cryptoloop
+   Algorithmus für <4 GB Bilder. HINWEIS: out_buf == in_buf ist
+   unterstützt */
 static int encrypt_sectors(BDRVQcowState *s, int64_t sector_num,
                            uint8_t *out_buf, const uint8_t *in_buf,
                            int nb_sectors, bool enc, Error **errp)
@@ -346,18 +346,18 @@ static int encrypt_sectors(BDRVQcowState *s, int64_t sector_num,
     return 0;
 }
 
-/* 'allocate' is:
+/* 'Zuteilen' ist:
  *
- * 0 to not allocate.
+ * 0 bis nicht zuordnen.
  *
- * 1 to allocate a normal cluster (for sector indexes 'n_start' to
- * 'n_end')
+ * 1 einen normalen Cluster (für Sektorindizes 'n_start' zuzuweisen,
+ * 'N_end')
  *
- * 2 to allocate a compressed cluster of size
- * 'compressed_size'. 'compressed_size' must be > 0 and <
- * cluster_size
+ * 2 eine komprimierte Cluster von Größe zuzuweisen
+ * 'Compressed_size'. 'Compressed_size' muss> 0 und <
+ * Clustergröße
  *
- * return 0 if not allocated.
+ * 0 zurück, wenn nicht zugeordnet.
  */
 static uint64_t get_cluster_offset(BlockDriverState *bs,
                                    uint64_t offset, int allocate,
@@ -376,11 +376,11 @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
     if (!l2_offset) {
         if (!allocate)
             return 0;
-        /* allocate a new l2 entry */
+        /* einen neuen l2 Eintrag zuweisen */
         l2_offset = bdrv_getlength(bs->file->bs);
-        /* round to cluster size */
+        /* Runde Clustergröße */
         l2_offset = (l2_offset + s->cluster_size - 1) & ~(s->cluster_size - 1);
-        /* update the L1 entry */
+        /* Aktualisierung der L1-Eintrag */
         s->l1_table[l1_index] = l2_offset;
         tmp = cpu_to_be64(l2_offset);
         if (bdrv_pwrite_sync(bs->file->bs,
@@ -391,7 +391,7 @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
     }
     for(i = 0; i < L2_CACHE_SIZE; i++) {
         if (l2_offset == s->l2_cache_offsets[i]) {
-            /* increment the hit count */
+            /* erhöhe den Trefferanzahl */
             if (++s->l2_cache_counts[i] == 0xffffffff) {
                 for(j = 0; j < L2_CACHE_SIZE; j++) {
                     s->l2_cache_counts[j] >>= 1;
@@ -401,7 +401,8 @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
             goto found;
         }
     }
-    /* not found: load a new entry in the least used one */
+    /* nicht gefunden: in der am wenigsten genutzte man einen neuen Eintrag
+     * laden */
     min_index = 0;
     min_count = 0xffffffff;
     for(i = 0; i < L2_CACHE_SIZE; i++) {
@@ -431,18 +432,18 @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
         ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {
         if (!allocate)
             return 0;
-        /* allocate a new cluster */
+        /* weisen Sie einen neuen Cluster */
         if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
             (n_end - n_start) < s->cluster_sectors) {
-            /* if the cluster is already compressed, we must
-               decompress it in the case it is not completely
-               overwritten */
+            /* wenn der Cluster bereits komprimiert ist, müssen wir
+               Dekomprimieren es in dem Fall ist es nicht völlig
+               überschrieben */
             if (decompress_cluster(bs, cluster_offset) < 0)
                 return 0;
             cluster_offset = bdrv_getlength(bs->file->bs);
             cluster_offset = (cluster_offset + s->cluster_size - 1) &
                 ~(s->cluster_size - 1);
-            /* write the cluster content */
+            /* Schreiben Sie den Cluster-Gehalt */
             if (bdrv_pwrite(bs->file->bs, cluster_offset, s->cluster_cache,
                             s->cluster_size) !=
                 s->cluster_size)
@@ -450,12 +451,12 @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
         } else {
             cluster_offset = bdrv_getlength(bs->file->bs);
             if (allocate == 1) {
-                /* round to cluster size */
+                /* Runde Clustergröße */
                 cluster_offset = (cluster_offset + s->cluster_size - 1) &
                     ~(s->cluster_size - 1);
                 bdrv_truncate(bs->file->bs, cluster_offset + s->cluster_size);
-                /* if encrypted, we must initialize the cluster
-                   content which won't be written */
+                /* wenn diese verschlüsselt sind, müssen wir die Cluster
+                   initialisieren Inhalte, die nicht geschrieben werden */
                 if (bs->encrypted &&
                     (n_end - n_start) < s->cluster_sectors) {
                     uint64_t start_sect;
@@ -485,7 +486,7 @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
                     (uint64_t)compressed_size << (63 - s->cluster_bits);
             }
         }
-        /* update L2 table */
+        /* Update L2 Tabelle */
         tmp = cpu_to_be64(cluster_offset);
         l2_table[l2_index] = tmp;
         if (bdrv_pwrite_sync(bs->file->bs, l2_offset + l2_index * sizeof(tmp),
@@ -596,7 +597,7 @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
     qemu_co_mutex_lock(&s->lock);
 
     while (nb_sectors != 0) {
-        /* prepare next request */
+        /* Vorbereitung nächste Anfrage */
         cluster_offset = get_cluster_offset(bs, sector_num << 9,
                                                  0, 0, 0, 0);
         index_in_cluster = sector_num & (s->cluster_sectors - 1);
@@ -607,7 +608,7 @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
 
         if (!cluster_offset) {
             if (bs->backing) {
-                /* read from the base image */
+                /* lesen aus dem Basisbild */
                 hd_iov.iov_base = (void *)buf;
                 hd_iov.iov_len = n * 512;
                 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
@@ -619,11 +620,11 @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
                     goto fail;
                 }
             } else {
-                /* Note: in this case, no need to wait */
+                /* Hinweis: in diesem Fall keine Notwendigkeit, warten */
                 memset(buf, 0, 512 * n);
             }
         } else if (cluster_offset & QCOW_OFLAG_COMPRESSED) {
-            /* add AIO support for compressed blocks ? */
+            /* hinzufügen AIO Unterstützung für komprimierte Blöcke? */
             if (decompress_cluster(bs, cluster_offset) < 0) {
                 goto fail;
             }
@@ -689,7 +690,7 @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
     uint8_t *buf;
     void *orig_buf;
 
-    s->cluster_cache_offset = -1; /* disable compressed cache */
+    s->cluster_cache_offset = -1; /* deaktivieren komprimierten Cache */
 
     if (qiov->niov > 1) {
         buf = orig_buf = qemu_try_blockalign(bs, qiov->size);
@@ -789,7 +790,7 @@ static int qcow_create(const char *filename, QemuOpts *opts, Error **errp)
     int ret;
     BlockBackend *qcow_blk;
 
-    /* Read out options */
+    /* Vorlesen Optionen */
     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
                           BDRV_SECTOR_SIZE);
     backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
@@ -831,15 +832,15 @@ static int qcow_create(const char *filename, QemuOpts *opts, Error **errp)
             header.backing_file_size = cpu_to_be32(backing_filename_len);
             header_size += backing_filename_len;
         } else {
-            /* special backing file for vvfat */
+            /* Spezial-Trägerdatei für vvfat */
             backing_file = NULL;
         }
-        header.cluster_bits = 9; /* 512 byte cluster to avoid copying
-                                    unmodified sectors */
-        header.l2_bits = 12; /* 32 KB L2 tables */
+        header.cluster_bits = 9; /* 512-Byte-Cluster Kopieren zu vermeiden
+                                    unmodifizierten Sektoren */
+        header.l2_bits = 12; /* 32 KB L2-Tabellen */
     } else {
-        header.cluster_bits = 12; /* 4 KB clusters */
-        header.l2_bits = 9; /* 4 KB L2 tables */
+        header.cluster_bits = 12; /* 4 KB Cluster */
+        header.l2_bits = 9; /* 4 KB L2-Tabellen */
     }
     header_size = (header_size + 7) & ~7;
     shift = header.cluster_bits + header.l2_bits;
@@ -852,7 +853,7 @@ static int qcow_create(const char *filename, QemuOpts *opts, Error **errp)
         header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
     }
 
-    /* write all the data */
+    /* Schreiben Sie alle Daten */
     ret = blk_pwrite(qcow_blk, 0, &header, sizeof(header));
     if (ret != sizeof(header)) {
         goto exit;
@@ -907,8 +908,8 @@ static int qcow_make_empty(BlockDriverState *bs)
     return 0;
 }
 
-/* XXX: put compressed sectors first, then all the cluster aligned
-   tables to avoid losing bytes in alignment */
+/* XXX: Put-Druck Sektoren zuerst, dann das ganze Cluster ausgerichtet
+   Tabellen zu vermeiden Bytes in Ausrichtung zu verlieren */
 static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num,
                                  const uint8_t *buf, int nb_sectors)
 {
@@ -921,7 +922,8 @@ static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num,
     if (nb_sectors != s->cluster_sectors) {
         ret = -EINVAL;
 
-        /* Zero-pad last write if image size is not cluster aligned */
+        /* Null-Pad letzte Schreib, wenn die Bildgröße ist nicht ausgerichtet
+         * Cluster */
         if (sector_num + nb_sectors == bs->total_sectors &&
             nb_sectors < s->cluster_sectors) {
             uint8_t *pad_buf = qemu_blockalign(bs, s->cluster_size);
@@ -936,7 +938,7 @@ static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num,
 
     out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
 
-    /* best compression, small window, no zlib header */
+    /* beste Kompression, kleine Fenster, keine zlib-Header */
     memset(&strm, 0, sizeof(strm));
     ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
                        Z_DEFLATED, -12,
@@ -962,7 +964,7 @@ static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num,
     deflateEnd(&strm);
 
     if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
-        /* could not compress: write normal cluster */
+        /* komprimieren konnte nicht: Schreiben normalen Cluster */
         ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors);
         if (ret < 0) {
             goto fail;
@@ -1015,7 +1017,7 @@ static QemuOptsList qcow_create_opts = {
             .help = "Encrypt the image",
             .def_value_str = "off"
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     }
 };
 
diff --git a/block/qcow2-cache.c b/block/qcow2-cache.c
index 0fe8eda..937f458 100644
--- a/block/qcow2-cache.c
+++ b/block/qcow2-cache.c
@@ -22,7 +22,7 @@
  * THE SOFTWARE.
  */
 
-/* Needed for CONFIG_MADVISE */
+/* Erforderlich für CONFIG_MADVISE */
 #include "qemu/osdep.h"
 
 #if defined(CONFIG_MADVISE) || defined(CONFIG_POSIX_MADVISE)
@@ -97,12 +97,13 @@ void qcow2_cache_clean_unused(BlockDriverState *bs, Qcow2Cache *c)
     while (i < c->size) {
         int to_clean = 0;
 
-        /* Skip the entries that we don't need to clean */
+        /* Überspringen Sie die Einträge, die wir nicht brauchen, zu reinigen
+         */
         while (i < c->size && !can_clean_entry(c, i)) {
             i++;
         }
 
-        /* And count how many we can clean in a row */
+        /* Und zählen, wie viele wir in einer Reihe reinigen */
         while (i < c->size && can_clean_entry(c, i)) {
             c->entries[i].offset = 0;
             c->entries[i].lru_counter = 0;
@@ -315,7 +316,7 @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
     trace_qcow2_cache_get(qemu_coroutine_self(), c == s->l2_table_cache,
                           offset, read_from_disk);
 
-    /* Check if the table is already cached */
+    /* Überprüfen Sie, ob die Tabelle bereits zwischengespeichert wird */
     i = lookup_index = (offset / s->cluster_size * 4) % c->size;
     do {
         const Qcow2CachedTable *t = &c->entries[i];
@@ -332,12 +333,13 @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
     } while (i != lookup_index);
 
     if (min_lru_index == -1) {
-        /* This can't happen in current synchronous code, but leave the check
-         * here as a reminder for whoever starts using AIO with the cache */
+        /* Dies kann nicht im laufenden Synchroncode passieren, aber lassen Sie
+         * das Kontroll hier als Erinnerung für jeden, beginnt AIO mit dem
+         * Cache-Verwendung */
         abort();
     }
 
-    /* Cache miss: write a table back and replace it */
+    /* Cache-Miss: Schreiben Sie eine Tabelle zurück und ersetzen Sie es */
     i = min_lru_index;
     trace_qcow2_cache_get_replace_entry(qemu_coroutine_self(),
                                         c == s->l2_table_cache, i);
@@ -365,7 +367,7 @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
 
     c->entries[i].offset = offset;
 
-    /* And return the right table */
+    /* Und kehren die richtige Tabelle */
 found:
     c->entries[i].ref++;
     *table = qcow2_cache_get_table_addr(bs, c, i);
diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index 31ecc10..94c3c8c 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -44,9 +44,9 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
     if (min_size <= s->l1_size)
         return 0;
 
-    /* Do a sanity check on min_size before trying to calculate new_l1_size
-     * (this prevents overflows during the while loop for the calculation of
-     * new_l1_size) */
+    /* Führen Sie eine Plausibilitätsprüfung auf min_size, bevor Sie
+     * versuchen new_l1_size zu berechnen (Dies verhindert Überlauf während
+     * der while-Schleife für die Berechnung von new_l1_size) */
     if (min_size > INT_MAX / sizeof(uint64_t)) {
         return -EFBIG;
     }
@@ -54,7 +54,8 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
     if (exact_size) {
         new_l1_size = min_size;
     } else {
-        /* Bump size up to reduce the number of times we have to grow */
+        /* Bump Größe bis zu der Anzahl der Male reduzieren wir müssen
+         * wachsen */
         new_l1_size = s->l1_size;
         if (new_l1_size == 0) {
             new_l1_size = 1;
@@ -83,7 +84,7 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
 
     memcpy(new_l1_table, s->l1_table, s->l1_size * sizeof(uint64_t));
 
-    /* write new table (align to cluster) */
+    /* schreiben neue Tabelle (ausrichten zu Cluster) */
     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ALLOC_TABLE);
     new_l1_table_offset = qcow2_alloc_clusters(bs, new_l1_size2);
     if (new_l1_table_offset < 0) {
@@ -96,8 +97,8 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
         goto fail;
     }
 
-    /* the L1 position has not yet been updated, so these clusters must
-     * indeed be completely free */
+    /* die L1-Position wurde noch nicht aktualisiert, so dass diese Cluster
+     * müssen sein in der Tat völlig frei */
     ret = qcow2_pre_write_overlap_check(bs, 0, new_l1_table_offset,
                                         new_l1_size2);
     if (ret < 0) {
@@ -114,7 +115,7 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
     for(i = 0; i < s->l1_size; i++)
         new_l1_table[i] = be64_to_cpu(new_l1_table[i]);
 
-    /* set new table */
+    /* set neue Tabelle */
     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE);
     cpu_to_be32w((uint32_t*)data, new_l1_size);
     stq_be_p(data + 4, new_l1_table_offset);
@@ -142,11 +143,12 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
 /*
  * l2_load
  *
- * Loads a L2 table into memory. If the table is in the cache, the cache
- * is used; otherwise the L2 table is loaded from the image file.
+ * Lädt eine L2-Tabelle in den Speicher. Wenn die Tabelle in dem Cache, der
+ * Cache wird eingesetzt; ansonsten wird der L2-Tabelle aus der Bilddatei
+ * geladen.
  *
- * Returns a pointer to the L2 table on success, or NULL if the read from
- * the image file failed.
+ * Gibt einen Zeiger auf den L2-Tabelle auf Erfolg oder NULL, wenn das Lesen von
+ * die Bilddatei ist fehlgeschlagen.
  */
 
 static int l2_load(BlockDriverState *bs, uint64_t l2_offset,
@@ -161,8 +163,9 @@ static int l2_load(BlockDriverState *bs, uint64_t l2_offset,
 }
 
 /*
- * Writes one sector of the L1 table to the disk (can't update single entries
- * and we really don't want bdrv_pread to perform a read-modify-write)
+ * Schreibt ein Sektor der L1-Tabelle auf die Festplatte (nicht aktualisieren
+ * einzelne Einträge und wir wollen wirklich bdrv_pread keine
+ * Lese-Modifizieren-Schreiben durchzuführen)
  */
 #define L1_ENTRIES_PER_SECTOR (512 / 8)
 int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)
@@ -199,10 +202,11 @@ int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)
 /*
  * l2_allocate
  *
- * Allocate a new l2 entry in the file. If l1_index points to an already
- * used entry in the L2 table (i.e. we are doing a copy on write for the L2
- * table) copy the contents of the old L2 table into the newly allocated one.
- * Otherwise the new table is initialized with zeros.
+ * Vergeben Sie einen neuen l2 Eintrag in der Datei. Wenn l1_index Punkte zu
+ * einem bereits gebrauchte Eintrag in der L2-Tabelle (das heißt wir tun eine
+ * Kopie auf Schreib für den L2 Tabelle), den Inhalt der alten L2 Tabelle in
+ * den neu zugewiesenen kopieren. Andernfalls die neue Tabelle wird mit Nullen
+ * initialisiert.
  *
  */
 
@@ -218,7 +222,7 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
 
     trace_qcow2_l2_allocate(bs, l1_index);
 
-    /* allocate a new l2 entry */
+    /* einen neuen l2 Eintrag zuweisen */
 
     l2_offset = qcow2_alloc_clusters(bs, s->l2_size * sizeof(uint64_t));
     if (l2_offset < 0) {
@@ -231,7 +235,7 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
         goto fail;
     }
 
-    /* allocate a new entry in the l2 cache */
+    /* einen neuen Eintrag in der L2-Cache zuteilen */
 
     trace_qcow2_l2_allocate_get_empty(bs, l1_index);
     ret = qcow2_cache_get_empty(bs, s->l2_table_cache, l2_offset, (void**) table);
@@ -242,12 +246,13 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
     l2_table = *table;
 
     if ((old_l2_offset & L1E_OFFSET_MASK) == 0) {
-        /* if there was no old l2 table, clear the new table */
+        /* wenn es keine alten l2 Tisch war, deaktivieren Sie die neue Tabelle
+         */
         memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
     } else {
         uint64_t* old_table;
 
-        /* if there was an old l2 table, read it from the disk */
+        /* wenn es ein alter l2 Tisch war, las er von der Platte */
         BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_COW_READ);
         ret = qcow2_cache_get(bs, s->l2_table_cache,
             old_l2_offset & L1E_OFFSET_MASK,
@@ -261,7 +266,7 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
         qcow2_cache_put(bs, s->l2_table_cache, (void **) &old_table);
     }
 
-    /* write the l2 table to the file */
+    /* Der L2-Tabelle in die Datei schreiben */
     BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_WRITE);
 
     trace_qcow2_l2_allocate_write_l2(bs, l1_index);
@@ -271,7 +276,7 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
         goto fail;
     }
 
-    /* update the L1 entry */
+    /* Aktualisierung der L1-Eintrag */
     trace_qcow2_l2_allocate_write_l1(bs, l1_index);
     s->l1_table[l1_index] = l2_offset | QCOW_OFLAG_COPIED;
     ret = qcow2_write_l1_entry(bs, l1_index);
@@ -297,11 +302,12 @@ fail:
 }
 
 /*
- * Checks how many clusters in a given L2 table are contiguous in the image
- * file. As soon as one of the flags in the bitmask stop_flags changes compared
- * to the first cluster, the search is stopped and the cluster is not counted
- * as contiguous. (This allows it, for example, to stop at the first compressed
- * cluster which may require a different handling)
+ * Prüft, wie viele Cluster in einem bestimmten L2 Tabelle im Bild
+ * aneinandergrenzen Datei. Sobald eine der Fahnen in der Bitmaske stop_flags
+ * Änderungen im Vergleich zu dem ersten Cluster, wird die Suche gestoppt und
+ * der Cluster nicht gezählt als zusammenhängend. (Dies ermöglicht es,
+ * beispielsweise bei der ersten zu stoppen komprimiert Cluster, die eine
+ * unterschiedliche Behandlung erfordern kann)
  */
 static int count_contiguous_clusters(int nb_clusters, int cluster_size,
         uint64_t *l2_table, uint64_t stop_flags)
@@ -343,9 +349,9 @@ static int count_contiguous_clusters_by_type(int nb_clusters,
     return i;
 }
 
-/* The crypt function is compatible with the linux cryptoloop
-   algorithm for < 4 GB images. NOTE: out_buf == in_buf is
-   supported */
+/* Die Krypta Funktion ist kompatibel mit dem Linux cryptoloop
+   Algorithmus für <4 GB Bilder. HINWEIS: out_buf == in_buf ist
+   unterstützt */
 int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num,
                           uint8_t *out_buf, const uint8_t *in_buf,
                           int nb_sectors, bool enc,
@@ -419,9 +425,10 @@ static int coroutine_fn copy_sectors(BlockDriverState *bs,
         goto out;
     }
 
-    /* Call .bdrv_co_readv() directly instead of using the public block-layer
-     * interface.  This avoids double I/O throttling and request tracking,
-     * which can lead to deadlock when block layer copy-on-read is enabled.
+    /* Rufen Sie .bdrv_co_readv () direkt anstelle der Verwendung der
+     * öffentlichen Block-Schicht Schnittstelle. Dies vermeidet doppelte
+     * E / A-Drosselung und Anforderungsverfolgung, das kann zu einem Deadlock
+     * führen, wenn Block-Layer Copy-on-Lesen aktiviert ist.
      */
     ret = bs->drv->bdrv_co_readv(bs, start_sect + n_start, n, &qiov);
     if (ret < 0) {
@@ -463,16 +470,17 @@ out:
 /*
  * get_cluster_offset
  *
- * For a given offset of the disk image, find the cluster offset in
- * qcow2 file. The offset is stored in *cluster_offset.
+ * Für eine der Disk-Image angegebenen Offset, finden Sie den Cluster-Offset in
+ * qcow2 Datei. Der Offset wird in * cluster_offset gespeichert.
  *
- * on entry, *num is the number of contiguous sectors we'd like to
- * access following offset.
+ * über den Eintritt ist * num die Anzahl der zusammenhängenden Sektoren
+ * würden wir gerne Zugang Offset folgen.
  *
- * on exit, *num is the number of contiguous sectors we can read.
+ * an der Ausfahrt ist * num die Anzahl der zusammenhängenden Sektoren wir
+ * lesen können.
  *
- * Returns the cluster type (QCOW2_CLUSTER_*) on success, -errno in error
- * cases.
+ * Gibt den Cluster-Typ (QCOW2_CLUSTER_ *) auf Erfolg, -errno in Fehler
+ * Fälle.
  */
 int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
     int *num, uint64_t *cluster_offset)
@@ -490,13 +498,13 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
 
     l1_bits = s->l2_bits + s->cluster_bits;
 
-    /* compute how many bytes there are between the offset and
-     * the end of the l1 entry
+    /* berechnen, wie viele Bytes zwischen dem Offset sind, und
+     * das Ende des l1 Eintritts
      */
 
     nb_available = (1ULL << l1_bits) - (offset & ((1ULL << l1_bits) - 1));
 
-    /* compute the number of available sectors */
+    /* berechnen die Anzahl der verfügbaren Sektoren */
 
     nb_available = (nb_available >> 9) + index_in_cluster;
 
@@ -507,7 +515,7 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
 
     *cluster_offset = 0;
 
-    /* seek to the l2 offset in the l1 table */
+    /* zum l2 suchen in der l1 Tabellenoffset */
 
     l1_index = offset >> l1_bits;
     if (l1_index >= s->l1_size) {
@@ -528,25 +536,25 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
         return -EIO;
     }
 
-    /* load the l2 table in memory */
+    /* laden Sie die l2 Tabelle im Speicher */
 
     ret = l2_load(bs, l2_offset, &l2_table);
     if (ret < 0) {
         return ret;
     }
 
-    /* find the cluster offset for the given disk offset */
+    /* finden Sie den Cluster für die gegebene Platte Offset */
 
     l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
     *cluster_offset = be64_to_cpu(l2_table[l2_index]);
 
-    /* nb_needed <= INT_MAX, thus nb_clusters <= INT_MAX, too */
+    /* nb_needed <= INT_MAX, so nb_clusters <= INT_MAX auch */
     nb_clusters = size_to_clusters(s, nb_needed << 9);
 
     ret = qcow2_get_cluster_type(*cluster_offset);
     switch (ret) {
     case QCOW2_CLUSTER_COMPRESSED:
-        /* Compressed clusters can only be processed one by one */
+        /* Komprimierte Cluster können nur einzeln verarbeitet werden, */
         c = 1;
         *cluster_offset &= L2E_COMPRESSED_OFFSET_SIZE_MASK;
         break;
@@ -563,13 +571,13 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
         *cluster_offset = 0;
         break;
     case QCOW2_CLUSTER_UNALLOCATED:
-        /* how many empty clusters ? */
+        /* wie viele leere Cluster? */
         c = count_contiguous_clusters_by_type(nb_clusters, &l2_table[l2_index],
                                               QCOW2_CLUSTER_UNALLOCATED);
         *cluster_offset = 0;
         break;
     case QCOW2_CLUSTER_NORMAL:
-        /* how many allocated clusters ? */
+        /* wie viele Cluster zugewiesen? */
         c = count_contiguous_clusters(nb_clusters, s->cluster_size,
                 &l2_table[l2_index], QCOW_OFLAG_ZERO);
         *cluster_offset &= L2E_OFFSET_MASK;
@@ -606,13 +614,13 @@ fail:
 /*
  * get_cluster_table
  *
- * for a given disk offset, load (and allocate if needed)
- * the l2 table.
+ * für eine bestimmte Platte versetzt, Last (und zuzuweisen, wenn erforderlich)
+ * die l2 Tisch.
  *
- * the l2 table offset in the qcow2 file and the cluster index
- * in the l2 table are given to the caller.
+ * die l2-Tabelle in der qcow2-Datei und der Cluster-Index-Offset
+ * in der L2-Tabelle an den Anrufer gegeben.
  *
- * Returns 0 on success, -errno in failure case
+ * Gibt 0 zurück, bei Erfolg, -errno im Fehlerfall
  */
 static int get_cluster_table(BlockDriverState *bs, uint64_t offset,
                              uint64_t **new_l2_table,
@@ -624,7 +632,7 @@ static int get_cluster_table(BlockDriverState *bs, uint64_t offset,
     uint64_t *l2_table = NULL;
     int ret;
 
-    /* seek to the l2 offset in the l1 table */
+    /* zum l2 suchen in der l1 Tabellenoffset */
 
     l1_index = offset >> (s->l2_bits + s->cluster_bits);
     if (l1_index >= s->l1_size) {
@@ -643,29 +651,30 @@ static int get_cluster_table(BlockDriverState *bs, uint64_t offset,
         return -EIO;
     }
 
-    /* seek the l2 table of the given l2 offset */
+    /* Der L2-Tabelle des gegebenen l2 suchen Offset */
 
     if (s->l1_table[l1_index] & QCOW_OFLAG_COPIED) {
-        /* load the l2 table in memory */
+        /* laden Sie die l2 Tabelle im Speicher */
         ret = l2_load(bs, l2_offset, &l2_table);
         if (ret < 0) {
             return ret;
         }
     } else {
-        /* First allocate a new L2 table (and do COW if needed) */
+        /* Zuerst weisen Sie einen neuen L2-Tabelle (und KUH tun, wenn
+         * erforderlich) */
         ret = l2_allocate(bs, l1_index, &l2_table);
         if (ret < 0) {
             return ret;
         }
 
-        /* Then decrease the refcount of the old table */
+        /* Dann sinken die refcount der alten Tabelle */
         if (l2_offset) {
             qcow2_free_clusters(bs, l2_offset, s->l2_size * sizeof(uint64_t),
                                 QCOW2_DISCARD_OTHER);
         }
     }
 
-    /* find the cluster offset for the given disk offset */
+    /* finden Sie den Cluster für die gegebene Platte Offset */
 
     l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
 
@@ -678,13 +687,14 @@ static int get_cluster_table(BlockDriverState *bs, uint64_t offset,
 /*
  * alloc_compressed_cluster_offset
  *
- * For a given offset of the disk image, return cluster offset in
- * qcow2 file.
+ * Für eine der Disk-Image angegebenen Offset, Rück Cluster versetzt
+ * qcow2 Datei.
  *
- * If the offset is not found, allocate a new compressed cluster.
+ * Wenn der Offset nicht gefunden wird, einen neuen komprimierten Cluster
+ * zuordnen.
  *
- * Return the cluster offset if successful,
- * Return 0, otherwise.
+ * Bringen Sie den Cluster-Offset, falls erfolgreich,
+ * Return 0, sonst.
  *
  */
 
@@ -703,8 +713,8 @@ uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
         return 0;
     }
 
-    /* Compression can't overwrite anything. Fail if the cluster was already
-     * allocated. */
+    /* Die Komprimierung kann nichts überschreiben. Fehlschlagen, wenn der
+     * Cluster bereits war zugeordnet. */
     cluster_offset = be64_to_cpu(l2_table[l2_index]);
     if (cluster_offset & L2E_OFFSET_MASK) {
         qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
@@ -723,9 +733,9 @@ uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
     cluster_offset |= QCOW_OFLAG_COMPRESSED |
                       ((uint64_t)nb_csectors << s->csize_shift);
 
-    /* update L2 table */
+    /* Update L2 Tabelle */
 
-    /* compressed clusters never have the copied flag */
+    /* komprimierte Cluster haben nie die kopierte Flagge */
 
     BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
     qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table);
@@ -755,9 +765,9 @@ static int perform_cow(BlockDriverState *bs, QCowL2Meta *m, Qcow2COWRegion *r)
     }
 
     /*
-     * Before we update the L2 table to actually point to the new cluster, we
-     * need to be sure that the refcounts have been increased and COW was
-     * handled.
+     * Bevor wir die L2-Tabelle aktualisieren, um Punkt tatsächlich auf den
+     * neuen Cluster, wir müssen sicher sein, dass die Refcounts wurden erhöht
+     * und COW war abgewickelt.
      */
     qcow2_cache_depends_on_flush(s->l2_table_cache);
 
@@ -780,7 +790,7 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)
         goto err;
     }
 
-    /* copy content of unmodified sectors */
+    /* Kopie Inhalt von unmodifizierten Sektoren */
     ret = perform_cow(bs, m, &m->cow_start);
     if (ret < 0) {
         goto err;
@@ -791,7 +801,7 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)
         goto err;
     }
 
-    /* Update L2 table. */
+    /* Update-L2-Tabelle. */
     if (s->use_lazy_refcounts) {
         qcow2_mark_dirty(bs);
     }
@@ -808,12 +818,13 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)
 
     assert(l2_index + m->nb_clusters <= s->l2_size);
     for (i = 0; i < m->nb_clusters; i++) {
-        /* if two concurrent writes happen to the same unallocated cluster
-	 * each write allocates separate cluster and writes data concurrently.
-	 * The first one to complete updates l2 table with pointer to its
-	 * cluster the second one has to do RMW (which is done above by
-	 * copy_sectors()), update l2 table with its cluster pointer and free
-	 * old cluster. This is what this loop does */
+        /* wenn zwei gleichzeitige Schreiben passieren zu demselben nicht
+         * zugewiesenen Cluster Jeder Schreib ordnet separaten Cluster und
+         * schreibt gleichzeitig Daten.
+         * Die erste mit Zeiger-Updates l2 Tabelle zu vervollständigen, um
+         * seine Cluster die zweite hat RMW zu tun (die von oben gemacht wird
+         * Copy_sectors ()), aktualisieren l2 Tabelle mit seiner Cluster-Pointer
+         * und kostenlos Alten Cluster. Dies ist, was diese Schleife tut */
         if(l2_table[l2_index + i] != 0)
             old_cluster[j++] = l2_table[l2_index + i];
 
@@ -825,10 +836,12 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)
     qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
 
     /*
-     * If this was a COW, we need to decrease the refcount of the old cluster.
+     * Wenn dies eine Kuh war, müssen wir die refcount des alten Cluster zu
+     * verringern.
      *
-     * Don't discard clusters that reach a refcount of 0 (e.g. compressed
-     * clusters), the next write will reuse them anyway.
+     * verwerfen Sie nicht Cluster, die eine refcount von 0 (z erreichen
+     * komprimiert Cluster), wird die nächste Schreib sie trotzdem
+     * wiederverwenden.
      */
     if (j != 0) {
         for (i = 0; i < j; i++) {
@@ -844,9 +857,10 @@ err:
  }
 
 /*
- * Returns the number of contiguous clusters that can be used for an allocating
- * write, but require COW to be performed (this includes yet unallocated space,
- * which must copy from the backing file)
+ * Gibt die Anzahl der zusammenhängenden Clustern, die für eine Aufteilung
+ * genutzt werden können schreiben, aber erfordern KUH durchgeführt werden
+ * (dies noch nicht zugeordneten Speicherplatz umfasst, die sich aus der
+ * Trägerdatei kopieren muss)
  */
 static int count_cow_clusters(BDRVQcow2State *s, int nb_clusters,
     uint64_t *l2_table, int l2_index)
@@ -878,18 +892,21 @@ out:
 }
 
 /*
- * Check if there already is an AIO write request in flight which allocates
- * the same cluster. In this case we need to wait until the previous
- * request has completed and updated the L2 table accordingly.
+ * Überprüfen Sie, ob es bereits eine AIO Schreibanforderung im Flug ist die
+ * zuordnet die gleichen Cluster. In diesem Fall müssen wir bis zum
+ * vorherigen warten Anforderung abgeschlossen und die L2-Tabelle entsprechend
+ * aktualisiert.
  *
- * Returns:
- *   0       if there was no dependency. *cur_bytes indicates the number of
- *           bytes from guest_offset that can be read before the next
- *           dependency must be processed (or the request is complete)
+ * Kehrt zurück:
+ *   0, wenn es keine Abhängigkeit. * Cur_bytes gibt die Anzahl der
+ *           Bytes von guest_offset die vor der nächsten gelesen werden kann,
+ *           Abhängigkeit verarbeitet werden müssen (oder die Anforderung
+ *           abgeschlossen ist)
  *
- *   -EAGAIN if we had to wait for another request, previously gathered
- *           information on cluster allocation may be invalid now. The caller
- *           must start over anyway, so consider *cur_bytes undefined.
+ *   -EAGAIN, Wenn wir für eine andere Anforderung warten mussten, die zuvor
+ *            gesammelt Informationen über Cluster Zuordnung kann nun
+ *            ungültig. Der Anrufer von vorn beginnen müssen sowieso, also
+ *            betrachten *cur_bytes undefiniert.
  */
 static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,
     uint64_t *cur_bytes, QCowL2Meta **m)
@@ -906,27 +923,29 @@ static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,
         uint64_t old_end = l2meta_cow_end(old_alloc);
 
         if (end <= old_start || start >= old_end) {
-            /* No intersection */
+            /* keinen Schnittpunkt */
         } else {
             if (start < old_start) {
-                /* Stop at the start of a running allocation */
+                /* Stoppen Sie zu Beginn eines laufenden Zuteilungs */
                 bytes = old_start - start;
             } else {
                 bytes = 0;
             }
 
-            /* Stop if already an l2meta exists. After yielding, it wouldn't
-             * be valid any more, so we'd have to clean up the old L2Metas
-             * and deal with requests depending on them before starting to
-             * gather new ones. Not worth the trouble. */
+            /* Stoppen Sie, wenn bereits ein l2meta existiert. Nach dem
+             * Nachgeben, wäre es nicht Gültigkeit mehr, so würden wir die
+             * alten L2Metas aufräumen müssen und beschäftigen sich mit
+             * Anfragen je nach ihnen vor dem Start zu sammeln neue. Nicht
+             * der Mühe wert. */
             if (bytes == 0 && *m) {
                 *cur_bytes = 0;
                 return 0;
             }
 
             if (bytes == 0) {
-                /* Wait for the dependency to complete. We need to recheck
-                 * the free/allocated clusters when we continue. */
+                /* Warten Sie, die Abhängigkeit zu vervollständigen. Wir
+                 * müssen noch einmal zu überprüfen die freien / belegte
+                 * Cluster, wenn wir weiter. */
                 qemu_co_mutex_unlock(&s->lock);
                 qemu_co_queue_wait(&old_alloc->dependent_requests);
                 qemu_co_mutex_lock(&s->lock);
@@ -935,34 +954,36 @@ static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,
         }
     }
 
-    /* Make sure that existing clusters and new allocations are only used up to
-     * the next dependency if we shortened the request above */
+    /* Stellen Sie sicher, dass die bestehenden Cluster und neue Zuweisungen
+     * nur bis verwendet werden, um die nächste Abhängigkeit, wenn wir die
+     * Anfrage über verkürzt */
     *cur_bytes = bytes;
 
     return 0;
 }
 
 /*
- * Checks how many already allocated clusters that don't require a copy on
- * write there are at the given guest_offset (up to *bytes). If
- * *host_offset is not zero, only physically contiguous clusters beginning at
- * this host offset are counted.
+ * Prüft, wie viele bereits zugewiesenen Cluster, die nicht über eine
+ * Kopie benötigen auf schreiben gibt es bei der gegebenen guest_offset (bis zu
+ * *bytes). Ob *host_offset nicht Null ist, nur physikalisch zusammenhängenden
+ * Clustern auf Anfang Diesen Gastgeber versetzt sind gezählt.
  *
- * Note that guest_offset may not be cluster aligned. In this case, the
- * returned *host_offset points to exact byte referenced by guest_offset and
- * therefore isn't cluster aligned as well.
+ * Beachten Sie, dass guest_offset nicht Cluster ausgerichtet werden können. In
+ * diesem Fall ist die zurück *host_offset Punkte auf genaue Byte von
+ * guest_offset verwiesen und deshalb wird nicht als gut ausgerichtet Cluster.
  *
- * Returns:
- *   0:     if no allocated clusters are available at the given offset.
- *          *bytes is normally unchanged. It is set to 0 if the cluster
- *          is allocated and doesn't need COW, but doesn't have the right
- *          physical offset.
+ * Kehrt zurück:
+ *   0: wenn keine zugewiesenen Cluster sind unter den gegebenen Offset.
+ *          * Bytes ist in der Regel unverändert. Es wird auf 0 gesetzt, wenn
+ *          der Cluster zugeordnet ist und nicht COW brauchen, aber nicht das
+ *          Recht haben, physikalischen Offset.
  *
- *   1:     if allocated clusters that don't require a COW are available at
- *          the requested offset. *bytes may have decreased and describes
- *          the length of the area that can be written to.
+ *   1: wenn zugewiesen Cluster, die zur Verfügung stehen Sie nicht eine Kuh
+ *          erfordern bei die angeforderten versetzt. * Bytes verringert haben
+ *          kann und beschreibt die Länge der Fläche, die geschrieben werden
+ *          kann.
  *
- *  -errno: in error cases
+ *  -errno: im Fehlerfall
  */
 static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
     uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m)
@@ -982,8 +1003,8 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
                                 == offset_into_cluster(s, *host_offset));
 
     /*
-     * Calculate the number of clusters to look for. We stop at L2 table
-     * boundaries to keep things simple.
+     * Berechne die Anzahl der Cluster zu suchen. Wir halten an L2-Tabelle
+     * Grenzen Dinge einfach zu halten.
      */
     nb_clusters =
         size_to_clusters(s, offset_into_cluster(s, guest_offset) + *bytes);
@@ -992,7 +1013,7 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
     nb_clusters = MIN(nb_clusters, s->l2_size - l2_index);
     assert(nb_clusters <= INT_MAX);
 
-    /* Find L2 entry for the first involved cluster */
+    /* Finden L2-Eintrag für den ersten beteiligten Cluster */
     ret = get_cluster_table(bs, guest_offset, &l2_table, &l2_index);
     if (ret < 0) {
         return ret;
@@ -1000,11 +1021,12 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
 
     cluster_offset = be64_to_cpu(l2_table[l2_index]);
 
-    /* Check how many clusters are already allocated and don't need COW */
+    /* Überprüfen Sie, wie viele Cluster bereits zugeordnet sind und nicht COW
+     * brauchen */
     if (qcow2_get_cluster_type(cluster_offset) == QCOW2_CLUSTER_NORMAL
         && (cluster_offset & QCOW_OFLAG_COPIED))
     {
-        /* If a specific host_offset is required, check it */
+        /* Wenn eine bestimmte host_offset erforderlich ist, überprüfen */
         bool offset_matches =
             (cluster_offset & L2E_OFFSET_MASK) == *host_offset;
 
@@ -1023,7 +1045,7 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
             goto out;
         }
 
-        /* We keep all QCOW_OFLAG_COPIED clusters */
+        /* Wir halten alle QCOW_OFLAG_COPIED Cluster */
         keep_clusters =
             count_contiguous_clusters(nb_clusters, s->cluster_size,
                                       &l2_table[l2_index],
@@ -1039,12 +1061,13 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
         ret = 0;
     }
 
-    /* Cleanup */
+    /* Aufräumen */
 out:
     qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
 
-    /* Only return a host offset if we actually made progress. Otherwise we
-     * would make requirements for handle_alloc() that it can't fulfill */
+    /* Nur geben einen Host-Offset, wenn wir tatsächlich Fortschritte gemacht.
+     * Ansonsten wir machen Anforderungen für handle_alloc würde (), dass es
+     * nicht erfüllen kann */
     if (ret > 0) {
         *host_offset = (cluster_offset & L2E_OFFSET_MASK)
                      + offset_into_cluster(s, guest_offset);
@@ -1054,23 +1077,24 @@ out:
 }
 
 /*
- * Allocates new clusters for the given guest_offset.
+ * Ordnet neuen Cluster für die gegebene guest_offset.
  *
- * At most *nb_clusters are allocated, and on return *nb_clusters is updated to
- * contain the number of clusters that have been allocated and are contiguous
- * in the image file.
+ * Bei den meisten *nb_clusters zugeordnet sind, und bei der Rückkehr
+ * *nb_clusters wird aktualisiert enthalten, um die Anzahl von Clustern, die
+ * zugewiesen worden sind und zusammenhängende in der Bilddatei.
  *
- * If *host_offset is non-zero, it specifies the offset in the image file at
- * which the new clusters must start. *nb_clusters can be 0 on return in this
- * case if the cluster at host_offset is already in use. If *host_offset is
- * zero, the clusters can be allocated anywhere in the image file.
+ * Wenn *host_offset nicht Null ist, gibt es den Versatz in der Bilddatei an
+ * die die neuen Cluster beginnen. *nb_clusters kann 0 auf Rückkehr in das sein
+ * Fall, wenn der Cluster bei host_offset bereits im Einsatz ist. Wenn
+ * *host_offset ist Null ist, können die Cluster überall in der Bilddatei
+ * zugeordnet werden.
  *
- * *host_offset is updated to contain the offset into the image file at which
- * the first allocated cluster starts.
+ * *host_offset aktualisiert wird der Versatz in die Bilddatei zu enthalten, an
+ * denen der erste zugewiesen Cluster beginnt.
  *
- * Return 0 on success and -errno in error cases. -EAGAIN means that the
- * function has been waiting for another request and the allocation must be
- * restarted, but the whole request should not be failed.
+ * Zurück 0 bei Erfolg und -errno in Fehlerfällen. -EAGAIN Bedeutet, dass die
+ * Funktion wurde für eine weitere Anforderung warten, und die Zuteilung muss
+ * sein neu gestartet, aber die ganze Anforderung sollte nicht versäumt werden.
  */
 static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset,
                                    uint64_t *host_offset, uint64_t *nb_clusters)
@@ -1080,7 +1104,7 @@ static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset,
     trace_qcow2_do_alloc_clusters_offset(qemu_coroutine_self(), guest_offset,
                                          *host_offset, *nb_clusters);
 
-    /* Allocate new clusters */
+    /* Ordnen Sie neue Cluster */
     trace_qcow2_cluster_alloc_phys(qemu_coroutine_self());
     if (*host_offset == 0) {
         int64_t cluster_offset =
@@ -1101,24 +1125,25 @@ static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset,
 }
 
 /*
- * Allocates new clusters for an area that either is yet unallocated or needs a
- * copy on write. If *host_offset is non-zero, clusters are only allocated if
- * the new allocation can match the specified host offset.
+ * Ordnet neue Cluster für einen Bereich, der entweder noch nicht zugeteilten
+ * oder muss ein Kopieren beim Schreiben. Wenn *host_offset nicht Null ist,
+ * werden nur Cluster zugeordnet, wenn die neue Zuordnung kann den angegebenen
+ * Host-Offset entsprechen.
  *
- * Note that guest_offset may not be cluster aligned. In this case, the
- * returned *host_offset points to exact byte referenced by guest_offset and
- * therefore isn't cluster aligned as well.
+ * Beachten Sie, dass guest_offset nicht Cluster ausgerichtet werden können.
+ * In diesem Fall ist die zurück *host_offset Punkte auf genaue Byte von
+ * guest_offset verwiesen und deshalb wird nicht als gut ausgerichtet Cluster.
  *
- * Returns:
- *   0:     if no clusters could be allocated. *bytes is set to 0,
- *          *host_offset is left unchanged.
+ * Kehrt zurück:
+ *   0: wenn keine Cluster zugeordnet werden konnten. *bytes auf 0 gesetzt ist,
+ *          *host_offset bleibt unverändert.
  *
- *   1:     if new clusters were allocated. *bytes may be decreased if the
- *          new allocation doesn't cover all of the requested area.
- *          *host_offset is updated to contain the host offset of the first
- *          newly allocated cluster.
+ *   1: wenn neue Cluster zugeteilt wurden. *bytes, wenn die verringert werden
+ *          Neubestimmung deckt nicht alle angeforderten Bereich.
+ *          *host_offset wird aktualisiert, um den Host zu enthalten Offset des
+ *          ersten neu zugewiesenen Cluster.
  *
- *  -errno: in error cases
+ *  -errno: im Fehlerfall
  */
 static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
     uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m)
@@ -1137,8 +1162,8 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
     assert(*bytes > 0);
 
     /*
-     * Calculate the number of clusters to look for. We stop at L2 table
-     * boundaries to keep things simple.
+     * Berechne die Anzahl der Cluster zu suchen. Wir halten an L2-Tabelle
+     * Grenzen Dinge einfach zu halten.
      */
     nb_clusters =
         size_to_clusters(s, offset_into_cluster(s, guest_offset) + *bytes);
@@ -1147,7 +1172,7 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
     nb_clusters = MIN(nb_clusters, s->l2_size - l2_index);
     assert(nb_clusters <= INT_MAX);
 
-    /* Find L2 entry for the first involved cluster */
+    /* Finden L2-Eintrag für den ersten beteiligten Cluster */
     ret = get_cluster_table(bs, guest_offset, &l2_table, &l2_index);
     if (ret < 0) {
         return ret;
@@ -1155,21 +1180,21 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
 
     entry = be64_to_cpu(l2_table[l2_index]);
 
-    /* For the moment, overwrite compressed clusters one by one */
+    /* Im Moment überschreiben eine komprimierte Cluster durch ein */
     if (entry & QCOW_OFLAG_COMPRESSED) {
         nb_clusters = 1;
     } else {
         nb_clusters = count_cow_clusters(s, nb_clusters, l2_table, l2_index);
     }
 
-    /* This function is only called when there were no non-COW clusters, so if
-     * we can't find any unallocated or COW clusters either, something is
-     * wrong with our code. */
+    /* Diese Funktion wird nur aufgerufen, wenn es keine nicht-COW Cluster
+     * wurden, so dass, wenn können wir keine nicht zugeteilter oder
+     * COW Cluster entweder finden, ist etwas mit unserem Code falsch. */
     assert(nb_clusters > 0);
 
     qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
 
-    /* Allocate, if necessary at a given offset in the image file */
+    /* Ordnen Sie bei Bedarf auf eine in der Bilddatei angegebenen Offset */
     alloc_cluster_offset = start_of_cluster(s, *host_offset);
     ret = do_alloc_cluster_offset(bs, guest_offset, &alloc_cluster_offset,
                                   &nb_clusters);
@@ -1177,16 +1202,16 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
         goto fail;
     }
 
-    /* Can't extend contiguous allocation */
+    /* Kann nicht zusammenhängende Zuordnung erweitern */
     if (nb_clusters == 0) {
         *bytes = 0;
         return 0;
     }
 
-    /* !*host_offset would overwrite the image header and is reserved for "no
-     * host offset preferred". If 0 was a valid host offset, it'd trigger the
-     * following overlap check; do that now to avoid having an invalid value in
-     * *host_offset. */
+    /* ! * Host_offset würde das Bild Header überschreiben und ist reserviert
+     * für "no Offset bevorzugt "Host. Wenn 0 wurde ein gültiger Host-Offset,
+     * es würde auslösen die folgende Überlappungsprüfung; tun Sie das jetzt
+     * zu vermeiden, einen ungültigen Wert, in *host_offset. */
     if (!alloc_cluster_offset) {
         ret = qcow2_pre_write_overlap_check(bs, 0, alloc_cluster_offset,
                                             nb_clusters * s->cluster_size);
@@ -1195,18 +1220,18 @@ static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset,
     }
 
     /*
-     * Save info needed for meta data update.
+     * Speichern Sie Informationen für die Meta-Daten-Update erforderlich.
      *
-     * requested_sectors: Number of sectors from the start of the first
-     * newly allocated cluster to the end of the (possibly shortened
-     * before) write request.
+     * requested_sectors: Anzahl der Sektoren vom Anfang des ersten
+     * neu Cluster zum Ende der zugewiesenen (möglicherweise verkürzten
+     * vor) Schreibanforderung.
      *
-     * avail_sectors: Number of sectors from the start of the first
-     * newly allocated to the end of the last newly allocated cluster.
+     * avail_sectors: Anzahl der Sektoren vom Anfang des ersten
+     * bis zum Ende des letzten neu zugewiesenen Cluster neu zugeordnet.
      *
-     * nb_sectors: The number of sectors from the start of the first
-     * newly allocated cluster to the end of the area that the write
-     * request actually writes to (excluding COW at the end)
+     * nb_sectors: die Anzahl von Sektoren vom Beginn der ersten
+     * neu Cluster mit dem Ende des Bereichs, der die Schreib- zugeordnet
+     * Anfrage tatsächlich schreibt (mit Ausnahme von COW am Ende)
      */
     int requested_sectors =
         (*bytes + offset_into_cluster(s, guest_offset))
@@ -1257,21 +1282,23 @@ fail:
 /*
  * alloc_cluster_offset
  *
- * For a given offset on the virtual disk, find the cluster offset in qcow2
- * file. If the offset is not found, allocate a new cluster.
+ * Für eine auf dem virtuellen Laufwerk angegebenen Offset, finden Sie den
+ * Cluster in qcow2 Offset Datei. Wenn der Offset nicht gefunden wird, einen
+ * neuen Cluster zuordnen.
  *
- * If the cluster was already allocated, m->nb_clusters is set to 0 and
- * other fields in m are meaningless.
+ * Wenn der Cluster wurde bereits vergeben, m-> nb_clusters auf 0 gesetzt ist
+ * und andere Felder in m sind bedeutungslos.
  *
- * If the cluster is newly allocated, m->nb_clusters is set to the number of
- * contiguous clusters that have been allocated. In this case, the other
- * fields of m are valid and contain information about the first allocated
- * cluster.
+ * Wenn der Cluster neu zugeordnet wird, m-> nb_clusters bis die Anzahl der
+ * gesetzten zusammenhängenden Clustern, die zugewiesen worden sind. In diesem
+ * Fall wird der andere Felder m gültig und enthalten Informationen über den
+ * ersten zugewiesenen Cluster.
  *
- * If the request conflicts with another write request in flight, the coroutine
- * is queued and will be reentered when the dependency has completed.
+ * Wenn die Anforderung in Konflikt mit einem anderen Schreibanforderung im
+ * Flug, die Koroutine Warteschlange und wird erneut eingegeben werden, wenn
+ * die Abhängigkeit abgeschlossen hat.
  *
- * Return 0 on success and -errno in error cases
+ * Zurück 0 bei Erfolg und -errno im Fehlerfall
  */
 int qcow2_alloc_cluster_offset(BlockDriverState *bs, uint64_t offset,
     int *num, uint64_t *host_offset, QCowL2Meta **m)
@@ -1313,28 +1340,30 @@ again:
         cur_bytes = remaining;
 
         /*
-         * Now start gathering as many contiguous clusters as possible:
+         * Starten Sie nun so viele zusammenhängende Cluster wie möglich zu
+         * sammeln:
          *
-         * 1. Check for overlaps with in-flight allocations
+         * 1. Überprüfen Sie, ob Überschneidungen mit in-flight Zuweisungen
          *
-         *      a) Overlap not in the first cluster -> shorten this request and
-         *         let the caller handle the rest in its next loop iteration.
+         *      a) Overlap nicht im ersten Cluster -> verkürzen diese
+         *         Anforderung und lassen Sie den Anrufer, den Rest in seiner
+         *         nächsten Schleifeniterationslatenzzeit behandeln.
          *
-         *      b) Real overlaps of two requests. Yield and restart the search
-         *         for contiguous clusters (the situation could have changed
-         *         while we were sleeping)
+         *      b) Echt Überschneidungen von zwei Anfragen. Ausbeute und
+         *         starten Sie die Suche für zusammenhängende Cluster (könnte
+         *         sich die Situation geändert haben während wir schliefen)
          *
-         *      c) TODO: Request starts in the same cluster as the in-flight
-         *         allocation ends. Shorten the COW of the in-fight allocation,
-         *         set cluster_offset to write to the same cluster and set up
-         *         the right synchronisation between the in-flight request and
-         *         the new one.
+         *      c) TODO: Anfrage startet im gleichen Cluster wie der in-flight
+         *         Zuordnung endet. Verkürzen Sie die Kuh der in-Kampf
+         *         Zuweisung, set cluster_offset zu demselben Cluster zu
+         *         schreiben und einrichten die richtige Synchronisation
+         *         zwischen dem In-Flight-Anfrage und der neue.
          */
         ret = handle_dependencies(bs, start, &cur_bytes, m);
         if (ret == -EAGAIN) {
-            /* Currently handle_dependencies() doesn't yield if we already had
-             * an allocation. If it did, we would have to clean up the L2Meta
-             * structs before starting over. */
+            /* Derzeit handle_dependencies () nicht nachgibt, wenn wir
+             * bereits hatten eine Zuordnung. Wenn ja, würden wir die L2Meta
+             * aufräumen müssen structs vor dem Start über. */
             assert(*m == NULL);
             goto again;
         } else if (ret < 0) {
@@ -1342,13 +1371,13 @@ again:
         } else if (cur_bytes == 0) {
             break;
         } else {
-            /* handle_dependencies() may have decreased cur_bytes (shortened
-             * the allocations below) so that the next dependency is processed
-             * correctly during the next loop iteration. */
+            /* handle_dependencies () haben cur_bytes vermindert (verkürzt
+             * die Zuordnungen unten), so dass die nächste Abhängigkeits
+             * verarbeitet wird richtig bei der nächsten Iteration. */
         }
 
         /*
-         * 2. Count contiguous COPIED clusters.
+         * 2. Graf zusammenhängenden COPIED Cluster.
          */
         ret = handle_copied(bs, start, &cluster_offset, &cur_bytes, m);
         if (ret < 0) {
@@ -1360,8 +1389,9 @@ again:
         }
 
         /*
-         * 3. If the request still hasn't completed, allocate new clusters,
-         *    considering any cluster_offset of steps 1c or 2.
+         * 3. Wird der Antrag noch nicht abgeschlossen hat, teilt neue Cluster,
+         *    jede cluster_offset von Schritten 1c oder 2 unter
+         *    Berücksichtigung.
          */
         ret = handle_alloc(bs, start, &cluster_offset, &cur_bytes, m);
         if (ret < 0) {
@@ -1435,9 +1465,9 @@ int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
 }
 
 /*
- * This discards as many clusters of nb_clusters as possible at once (i.e.
- * all clusters in the same L2 table) and returns the number of discarded
- * clusters.
+ * Dies wirft so viele Cluster von nb_clusters wie möglich auf einmal (das
+ * heißt alle Cluster in demselben L2-Tabelle) und gibt die Anzahl der
+ * verworfenen Cluster.
  */
 static int discard_single_l2(BlockDriverState *bs, uint64_t offset,
                              uint64_t nb_clusters, enum qcow2_discard_type type,
@@ -1454,7 +1484,7 @@ static int discard_single_l2(BlockDriverState *bs, uint64_t offset,
         return ret;
     }
 
-    /* Limit nb_clusters to one L2 table */
+    /* Limit nb_clusters einem L2-Tabelle */
     nb_clusters = MIN(nb_clusters, s->l2_size - l2_index);
     assert(nb_clusters <= INT_MAX);
 
@@ -1464,17 +1494,18 @@ static int discard_single_l2(BlockDriverState *bs, uint64_t offset,
         old_l2_entry = be64_to_cpu(l2_table[l2_index + i]);
 
         /*
-         * If full_discard is false, make sure that a discarded area reads back
-         * as zeroes for v3 images (we cannot do it for v2 without actually
-         * writing a zero-filled buffer). We can skip the operation if the
-         * cluster is already marked as zero, or if it's unallocated and we
-         * don't have a backing file.
+         * Wenn full_discard falsch ist, stellen Sie sicher, dass eine
+         * weggeworfene Bereich zurück liest als Nullen für v3 Bilder (wir es
+         * für v2 nicht tun können, ohne tatsächlich eine Null-gefüllten
+         * Puffer zu schreiben). Wir können den Vorgang überspringen, wenn die
+         * Cluster ist bereits als Null markiert, oder wenn es nicht zugewiesen
+         * und wir nicht eine Trägerdatei.
          *
-         * TODO We might want to use bdrv_get_block_status(bs) here, but we're
-         * holding s->lock, so that doesn't work today.
+         * TODO Wir könnten hier bdrv_get_block_status (bs) verwenden möchten,
+         * aber wir sind Halten s-> sperren, so dass nicht heute arbeiten.
          *
-         * If full_discard is true, the sector should not read back as zeroes,
-         * but rather fall through to the backing file.
+         * Wenn full_discard wahr ist, sollte der Sektor nicht als Nullen
+         * zurückgelesen, sondern fallen durch auf die Trägerdatei.
          */
         switch (qcow2_get_cluster_type(old_l2_entry)) {
             case QCOW2_CLUSTER_UNALLOCATED:
@@ -1497,7 +1528,7 @@ static int discard_single_l2(BlockDriverState *bs, uint64_t offset,
                 abort();
         }
 
-        /* First remove L2 entries */
+        /* Entfernen Sie zuerst L2 Einträge */
         qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table);
         if (!full_discard && s->qcow_version >= 3) {
             l2_table[l2_index + i] = cpu_to_be64(QCOW_OFLAG_ZERO);
@@ -1505,7 +1536,7 @@ static int discard_single_l2(BlockDriverState *bs, uint64_t offset,
             l2_table[l2_index + i] = cpu_to_be64(0);
         }
 
-        /* Then decrease the refcount */
+        /* Dann sinken die refcount */
         qcow2_free_any_clusters(bs, old_l2_entry, 1, type);
     }
 
@@ -1524,7 +1555,7 @@ int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset,
 
     end_offset = offset + (nb_sectors << BDRV_SECTOR_BITS);
 
-    /* Round start up and end down */
+    /* Start-Runde und am Ende nach unten */
     offset = align_offset(offset, s->cluster_size);
     end_offset = start_of_cluster(s, end_offset);
 
@@ -1536,7 +1567,8 @@ int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset,
 
     s->cache_discards = true;
 
-    /* Each L2 table is handled by its own loop iteration */
+    /* Jeder L2-Tabelle wird durch eine eigene Schleifeniterationslatenzzeit
+     * behandelt */
     while (nb_clusters > 0) {
         ret = discard_single_l2(bs, offset, nb_clusters, type, full_discard);
         if (ret < 0) {
@@ -1556,9 +1588,9 @@ fail:
 }
 
 /*
- * This zeroes as many clusters of nb_clusters as possible at once (i.e.
- * all clusters in the same L2 table) and returns the number of zeroed
- * clusters.
+ * Diese Nullen wie viele Cluster von nb_clusters wie möglich auf einmal (das
+ * heißt alle Cluster in demselben L2-Tabelle) und gibt die Anzahl der
+ * genullten Cluster.
  */
 static int zero_single_l2(BlockDriverState *bs, uint64_t offset,
                           uint64_t nb_clusters)
@@ -1574,7 +1606,7 @@ static int zero_single_l2(BlockDriverState *bs, uint64_t offset,
         return ret;
     }
 
-    /* Limit nb_clusters to one L2 table */
+    /* Limit nb_clusters einem L2-Tabelle */
     nb_clusters = MIN(nb_clusters, s->l2_size - l2_index);
     assert(nb_clusters <= INT_MAX);
 
@@ -1583,7 +1615,7 @@ static int zero_single_l2(BlockDriverState *bs, uint64_t offset,
 
         old_offset = be64_to_cpu(l2_table[l2_index + i]);
 
-        /* Update L2 entries */
+        /* Update-L2-Einträge */
         qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table);
         if (old_offset & QCOW_OFLAG_COMPRESSED) {
             l2_table[l2_index + i] = cpu_to_be64(QCOW_OFLAG_ZERO);
@@ -1604,12 +1636,13 @@ int qcow2_zero_clusters(BlockDriverState *bs, uint64_t offset, int nb_sectors)
     uint64_t nb_clusters;
     int ret;
 
-    /* The zero flag is only supported by version 3 and newer */
+    /* Die Null-Flag wird nur von Version 3 und höher unterstützt */
     if (s->qcow_version < 3) {
         return -ENOTSUP;
     }
 
-    /* Each L2 table is handled by its own loop iteration */
+    /* Jeder L2-Tabelle wird durch eine eigene Schleifeniterationslatenzzeit
+     * behandelt */
     nb_clusters = size_to_clusters(s, nb_sectors << BDRV_SECTOR_BITS);
 
     s->cache_discards = true;
@@ -1633,12 +1666,12 @@ fail:
 }
 
 /*
- * Expands all zero clusters in a specific L1 table (or deallocates them, for
- * non-backed non-pre-allocated zero clusters).
+ * Erweitert alle Null-Cluster in einem bestimmten L1-Tabelle (oder freigibt
+ * sie, für nicht gesicherte nicht vorab zugewiesen Null-Cluster).
  *
- * l1_entries and *visited_l1_entries are used to keep track of progress for
- * status_cb(). l1_entries contains the total number of L1 entries and
- * *visited_l1_entries counts all visited L1 entries.
+ * l1_entries und *visited_l1_entries werden benutzt, um die Fortschritte zu
+ * halten für status_cb (). l1_entries enthält die Gesamtzahl der L1-Einträge
+ * und *visited_l1_entries zählt alle besuchten L1-Einträge.
  */
 static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
                                       int l1_size, int64_t *visited_l1_entries,
@@ -1653,8 +1686,8 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
     int i, j;
 
     if (!is_active_l1) {
-        /* inactive L2 tables require a buffer to be stored in when loading
-         * them from disk */
+        /* inaktiv L2 Tabellen erfordern einen Puffer gespeichert werden, beim
+         * Laden sie von der Festplatte */
         l2_table = qemu_try_blockalign(bs->file->bs, s->cluster_size);
         if (l2_table == NULL) {
             return -ENOMEM;
@@ -1667,7 +1700,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
         uint64_t l2_refcount;
 
         if (!l2_offset) {
-            /* unallocated */
+            /* nicht zugeteilt */
             (*visited_l1_entries)++;
             if (status_cb) {
                 status_cb(bs, *visited_l1_entries, l1_entries, cb_opaque);
@@ -1684,11 +1717,11 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
         }
 
         if (is_active_l1) {
-            /* get active L2 tables from cache */
+            /* Sie aktiv L2-Tabellen aus dem Cache */
             ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset,
                     (void **)&l2_table);
         } else {
-            /* load inactive L2 tables from disk */
+            /* laden inaktiv L2 Tabellen von der Festplatte */
             ret = bdrv_read(bs->file->bs, l2_offset / BDRV_SECTOR_SIZE,
                             (void *)l2_table, s->cluster_sectors);
         }
@@ -1714,8 +1747,8 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
 
             if (!preallocated) {
                 if (!bs->backing) {
-                    /* not backed; therefore we can simply deallocate the
-                     * cluster */
+                    /* nicht gesichert; Daher können wir einfach die freigeben
+                     * Gruppe */
                     l2_table[j] = 0;
                     l2_dirty = true;
                     continue;
@@ -1728,8 +1761,9 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
                 }
 
                 if (l2_refcount > 1) {
-                    /* For shared L2 tables, set the refcount accordingly (it is
-                     * already 1 and needs to be l2_refcount) */
+                    /* Für L2 Tabellen gemeinsam genutzt, stellen Sie die
+                     * refcount entsprechend (es ist 1 bereits und muss
+                     * l2_refcount) */
                     ret = qcow2_update_cluster_refcount(bs,
                             offset >> s->cluster_bits,
                             refcount_diff(1, l2_refcount), false,
@@ -1825,10 +1859,11 @@ fail:
 }
 
 /*
- * For backed images, expands all zero clusters on the image. For non-backed
- * images, deallocates all non-pre-allocated zero clusters (and claims the
- * allocation for pre-allocated ones). This is important for downgrading to a
- * qcow2 version which doesn't yet support metadata zero clusters.
+ * Für gesicherte Bilder, dehnt sich alle Null-Cluster auf das Bild. Für nicht
+ * gesichert Bilder, freigibt alle nicht im Voraus zugewiesenen Null-Cluster
+ * (und behauptet, die Zuteilung für vorab zugewiesen sind). Dies ist wichtig,
+ * zu einer Herabstufung qcow2 Version, die noch keine Metadaten Null-Cluster
+ * unterstützen.
  */
 int qcow2_expand_zero_clusters(BlockDriverState *bs,
                                BlockDriverAmendStatusCB *status_cb,
@@ -1854,13 +1889,14 @@ int qcow2_expand_zero_clusters(BlockDriverState *bs,
         goto fail;
     }
 
-    /* Inactive L1 tables may point to active L2 tables - therefore it is
-     * necessary to flush the L2 table cache before trying to access the L2
-     * tables pointed to by inactive L1 entries (else we might try to expand
-     * zero clusters that have already been expanded); furthermore, it is also
-     * necessary to empty the L2 table cache, since it may contain tables which
-     * are now going to be modified directly on disk, bypassing the cache.
-     * qcow2_cache_empty() does both for us. */
+    /* Inaktive L1 Tabellen aktiv L2 Tabellen zeigen kann - daher ist es
+     * notwendig, um die L2-Tabelle Cache zu leeren, bevor Sie den L2
+     * zuzugreifen versuchen, Tabellen, auf den inaktiven L1-Einträge (sonst
+     * versuchen wir vielleicht zu erweitern Null-Cluster, die bereits
+     * erweitert haben); Weiterhin ist es auch notwendig, um die
+     * L2 Tabellen-Cache zu leeren, da es Tabellen enthalten, die werden
+     * jetzt direkt auf der Festplatte geändert werden, um den Cache zu
+     * umgehen. qcow2_cache_empty () wird beides für uns. */
     ret = qcow2_cache_empty(bs, s->l2_table_cache);
     if (ret < 0) {
         goto fail;
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index ca6094f..fe83b07 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -80,7 +80,7 @@ static Qcow2SetRefcountFunc *const set_refcount_funcs[] = {
 
 
 /*********************************************************/
-/* refcount handling */
+/* refcount Handhabung */
 
 int qcow2_refcount_init(BlockDriverState *bs)
 {
@@ -227,8 +227,8 @@ static int load_refcount_block(BlockDriverState *bs,
 }
 
 /*
- * Retrieves the refcount of the cluster given by its index and stores it in
- * *refcount. Returns 0 on success and -errno on failure.
+ * Ermittelt die refcount des Clusters durch seinen Index gegeben und speichert
+ * sie in *refcount. Gibt bei Erfolg 0 und -errno bei einem Fehler.
  */
 int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index,
                        uint64_t *refcount)
@@ -273,8 +273,8 @@ int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index,
 }
 
 /*
- * Rounds the refcount table size up to avoid growing the table for each single
- * refcount block that is allocated.
+ * Runden der refcount Tischgröße bis für jeden einzelnen wächst die Tabelle
+ * zu vermeiden refcount Block, der zugeordnet ist.
  */
 static unsigned int next_refcount_table_size(BDRVQcow2State *s,
     unsigned int min_size)
@@ -291,7 +291,7 @@ static unsigned int next_refcount_table_size(BDRVQcow2State *s,
 }
 
 
-/* Checks if two offsets are described by the same refcount block */
+/* Prüft, ob zwei Offsets durch den gleichen refcount Block beschrieben */
 static int in_same_refcount_block(BDRVQcow2State *s, uint64_t offset_a,
     uint64_t offset_b)
 {
@@ -302,10 +302,10 @@ static int in_same_refcount_block(BDRVQcow2State *s, uint64_t offset_a,
 }
 
 /*
- * Loads a refcount block. If it doesn't exist yet, it is allocated first
- * (including growing the refcount table if needed).
+ * Lädt ein refcount Block. Wenn es noch nicht existiert, wird sie zugeordnet
+ * erste (Einschließlich der refcount Tabelle wächst, wenn erforderlich).
  *
- * Returns 0 on success or -errno in error case
+ * Gibt 0 zurück, bei Erfolg -errno im Fehlerfall
  */
 static int alloc_refcount_block(BlockDriverState *bs,
                                 int64_t cluster_index, void **refcount_block)
@@ -316,7 +316,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
 
     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
 
-    /* Find the refcount block for the given cluster */
+    /* Finden Sie den refcount Block für den gegebenen Cluster */
     refcount_table_index = cluster_index >> s->refcount_block_bits;
 
     if (refcount_table_index < s->refcount_table_size) {
@@ -324,7 +324,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         uint64_t refcount_block_offset =
             s->refcount_table[refcount_table_index] & REFT_OFFSET_MASK;
 
-        /* If it's already there, we're done */
+        /* Wenn es schon da ist, sind wir fertig */
         if (refcount_block_offset) {
             if (offset_into_cluster(s, refcount_block_offset)) {
                 qcow2_signal_corruption(bs, true, -1, -1, "Refblock offset %#"
@@ -340,37 +340,42 @@ static int alloc_refcount_block(BlockDriverState *bs,
     }
 
     /*
-     * If we came here, we need to allocate something. Something is at least
-     * a cluster for the new refcount block. It may also include a new refcount
-     * table if the old refcount table is too small.
+     * Wenn wir hierher kamen, brauchen wir etwas zu vergeben. Etwas ist
+     * zumindest ein Cluster für den neuen refcount Block. Es kann auch
+     * eine neue refcount umfassen Tabelle, wenn der alte refcount Tabelle ist
+     * zu klein.
      *
-     * Note that allocating clusters here needs some special care:
+     * Beachten Sie, dass Cluster hier benötigt eine spezielle Pflege
+     * Aufteilung:
      *
-     * - We can't use the normal qcow2_alloc_clusters(), it would try to
-     *   increase the refcount and very likely we would end up with an endless
-     *   recursion. Instead we must place the refcount blocks in a way that
-     *   they can describe them themselves.
+     * - Wir können nicht die normalen qcow2_alloc_clusters () verwenden, wäre
+     *   es versuchen, erhöhen die refcount und sehr wahrscheinlich würden wir
+     *   mit einem endlosen Ende Rekursion. Stattdessen müssen wir die refcount
+     *   Blöcke so platzieren, sie können sie sich beschreiben.
      *
-     * - We need to consider that at this point we are inside update_refcounts
-     *   and potentially doing an initial refcount increase. This means that
-     *   some clusters have already been allocated by the caller, but their
-     *   refcount isn't accurate yet. If we allocate clusters for metadata, we
-     *   need to return -EAGAIN to signal the caller that it needs to restart
-     *   the search for free clusters.
+     * - Wir müssen bedenken, dass wir an dieser Stelle innerhalb
+     *   update_refcounts sind und möglicherweise eine anfängliche refcount
+     *   Anstieg zu tun. Das bedeutet, dass Einige Blöcke sind bereits von dem
+     *   Anrufer zugewiesen wurde, aber ihre refcount ist noch nicht genau.
+     *   Wenn wir Cluster für Metadaten zuweisen, wir müssen -EAGAIN
+     *   zurückkehren, um den Anrufer zu signalisieren, dass es muss neu
+     *   gestartet werden die Suche nach freien Clustern.
      *
-     * - alloc_clusters_noref and qcow2_free_clusters may load a different
-     *   refcount block into the cache
+     * - Alloc_clusters_noref und qcow2_free_clusters laden kann eine andere
+     *   refcount Block in den Cache
      */
 
     *refcount_block = NULL;
 
-    /* We write to the refcount table, so we might depend on L2 tables */
+    /* Wir schreiben Sie an die refcount Tisch, so dass wir vielleicht auf den
+     * L2-Tabellen abhängen */
     ret = qcow2_cache_flush(bs, s->l2_table_cache);
     if (ret < 0) {
         return ret;
     }
 
-    /* Allocate the refcount block itself and mark it as used */
+    /* Ordnen Sie die refcount Block selbst und markieren Sie ihn als
+     * gebraucht */
     int64_t new_block = alloc_clusters_noref(bs, s->cluster_size);
     if (new_block < 0) {
         return new_block;
@@ -383,7 +388,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
 #endif
 
     if (in_same_refcount_block(s, new_block, cluster_index << s->cluster_bits)) {
-        /* Zero the new refcount block before updating it */
+        /* Null, um die neuen refcount Block, bevor es die Aktualisierung */
         ret = qcow2_cache_get_empty(bs, s->refcount_block_cache, new_block,
                                     refcount_block);
         if (ret < 0) {
@@ -392,13 +397,14 @@ static int alloc_refcount_block(BlockDriverState *bs,
 
         memset(*refcount_block, 0, s->cluster_size);
 
-        /* The block describes itself, need to update the cache */
+        /* Der Block beschreibt sich selbst, müssen Sie den Cache zu
+         * aktualisieren */
         int block_index = (new_block >> s->cluster_bits) &
             (s->refcount_block_size - 1);
         s->set_refcount(*refcount_block, block_index, 1);
     } else {
-        /* Described somewhere else. This can recurse at most twice before we
-         * arrive at a block that describes itself. */
+        /* Beschrieben woanders. Dies kann höchstens zweimal, bevor wir
+         * Rekursion kommen zu einem Block, der selbst beschreibt. */
         ret = update_refcount(bs, new_block, s->cluster_size, 1, false,
                               QCOW2_DISCARD_NEVER);
         if (ret < 0) {
@@ -410,8 +416,8 @@ static int alloc_refcount_block(BlockDriverState *bs,
             goto fail_block;
         }
 
-        /* Initialize the new refcount block only after updating its refcount,
-         * update_refcount uses the refcount cache itself */
+        /* Initialisieren Sie den neuen refcount Block erst nach seiner refcount
+         * aktualisieren, update_refcount verwendet den refcount Cache selbst */
         ret = qcow2_cache_get_empty(bs, s->refcount_block_cache, new_block,
                                     refcount_block);
         if (ret < 0) {
@@ -421,7 +427,8 @@ static int alloc_refcount_block(BlockDriverState *bs,
         memset(*refcount_block, 0, s->cluster_size);
     }
 
-    /* Now the new refcount block needs to be written to disk */
+    /* Jetzt ist die neue refcount Block muss auf die Festplatte geschrieben
+     * werden */
     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE);
     qcow2_cache_entry_mark_dirty(bs, s->refcount_block_cache, *refcount_block);
     ret = qcow2_cache_flush(bs, s->refcount_block_cache);
@@ -429,7 +436,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         goto fail_block;
     }
 
-    /* If the refcount table is big enough, just hook the block up there */
+    /* Wenn die refcount Tisch groß genug ist, nur um den Block Haken dort */
     if (refcount_table_index < s->refcount_table_size) {
         uint64_t data64 = cpu_to_be64(new_block);
         BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);
@@ -442,36 +449,38 @@ static int alloc_refcount_block(BlockDriverState *bs,
 
         s->refcount_table[refcount_table_index] = new_block;
 
-        /* The new refcount block may be where the caller intended to put its
-         * data, so let it restart the search. */
+        /* Der neue refcount Block kann sein, wo der Anrufer soll seine setzen
+         * Daten, so lassen Sie es die Suche neu starten. */
         return -EAGAIN;
     }
 
     qcow2_cache_put(bs, s->refcount_block_cache, refcount_block);
 
     /*
-     * If we come here, we need to grow the refcount table. Again, a new
-     * refcount table needs some space and we can't simply allocate to avoid
-     * endless recursion.
+     * Wenn wir hierher kommen, müssen wir die refcount Tisch zu wachsen.
+     * Wieder ein neuer refcount Tisch braucht etwas Platz und wir können
+     * nicht einfach zuordnen zu vermeiden endlose Rekursion.
      *
-     * Therefore let's grab new refcount blocks at the end of the image, which
-     * will describe themselves and the new refcount table. This way we can
-     * reference them only in the new table and do the switch to the new
-     * refcount table at once without producing an inconsistent state in
-     * between.
+     * Deshalb lassen Sie uns am Ende des Bildes neue refcount Blöcke
+     * greifen, die beschreibt sich selbst und die neue refcount Tabelle.
+     * Auf diese Weise können wir sie verweisen nur in der neuen Tabelle
+     * und machen die Umstellung auf die neue refcount Tabelle auf einmal
+     * ohne einen inkonsistenten Zustand produziert in zwischen.
      */
     BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_GROW);
 
-    /* Calculate the number of refcount blocks needed so far; this will be the
-     * basis for calculating the index of the first cluster used for the
-     * self-describing refcount structures which we are about to create.
+    /* Berechnen Sie die Anzahl der refcount Blöcke so weit erforderlich; Dies
+     * wird der Grundlage für die verwendete den Index des ersten Clusters
+     * Berechnungs selbsterklärend refcount Strukturen, die wir schaffen
+     * wollen.
      *
-     * Because we reached this point, there cannot be any refcount entries for
-     * cluster_index or higher indices yet. However, because new_block has been
-     * allocated to describe that cluster (and it will assume this role later
-     * on), we cannot use that index; also, new_block may actually have a higher
-     * cluster index than cluster_index, so it needs to be taken into account
-     * here (and 1 needs to be added to its value because that cluster is used).
+     * Weil wir diesen Punkt erreicht hat, kann es keine refcount Einträge
+     * werden für cluster_index oder höheren Indizes noch. Da jedoch new_block
+     * gewesen später zugewiesen, dass Cluster zu beschreiben (und es wird
+     * diese Rolle übernehmen on), können wir nicht diesen Index verwenden;
+     * Auch new_block kann tatsächlich eine höhere Cluster-Index als
+     * cluster_index, so berücksichtigt werden muss, hier (und 1 muss sein
+     * Wert hinzugefügt werden, weil die Cluster verwendet wird).
      */
     uint64_t blocks_used = DIV_ROUND_UP(MAX(cluster_index + 1,
                                             (new_block >> s->cluster_bits) + 1),
@@ -481,7 +490,8 @@ static int alloc_refcount_block(BlockDriverState *bs,
         return -EFBIG;
     }
 
-    /* And now we need at least one block more for the new metadata */
+    /* Und jetzt müssen wir mindestens einen Block mehr für den neuen
+     * Metadaten */
     uint64_t table_size = next_refcount_table_size(s, blocks_used + 1);
     uint64_t last_table_size;
     uint64_t blocks_clusters;
@@ -505,7 +515,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         s->refcount_table_size, table_size);
 #endif
 
-    /* Create the new refcount table and blocks */
+    /* Erstellen Sie die neue refcount Tabelle und blockiert */
     uint64_t meta_offset = (blocks_used * s->refcount_block_size) *
         s->cluster_size;
     uint64_t table_offset = meta_offset + blocks_clusters * s->cluster_size;
@@ -518,7 +528,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         goto fail_table;
     }
 
-    /* Fill the new refcount table */
+    /* Füllen Sie den neuen refcount Tisch */
     memcpy(new_table, s->refcount_table,
         s->refcount_table_size * sizeof(uint64_t));
     new_table[refcount_table_index] = new_block;
@@ -528,14 +538,14 @@ static int alloc_refcount_block(BlockDriverState *bs,
         new_table[blocks_used + i] = meta_offset + (i * s->cluster_size);
     }
 
-    /* Fill the refcount blocks */
+    /* Füllen Sie die refcount Blöcke */
     uint64_t table_clusters = size_to_clusters(s, table_size * sizeof(uint64_t));
     int block = 0;
     for (i = 0; i < table_clusters + blocks_clusters; i++) {
         s->set_refcount(new_blocks, block++, 1);
     }
 
-    /* Write refcount blocks to disk */
+    /* Schreiben refcount Blöcke auf der Festplatte */
     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS);
     ret = bdrv_pwrite_sync(bs->file->bs, meta_offset, new_blocks,
         blocks_clusters * s->cluster_size);
@@ -545,7 +555,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         goto fail_table;
     }
 
-    /* Write refcount table to disk */
+    /* Schreiben refcount Tabelle auf die Festplatte */
     for(i = 0; i < table_size; i++) {
         cpu_to_be64s(&new_table[i]);
     }
@@ -561,7 +571,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         be64_to_cpus(&new_table[i]);
     }
 
-    /* Hook up the new refcount table in the qcow2 header */
+    /* Schließen Sie die neue refcount Tabelle im qcow2 Kopf */
     struct QEMU_PACKED {
         uint64_t d64;
         uint32_t d32;
@@ -576,7 +586,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
         goto fail_table;
     }
 
-    /* And switch it in memory */
+    /* Und schalten Sie es im Speicher */
     uint64_t old_table_offset = s->refcount_table_offset;
     uint64_t old_table_size = s->refcount_table_size;
 
@@ -585,7 +595,7 @@ static int alloc_refcount_block(BlockDriverState *bs,
     s->refcount_table_size = table_size;
     s->refcount_table_offset = table_offset;
 
-    /* Free old table. */
+    /* Freie alte Tabelle. */
     qcow2_free_clusters(bs, old_table_offset, old_table_size * sizeof(uint64_t),
                         QCOW2_DISCARD_OTHER);
 
@@ -594,9 +604,10 @@ static int alloc_refcount_block(BlockDriverState *bs,
         return ret;
     }
 
-    /* If we were trying to do the initial refcount update for some cluster
-     * allocation, we might have used the same clusters to store newly
-     * allocated metadata. Make the caller search some new space. */
+    /* Wenn wir versuchten, die anfängliche refcount Update für einige Cluster
+     * zu tun Zuteilung, wir könnten die gleichen Cluster verwendet haben, neu
+     * zu speichern, zugeordnet Metadaten. Machen Sie den Anrufer einige neue
+     * Raum suchen. */
     return -EAGAIN;
 
 fail_table:
@@ -617,7 +628,7 @@ void qcow2_process_discards(BlockDriverState *bs, int ret)
     QTAILQ_FOREACH_SAFE(d, &s->discards, next, next) {
         QTAILQ_REMOVE(&s->discards, d, next);
 
-        /* Discard is optional, ignore the return value */
+        /* Verwerfen ist optional, ignorieren den Rückgabewert */
         if (ret >= 0) {
             bdrv_discard(bs->file->bs,
                          d->offset >> BDRV_SECTOR_BITS,
@@ -639,9 +650,9 @@ static void update_refcount_discard(BlockDriverState *bs,
         uint64_t new_end = MAX(offset + length, d->offset + d->bytes);
 
         if (new_end - new_start <= length + d->bytes) {
-            /* There can't be any overlap, areas ending up here have no
-             * references any more and therefore shouldn't get freed another
-             * time. */
+            /* Es kann keine Überschneidungen, Abgeschlagenheit, hier oben
+             * haben keine Referenzen mehr und kann daher nicht ein anderes
+             * bekommen sollte befreit Zeit. */
             assert(d->bytes + length == new_end - new_start);
             d->offset = new_start;
             d->bytes = new_end - new_start;
@@ -658,7 +669,7 @@ static void update_refcount_discard(BlockDriverState *bs,
     QTAILQ_INSERT_TAIL(&s->discards, d, next);
 
 found:
-    /* Merge discard requests if they are adjacent now */
+    /* Merge Discard-Anfragen, ob sie nun benachbart sind */
     QTAILQ_FOREACH_SAFE(p, &s->discards, next, next) {
         if (p == d
             || p->offset > d->offset + d->bytes
@@ -667,7 +678,7 @@ found:
             continue;
         }
 
-        /* Still no overlap possible */
+        /* Noch keine Überschneidungen möglich */
         assert(p->offset == d->offset + d->bytes
             || d->offset == p->offset + p->bytes);
 
@@ -678,9 +689,10 @@ found:
     }
 }
 
-/* XXX: cache several refcount block clusters ? */
-/* @addend is the absolute value of the addend; if @decrease is set, @addend
- * will be subtracted from the current refcount, otherwise it will be added */
+/* XXX: Cache mehrere refcount Block Cluster? */
+/* @addend ist der absolute Wert des Addenden; wenn @decrease gesetzt ist,
+ * @addend wird von der aktuellen refcount abgezogen werden, sonst wird sie
+ * hinzugefügt */
 static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
                                                    int64_t offset,
                                                    int64_t length,
@@ -720,7 +732,7 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
         int64_t cluster_index = cluster_offset >> s->cluster_bits;
         int64_t table_index = cluster_index >> s->refcount_block_bits;
 
-        /* Load the refcount block and allocate it if needed */
+        /* Laden Sie den refcount Block und ordnen sie, wenn nötig */
         if (table_index != old_table_index) {
             if (refcount_block) {
                 qcow2_cache_put(bs, s->refcount_block_cache, &refcount_block);
@@ -735,7 +747,7 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
         qcow2_cache_entry_mark_dirty(bs, s->refcount_block_cache,
                                      refcount_block);
 
-        /* we can update the count and save it */
+        /* wir können die Zählung aktualisieren und speichern */
         block_index = cluster_index & (s->refcount_block_size - 1);
 
         refcount = s->get_refcount(refcount_block, block_index);
@@ -767,14 +779,15 @@ fail:
         qcow2_process_discards(bs, ret);
     }
 
-    /* Write last changed block to disk */
+    /* Schreiben Sie zuletzt geändert Block auf der Festplatte */
     if (refcount_block) {
         qcow2_cache_put(bs, s->refcount_block_cache, &refcount_block);
     }
 
     /*
-     * Try do undo any updates if an error is returned (This may succeed in
-     * some cases like ENOSPC for allocating a new refcount block)
+     * Versuchen Sie keine Updates rückgängig machen, wenn ein Fehler
+     * zurückgegeben (Dies gelingt kann In einigen Fällen wie ENOSPC für
+     * einen neuen refcount Block Zuteilung)
      */
     if (ret < 0) {
         int dummy;
@@ -787,12 +800,13 @@ fail:
 }
 
 /*
- * Increases or decreases the refcount of a given cluster.
+ * Erhöht oder verringert die refcount eines bestimmten Clusters.
  *
- * @addend is the absolute value of the addend; if @decrease is set, @addend
- * will be subtracted from the current refcount, otherwise it will be added.
+ * @addend ist der absolute Wert des Addenden; wenn @decrease gesetzt ist,
+ * @addend wird von der aktuellen refcount abgezogen werden, sonst wird es
+ * hinzugefügt werden.
  *
- * On success 0 is returned; on failure -errno is returned.
+ * Bei Erfolg wird 0 zurückgegeben; bei Ausfall -errno zurückgegeben.
  */
 int qcow2_update_cluster_refcount(BlockDriverState *bs,
                                   int64_t cluster_index,
@@ -814,18 +828,19 @@ int qcow2_update_cluster_refcount(BlockDriverState *bs,
 
 
 /*********************************************************/
-/* cluster allocation functions */
+/* Cluster-Zuordnungsfunktionen */
 
 
 
-/* return < 0 if error */
+/* Rückkehr <0, wenn Fehler */
 static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t i, nb_clusters, refcount;
     int ret;
 
-    /* We can't allocate clusters if they may still be queued for discard. */
+    /* Wir können keine Cluster zuordnen, wenn sie noch für Verwerfungs die
+     * Warteschlange gestellt werden kann. */
     if (s->cache_discards) {
         qcow2_process_discards(bs, 0);
     }
@@ -843,8 +858,8 @@ retry:
         }
     }
 
-    /* Make sure that all offsets in the "allocated" range are representable
-     * in an int64_t */
+    /* Stellen Sie sicher, dass alle Offsets im "zugeordnet" Bereich
+     * darstellbaren in einem int64_t */
     if (s->free_cluster_index > 0 &&
         s->free_cluster_index - 1 > (INT64_MAX >> s->cluster_bits))
     {
@@ -895,7 +910,7 @@ int64_t qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
     }
 
     do {
-        /* Check how many clusters there are free */
+        /* Überprüfen Sie, wie viele Cluster dort frei */
         cluster_index = offset >> s->cluster_bits;
         for(i = 0; i < nb_clusters; i++) {
             ret = qcow2_get_refcount(bs, cluster_index++, &refcount);
@@ -906,7 +921,7 @@ int64_t qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
             }
         }
 
-        /* And then allocate them */
+        /* Und dann ordnen sie */
         ret = update_refcount(bs, offset, i << s->cluster_bits, 1, false,
                               QCOW2_DISCARD_NEVER);
     } while (ret == -EAGAIN);
@@ -918,8 +933,8 @@ int64_t qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
     return i;
 }
 
-/* only used to allocate compressed sectors. We try to allocate
-   contiguous sectors. size must be <= cluster_size */
+/* nur verwendet komprimierte Sektoren zuzuordnen. Wir versuchen zu vergeben
+   zusammenhängenden Sektoren. Größe muss <= CLUSTER_SIZE */
 int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)
 {
     BDRVQcow2State *s = bs->opaque;
@@ -971,8 +986,8 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)
         return ret;
     }
 
-    /* The cluster refcount was incremented; refcount blocks must be flushed
-     * before the caller's L2 table updates. */
+    /* Der Cluster refcount wurde erhöht; refcount Blöcke müssen gespült
+     * werden vor der L2-Tabellenaktualisierungen des Anrufers. */
     qcow2_cache_set_dependency(bs, s->l2_table_cache, s->refcount_block_cache);
 
     s->free_byte_offset = offset + size;
@@ -993,13 +1008,14 @@ void qcow2_free_clusters(BlockDriverState *bs,
     ret = update_refcount(bs, offset, size, 1, true, type);
     if (ret < 0) {
         fprintf(stderr, "qcow2_free_clusters failed: %s\n", strerror(-ret));
-        /* TODO Remember the clusters to free them later and avoid leaking */
+        /* Denken Sie daran, TODO die Cluster um sie zu befreien später und
+         * vermeiden undicht */
     }
 }
 
 /*
- * Free a cluster using its L2 entry (handles clusters of all types, e.g.
- * normal cluster, compressed cluster, etc.)
+ * Befreien eines Clusters seine L2-Eintrag mit (Griffe Cluster aller Art, z
+ * normalen Cluster, Druck Cluster, etc.)
  */
 void qcow2_free_any_clusters(BlockDriverState *bs, uint64_t l2_entry,
                              int nb_clusters, enum qcow2_discard_type type)
@@ -1040,11 +1056,11 @@ void qcow2_free_any_clusters(BlockDriverState *bs, uint64_t l2_entry,
 
 
 /*********************************************************/
-/* snapshots and image creation */
+/* Snapshots und Image-Erstellung */
 
 
 
-/* update the refcounts of snapshots and the copied flag */
+/* Aktualisieren Sie die Refcounts von Snapshots und die kopierte Flagge */
 int qcow2_update_snapshot_refcount(BlockDriverState *bs,
     int64_t l1_table_offset, int l1_size, int addend)
 {
@@ -1063,9 +1079,9 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
 
     s->cache_discards = true;
 
-    /* WARNING: qcow2_snapshot_goto relies on this function not using the
-     * l1_table_offset when it is the current s->l1_table_offset! Be careful
-     * when changing this! */
+    /* WARNUNG: qcow2_snapshot_goto stützt sich auf diese Funktion nicht die
+     * Verwendung von l1_table_offset, wenn es die aktuelle
+     * s-> l1_table_offset! Achtung Bei einer Änderung dieser! */
     if (l1_table_offset != s->l1_table_offset) {
         l1_table = g_try_malloc0(align_offset(l1_size2, 512));
         if (l1_size2 && l1_table == NULL) {
@@ -1127,7 +1143,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
                                 goto fail;
                             }
                         }
-                        /* compressed clusters are never modified */
+                        /* komprimierte Cluster werden nicht verändert */
                         refcount = 2;
                         break;
 
@@ -1146,7 +1162,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
 
                         cluster_index = (offset & L2E_OFFSET_MASK) >> s->cluster_bits;
                         if (!cluster_index) {
-                            /* unallocated */
+                            /* nicht zugeteilt */
                             refcount = 0;
                             break;
                         }
@@ -1221,7 +1237,7 @@ fail:
     s->cache_discards = false;
     qcow2_process_discards(bs, ret);
 
-    /* Update L1 only if it isn't deleted anyway (addend = -1) */
+    /* Update-L1 nur, wenn es nicht gelöscht wird, sowieso (Summand = -1) */
     if (ret == 0 && addend >= 0 && l1_modified) {
         for (i = 0; i < l1_size; i++) {
             cpu_to_be64s(&l1_table[i]);
@@ -1243,31 +1259,33 @@ fail:
 
 
 /*********************************************************/
-/* refcount checking functions */
+/* RefCount Prüffunktionen */
 
 
 static uint64_t refcount_array_byte_size(BDRVQcow2State *s, uint64_t entries)
 {
-    /* This assertion holds because there is no way we can address more than
-     * 2^(64 - 9) clusters at once (with cluster size 512 = 2^9, and because
-     * offsets have to be representable in bytes); due to every cluster
-     * corresponding to one refcount entry, we are well below that limit */
+    /* Diese Behauptung hält, weil es keine Möglichkeit gibt, wir mehr als
+     * adressieren 2 ^ (64-9) Cluster auf einmal (mit Clustergröße
+     * 512 = 2 ^ 9, und weil Offsets haben darstellbare in Bytes zu sein);
+     * wegen jedem Cluster entsprechend einem refcount Eintrag, sind wir
+     * weit unter dieser Grenze */
     assert(entries < (UINT64_C(1) << (64 - 9)));
 
-    /* Thanks to the assertion this will not overflow, because
-     * s->refcount_order < 7.
-     * (note: x << s->refcount_order == x * s->refcount_bits) */
+    /* dies dank der Behauptung nicht überläuft, weil
+     * s-> refcount_order <7.
+     * (Anmerkung: x << s-> refcount_order == x * s-> refcount_bits) */
     return DIV_ROUND_UP(entries << s->refcount_order, 8);
 }
 
 /**
- * Reallocates *array so that it can hold new_size entries. *size must contain
- * the current number of entries in *array. If the reallocation fails, *array
- * and *size will not be modified and -errno will be returned. If the
- * reallocation is successful, *array will be set to the new buffer, *size
- * will be set to new_size and 0 will be returned. The size of the reallocated
- * refcount array buffer will be aligned to a cluster boundary, and the newly
- * allocated area will be zeroed.
+ * Verteilt * Array, so dass es new_size Einträge aufnehmen kann. * Größe
+ * muss enthalten die aktuelle Anzahl der Einträge in * array. Wenn die
+ * Neuzuweisung fehlschlägt, * array und * Größe wird nicht geändert und
+ * -errno zurückgegeben. wenn der Neuzuteilung erfolgreich ist, * Array wird
+ * auf den neuen Puffer eingestellt werden, * Größe wird gesetzt wird
+ * new_size und 0 zurückgegeben werden. Die Größe des umverteilt refcount
+ * array Puffer wird zu einem Cluster-Grenze ausgerichtet werden, und die neu
+ * zugewiesenen Bereich wird auf Null gesetzt.
  */
 static int realloc_refcount_array(BDRVQcow2State *s, void **array,
                                   int64_t *size, int64_t new_size)
@@ -1275,7 +1293,8 @@ static int realloc_refcount_array(BDRVQcow2State *s, void **array,
     int64_t old_byte_size, new_byte_size;
     void *new_ptr;
 
-    /* Round to clusters so the array can be directly written to disk */
+    /* Rund um Cluster so das Array kann auf die Festplatte direkt geschrieben
+     * werden */
     old_byte_size = size_to_clusters(s, refcount_array_byte_size(s, *size))
                     * s->cluster_size;
     new_byte_size = size_to_clusters(s, refcount_array_byte_size(s, new_size))
@@ -1309,11 +1328,12 @@ static int realloc_refcount_array(BDRVQcow2State *s, void **array,
 }
 
 /*
- * Increases the refcount for a range of clusters in a given refcount table.
- * This is used to construct a temporary refcount table out of L1 and L2 tables
- * which can be compared to the refcount table saved in the image.
+ * Erhöht die refcount für eine Reihe von Clustern in einer bestimmten
+ * refcount Tabelle. Dies wird verwendet, um eine temporäre refcount Tabelle
+ * von L1 und L2-Tabellen zu konstruieren die mit dem refcount Tabelle
+ * verglichen werden kann, in dem Bild gespeichert.
  *
- * Modifies the number of errors in res.
+ * Ändert die Anzahl der Fehler in res.
  */
 static int inc_refcounts(BlockDriverState *bs,
                          BdrvCheckResult *res,
@@ -1359,18 +1379,18 @@ static int inc_refcounts(BlockDriverState *bs,
     return 0;
 }
 
-/* Flags for check_refcounts_l1() and check_refcounts_l2() */
+/* Flags für check_refcounts_l1 () und check_refcounts_l2 () */
 enum {
-    CHECK_FRAG_INFO = 0x2,      /* update BlockFragInfo counters */
+    CHECK_FRAG_INFO = 0x2,      /* aktualisieren BlockFragInfo Zähler */
 };
 
 /*
- * Increases the refcount in the given refcount table for the all clusters
- * referenced in the L2 table. While doing so, performs some checks on L2
- * entries.
+ * Erhöht die refcount in der gegebenen refcount Tabelle für die alle Cluster
+ * in der L2-Tabelle verwiesen. Während Dabei führt einige Prüfungen auf L2
+ * Einträge.
  *
- * Returns the number of errors found by the checks or -errno if an internal
- * error occurred.
+ * Gibt die Anzahl der Fehler, die von den Kontrollen gefunden oder -errno
+ * wenn eine interne Ein Fehler ist aufgetreten.
  */
 static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
                               void **refcount_table,
@@ -1382,7 +1402,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
     uint64_t next_contiguous_offset = 0;
     int i, l2_size, nb_csectors, ret;
 
-    /* Read L2 table from disk */
+    /* Lesen Sie L2-Tabelle von der Festplatte */
     l2_size = s->l2_size * sizeof(uint64_t);
     l2_table = g_malloc(l2_size);
 
@@ -1393,13 +1413,13 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
         goto fail;
     }
 
-    /* Do the actual checks */
+    /* Sind die tatsächlichen Kontrollen */
     for(i = 0; i < s->l2_size; i++) {
         l2_entry = be64_to_cpu(l2_table[i]);
 
         switch (qcow2_get_cluster_type(l2_entry)) {
         case QCOW2_CLUSTER_COMPRESSED:
-            /* Compressed clusters don't have QCOW_OFLAG_COPIED */
+            /* Komprimierte Cluster haben keine QCOW_OFLAG_COPIED */
             if (l2_entry & QCOW_OFLAG_COPIED) {
                 fprintf(stderr, "ERROR: cluster %" PRId64 ": "
                     "copied flag must never be set for compressed "
@@ -1408,7 +1428,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
                 res->corruptions++;
             }
 
-            /* Mark cluster as used */
+            /* Mark Cluster als verwendet */
             nb_csectors = ((l2_entry >> s->csize_shift) &
                            s->csize_mask) + 1;
             l2_entry &= s->cluster_offset_mask;
@@ -1422,10 +1442,11 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
                 res->bfi.allocated_clusters++;
                 res->bfi.compressed_clusters++;
 
-                /* Compressed clusters are fragmented by nature.  Since they
-                 * take up sub-sector space but we only have sector granularity
-                 * I/O we need to re-read the same sectors even for adjacent
-                 * compressed clusters.
+                /* Komprimierte Cluster werden von der Natur fragmentiert. Seit
+                 * sie nehmen Teilsektor Platz, aber wir nur Sektor
+                 * Granularität haben I / O benötigen wir, um die gleichen
+                 * Sektoren auch für benachbarte erneut zu lesen komprimierte
+                 * Cluster.
                  */
                 res->bfi.fragmented_clusters++;
             }
@@ -1435,7 +1456,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
             if ((l2_entry & L2E_OFFSET_MASK) == 0) {
                 break;
             }
-            /* fall through */
+            /* durchfallen */
 
         case QCOW2_CLUSTER_NORMAL:
         {
@@ -1450,14 +1471,14 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
                 next_contiguous_offset = offset + s->cluster_size;
             }
 
-            /* Mark cluster as used */
+            /* Mark Cluster als verwendet */
             ret = inc_refcounts(bs, res, refcount_table, refcount_table_size,
                                 offset, s->cluster_size);
             if (ret < 0) {
                 goto fail;
             }
 
-            /* Correct offsets are cluster aligned */
+            /* Korrekte Offsets sind Cluster ausgerichteter */
             if (offset_into_cluster(s, offset)) {
                 fprintf(stderr, "ERROR offset=%" PRIx64 ": Cluster is not "
                     "properly aligned; L2 entry corrupted.\n", offset);
@@ -1483,12 +1504,12 @@ fail:
 }
 
 /*
- * Increases the refcount for the L1 table, its L2 tables and all referenced
- * clusters in the given refcount table. While doing so, performs some checks
- * on L1 and L2 entries.
+ * Erhöht die refcount für den L1-Tabelle, seine L2-Tabellen und alle
+ * referenzierten Cluster in der gegebenen refcount Tabelle. Während Dabei
+ * führt einige Prüfungen auf L1 und L2-Einträge.
  *
- * Returns the number of errors found by the checks or -errno if an internal
- * error occurred.
+ * Gibt die Anzahl der Fehler, die von den Kontrollen gefunden oder -errno
+ * wenn eine interne Ein Fehler ist aufgetreten.
  */
 static int check_refcounts_l1(BlockDriverState *bs,
                               BdrvCheckResult *res,
@@ -1503,14 +1524,14 @@ static int check_refcounts_l1(BlockDriverState *bs,
 
     l1_size2 = l1_size * sizeof(uint64_t);
 
-    /* Mark L1 table as used */
+    /* Mark L1-Tabelle als verwendet */
     ret = inc_refcounts(bs, res, refcount_table, refcount_table_size,
                         l1_table_offset, l1_size2);
     if (ret < 0) {
         goto fail;
     }
 
-    /* Read L1 table entries from disk */
+    /* Lesen Sie L1 Tabelleneinträge von der Festplatte */
     if (l1_size2 > 0) {
         l1_table = g_try_malloc(l1_size2);
         if (l1_table == NULL) {
@@ -1528,11 +1549,11 @@ static int check_refcounts_l1(BlockDriverState *bs,
             be64_to_cpus(&l1_table[i]);
     }
 
-    /* Do the actual checks */
+    /* Sind die tatsächlichen Kontrollen */
     for(i = 0; i < l1_size; i++) {
         l2_offset = l1_table[i];
         if (l2_offset) {
-            /* Mark L2 table as used */
+            /* Mark L2-Tabelle als verwendet */
             l2_offset &= L1E_OFFSET_MASK;
             ret = inc_refcounts(bs, res, refcount_table, refcount_table_size,
                                 l2_offset, s->cluster_size);
@@ -1540,14 +1561,14 @@ static int check_refcounts_l1(BlockDriverState *bs,
                 goto fail;
             }
 
-            /* L2 tables are cluster aligned */
+            /* L2 Tabellen sind Cluster ausgerichteter */
             if (offset_into_cluster(s, l2_offset)) {
                 fprintf(stderr, "ERROR l2_offset=%" PRIx64 ": Table is not "
                     "cluster aligned; L1 entry corrupted\n", l2_offset);
                 res->corruptions++;
             }
 
-            /* Process and check L2 entries */
+            /* Prozess- und überprüfen L2 Einträge */
             ret = check_refcounts_l2(bs, res, refcount_table,
                                      refcount_table_size, l2_offset, flags);
             if (ret < 0) {
@@ -1564,12 +1585,13 @@ fail:
 }
 
 /*
- * Checks the OFLAG_COPIED flag for all L1 and L2 entries.
+ * Prüft die OFLAG_COPIED Flag für alle L1 und L2-Einträge.
  *
- * This function does not print an error message nor does it increment
- * check_errors if qcow2_get_refcount fails (this is because such an error will
- * have been already detected and sufficiently signaled by the calling function
- * (qcow2_check_refcounts) by the time this function is called).
+ * Diese Funktion ist nicht eine Fehlermeldung auch nicht erhöht
+ * check_errors wenn qcow2_get_refcount fehlschlägt (dies liegt daran, dass
+ * ein solcher Fehler wird wurden von der aufrufenden Funktion signalisiert
+ * bereits erkannt und hinreichend (Qcow2_check_refcounts) durch die Zeit,
+ * diese Funktion aufgerufen wird).
  */
 static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
                               BdrvCheckMode fix)
@@ -1592,7 +1614,7 @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
         ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits,
                                  &refcount);
         if (ret < 0) {
-            /* don't print message nor increment check_errors */
+            /* nicht gedruckt Nachricht noch Schritt check_errors */
             continue;
         }
         if ((refcount == 1) != ((l1_entry & QCOW_OFLAG_COPIED) != 0)) {
@@ -1636,7 +1658,7 @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
                                          data_offset >> s->cluster_bits,
                                          &refcount);
                 if (ret < 0) {
-                    /* don't print message nor increment check_errors */
+                    /* nicht gedruckt Nachricht noch Schritt check_errors */
                     continue;
                 }
                 if ((refcount == 1) != ((l2_entry & QCOW_OFLAG_COPIED) != 0)) {
@@ -1687,8 +1709,8 @@ fail:
 }
 
 /*
- * Checks consistency of refblocks and accounts for each refblock in
- * *refcount_table.
+ * Prüft die Konsistenz von refblocks und Konten für jeden refblock in
+ * * Refcount_table.
  */
 static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                            BdrvCheckMode fix, bool *rebuild,
@@ -1703,7 +1725,7 @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
         offset = s->refcount_table[i];
         cluster = offset >> s->cluster_bits;
 
-        /* Refcount blocks are cluster aligned */
+        /* RefCount Blöcke sind Cluster ausgerichteter */
         if (offset_into_cluster(s, offset)) {
             fprintf(stderr, "ERROR refcount block %" PRId64 " is not "
                 "cluster aligned; refcount table entry corrupted\n", i);
@@ -1755,9 +1777,10 @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                 if (ret < 0) {
                     return ret;
                 }
-                /* No need to check whether the refcount is now greater than 1:
-                 * This area was just allocated and zeroed, so it can only be
-                 * exactly 1 after inc_refcounts() */
+                /* Keine Notwendigkeit, ob der refcount zu überprüfen, ist
+                 * jetzt größer als 1: Dieser Bereich wurde nur zugeteilt und
+                 * auf Null gesetzt, so kann es nur sein, genau 1 nach
+                 * inc_refcounts () */
                 continue;
 
 resize_fail:
@@ -1791,7 +1814,7 @@ resize_fail:
 }
 
 /*
- * Calculates an in-memory refcount table.
+ * Berechnet einen In-Memory-refcount Tabelle.
  */
 static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
                                BdrvCheckMode fix, bool *rebuild,
@@ -1812,21 +1835,21 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
         }
     }
 
-    /* header */
+    /* Kopfzeile */
     ret = inc_refcounts(bs, res, refcount_table, nb_clusters,
                         0, s->cluster_size);
     if (ret < 0) {
         return ret;
     }
 
-    /* current L1 table */
+    /* Strom L1 Tabelle */
     ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
                              s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO);
     if (ret < 0) {
         return ret;
     }
 
-    /* snapshots */
+    /* Schnappschüsse */
     for (i = 0; i < s->nb_snapshots; i++) {
         sn = s->snapshots + i;
         ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
@@ -1841,7 +1864,7 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
         return ret;
     }
 
-    /* refcount data */
+    /* refcount Daten */
     ret = inc_refcounts(bs, res, refcount_table, nb_clusters,
                         s->refcount_table_offset,
                         s->refcount_table_size * sizeof(uint64_t));
@@ -1853,8 +1876,8 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 }
 
 /*
- * Compares the actual reference count for each cluster in the image against the
- * refcount as reported by the refcount structures on-disk.
+ * Vergleicht den aktuellen Referenzzähler für jeden Cluster in das Bild gegen
+ * die refcount wie durch die refcount Strukturen auf der Festplatte gemeldet.
  */
 static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
                               BdrvCheckMode fix, bool *rebuild,
@@ -1882,7 +1905,7 @@ static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
         }
 
         if (refcount1 != refcount2) {
-            /* Check if we're allowed to fix the mismatch */
+            /* Prüfen, ob wir erlaubt sind die Diskrepanz zu beheben */
             int *num_fixed = NULL;
             if (refcount1 == 0) {
                 *rebuild = true;
@@ -1910,7 +1933,7 @@ static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
                 }
             }
 
-            /* And if we couldn't, print an error */
+            /* Und wenn wir konnten nicht, einen Fehler drucken */
             if (refcount1 < refcount2) {
                 res->corruptions++;
             } else {
@@ -1921,16 +1944,17 @@ static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 }
 
 /*
- * Allocates clusters using an in-memory refcount table (IMRT) in contrast to
- * the on-disk refcount structures.
+ * Ordnet Cluster unter Verwendung eines In-Memory-refcount Tabelle (IMRT) im
+ * Gegensatz zu die auf der Festplatte refcount Strukturen.
  *
- * On input, *first_free_cluster tells where to start looking, and need not
- * actually be a free cluster; the returned offset will not be before that
- * cluster.  On output, *first_free_cluster points to the first gap found, even
- * if that gap was too small to be used as the returned offset.
+ * Bei der Eingabe sagt * first_free_cluster, wo zu Beginn der Suche, und
+ * brauchen nicht eigentlich ein freier Cluster sein; der Offset zurückgegeben
+ * wird, bevor das nicht sein Cluster. Bei der Ausgabe * first_free_cluster
+ * zeigt auf den ersten Spalt gefunden, sogar wenn diese Lücke zu klein war,
+ * um den Offset zurückgegeben werden.
  *
- * Note that *first_free_cluster is a cluster index whereas the return value is
- * an offset.
+ * Beachten Sie, dass * first_free_cluster ist ein Cluster-Index während der
+ * Rückgabewert ein Offset.
  */
 static int64_t alloc_clusters_imrt(BlockDriverState *bs,
                                    int cluster_count,
@@ -1944,8 +1968,8 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,
     int contiguous_free_clusters;
     int ret;
 
-    /* Starting at *first_free_cluster, find a range of at least cluster_count
-     * continuously free clusters */
+    /* Ab * first_free_cluster, finden Sie einen Bereich von mindestens
+     * cluster_count kontinuierlich freien Clustern */
     for (contiguous_free_clusters = 0;
          cluster < *imrt_nb_clusters &&
          contiguous_free_clusters < cluster_count;
@@ -1954,8 +1978,8 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,
         if (!s->get_refcount(*refcount_table, cluster)) {
             contiguous_free_clusters++;
             if (first_gap) {
-                /* If this is the first free cluster found, update
-                 * *first_free_cluster accordingly */
+                /* Wenn dies der erste freie Cluster gefunden ist, aktualisieren
+                 * * First_free_cluster entsprechend */
                 *first_free_cluster = cluster;
                 first_gap = false;
             }
@@ -1964,20 +1988,21 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,
         }
     }
 
-    /* If contiguous_free_clusters is greater than zero, it contains the number
-     * of continuously free clusters until the current cluster; the first free
-     * cluster in the current "gap" is therefore
-     * cluster - contiguous_free_clusters */
+    /* Wenn contiguous_free_clusters größer als Null ist, enthält es die
+     * Nummer von kontinuierlich freien Clustern, bis der aktuelle Cluster;
+     * die erste freie Cluster in der aktuellen "Lücke" ist daher
+     * Cluster - contiguous_free_clusters */
 
-    /* If no such range could be found, grow the in-memory refcount table
-     * accordingly to append free clusters at the end of the image */
+    /* Wenn kein solcher Bereich gefunden werden konnte, wachsen die
+     * In-Memory-refcount Tabelle dementsprechend freien Clustern am Ende des
+     * Bildes anzuhängen */
     if (contiguous_free_clusters < cluster_count) {
-        /* contiguous_free_clusters clusters are already empty at the image end;
-         * we need cluster_count clusters; therefore, we have to allocate
-         * cluster_count - contiguous_free_clusters new clusters at the end of
-         * the image (which is the current value of cluster; note that cluster
-         * may exceed old_imrt_nb_clusters if *first_free_cluster pointed beyond
-         * the image end) */
+        /* contiguous_free_clusters Cluster am Bildende bereits leer sind;
+         * wir brauchen cluster_count Cluster; daher müssen wir vergeben
+         * cluster_count - contiguous_free_clusters neue Cluster am Ende
+         * das Bild (das ist der aktuelle Wert des Clusters ist, beachten Sie,
+         * dass Cluster überschreiten darf old_imrt_nb_clusters wenn
+         * * first_free_cluster über spitz das Bild Ende) */
         ret = realloc_refcount_array(s, refcount_table, imrt_nb_clusters,
                                      cluster + cluster_count
                                      - contiguous_free_clusters);
@@ -1986,7 +2011,7 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,
         }
     }
 
-    /* Go back to the first free cluster */
+    /* Gehen Sie zurück zu den ersten freien Cluster */
     cluster -= contiguous_free_clusters;
     for (i = 0; i < cluster_count; i++) {
         s->set_refcount(*refcount_table, cluster + i, 1);
@@ -1996,12 +2021,12 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,
 }
 
 /*
- * Creates a new refcount structure based solely on the in-memory information
- * given through *refcount_table. All necessary allocations will be reflected
- * in that array.
+ * Erstellt eine neue refcount Struktur ausschließlich auf der
+ * In-Memory-Informationen basierend durch * refcount_table gegeben. Alle
+ * notwendigen Zuweisungen werden reflektiert in diesem Array.
  *
- * On success, the old refcount structure is leaked (it will be covered by the
- * new refcount structure).
+ * Bei Erfolg wird die alte refcount Struktur durchgesickert (es wird durch
+ * die abgedeckt werden neue refcount Struktur).
  */
 static int rebuild_refcount_structure(BlockDriverState *bs,
                                       BdrvCheckResult *res,
@@ -2031,7 +2056,8 @@ write_refblocks:
         refblock_index = cluster >> s->refcount_block_bits;
         refblock_start = refblock_index << s->refcount_block_bits;
 
-        /* Don't allocate a cluster in a refblock already written to disk */
+        /* Verwenden Sie kein Cluster in einem refblock zuweisen bereits auf
+         * die Platte geschrieben */
         if (first_free_cluster < refblock_start) {
             first_free_cluster = refblock_start;
         }
@@ -2064,15 +2090,16 @@ write_refblocks:
             memset(on_disk_reftable + old_reftable_size, 0,
                    (reftable_size - old_reftable_size) * sizeof(uint64_t));
 
-            /* The offset we have for the reftable is now no longer valid;
-             * this will leak that range, but we can easily fix that by running
-             * a leak-fixing check after this rebuild operation */
+            /* Der Offset haben wir für die refTable ist jetzt nicht mehr
+             * gültig; Dies wird diesen Bereich auslaufen, aber wir können das
+             * leicht beheben, indem Sie ein Leck Festsetzungsprüfung nach
+             * dieser Operation wieder aufbauen */
             reftable_offset = -1;
         }
         on_disk_reftable[refblock_index] = refblock_offset;
 
-        /* If this is apparently the last refblock (for now), try to squeeze the
-         * reftable in */
+        /* Wenn dies anscheinend der letzte refblock ist (bis jetzt), versuchen
+         * Sie das zu quetschen refTable in */
         if (refblock_index == (*nb_clusters - 1) >> s->refcount_block_bits &&
             reftable_offset < 0)
         {
@@ -2097,8 +2124,8 @@ write_refblocks:
             goto fail;
         }
 
-        /* The size of *refcount_table is always cluster-aligned, therefore the
-         * write operation will not overflow */
+        /* Die Größe * refcount_table ist immer Cluster ausgerichtet sind,
+         * damit die Schreiboperation nicht überläuft */
         on_disk_refblock = (void *)((char *) *refcount_table +
                                     refblock_index * s->cluster_size);
 
@@ -2109,7 +2136,7 @@ write_refblocks:
             goto fail;
         }
 
-        /* Go to the end of this refblock */
+        /* Zum Ende dieses refblock */
         cluster = refblock_start + s->refcount_block_size - 1;
     }
 
@@ -2119,7 +2146,7 @@ write_refblocks:
         post_refblock_start = ROUND_UP(*nb_clusters, s->refcount_block_size);
         reftable_clusters = size_to_clusters(s,
                                              reftable_size * sizeof(uint64_t));
-        /* Not pretty but simple */
+        /* Nicht schön, aber einfach */
         if (first_free_cluster < post_refblock_start) {
             first_free_cluster = post_refblock_start;
         }
@@ -2158,7 +2185,7 @@ write_refblocks:
         goto fail;
     }
 
-    /* Enter new reftable into the image header */
+    /* Geben Sie den neuen refTable in die Bildkopf */
     cpu_to_be64w(&reftable_offset_and_clusters.reftable_offset,
                  reftable_offset);
     cpu_to_be32w(&reftable_offset_and_clusters.reftable_clusters,
@@ -2187,10 +2214,11 @@ fail:
 }
 
 /*
- * Checks an image for refcount consistency.
+ * Prüft ein Bild für refcount Konsistenz.
  *
- * Returns 0 if no errors are found, the number of errors in case the image is
- * detected as corrupted, and -errno when an internal error occurred.
+ * 0 zurück, wenn keine Fehler gefunden werden, die Anzahl der Fehler, falls
+ * das Bild als beschädigt erkannt und -errno, wenn ein interner Fehler
+ * aufgetreten ist.
  */
 int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
                           BdrvCheckMode fix)
@@ -2223,9 +2251,9 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
         goto fail;
     }
 
-    /* In case we don't need to rebuild the refcount structure (but want to fix
-     * something), this function is immediately called again, in which case the
-     * result should be ignored */
+    /* Für den Fall, brauchen wir nicht die refcount Struktur neu zu erstellen
+     * (aber wollen zu beheben etwas), wird diese Funktion sofort wieder
+     * aufgerufen wird, in welchem Fall der Ergebnis sollte ignoriert */
     pre_compare_res = *res;
     compare_refcounts(bs, res, 0, &rebuild, &highest_cluster, refcount_table,
                       nb_clusters);
@@ -2244,8 +2272,8 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
         res->corruptions = 0;
         res->leaks = 0;
 
-        /* Because the old reftable has been exchanged for a new one the
-         * references have to be recalculated */
+        /* Da die alte refTable wurde für eine neue ausgetauscht der
+         * Referenzen sind neu berechnet werden */
         rebuild = false;
         memset(refcount_table, 0, refcount_array_byte_size(s, nb_clusters));
         ret = calculate_refcounts(bs, res, 0, &rebuild, &refcount_table,
@@ -2255,9 +2283,10 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
         }
 
         if (fix & BDRV_FIX_LEAKS) {
-            /* The old refcount structures are now leaked, fix it; the result
-             * can be ignored, aside from leaks which were introduced by
-             * rebuild_refcount_structure() that could not be fixed */
+            /* Die alten refcount Strukturen sind nun ausgelaufen ist, fixieren;
+             * das Ergebnis kann von Lecks ignoriert, beiseite, die durch
+             * eingeführt wurden rebuild_refcount_structure (), die nicht
+             * repariert werden konnte */
             BdrvCheckResult saved_res = *res;
             *res = (BdrvCheckResult){ 0 };
 
@@ -2268,9 +2297,9 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
                         "broken\n");
             }
 
-            /* Any leaks accounted for here were introduced by
-             * rebuild_refcount_structure() because that function has created a
-             * new refcount structure from scratch */
+            /* Undichtigkeiten für hier berücksichtigt wurden eingeführt
+             * durch rebuild_refcount_structure (), weil die Funktion
+             * erstellt eine neue refcount Struktur von Grund auf neu */
             fresh_leaks = res->leaks;
             *res = saved_res;
         }
@@ -2297,7 +2326,7 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
         }
     }
 
-    /* check OFLAG_COPIED */
+    /* überprüfen OFLAG_COPIED */
     ret = check_oflag_copied(bs, res, fix);
     if (ret < 0) {
         goto fail;
@@ -2316,18 +2345,22 @@ fail:
     ranges_overlap(offset, size, ofs, sz)
 
 /*
- * Checks if the given offset into the image file is actually free to use by
- * looking for overlaps with important metadata sections (L1/L2 tables etc.),
- * i.e. a sanity check without relying on the refcount tables.
+ * Überprüft, ob die in die Bilddatei angegebenen Offset ist eigentlich frei
+ * durch die Verwendung Suche nach Überschneidungen mit wichtigen Metadaten
+ * Abschnitten (L1 / L2-Tabellen etc.), das heißt eine Plausibilitätsprüfung
+ * auf den refcount Tabellen, ohne sich.
  *
- * The ign parameter specifies what checks not to perform (being a bitmask of
- * QCow2MetadataOverlap values), i.e., what sections to ignore.
+ * Der ign Parameter gibt an, welche Schecks nicht durchzuführen (im Falle
+ * einer Bitmaske QCow2MetadataOverlap Werte), das heißt, welche Abschnitte
+ * zu ignorieren.
  *
- * Returns:
- * - 0 if writing to this offset will not affect the mentioned metadata
- * - a positive QCow2MetadataOverlap value indicating one overlapping section
- * - a negative value (-errno) indicating an error while performing a check,
- *   e.g. when bdrv_read failed on QCOW2_OL_INACTIVE_L2
+ * Kehrt zurück:
+ * - 0, wenn Offset dieses Schreiben wird keinen Einfluss auf die genannten
+ *   Metadaten
+ * - Ein positiver QCow2MetadataOverlap Wert ein Überlappungsbereich anzeigt,
+ * - Ein negativer Wert (-errno) einen Fehler anzeigt, während eine Prüfung
+ *   durchgeführt wird, z.B. wenn bdrv_read fehlgeschlagen auf
+ *   QCOW2_OL_INACTIVE_L2
  */
 int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
                                  int64_t size)
@@ -2346,7 +2379,7 @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
         }
     }
 
-    /* align range to test to cluster boundaries */
+    /* ausrichten Bereich Clustergrenzen zu testen */
     size = align_offset(offset_into_cluster(s, offset) + size, s->cluster_size);
     offset = start_of_cluster(s, offset);
 
@@ -2444,14 +2477,16 @@ static const char *metadata_ol_names[] = {
 };
 
 /*
- * First performs a check for metadata overlaps (through
- * qcow2_check_metadata_overlap); if that fails with a negative value (error
- * while performing a check), that value is returned. If an impending overlap
- * is detected, the BDS will be made unusable, the qcow2 file marked corrupt
- * and -EIO returned.
+ * Zunächst führt eine Prüfung für Metadaten Überlappungen (durch
+ * qcow2_check_metadata_overlap); wenn das nicht klappt mit einem negativen Wert
+ * (Fehler während ein check) durchgeführt wird, wird dieser Wert
+ * zurückgegeben. Wenn eine bevorstehende Überlappung erkannt wird, werden die
+ * BDS unbrauchbar gemacht, markiert die qcow2 Datei beschädigt und -EIO
+ * zurückgegeben.
  *
- * Returns 0 if there were neither overlaps nor errors while checking for
- * overlaps; or a negative value (-errno) on error.
+ * Gibt 0 zurück, wenn es weder Überschneidungen noch Fehler waren während
+ * der Überprüfung für überlappt; oder ein negativer Wert (-errno) auf
+ * Fehler.
  */
 int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset,
                                   int64_t size)
@@ -2473,15 +2508,17 @@ int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset,
     return 0;
 }
 
-/* A pointer to a function of this type is given to walk_over_reftable(). That
- * function will create refblocks and pass them to a RefblockFinishOp once they
- * are completed (@refblock). @refblock_empty is set if the refblock is
- * completely empty.
+/* Ein Zeiger auf eine Funktion dieses Typs ist gegeben walk_over_reftable ().
+ * Dass Funktion refblocks erstellen und sie zu einem RefblockFinishOp, sobald
+ * sie passieren abgeschlossen (@refblock) sind. @refblock_empty wird gesetzt,
+ * wenn die refblock ist völlig leer.
  *
- * Along with the refblock, a corresponding reftable entry is passed, in the
- * reftable @reftable (which may be reallocated) at @reftable_index.
+ * Zusammen mit dem refblock wird eine entsprechende refTable Eintrag
+ * vergangen, in der refTable @reftable bei @reftable_index (die neu
+ * zugeordnet werden kann).
  *
- * @allocated should be set to true if a new cluster has been allocated.
+ * @allocated sollte auf true gesetzt werden, wenn ein neuer Cluster zugeordnet
+ * ist.
  */
 typedef int (RefblockFinishOp)(BlockDriverState *bs, uint64_t **reftable,
                                uint64_t reftable_index, uint64_t *reftable_size,
@@ -2489,9 +2526,9 @@ typedef int (RefblockFinishOp)(BlockDriverState *bs, uint64_t **reftable,
                                bool *allocated, Error **errp);
 
 /**
- * This "operation" for walk_over_reftable() allocates the refblock on disk (if
- * it is not empty) and inserts its offset into the new reftable. The size of
- * this new reftable is increased as required.
+ * Diese "Betrieb" für walk_over_reftable () ordnet die refblock auf der
+ * Festplatte (falls es ist nicht leer) und fügt seine in die neue refTable
+ * versetzt. Die Größe von Diese neue refTable wird nach Bedarf erhöht.
  */
 static int alloc_refblock(BlockDriverState *bs, uint64_t **reftable,
                           uint64_t reftable_index, uint64_t *reftable_size,
@@ -2542,9 +2579,9 @@ static int alloc_refblock(BlockDriverState *bs, uint64_t **reftable,
 }
 
 /**
- * This "operation" for walk_over_reftable() writes the refblock to disk at the
- * offset specified by the new reftable's entry. It does not modify the new
- * reftable or change any refcounts.
+ * Diese "Betrieb" für walk_over_reftable () schreibt die refblock auf die
+ * Festplatte an der Offset durch den neuen refTable der Eintrag angegeben.
+ * Es verändert nicht die neue refTable oder irgendwelche Refcounts ändern.
  */
 static int flush_refblock(BlockDriverState *bs, uint64_t **reftable,
                           uint64_t reftable_index, uint64_t *reftable_size,
@@ -2577,17 +2614,20 @@ static int flush_refblock(BlockDriverState *bs, uint64_t **reftable,
 }
 
 /**
- * This function walks over the existing reftable and every referenced refblock;
- * if @new_set_refcount is non-NULL, it is called for every refcount entry to
- * create an equal new entry in the passed @new_refblock. Once that
- * @new_refblock is completely filled, @operation will be called.
+ * Diese Funktion geht über die bestehende refTable und jedes referenzierte
+ * refblock; wenn @new_set_refcount nicht NULL ist, wird es für jeden
+ * refcount Eintrag aufgerufen eine gleiche neuen Eintrag in der übergebenen
+ * @new_refblock erstellen. Sobald das @new_refblock vollständig gefüllt ist,
+ * wird @operation aufgerufen werden.
  *
- * @status_cb and @cb_opaque are used for the amend operation's status callback.
- * @index is the index of the walk_over_reftable() calls and @total is the total
- * number of walk_over_reftable() calls per amend operation. Both are used for
- * calculating the parameters for the status callback.
+ * @status_cb und @cb_opaque sind für die Änderung der Operation Status
+ * Rückruf verwendet. @index ist der Index des walk_over_reftable () aufruft
+ * und @total ist die Gesamt Anzahl der walk_over_reftable () ruft pro
+ * Betrieb ändern. Beide werden verwendet für Berechnen der Parameter für
+ * den Status Rückruf.
  *
- * @allocated is set to true if a new cluster has been allocated.
+ * @allocated auf true gesetzt ist, wenn ein neuer Cluster zugeordnet worden
+ * ist.
  */
 static int walk_over_reftable(BlockDriverState *bs, uint64_t **new_reftable,
                               uint64_t *new_reftable_index,
@@ -2642,7 +2682,7 @@ static int walk_over_reftable(BlockDriverState *bs, uint64_t **new_reftable,
                 uint64_t refcount;
 
                 if (new_refblock_index >= new_refblock_size) {
-                    /* new_refblock is now complete */
+                    /* new_refblock ist nun abgeschlossen */
                     ret = operation(bs, new_reftable, *new_reftable_index,
                                     new_reftable_size, new_refblock,
                                     new_refblock_empty, allocated, errp);
@@ -2683,12 +2723,12 @@ static int walk_over_reftable(BlockDriverState *bs, uint64_t **new_reftable,
 
             qcow2_cache_put(bs, s->refcount_block_cache, &refblock);
         } else {
-            /* No refblock means every refcount is 0 */
+            /* Keine refblock bedeutet, dass jeder refcount 0 */
             for (refblock_index = 0; refblock_index < s->refcount_block_size;
                  refblock_index++)
             {
                 if (new_refblock_index >= new_refblock_size) {
-                    /* new_refblock is now complete */
+                    /* new_refblock ist nun abgeschlossen */
                     ret = operation(bs, new_reftable, *new_reftable_index,
                                     new_reftable_size, new_refblock,
                                     new_refblock_empty, allocated, errp);
@@ -2711,7 +2751,8 @@ static int walk_over_reftable(BlockDriverState *bs, uint64_t **new_reftable,
     }
 
     if (new_refblock_index > 0) {
-        /* Complete the potentially existing partially filled final refblock */
+        /* Füllen Sie das potenziell vorhandene teilweise gefüllt letzte
+         * refblock */
         if (new_set_refcount) {
             for (; new_refblock_index < new_refblock_size;
                  new_refblock_index++)
@@ -2758,7 +2799,7 @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
     assert(s->qcow_version >= 3);
     assert(refcount_order >= 0 && refcount_order <= 6);
 
-    /* see qcow2_open() */
+    /* siehe qcow2_open () */
     new_refblock_size = 1 << (s->cluster_bits - (refcount_order - 3));
 
     new_get_refcount = get_refcount_funcs[refcount_order];
@@ -2770,15 +2811,15 @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
 
         new_allocation = false;
 
-        /* At least we have to do this walk and the one which writes the
-         * refblocks; also, at least we have to do this loop here at least
-         * twice (normally), first to do the allocations, and second to
-         * determine that everything is correctly allocated, this then makes
-         * three walks in total */
+        /* Wenigstens haben wir diesen Weg und das eine zu tun, die das schreibt
+         * refblocks; auch, zumindest müssen wir hier zumindest diese Schleife
+         * zu tun zweimal (in der Regel), zuerst die Zuweisungen zu tun, und an
+         * zweiter Stelle zu feststellen, dass alles korrekt zugeordnet ist,
+         * dies dann macht drei Wanderungen insgesamt */
         total_walks = MAX(walk_index + 2, 3);
 
-        /* First, allocate the structures so they are present in the refcount
-         * structures */
+        /* Zunächst erfolgt die Zuweisung der Strukturen, so dass sie in der
+         * refcount Strukturen */
         ret = walk_over_reftable(bs, &new_reftable, &new_reftable_index,
                                  &new_reftable_size, NULL, new_refblock_size,
                                  new_refcount_bits, &alloc_refblock,
@@ -2809,7 +2850,7 @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
         }
     } while (new_allocation);
 
-    /* Second, write the new refblocks */
+    /* Zweitens schreiben die neuen refblocks */
     ret = walk_over_reftable(bs, &new_reftable, &new_reftable_index,
                              &new_reftable_size, new_refblock,
                              new_refblock_size, new_refcount_bits,
@@ -2822,7 +2863,7 @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
     assert(!new_allocation);
 
 
-    /* Write the new reftable */
+    /* Schreiben Sie die neue refTable */
     ret = qcow2_pre_write_overlap_check(bs, 0, new_reftable_offset,
                                         new_reftable_size * sizeof(uint64_t));
     if (ret < 0) {
@@ -2847,17 +2888,18 @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
     }
 
 
-    /* Empty the refcount cache */
+    /* Leeren Sie den Cache refcount */
     ret = qcow2_cache_flush(bs, s->refcount_block_cache);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to flush the refblock cache");
         goto done;
     }
 
-    /* Update the image header to point to the new reftable; this only updates
-     * the fields which are relevant to qcow2_update_header(); other fields
-     * such as s->refcount_table or s->refcount_bits stay stale for now
-     * (because we have to restore everything if qcow2_update_header() fails) */
+    /* Aktualisieren Sie die Bild-Header an den neuen refTable zu zeigen;
+     * diese nur Updates die Felder, die zu qcow2_update_header() relevant
+     * sind; anderen Bereichen wie s-> refcount_table oder
+     * s-> refcount_bits jetzt abgestanden bleiben (Weil wir alles
+     * wiederherstellen, wenn qcow2_update_header () fehlschlägt) */
     old_refcount_order  = s->refcount_order;
     old_reftable_size   = s->refcount_table_size;
     old_reftable_offset = s->refcount_table_offset;
@@ -2875,7 +2917,7 @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
         goto done;
     }
 
-    /* Now update the rest of the in-memory information */
+    /* Jetzt aktualisieren den Rest der In-Memory-Informationen */
     old_reftable = s->refcount_table;
     s->refcount_table = new_reftable;
 
@@ -2889,17 +2931,17 @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
     s->get_refcount = new_get_refcount;
     s->set_refcount = new_set_refcount;
 
-    /* For cleaning up all old refblocks and the old reftable below the "done"
-     * label */
+    /* Für alle alten refblocks und die alte refTable unter dem "fertig"
+     * Aufräumen Etikette */
     new_reftable        = old_reftable;
     new_reftable_size   = old_reftable_size;
     new_reftable_offset = old_reftable_offset;
 
 done:
     if (new_reftable) {
-        /* On success, new_reftable actually points to the old reftable (and
-         * new_reftable_size is the old reftable's size); but that is just
-         * fine */
+        /* Bei Erfolg zeigt new_reftable tatsächlich auf die alte refTable (und
+         * new_reftable_size ist die alte refTable Größe); aber das ist nur
+         * fein */
         for (i = 0; i < new_reftable_size; i++) {
             uint64_t offset = new_reftable[i] & REFT_OFFSET_MASK;
             if (offset) {
diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c
index 5f4a17e..8fd79a8 100644
--- a/block/qcow2-snapshot.c
+++ b/block/qcow2-snapshot.c
@@ -64,7 +64,7 @@ int qcow2_read_snapshots(BlockDriverState *bs)
     s->snapshots = g_new0(QCowSnapshot, s->nb_snapshots);
 
     for(i = 0; i < s->nb_snapshots; i++) {
-        /* Read statically sized part of the snapshot header */
+        /* Lesen Sie statisch Größe Teil des Snapshot-Header */
         offset = align_offset(offset, 8);
         ret = bdrv_pread(bs->file->bs, offset, &h, sizeof(h));
         if (ret < 0) {
@@ -84,7 +84,7 @@ int qcow2_read_snapshots(BlockDriverState *bs)
         id_str_size = be16_to_cpu(h.id_str_size);
         name_size = be16_to_cpu(h.name_size);
 
-        /* Read extra data */
+        /* Lesen Sie zusätzliche Daten */
         ret = bdrv_pread(bs->file->bs, offset, &extra,
                          MIN(sizeof(extra), extra_data_size));
         if (ret < 0) {
@@ -102,7 +102,7 @@ int qcow2_read_snapshots(BlockDriverState *bs)
             sn->disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
         }
 
-        /* Read snapshot ID */
+        /* Lesen Sie Snapshot-ID */
         sn->id_str = g_malloc(id_str_size + 1);
         ret = bdrv_pread(bs->file->bs, offset, sn->id_str, id_str_size);
         if (ret < 0) {
@@ -111,7 +111,7 @@ int qcow2_read_snapshots(BlockDriverState *bs)
         offset += id_str_size;
         sn->id_str[id_str_size] = '\0';
 
-        /* Read snapshot name */
+        /* Lesen Sie Snapshot-Name */
         sn->name = g_malloc(name_size + 1);
         ret = bdrv_pread(bs->file->bs, offset, sn->name, name_size);
         if (ret < 0) {
@@ -135,7 +135,7 @@ fail:
     return ret;
 }
 
-/* add at the end of the file a new list of snapshots */
+/* eine neue Liste von Snapshots am Ende der Datei hinzufügen */
 static int qcow2_write_snapshots(BlockDriverState *bs)
 {
     BDRVQcow2State *s = bs->opaque;
@@ -150,7 +150,7 @@ static int qcow2_write_snapshots(BlockDriverState *bs)
     int64_t offset, snapshots_offset = 0;
     int ret;
 
-    /* compute the size of the snapshots */
+    /* Berechnen der Größe der Schnappschüsse */
     offset = 0;
     for(i = 0; i < s->nb_snapshots; i++) {
         sn = s->snapshots + i;
@@ -169,7 +169,7 @@ static int qcow2_write_snapshots(BlockDriverState *bs)
     assert(offset <= INT_MAX);
     snapshots_size = offset;
 
-    /* Allocate space for the new snapshot list */
+    /* Ordnen Sie Platz für die neue Snapshot-Liste */
     snapshots_offset = qcow2_alloc_clusters(bs, snapshots_size);
     offset = snapshots_offset;
     if (offset < 0) {
@@ -181,22 +181,23 @@ static int qcow2_write_snapshots(BlockDriverState *bs)
         goto fail;
     }
 
-    /* The snapshot list position has not yet been updated, so these clusters
-     * must indeed be completely free */
+    /* Die Snapshot-Liste Position wurde noch nicht aktualisiert worden, so dass
+     * diese Cluster muss in der Tat völlig frei sein */
     ret = qcow2_pre_write_overlap_check(bs, 0, offset, snapshots_size);
     if (ret < 0) {
         goto fail;
     }
 
 
-    /* Write all snapshots to the new list */
+    /* Schreiben Sie alle Snapshots auf die neue Liste */
     for(i = 0; i < s->nb_snapshots; i++) {
         sn = s->snapshots + i;
         memset(&h, 0, sizeof(h));
         h.l1_table_offset = cpu_to_be64(sn->l1_table_offset);
         h.l1_size = cpu_to_be32(sn->l1_size);
-        /* If it doesn't fit in 32 bit, older implementations should treat it
-         * as a disk-only snapshot rather than truncate the VM state */
+        /* Wenn es nicht in 32-Bit passt, älteren Implementierungen sollte es
+         * behandeln als scheiben nur snapshot anstatt die VM Zustand
+         * trunkieren */
         if (sn->vm_state_size <= 0xffffffff) {
             h.vm_state_size = cpu_to_be32(sn->vm_state_size);
         }
@@ -242,8 +243,9 @@ static int qcow2_write_snapshots(BlockDriverState *bs)
     }
 
     /*
-     * Update the header to point to the new snapshot table. This requires the
-     * new table and its refcounts to be stable on disk.
+     * Aktualisieren Sie den Header an den neuen Snapshot-Tabelle zu verweisen.
+     * Dies erfordert die neue Tabelle, und seine Refcounts auf der Platte
+     * stabil.
      */
     ret = bdrv_flush(bs);
     if (ret < 0) {
@@ -262,7 +264,7 @@ static int qcow2_write_snapshots(BlockDriverState *bs)
         goto fail;
     }
 
-    /* free the old snapshot table */
+    /* befreien die alte Snapshot-Tabelle */
     qcow2_free_clusters(bs, s->snapshots_offset, s->snapshots_size,
                         QCOW2_DISCARD_SNAPSHOT);
     s->snapshots_offset = snapshots_offset;
@@ -337,7 +339,7 @@ static int find_snapshot_by_id_or_name(BlockDriverState *bs,
     return find_snapshot_by_id_and_name(bs, NULL, id_or_name);
 }
 
-/* if no id is provided, a new one is constructed */
+/* wenn keine ID angegeben ist, wird eine neue gebaut */
 int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
 {
     BDRVQcow2State *s = bs->opaque;
@@ -354,15 +356,15 @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
 
     memset(sn, 0, sizeof(*sn));
 
-    /* Generate an ID */
+    /* Generieren Sie eine ID */
     find_new_snapshot_id(bs, sn_info->id_str, sizeof(sn_info->id_str));
 
-    /* Check that the ID is unique */
+    /* Überprüfen Sie, ob die ID eindeutig ist */
     if (find_snapshot_by_id_and_name(bs, sn_info->id_str, NULL) >= 0) {
         return -EEXIST;
     }
 
-    /* Populate sn with passed data */
+    /* Bestücken sn mit übergebenen Daten */
     sn->id_str = g_strdup(sn_info->id_str);
     sn->name = g_strdup(sn_info->name);
 
@@ -372,7 +374,8 @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
     sn->date_nsec = sn_info->date_nsec;
     sn->vm_clock_nsec = sn_info->vm_clock_nsec;
 
-    /* Allocate the L1 table of the snapshot and copy the current one there. */
+    /* Ordnen Sie die L1-Tabelle des Schnappschusses und kopieren Sie die
+     * aktuelle. */
     l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t));
     if (l1_table_offset < 0) {
         ret = l1_table_offset;
@@ -408,16 +411,16 @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
     l1_table = NULL;
 
     /*
-     * Increase the refcounts of all clusters and make sure everything is
-     * stable on disk before updating the snapshot table to contain a pointer
-     * to the new L1 table.
+     * Erhöhen Sie die Refcounts aller Cluster und stellen Sie sicher, alles
+     * ist stabil auf der Festplatte, bevor Sie den Snapshot-Tabelle zu
+     * aktualisieren einen Zeiger enthalten auf die neue L1-Tabelle.
      */
     ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 1);
     if (ret < 0) {
         goto fail;
     }
 
-    /* Append the new snapshot to the snapshot list */
+    /* Fügen Sie den neuen Snapshot auf die Snapshot-Liste */
     new_snapshot_list = g_new(QCowSnapshot, s->nb_snapshots + 1);
     if (s->snapshots) {
         memcpy(new_snapshot_list, s->snapshots,
@@ -437,8 +440,9 @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
 
     g_free(old_snapshot_list);
 
-    /* The VM state isn't needed any more in the active L1 table; in fact, it
-     * hurts by causing expensive COW for the next snapshot. */
+    /* Der VM-Status ist nicht mehr in der aktiven L1 Tabelle benötigt wird; in
+     * der Tat, es verletzt durch teure KUH für den nächsten Schnappschuss zu
+     * verursachen. */
     qcow2_discard_clusters(bs, qcow2_vm_state_offset(s),
                            align_offset(sn->vm_state_size, s->cluster_size)
                                 >> BDRV_SECTOR_BITS,
@@ -460,7 +464,7 @@ fail:
     return ret;
 }
 
-/* copy the snapshot 'snapshot_name' into the current disk image */
+/* Kopieren Sie den Snapshot 'snapshot_name' in die aktuelle Disk-Image */
 int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
 {
     BDRVQcow2State *s = bs->opaque;
@@ -470,7 +474,7 @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
     int ret;
     uint64_t *sn_l1_table = NULL;
 
-    /* Search the snapshot */
+    /* Suchen Sie den Snapshot */
     snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id);
     if (snapshot_index < 0) {
         return -ENOENT;
@@ -485,9 +489,10 @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
     }
 
     /*
-     * Make sure that the current L1 table is big enough to contain the whole
-     * L1 table of the snapshot. If the snapshot L1 table is smaller, the
-     * current one must be padded with zeros.
+     * Stellen Sie sicher, dass der Strom L1 Tabelle groß genug ist, um das
+     * Ganze zu enthalten L1 Tabelle des Schnappschusses. Wenn der
+     * Snapshot-L1-Tabelle ist kleiner, die Strom muss man mit Nullen
+     * aufgefüllt werden.
      */
     ret = qcow2_grow_l1_table(bs, sn->l1_size, true);
     if (ret < 0) {
@@ -498,12 +503,12 @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
     sn_l1_bytes = sn->l1_size * sizeof(uint64_t);
 
     /*
-     * Copy the snapshot L1 table to the current L1 table.
+     * Kopieren Sie den Snapshot-L1-Tabelle auf den aktuellen L1-Tabelle.
      *
-     * Before overwriting the old current L1 table on disk, make sure to
-     * increase all refcounts for the clusters referenced by the new one.
-     * Decrease the refcount referenced by the old one only when the L1
-     * table is overwritten.
+     * Vor dem Überschreiben der Festplatte des alten Strom L1 Tabelle, stellen
+     * Sie sicher, erhöhen alle Refcounts für die durch den neuen verwiesen
+     * Cluster. Verringern Sie die refcount durch die alte verwiesen nur,
+     * wenn die L1 Tabelle überschrieben.
      */
     sn_l1_table = g_try_malloc0(cur_l1_bytes);
     if (cur_l1_bytes && sn_l1_table == NULL) {
@@ -536,21 +541,22 @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
     }
 
     /*
-     * Decrease refcount of clusters of current L1 table.
+     * Verringern Sie refcount von Clustern von Strom L1-Tabelle.
      *
-     * At this point, the in-memory s->l1_table points to the old L1 table,
-     * whereas on disk we already have the new one.
+     * An diesem Punkt, der In-Memory-s-> l1_table Punkte auf den alten
+     * L1 Tabelle während auf der Festplatte haben wir bereits die neuen.
      *
-     * qcow2_update_snapshot_refcount special cases the current L1 table to use
-     * the in-memory data instead of really using the offset to load a new one,
-     * which is why this works.
+     * qcow2_update_snapshot_refcount besonderen Fällen die aktuelle L1 Tabelle
+     * zu verwenden, die im Speicher befindlichen Daten, anstatt wirklich den
+     * Offset zu laden eine neue Verwendung, weshalb das funktioniert.
      */
     ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset,
                                          s->l1_size, -1);
 
     /*
-     * Now update the in-memory L1 table to be in sync with the on-disk one. We
-     * need to do this even if updating refcounts failed.
+     * Jetzt aktualisieren, um die In-Memory-L1-Tabelle mit der On-Disk eine
+     * vollkommen synchron sein. Wir müssen dies selbst dann, wenn die
+     * Aktualisierung Refcounts nicht getan.
      */
     for(i = 0;i < s->l1_size; i++) {
         s->l1_table[i] = be64_to_cpu(sn_l1_table[i]);
@@ -564,8 +570,8 @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
     sn_l1_table = NULL;
 
     /*
-     * Update QCOW_OFLAG_COPIED in the active L1 table (it may have changed
-     * when we decreased the refcount of the old snapshot.
+     * Update QCOW_OFLAG_COPIED in der aktiven L1-Tabelle (es mag sich geändert
+     * haben wenn wir verringerte die refcount des alten Schnappschuss.
      */
     ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);
     if (ret < 0) {
@@ -594,7 +600,7 @@ int qcow2_snapshot_delete(BlockDriverState *bs,
     QCowSnapshot sn;
     int snapshot_index, ret;
 
-    /* Search the snapshot */
+    /* Suchen Sie den Snapshot */
     snapshot_index = find_snapshot_by_id_and_name(bs, snapshot_id, name);
     if (snapshot_index < 0) {
         error_setg(errp, "Can't find the snapshot");
@@ -602,7 +608,7 @@ int qcow2_snapshot_delete(BlockDriverState *bs,
     }
     sn = s->snapshots[snapshot_index];
 
-    /* Remove it from the snapshot list */
+    /* Entfernen Sie es aus der Snapshot-Liste */
     memmove(s->snapshots + snapshot_index,
             s->snapshots + snapshot_index + 1,
             (s->nb_snapshots - snapshot_index - 1) * sizeof(sn));
@@ -615,15 +621,15 @@ int qcow2_snapshot_delete(BlockDriverState *bs,
     }
 
     /*
-     * The snapshot is now unused, clean up. If we fail after this point, we
-     * won't recover but just leak clusters.
+     * Der Snapshot jetzt ungenutzt ist, aufzuräumen. Wenn wir nicht nach
+     * diesem Punkt, wir wird sich nicht erholen, sondern Cluster auslaufen nur.
      */
     g_free(sn.id_str);
     g_free(sn.name);
 
     /*
-     * Now decrease the refcounts of clusters referenced by the snapshot and
-     * free the L1 table.
+     * Jetzt die Refcounts von Clustern durch Snapshot referenziert verringern
+     * und befreien die L1-Tabelle.
      */
     ret = qcow2_update_snapshot_refcount(bs, sn.l1_table_offset,
                                          sn.l1_size, -1);
@@ -634,7 +640,8 @@ int qcow2_snapshot_delete(BlockDriverState *bs,
     qcow2_free_clusters(bs, sn.l1_table_offset, sn.l1_size * sizeof(uint64_t),
                         QCOW2_DISCARD_SNAPSHOT);
 
-    /* must update the copied flag on the current cluster offsets */
+    /* die kopierte Flagge auf den aktuellen Cluster-Offsets muss aktualisiert
+     * werden */
     ret = qcow2_update_snapshot_refcount(bs, s->l1_table_offset, s->l1_size, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret,
@@ -694,7 +701,7 @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,
 
     assert(bs->read_only);
 
-    /* Search the snapshot */
+    /* Suchen Sie den Snapshot */
     snapshot_index = find_snapshot_by_id_and_name(bs, snapshot_id, name);
     if (snapshot_index < 0) {
         error_setg(errp,
@@ -703,7 +710,7 @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,
     }
     sn = &s->snapshots[snapshot_index];
 
-    /* Allocate and read in the snapshot's L1 table */
+    /* Ordnen und in der Snapshot-L1-Tabelle lesen */
     if (sn->l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {
         error_setg(errp, "Snapshot L1 table too large");
         return -EFBIG;
@@ -723,7 +730,7 @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,
         return ret;
     }
 
-    /* Switch the L1 table */
+    /* Schalten Sie den L1-Tabelle */
     qemu_vfree(s->l1_table);
 
     s->l1_size = sn->l1_size;
diff --git a/block/qcow2.c b/block/qcow2.c
index 056525c..d2aa94b 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -38,19 +38,19 @@
 #include "qemu/cutils.h"
 
 /*
-  Differences with QCOW:
-
-  - Support for multiple incremental snapshots.
-  - Memory management by reference counts.
-  - Clusters which have a reference count of one have the bit
-    QCOW_OFLAG_COPIED to optimize write performance.
-  - Size of compressed clusters is stored in sectors to reduce bit usage
-    in the cluster offsets.
-  - Support for storing additional data (such as the VM state) in the
-    snapshots.
-  - If a backing store is used, the cluster size is not constrained
-    (could be backported to QCOW).
-  - L2 tables have always a size of one cluster.
+  Unterschiede mit qcow:
+
+  - Unterstützung für mehrere inkrementelle Snapshots.
+  - Speicherverwaltung durch Verweis zählt.
+  - Cluster, die einen Referenzzähler ein, haben die Möglichkeit Bit
+    QCOW_OFLAG_COPIED Schreibleistung zu optimieren.
+  - Größe der komprimierten Cluster wird in Sektoren gespeichert Bitverwendung
+    reduzieren in den Cluster-Offsets.
+  - Unterstützung für die Speicherung von zusätzlichen Daten (wie die
+    VM-Zustand) in der Schnappschüsse.
+  - Wenn ein Zusatzspeicher verwendet wird, wird die Clustergröße nicht
+    eingeschränkt (Könnte zu qcow zurückportiert werden).
+  - L2-Tabellen haben immer eine Größe eines Clusters.
 */
 
 
@@ -77,11 +77,12 @@ static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
 
 
 /* 
- * read qcow2 extension and fill bs
- * start reading from start_offset
- * finish reading upon magic of value 0 or when end_offset reached
- * unknown magic is skipped (future extension this version knows nothing about)
- * return 0 upon success, non-0 otherwise
+ * lesen qcow2 Erweiterung und füllen bs
+ * Start von START_OFFSET lesen
+ * Ende lesen auf Magie der Wert 0 oder wenn end_offset erreicht
+ * unbekannt Magie wird übersprungen (zukünftige Erweiterung dieser Version
+ * nichts weiß)
+ * return 0 auf Erfolg, nicht 0 sonst
  */
 static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                                  uint64_t end_offset, void **p_feature_table,
@@ -99,7 +100,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
     while (offset < end_offset) {
 
 #ifdef DEBUG_EXT
-        /* Sanity check */
+        /* Gesundheitsüberprüfung */
         if (offset > s->cluster_size)
             printf("qcow2_read_extension: suspicious offset %lu\n", offset);
 
@@ -162,7 +163,8 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
             break;
 
         default:
-            /* unknown magic - save it in case we need to rewrite the header */
+            /* unbekannt Magie - es für den Fall, speichern wir den Header neu
+             * schreiben müssen */
             {
                 Qcow2UnknownHeaderExtension *uext;
 
@@ -229,11 +231,11 @@ static void report_unsupported_feature(Error **errp, Qcow2Feature *table,
 }
 
 /*
- * Sets the dirty bit and flushes afterwards if necessary.
+ * Setzt das Dirty-Bit und spült danach, wenn nötig.
  *
- * The incompatible_features bit is only set if the image file header was
- * updated successfully.  Therefore it is not required to check the return
- * value of this function.
+ * Das incompatible_features Bit wird nur gesetzt, wenn die Image-Datei-Header
+ * war Erfolgreich geupdated. Daher ist es nicht erforderlich, um die Rückkehr
+ * zu überprüfen Wert dieser Funktion.
  */
 int qcow2_mark_dirty(BlockDriverState *bs)
 {
@@ -244,7 +246,7 @@ int qcow2_mark_dirty(BlockDriverState *bs)
     assert(s->qcow_version >= 3);
 
     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
-        return 0; /* already dirty */
+        return 0; /* bereits verschmutzt */
     }
 
     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
@@ -258,15 +260,16 @@ int qcow2_mark_dirty(BlockDriverState *bs)
         return ret;
     }
 
-    /* Only treat image as dirty if the header was updated successfully */
+    /* Nur behandeln Bild als schmutzig, wenn der Header erfolgreich
+     * aktualisiert wurde */
     s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
     return 0;
 }
 
 /*
- * Clears the dirty bit and flushes before if necessary.  Only call this
- * function when there are no pending requests, it does not guard against
- * concurrent requests dirtying the image.
+ * Löscht das Dirty-Bit und spült vor, wenn nötig. Nur nennen dies
+ * Funktion, wenn es keine ausstehenden Anforderungen sind, ist es schützen
+ * nicht gegen gleichzeitige Anforderungen das Bild zu beschmutzen.
  */
 static int qcow2_mark_clean(BlockDriverState *bs)
 {
@@ -288,7 +291,7 @@ static int qcow2_mark_clean(BlockDriverState *bs)
 }
 
 /*
- * Marks the image as corrupt.
+ * Markiert das Bild als korrupt.
  */
 int qcow2_mark_corrupt(BlockDriverState *bs)
 {
@@ -299,8 +302,8 @@ int qcow2_mark_corrupt(BlockDriverState *bs)
 }
 
 /*
- * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
- * before if necessary.
+ * als konsistent markiert das Bild, das heißt, führt zum Löschen der
+ * beschädigten Bit, und spült vor, falls erforderlich.
  */
 int qcow2_mark_consistent(BlockDriverState *bs)
 {
@@ -342,8 +345,9 @@ static int validate_table_offset(BlockDriverState *bs, uint64_t offset,
     BDRVQcow2State *s = bs->opaque;
     uint64_t size;
 
-    /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
-     * because values will be passed to qemu functions taking int64_t. */
+    /* Verwenden unterzeichnet INT64_MAX als Maximum auch für
+     * uint64_t Header-Felder, weil Werte zu qemu-Funktionen übergeben werden,
+     * wobei int64_t. */
     if (entries > INT64_MAX / entry_len) {
         return -EINVAL;
     }
@@ -354,7 +358,7 @@ static int validate_table_offset(BlockDriverState *bs, uint64_t offset,
         return -EINVAL;
     }
 
-    /* Tables must be cluster aligned */
+    /* Tabellen müssen Cluster ausgerichtet werden */
     if (offset & (s->cluster_size - 1)) {
         return -EINVAL;
     }
@@ -460,7 +464,7 @@ static QemuOptsList qcow2_runtime_opts = {
             .type = QEMU_OPT_NUMBER,
             .help = "Clean unused cache entries after this time (in seconds)",
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     },
 };
 
@@ -608,7 +612,8 @@ static int qcow2_update_options_prepare(BlockDriverState *bs,
         goto fail;
     }
 
-    /* get L2 table/refcount block cache size from command line options */
+    /* L2 Tabelle / refcount Block-Cache-Größe von Kommandozeilenoptionen
+     * erhalten */
     read_cache_sizes(bs, opts, &l2_cache_size, &refcount_cache_size,
                      &local_err);
     if (local_err) {
@@ -637,7 +642,7 @@ static int qcow2_update_options_prepare(BlockDriverState *bs,
         goto fail;
     }
 
-    /* alloc new L2 table/refcount block cache, flush old one */
+    /* alloc neue L2-Tabelle / refcount Block Cache, bündig alte */
     if (s->l2_table_cache) {
         ret = qcow2_cache_flush(bs, s->l2_table_cache);
         if (ret) {
@@ -663,7 +668,7 @@ static int qcow2_update_options_prepare(BlockDriverState *bs,
         goto fail;
     }
 
-    /* New interval for cache cleanup timer */
+    /* New Intervall für die Cache-Bereinigung Timer */
     r->cache_clean_interval =
         qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL,
                             s->cache_clean_interval);
@@ -673,7 +678,7 @@ static int qcow2_update_options_prepare(BlockDriverState *bs,
         goto fail;
     }
 
-    /* lazy-refcounts; flush if going from enabled to disabled */
+    /* lazy-Refcounts; bündig, wenn von behinderten gehen aktiviert */
     r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS,
         (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS));
     if (r->use_lazy_refcounts && s->qcow_version < 3) {
@@ -691,7 +696,7 @@ static int qcow2_update_options_prepare(BlockDriverState *bs,
         }
     }
 
-    /* Overlap check options */
+    /* Overlap Prüfoptionen */
     opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP);
     opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE);
     if (opt_overlap_check_template && opt_overlap_check &&
@@ -725,8 +730,8 @@ static int qcow2_update_options_prepare(BlockDriverState *bs,
 
     r->overlap_check = 0;
     for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) {
-        /* overlap-check defines a template bitmask, but every flag may be
-         * overwritten through the associated boolean option */
+        /* Overlap-Check definiert eine Vorlage bitmask, aber jede Fahne kann
+         * sein, durch die zugehörige boolean Option überschrieben */
         r->overlap_check |=
             qemu_opt_get_bool(opts, overlap_bool_option_names[i],
                               overlap_check_template & (1 << i)) << i;
@@ -848,7 +853,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
 
     s->qcow_version = header.version;
 
-    /* Initialise cluster size */
+    /* Initialisiere Clustergröße */
     if (header.cluster_bits < MIN_CLUSTER_BITS ||
         header.cluster_bits > MAX_CLUSTER_BITS) {
         error_setg(errp, "Unsupported cluster size: 2^%" PRIu32,
@@ -861,7 +866,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
     s->cluster_size = 1 << s->cluster_bits;
     s->cluster_sectors = 1 << (s->cluster_bits - 9);
 
-    /* Initialise version 3 header fields */
+    /* Initialisiere Version 3-Header-Felder */
     if (header.version == 2) {
         header.incompatible_features    = 0;
         header.compatible_features      = 0;
@@ -912,7 +917,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         ext_end = 1 << header.cluster_bits;
     }
 
-    /* Handle feature bits */
+    /* Handle Feature Bits */
     s->incompatible_features    = header.incompatible_features;
     s->compatible_features      = header.compatible_features;
     s->autoclear_features       = header.autoclear_features;
@@ -930,7 +935,8 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
-        /* Corrupt images may not be written to unless they are being repaired
+        /* Corrupt Bilder können nicht geschrieben werden, es sei denn, sie
+         * repariert werden
          */
         if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
             error_setg(errp, "qcow2: Image is corrupt; cannot be opened "
@@ -940,7 +946,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         }
     }
 
-    /* Check support for various header values */
+    /* Überprüfen Sie die Unterstützung für verschiedene Header-Werte */
     if (header.refcount_order > 6) {
         error_setg(errp, "Reference count entry width too large; may not "
                    "exceed 64 bits");
@@ -976,9 +982,9 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         bs->encrypted = 1;
     }
 
-    s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */
+    s->l2_bits = s->cluster_bits - 3; /* L2 ist immer ein Cluster */
     s->l2_size = 1 << s->l2_bits;
-    /* 2^(s->refcount_order - 3) is the refcount width in bytes */
+    /* 2 ^ (s-> refcount_order - 3) ist die refcount Breite in Bytes */
     s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3);
     s->refcount_block_size = 1 << s->refcount_block_bits;
     bs->total_sectors = header.size / 512;
@@ -1003,7 +1009,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    /* Snapshot table offset/length */
+    /* Snapshot-Tabelle Offset / Länge */
     if (header.nb_snapshots > QCOW_MAX_SNAPSHOTS) {
         error_setg(errp, "Too many snapshots");
         ret = -EINVAL;
@@ -1018,7 +1024,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    /* read the level 1 table */
+    /* Lesen Sie die Ebene 1 Tisch */
     if (header.l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {
         error_setg(errp, "Active L1 table too large");
         ret = -EFBIG;
@@ -1034,8 +1040,8 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
     }
     s->l1_vm_state_index = l1_vm_state_index;
 
-    /* the L1 table must contain at least enough entries to put
-       header.size bytes */
+    /* die L1-Tabelle muss mindestens genügend Einträge enthalten setzen
+       header.size Bytes */
     if (s->l1_size < s->l1_vm_state_index) {
         error_setg(errp, "L1 table is too small");
         ret = -EINVAL;
@@ -1070,14 +1076,14 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         }
     }
 
-    /* Parse driver-specific options */
+    /* Parse treiberspezifischen Optionen */
     ret = qcow2_update_options(bs, options, flags, errp);
     if (ret < 0) {
         goto fail;
     }
 
     s->cluster_cache = g_malloc(s->cluster_size);
-    /* one more sector for decompressed data alignment */
+    /* ein weiterer Sektor für die Ausrichtung dekomprimiert Daten */
     s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
                                                     * s->cluster_size + 512);
     if (s->cluster_data == NULL) {
@@ -1098,7 +1104,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
     QLIST_INIT(&s->cluster_allocs);
     QTAILQ_INIT(&s->discards);
 
-    /* read qcow2 extensions */
+    /* lesen qcow2 Erweiterungen */
     if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL,
         &local_err)) {
         error_propagate(errp, local_err);
@@ -1106,7 +1112,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    /* read the backing file name */
+    /* Lesen Sie die Unterstützung Dateinamen */
     if (header.backing_file_offset != 0) {
         len = header.backing_file_size;
         if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
@@ -1125,7 +1131,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         s->image_backing_file = g_strdup(bs->backing_file);
     }
 
-    /* Internal snapshots */
+    /* Interne Schnappschüsse */
     s->snapshots_offset = header.snapshots_offset;
     s->nb_snapshots = header.nb_snapshots;
 
@@ -1135,7 +1141,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    /* Clear unknown autoclear feature bits */
+    /* Klar unbekannt AUTOCLEAR- Feature Bits */
     if (!bs->read_only && !(flags & BDRV_O_INACTIVE) && s->autoclear_features) {
         s->autoclear_features = 0;
         ret = qcow2_update_header(bs);
@@ -1145,10 +1151,10 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         }
     }
 
-    /* Initialise locks */
+    /* Initialisiere Schlösser */
     qemu_co_mutex_init(&s->lock);
 
-    /* Repair image if dirty */
+    /* Reparatur Bild, wenn sie verschmutzt */
     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
         (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {
         BdrvCheckResult result = {0};
@@ -1174,7 +1180,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
     qcow2_free_snapshots(bs);
     qcow2_refcount_close(bs);
     qemu_vfree(s->l1_table);
-    /* else pre-write overlap checks in cache_destroy may crash */
+    /* sonst vorgeSchreib Überlappung Kontrollen in cache_destroy abstürzen */
     s->l1_table = NULL;
     cache_clean_timer_del(bs);
     if (s->l2_table_cache) {
@@ -1206,8 +1212,8 @@ static int qcow2_set_key(BlockDriverState *bs, const char *key)
     len = strlen(key);
     if (len > 16)
         len = 16;
-    /* XXX: we could compress the chars to 7 bits to increase
-       entropy */
+    /* XXX: wir konnten die Zeichen auf 7 Bit komprimieren zu erhöhen
+       Entropie */
     for(i = 0;i < len;i++) {
         keybuf[i] = key[i];
     }
@@ -1221,9 +1227,9 @@ static int qcow2_set_key(BlockDriverState *bs, const char *key)
         &err);
 
     if (!s->cipher) {
-        /* XXX would be nice if errors in this method could
-         * be properly propagate to the caller. Would need
-         * the bdrv_set_key() API signature to be fixed. */
+        /* XXX wäre schön, wenn Fehler in diesem Verfahren könnte
+         * werden richtig an den Aufrufer propagieren. Würde brauchen
+         * die bdrv_set_key () API Signatur festgelegt werden. */
         error_free(err);
         return -1;
     }
@@ -1245,7 +1251,8 @@ static int qcow2_reopen_prepare(BDRVReopenState *state,
         goto fail;
     }
 
-    /* We need to write out any unwritten data if we reopen read-only. */
+    /* Wir müssen alle ungeschriebenen Daten schreiben, wenn wir
+     * schreibgeschützt wieder öffnen. */
     if ((state->flags & BDRV_O_RDWR) == 0) {
         ret = bdrv_flush(state->bs);
         if (ret < 0) {
@@ -1287,7 +1294,8 @@ static void qcow2_join_options(QDict *options, QDict *old_options)
         qdict_haskey(options, QCOW2_OPT_CACHE_SIZE);
     bool has_all_cache_options;
 
-    /* New overlap template overrides all old overlap options */
+    /* Vorlage New Überlappung überschreibt alle alten
+     * Überlappungsoptionen */
     if (has_new_overlap_template) {
         qdict_del(old_options, QCOW2_OPT_OVERLAP);
         qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE);
@@ -1301,7 +1309,7 @@ static void qcow2_join_options(QDict *options, QDict *old_options)
         qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2);
     }
 
-    /* New total cache size overrides all old options */
+    /* Neue Gesamtcachegröße überschreibt alle alten Optionen */
     if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) {
         qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE);
         qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
@@ -1310,9 +1318,10 @@ static void qcow2_join_options(QDict *options, QDict *old_options)
     qdict_join(options, old_options, false);
 
     /*
-     * If after merging all cache size options are set, an old total size is
-     * overwritten. Do keep all options, however, if all three are new. The
-     * resulting error message is what we want to happen.
+     * Wenn nach dem alle Cache-Größe Optionen fusionieren, eine alte
+     * Gesamtgröße ist überschrieben. Bewahren Sie alle Optionen, aber wenn
+     * alle drei neu sind. Das Fehlermeldung resultiert, ist, was wir wollen
+     * passieren.
      */
     has_all_cache_options =
         qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) ||
@@ -1355,7 +1364,7 @@ static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
     return status;
 }
 
-/* handle reading after the end of the backing file */
+/* Griff nach dem Ende der Trägerdatei gelesen */
 int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
                   int64_t sector_num, int nb_sectors)
 {
@@ -1378,7 +1387,7 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
     BDRVQcow2State *s = bs->opaque;
     int index_in_cluster, n1;
     int ret;
-    int cur_nr_sectors; /* number of sectors in current iteration */
+    int cur_nr_sectors; /* Anzahl der Sektoren in der aktuellen Iteration */
     uint64_t cluster_offset = 0;
     uint64_t bytes_done = 0;
     QEMUIOVector hd_qiov;
@@ -1390,7 +1399,7 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
 
     while (remaining_sectors != 0) {
 
-        /* prepare next request */
+        /* Vorbereitung nächste Anfrage */
         cur_nr_sectors = remaining_sectors;
         if (s->cipher) {
             cur_nr_sectors = MIN(cur_nr_sectors,
@@ -1413,7 +1422,7 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
         case QCOW2_CLUSTER_UNALLOCATED:
 
             if (bs->backing) {
-                /* read from the base image */
+                /* lesen aus dem Basisbild */
                 n1 = qcow2_backing_read1(bs->backing->bs, &hd_qiov,
                     sector_num, cur_nr_sectors);
                 if (n1 > 0) {
@@ -1436,7 +1445,7 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
                     }
                 }
             } else {
-                /* Note: in this case, no need to wait */
+                /* Hinweis: in diesem Fall keine Notwendigkeit, warten */
                 qemu_iovec_memset(&hd_qiov, 0, 0, 512 * cur_nr_sectors);
             }
             break;
@@ -1446,7 +1455,7 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
             break;
 
         case QCOW2_CLUSTER_COMPRESSED:
-            /* add AIO support for compressed blocks ? */
+            /* hinzufügen AIO Unterstützung für komprimierte Blöcke? */
             ret = qcow2_decompress_cluster(bs, cluster_offset);
             if (ret < 0) {
                 goto fail;
@@ -1467,8 +1476,9 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
                 assert(s->cipher);
 
                 /*
-                 * For encrypted images, read everything into a temporary
-                 * contiguous buffer on which the AES functions can work.
+                 * Für verschlüsselte Bilder, lesen Sie alles in eine
+                 * temporäre zusammenhängenden Puffer, auf denen die
+                 * AES Funktionen arbeiten können.
                  */
                 if (!cluster_data) {
                     cluster_data =
@@ -1541,7 +1551,7 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
     BDRVQcow2State *s = bs->opaque;
     int index_in_cluster;
     int ret;
-    int cur_nr_sectors; /* number of sectors in current iteration */
+    int cur_nr_sectors; /* Anzahl der Sektoren in der aktuellen Iteration */
     uint64_t cluster_offset;
     QEMUIOVector hd_qiov;
     uint64_t bytes_done = 0;
@@ -1553,7 +1563,7 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
 
     qemu_iovec_init(&hd_qiov, qiov->niov);
 
-    s->cluster_cache_offset = -1; /* disable compressed cache */
+    s->cluster_cache_offset = -1; /* deaktivieren komprimierten Cache */
 
     qemu_co_mutex_lock(&s->lock);
 
@@ -1640,7 +1650,7 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
                 goto fail;
             }
 
-            /* Take the request off the list of running requests */
+            /* Nehmen Sie die Anfrage von der Liste der laufenden Anfragen */
             if (l2meta->nb_clusters != 0) {
                 QLIST_REMOVE(l2meta, next_in_flight);
             }
@@ -1712,7 +1722,7 @@ static void qcow2_close(BlockDriverState *bs)
 {
     BDRVQcow2State *s = bs->opaque;
     qemu_vfree(s->l1_table);
-    /* else pre-write overlap checks in cache_destroy may crash */
+    /* sonst vorgeSchreib Überlappung Kontrollen in cache_destroy abstürzen */
     s->l1_table = NULL;
 
     if (!(s->flags & BDRV_O_INACTIVE)) {
@@ -1748,8 +1758,9 @@ static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
     int ret;
 
     /*
-     * Backing files are read-only which makes all of their metadata immutable,
-     * that means we don't have to worry about reopening them here.
+     * Sichern von Dateien sind schreibgeschützt, die alle ihre Metadaten
+     * unveränderlich macht, das bedeutet, dass wir sie hier nicht über die
+     * Wiedereröffnung zu kümmern.
      */
 
     cipher = s->cipher;
@@ -1804,12 +1815,13 @@ static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
 }
 
 /*
- * Updates the qcow2 header, including the variable length parts of it, i.e.
- * the backing file name and all extensions. qcow2 was not designed to allow
- * such changes, so if we run out of space (we can only use the first cluster)
- * this function may fail.
+ * Aktualisiert die qcow2 Header, einschließlich der variablen Länge Teile
+ * davon, das heißt die Trägerdateinamen und alle Erweiterungen. qcow2 wurde,
+ * nicht zuzulassen, entworfen solche Veränderungen, so dass, wenn wir aus
+ * dem Raum laufen (wir können nur den ersten Cluster verwenden)
+ * Diese Funktion kann fehlschlagen.
  *
- * Returns 0 on success, -errno in error cases.
+ * Gibt 0 zurück, bei Erfolg, -errno in Fehlerfällen.
  */
 int qcow2_update_header(BlockDriverState *bs)
 {
@@ -1825,7 +1837,7 @@ int qcow2_update_header(BlockDriverState *bs)
 
     buf = qemu_blockalign(bs, buflen);
 
-    /* Header structure */
+    /* Header-Struktur */
     header = (QCowHeader*) buf;
 
     if (buflen < sizeof(*header)) {
@@ -1838,7 +1850,7 @@ int qcow2_update_header(BlockDriverState *bs)
     refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);
 
     *header = (QCowHeader) {
-        /* Version 2 fields */
+        /* Version 2 Felder */
         .magic                  = cpu_to_be32(QCOW_MAGIC),
         .version                = cpu_to_be32(s->qcow_version),
         .backing_file_offset    = 0,
@@ -1853,7 +1865,7 @@ int qcow2_update_header(BlockDriverState *bs)
         .nb_snapshots           = cpu_to_be32(s->nb_snapshots),
         .snapshots_offset       = cpu_to_be64(s->snapshots_offset),
 
-        /* Version 3 fields */
+        /* Version 3 Felder */
         .incompatible_features  = cpu_to_be64(s->incompatible_features),
         .compatible_features    = cpu_to_be64(s->compatible_features),
         .autoclear_features     = cpu_to_be64(s->autoclear_features),
@@ -1861,7 +1873,7 @@ int qcow2_update_header(BlockDriverState *bs)
         .header_length          = cpu_to_be32(header_length),
     };
 
-    /* For older versions, write a shorter header */
+    /* Für ältere Versionen, schreiben Sie eine kürzere Kopf */
     switch (s->qcow_version) {
     case 2:
         ret = offsetof(QCowHeader, incompatible_features);
@@ -1878,7 +1890,7 @@ int qcow2_update_header(BlockDriverState *bs)
     buflen -= ret;
     memset(buf, 0, buflen);
 
-    /* Preserve any unknown field in the header */
+    /* Bewahren Sie alle unbekannten Feld im Kopf */
     if (s->unknown_header_fields_size) {
         if (buflen < s->unknown_header_fields_size) {
             ret = -ENOSPC;
@@ -1890,7 +1902,7 @@ int qcow2_update_header(BlockDriverState *bs)
         buflen -= s->unknown_header_fields_size;
     }
 
-    /* Backing file format header extension */
+    /* Sichern Dateiformat Header-Erweiterung */
     if (s->image_backing_format) {
         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
                              s->image_backing_format,
@@ -1904,7 +1916,7 @@ int qcow2_update_header(BlockDriverState *bs)
         buflen -= ret;
     }
 
-    /* Feature table */
+    /* Feature-Tabelle */
     if (s->qcow_version >= 3) {
         Qcow2Feature features[] = {
             {
@@ -1933,7 +1945,7 @@ int qcow2_update_header(BlockDriverState *bs)
         buflen -= ret;
     }
 
-    /* Keep unknown header extensions */
+    /* Halten Sie unbekannte Header-Erweiterungen */
     QLIST_FOREACH(uext, &s->unknown_header_ext, next) {
         ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen);
         if (ret < 0) {
@@ -1944,7 +1956,7 @@ int qcow2_update_header(BlockDriverState *bs)
         buflen -= ret;
     }
 
-    /* End of header extensions */
+    /* Ende der Header-Erweiterungen */
     ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
     if (ret < 0) {
         goto fail;
@@ -1953,7 +1965,7 @@ int qcow2_update_header(BlockDriverState *bs)
     buf += ret;
     buflen -= ret;
 
-    /* Backing file name */
+    /* Sichern Dateinamen */
     if (s->image_backing_file) {
         size_t backing_file_len = strlen(s->image_backing_file);
 
@@ -1962,14 +1974,14 @@ int qcow2_update_header(BlockDriverState *bs)
             goto fail;
         }
 
-        /* Using strncpy is ok here, since buf is not NUL-terminated. */
+        /* strncpy verwenden ist hier ok, da buf nicht NUL-terminiert. */
         strncpy(buf, s->image_backing_file, buflen);
 
         header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
         header->backing_file_size   = cpu_to_be32(backing_file_len);
     }
 
-    /* Write the new header */
+    /* Schreiben Sie den neuen Header */
     ret = bdrv_pwrite(bs->file->bs, 0, header, s->cluster_size);
     if (ret < 0) {
         goto fail;
@@ -2028,24 +2040,25 @@ static int preallocate(BlockDriverState *bs)
                 return ret;
             }
 
-            /* There are no dependent requests, but we need to remove our
-             * request from the list of in-flight requests */
+            /* Es gibt keine abhängigen Anfragen, aber wir müssen unsere
+             * entfernen fordern von der Liste der in-flight-Anfragen */
             QLIST_REMOVE(meta, next_in_flight);
 
             g_free(meta);
             meta = next;
         }
 
-        /* TODO Preallocate data if requested */
+        /* TODO vorbelegen Daten auf Wunsch */
 
         nb_sectors -= num;
         offset += num << BDRV_SECTOR_BITS;
     }
 
     /*
-     * It is expected that the image file is large enough to actually contain
-     * all of the allocated clusters (otherwise we get failing reads after
-     * EOF). Extend the image to the last allocated sector.
+     * Es wird erwartet, dass die Bilddatei groß genug ist eigentlich zu
+     * enthalten alle zugewiesenen Cluster (sonst bekommen wir andernfalls
+     * liest nach EOF). Erweitern Sie das Bild in den letzten zugewiesenen
+     * Sektor.
      */
     if (host_offset != 0) {
         uint8_t buf[BDRV_SECTOR_SIZE];
@@ -2070,7 +2083,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,
     int cluster_bits;
     QDict *options;
 
-    /* Calculate cluster_bits */
+    /* Berechnen Cluster-Bits */
     cluster_bits = ctz32(cluster_size);
     if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
         (1 << cluster_bits) != cluster_size)
@@ -2081,16 +2094,16 @@ static int qcow2_create2(const char *filename, int64_t total_size,
     }
 
     /*
-     * Open the image file and write a minimal qcow2 header.
+     * Öffnen Sie die Bilddatei und schreiben einen minimalen qcow2-Header.
      *
-     * We keep things simple and start with a zero-sized image. We also
-     * do without refcount blocks or a L1 table for now. We'll fix the
-     * inconsistency later.
+     * Wir halten die Dinge einfach und mit einer Null-Größe Bild starten.
+     * Wir ... auch tun, ohne refcount Blöcke oder L1-Tabelle für den Moment.
+     * Wir werden das beheben später Inkonsistenz.
      *
-     * We do need a refcount table because growing the refcount table means
-     * allocating two new refcount blocks - the seconds of which would be at
-     * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
-     * size for any qcow2 image.
+     * Wir haben eine refcount Tisch brauchen, weil die refcount Tabellenmittel
+     * wächst zwei neue refcount Blöcke Aufteilung - die Sekunden davon wäre
+     * bei 2 GB für 64k-Cluster, und wir wollen nicht, eine 2 GB ursprüngliche
+     * Datei zu haben, Größe für qcow2 Bild.
      */
     BlockBackend *blk;
     QCowHeader *header;
@@ -2099,58 +2112,60 @@ static int qcow2_create2(const char *filename, int64_t total_size,
     int ret;
 
     if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
-        /* Note: The following calculation does not need to be exact; if it is a
-         * bit off, either some bytes will be "leaked" (which is fine) or we
-         * will need to increase the file size by some bytes (which is fine,
-         * too, as long as the bulk is allocated here). Therefore, using
-         * floating point arithmetic is fine. */
+        /* Hinweis: Die folgende Berechnung nicht genau zu sein braucht; wenn
+         * es ein biss, entweder einige Bytes "durchgesickert" wird (was in
+         * Ordnung ist), oder wir müssen Sie die Dateigröße von einigen Bytes
+         * zu erhöhen (was in Ordnung ist, zu, solange die Masse wird hier
+         * zugeordnet). Daher ist die Verwendung Gleitpunktarithmetik ist in
+         * Ordnung. */
         int64_t meta_size = 0;
         uint64_t nreftablee, nrefblocke, nl1e, nl2e;
         int64_t aligned_total_size = align_offset(total_size, cluster_size);
         int refblock_bits, refblock_size;
-        /* refcount entry size in bytes */
+        /* refcount Eintrag Größe in Byte */
         double rces = (1 << refcount_order) / 8.;
 
-        /* see qcow2_open() */
+        /* siehe qcow2_open () */
         refblock_bits = cluster_bits - (refcount_order - 3);
         refblock_size = 1 << refblock_bits;
 
-        /* header: 1 cluster */
+        /* Header: 1 Cluster */
         meta_size += cluster_size;
 
-        /* total size of L2 tables */
+        /* Gesamtgröße des L2-Tabellen */
         nl2e = aligned_total_size / cluster_size;
         nl2e = align_offset(nl2e, cluster_size / sizeof(uint64_t));
         meta_size += nl2e * sizeof(uint64_t);
 
-        /* total size of L1 tables */
+        /* Gesamtgröße von L1 Tabellen */
         nl1e = nl2e * sizeof(uint64_t) / cluster_size;
         nl1e = align_offset(nl1e, cluster_size / sizeof(uint64_t));
         meta_size += nl1e * sizeof(uint64_t);
 
-        /* total size of refcount blocks
+        /* Gesamtgröße von refcount Blöcke
          *
-         * note: every host cluster is reference-counted, including metadata
-         * (even refcount blocks are recursively included).
-         * Let:
-         *   a = total_size (this is the guest disk size)
-         *   m = meta size not including refcount blocks and refcount tables
-         *   c = cluster size
-         *   y1 = number of refcount blocks entries
-         *   y2 = meta size including everything
-         *   rces = refcount entry size in bytes
-         * then,
-         *   y1 = (y2 + a)/c
-         *   y2 = y1 * rces + y1 * rces * sizeof(u64) / c + m
-         * we can get y1:
-         *   y1 = (a + m) / (c - rces - rces * sizeof(u64) / c)
+         * Hinweis: Jeder Host-Cluster ist Referenz gezählt, einschließlich
+         * Metadaten (Auch refcount Blöcke werden rekursiv enthalten).
+         * Lassen:
+         *   a = total_size (dies ist die Größe Gast Platte)
+         *   m = Meta-Größe nicht einschließlich refcount Blöcke und
+         *       refcount Tabellen
+         *   c = Clustergröße
+         *   y1 = Anzahl der Blöcke refcount entries
+         *   y2 = meta Größe einschließlich alles
+         *   RCEs = refcount Eintrag Größe in Byte
+         * dann,
+         *   y1 = (y2 + a) / c
+         *   y2 = y1 * RCEs + y1 * RCEs * sizeof (u64) / c + m
+         * wir können y1 erhalten:
+         *   y1 = (a + m) / (c - RCEs - RCEs * sizeof (U64) / c)
          */
         nrefblocke = (aligned_total_size + meta_size + cluster_size)
                    / (cluster_size - rces - rces * sizeof(uint64_t)
                                                  / cluster_size);
         meta_size += DIV_ROUND_UP(nrefblocke, refblock_size) * cluster_size;
 
-        /* total size of refcount tables */
+        /* Gesamtgröße von refcount Tabellen */
         nreftablee = nrefblocke / refblock_size;
         nreftablee = align_offset(nreftablee, cluster_size / sizeof(uint64_t));
         meta_size += nreftablee * sizeof(uint64_t);
@@ -2176,7 +2191,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,
 
     blk_set_allow_write_beyond_eof(blk, true);
 
-    /* Write the header */
+    /* Schreiben Sie den Header */
     QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header));
     header = g_malloc0(cluster_size);
     *header = (QCowHeader) {
@@ -2210,7 +2225,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,
         goto out;
     }
 
-    /* Write a refcount table with one refcount block */
+    /* Schreiben Sie einen refcount Tisch mit einem refcount Block */
     refcount_table = g_malloc0(2 * cluster_size);
     refcount_table[0] = cpu_to_be64(2 * cluster_size);
     ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size);
@@ -2225,9 +2240,9 @@ static int qcow2_create2(const char *filename, int64_t total_size,
     blk = NULL;
 
     /*
-     * And now open the image and make it consistent first (i.e. increase the
-     * refcount of the cluster that is occupied by the header and the refcount
-     * table)
+     * Und nun das Bild öffnen, und es im Einklang ersten machen (das heißt
+     * die Erhöhung refcount des Clusters, die von dem Header und dem refcount
+     * besetzt ist Tabelle)
      */
     options = qdict_new();
     qdict_put(options, "driver", qstring_from_str("qcow2"));
@@ -2250,21 +2265,23 @@ static int qcow2_create2(const char *filename, int64_t total_size,
         abort();
     }
 
-    /* Create a full header (including things like feature table) */
+    /* Erstellen Sie einen vollständigen Header (einschließlich solcher Dinge
+     * wie Feature-Tabelle) */
     ret = qcow2_update_header(blk_bs(blk));
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not update qcow2 header");
         goto out;
     }
 
-    /* Okay, now that we have a valid image, let's give it the right size */
+    /* Okay, jetzt, da wir ein gültiges Bild haben, lassen Sie uns es die
+     * richtige Größe geben */
     ret = blk_truncate(blk, total_size);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not resize image");
         goto out;
     }
 
-    /* Want a backing file? There you go.*/
+    /* Möchten Sie eine Trägerdatei? Dort gehen Sie.*/
     if (backing_file) {
         ret = bdrv_change_backing_file(blk_bs(blk), backing_file, backing_format);
         if (ret < 0) {
@@ -2274,7 +2291,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,
         }
     }
 
-    /* And if we're supposed to preallocate metadata, do that now */
+    /* Und wenn wir angeblich sind Metadaten vorab zuzuordnen, das jetzt tun */
     if (prealloc != PREALLOC_MODE_OFF) {
         BDRVQcow2State *s = blk_bs(blk)->opaque;
         qemu_co_mutex_lock(&s->lock);
@@ -2289,7 +2306,8 @@ static int qcow2_create2(const char *filename, int64_t total_size,
     blk_unref(blk);
     blk = NULL;
 
-    /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */
+    /* Öffnen Sie erneut das Bild ohne BDRV_O_NO_FLUSH es zu spülen vor der
+     * Rückkehr */
     options = qdict_new();
     qdict_put(options, "driver", qstring_from_str("qcow2"));
     blk = blk_new_open(filename, NULL, options,
@@ -2323,7 +2341,7 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
     Error *local_err = NULL;
     int ret;
 
-    /* Read out options */
+    /* Vorlesen Optionen */
     size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
                     BDRV_SECTOR_SIZE);
     backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
@@ -2345,7 +2363,7 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
     g_free(buf);
     buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL);
     if (!buf) {
-        /* keep the default */
+        /* behalten Sie die Standardeinstellung */
     } else if (!strcmp(buf, "0.10")) {
         version = 2;
     } else if (!strcmp(buf, "1.1")) {
@@ -2413,12 +2431,12 @@ static coroutine_fn int qcow2_co_write_zeroes(BlockDriverState *bs,
     int ret;
     BDRVQcow2State *s = bs->opaque;
 
-    /* Emulate misaligned zero writes */
+    /* Emulieren falsch ausgerichtet Null schreibt */
     if (sector_num % s->cluster_sectors || nb_sectors % s->cluster_sectors) {
         return -ENOTSUP;
     }
 
-    /* Whatever is left can use real zero clusters */
+    /* Was auch immer können echte Null-Cluster links verwenden */
     qemu_co_mutex_lock(&s->lock);
     ret = qcow2_zero_clusters(bs, sector_num << BDRV_SECTOR_BITS,
         nb_sectors);
@@ -2451,13 +2469,13 @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
         return -EINVAL;
     }
 
-    /* cannot proceed if image has snapshots */
+    /* kann nicht fortgesetzt werden, wenn Bildschnappschüsse hat */
     if (s->nb_snapshots) {
         error_report("Can't resize an image which has snapshots");
         return -ENOTSUP;
     }
 
-    /* shrinking is currently not supported */
+    /* Schrumpfen wird derzeit nicht unterstützt */
     if (offset < bs->total_sectors * 512) {
         error_report("qcow2 doesn't support shrinking images yet");
         return -ENOTSUP;
@@ -2469,7 +2487,7 @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
         return ret;
     }
 
-    /* write updated header.size */
+    /* schreiben aktualisiert header.size */
     offset = cpu_to_be64(offset);
     ret = bdrv_pwrite_sync(bs->file->bs, offsetof(QCowHeader, size),
                            &offset, sizeof(uint64_t));
@@ -2481,8 +2499,8 @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
     return 0;
 }
 
-/* XXX: put compressed sectors first, then all the cluster aligned
-   tables to avoid losing bytes in alignment */
+/* XXX: Put-Druck Sektoren zuerst, dann das ganze Cluster ausgerichtet
+   Tabellen zu vermeiden Bytes in Ausrichtung zu verlieren */
 static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
                                   const uint8_t *buf, int nb_sectors)
 {
@@ -2493,8 +2511,8 @@ static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
     uint64_t cluster_offset;
 
     if (nb_sectors == 0) {
-        /* align end of file to a sector boundary to ease reading with
-           sector based I/Os */
+        /* Ende der Datei an einer Sektorgrenze auszurichten erleichtern das
+           Lesen Sektor basierend I / Os */
         cluster_offset = bdrv_getlength(bs->file->bs);
         return bdrv_truncate(bs->file->bs, cluster_offset);
     }
@@ -2502,7 +2520,8 @@ static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
     if (nb_sectors != s->cluster_sectors) {
         ret = -EINVAL;
 
-        /* Zero-pad last write if image size is not cluster aligned */
+        /* Null-Pad letzte Schreib, wenn die Bildgröße ist nicht ausgerichtet
+         * Cluster */
         if (sector_num + nb_sectors == bs->total_sectors &&
             nb_sectors < s->cluster_sectors) {
             uint8_t *pad_buf = qemu_blockalign(bs, s->cluster_size);
@@ -2517,7 +2536,7 @@ static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
 
     out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
 
-    /* best compression, small window, no zlib header */
+    /* beste Kompression, kleine Fenster, keine zlib-Header */
     memset(&strm, 0, sizeof(strm));
     ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
                        Z_DEFLATED, -12,
@@ -2543,7 +2562,7 @@ static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
     deflateEnd(&strm);
 
     if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
-        /* could not compress: write normal cluster */
+        /* komprimieren konnte nicht: Schreiben normalen Cluster */
         ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors);
         if (ret < 0) {
             goto fail;
@@ -2598,7 +2617,7 @@ static int make_completely_empty(BlockDriverState *bs)
         goto fail;
     }
 
-    /* Refcounts will be broken utterly */
+    /* Refcounts wird völlig gebrochen werden */
     ret = qcow2_mark_dirty(bs);
     if (ret < 0) {
         goto fail;
@@ -2609,8 +2628,8 @@ static int make_completely_empty(BlockDriverState *bs)
     l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t));
     l1_size2 = (uint64_t)s->l1_size * sizeof(uint64_t);
 
-    /* After this call, neither the in-memory nor the on-disk refcount
-     * information accurately describe the actual references */
+    /* Nach diesem Aufruf weder die im Speicher noch die On-Disk-refcount
+     * Informationen genau die aktuellen Referenzen beschreiben */
 
     ret = bdrv_write_zeroes(bs->file->bs, s->l1_table_offset / BDRV_SECTOR_SIZE,
                             l1_clusters * s->cluster_sectors, 0);
@@ -2621,18 +2640,19 @@ static int make_completely_empty(BlockDriverState *bs)
 
     BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE);
 
-    /* Overwrite enough clusters at the beginning of the sectors to place
-     * the refcount table, a refcount block and the L1 table in; this may
-     * overwrite parts of the existing refcount and L1 table, which is not
-     * an issue because the dirty flag is set, complete data loss is in fact
-     * desired and partial data loss is consequently fine as well */
+    /* Überschreiben genug Cluster am Anfang der Sektoren zu platzieren
+     * die refcount Tisch, ein refcount Block und der L1-Tabelle in; das
+     * vielleicht überschreiben Teile des bestehenden refcount und L1-Tabelle,
+     * die nicht ist ein Problem, weil das schmutzige Flag gesetzt ist,
+     * kompletten Datenverlust ist in der Tat Soll- und Teildatenverlust ist
+     * somit auch gut */
     ret = bdrv_write_zeroes(bs->file->bs, s->cluster_size / BDRV_SECTOR_SIZE,
                             (2 + l1_clusters) * s->cluster_size /
                             BDRV_SECTOR_SIZE, 0);
-    /* This call (even if it failed overall) may have overwritten on-disk
-     * refcount structures; in that case, the in-memory refcount information
-     * will probably differ from the on-disk information which makes the BDS
-     * unusable */
+    /* Dieser Aufruf (auch wenn es insgesamt nicht) haben auf der Festplatte
+     * überschrieben refcount Strukturen; in diesem Fall kann die im Speicher
+     * refcount Informationen wird wahrscheinlich von der
+     * On-Disk Informationen, die den über BDS macht unbrauchbar */
     if (ret < 0) {
         goto fail_broken_refcounts;
     }
@@ -2640,9 +2660,10 @@ static int make_completely_empty(BlockDriverState *bs)
     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
     BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE);
 
-    /* "Create" an empty reftable (one cluster) directly after the image
-     * header and an empty L1 table three clusters after the image header;
-     * the cluster between those two will be used as the first refblock */
+    /* "Create" ein leeres refTable (ein Cluster) direkt nach dem Bild
+     * Header und eine leere L1 Tabelle drei Cluster nach dem Bild-Header;
+     * der Cluster zwischen diesen beiden wird als erste refblock verwendet
+     * werden */
     cpu_to_be64w(&l1_ofs_rt_ofs_cls.l1_offset, 3 * s->cluster_size);
     cpu_to_be64w(&l1_ofs_rt_ofs_cls.reftable_offset, s->cluster_size);
     cpu_to_be32w(&l1_ofs_rt_ofs_cls.reftable_clusters, 1);
@@ -2667,15 +2688,16 @@ static int make_completely_empty(BlockDriverState *bs)
     s->refcount_table = new_reftable;
     new_reftable = NULL;
 
-    /* Now the in-memory refcount information again corresponds to the on-disk
-     * information (reftable is empty and no refblocks (the refblock cache is
-     * empty)); however, this means some clusters (e.g. the image header) are
-     * referenced, but not refcounted, but the normal qcow2 code assumes that
-     * the in-memory information is always correct */
+    /* Nun ist die In-Memory-refcount Informationen entspricht wieder dem
+     * On-Disk Informationen (refTable leer ist und keine refblocks (der
+     * refblock Cache ist leer)); jedoch bedeutet dies einige Cluster
+     * (beispielsweise das Bild-Header) sind Bezug genommen wird, aber nicht
+     * refcounted, aber der normale qcow2 Code geht davon aus, dass die
+     * In-Memory-Daten immer korrekt */
 
     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
 
-    /* Enter the first refblock into the reftable */
+    /* Geben Sie den ersten refblock in die refTable */
     rt_entry = cpu_to_be64(2 * s->cluster_size);
     ret = bdrv_pwrite_sync(bs->file->bs, s->cluster_size,
                            &rt_entry, sizeof(rt_entry));
@@ -2695,8 +2717,8 @@ static int make_completely_empty(BlockDriverState *bs)
         abort();
     }
 
-    /* Now finally the in-memory information corresponds to the on-disk
-     * structures and is correct */
+    /* Nun endlich die im Speicher entspricht Information an die auf der
+     * Festplatte Strukturen und ist richtig */
     ret = qcow2_mark_clean(bs);
     if (ret < 0) {
         goto fail;
@@ -2710,12 +2732,13 @@ static int make_completely_empty(BlockDriverState *bs)
     return 0;
 
 fail_broken_refcounts:
-    /* The BDS is unusable at this point. If we wanted to make it usable, we
-     * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
-     * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
-     * again. However, because the functions which could have caused this error
-     * path to be taken are used by those functions as well, it's very likely
-     * that that sequence will fail as well. Therefore, just eject the BDS. */
+    /* Der BDS ist an dieser Stelle unbrauchbar. Wenn wir wollten, es nutzbar zu
+     * machen, wir hätte qcow2_refcount_close (), qcow2_refcount_init () zu
+     * nennen, qcow2_check_refcounts (), qcow2_refcount_close () und
+     * qcow2_refcount_init () aufs Neue. Da jedoch die Funktionen, die diesen
+     * Fehler verursacht haben könnte Pfad zu werden, als auch von den
+     * Funktionen genommen, ist es sehr wahrscheinlich, dass diese Sequenz wird
+     * auch scheitern. Daher auswerfen nur die BDS. */
     bs->drv = NULL;
 
 fail:
@@ -2734,24 +2757,25 @@ static int qcow2_make_empty(BlockDriverState *bs)
 
     if (s->qcow_version >= 3 && !s->snapshots &&
         3 + l1_clusters <= s->refcount_block_size) {
-        /* The following function only works for qcow2 v3 images (it requires
-         * the dirty flag) and only as long as there are no snapshots (because
-         * it completely empties the image). Furthermore, the L1 table and three
-         * additional clusters (image header, refcount table, one refcount
-         * block) have to fit inside one refcount block. */
+        /* Die folgende Funktion ist nur für qcow2 v3 Bilder (es erfordert
+         * das schmutzige Flagge) und nur so lange, wie es keine Schnappschüsse
+         * (weil es leert sich das Bild vollständig). Weiterhin ist die
+         * L1-Tabelle und drei zusätzliche Cluster (Bild-Header,
+         * refcount Tisch, ein refcount * Block) haben innerhalb eines
+         * refcount Block zu passen. */
         return make_completely_empty(bs);
     }
 
-    /* This fallback code simply discards every active cluster; this is slow,
-     * but works in all cases */
+    /* Dieser Rückfall Code einfach verwirft alle aktiven Cluster; Dies ist
+     * langsam, funktioniert aber in allen Fällen */
     for (start_sector = 0; start_sector < bs->total_sectors;
          start_sector += sector_step)
     {
-        /* As this function is generally used after committing an external
-         * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
-         * default action for this kind of discard is to pass the discard,
-         * which will ideally result in an actually smaller image file, as
-         * is probably desired. */
+        /* Da diese Funktion wird nach der Begehung einer externen allgemein
+         * verwendet Schnappschuss, scheint QCOW2_DISCARD_SNAPSHOT angemessen.
+         * Auch der Standardaktion für diese Art von Ablage ist der Ablage
+         * passieren, die idealerweise in einem tatsächlich kleinere Bilddatei
+         * zur Folge haben, wie ist wahrscheinlich erwünscht. */
         ret = qcow2_discard_clusters(bs, start_sector * BDRV_SECTOR_SIZE,
                                      MIN(sector_step,
                                          bs->total_sectors - start_sector),
@@ -2824,8 +2848,9 @@ static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs)
             .refcount_bits      = s->refcount_bits,
         };
     } else {
-        /* if this assertion fails, this probably means a new version was
-         * added without having it covered here */
+        /* wenn diese Behauptung fehlschlägt, bedeutet dies wahrscheinlich
+         * eine neue Version war hinzugefügt, ohne dass es hier behandelt zu
+         * haben */
         assert(false);
     }
 
@@ -2866,9 +2891,9 @@ static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
     ret = bdrv_pwritev(bs, qcow2_vm_state_offset(s) + pos, qiov);
     bs->zero_beyond_eof = zero_beyond_eof;
 
-    /* bdrv_co_do_writev will have increased the total_sectors value to include
-     * the VM state - the VM state is however not an actual part of the block
-     * device, therefore, we need to restore the old value. */
+    /* bdrv_co_do_writev den total_sectors Wert enthalten haben zugenommen
+     * die VM-Status - die VM-Status ist jedoch kein tatsächlicher Teil des
+     * Blockgeräts, daher müssen wir den alten Wert wiederherzustellen. */
     bs->total_sectors = total_sectors;
 
     return ret;
@@ -2890,8 +2915,8 @@ static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,
 }
 
 /*
- * Downgrades an image's version. To achieve this, any incompatible features
- * have to be removed.
+ * Herabstufungen eines Bildes Version. Um dies zu erreichen, werden alle
+ * inkompatible Funktionen muss entfernt werden.
  */
 static int qcow2_downgrade(BlockDriverState *bs, int target_version,
                            BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
@@ -2913,7 +2938,7 @@ static int qcow2_downgrade(BlockDriverState *bs, int target_version,
         return -ENOTSUP;
     }
 
-    /* clear incompatible features */
+    /* klar inkompatible Funktionen */
     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
         ret = qcow2_mark_clean(bs);
         if (ret < 0) {
@@ -2921,20 +2946,21 @@ static int qcow2_downgrade(BlockDriverState *bs, int target_version,
         }
     }
 
-    /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
-     * the first place; if that happens nonetheless, returning -ENOTSUP is the
-     * best thing to do anyway */
+    /* mit QCOW2_INCOMPAT_CORRUPT, ist es ziemlich unmöglich, hier zu bekommen
+     * den ersten Platz; wenn dies dennoch geschieht, ist Rückkehr -ENOTSUP die
+     * Beste, was zu tun sowieso */
 
     if (s->incompatible_features) {
         return -ENOTSUP;
     }
 
-    /* since we can ignore compatible features, we can set them to 0 as well */
+    /* da wir kompatiblen Funktionen ignorieren können, können wir sie auf 0
+     * gesetzt und */
     s->compatible_features = 0;
-    /* if lazy refcounts have been used, they have already been fixed through
-     * clearing the dirty flag */
+    /* wenn faul Refcounts verwendet wurden, haben sie bereits festgelegt
+     * worden durch Löschen der schmutzige Flagge */
 
-    /* clearing autoclear features is trivial */
+    /* AUTOCLEAR- Funktionen Clearing ist trivial */
     s->autoclear_features = 0;
 
     ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque);
@@ -2952,9 +2978,9 @@ static int qcow2_downgrade(BlockDriverState *bs, int target_version,
 }
 
 typedef enum Qcow2AmendOperation {
-    /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
-     * statically initialized to so that the helper CB can discern the first
-     * invocation from an operation change */
+    /* Dies ist der Wert Qcow2AmendHelperCBInfo :: last_operation wird
+     * statisch initialisiert, so dass die Helfer CB die erste erkennen kann
+     * Aufruf von einer Operation ändern */
     QCOW2_NO_OPERATION = 0,
 
     QCOW2_CHANGING_REFCOUNT_ORDER,
@@ -2962,22 +2988,22 @@ typedef enum Qcow2AmendOperation {
 } Qcow2AmendOperation;
 
 typedef struct Qcow2AmendHelperCBInfo {
-    /* The code coordinating the amend operations should only modify
-     * these four fields; the rest will be managed by the CB */
+    /* Der Code der Operationen ändern zu koordinieren sollte nur ändern
+     * diese vier Felder; der Rest wird von der CB verwaltet */
     BlockDriverAmendStatusCB *original_status_cb;
     void *original_cb_opaque;
 
     Qcow2AmendOperation current_operation;
 
-    /* Total number of operations to perform (only set once) */
+    /* Gesamtzahl der Operationen auszuführen (nur einmal festgelegt) */
     int total_operations;
 
-    /* The following fields are managed by the CB */
+    /* Die folgenden Felder werden von der CB verwaltet */
 
-    /* Number of operations completed */
+    /* Anzahl der Operationen abgeschlossen */
     int operations_completed;
 
-    /* Cumulative offset of all completed operations */
+    /* Kumulative aller abgeschlossenen Operationen Offset */
     int64_t offset_completed;
 
     Qcow2AmendOperation last_operation;
@@ -3008,10 +3034,11 @@ static void qcow2_amend_helper_cb(BlockDriverState *bs,
 
     current_work_size = info->offset_completed + operation_work_size;
 
-    /* current_work_size is the total work size for (operations_completed + 1)
-     * operations (which includes this one), so multiply it by the number of
-     * operations not covered and divide it by the number of operations
-     * covered to get a projection for the operations not covered */
+    /* current_work_size ist die Gesamtarbeitsgröße für
+     * (operations_completed + 1) Operationen (einschließlich dieser)
+     * multiplizieren, so dass es durch die Anzahl der Operationen nicht
+     * abgedeckt und teilen sich durch die Anzahl der Operationen bedeckt
+     * einen Vorsprung für die Operationen nicht zu bekommen bedeckt */
     projected_work_size = current_work_size * (info->total_operations -
                                                info->operations_completed - 1)
                                             / (info->operations_completed + 1);
@@ -3040,7 +3067,7 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
 
     while (desc && desc->name) {
         if (!qemu_opt_find(opts, desc->name)) {
-            /* only change explicitly defined options */
+            /* ändern, dass nur explizit definierte Optionen */
             desc++;
             continue;
         }
@@ -3048,7 +3075,7 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
         if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) {
             compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
             if (!compat) {
-                /* preserve default */
+                /* bewahren Standard */
             } else if (!strcmp(compat, "0.10")) {
                 new_version = 2;
             } else if (!strcmp(compat, "1.1")) {
@@ -3096,8 +3123,9 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
                 return -EINVAL;
             }
         } else {
-            /* if this point is reached, this probably means a new option was
-             * added without having it covered here */
+            /* Wenn dieser Punkt erreicht ist, bedeutet dies wahrscheinlich eine
+             * neue Option war hinzugefügt, ohne dass es hier behandelt zu
+             * haben */
             abort();
         }
 
@@ -3111,7 +3139,8 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
                           + (s->refcount_bits != refcount_bits)
     };
 
-    /* Upgrade first (some features may require compat=1.1) */
+    /* Aktualisieren Sie zuerst (Einige Funktionen erfordern möglicherweise
+     * compat = 1.1) */
     if (new_version > old_version) {
         s->qcow_version = new_version;
         ret = qcow2_update_header(bs);
@@ -3166,12 +3195,12 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
             }
             s->use_lazy_refcounts = true;
         } else {
-            /* make image clean first */
+            /* machen Bild sauber zuerst */
             ret = qcow2_mark_clean(bs);
             if (ret < 0) {
                 return ret;
             }
-            /* now disallow lazy refcounts */
+            /* jetzt nicht zulassen faul Refcounts */
             s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
             ret = qcow2_update_header(bs);
             if (ret < 0) {
@@ -3189,7 +3218,8 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
         }
     }
 
-    /* Downgrade last (so unsupported features can be removed before) */
+    /* Herunterstufung zuletzt (so nicht unterstützten Funktionen können,
+     * bevor sie entfernt werden) */
     if (new_version < old_version) {
         helper_cb_info.current_operation = QCOW2_DOWNGRADING;
         ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb,
@@ -3203,10 +3233,10 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
 }
 
 /*
- * If offset or size are negative, respectively, they will not be included in
- * the BLOCK_IMAGE_CORRUPTED event emitted.
- * fatal will be ignored for read-only BDS; corruptions found there will always
- * be considered non-fatal.
+ * Wenn Offset oder Größe negativ sind bzw. werden sie nicht einbezogen
+ * die BLOCK_IMAGE_CORRUPTED Ereignis emittiert.
+ * fatal für Nur-Lese-BDS ignoriert werden; Verfälschungen dort zu finden
+ * wird immer werden als nicht tödlich.
  */
 void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
                              int64_t size, const char *message_format, ...)
@@ -3246,7 +3276,7 @@ void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
 
     if (fatal) {
         qcow2_mark_corrupt(bs);
-        bs->drv = NULL; /* make BDS unusable */
+        bs->drv = NULL; /* machen BDS unbrauchbar */
     }
 
     s->signaled_corruption = true;
@@ -3306,7 +3336,7 @@ static QemuOptsList qcow2_create_opts = {
             .help = "Width of a reference count entry in bits",
             .def_value_str = "16"
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     }
 };
 
diff --git a/block/qcow2.h b/block/qcow2.h
index a063a3c..9ca88e2 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -40,40 +40,42 @@
 #define QCOW_MAX_CRYPT_CLUSTERS 32
 #define QCOW_MAX_SNAPSHOTS 65536
 
-/* 8 MB refcount table is enough for 2 PB images at 64k cluster size
- * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */
+/* 8 MB refcount Tabelle ist ausreichend für 2 PB Bilder bei 64k Clustergröße
+ * (128 GB für 512-Byte-Cluster, 2 EB für 2 MB Cluster) */
 #define QCOW_MAX_REFTABLE_SIZE 0x800000
 
-/* 32 MB L1 table is enough for 2 PB images at 64k cluster size
- * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */
+/* 32 MB L1 Tabelle ist ausreichend für 2 PB Bilder bei 64k Clustergröße
+ * (128 GB für 512-Byte-Cluster, 2 EB für 2 MB Cluster) */
 #define QCOW_MAX_L1_SIZE 0x2000000
 
-/* Allow for an average of 1k per snapshot table entry, should be plenty of
- * space for snapshot names and IDs */
+/* Lassen Sie für einen Durchschnitt von 1k pro Snapshot-Tabelleneintrag,
+ * sollte viel sein Platz für Snapshot-Namen und IDs */
 #define QCOW_MAX_SNAPSHOTS_SIZE (1024 * QCOW_MAX_SNAPSHOTS)
 
-/* indicate that the refcount of the referenced cluster is exactly one. */
+/* zeigen, dass die refcount des referenzierten Cluster genau eins ist. */
 #define QCOW_OFLAG_COPIED     (1ULL << 63)
-/* indicate that the cluster is compressed (they never have the copied flag) */
+/* zeigen, dass der Cluster komprimiert wird (sie haben nie die kopierte
+ * Flagge) */
 #define QCOW_OFLAG_COMPRESSED (1ULL << 62)
-/* The cluster reads as all zeros */
+/* Der Cluster lautet wie Nullen */
 #define QCOW_OFLAG_ZERO (1ULL << 0)
 
 #define MIN_CLUSTER_BITS 9
 #define MAX_CLUSTER_BITS 21
 
-/* Must be at least 2 to cover COW */
-#define MIN_L2_CACHE_SIZE 2 /* clusters */
+/* Muss mindestens 2 sein COW abzudecken */
+#define MIN_L2_CACHE_SIZE 2 /* Cluster */
 
-/* Must be at least 4 to cover all cases of refcount table growth */
-#define MIN_REFCOUNT_CACHE_SIZE 4 /* clusters */
+/* Es muss mindestens 4 sein, alle Fälle von refcount Tabelle Wachstum zu
+ * decken */
+#define MIN_REFCOUNT_CACHE_SIZE 4 /* Cluster */
 
-/* Whichever is more */
-#define DEFAULT_L2_CACHE_CLUSTERS 8 /* clusters */
-#define DEFAULT_L2_CACHE_BYTE_SIZE 1048576 /* bytes */
+/* Unabhängig davon, welche mehr */
+#define DEFAULT_L2_CACHE_CLUSTERS 8 /* Cluster */
+#define DEFAULT_L2_CACHE_BYTE_SIZE 1048576 /* Bytes */
 
-/* The refblock cache needs only a fourth of the L2 cache size to cover as many
- * clusters */
+/* Der refblock Cache benötigt nur ein Viertel des L2-Cache-Größe so viele
+ * zur Deckung Cluster */
 #define DEFAULT_L2_REFCOUNT_SIZE_RATIO 4
 
 #define DEFAULT_CLUSTER_SIZE 65536
@@ -104,16 +106,16 @@ typedef struct QCowHeader {
     uint64_t backing_file_offset;
     uint32_t backing_file_size;
     uint32_t cluster_bits;
-    uint64_t size; /* in bytes */
+    uint64_t size; /* in Bytes */
     uint32_t crypt_method;
-    uint32_t l1_size; /* XXX: save number of clusters instead ? */
+    uint32_t l1_size; /* XXX: statt Anzahl der Cluster speichern? */
     uint64_t l1_table_offset;
     uint64_t refcount_table_offset;
     uint32_t refcount_table_clusters;
     uint32_t nb_snapshots;
     uint64_t snapshots_offset;
 
-    /* The following fields are only valid for version >= 3 */
+    /* Die folgenden Felder sind nur gültig für Version> = 3 */
     uint64_t incompatible_features;
     uint64_t compatible_features;
     uint64_t autoclear_features;
@@ -123,7 +125,7 @@ typedef struct QCowHeader {
 } QEMU_PACKED QCowHeader;
 
 typedef struct QEMU_PACKED QCowSnapshotHeader {
-    /* header is 8 byte aligned */
+    /* Header ist 8 Byte ausgerichtet */
     uint64_t l1_table_offset;
 
     uint32_t l1_size;
@@ -136,10 +138,10 @@ typedef struct QEMU_PACKED QCowSnapshotHeader {
     uint64_t vm_clock_nsec;
 
     uint32_t vm_state_size;
-    uint32_t extra_data_size; /* for extension */
-    /* extra data follows */
-    /* id_str follows */
-    /* name follows  */
+    uint32_t extra_data_size; /* für Erweiterung */
+    /* zusätzliche Daten folgt */
+    /* id_str folgt */
+    /* Name folgt  */
 } QCowSnapshotHeader;
 
 typedef struct QEMU_PACKED QCowSnapshotExtraData {
@@ -176,7 +178,7 @@ enum {
     QCOW2_FEAT_TYPE_AUTOCLEAR       = 2,
 };
 
-/* Incompatible feature bits */
+/* Inkompatible Feature Bits */
 enum {
     QCOW2_INCOMPAT_DIRTY_BITNR   = 0,
     QCOW2_INCOMPAT_CORRUPT_BITNR = 1,
@@ -187,7 +189,7 @@ enum {
                                  | QCOW2_INCOMPAT_CORRUPT,
 };
 
-/* Compatible feature bits */
+/* Kompatibel Feature Bits */
 enum {
     QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR = 0,
     QCOW2_COMPAT_LAZY_REFCOUNTS       = 1 << QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
@@ -256,7 +258,8 @@ typedef struct BDRVQcow2State {
 
     CoMutex lock;
 
-    QCryptoCipher *cipher; /* current cipher, NULL if no key yet */
+    /* Stromchiffre, NULL, wenn kein Schlüssel vorhanden */
+    QCryptoCipher *cipher;
     uint32_t crypt_method_header;
     uint64_t snapshots_offset;
     int snapshots_size;
@@ -275,7 +278,7 @@ typedef struct BDRVQcow2State {
 
     bool discard_passthrough[QCOW2_DISCARD_MAX];
 
-    int overlap_check; /* bitmask of Qcow2MetadataOverlap values */
+    int overlap_check; /* bitmask von Qcow2MetadataOverlap Werte */
     bool signaled_corruption;
 
     uint64_t incompatible_features;
@@ -288,64 +291,64 @@ typedef struct BDRVQcow2State {
     QTAILQ_HEAD (, Qcow2DiscardRegion) discards;
     bool cache_discards;
 
-    /* Backing file path and format as stored in the image (this is not the
-     * effective path/format, which may be the result of a runtime option
-     * override) */
+    /* Sichern Dateipfad und Format wie in dem Bild gespeichert (dies ist nicht
+     * das ist effektive Weg / Format, das das Ergebnis einer Runtime-Option
+     * sein kann gekröpft) */
     char *image_backing_file;
     char *image_backing_format;
 } BDRVQcow2State;
 
 typedef struct Qcow2COWRegion {
     /**
-     * Offset of the COW region in bytes from the start of the first cluster
-     * touched by the request.
+     * Offset der COW-Region in Bytes vom Anfang des ersten Clusters
+     * durch die Anforderung berührt.
      */
     uint64_t    offset;
 
-    /** Number of sectors to copy */
+    /** Anzahl der Sektoren zu kopieren */
     int         nb_sectors;
 } Qcow2COWRegion;
 
 /**
- * Describes an in-flight (part of a) write request that writes to clusters
- * that are not referenced in their L2 table yet.
+ * Beschreibt ein in-flight (Teil eines) Schreibanforderung, die an Cluster
+ * schreibt, die noch nicht in ihrer L2 Tabelle verwiesen.
  */
 typedef struct QCowL2Meta
 {
-    /** Guest offset of the first newly allocated cluster */
+    /** Gast Offset des ersten neu zugewiesenen Cluster */
     uint64_t offset;
 
-    /** Host offset of the first newly allocated cluster */
+    /** Host-Offset neu des ersten zugewiesenen Cluster */
     uint64_t alloc_offset;
 
     /**
-     * Number of sectors from the start of the first allocated cluster to
-     * the end of the (possibly shortened) request
+     * Anzahl von Sektoren vom Beginn des ersten zugewiesenen Cluster
+     * das Ende der (möglicherweise gekürzt) Anfrage
      */
     int nb_available;
 
-    /** Number of newly allocated clusters */
+    /** Anzahl der neu zugewiesenen Cluster */
     int nb_clusters;
 
     /**
-     * Requests that overlap with this allocation and wait to be restarted
-     * when the allocating request has completed.
+     * Anfrangen, die mit dieser Zuordnung überlappen, und darauf warten, neu
+     * gestartet zu werden, wenn die Zuteilungsanforderung abgeschlossen ist.
      */
     CoQueue dependent_requests;
 
     /**
-     * The COW Region between the start of the first allocated cluster and the
-     * area the guest actually writes to.
+     * Die Kuh Region zwischen dem Beginn des ersten zugewiesenen Cluster und
+     * die Gebiet der Gast tatsächlich schreibt.
      */
     Qcow2COWRegion cow_start;
 
     /**
-     * The COW Region between the area the guest actually writes to and the
-     * end of the last allocated cluster.
+     * Die Kuh Region zwischen dem Bereich der Gast schreibt tatsächlich und
+     * der Ende des letzten zugeordneten Cluster.
      */
     Qcow2COWRegion cow_end;
 
-    /** Pointer to next L2Meta of the same write request */
+    /** Zeiger auf das nächste L2Meta der gleichen Schreibanforderung */
     struct QCowL2Meta *next;
 
     QLIST_ENTRY(QCowL2Meta) next_in_flight;
@@ -378,22 +381,24 @@ typedef enum QCow2MetadataOverlap {
     QCOW2_OL_REFCOUNT_BLOCK = (1 << QCOW2_OL_REFCOUNT_BLOCK_BITNR),
     QCOW2_OL_SNAPSHOT_TABLE = (1 << QCOW2_OL_SNAPSHOT_TABLE_BITNR),
     QCOW2_OL_INACTIVE_L1    = (1 << QCOW2_OL_INACTIVE_L1_BITNR),
-    /* NOTE: Checking overlaps with inactive L2 tables will result in bdrv
-     * reads. */
+    /* HINWEIS: Überprüfen überlappt mit inaktiven L2 Tabellen führt in BDRV
+     * liest. */
     QCOW2_OL_INACTIVE_L2    = (1 << QCOW2_OL_INACTIVE_L2_BITNR),
 } QCow2MetadataOverlap;
 
-/* Perform all overlap checks which can be done in constant time */
+/* Führen Sie alle Überschneidungen überprüft, die in konstanter Zeit
+ * durchgeführt werden kann */
 #define QCOW2_OL_CONSTANT \
     (QCOW2_OL_MAIN_HEADER | QCOW2_OL_ACTIVE_L1 | QCOW2_OL_REFCOUNT_TABLE | \
      QCOW2_OL_SNAPSHOT_TABLE)
 
-/* Perform all overlap checks which don't require disk access */
+/* Führen Sie alle Überlappungsprüfungen, die keine Plattenzugriff
+ * erfordern */
 #define QCOW2_OL_CACHED \
     (QCOW2_OL_CONSTANT | QCOW2_OL_ACTIVE_L2 | QCOW2_OL_REFCOUNT_BLOCK | \
      QCOW2_OL_INACTIVE_L1)
 
-/* Perform all overlap checks */
+/* Führen Sie alle Überlappungsprüfungen */
 #define QCOW2_OL_ALL \
     (QCOW2_OL_CACHED | QCOW2_OL_INACTIVE_L2)
 
@@ -458,7 +463,7 @@ static inline int qcow2_get_cluster_type(uint64_t l2_entry)
     }
 }
 
-/* Check whether refcounts are eager or lazy */
+/* Überprüfen Sie, ob Refcounts sind gespannt oder faul */
 static inline bool qcow2_need_accurate_refcounts(BDRVQcow2State *s)
 {
     return !(s->incompatible_features & QCOW2_INCOMPAT_DIRTY);
@@ -482,7 +487,7 @@ static inline uint64_t refcount_diff(uint64_t r1, uint64_t r2)
 
 // FIXME Need qcow2_ prefix to global functions
 
-/* qcow2.c functions */
+/* qcow2.c Funktionen */
 int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
                   int64_t sector_num, int nb_sectors);
 
@@ -495,7 +500,7 @@ void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
                              int64_t size, const char *message_format, ...)
                              GCC_FMT_ATTR(5, 6);
 
-/* qcow2-refcount.c functions */
+/* qcow2-refcount.c Funktionen */
 int qcow2_refcount_init(BlockDriverState *bs);
 void qcow2_refcount_close(BlockDriverState *bs);
 
@@ -533,7 +538,7 @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
                                 BlockDriverAmendStatusCB *status_cb,
                                 void *cb_opaque, Error **errp);
 
-/* qcow2-cluster.c functions */
+/* qcow2-cluster.c Funktionen */
 int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
                         bool exact_size);
 int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index);
@@ -560,7 +565,7 @@ int qcow2_expand_zero_clusters(BlockDriverState *bs,
                                BlockDriverAmendStatusCB *status_cb,
                                void *cb_opaque);
 
-/* qcow2-snapshot.c functions */
+/* qcow2-snapshot.c Funktionen */
 int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info);
 int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id);
 int qcow2_snapshot_delete(BlockDriverState *bs,
@@ -576,7 +581,7 @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,
 void qcow2_free_snapshots(BlockDriverState *bs);
 int qcow2_read_snapshots(BlockDriverState *bs);
 
-/* qcow2-cache.c functions */
+/* qcow2-cache.c Funktionen */
 Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables);
 int qcow2_cache_destroy(BlockDriverState* bs, Qcow2Cache *c);
 
diff --git a/block/raw-aio.h b/block/raw-aio.h
index 811e375..77183b4 100644
--- a/block/raw-aio.h
+++ b/block/raw-aio.h
@@ -17,7 +17,7 @@
 
 #include "qemu/iov.h"
 
-/* AIO request types */
+/* AIO Anforderungstypen */
 #define QEMU_AIO_READ         0x0001
 #define QEMU_AIO_WRITE        0x0002
 #define QEMU_AIO_IOCTL        0x0004
@@ -28,12 +28,12 @@
         (QEMU_AIO_READ|QEMU_AIO_WRITE|QEMU_AIO_IOCTL|QEMU_AIO_FLUSH| \
          QEMU_AIO_DISCARD|QEMU_AIO_WRITE_ZEROES)
 
-/* AIO flags */
+/* AIO-Flags */
 #define QEMU_AIO_MISALIGNED   0x1000
 #define QEMU_AIO_BLKDEV       0x2000
 
 
-/* linux-aio.c - Linux native implementation */
+/* linux-aio.c - Linux native Implementierung */
 #ifdef CONFIG_LINUX_AIO
 void *laio_init(void);
 void laio_cleanup(void *s);
diff --git a/block/raw-posix.c b/block/raw-posix.c
index 906d5c9..2f72c8e 100644
--- a/block/raw-posix.c
+++ b/block/raw-posix.c
@@ -65,7 +65,7 @@
 #include <asm/dasd.h>
 #endif
 #ifndef FS_NOCOW_FL
-#define FS_NOCOW_FL                     0x00800000 /* Do not cow file */
+#define FS_NOCOW_FL                     0x00800000 /* Nicht Kuh-Datei */
 #endif
 #endif
 #if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
@@ -112,7 +112,7 @@ do { \
     } \
 } while (0)
 
-/* OS X does not have O_DSYNC */
+/* OS X nicht über O_DSYNC */
 #ifndef O_DSYNC
 #ifdef O_SYNC
 #define O_DSYNC O_SYNC
@@ -121,7 +121,7 @@ do { \
 #endif
 #endif
 
-/* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
+/* Ungefähre O_DIRECT mit O_DSYNC wenn O_DIRECT nicht verfügbar ist */
 #ifndef O_DIRECT
 #define O_DIRECT O_DSYNC
 #endif
@@ -171,7 +171,7 @@ typedef struct RawPosixAIOData {
     };
     int aio_niov;
     uint64_t aio_nbytes;
-#define aio_ioctl_cmd   aio_nbytes /* for QEMU_AIO_IOCTL */
+#define aio_ioctl_cmd   aio_nbytes /* für QEMU_AIO_IOCTL */
     off_t aio_offset;
     int aio_type;
 } RawPosixAIOData;
@@ -219,7 +219,8 @@ static int raw_normalize_devicepath(const char **filename)
 #endif
 
 /*
- * Get logical block size via ioctl. On success store it in @sector_size_p.
+ * Erhalten logische Blockgröße über ioctl. Bei Erfolg speichern Sie es in
+ * @sector_size_p.
  */
 static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
 {
@@ -228,7 +229,7 @@ static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
 
     errno = ENOTSUP;
 
-    /* Try a few ioctls to get the right size */
+    /* Probieren Sie ein paar ioctls die richtige Größe zu bekommen */
 #ifdef BLKSSZGET
     if (ioctl(fd, BLKSSZGET, &sector_size) >= 0) {
         *sector_size_p = sector_size;
@@ -252,9 +253,9 @@ static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
 }
 
 /**
- * Get physical block size of @fd.
- * On success, store it in @blk_size and return 0.
- * On failure, return -errno.
+ * Erhalten Sie physischen Blockgröße von @fd.
+ * Bei Erfolg, sollte sie in @blk_size und 0 zurück.
+ * Bei einem Fehler Rückkehr -errno.
  */
 static int probe_physical_blocksize(int fd, unsigned int *blk_size)
 {
@@ -268,9 +269,11 @@ static int probe_physical_blocksize(int fd, unsigned int *blk_size)
 #endif
 }
 
-/* Check if read is allowed with given memory buffer and length.
+/* Überprüfen Sie, ob gelesen wird mit bestimmten Speicherpuffer und Länge
+ * erlaubt.
  *
- * This function is used to check O_DIRECT memory buffer and request alignment.
+ * Mit dieser Funktion wird O_DIRECT Speicherpuffer und Anforderung Ausrichtung
+ * zu prüfen.
  */
 static bool raw_is_io_aligned(int fd, void *buf, size_t len)
 {
@@ -281,9 +284,10 @@ static bool raw_is_io_aligned(int fd, void *buf, size_t len)
     }
 
 #ifdef __linux__
-    /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads.  Ignore
-     * other errors (e.g. real I/O error), which could happen on a failed
-     * drive, since we only care about probing alignment.
+    /* Der Linux-Kernel gibt EINVAL für falsch ausgerichtete O_DIRECT liest.
+     * Ignorieren andere Fehler (z reale I / O-Fehler), die auf einem
+     * ausgefallenen passieren könnte fahren, da wir über Sondieren
+     * Ausrichtung nur kümmern.
      */
     if (errno != EINVAL) {
         return true;
@@ -299,8 +303,8 @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
     char *buf;
     size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
 
-    /* For SCSI generic devices the alignment is not really used.
-       With buffered I/O, we don't have any restrictions. */
+    /* Für allgemeine SCSI-Geräten ist die Ausrichtung nicht wirklich genutzt.
+       Mit I buffered / O, haben wir keine Einschränkungen. */
     if (bdrv_is_sg(bs) || !s->needs_alignment) {
         bs->request_alignment = 1;
         s->buf_align = 1;
@@ -309,7 +313,8 @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
 
     bs->request_alignment = 0;
     s->buf_align = 0;
-    /* Let's try to use the logical blocksize for the alignment. */
+    /* Lassen Sie uns versuchen, die logische Blockgröße für die Ausrichtung
+     * zu verwenden. */
     if (probe_logical_blocksize(fd, &bs->request_alignment) < 0) {
         bs->request_alignment = 0;
     }
@@ -318,13 +323,14 @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
         struct dioattr da;
         if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {
             bs->request_alignment = da.d_miniosz;
-            /* The kernel returns wrong information for d_mem */
-            /* s->buf_align = da.d_mem; */
+            /* Der Kernel gibt falsche Informationen für d_mem */
+            /* s-> buf_align = da.d_mem; */
         }
     }
 #endif
 
-    /* If we could not get the sizes so far, we can only guess them */
+    /* Wenn wir nicht die Größen so weit kommen konnte, können wir sie nur
+     * vermuten, */
     if (!s->buf_align) {
         size_t align;
         buf = qemu_memalign(max_align, 2 * max_align);
@@ -367,8 +373,8 @@ static void raw_parse_flags(int bdrv_flags, int *open_flags)
         *open_flags |= O_RDONLY;
     }
 
-    /* Use O_DSYNC for write-through caching, no flags for write-back caching,
-     * and O_DIRECT for no caching. */
+    /* Verwenden Sie O_DSYNC für Write-Through-Caching, Flaggen nicht für
+     * Write-Back-Caching, und O_DIRECT ohne Caching. */
     if ((bdrv_flags & BDRV_O_NOCACHE)) {
         *open_flags |= O_DIRECT;
     }
@@ -404,13 +410,13 @@ static int raw_set_aio(void **aio_ctx, int *use_aio, int bdrv_flags)
     assert(aio_ctx != NULL);
     assert(use_aio != NULL);
     /*
-     * Currently Linux do AIO only for files opened with O_DIRECT
-     * specified so check NOCACHE flag too
+     * Linux tun AIO Zur Zeit nur für Dateien mit O_DIRECT geöffnet
+     * angegeben, so überprüfen zu NOCACHE Flagge
      */
     if ((bdrv_flags & (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) ==
                       (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) {
 
-        /* if non-NULL, laio_init() has already been run */
+        /* wenn nicht NULL, laio_init () bereits ausgeführt wurde */
         if (*aio_ctx == NULL) {
             *aio_ctx = laio_init();
             if (!*aio_ctx) {
@@ -432,9 +438,9 @@ error:
 static void raw_parse_filename(const char *filename, QDict *options,
                                Error **errp)
 {
-    /* The filename does not have to be prefixed by the protocol name, since
-     * "file" is the default protocol; therefore, the return value of this
-     * function call can be ignored. */
+    /* Der Dateiname muss nicht durch den Protokollnamen vorangestellt werden,
+     * da "File" ist das Standardprotokoll; daher der Rückgabewert dieser
+     * Funktionsaufruf kann ignoriert werden. */
     strstart(filename, "file:", &filename);
 
     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
@@ -449,7 +455,7 @@ static QemuOptsList raw_runtime_opts = {
             .type = QEMU_OPT_STRING,
             .help = "File name of the image",
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     },
 };
 
@@ -513,7 +519,7 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
         ret = -EINVAL;
         goto fail;
     }
-#endif /* !defined(CONFIG_LINUX_AIO) */
+#endif /* ! Definiert (CONFIG_LINUX_AIO) */
 
     s->has_discard = true;
     s->has_write_zeroes = true;
@@ -538,9 +544,10 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
         }
 #endif
 #ifdef __linux__
-        /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache.  Do
-         * not rely on the contents of discarded blocks unless using O_DIRECT.
-         * Same for BLKZEROOUT.
+        /* Unter Linux 3.10, verlässt BLKDISCARD veraltete Daten in den
+         * Seiten-Cache. Machen nicht auf den Inhalt der Blöcke verworfen
+         * verlassen O_DIRECT sofern nicht verwenden. Das Gleiche gilt für
+         * BLKZEROOUT.
          */
         if (!(bs->open_flags & BDRV_O_NOCACHE)) {
             s->discard_zeroes = false;
@@ -551,10 +558,11 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
 #ifdef __FreeBSD__
     if (S_ISCHR(st.st_mode)) {
         /*
-         * The file is a char device (disk), which on FreeBSD isn't behind
-         * a pager, so force all requests to be aligned. This is needed
-         * so QEMU makes sure all IO operations on the device are aligned
-         * to sector size, or else FreeBSD will reject them with EINVAL.
+         * Die Datei ist eine char-Gerät (Disk), die auf FreeBSD ist nicht
+         * hinter ein Pager, zwingen so alle Anforderungen ausgerichtet werden.
+         * Dies ist erforderlich, so macht QEMU sicher, dass alle
+         * IO-Operationen auf dem Gerät ausgerichtet sind In den Sektorgröße
+         * oder auch FreeBSD wird sie mit EINVAL ablehnen.
          */
         s->needs_alignment = true;
     }
@@ -611,9 +619,10 @@ static int raw_reopen_prepare(BDRVReopenState *state,
 #ifdef CONFIG_LINUX_AIO
     raw_s->use_aio = s->use_aio;
 
-    /* we can use s->aio_ctx instead of a copy, because the use_aio flag is
-     * valid in the 'false' condition even if aio_ctx is set, and raw_set_aio()
-     * won't override aio_ctx if aio_ctx is non-NULL */
+    /* können wir verwenden s-> aio_ctx statt einer Kopie, weil die use_aio
+     * Flag gültig in der "falschen" Zustand, auch wenn aio_ctx gesetzt ist,
+     * und raw_set_aio () nicht außer Kraft setzen, wenn aio_ctx aio_ctx nicht
+     * NULL ist */
     if (raw_set_aio(&s->aio_ctx, &raw_s->use_aio, state->flags)) {
         error_setg(errp, "Could not set AIO state");
         return -1;
@@ -634,17 +643,18 @@ static int raw_reopen_prepare(BDRVReopenState *state,
 #endif
 
 #ifdef O_ASYNC
-    /* Not all operating systems have O_ASYNC, and those that don't
-     * will not let us track the state into raw_s->open_flags (typically
-     * you achieve the same effect with an ioctl, for example I_SETSIG
-     * on Solaris). But we do not use O_ASYNC, so that's fine.
+    /* Nicht alle Betriebssysteme haben O_ASYNC, und diejenigen, die dies nicht
+     * tun lassen Sie uns den Zustand nicht verfolgen in raw_s-> open_flags
+     * (typischerweise Sie den gleichen Effekt mit einem ioctl zu erreichen,
+     * zum Beispiel I_SETSIG auf Solaris). Aber wir O_ASYNC setzen nicht, so
+     * ist das in Ordnung.
      */
     assert((s->open_flags & O_ASYNC) == 0);
 #endif
 
     if ((raw_s->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
-        /* dup the original fd */
-        /* TODO: use qemu fcntl wrapper */
+        /* dup die ursprüngliche fd */
+        /* TODO: Verwendung qemu fcntl Wrapper */
 #ifdef F_DUPFD_CLOEXEC
         raw_s->fd = fcntl(s->fd, F_DUPFD_CLOEXEC, 0);
 #else
@@ -662,7 +672,8 @@ static int raw_reopen_prepare(BDRVReopenState *state,
         }
     }
 
-    /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
+    /* Wenn wir nicht fcntl verwenden können, oder fcntl fehlgeschlagen ist,
+     * zurückgreifen zu qemu_open () */
     if (raw_s->fd == -1) {
         const char *normalized_filename = state->bs->filename;
         ret = raw_normalize_devicepath(&normalized_filename);
@@ -678,8 +689,8 @@ static int raw_reopen_prepare(BDRVReopenState *state,
         }
     }
 
-    /* Fail already reopen_prepare() if we can't get a working O_DIRECT
-     * alignment with the new fd. */
+    /* Nicht bestanden bereits reopen_prepare (), wenn wir nicht eine
+     * funktionierende O_DIRECT bekommen Ausrichtung mit dem neuen fd. */
     if (raw_s->fd != -1) {
         raw_probe_alignment(state->bs, raw_s->fd, &local_err);
         if (local_err) {
@@ -715,7 +726,7 @@ static void raw_reopen_abort(BDRVReopenState *state)
 {
     BDRVRawReopenState *raw_s = state->opaque;
 
-     /* nothing to do if NULL, we didn't get far enough */
+     /* nichts zu tun, wenn NULL, wir nicht weit genug bekommen */
     if (raw_s == NULL) {
         return;
     }
@@ -749,16 +760,16 @@ static int check_for_dasd(int fd)
 }
 
 /**
- * Try to get @bs's logical and physical block size.
- * On success, store them in @bsz and return zero.
- * On failure, return negative errno.
+ * Versuchen Sie, @ der bs logischen und physischen Blockgröße.
+ * Bei Erfolg speichern sie in @bsz und null zurück.
+ * Bei einem Fehler Rückkehr negativ errno.
  */
 static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 {
     BDRVRawState *s = bs->opaque;
     int ret;
 
-    /* If DASD, get blocksizes */
+    /* Wenn DASD, bekommen Blockgrößen */
     if (check_for_dasd(s->fd) < 0) {
         return -ENOTSUP;
     }
@@ -770,10 +781,10 @@ static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 }
 
 /**
- * Try to get @bs's geometry: cyls, heads, sectors.
- * On success, store them in @geo and return 0.
- * On failure return -errno.
- * (Allows block driver to assign default geometry values that guest sees)
+ * Versuchen @ bs Geometrie zu erhalten: cyls, Köpfe, Sektoren.
+ * Bei Erfolg speichern sie in @geo und 0 zurück.
+ * Bei einem Fehler Rückkehr -errno.
+ * (Ermöglicht Blocktreiber Standardgeometriewerte zuweisen, dass Gast sieht)
  */
 #ifdef __linux__
 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
@@ -781,19 +792,19 @@ static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
     BDRVRawState *s = bs->opaque;
     struct hd_geometry ioctl_geo = {0};
 
-    /* If DASD, get its geometry */
+    /* Wenn DASD, erhalten ihre Geometrie */
     if (check_for_dasd(s->fd) < 0) {
         return -ENOTSUP;
     }
     if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
         return -errno;
     }
-    /* HDIO_GETGEO may return success even though geo contains zeros
-       (e.g. certain multipath setups) */
+    /* HDIO_GETGEO kann Erfolg zurückgeben, auch wenn geo Nullen enthält
+       (Z.B. bestimmte Mehrweg-Setups) */
     if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
         return -ENOTSUP;
     }
-    /* Do not return a geometry for partition */
+    /* Verwenden Sie keine Geometrie für Partition zurückkehren */
     if (ioctl_geo.start != 0) {
         return -ENOTSUP;
     }
@@ -891,10 +902,10 @@ static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
 }
 
 /*
- * Read/writes the data to/from a given linear buffer.
+ * Lese- / schreibt die Daten zu / von einem gegebenen linearen Puffer.
  *
- * Returns the number of bytes handles or -errno in case of an error. Short
- * reads are only returned if the end of the file is reached.
+ * Gibt die Anzahl von Bytes, Griffe oder -errno im Falle eines Fehlers. Kurz
+ * nur zurück liest, wenn das Ende der Datei erreicht ist.
  */
 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
 {
@@ -919,9 +930,10 @@ static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
                    (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
                    !(aiocb->aio_type & QEMU_AIO_WRITE) &&
                    offset > 0) {
-            /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
-             * after a short read.  Assume that O_DIRECT short reads only occur
-             * at EOF.  Therefore this is a short read, not an I/O error.
+            /* O_DIRECT pread () kann mit EINVAL fehlschlagen, wenn nicht
+             * ausgerichteten Offset nach einer kurzen Lektüre. Es sei
+             * angenommen, dass O_DIRECT kurz nur liest auftreten bei EOF.
+             * Daher ist dies eine kurze Lese, und kein I / O-Fehler.
              */
             break;
         } else if (len == -1) {
@@ -943,17 +955,17 @@ static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
 
     if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
         /*
-         * If there is just a single buffer, and it is properly aligned
-         * we can just use plain pread/pwrite without any problems.
+         * Wenn es nur einen einzigen Puffer, und es richtig ausgerichtet ist
+         * wir können einfach nur pread / pwrite ohne Probleme verwenden.
          */
         if (aiocb->aio_niov == 1) {
              return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base);
         }
         /*
-         * We have more than one iovec, and all are properly aligned.
+         * Wir haben mehr als eine iovec und alle richtig ausgerichtet sind.
          *
-         * Try preadv/pwritev first and fall back to linearizing the
-         * buffer if it's not supported.
+         * Versuchen Sie preadv / pwritev erste und fallen wieder die zu
+         * Linearisieren Puffer, wenn es nicht unterstützt wird.
          */
         if (preadv_present) {
             nbytes = handle_aiocb_rw_vector(aiocb);
@@ -965,15 +977,15 @@ static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
         }
 
         /*
-         * XXX(hch): short read/write.  no easy way to handle the reminder
-         * using these interfaces.  For now retry using plain
-         * pread/pwrite?
+         * XXX (HCH): Für kurze Lese- / Schreib. keine einfache Möglichkeit,
+         * um die Erinnerung zu handhaben Mit diesen Schnittstellen. Für
+         * versuchen nun klar, mit pread / pwrite?
          */
     }
 
     /*
-     * Ok, we have to do it the hard way, copy all segments into
-     * a single aligned buffer.
+     * Ok, wir haben es auf die harte Art und Weise zu tun, kopieren Sie alle
+     * Segmente in ein einziger ausgerichtet Puffer.
      */
     buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
     if (buf == NULL) {
@@ -1310,10 +1322,10 @@ static BlockAIOCB *raw_aio_submit(BlockDriverState *bs,
         return NULL;
 
     /*
-     * Check if the underlying device requires requests to be aligned,
-     * and if the request we are trying to submit is aligned or not.
-     * If this is the case tell the low-level driver that it needs
-     * to copy the buffer.
+     * Überprüfen Sie, ob die zugrunde liegende Geräteanforderungen erfordert
+     * ausgerichtet werden, und wenn die Anforderung wir einreichen versuchen
+     * ausgerichtet ist oder nicht. Ist dies der Fall, sagen die
+     * Low-Level-Treiber, der es braucht den Puffer zu kopieren.
      */
     if (s->needs_alignment) {
         if (!bdrv_qiov_is_aligned(bs, qiov)) {
@@ -1486,7 +1498,7 @@ static int64_t raw_getlength(BlockDriverState *bs)
     }
 
     /*
-     * Use the DKIOCGMEDIAINFO ioctl to read the size.
+     * Verwenden Sie die DKIOCGMEDIAINFO ioctl die Größe zu lesen.
      */
     ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
     if (ret != -1) {
@@ -1494,8 +1506,8 @@ static int64_t raw_getlength(BlockDriverState *bs)
     }
 
     /*
-     * There are reports that lseek on some devices fails, but
-     * irc discussion said that contingency on contingency was overkill.
+     * Es gibt Berichte, dass bei einigen Geräten lseek ausfällt, aber
+     * irc Diskussion gesagt, dass Kontingenz auf Kontingenz Overkill war.
      */
     size = lseek(s->fd, 0, SEEK_END);
     if (size < 0) {
@@ -1559,10 +1571,11 @@ again:
 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
         switch(s->type) {
         case FTYPE_CD:
-            /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
+            /* XXX FreeBSD acd kehrt UINT_MAX Sektoren für ein leeres
+             * Laufwerk */
             if (size == 2048LL * (unsigned)-1)
                 size = 0;
-            /* XXX no disc?  maybe we need to reopen... */
+            /* XXX keine Disc? vielleicht müssen wir wieder öffnen ... */
             if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
                 reopened = 1;
                 goto again;
@@ -1620,7 +1633,7 @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
 
     strstart(filename, "file:", &filename);
 
-    /* Read out options */
+    /* Vorlesen Optionen */
     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
                           BDRV_SECTOR_SIZE);
     nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
@@ -1645,10 +1658,10 @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
 
     if (nocow) {
 #ifdef __linux__
-        /* Set NOCOW flag to solve performance issue on fs like btrfs.
-         * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
-         * will be ignored since any failure of this operation should not
-         * block the left work.
+        /* Stellen Sie NOCOW Flag Performance-Problem auf fs wie Btrfs zu
+         * lösen. Dies ist eine Optimierung. Der FS_IOC_SETFLAGS ioctl
+         * Rückgabewert wird da jeder Ausfall dieser Operation ignoriert
+         * werden sollte nicht blockieren die linke Arbeit.
          */
         int attr;
         if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
@@ -1667,7 +1680,7 @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
     switch (prealloc) {
 #ifdef CONFIG_POSIX_FALLOCATE
     case PREALLOC_MODE_FALLOC:
-        /* posix_fallocate() doesn't set errno. */
+        /* posix_fallocate () führt errno nicht gesetzt. */
         result = -posix_fallocate(fd, 0, total_size);
         if (result != 0) {
             error_setg_errno(errp, -result,
@@ -1721,14 +1734,15 @@ out:
 }
 
 /*
- * Find allocation range in @bs around offset @start.
- * May change underlying file descriptor's file offset.
- * If @start is not in a hole, store @start in @data, and the
- * beginning of the next hole in @hole, and return 0.
- * If @start is in a non-trailing hole, store @start in @hole and the
- * beginning of the next non-hole in @data, and return 0.
- * If @start is in a trailing hole or beyond EOF, return -ENXIO.
- * If we can't find out, return a negative errno other than -ENXIO.
+ * Finden Zuordnungsbereichs in @bs um Offset @start.
+ * Kann ändern Dateideskriptor der Datei Offset zugrunde liegen.
+ * Wenn @start ist nicht in einem Loch, speichern @start in @data, und die
+ * Anfang des nächsten Loch in @ Loch und 0 zurück.
+ * Wenn @start ist in einer nicht abschließenden Loch, speichern @start in
+ * @ Loch und die Anfang des nächsten Nicht-Loch in @data und 0 zurück.
+ * Wenn @start in einem nachgestellten Loch oder über EOF ist, kehren -ENXIO.
+ * Wenn wir nicht herausfinden können, kehren Sie zu einem negativen errno
+ * andere als -ENXIO.
  */
 static int find_allocation(BlockDriverState *bs, off_t start,
                            off_t *data, off_t *hole)
@@ -1738,67 +1752,67 @@ static int find_allocation(BlockDriverState *bs, off_t start,
     off_t offs;
 
     /*
-     * SEEK_DATA cases:
-     * D1. offs == start: start is in data
-     * D2. offs > start: start is in a hole, next data at offs
-     * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
-     *                              or start is beyond EOF
-     *     If the latter happens, the file has been truncated behind
-     *     our back since we opened it.  All bets are off then.
-     *     Treating like a trailing hole is simplest.
-     * D4. offs < 0, errno != ENXIO: we learned nothing
+     * SEEK_DATA Fälle:
+     * D1. offs == Start: Start in Daten
+     * D2. offs> starten: Start in ein Loch ist, bei offs nächsten Daten
+     * D3. offs <0, errno = ENXIO: entweder Start ist in einem abschließenden
+     *                             Loch oder Start ist über EOF
+     *     Wenn letzteres der Fall ist, wurde die Datei hinter abgeschnitten
+     *     Rücken, da wir es geöffnet. Alle Wetten ab dann.
+     *     Die Behandlung wie ein nachlauf Loch ist am einfachsten.
+     * D4. offs <0, errno = ENXIO: wir nichts gelernt
      */
     offs = lseek(s->fd, start, SEEK_DATA);
     if (offs < 0) {
-        return -errno;          /* D3 or D4 */
+        return -errno;          /* D3 oder D4 */
     }
     assert(offs >= start);
 
     if (offs > start) {
-        /* D2: in hole, next data at offs */
+        /* D2: in Loch nächsten Daten bei offs */
         *hole = start;
         *data = offs;
         return 0;
     }
 
-    /* D1: in data, end not yet known */
+    /* D1: in Daten, Ende noch nicht bekannt */
 
     /*
-     * SEEK_HOLE cases:
-     * H1. offs == start: start is in a hole
-     *     If this happens here, a hole has been dug behind our back
-     *     since the previous lseek().
-     * H2. offs > start: either start is in data, next hole at offs,
-     *                   or start is in trailing hole, EOF at offs
-     *     Linux treats trailing holes like any other hole: offs ==
-     *     start.  Solaris seeks to EOF instead: offs > start (blech).
-     *     If that happens here, a hole has been dug behind our back
-     *     since the previous lseek().
-     * H3. offs < 0, errno = ENXIO: start is beyond EOF
-     *     If this happens, the file has been truncated behind our
-     *     back since we opened it.  Treat it like a trailing hole.
-     * H4. offs < 0, errno != ENXIO: we learned nothing
-     *     Pretend we know nothing at all, i.e. "forget" about D1.
+     * SEEK_HOLE Fälle:
+     * H1. offs == Start: Start ist in einem Loch
+     *     Wenn dies hier der Fall ist, hat ein Loch wurde hinter unserem
+     *     Rücken gegraben seit dem vorherigen lseek ().
+     * H2. offs> starten: entweder Start in Daten, das nächste Loch ist bei
+     *     offs, oder Start ist Loch in der Schleppkette, EOF bei offs
+     *     Linux leckereien Löcher wie jedes andere Loch Hinter: offs ==
+     *     Anfang. Solaris sucht stattdessen EOF: offs> start (blech).
+     *     Wenn das hier der Fall ist, hat ein Loch wurde hinter unserem Rücken
+     *     gegraben seit dem vorherigen lseek ().
+     * H3. offs <0, errno = ENXIO: Start ist über EOF
+     *     Wenn dies geschieht, wurde die Datei hinter unserem abgeschnitten
+     *     zurück, da wir es geöffnet. Behandeln Sie es wie ein nachlauf Loch.
+     * H4. offs <0, errno = ENXIO: wir nichts gelernt
+     *     Täuschen wir wissen gar nichts, das heißt "vergessen" über D1.
      */
     offs = lseek(s->fd, start, SEEK_HOLE);
     if (offs < 0) {
-        return -errno;          /* D1 and (H3 or H4) */
+        return -errno;          /* D1 und (H3 oder H4) */
     }
     assert(offs >= start);
 
     if (offs > start) {
         /*
-         * D1 and H2: either in data, next hole at offs, or it was in
-         * data but is now in a trailing hole.  In the latter case,
-         * all bets are off.  Treating it as if it there was data all
-         * the way to EOF is safe, so simply do that.
+         * D1 und H2: entweder in Daten, nächste Loch in offs, oder es war in
+         * die Daten sind jedoch nun in einem abschließenden Loch. Im letzteren
+         * Fall, sind alle Wetten ab. Behandeln, als ob es Daten gibt es war
+         * alles der Weg zum EOF ist sicher, so einfach das tun.
          */
         *data = start;
         *hole = offs;
         return 0;
     }
 
-    /* D1 and H1 */
+    /* D1 und H1 */
     return -EBUSY;
 #else
     return -ENOTSUP;
@@ -1806,17 +1820,17 @@ static int find_allocation(BlockDriverState *bs, off_t start,
 }
 
 /*
- * Returns the allocation status of the specified sectors.
+ * Gibt den Zuordnungs-Status der angegebenen Sektoren.
  *
- * If 'sector_num' is beyond the end of the disk image the return value is 0
- * and 'pnum' is set to 0.
+ * Wenn 'sector_num' über das Ende des Disk-Image ist der Rückgabewert 0
+ * und 'pnum' auf 0 gesetzt ist.
  *
- * 'pnum' is set to the number of sectors (including and immediately following
- * the specified sector) that are known to be in the same
- * allocated/unallocated state.
+ * 'Pnum' ist auf die Anzahl der Sektoren gesetzt (einschließlich und
+ * unmittelbar im Anschluss an der angegebene Sektor), die in derselben
+ * bekannt sind zugeordnet / nicht zugeordneten Zustand.
  *
- * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
- * beyond the end of the disk image it will be clamped.
+ * 'Nb_sectors' ist der höchste Wert 'pnum' gesetzt werden soll. Wenn
+ * nb_sectors geht über das Ende des Disk-Image wird es gespannt werden.
  */
 static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
                                                     int64_t sector_num,
@@ -1845,20 +1859,21 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
 
     ret = find_allocation(bs, start, &data, &hole);
     if (ret == -ENXIO) {
-        /* Trailing hole */
+        /* Nachgestellte Loch */
         *pnum = nb_sectors;
         ret = BDRV_BLOCK_ZERO;
     } else if (ret < 0) {
-        /* No info available, so pretend there are no holes */
+        /* Keine Information verfügbar, so tun, so gibt es keine Löcher */
         *pnum = nb_sectors;
         ret = BDRV_BLOCK_DATA;
     } else if (data == start) {
-        /* On a data extent, compute sectors to the end of the extent,
-         * possibly including a partial sector at EOF. */
+        /* Auf einem Daten Maße berechnen Sektoren bis zum Ende des Ausmaßes,
+         * möglicherweise auch einen Teilsektor bei EOF. */
         *pnum = MIN(nb_sectors, DIV_ROUND_UP(hole - start, BDRV_SECTOR_SIZE));
         ret = BDRV_BLOCK_DATA;
     } else {
-        /* On a hole, compute sectors to the beginning of the next extent.  */
+        /* Auf einem Loch, berechnen Sektoren zu Beginn des nächsten
+         * Ausmaß. */
         assert(hole == start);
         *pnum = MIN(nb_sectors, (data - start) / BDRV_SECTOR_SIZE);
         ret = BDRV_BLOCK_ZERO;
@@ -1921,7 +1936,7 @@ static QemuOptsList raw_create_opts = {
             .type = QEMU_OPT_STRING,
             .help = "Preallocation mode (allowed values: off, falloc, full)"
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     }
 };
 
@@ -1930,7 +1945,7 @@ BlockDriver bdrv_file = {
     .protocol_name = "file",
     .instance_size = sizeof(BDRVRawState),
     .bdrv_needs_filename = true,
-    .bdrv_probe = NULL, /* no probe for protocols */
+    .bdrv_probe = NULL, /* keine Sonde für Protokolle */
     .bdrv_parse_filename = raw_parse_filename,
     .bdrv_file_open = raw_open,
     .bdrv_reopen_prepare = raw_reopen_prepare,
@@ -1964,7 +1979,7 @@ BlockDriver bdrv_file = {
 };
 
 /***********************************************/
-/* host device */
+/* Host-Gerät */
 
 #if defined(__APPLE__) && defined(__MACH__)
 static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
@@ -2000,7 +2015,7 @@ static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
             continue;
         }
 
-        /* If a match was found, leave the loop */
+        /* Wenn eine Übereinstimmung gefunden wurde, lassen Sie die Schleife */
         if (*mediaIterator != 0) {
             DPRINTF("Matching using %s\n", matching_array[index]);
             mediaType = g_strdup(matching_array[index]);
@@ -2039,14 +2054,14 @@ kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
     return kernResult;
 }
 
-/* Sets up a real cdrom for use in QEMU */
+/* Richtet eine echte CD-ROM für den Einsatz in QEMU */
 static bool setup_cdrom(char *bsd_path, Error **errp)
 {
     int index, num_of_test_partitions = 2, fd;
     char test_partition[MAXPATHLEN];
     bool partition_found = false;
 
-    /* look for a working partition */
+    /* suchen Sie nach einem Arbeitspartition */
     for (index = 0; index < num_of_test_partitions; index++) {
         snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
                  index);
@@ -2058,7 +2073,7 @@ static bool setup_cdrom(char *bsd_path, Error **errp)
         }
     }
 
-    /* if a working partition on the device was not found */
+    /* wenn eine Arbeits Partition auf dem Gerät wurde nicht gefunden */
     if (partition_found == false) {
         error_setg(errp, "Failed to find a working partition on disc");
     } else {
@@ -2068,7 +2083,7 @@ static bool setup_cdrom(char *bsd_path, Error **errp)
     return partition_found;
 }
 
-/* Prints directions on mounting and unmounting a device */
+/* Drucke Richtungen auf Montage und Aushängen einer Vorrichtung */
 static void print_unmounting_directions(const char *file_name)
 {
     error_report("If device %s is mounted on the desktop, unmount"
@@ -2078,13 +2093,14 @@ static void print_unmounting_directions(const char *file_name)
     error_report("Command to mount device: diskutil mountDisk %s", file_name);
 }
 
-#endif /* defined(__APPLE__) && defined(__MACH__) */
+#endif /* defined (__ APPLE__) && defined (__ MACH__) */
 
 static int hdev_probe_device(const char *filename)
 {
     struct stat st;
 
-    /* allow a dedicated CD-ROM driver to match with a higher priority */
+    /* ein spezielles CD-ROM-Treiber erlauben, mit einer höheren Priorität zu
+     * entsprechen */
     if (strstart(filename, "/dev/cdrom", NULL))
         return 50;
 
@@ -2099,13 +2115,13 @@ static int hdev_probe_device(const char *filename)
 static int check_hdev_writable(BDRVRawState *s)
 {
 #if defined(BLKROGET)
-    /* Linux block devices can be configured "read-only" using blockdev(8).
-     * This is independent of device node permissions and therefore open(2)
-     * with O_RDWR succeeds.  Actual writes fail with EPERM.
+    /* Linux-Block-Geräte können "read-only" mit blockdev (8) konfiguriert
+     * werden. Dies ist unabhängig von Geräteknoten Berechtigungen und daher
+     * offen (2) mit O_RDWR gelingt. Tatsächliche schreibt nicht mit EPERM.
      *
-     * bdrv_open() is supposed to fail if the disk is read-only.  Explicitly
-     * check for read-only block devices so that Linux block devices behave
-     * properly.
+     * bdrv_open () soll zum Scheitern verurteilt, wenn der Datenträger ist
+     * schreibgeschützt. Ausdrücklich Check für Nur-Lese-Block-Geräte, so
+     * dass Linux-Block-Geräte verhalten richtig.
      */
     struct stat st;
     int readonly = 0;
@@ -2125,14 +2141,14 @@ static int check_hdev_writable(BDRVRawState *s)
     if (readonly) {
         return -EACCES;
     }
-#endif /* defined(BLKROGET) */
+#endif /* definiert (BLKROGET) */
     return 0;
 }
 
 static void hdev_parse_filename(const char *filename, QDict *options,
                                 Error **errp)
 {
-    /* The prefix is optional, just as for "file". */
+    /* Das Präfix ist optional, ebenso wie für "Datei". */
     strstart(filename, "host_device:", &filename);
 
     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
@@ -2172,7 +2188,7 @@ static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
     char bsd_path[MAXPATHLEN] = "";
     bool error_occurred = false;
 
-    /* If using a real cdrom */
+    /* Wenn eine echte CD-Rom mit */
     if (strcmp(filename, "/dev/cdrom") == 0) {
         char *mediaType = NULL;
         kern_return_t ret_val;
@@ -2193,14 +2209,15 @@ static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
             goto hdev_open_Mac_error;
         }
 
-        /* If a real optical drive was not found */
+        /* Wenn eine echte optische Laufwerk wurde nicht gefunden */
         if (bsd_path[0] == '\0') {
             error_setg(errp, "Failed to obtain bsd path for optical drive");
             error_occurred = true;
             goto hdev_open_Mac_error;
         }
 
-        /* If using a cdrom disc and finding a partition on the disc failed */
+        /* Wenn eine CD-ROM-Disc und eine Partition auf der Platte zu finden,
+         * fehlgeschlagen */
         if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
             setup_cdrom(bsd_path, errp) == false) {
             print_unmounting_directions(bsd_path);
@@ -2219,7 +2236,7 @@ hdev_open_Mac_error:
             return -ENOENT;
         }
     }
-#endif /* defined(__APPLE__) && defined(__MACH__) */
+#endif /* defined (__ APPLE__) && defined (__ MACH__) */
 
     s->type = FTYPE_FILE;
 
@@ -2232,15 +2249,16 @@ hdev_open_Mac_error:
         if (*bsd_path) {
             filename = bsd_path;
         }
-        /* if a physical device experienced an error while being opened */
+        /* wenn ein physisches Gerät ein Fehler aufgetreten, während geöffnet
+         * werden */
         if (strncmp(filename, "/dev/", 5) == 0) {
             print_unmounting_directions(filename);
         }
-#endif /* defined(__APPLE__) && defined(__MACH__) */
+#endif /* defined (__ APPLE__) && defined (__ MACH__) */
         return ret;
     }
 
-    /* Since this does ioctl the device must be already opened */
+    /* Da dies das Gerät tut ioctl muss bereits geöffnet */
     bs->sg = hdev_is_sg(bs);
 
     if (flags & BDRV_O_RDWR) {
@@ -2284,7 +2302,8 @@ static int fd_open(BlockDriverState *bs)
 {
     BDRVRawState *s = bs->opaque;
 
-    /* this is just to ensure s->fd is sane (its called by io ops) */
+    /* dies ist nur s-, um sicherzustellen,> fd gesund ist
+     * (sein von io ops genannt) */
     if (s->fd >= 0)
         return 0;
     return -EIO;
@@ -2332,10 +2351,10 @@ static int hdev_create(const char *filename, QemuOpts *opts,
     int64_t total_size = 0;
     bool has_prefix;
 
-    /* This function is used by both protocol block drivers and therefore either
-     * of these prefixes may be given.
-     * The return value has to be stored somewhere, otherwise this is an error
-     * due to -Werror=unused-value. */
+    /* Diese Funktion wird von den beiden Protokollblock Treiber verwendet und
+     * daher entweder dieser Präfixe gegeben werden kann.
+     * Der Rückgabewert muss irgendwo gelagert werden, sonst ist dies ein
+     * Fehler aufgrund Werror = ungenutzt-Wert. */
     has_prefix =
         strstart(filename, "host_device:", &filename) ||
         strstart(filename, "host_cdrom:" , &filename);
@@ -2348,7 +2367,7 @@ static int hdev_create(const char *filename, QemuOpts *opts,
         return ret;
     }
 
-    /* Read out options */
+    /* Vorlesen Optionen */
     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
                           BDRV_SECTOR_SIZE);
 
@@ -2411,7 +2430,7 @@ static BlockDriver bdrv_host_device = {
     .bdrv_detach_aio_context = raw_detach_aio_context,
     .bdrv_attach_aio_context = raw_attach_aio_context,
 
-    /* generic scsi device */
+    /* generische SCSI Gerät */
 #ifdef __linux__
     .bdrv_aio_ioctl     = hdev_aio_ioctl,
 #endif
@@ -2421,7 +2440,7 @@ static BlockDriver bdrv_host_device = {
 static void cdrom_parse_filename(const char *filename, QDict *options,
                                  Error **errp)
 {
-    /* The prefix is optional, just as for "file". */
+    /* Das Präfix ist optional, ebenso wie für "Datei". */
     strstart(filename, "host_cdrom:", &filename);
 
     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
@@ -2438,7 +2457,8 @@ static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
 
     s->type = FTYPE_CD;
 
-    /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
+    /* offen nicht einmal fehl, wenn keine CD eingelegt ist, so fügen Sie
+     * O_NONBLOCK */
     ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
     if (local_err) {
         error_propagate(errp, local_err);
@@ -2461,7 +2481,7 @@ static int cdrom_probe_device(const char *filename)
         goto outc;
     }
 
-    /* Attempt to detect via a CDROM specific ioctl */
+    /* Der Versuch, über ein CD-ROM-spezifische ioctl zu erkennen */
     ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
     if (ret >= 0)
         prio = 100;
@@ -2500,10 +2520,10 @@ static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
 
     if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
         /*
-         * Note: an error can happen if the distribution automatically
-         * mounts the CD-ROM
+         * Hinweis: ein Fehler automatisch, wenn die Verteilung passieren kann
+         * richtet die CD-ROM
          */
-        /* perror("CDROM_LOCKDOOR"); */
+        /* perror ( "CDROM_LOCKDOOR"); */
     }
 }
 
@@ -2539,12 +2559,12 @@ static BlockDriver bdrv_host_cdrom = {
     .bdrv_detach_aio_context = raw_detach_aio_context,
     .bdrv_attach_aio_context = raw_attach_aio_context,
 
-    /* removable device support */
+    /* herausnehmbaren Geräteträger */
     .bdrv_is_inserted   = cdrom_is_inserted,
     .bdrv_eject         = cdrom_eject,
     .bdrv_lock_medium   = cdrom_lock_medium,
 
-    /* generic scsi device */
+    /* generische SCSI Gerät */
     .bdrv_aio_ioctl     = hdev_aio_ioctl,
 };
 #endif /* __linux__ */
@@ -2567,7 +2587,7 @@ static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
         return ret;
     }
 
-    /* make sure the door isn't locked at this time */
+    /* Sicherstellen, dass die Tür zu diesem Zeitpunkt nicht gesperrt */
     ioctl(s->fd, CDIOCALLOW);
     return 0;
 }
@@ -2586,8 +2606,8 @@ static int cdrom_reopen(BlockDriverState *bs)
     int fd;
 
     /*
-     * Force reread of possibly changed/newly loaded disc,
-     * FreeBSD seems to not notice sometimes...
+     * Force-reread möglicherweise geändert / neu eingelegte Disc,
+     * FreeBSD scheint manchmal nicht zu bemerken ...
      */
     if (s->fd >= 0)
         qemu_close(s->fd);
@@ -2598,7 +2618,7 @@ static int cdrom_reopen(BlockDriverState *bs)
     }
     s->fd = fd;
 
-    /* make sure the door isn't locked at this time */
+    /* Sicherstellen, dass die Tür zu diesem Zeitpunkt nicht gesperrt */
     ioctl(s->fd, CDIOCALLOW);
     return 0;
 }
@@ -2636,10 +2656,10 @@ static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
         return;
     if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
         /*
-         * Note: an error can happen if the distribution automatically
-         * mounts the CD-ROM
+         * Hinweis: ein Fehler automatisch, wenn die Verteilung passieren kann
+         * richtet die CD-ROM
          */
-        /* perror("CDROM_LOCKDOOR"); */
+        /* perror ( "CDROM_LOCKDOOR"); */
     }
 }
 
@@ -2675,7 +2695,7 @@ static BlockDriver bdrv_host_cdrom = {
     .bdrv_detach_aio_context = raw_detach_aio_context,
     .bdrv_attach_aio_context = raw_attach_aio_context,
 
-    /* removable device support */
+    /* herausnehmbaren Geräteträger */
     .bdrv_is_inserted   = cdrom_is_inserted,
     .bdrv_eject         = cdrom_eject,
     .bdrv_lock_medium   = cdrom_lock_medium,
@@ -2685,8 +2705,8 @@ static BlockDriver bdrv_host_cdrom = {
 static void bdrv_file_init(void)
 {
     /*
-     * Register all the drivers.  Note that order is important, the driver
-     * registered last will get probed first.
+     * Registrieren Sie alle Treiber. Beachten Sie, dass wichtig ist, der Fahrer
+     * registriert wird zuletzt erste sondiert bekommen.
      */
     bdrv_register(&bdrv_file);
     bdrv_register(&bdrv_host_device);
diff --git a/block/raw-win32.c b/block/raw-win32.c
index fd23891..5f8eb56 100644
--- a/block/raw-win32.c
+++ b/block/raw-win32.c
@@ -52,15 +52,15 @@ typedef struct RawWin32AIOData {
 typedef struct BDRVRawState {
     HANDLE hfile;
     int type;
-    char drive_path[16]; /* format: "d:\" */
+    char drive_path[16]; /* Format: "d: \" */
     QEMUWin32AIOState *aio;
 } BDRVRawState;
 
 /*
- * Read/writes the data to/from a given linear buffer.
+ * Lese- / schreibt die Daten zu / von einem gegebenen linearen Puffer.
  *
- * Returns the number of bytes handles or -errno in case of an error. Short
- * reads are only returned if the end of the file is reached.
+ * Gibt die Anzahl von Bytes, Griffe oder -errno im Falle eines Fehlers. Kurz
+ * nur zurück liest, wenn das Ende der Datei erreicht ist.
  */
 static size_t handle_aiocb_rw(RawWin32AIOData *aiocb)
 {
@@ -105,8 +105,8 @@ static int aio_worker(void *arg)
     case QEMU_AIO_READ:
         count = handle_aiocb_rw(aiocb);
         if (count < aiocb->aio_nbytes) {
-            /* A short read means that we have reached EOF. Pad the buffer
-             * with zeros for bytes after EOF. */
+            /* Eine kurze Lese bedeutet, dass wir EOF erreicht haben. Füllt das
+             * Puffer mit Nullen für Bytes nach EOF. */
             iov_memset(aiocb->aio_iov, aiocb->aio_niov, count,
                       0, aiocb->aio_nbytes - count);
 
@@ -177,7 +177,7 @@ int qemu_ftruncate64(int fd, int64_t length)
 
     h = (HANDLE)_get_osfhandle(fd);
 
-    /* get current position, ftruncate do not change position */
+    /* erhalten aktuelle Position, ftruncate nicht Position ändern */
     li.HighPart = 0;
     li.LowPart = SetFilePointer (h, 0, &li.HighPart, FILE_CURRENT);
     if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
@@ -191,7 +191,7 @@ int qemu_ftruncate64(int fd, int64_t length)
     }
     res = SetEndOfFile(h);
 
-    /* back to old position */
+    /* zurück zur alten Position */
     SetFilePointer(h, li.LowPart, &li.HighPart, FILE_BEGIN);
     return res ? 0 : -1;
 }
@@ -240,7 +240,7 @@ static void raw_probe_alignment(BlockDriverState *bs)
             bs->request_alignment = dg.Geometry.BytesPerSector;
             return;
         }
-        /* try GetDiskFreeSpace too */
+        /* versuchen GetDiskFreeSpace zu */
     }
 
     if (s->drive_path[0]) {
@@ -274,9 +274,9 @@ static void raw_parse_flags(int flags, int *access_flags, DWORD *overlapped)
 static void raw_parse_filename(const char *filename, QDict *options,
                                Error **errp)
 {
-    /* The filename does not have to be prefixed by the protocol name, since
-     * "file" is the default protocol; therefore, the return value of this
-     * function call can be ignored. */
+    /* Der Dateiname muss nicht durch den Protokollnamen vorangestellt werden,
+     * da "File" ist das Standardprotokoll; daher der Rückgabewert dieser
+     * Funktionsaufruf kann ignoriert werden. */
     strstart(filename, "file:", &filename);
 
     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
@@ -291,7 +291,7 @@ static QemuOptsList raw_runtime_opts = {
             .type = QEMU_OPT_STRING,
             .help = "File name of the image",
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     },
 };
 
@@ -325,7 +325,7 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
     } else if (filename[0] == '\\' && filename[1] == '\\') {
         s->drive_path[0] = 0;
     } else {
-        /* Relative path.  */
+        /* Relative Pfad.  */
         char buf[MAX_PATH];
         GetCurrentDirectory(MAX_PATH, buf);
         snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", buf[0]);
@@ -433,8 +433,8 @@ static int raw_truncate(BlockDriverState *bs, int64_t offset)
     high = offset >> 32;
 
     /*
-     * An error has occurred if the return value is INVALID_SET_FILE_POINTER
-     * and GetLastError doesn't return NO_ERROR.
+     * Ein Fehler ist aufgetreten, wenn der Rückgabewert
+     * INVALID SET_FILE_POINTER ist und GetLastError nicht zurück NO_ERROR.
      */
     dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN);
     if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
@@ -488,7 +488,8 @@ static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
     get_compressed_t get_compressed;
     struct _stati64 st;
     const char *filename = bs->filename;
-    /* WinNT support GetCompressedFileSize to determine allocate size */
+    /* WinNT Unterstützung GetCompressedFileSize zu bestimmen Größe
+     * zuweisen */
     get_compressed =
         (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"),
                                             "GetCompressedFileSizeA");
@@ -513,7 +514,7 @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
 
     strstart(filename, "file:", &filename);
 
-    /* Read out options */
+    /* Vorlesen Optionen */
     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
                           BDRV_SECTOR_SIZE);
 
@@ -539,7 +540,7 @@ static QemuOptsList raw_create_opts = {
             .type = QEMU_OPT_SIZE,
             .help = "Virtual disk size"
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     }
 };
 
@@ -567,7 +568,7 @@ BlockDriver bdrv_file = {
 };
 
 /***********************************************/
-/* host device */
+/* Host-Gerät */
 
 static int find_cdrom(char *cdrom_name, int cdrom_name_size)
 {
@@ -627,7 +628,7 @@ static int hdev_probe_device(const char *filename)
 static void hdev_parse_filename(const char *filename, QDict *options,
                                 Error **errp)
 {
-    /* The prefix is optional, just as for "file". */
+    /* Das Präfix ist optional, ebenso wie für "Datei". */
     strstart(filename, "host_device:", &filename);
 
     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
@@ -664,7 +665,7 @@ static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
         }
         filename = device_name;
     } else {
-        /* transform drive letters into device name */
+        /* Laufwerksbuchstaben in Gerätenamen umwandeln */
         if (((filename[0] >= 'a' && filename[0] <= 'z') ||
              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
             filename[1] == ':' && filename[2] == '\0') {
diff --git a/block/raw_bsd.c b/block/raw_bsd.c
index a6cc7e9..cd23531 100644
--- a/block/raw_bsd.c
+++ b/block/raw_bsd.c
@@ -40,7 +40,7 @@ static QemuOptsList raw_create_opts = {
             .type = QEMU_OPT_SIZE,
             .help = "Virtual disk size"
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     }
 };
 
@@ -67,14 +67,15 @@ raw_co_writev_flags(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
     int ret;
 
     if (bs->probed && sector_num == 0) {
-        /* As long as these conditions are true, we can't get partial writes to
-         * the probe buffer and can just directly check the request. */
+        /* Solange diese Bedingungen erfüllt sind, können wir bekommen nicht
+         * teilweise schreibt zu die Sonde Puffer und kann nur direkt die
+         * Anfrage prüfen. */
         QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE != 512);
         QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != 512);
 
         if (nb_sectors == 0) {
-            /* qemu_iovec_to_buf() would fail, but we want to return success
-             * instead of -EINVAL in this case. */
+            /* qemu_iovec_to_buf () fehlschlagen würde, aber wir wollen Erfolg
+             * zurück statt -EINVAL in diesem Fall. */
             return 0;
         }
 
@@ -96,8 +97,8 @@ raw_co_writev_flags(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
             goto fail;
         }
 
-        /* Use the checked buffer, a malicious guest might be overwriting its
-         * original buffer in the background. */
+        /* Verwenden Sie das getestete Puffer, ein bösartiger Gast könnte
+         * überschrieben wird seine Original-Puffer im Hintergrund. */
         qemu_iovec_init(&local_qiov, qiov->niov + 1);
         qemu_iovec_add(&local_qiov, buf, 512);
         qemu_iovec_concat(&local_qiov, qiov, 512, qiov->size - 512);
@@ -232,8 +233,8 @@ static void raw_close(BlockDriverState *bs)
 
 static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
 {
-    /* smallest possible positive score so that raw is used if and only if no
-     * other block driver works
+    /* kleinstmögliche positive Punktzahl, so dass roh verwendet wird, wenn und
+     * nur wenn kein andere Block-Treiber funktioniert
      */
     return 1;
 }
diff --git a/block/vpc.c b/block/vpc.c
index 8830b5b..5d10540 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -162,7 +162,7 @@ static QemuOptsList vpc_runtime_opts = {
                     "or use the disk current_size specified in the VHD footer. "
                     "{chs, current_size}"
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     }
 };
 
@@ -194,7 +194,7 @@ static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
     size_calc = qemu_opt_get(opts, VPC_OPT_SIZE_CALC);
 
     if (!size_calc) {
-       /* no override, use autodetect only */
+        /* Kein Vorrang, verwenden Sie die automatische Erkennung nur */
     } else if (!strcmp(size_calc, "current_size")) {
         s->force_use_sz = true;
     } else if (!strcmp(size_calc, "chs")) {
@@ -252,7 +252,8 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
             goto fail;
         }
 
-        /* If a fixed disk, the footer is found only at the end of the file */
+        /* Wenn eine Festplatte, wird die Fußzeile erst am Ende der Datei
+         * gefunden */
         ret = bdrv_pread(bs->file->bs, offset-HEADER_SIZE, s->footer_buf,
                          HEADER_SIZE);
         if (ret < 0) {
@@ -272,7 +273,8 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
         fprintf(stderr, "block-vpc: The header checksum of '%s' is "
             "incorrect.\n", bs->filename);
 
-    /* Write 'checksum' back to footer, or else will leave it with zero. */
+    /* Schreiben 'Prüfsumme' zurück zur Fußzeile oder sonst verlassen sie mit
+     * Null. */
     footer->checksum = cpu_to_be32(checksum);
 
     // The visible size of a image in Virtual PC depends on the geometry
@@ -281,28 +283,31 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
     bs->total_sectors = (int64_t)
         be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;
 
-    /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
-     * VHD image sizes differently.  VPC will rely on CHS geometry,
-     * while Hyper-V and disk2vhd use the size specified in the footer.
+    /* Microsoft Virtual PC und Microsoft Hyper-V erzeugen und lesen
+     * VHD Bildgrößen unterschiedlich. VPC auf CHS-Geometrie verlassen,
+     * während Hyper-V und Disk2vhd die Größe in der Fußzeile angegeben
+     * verwenden.
      *
-     * We use a couple of approaches to try and determine the correct method:
-     * look at the Creator App field, and look for images that have CHS
-     * geometry that is the maximum value.
+     * Wir verwenden ein paar Ansätze, die richtige Methode, um zu versuchen
+     * und zu bestimmen: Blick auf den Schöpfer App Feld, und suchen Sie nach
+     * Bildern, die CHS haben Geometrie, die der Maximalwert ist.
      *
-     * If the CHS geometry is the maximum CHS geometry, then we assume that
-     * the size is the footer->current_size to avoid truncation.  Otherwise,
-     * we follow the table based on footer->creator_app:
+     * Wenn die CHS-Geometrie die maximale CHS-Geometrie ist, dann gehen wir
+     * davon aus, dass Die Größe ist die footer-> aktuelle_größe Abschneiden
+     * zu vermeiden. Andernfalls, wir folgen der Tabelle basiert auf
+     * footer-> creator_app:
      *
-     *  Known creator apps:
-     *      'vpc '  :  CHS              Virtual PC (uses disk geometry)
-     *      'qemu'  :  CHS              QEMU (uses disk geometry)
-     *      'qem2'  :  current_size     QEMU (uses current_size)
-     *      'win '  :  current_size     Hyper-V
-     *      'd2v '  :  current_size     Disk2vhd
+     *  Bekannte Schöpfer Apps:
+     *      "VPC": CHS Virtual PC (verwendet Plattengeometrie)
+     *      'QEMU': CHS QEMU (verwendet Plattengeometrie)
+     *      'Qem2': aktuelle_größe QEMU (verwendet aktuelle_größe)
+     *      "Gewinnen": aktuelle_größe Hyper-V
+     *      'D2v': aktuelle_größe Disk2vhd
      *
-     *  The user can override the table values via drive options, however
-     *  even with an override we will still use current_size for images
-     *  that have CHS geometry of the maximum size.
+     *  Der Benutzer kann die Tabellenwerte über die Antriebsoptionen außer
+     *  Kraft setzen, aber selbst bei einer Überschreibung wird immer noch wir
+     *  aktuelle_größe für Bilder verwenden dass haben CHS Geometrie der
+     *  maximalen Größe.
      */
     use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
                !!strncmp(footer->creator_app, "qem2", 4) &&
@@ -313,7 +318,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
                                         BDRV_SECTOR_SIZE;
     }
 
-    /* Allow a maximum disk size of approximately 2 TB */
+    /* Lassen Sie eine maximale Festplattengröße von ca. 2 TB */
     if (bs->total_sectors >= VHD_MAX_SECTORS) {
         ret = -EFBIG;
         goto fail;
@@ -416,7 +421,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
 
     qemu_co_mutex_init(&s->lock);
 
-    /* Disable migration when VHD images are used */
+    /* Deaktivieren Sie die Migration, wenn VHD-Images verwendet werden */
     error_setg(&s->migration_blocker, "The vpc format used by node '%s' "
                "does not support live migration",
                bdrv_get_device_or_node_name(bs));
@@ -439,11 +444,11 @@ static int vpc_reopen_prepare(BDRVReopenState *state,
 }
 
 /*
- * Returns the absolute byte offset of the given sector in the image file.
- * If the sector is not allocated, -1 is returned instead.
+ * Gibt den absoluten Byte-Offset des jeweiligen Sektors in der Bilddatei.
+ * Wenn der Sektor nicht zugeordnet wird, wird -1 statt zurückgegeben.
  *
- * The parameter write must be 1 if the offset will be used for a write
- * operation (the block bitmaps is updated then), 0 otherwise.
+ * Der Parameter Schreib muss 1 sein, wenn die für einen Schreib verwendet
+ * ausgeglichen werden Betrieb (die Block-Bitmaps aktualisiert dann), 0 sonst.
  */
 static inline int64_t get_sector_offset(BlockDriverState *bs,
     int64_t sector_num, int write)
@@ -479,10 +484,10 @@ static inline int64_t get_sector_offset(BlockDriverState *bs,
 }
 
 /*
- * Writes the footer to the end of the image file. This is needed when the
- * file grows as it overwrites the old footer
+ * Schreibt die Fußzeile an das Ende der Bilddatei. Dies ist erforderlich,
+ * wenn die Datei wächst, wie es die alte Fußzeile überschreibt
  *
- * Returns 0 on success and < 0 on error
+ * Gibt bei Erfolg 0 und <0 auf Fehler
  */
 static int rewrite_footer(BlockDriverState* bs)
 {
@@ -498,11 +503,11 @@ static int rewrite_footer(BlockDriverState* bs)
 }
 
 /*
- * Allocates a new block. This involves writing a new footer and updating
- * the Block Allocation Table to use the space at the old end of the image
- * file (overwriting the old footer)
+ * Ordnet einen neuen Block. Dies beinhaltet eine neue Fußzeile zu schreiben
+ * und zu aktualisieren die Block-Allocation Table den Raum am alten Ende des
+ * Bildes zu verwenden, Datei (Überschreiben der alten Fußzeile)
  *
- * Returns the sectors' offset in the image file on success and < 0 on error
+ * Gibt den Sektoren "Offset in der Bilddatei auf Erfolg und <0 auf Fehler
  */
 static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
 {
@@ -687,7 +692,8 @@ static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
     *pnum = 0;
 
     do {
-        /* All sectors in a block are contiguous (without using the bitmap) */
+        /* Alle Sektoren in einem Block angrenzen (ohne das Bitmap verwendet
+         * wird) */
         n = ROUND_UP(sector_num + 1, s->block_size / BDRV_SECTOR_SIZE)
           - sector_num;
         n = MIN(n, nb_sectors);
@@ -695,8 +701,8 @@ static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
         *pnum += n;
         sector_num += n;
         nb_sectors -= n;
-        /* *pnum can't be greater than one block for allocated
-         * sectors since there is always a bitmap in between. */
+        /* * Pnum kann nicht größer sein als ein Block für zugewiesen
+         * Sektoren, da es immer eine Bitmap dazwischen. */
         if (allocated) {
             *file = bs->file->bs;
             return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;
@@ -711,16 +717,16 @@ static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
 }
 
 /*
- * Calculates the number of cylinders, heads and sectors per cylinder
- * based on a given number of sectors. This is the algorithm described
- * in the VHD specification.
+ * Berechnet die Anzahl der Zylinder, Köpfe und Sektoren pro Zylinder
+ * basierend auf einer vorgegebenen Anzahl von Sektoren. Dies ist der
+ * beschriebene Algorithmus in der VHD-Spezifikation.
  *
- * Note that the geometry doesn't always exactly match total_sectors but
- * may round it down.
+ * Beachten Sie, dass die Geometrie nicht immer genau total_sectors passen, aber
+ * kann rund es nach unten.
  *
- * Returns 0 on success, -EFBIG if the size is larger than ~2 TB. Override
- * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
- * and instead allow up to 255 heads.
+ * Gibt 0 zurück, bei Erfolg, -EFBIG, wenn die Größe größer als ~ 2 TB.
+ * außer Kraft setzen die Hardware-EIDE und ATA-2 Grenze von 16 Köpfe (max
+ * Plattengröße von 127 GB) und stattdessen erlauben bis zu 255 Köpfe.
  */
 static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
     uint8_t* heads, uint8_t* secs_per_cyl)
@@ -803,8 +809,9 @@ static int create_dynamic_disk(BlockBackend *blk, uint8_t *buf,
     memcpy(dyndisk_header->magic, "cxsparse", 8);
 
     /*
-     * Note: The spec is actually wrong here for data_offset, it says
-     * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
+     * Hinweis: Die Spezifikation hier eigentlich falsch ist für data_offset,
+     * heißt es 0xFFFFFFFF, aber MS-Tools erwarten, dass alle 64 Bit gesetzt
+     * werden.
      */
     dyndisk_header->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
     dyndisk_header->table_offset = cpu_to_be64(3 * 512);
@@ -831,7 +838,7 @@ static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
 {
     int ret;
 
-    /* Add footer to total size */
+    /* In Fußzeile Gesamtgröße */
     total_size += HEADER_SIZE;
 
     ret = blk_truncate(blk, total_size);
@@ -864,7 +871,7 @@ static int vpc_create(const char *filename, QemuOpts *opts, Error **errp)
     Error *local_err = NULL;
     BlockBackend *blk = NULL;
 
-    /* Read out options */
+    /* Vorlesen Optionen */
     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
                           BDRV_SECTOR_SIZE);
     disk_type_param = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT);
@@ -900,16 +907,19 @@ static int vpc_create(const char *filename, QemuOpts *opts, Error **errp)
     blk_set_allow_write_beyond_eof(blk, true);
 
     /*
-     * Calculate matching total_size and geometry. Increase the number of
-     * sectors requested until we get enough (or fail). This ensures that
-     * qemu-img convert doesn't truncate images, but rather rounds up.
+     * Berechnen Sie passende total_size und Geometrie. Erhöhen Sie die Anzahl
+     * der Sektoren aufgefordert, bis wir genug (oder nicht) zu bekommen. Dies
+     * stellt sicher, dass qemu-img convert kürzt nicht Bilder, sondern
+     * abrundet.
      *
-     * If the image size can't be represented by a spec conformant CHS geometry,
-     * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
-     * the image size from the VHD footer to calculate total_sectors.
+     * Wenn die Bildgröße kann nicht durch eine Spezifikation konformes
+     * CHS-Geometrie dargestellt werden, setzen wir die Geometrie zu
+     * 65535 x 16 x 255 (CxHxS) Sektoren und Nutzung die Bildgröße aus der
+     * VHD Fußzeile total_sectors berechnen.
      */
     if (force_size) {
-        /* This will force the use of total_size for sector count, below */
+        /* Dadurch wird die Verwendung von total_size für Sektorzählung
+         * zwingen, unter */
         cyls         = VHD_CHS_MAX_C;
         heads        = VHD_CHS_MAX_H;
         secs_per_cyl = VHD_CHS_MAX_S;
@@ -922,7 +932,7 @@ static int vpc_create(const char *filename, QemuOpts *opts, Error **errp)
 
     if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
         total_sectors = total_size / BDRV_SECTOR_SIZE;
-        /* Allow a maximum disk size of approximately 2 TB */
+        /* Lassen Sie eine maximale Festplattengröße von ca. 2 TB */
         if (total_sectors > VHD_MAX_SECTORS) {
             ret = -EFBIG;
             goto out;
@@ -932,7 +942,7 @@ static int vpc_create(const char *filename, QemuOpts *opts, Error **errp)
         total_size = total_sectors * BDRV_SECTOR_SIZE;
     }
 
-    /* Prepare the Hard Disk Footer */
+    /* Bereiten Sie die Festplatte Footer */
     memset(buf, 0, 1024);
 
     memcpy(footer->creator, "conectix", 8);
@@ -952,7 +962,7 @@ static int vpc_create(const char *filename, QemuOpts *opts, Error **errp)
     }
     footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE);
 
-    /* Version of Virtual PC 2007 */
+    /* Version von Virtual PC 2007 */
     footer->major = cpu_to_be16(0x0005);
     footer->minor = cpu_to_be16(0x0003);
     footer->orig_size = cpu_to_be64(total_size);
@@ -1028,7 +1038,7 @@ static QemuOptsList vpc_create_opts = {
                     "specified, rather than using the nearest CHS-based "
                     "calculation"
         },
-        { /* end of list */ }
+        { /* Ende der Liste */ }
     }
 };
 
diff --git a/block/win32-aio.c b/block/win32-aio.c
index 2d509a9..7b31134 100644
--- a/block/win32-aio.c
+++ b/block/win32-aio.c
@@ -56,7 +56,7 @@ typedef struct QEMUWin32AIOCB {
 } QEMUWin32AIOCB;
 
 /*
- * Completes an AIO request (calls the callback and frees the ACB).
+ * Vervollständigt ein AIO Anfrage (die Rückrufe und befreit den ACB).
  */
 static void win32_aio_process_completion(QEMUWin32AIOState *s,
     QEMUWin32AIOCB *waiocb, DWORD count)
@@ -69,7 +69,7 @@ static void win32_aio_process_completion(QEMUWin32AIOState *s,
     } else {
         ret = 0;
         if (count < waiocb->nbytes) {
-            /* Short reads mean EOF, pad with zeros. */
+            /* Kurz liest mittlere EOF, Pad mit Nullen. */
             if (waiocb->is_read) {
                 qemu_iovec_memset(waiocb->qiov, count, 0,
                     waiocb->qiov->size - count);
diff --git a/blockdev-nbd.c b/blockdev-nbd.c
index 12cae0e..fa13427 100644
--- a/blockdev-nbd.c
+++ b/blockdev-nbd.c
@@ -184,9 +184,10 @@ void qmp_nbd_server_add(const char *device, bool has_writable, bool writable,
 
     nbd_export_set_name(exp, device);
 
-    /* The list of named exports has a strong reference to this export now and
-     * our only way of accessing it is through nbd_export_find(), so we can drop
-     * the strong reference that is @exp. */
+    /* Die Liste der Namen Exporte hat einen starken Hinweis auf diese Export
+     * jetzt und unsere einzige Möglichkeit für den Zugriff ist durch
+     * nbd_export_find (), so können wir fallen die starke Referenz, die @Exp
+     * ist. */
     nbd_export_put(exp);
 }
 
diff --git a/qemu-img.c b/qemu-img.c
index 06264d9..30d8283 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -59,7 +59,8 @@ typedef enum OutputFormat {
     OFORMAT_HUMAN,
 } OutputFormat;
 
-/* Default to cache=writeback as data integrity is not important for qemu-img */
+/* Standard-Cache = writeback als Datenintegrität ist nicht wichtig für
+ * qemu-img */
 #define BDRV_DEFAULT_CACHE "writeback"
 
 static void format_print(void *opaque, const char *name)
@@ -81,7 +82,7 @@ static void QEMU_NORETURN GCC_FMT_ATTR(1, 2) error_exit(const char *fmt, ...)
     exit(EXIT_FAILURE);
 }
 
-/* Please keep in synch with qemu-img.texi */
+/* Bitte halten Sie synchron mit qemu-img.texi */
 static void QEMU_NORETURN help(void)
 {
     const char *help_msg =
@@ -199,7 +200,7 @@ static int print_block_option_help(const char *filename, const char *fmt)
     QemuOptsList *create_opts = NULL;
     Error *local_err = NULL;
 
-    /* Find driver and parse its options */
+    /* Finden Sie Treiber und analysieren seine Optionen */
     drv = bdrv_find_format(fmt);
     if (!drv) {
         error_report("Unknown file format '%s'", fmt);
@@ -420,7 +421,7 @@ static int img_create(int argc, char **argv)
         }
     }
 
-    /* Get the filename */
+    /* Holen Sie sich den Dateinamen */
     filename = (optind < argc) ? argv[optind] : NULL;
     if (options && has_help_option(options)) {
         g_free(options);
@@ -439,7 +440,7 @@ static int img_create(int argc, char **argv)
         goto fail;
     }
 
-    /* Get image size, if specified */
+    /* Erhalten Sie die Bildgröße, falls angegeben */
     if (optind < argc) {
         int64_t sval;
         char *end;
@@ -577,13 +578,14 @@ static int collect_image_check(BlockDriverState *bs,
 }
 
 /*
- * Checks an image for consistency. Exit codes:
+ * Prüft ein Bild für Konsistenz. Exit-Codes:
  *
- *  0 - Check completed, image is good
- *  1 - Check not completed because of internal errors
- *  2 - Check completed, image is corrupted
- *  3 - Check completed, image has leaked clusters, but is good otherwise
- * 63 - Checks are not supported by the image format
+ *  0 - Prüfung abgeschlossen, ist das Bild gut
+ *  1 - Überprüfen Sie aufgrund interner Fehler nicht abgeschlossen
+ *  2 - Überprüfen abgeschlossen, wird das Bild beschädigt
+ *  3 - Überprüfen Sie abgeschlossen, Bild durchgesickert Cluster hat, ist
+ *      aber gut anders
+ * 63 - Schecks werden nicht durch das Bildformat unterstützt
  */
 static int img_check(int argc, char **argv)
 {
@@ -787,8 +789,8 @@ static void run_block_job(BlockJob *job, Error **errp)
 
     block_job_complete_sync(job, errp);
 
-    /* A block job may finish instantaneously without publishing any progress,
-     * so just signal completion here */
+    /* Ein Block Job zu beenden kann sofort ohne irgendwelche Fortschritte zu
+     * veröffentlichen, so signalisieren nur Fertigstellung hier */
     qemu_progress_print(100.f, 0);
 }
 
@@ -832,7 +834,7 @@ static int img_commit(int argc, char **argv)
             break;
         case 'b':
             base = optarg;
-            /* -b implies -d */
+            /* -b impliziert -d */
             drop = true;
             break;
         case 'd':
@@ -858,7 +860,7 @@ static int img_commit(int argc, char **argv)
         }
     }
 
-    /* Progress is not shown in Quiet mode */
+    /* Der Fortschritt wird nicht im stillen Modus gezeigt */
     if (quiet) {
         progress = false;
     }
@@ -898,9 +900,10 @@ static int img_commit(int argc, char **argv)
             goto done;
         }
     } else {
-        /* This is different from QMP, which by default uses the deepest file in
-         * the backing chain (i.e., the very base); however, the traditional
-         * behavior of qemu-img commit is using the immediate backing file. */
+        /* Dies unterscheidet sich von QMP, die standardmäßig verwendet die
+         * tiefste Datei in die Trägerkette (das heißt, die eigentliche
+         * Basis); jedoch die traditionellen Verhalten von qemu-img begehen
+         * wird die sofortige Unterstützung Datei. */
         base_bs = backing_bs(bs);
         if (!base_bs) {
             error_setg(&local_err, "Image does not have a backing file");
@@ -919,10 +922,10 @@ static int img_commit(int argc, char **argv)
         goto done;
     }
 
-    /* When the block job completes, the BlockBackend reference will point to
-     * the old backing file. In order to avoid that the top image is already
-     * deleted, so we can still empty it afterwards, increment the reference
-     * counter here preemptively. */
+    /* Wenn der Block Auftrag abgeschlossen ist, zeigen die BlockBackend
+     * Bezug auf die alte Trägerdatei. Um zu vermeiden, dass das obere Bild
+     * ist schon gelöscht, so können wir es noch danach zu leeren, erhöhe
+     * den Referenz begegnen hier präventiv. */
     if (!drop) {
         bdrv_ref(bs);
     }
@@ -961,11 +964,12 @@ done:
 }
 
 /*
- * Returns true iff the first sector pointed to by 'buf' contains at least
- * a non-NUL byte.
+ * Gibt true zurück, genau dann, wenn der erste Sektor, auf den 'buf' enthält
+ * mindestens ein nicht-NUL-Byte.
  *
- * 'pnum' is set to the number of sectors (including and immediately following
- * the first one) that are known to be in the same allocated/unallocated state.
+ * 'Pnum' ist auf die Anzahl der Sektoren gesetzt (einschließlich und
+ * unmittelbar im Anschluss an die erste), die in derselben zugeordnet / nicht
+ * zugeordneten Zustand bekannt sind.
  */
 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 {
@@ -988,9 +992,10 @@ static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 }
 
 /*
- * Like is_allocated_sectors, but if the buffer starts with a used sector,
- * up to 'min' consecutive sectors containing zeros are ignored. This avoids
- * breaking up write requests for only small sparse areas.
+ * Wie is_allocated_sectors, aber wenn der Puffer mit einem verwendeten Sektor
+ * beginnt, bis zu 'min' aufeinanderfolgenden Sektoren Nullen enthalten,
+ * werden ignoriert. Dies vermeidet Schreibanforderungen nur für kleine
+ * spärlich Bereiche Zerschlagung.
  */
 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
     int min)
@@ -1030,11 +1035,12 @@ static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
 }
 
 /*
- * Compares two buffers sector by sector. Returns 0 if the first sector of both
- * buffers matches, non-zero otherwise.
+ * Vergleicht zwei Puffer Sektor für Sektor. 0 zurück, wenn der erste Sektor
+ * von sowohl Puffer Streichhölzer, nicht Null sonst.
  *
- * pnum is set to the number of sectors (including and immediately following
- * the first one) that are known to have the same comparison result
+ * pnum ist auf die Anzahl der Sektoren gesetzt (einschließlich und unmittelbar
+ * im Anschluss an der erste), die die gleiche Vergleichsergebnis bekannt
+ * sind, haben
  */
 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
     int *pnum)
@@ -1074,17 +1080,18 @@ static int64_t sectors_to_process(int64_t total, int64_t from)
 }
 
 /*
- * Check if passed sectors are empty (not allocated or contain only 0 bytes)
+ * Überprüfen Sie, ob vergangen Sektoren leer sind (nicht zugeordnet oder
+ * enthalten nur 0 Bytes)
  *
- * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
- * data and negative value on error.
+ * Gibt 0 zurück, falls Sektoren mit 0 gefüllt, 1, wenn Sektoren enthalten
+ * nicht Null Daten und negativen Wert auf Fehler.
  *
- * @param blk:  BlockBackend for the image
- * @param sect_num: Number of first sector to check
- * @param sect_count: Number of sectors to check
- * @param filename: Name of disk file we are checking (logging purpose)
- * @param buffer: Allocated buffer for storing read data
- * @param quiet: Flag for quiet mode
+ * @param blk: BlockBackend für das Bild
+ * @param sect_num: Anzahl der ersten Sektor zu prüfen,
+ * @param sect_count: Anzahl der Sektoren zu überprüfen
+ * @param Dateiname: Name der Plattendatei prüfen wir (Anmeldung Zweck)
+ * @param Puffer: Allocated Puffer gelesenen Daten zum Speichern
+ * @param ruhig: Flag für den Ruhemodus
  */
 static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
                                int sect_count, const char *filename,
@@ -1108,11 +1115,11 @@ static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
 }
 
 /*
- * Compares two images. Exit codes:
+ * Vergleicht zwei Bilder. Exit-Codes:
  *
- * 0 - Images are identical
- * 1 - Images differ
- * >1 - Error occurred
+ * 0 - Bilder sind identisch
+ * 1 - Bilder unterscheiden
+ * >1 - Fehler aufgetreten
  */
 static int img_compare(int argc, char **argv)
 {
@@ -1123,7 +1130,7 @@ static int img_compare(int argc, char **argv)
     uint8_t *buf1 = NULL, *buf2 = NULL;
     int pnum1, pnum2;
     int allocated1, allocated2;
-    int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
+    int ret = 0; /* Rückgabewert - 0 Ident, 1 Verschiedene,> 1 Fehler */
     bool progress = false, quiet = false, strict = false;
     int flags;
     bool writethrough;
@@ -1186,7 +1193,7 @@ static int img_compare(int argc, char **argv)
         }
     }
 
-    /* Progress is not shown in Quiet mode */
+    /* Der Fortschritt wird nicht im stillen Modus gezeigt */
     if (quiet) {
         progress = false;
     }
@@ -1206,7 +1213,7 @@ static int img_compare(int argc, char **argv)
         goto out4;
     }
 
-    /* Initialize before goto out */
+    /* Initialisieren, bevor gehe aus */
     qemu_progress_init(progress, 2.0);
 
     flags = 0;
@@ -1475,11 +1482,11 @@ static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
         } else if (ret & BDRV_BLOCK_DATA) {
             s->status = BLK_DATA;
         } else if (!s->target_has_backing) {
-            /* Without a target backing file we must copy over the contents of
-             * the backing file as well. */
-            /* TODO Check block status of the backing file chain to avoid
-             * needlessly reading zeroes and limiting the iteration to the
-             * buffer size */
+            /* Ohne eine Zielträgerdatei müssen wir über den Inhalt kopieren
+             * als auch die Trägerdatei. */
+            /* TODO überprüfen Block Status der Trägerdatei Kette zu
+             * vermeiden unnötig Nullen und die Begrenzung der Iteration auf
+             * das Lesen Puffergröße */
             s->status = BLK_DATA;
         } else {
             s->status = BLK_BACKING_FILE;
@@ -1493,9 +1500,9 @@ static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
         n = MIN(n, s->buf_sectors);
     }
 
-    /* We need to write complete clusters for compressed images, so if an
-     * unallocated area is shorter than that, we must consider the whole
-     * cluster allocated. */
+    /* Wir müssen komplette Cluster für komprimierte Bilder zu schreiben, so
+     * dass, wenn ein nicht zugewiesenen Bereich kürzer ist als das, müssen
+     * wir die ganze betrachten Cluster zugeordnet. */
     if (s->compressed) {
         if (n < s->cluster_sectors) {
             n = MIN(s->cluster_sectors, s->total_sectors - sector_num);
@@ -1519,9 +1526,10 @@ static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sectors,
         BlockBackend *blk;
         int64_t bs_sectors;
 
-        /* In the case of compression with multiple source files, we can get a
-         * nb_sectors that spreads into the next part. So we must be able to
-         * read across multiple BDSes for one convert_read() call. */
+        /* Im Falle der Komprimierung mit mehreren Quelldateien, können wir
+         * eine bekommen nb_sectors, die in den nächsten Teil ausbreitet.
+         * Deshalb müssen wir in der Lage sein, Lesen Sie über mehrere BDSes
+         * für ein convert_read () Aufruf. */
         convert_select_part(s, sector_num);
         blk = s->src[s->src_cur];
         bs_sectors = s->src_sectors[s->src_cur];
@@ -1550,17 +1558,18 @@ static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
 
         switch (s->status) {
         case BLK_BACKING_FILE:
-            /* If we have a backing file, leave clusters unallocated that are
-             * unallocated in the source image, so that the backing file is
-             * visible at the respective offset. */
+            /* Wenn wir eine Trägerdatei haben, lassen Cluster nicht
+             * zugeordneten, das sind in dem Quellenbild nicht zugewiesenen,
+             * so dass die Trägerdatei sichtbar an der jeweiligen Offset. */
             assert(s->target_has_backing);
             break;
 
         case BLK_DATA:
-            /* We must always write compressed clusters as a whole, so don't
-             * try to find zeroed parts in the buffer. We can only save the
-             * write if the buffer is completely zeroed and we're allowed to
-             * keep the target sparse. */
+            /* Wir müssen immer komprimiert Cluster als Ganzes zu schreiben,
+             * also nicht versuchen genullten Teile in den Puffer zu finden.
+             * Wir können nur sparen die schreiben, wenn der Puffer
+             * vollständig auf Null gestellt wird und wir dürfen halten das
+             * Ziel spärlich. */
             if (s->compressed) {
                 if (s->has_zero_init && s->min_sparse &&
                     buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))
@@ -1576,9 +1585,9 @@ static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
                 break;
             }
 
-            /* If there is real non-zero data or we're told to keep the target
-             * fully allocated (-S 0), we must write it. Otherwise we can treat
-             * it as zero sectors. */
+            /* Wenn es echte Daten ungleich Null oder wir gesagt, das Ziel
+             * zu halten vollständig (-S 0), können wir es schreiben müssen.
+             * Sonst können wir behandeln als Null Sektoren. */
             if (!s->min_sparse ||
                 is_allocated_sectors_min(buf, n, &n, s->min_sparse))
             {
@@ -1588,7 +1597,7 @@ static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_sectors,
                 }
                 break;
             }
-            /* fall-through */
+            /* durchfallen */
 
         case BLK_ZERO:
             if (s->has_zero_init) {
@@ -1616,7 +1625,8 @@ static int convert_do_copy(ImgConvertState *s)
     int ret;
     int n;
 
-    /* Check whether we have zero initialisation or can get it efficiently */
+    /* Überprüfen Sie, ob wir Null Initialisierung haben oder es kann
+     * effizient erhalten */
     s->has_zero_init = s->min_sparse && !s->target_has_backing
                      ? bdrv_has_zero_init(blk_bs(s->target))
                      : false;
@@ -1630,8 +1640,8 @@ static int convert_do_copy(ImgConvertState *s)
         }
     }
 
-    /* Allocate buffer for copied data. For compressed images, only one cluster
-     * can be copied at a time. */
+    /* Ordnen Sie Puffer für kopierten Daten. Für komprimierte Bilder, nur
+     * ein Cluster kann zu einem Zeitpunkt kopiert werden. */
     if (s->compressed) {
         if (s->cluster_sectors <= 0 || s->cluster_sectors > s->buf_sectors) {
             error_report("invalid cluster size");
@@ -1642,7 +1652,7 @@ static int convert_do_copy(ImgConvertState *s)
     }
     buf = blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE);
 
-    /* Calculate allocated sectors for progress */
+    /* Berechnen zugeordnet Sektoren für den Fortschritt */
     s->allocated_sectors = 0;
     sector_num = 0;
     while (sector_num < s->total_sectors) {
@@ -1658,7 +1668,7 @@ static int convert_do_copy(ImgConvertState *s)
         sector_num += n;
     }
 
-    /* Do the copy */
+    /* Haben die Kopie */
     s->src_cur = 0;
     s->src_cur_offset = 0;
     s->sector_next_status = 0;
@@ -1703,7 +1713,7 @@ static int convert_do_copy(ImgConvertState *s)
     }
 
     if (s->compressed) {
-        /* signal EOF to align */
+        /* Signal EOF ausrichten */
         ret = blk_write_compressed(s->target, 0, NULL, 0);
         if (ret < 0) {
             goto fail;
@@ -1735,7 +1745,8 @@ static int img_convert(int argc, char **argv)
     const char *out_baseimg_param;
     char *options = NULL;
     const char *snapshot_name = NULL;
-    int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
+    int min_sparse = 8; /* mindestens 4k von Nullen für spärliche Erkennung
+                           benötigen */
     bool quiet = false;
     Error *local_err = NULL;
     QemuOpts *sn_opts = NULL;
@@ -1868,7 +1879,7 @@ static int img_convert(int argc, char **argv)
         goto fail_getopt;
     }
 
-    /* Initialize before goto out */
+    /* Initialisieren, bevor gehe aus */
     if (quiet) {
         progress = 0;
     }
@@ -1946,7 +1957,7 @@ static int img_convert(int argc, char **argv)
         goto out;
     }
 
-    /* Find driver and parse its options */
+    /* Finden Sie Treiber und analysieren seine Optionen */
     drv = bdrv_find_format(out_fmt);
     if (!drv) {
         error_report("Unknown file format '%s'", out_fmt);
@@ -1997,13 +2008,13 @@ static int img_convert(int argc, char **argv)
         }
     }
 
-    /* Get backing file name if -o backing_file was used */
+    /* Erhalten Sie Dateinamen sichern, wenn -o backing_file verwendet wurde, */
     out_baseimg_param = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
     if (out_baseimg_param) {
         out_baseimg = out_baseimg_param;
     }
 
-    /* Check if compression is supported */
+    /* Überprüfen Sie, ob die Komprimierung unterstützt wird */
     if (compress) {
         bool encryption =
             qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, false);
@@ -2034,7 +2045,7 @@ static int img_convert(int argc, char **argv)
     }
 
     if (!skip_create) {
-        /* Create the new image */
+        /* Erstellen Sie das neue Bild */
         ret = bdrv_create(drv, out_filename, opts, &local_err);
         if (ret < 0) {
             error_reportf_err(local_err, "%s: error while converting %s: ",
@@ -2050,10 +2061,10 @@ static int img_convert(int argc, char **argv)
         goto out;
     }
 
-    /* XXX we should allow --image-opts to trigger use of
-     * img_open() here, but then we have trouble with
-     * the bdrv_create() call which takes different params.
-     * Not critical right now, so fix can wait...
+    /* XXX sollten wir --image-opts ermöglichen die Verwendung von auszulösen
+     * img_open () hier, aber dann haben wir Probleme mit
+     * die bdrv_create () Aufruf, die unterschiedliche params nimmt.
+     * Nicht kritisch gerade jetzt, so reparieren kann warten ...
      */
     out_blk = img_open_file(out_filename, out_fmt, flags, writethrough, quiet);
     if (!out_blk) {
@@ -2062,9 +2073,9 @@ static int img_convert(int argc, char **argv)
     }
     out_bs = blk_bs(out_blk);
 
-    /* increase bufsectors from the default 4096 (2M) if opt_transfer_length
-     * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB)
-     * as maximum. */
+    /* erhöhen bufsectors von der Standard-4096 (2M), wenn opt_transfer_length
+     * oder discard_alignment der out_bs größer ist. Beschränken auf 32.768
+     * (16MB) als Maximum. */
     bufsectors = MIN(32768,
                      MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length,
                                          out_bs->bl.discard_alignment))
@@ -2210,15 +2221,15 @@ static gboolean str_equal_func(gconstpointer a, gconstpointer b)
 }
 
 /**
- * Open an image file chain and return an ImageInfoList
+ * Öffnen Sie eine Bilddatei Kette und geben eine ImageInfoList
  *
- * @filename: topmost image filename
- * @fmt: topmost image format (may be NULL to autodetect)
- * @chain: true  - enumerate entire backing file chain
- *         false - only topmost image file
+ * @filename: oberste Dateiname Bild
+ * @fmt: oberste Bildformat (kann NULL sein, um die automatische Erkennung)
+ * @chain: true - aufzuzählen gesamte Trägerdatei Kette
+ *         false - nur oberste Bilddatei
  *
- * Returns a list of ImageInfo objects or NULL if there was an error opening an
- * image file.  If there was an error a message will have been printed to
+ * Gibt eine Liste von Objekten oder Imageinfo NULL, wenn es einen Fehler gab
+ * eine Öffnung Bilddatei. Wenn ein Fehler eine Meldung war gedruckt wurden
  * stderr.
  */
 static ImageInfoList *collect_image_info_list(bool image_opts,
@@ -2404,8 +2415,9 @@ static void dump_map_entry(OutputFormat output_format, MapEntry *e,
                    e->has_offset ? e->offset : 0,
                    e->has_filename ? e->filename : "");
         }
-        /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
-         * Modify the flags here to allow more coalescing.
+        /* Dieses Format ignoriert die Unterscheidung zwischen 0, ZERO und
+         * ZERO | DATA. Ändern Sie die Fahnen hier, um mehr Koaleszierstruktur
+         * ermöglichen.
          */
         if (next && (!next->data || next->zero)) {
             next->data = false;
@@ -2439,9 +2451,9 @@ static int get_block_status(BlockDriverState *bs, int64_t sector_num,
     BlockDriverState *file;
     bool has_offset;
 
-    /* As an optimization, we could cache the current range of unallocated
-     * clusters in each file of the chain, and avoid querying the same
-     * range repeatedly.
+    /* Als Optimierung konnten wir den Strombereich von nicht zugeordneten
+     * cachen Cluster in jeder Datei der Kette, und vermeiden Sie die gleiche
+     * Abfrage reichen wiederholt.
      */
 
     depth = 0;
@@ -2595,7 +2607,7 @@ static int img_map(int argc, char **argv)
 
         sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
 
-        /* Probe up to 1 GiB at a time.  */
+        /* Sonde bis zu 1 GiB zu einem Zeitpunkt.  */
         nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
         n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
         ret = get_block_status(bs, sector_num, n, &next);
@@ -2642,7 +2654,7 @@ static int img_snapshot(int argc, char **argv)
     bool image_opts = false;
 
     bdrv_oflags = BDRV_O_RDWR;
-    /* Parse commandline parameters */
+    /* Parse Kommandozeilenparameter */
     for(;;) {
         static const struct option long_options[] = {
             {"help", no_argument, 0, 'h'},
@@ -2666,7 +2678,7 @@ static int img_snapshot(int argc, char **argv)
                 return 0;
             }
             action = SNAPSHOT_LIST;
-            bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
+            bdrv_oflags &= ~BDRV_O_RDWR; /* keine Notwendigkeit für RW */
             break;
         case 'a':
             if (action) {
@@ -2721,14 +2733,14 @@ static int img_snapshot(int argc, char **argv)
         return 1;
     }
 
-    /* Open the image */
+    /* Öffnen Sie das Bild */
     blk = img_open(image_opts, filename, NULL, bdrv_oflags, false, quiet);
     if (!blk) {
         return 1;
     }
     bs = blk_bs(blk);
 
-    /* Perform the requested action */
+    /* Führen Sie die gewünschte Aktion */
     switch(action) {
     case SNAPSHOT_LIST:
         dump_snapshots(bs);
@@ -2767,7 +2779,7 @@ static int img_snapshot(int argc, char **argv)
         break;
     }
 
-    /* Cleanup */
+    /* Aufräumen */
     blk_unref(blk);
     if (ret) {
         return 1;
@@ -2791,7 +2803,7 @@ static int img_rebase(int argc, char **argv)
     Error *local_err = NULL;
     bool image_opts = false;
 
-    /* Parse commandline parameters */
+    /* Parse Kommandozeilenparameter */
     fmt = NULL;
     cache = BDRV_DEFAULT_CACHE;
     src_cache = BDRV_DEFAULT_CACHE;
@@ -2888,15 +2900,17 @@ static int img_rebase(int argc, char **argv)
         goto out;
     }
 
-    /* The source files are opened read-only, don't care about WCE */
+    /* Die Quelldateien werden geöffnet schreibgeschützt, kümmern sich nicht
+     * um WCE */
     assert((src_flags & BDRV_O_RDWR) == 0);
     (void) src_writethrough;
 
     /*
-     * Open the images.
+     * Öffnen Sie die Bilder.
      *
-     * Ignore the old backing file for unsafe rebase in case we want to correct
-     * the reference to a renamed or moved backing file.
+     * Ignorieren Sie die alte Trägerdatei für unsichere Rebase im Fall wollen
+     * wir korrigieren der Verweis auf eine Träger Datei umbenannt oder
+     * verschoben.
      */
     blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
     if (!blk) {
@@ -2913,7 +2927,8 @@ static int img_rebase(int argc, char **argv)
         }
     }
 
-    /* For safe rebasing we need to compare old and new backing file */
+    /* Für eine sichere Rebasing brauchen wir alte und neue Trägerdatei zu
+     * vergleichen */
     if (!unsafe) {
         char backing_name[PATH_MAX];
         QDict *options = NULL;
@@ -2953,13 +2968,14 @@ static int img_rebase(int argc, char **argv)
     }
 
     /*
-     * Check each unallocated cluster in the COW file. If it is unallocated,
-     * accesses go to the backing file. We must therefore compare this cluster
-     * in the old and new backing file, and if they differ we need to copy it
-     * from the old backing file into the COW file.
+     * Überprüfen Sie jede nicht zugewiesenen Cluster in der COW-Datei. Wenn
+     * es nicht zugeordneten ist, gehen Zugriffe auf die Trägerdatei. Daher
+     * müssen wir diese Cluster vergleichen in den alten und neuen
+     * Trägerdatei, und wenn sie sich unterscheiden müssen wir es zu kopieren
+     * von der alten Trägerdatei in die COW-Datei.
      *
-     * If qemu-img crashes during this step, no harm is done. The content of
-     * the image is the same as the original one at any time.
+     * Wenn qemu-img Abstürze während dieses Schritts wird kein Schaden. Der
+     * Inhalt von das Bild ist das gleiche wie das Original zu jeder Zeit.
      */
     if (!unsafe) {
         int64_t num_sectors;
@@ -3006,14 +3022,15 @@ static int img_rebase(int argc, char **argv)
 
         for (sector = 0; sector < num_sectors; sector += n) {
 
-            /* How many sectors can we handle with the next read? */
+            /* Wie viele Sektoren können wir mit dem nächsten Lese umgehen? */
             if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
                 n = (IO_BUF_SIZE / 512);
             } else {
                 n = num_sectors - sector;
             }
 
-            /* If the cluster is allocated, we don't need to take action */
+            /* Wenn der Cluster zugeordnet ist, brauchen wir keine Maßnahmen
+             * zu ergreifen, */
             ret = bdrv_is_allocated(bs, sector, n, &n);
             if (ret < 0) {
                 error_report("error while reading image metadata: %s",
@@ -3025,8 +3042,8 @@ static int img_rebase(int argc, char **argv)
             }
 
             /*
-             * Read old and new backing file and take into consideration that
-             * backing files may be smaller than the COW image.
+             * Lesen Sie alte und neue Trägerdatei und beachten Sie, dass
+             * kann das Sichern von Dateien kleiner als die Kuh Bild.
              */
             if (sector >= old_backing_num_sectors) {
                 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
@@ -3056,7 +3073,8 @@ static int img_rebase(int argc, char **argv)
                 }
             }
 
-            /* If they differ, we need to write to the COW file */
+            /* Wenn sie sich unterscheiden, müssen wir in die COW-Datei zu
+             * schreiben */
             uint64_t written = 0;
 
             while (written < n) {
@@ -3081,9 +3099,10 @@ static int img_rebase(int argc, char **argv)
     }
 
     /*
-     * Change the backing file. All clusters that are different from the old
-     * backing file are overwritten in the COW file now, so the visible content
-     * doesn't change when we switch the backing file.
+     * Ändern Sie die Trägerdatei. Alle Cluster, die verschieden von der
+     * alten sind Trägerdatei werden nun in der COW-Datei überschrieben, so
+     * dass der Inhalt sichtbar ändert sich nicht, wenn wir die
+     * Unterstützung Datei wechseln.
      */
     if (out_baseimg && *out_baseimg) {
         ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
@@ -3101,14 +3120,15 @@ static int img_rebase(int argc, char **argv)
 
     qemu_progress_print(100, 0);
     /*
-     * TODO At this point it is possible to check if any clusters that are
-     * allocated in the COW file are the same in the backing file. If so, they
-     * could be dropped from the COW file. Don't do this before switching the
-     * backing file, in case of a crash this would lead to corruption.
+     * TODO An dieser Stelle ist es möglich, zu überprüfen, ob alle Cluster,
+     * die sind in der COW-Datei zugeordnet sind gleich in der Trägerdatei.
+     * Wenn ja, sie konnte von der Kuh-Datei gelöscht werden. Tun Sie dies
+     * nicht, bevor die Schalt Datei, in einem Crash-Fall die Sicherung
+     * dieser würde zu Korruption führen.
      */
 out:
     qemu_progress_end();
-    /* Cleanup */
+    /* Aufräumen */
     if (!unsafe) {
         blk_unref(blk_old_backing);
         blk_unref(blk_new_backing);
@@ -3143,14 +3163,14 @@ static int img_resize(int argc, char **argv)
                 .type = QEMU_OPT_SIZE,
                 .help = "Virtual disk size"
             }, {
-                /* end of list */
+                /* Ende der Liste */
             }
         },
     };
     bool image_opts = false;
 
-    /* Remove size from argv manually so that negative numbers are not treated
-     * as options by getopt. */
+    /* Entfernen der Größe von argv manuell so daß negative Zahlen nicht
+     * behandelt werden wie Optionen, die von getopt. */
     if (argc < 3) {
         error_exit("Not enough arguments");
         return 1;
@@ -3158,7 +3178,7 @@ static int img_resize(int argc, char **argv)
 
     size = argv[--argc];
 
-    /* Parse getopt arguments */
+    /* Parse getopt Argumente */
     fmt = NULL;
     for(;;) {
         static const struct option long_options[] = {
@@ -3208,7 +3228,7 @@ static int img_resize(int argc, char **argv)
         return 1;
     }
 
-    /* Choose grow, shrink, or absolute resize mode */
+    /* Wählen Sie wachsen, schrumpfen oder absolute Resize-Modus */
     switch (size[0]) {
     case '+':
         relative = 1;
@@ -3223,7 +3243,7 @@ static int img_resize(int argc, char **argv)
         break;
     }
 
-    /* Parse size */
+    /* Parse Größe */
     param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
     qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
     if (err) {
@@ -3377,8 +3397,8 @@ static int img_amend(int argc, char **argv)
 
     filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
     if (fmt && has_help_option(options)) {
-        /* If a format is explicitly specified (and possibly no filename is
-         * given), print option help here */
+        /* Wenn ein Format explizit angegeben wird (und möglicherweise kein
+         * Dateiname ist hier gegeben), Hilfe Druckoption */
         ret = print_block_option_help(filename, fmt);
         goto out;
     }
@@ -3406,7 +3426,7 @@ static int img_amend(int argc, char **argv)
     fmt = bs->drv->format_name;
 
     if (has_help_option(options)) {
-        /* If the format was auto-detected, print option help here */
+        /* Wenn das Format wurde automatisch erkannt, Druckoption Hilfe hier */
         ret = print_block_option_help(filename, fmt);
         goto out;
     }
@@ -3429,7 +3449,7 @@ static int img_amend(int argc, char **argv)
         }
     }
 
-    /* In case the driver does not call amend_status_cb() */
+    /* Im Falle, dass der Fahrer nicht nennen amend_status_cb () */
     qemu_progress_print(0.f, 0);
     ret = bdrv_amend_options(bs, opts, &amend_status_cb, NULL);
     qemu_progress_print(100.f, 0);
@@ -3496,7 +3516,7 @@ int main(int argc, char **argv)
     qemu_add_opts(&qemu_object_opts);
     qemu_add_opts(&qemu_source_opts);
 
-    /* find the command */
+    /* finden Sie den Befehl */
     for (cmd = img_cmds; cmd->name != NULL; cmd++) {
         if (!strcmp(cmdname, cmd->name)) {
             return cmd->handler(argc - 1, argv + 1);
@@ -3513,6 +3533,6 @@ int main(int argc, char **argv)
         return 0;
     }
 
-    /* not found */
+    /* nicht gefunden */
     error_exit("Command not found: %s", cmdname);
 }
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index 382faa8..ec20579 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -13,7 +13,7 @@
 #include "qemu-io.h"
 #include "sysemu/block-backend.h"
 #include "block/block.h"
-#include "block/block_int.h" /* for info_f() */
+#include "block/block_int.h" /* für info_f () */
 #include "block/qapi.h"
 #include "qemu/error-report.h"
 #include "qemu/main-loop.h"
@@ -102,7 +102,7 @@ static const cmdinfo_t *find_command(const char *cmd)
     return NULL;
 }
 
-/* Invoke fn() for commands with a matching prefix */
+/* Rufen Sie fn () für Befehle mit einem passenden Präfix */
 void qemuio_complete_command(const char *input,
                              void (*fn)(const char *cmd, void *opaque),
                              void *opaque)
@@ -143,7 +143,7 @@ static int64_t cvtnum(const char *s)
 
     ret = qemu_strtosz_suffix(s, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
     if (*end != '\0') {
-        /* Detritus at the end of the string */
+        /* Detritus am Ende der Zeichenfolge */
         return -EINVAL;
     }
     return ret;
@@ -254,7 +254,7 @@ static void timestr(struct timeval *tv, char *ts, size_t size, int format)
                     (unsigned int) (usec * 100));
             return;
         }
-        format |= VERBOSE_FIXED_TIME; /* fallback if hours needed */
+        format |= VERBOSE_FIXED_TIME; /* Rückfall, wenn Stunden benötigt */
     }
 
     if ((format & VERBOSE_FIXED_TIME) || tv->tv_sec) {
@@ -269,10 +269,10 @@ static void timestr(struct timeval *tv, char *ts, size_t size, int format)
 }
 
 /*
- * Parse the pattern argument to various sub-commands.
+ * Analysieren Sie die Muster Argument verschiedenen Unterbefehle.
  *
- * Because the pattern is used as an argument to memset it must evaluate
- * to an unsigned integer that fits into a single byte.
+ * Da das Muster als Argument verwendet wird, um memset auswerten müssen
+ * auf eine ganze Zahl ohne Vorzeichen, die in einem einzigen Byte passt.
  */
 static int parse_pattern(const char *arg)
 {
@@ -289,10 +289,11 @@ static int parse_pattern(const char *arg)
 }
 
 /*
- * Memory allocation helpers.
+ * Speicherzuordnung Helfer.
  *
- * Make sure memory is aligned by default, or purposefully misaligned if
- * that is specified on the command line.
+ * Stellen Sie sicher, dass Speicher ist standardmäßig ausgerichtet sind,
+ * oder absichtlich falsch ausgerichtet, wenn dass auf der Befehlszeile
+ * angegeben.
  */
 
 #define MISALIGN_OFFSET     16
@@ -357,7 +358,7 @@ static void print_report(const char *op, struct timeval *t, int64_t offset,
                op, total, count, offset);
         printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
                s1, cnt, ts, s2, tdiv((double)cnt, *t));
-    } else {/* bytes,ops,time,bytes/sec,ops/sec */
+    } else {/* Bytes, ops, Zeit, Bytes / sec, ops / sec */
         printf("%"PRId64",%d,%s,%.3f,%.3f\n",
             total, cnt, ts,
             tdiv((double)total, *t),
@@ -366,8 +367,8 @@ static void print_report(const char *op, struct timeval *t, int64_t offset,
 }
 
 /*
- * Parse multiple length statements for vectored I/O, and construct an I/O
- * vector matching it.
+ * Parse mehrere Länge Anweisungen für vektorisiert I / O, und bauen eine
+ * I / O Vektor passende es.
  */
 static void *
 create_iovec(BlockBackend *blk, QEMUIOVector *qiov, char **argv, int nr_iov,
@@ -389,7 +390,7 @@ create_iovec(BlockBackend *blk, QEMUIOVector *qiov, char **argv, int nr_iov,
             goto fail;
         }
 
-        /* should be SIZE_T_MAX, but that doesn't exist */
+        /* SIZE_T_MAX sein sollte, aber das ist nicht vorhanden */
         if (len > INT_MAX) {
             printf("Argument '%s' exceeds maximum size %d\n", arg, INT_MAX);
             goto fail;
@@ -701,7 +702,8 @@ static int read_f(BlockBackend *blk, int argc, char **argv)
     char *buf;
     int64_t offset;
     int64_t count;
-    /* Some compilers get confused and warn if this is not initialized.  */
+    /* Einige Compiler verwirrt und warnen, wenn dies nicht initialisiert
+     * wird. */
     int64_t total = 0;
     int pattern = 0;
     int64_t pattern_offset = 0, pattern_count = 0;
@@ -839,7 +841,7 @@ static int read_f(BlockBackend *blk, int argc, char **argv)
         dump_buffer(buf, offset, count);
     }
 
-    /* Finally, report back -- -C gives a parsable format */
+    /* Schließlich Bericht zurück - bis C gibt ein Parse-Format */
     t2 = tsub(t2, t1);
     print_report("read", &t2, offset, count, total, cnt, Cflag);
 
@@ -887,7 +889,8 @@ static int readv_f(BlockBackend *blk, int argc, char **argv)
     int c, cnt;
     char *buf;
     int64_t offset;
-    /* Some compilers get confused and warn if this is not initialized.  */
+    /* Einige Compiler verwirrt und warnen, wenn dies nicht initialisiert
+     * wird. */
     int total = 0;
     int nr_iov;
     QEMUIOVector qiov;
@@ -968,7 +971,7 @@ static int readv_f(BlockBackend *blk, int argc, char **argv)
         dump_buffer(buf, offset, qiov.size);
     }
 
-    /* Finally, report back -- -C gives a parsable format */
+    /* Schließlich Bericht zurück - bis C gibt ein Parse-Format */
     t2 = tsub(t2, t1);
     print_report("read", &t2, offset, qiov.size, total, cnt, Cflag);
 
@@ -1021,7 +1024,8 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
     char *buf = NULL;
     int64_t offset;
     int64_t count;
-    /* Some compilers get confused and warn if this is not initialized.  */
+    /* Einige Compiler verwirrt und warnen, wenn dies nicht initialisiert
+     * wird. */
     int64_t total = 0;
     int pattern = 0xcd;
 
@@ -1129,7 +1133,7 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
         goto out;
     }
 
-    /* Finally, report back -- -C gives a parsable format */
+    /* Schließlich Bericht zurück - bis C gibt ein Parse-Format */
     t2 = tsub(t2, t1);
     print_report("wrote", &t2, offset, count, total, cnt, Cflag);
 
@@ -1178,7 +1182,8 @@ static int writev_f(BlockBackend *blk, int argc, char **argv)
     int c, cnt;
     char *buf;
     int64_t offset;
-    /* Some compilers get confused and warn if this is not initialized.  */
+    /* Einige Compiler verwirrt und warnen, wenn dies nicht initialisiert
+     * wird. */
     int total = 0;
     int nr_iov;
     int pattern = 0xcd;
@@ -1239,7 +1244,7 @@ static int writev_f(BlockBackend *blk, int argc, char **argv)
         goto out;
     }
 
-    /* Finally, report back -- -C gives a parsable format */
+    /* Schließlich Bericht zurück - bis C gibt ein Parse-Format */
     t2 = tsub(t2, t1);
     print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag);
 out:
@@ -1287,7 +1292,8 @@ static int multiwrite_f(BlockBackend *blk, int argc, char **argv)
     int c, cnt;
     char **buf;
     int64_t offset, first_offset = 0;
-    /* Some compilers get confused and warn if this is not initialized.  */
+    /* Einige Compiler verwirrt und warnen, wenn dies nicht initialisiert
+     * wird. */
     int total = 0;
     int nr_iov;
     int nr_reqs;
@@ -1333,7 +1339,7 @@ static int multiwrite_f(BlockBackend *blk, int argc, char **argv)
     for (i = 0; i < nr_reqs && optind < argc; i++) {
         int j;
 
-        /* Read the offset of the request */
+        /* Lesen Sie Offset des Antrags */
         offset = cvtnum(argv[optind]);
         if (offset < 0) {
             print_cvtnum_err(offset, argv[optind]);
@@ -1351,7 +1357,7 @@ static int multiwrite_f(BlockBackend *blk, int argc, char **argv)
             first_offset = offset;
         }
 
-        /* Read lengths for qiov entries */
+        /* Lesen Sie Längen für qiov Einträge */
         for (j = optind; j < argc; j++) {
             if (!strcmp(argv[j], ";")) {
                 break;
@@ -1360,7 +1366,7 @@ static int multiwrite_f(BlockBackend *blk, int argc, char **argv)
 
         nr_iov = j - optind;
 
-        /* Build request */
+        /* Bauen Sie Anfrage */
         buf[i] = create_iovec(blk, &qiovs[i], &argv[optind], nr_iov, pattern);
         if (buf[i] == NULL) {
             goto out;
@@ -1375,7 +1381,7 @@ static int multiwrite_f(BlockBackend *blk, int argc, char **argv)
         pattern++;
     }
 
-    /* If there were empty requests at the end, ignore them */
+    /* Wenn es am Ende leer Anfragen waren, ignorieren sie */
     nr_reqs = i;
 
     gettimeofday(&t1, NULL);
@@ -1391,7 +1397,7 @@ static int multiwrite_f(BlockBackend *blk, int argc, char **argv)
         goto out;
     }
 
-    /* Finally, report back -- -C gives a parsable format */
+    /* Schließlich Bericht zurück - bis C gibt ein Parse-Format */
     t2 = tsub(t2, t1);
     print_report("wrote", &t2, first_offset, total, total, cnt, Cflag);
 out:
@@ -1441,7 +1447,7 @@ static void aio_write_done(void *opaque, int ret)
         goto out;
     }
 
-    /* Finally, report back -- -C gives a parsable format */
+    /* Schließlich Bericht zurück - bis C gibt ein Parse-Format */
     t2 = tsub(t2, ctx->t1);
     print_report("wrote", &t2, ctx->offset, ctx->qiov.size,
                  ctx->qiov.size, 1, ctx->Cflag);
@@ -1485,7 +1491,7 @@ static void aio_read_done(void *opaque, int ret)
         dump_buffer(ctx->buf, ctx->offset, ctx->qiov.size);
     }
 
-    /* Finally, report back -- -C gives a parsable format */
+    /* Schließlich Bericht zurück - bis C gibt ein Parse-Format */
     t2 = tsub(t2, ctx->t1);
     print_report("read", &t2, ctx->offset, ctx->qiov.size,
                  ctx->qiov.size, 1, ctx->Cflag);
@@ -1900,7 +1906,7 @@ static int discard_f(BlockBackend *blk, int argc, char **argv)
         goto out;
     }
 
-    /* Finally, report back -- -C gives a parsable format */
+    /* Schließlich Bericht zurück - bis C gibt ein Parse-Format */
     if (!qflag) {
         t2 = tsub(t2, t1);
         print_report("discard", &t2, offset, count, count, 1, Cflag);
@@ -2084,8 +2090,8 @@ static QemuOptsList reopen_opts = {
     .merge_lists = true,
     .head = QTAILQ_HEAD_INITIALIZER(reopen_opts.head),
     .desc = {
-        /* no elements => accept any params */
-        { /* end of list */ }
+        /* keine Elemente => akzeptieren keine params */
+        { /* Ende der Liste */ }
     },
 };
 
@@ -2295,9 +2301,9 @@ static int sigraise_f(BlockBackend *blk, int argc, char **argv)
         return 0;
     }
 
-    /* Using raise() to kill this process does not necessarily flush all open
-     * streams. At least stdout and stderr (although the latter should be
-     * non-buffered anyway) should be flushed, though. */
+    /* Mit raise () diesen Prozess zu töten nicht bündig nicht unbedingt alle
+     * offenen Bäche. Mindestens stdout und stderr (obwohl letztere sein
+     * sollte ungepufferten sollte sowieso) gespült werden, wenn. */
     fflush(stdout);
     fflush(stderr);
 
@@ -2436,7 +2442,7 @@ bool qemuio_command(BlockBackend *blk, const char *cmd)
 
 static void __attribute((constructor)) init_qemuio_commands(void)
 {
-    /* initialize commands */
+    /* initialisieren Befehle */
     qemuio_add_command(&help_cmd);
     qemuio_add_command(&read_cmd);
     qemuio_add_command(&readv_cmd);
diff --git a/qemu-io.c b/qemu-io.c
index 0a738f1..31aea32 100644
--- a/qemu-io.c
+++ b/qemu-io.c
@@ -30,7 +30,7 @@ static char *progname;
 
 static BlockBackend *qemuio_blk;
 
-/* qemu-io commands passed using -c */
+/* qemu-io Befehle bestanden mit -c */
 static int ncmdline;
 static char **cmdline;
 static bool imageOpts;
@@ -129,8 +129,8 @@ static QemuOptsList empty_opts = {
     .merge_lists = true,
     .head = QTAILQ_HEAD_INITIALIZER(empty_opts.head),
     .desc = {
-        /* no elements => accept any params */
-        { /* end of list */ }
+        /* keine Elemente => akzeptieren keine params */
+        { /* Ende der Liste */ }
     },
 };
 
@@ -401,8 +401,8 @@ static QemuOptsList file_opts = {
     .implied_opt_name = "file",
     .head = QTAILQ_HEAD_INITIALIZER(file_opts.head),
     .desc = {
-        /* no elements => accept any params */
-        { /* end of list */ }
+        /* keine Elemente => akzeptieren keine params */
+        { /* Ende der Liste */ }
     },
 };
 
@@ -485,7 +485,7 @@ int main(int argc, char **argv)
             break;
         case 'T':
             if (!trace_init_backends()) {
-                exit(1); /* error message will have been printed */
+                exit(1); /* Fehlermeldung wurden, werden gedruckt */
             }
             break;
         case 'V':
@@ -533,7 +533,7 @@ int main(int argc, char **argv)
         exit(1);
     }
 
-    /* initialize commands */
+    /* initialisieren Befehle */
     qemuio_add_command(&quit_cmd);
     qemuio_add_command(&open_cmd);
     qemuio_add_command(&close_cmd);
@@ -547,7 +547,7 @@ int main(int argc, char **argv)
         atexit(reenable_tty_echo);
     }
 
-    /* open the device */
+    /* Öffnen Sie das Gerät */
     if (!readonly) {
         flags |= BDRV_O_RDWR;
     }
@@ -572,7 +572,8 @@ int main(int argc, char **argv)
     command_loop();
 
     /*
-     * Make sure all outstanding requests complete before the program exits.
+     * Stellen Sie sicher, dass alle ausstehenden Anforderungen abgeschlossen
+     * ist, bevor das Programm beendet.
      */
     bdrv_drain_all();
 
