[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-block] [PATCH] block: Move away from anglo-centricity
|
From: |
Max Reitz |
|
Subject: |
[Qemu-block] [PATCH] block: Move away from anglo-centricity |
|
Date: |
Fri, 1 Apr 2016 16:50:15 +0200 |
In its organizational structure, the qemu project is rather
decentralized: Many different maintainers manage their own more or less
secluded subsystems. However, regarding languages, it is still rather
anglo-centric.
This issue has been brought up multiple times in regards to user-visible
output such as error messages and has unfortunately generally been
dismissed, except for some UIs.
Development always flows from the developer community to the user. Our
developer community is just as diverse (or at least I hope it is) as our
user base. Therefore, we should reflect this diversity in our
development process in order for this diversity to reach our users as
well, so they can benefit from it.
The human-targeted part of that development process are comments in the
source code, obviously. Thus, in order to exhibit qemu's diversity, it
makes sense for each subsystem's comments to be translated into the
maintainer's native language.
Unfortunately, I do not speak Swabian.
However, as a submaintainer under Kevin, I think it will be fine to
translate the comments into German, as that is supposedly a language we
both share.
I'm certain that this will not hamper development itself by much. First
of all, many other developers in the block area are able to speak
German: Markus Armbruster, Stefan Hajnoczi, Peter Lieven, Stefan Weil,
just to name a few.
Second, good code is supposed to be self-explanatory, i.e. without
reading the comments. While it should go without saying that the block
layer's code quality is simply marvelous, we can now proof that it
indeed is, by seeing whether people who cannot speak German can still
understand the code.
(Although some of our code is rumored to be rather hard to understand
even with the comments. But those rumors are purely unfounded, I am
sure.)
In the rather improbable event that someone is not able to understand
the code without being able to read the comments, they will then need to
learn German. So this is fine, too.
Third, this will surely attract a wave of German developers who were so
far unable to participate in qemu's development because of the language
barrier. In order to facilitate this process, the next step will be to
use German commit messages for every commit in the block layer and to
allow German variable names.
I am sure if all maintainers follow this process of translating their
subsystem's comments, variable names and string contents into their
native language, qemu will become a shining example of what we call
„Kraut und Rüben“. And everyone knows how much the Krauts like Kraut.
Signed-off-by: Max Reitz <address@hidden>
---
block.c | 936 ++++++++++++++++++++++++++-----------------------
block/blkdebug.c | 44 +--
block/linux-aio.c | 51 +--
block/qcow.c | 122 +++----
block/qcow2-cache.c | 18 +-
block/qcow2-cluster.c | 566 ++++++++++++++++--------------
block/qcow2-refcount.c | 642 +++++++++++++++++----------------
block/qcow2-snapshot.c | 119 ++++---
block/qcow2.c | 536 +++++++++++++++-------------
block/qcow2.h | 127 +++----
block/raw-aio.h | 6 +-
block/raw-posix.c | 414 +++++++++++-----------
block/raw-win32.c | 45 +--
block/raw_bsd.c | 19 +-
block/vpc.c | 132 +++----
block/win32-aio.c | 4 +-
blockdev-nbd.c | 7 +-
qemu-img.c | 310 ++++++++--------
qemu-io-cmds.c | 80 +++--
qemu-io.c | 19 +-
20 files changed, 2218 insertions(+), 1979 deletions(-)
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, §or_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();
--
2.7.4
- [Qemu-block] [PATCH] block: Move away from anglo-centricity,
Max Reitz <=