From patchwork Sun Nov 15 11:36:01 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1400429 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=nongnu.org (client-ip=209.51.188.17; helo=lists.gnu.org; envelope-from=qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=web.de Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; secure) header.d=web.de header.i=@web.de header.a=rsa-sha256 header.s=dbaedf251592 header.b=JmGPgJPa; dkim-atps=neutral Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4CYqw853h9z9sRK for ; Sun, 15 Nov 2020 22:38:32 +1100 (AEDT) Received: from localhost ([::1]:54310 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1keGMY-0007Ba-K3 for incoming@patchwork.ozlabs.org; Sun, 15 Nov 2020 06:38:30 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:57004) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKL-0004pk-Lh; Sun, 15 Nov 2020 06:36:13 -0500 Received: from mout.web.de ([217.72.192.78]:58141) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKI-0008DK-6n; Sun, 15 Nov 2020 06:36:13 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1605440163; bh=gvEu2P710aTKvOOzPDI2YgsK1lHUggQxU9Jsb/WaOl0=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=JmGPgJPa8RgOhnfDdfPyk85JAendgH032EH/1HnYcVcwsWe7LBmtenvj+Qul9f5V3 m5rYhtRBgm44F123vfRhv1JeUYDcaB9ylS4827s1hX1v6kmwOxLf1jhaJDmEcxyIg3 7CIWJOmwuyViyWeq5E2q4t+vYTxvU9pSAk1v0KaY= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.172]) by smtp.web.de (mrweb106 [213.165.67.124]) with ESMTPSA (Nemesis) id 1N6sBp-1kDH360vL5-017xLl; Sun, 15 Nov 2020 12:36:03 +0100 Date: Sun, 15 Nov 2020 12:36:01 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v11 1/7] Introduce yank feature Message-ID: <2f88d8992faf582fc5172a8a09ec0a2df241e4f2.1605439674.git.lukasstraub2@web.de> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:Bmh8ztOTzqUx4M3qD22MidelPwobCZ3uhbthuYrRV4Gu7vRgkEZ oM5np8FwJfka87ve2uVFUiqXW3jnm/ExzZTQzMolurOGNmUduz7VfukbbjmKThYP/FIIa1H HeYXKAIXsUSm4iGUFYU7/yttXBJ/DOqasWBQ+xBIkIUxQkn62Cj6D+rkyLSWCvf3NBpZxks 7uQJiP0585xBENkIJ8Btw== X-UI-Out-Filterresults: notjunk:1;V03:K0:sdYEhh5+JBA=:np+ceTIF4I+9TPUFlKquiC U9mN/xBvdvKeT7SCFzSUJ8nM9X5uXe9TL+p4lNgWLKFcnwSslAF/m/OBG90PBs7RoNHf5pNGp jRG9ys1+8mvOwsBEyR2DDhowy7O6pL0Kpj4KtGEU8s9BAQAE4Zu3DZ+85G6ZpF6PehjIY/KfE ULafN63IJaPpdqOaTps0cHMDddcO9MQ7d7OBYlcjZJez0/an+oiRGKmAHkMR3BooffHCdWnrr a3s2BUT+J6sHUJMKuocTTa7PVb2Nfuz0SAzCtollUDbYuVHDd2r4PzeRwOtJQZcgKXDV//Htl Rsyo7BkX0k9x+zHJmPSAGDlY0mnLP8Ht8woGx9ghta4yGG7Cy7XRFNr7zdap72owJofW6htuI hQv4Ix5X/wl6PB2CriDe/c6z4ouVTLZo8ssztfqf3KtImxc3Blf1kW9FxgL05Q9ykITLRMv4/ b5Hiin28jWk49aM3GaqmWmDxUeUdkqlcYZu+BluIjnik4UOnm401AyyS/H57ZJAVCLE0HZWqy gF8vm+1l1B3RodvEbuSmOxOoJoYd/lTreOuIothf2KOeL2tfp1OWq9IxNqx0KNkywr957OKt5 prLRh3u5hFA34zVqLMt2cawKoRELg+jytMKqtG5OnI0r01caRBQJeXvCvtGoCHMUPAeoNGzVv aHKNQUDpuJBuWGCiIVHX4N8e5Un7W5/hPDsfp+S0SfGxj0lwPFJKkFlnJgN+tq1sDn2LA2t1h zXnr7CJLmzxK3OrhV4lGojb/ISqCiRgPIYBDFu1bc4j35NWQiiYKaXhQQTtO11YAjnWaEeqFy Pf3NQVnGeUgd8SDO0GOlTHj/eTEdlRmF0NOD6ridfoMnqNcg/lwvqPs7Gpgkv0mOQX4FsmEHW /LAiN0LENEaZVdw+DSkQ== Received-SPF: pass client-ip=217.72.192.78; envelope-from=lukasstraub2@web.de; helo=mout.web.de X-detected-operating-system: by eggs.gnu.org: First seen = 2020/11/15 05:44:48 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -24 X-Spam_score: -2.5 X-Spam_bar: -- X-Spam_report: (-2.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H2=-0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , "Daniel P. =?utf-8?b?QmVycmFuZ8Op?= " , qemu-block , Juan Quintela , Markus Armbruster , "Dr. David Alan Gilbert" , Max Reitz , Paolo Bonzini , =?utf-8?q?Marc-Andr=C3=A9?= Lureau Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: "Qemu-devel" The yank feature allows to recover from hanging qemu by "yanking" at various parts. Other qemu systems can register themselves and multiple yank functions. Then all yank functions for selected instances can be called by the 'yank' out-of-band qmp command. Available instances can be queried by a 'query-yank' oob command. Signed-off-by: Lukas Straub Acked-by: Stefan Hajnoczi Reviewed-by: Markus Armbruster --- MAINTAINERS | 7 ++ include/qemu/yank.h | 95 +++++++++++++++++++ qapi/meson.build | 1 + qapi/qapi-schema.json | 1 + qapi/yank.json | 119 +++++++++++++++++++++++ util/meson.build | 1 + util/yank.c | 216 ++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 440 insertions(+) create mode 100644 include/qemu/yank.h create mode 100644 qapi/yank.json create mode 100644 util/yank.c -- 2.20.1 diff --git a/MAINTAINERS b/MAINTAINERS index 2e018a0c1d..46ff468b13 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -2688,6 +2688,13 @@ F: util/uuid.c F: include/qemu/uuid.h F: tests/test-uuid.c +Yank feature +M: Lukas Straub +S: Odd fixes +F: util/yank.c +F: include/qemu/yank.h +F: qapi/yank.json + COLO Framework M: zhanghailiang S: Maintained diff --git a/include/qemu/yank.h b/include/qemu/yank.h new file mode 100644 index 0000000000..96f5b2626f --- /dev/null +++ b/include/qemu/yank.h @@ -0,0 +1,95 @@ +/* + * QEMU yank feature + * + * Copyright (c) Lukas Straub + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#ifndef YANK_H +#define YANK_H + +#include "qapi/qapi-types-yank.h" + +typedef void (YankFn)(void *opaque); + +/** + * yank_register_instance: Register a new instance. + * + * This registers a new instance for yanking. Must be called before any yank + * function is registered for this instance. + * + * This function is thread-safe. + * + * @instance: The instance. + * @errp: Error object. + */ +void yank_register_instance(const YankInstance *instance, Error **errp); + +/** + * yank_unregister_instance: Unregister a instance. + * + * This unregisters a instance. Must be called only after every yank function + * of the instance has been unregistered. + * + * This function is thread-safe. + * + * @instance: The instance. + */ +void yank_unregister_instance(const YankInstance *instance); + +/** + * yank_register_function: Register a yank function + * + * This registers a yank function. All limitations of qmp oob commands apply + * to the yank function as well. See docs/devel/qapi-code-gen.txt under + * "An OOB-capable command handler must satisfy the following conditions". + * + * This function is thread-safe. + * + * @instance: The instance. + * @func: The yank function. + * @opaque: Will be passed to the yank function. + */ +void yank_register_function(const YankInstance *instance, + YankFn *func, + void *opaque); + +/** + * yank_unregister_function: Unregister a yank function + * + * This unregisters a yank function. + * + * This function is thread-safe. + * + * @instance: The instance. + * @func: func that was passed to yank_register_function. + * @opaque: opaque that was passed to yank_register_function. + */ +void yank_unregister_function(const YankInstance *instance, + YankFn *func, + void *opaque); + +/** + * yank_generic_iochannel: Generic yank function for iochannel + * + * This is a generic yank function which will call qio_channel_shutdown on the + * provided QIOChannel. + * + * @opaque: QIOChannel to shutdown + */ +void yank_generic_iochannel(void *opaque); + +#define BLOCKDEV_YANK_INSTANCE(the_node_name) (&(YankInstance) { \ + .type = YANK_INSTANCE_TYPE_BLOCK_NODE, \ + .u.block_node.node_name = (the_node_name) }) + +#define CHARDEV_YANK_INSTANCE(the_id) (&(YankInstance) { \ + .type = YANK_INSTANCE_TYPE_CHARDEV, \ + .u.chardev.id = (the_id) }) + +#define MIGRATION_YANK_INSTANCE (&(YankInstance) { \ + .type = YANK_INSTANCE_TYPE_MIGRATION }) + +#endif diff --git a/qapi/meson.build b/qapi/meson.build index 0e98146f1f..ab68e7900e 100644 --- a/qapi/meson.build +++ b/qapi/meson.build @@ -47,6 +47,7 @@ qapi_all_modules = [ 'trace', 'transaction', 'ui', + 'yank', ] qapi_storage_daemon_modules = [ diff --git a/qapi/qapi-schema.json b/qapi/qapi-schema.json index 0b444b76d2..3441c9a9ae 100644 --- a/qapi/qapi-schema.json +++ b/qapi/qapi-schema.json @@ -86,6 +86,7 @@ { 'include': 'machine.json' } { 'include': 'machine-target.json' } { 'include': 'replay.json' } +{ 'include': 'yank.json' } { 'include': 'misc.json' } { 'include': 'misc-target.json' } { 'include': 'audio.json' } diff --git a/qapi/yank.json b/qapi/yank.json new file mode 100644 index 0000000000..167a775594 --- /dev/null +++ b/qapi/yank.json @@ -0,0 +1,119 @@ +# -*- Mode: Python -*- +# vim: filetype=python +# + +## +# = Yank feature +## + +## +# @YankInstanceType: +# +# An enumeration of yank instance types. See @YankInstance for more +# information. +# +# Since: 6.0 +## +{ 'enum': 'YankInstanceType', + 'data': [ 'block-node', 'chardev', 'migration' ] } + +## +# @YankInstanceBlockNode: +# +# Specifies which block graph node to yank. See @YankInstance for more +# information. +# +# @node-name: the name of the block graph node +# +# Since: 6.0 +## +{ 'struct': 'YankInstanceBlockNode', + 'data': { 'node-name': 'str' } } + +## +# @YankInstanceChardev: +# +# Specifies which character device to yank. See @YankInstance for more +# information. +# +# @id: the chardev's ID +# +# Since: 6.0 +## +{ 'struct': 'YankInstanceChardev', + 'data': { 'id': 'str' } } + +## +# @YankInstance: +# +# A yank instance can be yanked with the @yank qmp command to recover from a +# hanging QEMU. +# +# Currently implemented yank instances: +# - nbd block device: +# Yanking it will shut down the connection to the nbd server without +# attempting to reconnect. +# - socket chardev: +# Yanking it will shut down the connected socket. +# - migration: +# Yanking it will shut down all migration connections. Unlike +# @migrate_cancel, it will not notify the migration process, so migration +# will go into @failed state, instead of @cancelled state. @yank should be +# used to recover from hangs. +# +# Since: 6.0 +## +{ 'union': 'YankInstance', + 'base': { 'type': 'YankInstanceType' }, + 'discriminator': 'type', + 'data': { + 'block-node': 'YankInstanceBlockNode', + 'chardev': 'YankInstanceChardev' } } + +## +# @yank: +# +# Try to recover from hanging QEMU by yanking the specified instances. See +# @YankInstance for more information. +# +# Takes a list of @YankInstance as argument. +# +# Returns: - Nothing on success +# - @DeviceNotFound error, if any of the YankInstances doesn't exist +# +# Example: +# +# -> { "execute": "yank", +# "arguments": { +# "instances": [ +# { "type": "block-node", +# "node-name": "nbd0" } +# ] } } +# <- { "return": {} } +# +# Since: 6.0 +## +{ 'command': 'yank', + 'data': { 'instances': ['YankInstance'] }, + 'allow-oob': true } + +## +# @query-yank: +# +# Query yank instances. See @YankInstance for more information. +# +# Returns: list of @YankInstance +# +# Example: +# +# -> { "execute": "query-yank" } +# <- { "return": [ +# { "type": "block-node", +# "node-name": "nbd0" } +# ] } +# +# Since: 6.0 +## +{ 'command': 'query-yank', + 'returns': ['YankInstance'], + 'allow-oob': true } diff --git a/util/meson.build b/util/meson.build index f359af0d46..f7c67344e1 100644 --- a/util/meson.build +++ b/util/meson.build @@ -50,6 +50,7 @@ endif if have_system util_ss.add(when: 'CONFIG_GIO', if_true: [files('dbus.c'), gio]) + util_ss.add(files('yank.c')) endif if have_block diff --git a/util/yank.c b/util/yank.c new file mode 100644 index 0000000000..4a0f538359 --- /dev/null +++ b/util/yank.c @@ -0,0 +1,216 @@ +/* + * QEMU yank feature + * + * Copyright (c) Lukas Straub + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#include "qemu/osdep.h" +#include "qapi/error.h" +#include "qemu/thread.h" +#include "qemu/queue.h" +#include "qapi/qapi-commands-yank.h" +#include "qapi/qapi-visit-yank.h" +#include "qapi/clone-visitor.h" +#include "io/channel.h" +#include "qemu/yank.h" + +struct YankFuncAndParam { + YankFn *func; + void *opaque; + QLIST_ENTRY(YankFuncAndParam) next; +}; + +struct YankInstanceEntry { + YankInstance *instance; + QLIST_HEAD(, YankFuncAndParam) yankfns; + QLIST_ENTRY(YankInstanceEntry) next; +}; + +typedef struct YankFuncAndParam YankFuncAndParam; +typedef struct YankInstanceEntry YankInstanceEntry; + +/* + * This lock protects the yank_instance_list below. Because it's taken by + * OOB-capable commands, it must be "fast", i.e. it may only be held for a + * bounded, short time. See docs/devel/qapi-code-gen.txt for additional + * information. + */ +static QemuMutex yank_lock; + +static QLIST_HEAD(, YankInstanceEntry) yank_instance_list + = QLIST_HEAD_INITIALIZER(yank_instance_list); + +static bool yank_compare_instances(const YankInstance *a, const YankInstance *b) +{ + if (a->type != b->type) { + return false; + } + + switch (a->type) { + case YANK_INSTANCE_TYPE_BLOCK_NODE: + return !strcmp(a->u.block_node.node_name, b->u.block_node.node_name); + break; + + case YANK_INSTANCE_TYPE_CHARDEV: + return !strcmp(a->u.chardev.id, b->u.chardev.id); + break; + + case YANK_INSTANCE_TYPE_MIGRATION: + return true; + break; + + default: + abort(); + } +} + +static YankInstanceEntry *yank_find_entry(const YankInstance *instance) +{ + YankInstanceEntry *entry; + + QLIST_FOREACH(entry, &yank_instance_list, next) { + if (yank_compare_instances(entry->instance, instance)) { + return entry; + } + } + return NULL; +} + +void yank_register_instance(const YankInstance *instance, Error **errp) +{ + YankInstanceEntry *entry; + + qemu_mutex_lock(&yank_lock); + + if (yank_find_entry(instance)) { + error_setg(errp, "duplicate yank instance"); + qemu_mutex_unlock(&yank_lock); + return; + } + + entry = g_slice_new(YankInstanceEntry); + entry->instance = QAPI_CLONE(YankInstance, instance); + QLIST_INIT(&entry->yankfns); + QLIST_INSERT_HEAD(&yank_instance_list, entry, next); + + qemu_mutex_unlock(&yank_lock); +} + +void yank_unregister_instance(const YankInstance *instance) +{ + YankInstanceEntry *entry; + + qemu_mutex_lock(&yank_lock); + entry = yank_find_entry(instance); + assert(entry); + + assert(QLIST_EMPTY(&entry->yankfns)); + QLIST_REMOVE(entry, next); + qapi_free_YankInstance(entry->instance); + g_slice_free(YankInstanceEntry, entry); + + qemu_mutex_unlock(&yank_lock); +} + +void yank_register_function(const YankInstance *instance, + YankFn *func, + void *opaque) +{ + YankInstanceEntry *entry; + YankFuncAndParam *func_entry; + + qemu_mutex_lock(&yank_lock); + entry = yank_find_entry(instance); + assert(entry); + + func_entry = g_slice_new(YankFuncAndParam); + func_entry->func = func; + func_entry->opaque = opaque; + + QLIST_INSERT_HEAD(&entry->yankfns, func_entry, next); + qemu_mutex_unlock(&yank_lock); +} + +void yank_unregister_function(const YankInstance *instance, + YankFn *func, + void *opaque) +{ + YankInstanceEntry *entry; + YankFuncAndParam *func_entry; + + qemu_mutex_lock(&yank_lock); + entry = yank_find_entry(instance); + assert(entry); + + QLIST_FOREACH(func_entry, &entry->yankfns, next) { + if (func_entry->func == func && func_entry->opaque == opaque) { + QLIST_REMOVE(func_entry, next); + g_slice_free(YankFuncAndParam, func_entry); + qemu_mutex_unlock(&yank_lock); + return; + } + } + + abort(); +} + +void yank_generic_iochannel(void *opaque) +{ + QIOChannel *ioc = QIO_CHANNEL(opaque); + + qio_channel_shutdown(ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL); +} + +void qmp_yank(YankInstanceList *instances, + Error **errp) +{ + YankInstanceList *tail; + YankInstanceEntry *entry; + YankFuncAndParam *func_entry; + + qemu_mutex_lock(&yank_lock); + for (tail = instances; tail; tail = tail->next) { + entry = yank_find_entry(tail->value); + if (!entry) { + error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, "Instance not found"); + qemu_mutex_unlock(&yank_lock); + return; + } + } + for (tail = instances; tail; tail = tail->next) { + entry = yank_find_entry(tail->value); + assert(entry); + QLIST_FOREACH(func_entry, &entry->yankfns, next) { + func_entry->func(func_entry->opaque); + } + } + qemu_mutex_unlock(&yank_lock); +} + +YankInstanceList *qmp_query_yank(Error **errp) +{ + YankInstanceEntry *entry; + YankInstanceList *ret; + + ret = NULL; + + qemu_mutex_lock(&yank_lock); + QLIST_FOREACH(entry, &yank_instance_list, next) { + YankInstanceList *new_entry; + new_entry = g_new0(YankInstanceList, 1); + new_entry->value = QAPI_CLONE(YankInstance, entry->instance); + new_entry->next = ret; + ret = new_entry; + } + qemu_mutex_unlock(&yank_lock); + + return ret; +} + +static void __attribute__((__constructor__)) yank_init(void) +{ + qemu_mutex_init(&yank_lock); +} From patchwork Sun Nov 15 11:36:05 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1400428 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=nongnu.org (client-ip=209.51.188.17; helo=lists.gnu.org; envelope-from=qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=web.de Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; secure) header.d=web.de header.i=@web.de header.a=rsa-sha256 header.s=dbaedf251592 header.b=HikAQx9f; dkim-atps=neutral Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4CYqtQ6cvgz9sT6 for ; Sun, 15 Nov 2020 22:37:02 +1100 (AEDT) Received: from localhost ([::1]:49396 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1keGL6-00058p-6r for incoming@patchwork.ozlabs.org; Sun, 15 Nov 2020 06:37:00 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:57014) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKN-0004tx-Qb; Sun, 15 Nov 2020 06:36:15 -0500 Received: from mout.web.de ([212.227.15.4]:45823) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKL-0008FM-85; Sun, 15 Nov 2020 06:36:15 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1605440167; bh=w5u/TurdVtqqwpqqly6JdrVriXQLZl9jUyOIFeIdfFY=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=HikAQx9ftOFuD0KH9V/+sWYFW7yUDr9INqIpthlDb2y8mnnyF7GInNU+pF3beVEHl nf177eIQps5S2AD839b28cfiY4SdTxmM1vUoYzkCBBt8Ie96tvSoY5LdE1MSPHxnKu t1Tcm1v0QlLY30RKJArUIj6XN+udCAzJ3+i8GINw= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.172]) by smtp.web.de (mrweb004 [213.165.67.108]) with ESMTPSA (Nemesis) id 0LuIAZ-1kFTxx43zr-011gOm; Sun, 15 Nov 2020 12:36:07 +0100 Date: Sun, 15 Nov 2020 12:36:05 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v11 2/7] block/nbd.c: Add yank feature Message-ID: <14b78aebabb64b9f2ffaac025ee3b683bd7c9167.1605439674.git.lukasstraub2@web.de> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:m/a6x3iO3LBhzyEU36G4nZAnMONYm5/Obtq7Idpgb1CD6RoJnT/ 2KJf3xbLbSagXnzgAhWFQrCfjCLAZxhHoAeP41f3ZENu/7v6rYFST6RS3xLk1GGj+gIb++4 UJ+VeA7BLYoTwWFS7/BR4aqjKc7GOpBk4xBuLn7EbhidiyQ88iJXDv7g1xWrF4AZgaN3IH3 TepRNj5MS4ZTUwm8gTGSQ== X-UI-Out-Filterresults: notjunk:1;V03:K0:ox1auFY+z1w=:0++ReZhz0NoLyBfagKyIhy HlYhcxu+HWS+SeyKkraiYxvr5izmkZ4gLSANFaY8kp95E5RoS4BxCVSaG/g3tEyL6zMHejoRF l1iNDjgSFUN9TiY/QkrH87LfFlze366kiI04KOgT9LqZIG6d6inCKSzciRU+kj1dWT45EF3XY 9fDs6mjCYV6ht4Kge20g0DevCppYMPc9E0a2fgc4ho8tpuFllNfPj1lWrZ97SqT2OeCTKcyO7 1cD+vrK+Dw+I1v8hveJwr5wOoMhydj/VQn7XYfBUBqaM07U1lhlbh4jZpFab4mcV/73Shwlav tWAp+0A/rkeqr8wFAPWt0s/cuqPUCOW1Ud/+YUrxaZ39c289fFPtfT5nHuSXmkeuPCnKVdm/e cY7ZFAgXLFK9PpWFnVyYaza9AqzUj1ytlV0UsH5/OEPmdb0p+eB5JkmSY1hL9+WzHUpat4k/D /EbooCMfw7s9xV8iBcKpsh+ayLp05eeHjs+OdnkfeukA8b57sSbkWFADRcO4S7amv9dxCPz6E 7NTi30saYUAfPBb/tA4ax63OJpsdnck8QjJiaotvRcM7E5Df2Pnx4HjG3JYaEvaUtZTe4g4Ez ArDnhLNjlTEoGtoO0V9ggmoQnEXjmEsBdMbS/E9SoUQqWSlIWBwiVHuIG2txj02O7mipNhMc2 b7VjwcJUfKt2w1Itg2WmSDOXH10VopzJuIrHmSX93o44AM+XkagO/KsMVNPz1Ct03aY0Zcczr bR6DxrUVik9agDZUF04uDuJQWB1wpnRpQlZDzSVW4ivLc97ouKA6pXPnPtGqc4AhOAA9COcD8 lvrJe5GZmUULEGF7bPoyps9K0u3XNTFn06vXHmLW+HlV1DtLqSrBWBCf2oyY1mANiSuPDPrnP FqEaMmXIE5gvtcWBaoCg== Received-SPF: pass client-ip=212.227.15.4; envelope-from=lukasstraub2@web.de; helo=mout.web.de X-detected-operating-system: by eggs.gnu.org: First seen = 2020/11/15 06:19:13 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -24 X-Spam_score: -2.5 X-Spam_bar: -- X-Spam_report: (-2.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H3=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , "Daniel P. =?utf-8?b?QmVycmFuZ8Op?= " , qemu-block , Juan Quintela , Markus Armbruster , "Dr. David Alan Gilbert" , Max Reitz , Paolo Bonzini , =?utf-8?q?Marc-Andr=C3=A9?= Lureau Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: "Qemu-devel" Register a yank function which shuts down the socket and sets s->state = NBD_CLIENT_QUIT. This is the same behaviour as if an error occured. Signed-off-by: Lukas Straub Acked-by: Stefan Hajnoczi Reviewed-by: Eric Blake --- block/nbd.c | 154 +++++++++++++++++++++++++++++++--------------------- 1 file changed, 93 insertions(+), 61 deletions(-) -- 2.20.1 diff --git a/block/nbd.c b/block/nbd.c index 42536702b6..994d1e7b33 100644 --- a/block/nbd.c +++ b/block/nbd.c @@ -35,6 +35,7 @@ #include "qemu/option.h" #include "qemu/cutils.h" #include "qemu/main-loop.h" +#include "qemu/atomic.h" #include "qapi/qapi-visit-sockets.h" #include "qapi/qmp/qstring.h" @@ -44,6 +45,8 @@ #include "block/nbd.h" #include "block/block_int.h" +#include "qemu/yank.h" + #define EN_OPTSTR ":exportname=" #define MAX_NBD_REQUESTS 16 @@ -141,14 +144,13 @@ typedef struct BDRVNBDState { NBDConnectThread *connect_thread; } BDRVNBDState; -static QIOChannelSocket *nbd_establish_connection(SocketAddress *saddr, - Error **errp); -static QIOChannelSocket *nbd_co_establish_connection(BlockDriverState *bs, - Error **errp); +static int nbd_establish_connection(BlockDriverState *bs, SocketAddress *saddr, + Error **errp); +static int nbd_co_establish_connection(BlockDriverState *bs, Error **errp); static void nbd_co_establish_connection_cancel(BlockDriverState *bs, bool detach); -static int nbd_client_handshake(BlockDriverState *bs, QIOChannelSocket *sioc, - Error **errp); +static int nbd_client_handshake(BlockDriverState *bs, Error **errp); +static void nbd_yank(void *opaque); static void nbd_clear_bdrvstate(BDRVNBDState *s) { @@ -166,12 +168,12 @@ static void nbd_clear_bdrvstate(BDRVNBDState *s) static void nbd_channel_error(BDRVNBDState *s, int ret) { if (ret == -EIO) { - if (s->state == NBD_CLIENT_CONNECTED) { + if (qatomic_load_acquire(&s->state) == NBD_CLIENT_CONNECTED) { s->state = s->reconnect_delay ? NBD_CLIENT_CONNECTING_WAIT : NBD_CLIENT_CONNECTING_NOWAIT; } } else { - if (s->state == NBD_CLIENT_CONNECTED) { + if (qatomic_load_acquire(&s->state) == NBD_CLIENT_CONNECTED) { qio_channel_shutdown(s->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL); } s->state = NBD_CLIENT_QUIT; @@ -204,7 +206,7 @@ static void reconnect_delay_timer_cb(void *opaque) { BDRVNBDState *s = opaque; - if (s->state == NBD_CLIENT_CONNECTING_WAIT) { + if (qatomic_load_acquire(&s->state) == NBD_CLIENT_CONNECTING_WAIT) { s->state = NBD_CLIENT_CONNECTING_NOWAIT; while (qemu_co_enter_next(&s->free_sema, NULL)) { /* Resume all queued requests */ @@ -216,7 +218,7 @@ static void reconnect_delay_timer_cb(void *opaque) static void reconnect_delay_timer_init(BDRVNBDState *s, uint64_t expire_time_ns) { - if (s->state != NBD_CLIENT_CONNECTING_WAIT) { + if (qatomic_load_acquire(&s->state) != NBD_CLIENT_CONNECTING_WAIT) { return; } @@ -261,7 +263,7 @@ static void nbd_client_attach_aio_context(BlockDriverState *bs, * s->connection_co is either yielded from nbd_receive_reply or from * nbd_co_reconnect_loop() */ - if (s->state == NBD_CLIENT_CONNECTED) { + if (qatomic_load_acquire(&s->state) == NBD_CLIENT_CONNECTED) { qio_channel_attach_aio_context(QIO_CHANNEL(s->ioc), new_context); } @@ -287,7 +289,7 @@ static void coroutine_fn nbd_client_co_drain_begin(BlockDriverState *bs) reconnect_delay_timer_del(s); - if (s->state == NBD_CLIENT_CONNECTING_WAIT) { + if (qatomic_load_acquire(&s->state) == NBD_CLIENT_CONNECTING_WAIT) { s->state = NBD_CLIENT_CONNECTING_NOWAIT; qemu_co_queue_restart_all(&s->free_sema); } @@ -338,13 +340,14 @@ static void nbd_teardown_connection(BlockDriverState *bs) static bool nbd_client_connecting(BDRVNBDState *s) { - return s->state == NBD_CLIENT_CONNECTING_WAIT || - s->state == NBD_CLIENT_CONNECTING_NOWAIT; + NBDClientState state = qatomic_load_acquire(&s->state); + return state == NBD_CLIENT_CONNECTING_WAIT || + state == NBD_CLIENT_CONNECTING_NOWAIT; } static bool nbd_client_connecting_wait(BDRVNBDState *s) { - return s->state == NBD_CLIENT_CONNECTING_WAIT; + return qatomic_load_acquire(&s->state) == NBD_CLIENT_CONNECTING_WAIT; } static void connect_bh(void *opaque) @@ -424,12 +427,12 @@ static void *connect_thread_func(void *opaque) return NULL; } -static QIOChannelSocket *coroutine_fn +static int coroutine_fn nbd_co_establish_connection(BlockDriverState *bs, Error **errp) { + int ret; QemuThread thread; BDRVNBDState *s = bs->opaque; - QIOChannelSocket *res; NBDConnectThread *thr = s->connect_thread; qemu_mutex_lock(&thr->mutex); @@ -446,10 +449,12 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp) case CONNECT_THREAD_SUCCESS: /* Previous attempt finally succeeded in background */ thr->state = CONNECT_THREAD_NONE; - res = thr->sioc; + s->sioc = thr->sioc; thr->sioc = NULL; + yank_register_function(BLOCKDEV_YANK_INSTANCE(bs->node_name), + nbd_yank, bs); qemu_mutex_unlock(&thr->mutex); - return res; + return 0; case CONNECT_THREAD_RUNNING: /* Already running, will wait */ break; @@ -481,8 +486,13 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp) thr->state = CONNECT_THREAD_NONE; error_propagate(errp, thr->err); thr->err = NULL; - res = thr->sioc; + s->sioc = thr->sioc; thr->sioc = NULL; + if (s->sioc) { + yank_register_function(BLOCKDEV_YANK_INSTANCE(bs->node_name), + nbd_yank, bs); + } + ret = (s->sioc ? 0 : -1); break; case CONNECT_THREAD_RUNNING: case CONNECT_THREAD_RUNNING_DETACHED: @@ -491,7 +501,7 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp) * failed. Still connect thread is executing in background, and its * result may be used for next connection attempt. */ - res = NULL; + ret = -1; error_setg(errp, "Connection attempt cancelled by other operation"); break; @@ -508,7 +518,7 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp) qemu_mutex_unlock(&thr->mutex); - return res; + return ret; } /* @@ -561,7 +571,6 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) { int ret; Error *local_err = NULL; - QIOChannelSocket *sioc; if (!nbd_client_connecting(s)) { return; @@ -594,21 +603,22 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) /* Finalize previous connection if any */ if (s->ioc) { qio_channel_detach_aio_context(QIO_CHANNEL(s->ioc)); + yank_unregister_function(BLOCKDEV_YANK_INSTANCE(s->bs->node_name), + nbd_yank, s->bs); object_unref(OBJECT(s->sioc)); s->sioc = NULL; object_unref(OBJECT(s->ioc)); s->ioc = NULL; } - sioc = nbd_co_establish_connection(s->bs, &local_err); - if (!sioc) { + if (nbd_co_establish_connection(s->bs, &local_err) < 0) { ret = -ECONNREFUSED; goto out; } bdrv_dec_in_flight(s->bs); - ret = nbd_client_handshake(s->bs, sioc, &local_err); + ret = nbd_client_handshake(s->bs, &local_err); if (s->drained) { s->wait_drained_end = true; @@ -640,7 +650,7 @@ static coroutine_fn void nbd_co_reconnect_loop(BDRVNBDState *s) uint64_t timeout = 1 * NANOSECONDS_PER_SECOND; uint64_t max_timeout = 16 * NANOSECONDS_PER_SECOND; - if (s->state == NBD_CLIENT_CONNECTING_WAIT) { + if (qatomic_load_acquire(&s->state) == NBD_CLIENT_CONNECTING_WAIT) { reconnect_delay_timer_init(s, qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + s->reconnect_delay * NANOSECONDS_PER_SECOND); } @@ -683,7 +693,7 @@ static coroutine_fn void nbd_connection_entry(void *opaque) int ret = 0; Error *local_err = NULL; - while (s->state != NBD_CLIENT_QUIT) { + while (qatomic_load_acquire(&s->state) != NBD_CLIENT_QUIT) { /* * The NBD client can only really be considered idle when it has * yielded from qio_channel_readv_all_eof(), waiting for data. This is @@ -698,7 +708,7 @@ static coroutine_fn void nbd_connection_entry(void *opaque) nbd_co_reconnect_loop(s); } - if (s->state != NBD_CLIENT_CONNECTED) { + if (qatomic_load_acquire(&s->state) != NBD_CLIENT_CONNECTED) { continue; } @@ -753,6 +763,8 @@ static coroutine_fn void nbd_connection_entry(void *opaque) s->connection_co = NULL; if (s->ioc) { qio_channel_detach_aio_context(QIO_CHANNEL(s->ioc)); + yank_unregister_function(BLOCKDEV_YANK_INSTANCE(s->bs->node_name), + nbd_yank, s->bs); object_unref(OBJECT(s->sioc)); s->sioc = NULL; object_unref(OBJECT(s->ioc)); @@ -777,7 +789,7 @@ static int nbd_co_send_request(BlockDriverState *bs, qemu_co_queue_wait(&s->free_sema, &s->send_mutex); } - if (s->state != NBD_CLIENT_CONNECTED) { + if (qatomic_load_acquire(&s->state) != NBD_CLIENT_CONNECTED) { rc = -EIO; goto err; } @@ -804,7 +816,8 @@ static int nbd_co_send_request(BlockDriverState *bs, if (qiov) { qio_channel_set_cork(s->ioc, true); rc = nbd_send_request(s->ioc, request); - if (rc >= 0 && s->state == NBD_CLIENT_CONNECTED) { + if (qatomic_load_acquire(&s->state) == NBD_CLIENT_CONNECTED && + rc >= 0) { if (qio_channel_writev_all(s->ioc, qiov->iov, qiov->niov, NULL) < 0) { rc = -EIO; @@ -1129,7 +1142,7 @@ static coroutine_fn int nbd_co_do_receive_one_chunk( s->requests[i].receiving = true; qemu_coroutine_yield(); s->requests[i].receiving = false; - if (s->state != NBD_CLIENT_CONNECTED) { + if (qatomic_load_acquire(&s->state) != NBD_CLIENT_CONNECTED) { error_setg(errp, "Connection closed"); return -EIO; } @@ -1288,7 +1301,7 @@ static bool nbd_reply_chunk_iter_receive(BDRVNBDState *s, NBDReply local_reply; NBDStructuredReplyChunk *chunk; Error *local_err = NULL; - if (s->state != NBD_CLIENT_CONNECTED) { + if (qatomic_load_acquire(&s->state) != NBD_CLIENT_CONNECTED) { error_setg(&local_err, "Connection closed"); nbd_iter_channel_error(iter, -EIO, &local_err); goto break_loop; @@ -1313,7 +1326,8 @@ static bool nbd_reply_chunk_iter_receive(BDRVNBDState *s, } /* Do not execute the body of NBD_FOREACH_REPLY_CHUNK for simple reply. */ - if (nbd_reply_is_simple(reply) || s->state != NBD_CLIENT_CONNECTED) { + if (nbd_reply_is_simple(reply) || + qatomic_load_acquire(&s->state) != NBD_CLIENT_CONNECTED) { goto break_loop; } @@ -1745,6 +1759,15 @@ static int nbd_client_reopen_prepare(BDRVReopenState *state, return 0; } +static void nbd_yank(void *opaque) +{ + BlockDriverState *bs = opaque; + BDRVNBDState *s = (BDRVNBDState *)bs->opaque; + + qatomic_store_release(&s->state, NBD_CLIENT_QUIT); + qio_channel_shutdown(QIO_CHANNEL(s->sioc), QIO_CHANNEL_SHUTDOWN_BOTH, NULL); +} + static void nbd_client_close(BlockDriverState *bs) { BDRVNBDState *s = (BDRVNBDState *)bs->opaque; @@ -1757,52 +1780,53 @@ static void nbd_client_close(BlockDriverState *bs) nbd_teardown_connection(bs); } -static QIOChannelSocket *nbd_establish_connection(SocketAddress *saddr, - Error **errp) +static int nbd_establish_connection(BlockDriverState *bs, + SocketAddress *saddr, + Error **errp) { ERRP_GUARD(); - QIOChannelSocket *sioc; + BDRVNBDState *s = (BDRVNBDState *)bs->opaque; - sioc = qio_channel_socket_new(); - qio_channel_set_name(QIO_CHANNEL(sioc), "nbd-client"); + s->sioc = qio_channel_socket_new(); + qio_channel_set_name(QIO_CHANNEL(s->sioc), "nbd-client"); - qio_channel_socket_connect_sync(sioc, saddr, errp); + qio_channel_socket_connect_sync(s->sioc, saddr, errp); if (*errp) { - object_unref(OBJECT(sioc)); - return NULL; + object_unref(OBJECT(s->sioc)); + s->sioc = NULL; + return -1; } - qio_channel_set_delay(QIO_CHANNEL(sioc), false); + yank_register_function(BLOCKDEV_YANK_INSTANCE(bs->node_name), nbd_yank, bs); + qio_channel_set_delay(QIO_CHANNEL(s->sioc), false); - return sioc; + return 0; } -/* nbd_client_handshake takes ownership on sioc. On failure it is unref'ed. */ -static int nbd_client_handshake(BlockDriverState *bs, QIOChannelSocket *sioc, - Error **errp) +/* nbd_client_handshake takes ownership on s->sioc. On failure it's unref'ed. */ +static int nbd_client_handshake(BlockDriverState *bs, Error **errp) { BDRVNBDState *s = (BDRVNBDState *)bs->opaque; AioContext *aio_context = bdrv_get_aio_context(bs); int ret; trace_nbd_client_handshake(s->export); - - s->sioc = sioc; - - qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL); - qio_channel_attach_aio_context(QIO_CHANNEL(sioc), aio_context); + qio_channel_set_blocking(QIO_CHANNEL(s->sioc), false, NULL); + qio_channel_attach_aio_context(QIO_CHANNEL(s->sioc), aio_context); s->info.request_sizes = true; s->info.structured_reply = true; s->info.base_allocation = true; s->info.x_dirty_bitmap = g_strdup(s->x_dirty_bitmap); s->info.name = g_strdup(s->export ?: ""); - ret = nbd_receive_negotiate(aio_context, QIO_CHANNEL(sioc), s->tlscreds, + ret = nbd_receive_negotiate(aio_context, QIO_CHANNEL(s->sioc), s->tlscreds, s->hostname, &s->ioc, &s->info, errp); g_free(s->info.x_dirty_bitmap); g_free(s->info.name); if (ret < 0) { - object_unref(OBJECT(sioc)); + yank_unregister_function(BLOCKDEV_YANK_INSTANCE(bs->node_name), + nbd_yank, bs); + object_unref(OBJECT(s->sioc)); s->sioc = NULL; return ret; } @@ -1835,7 +1859,7 @@ static int nbd_client_handshake(BlockDriverState *bs, QIOChannelSocket *sioc, } if (!s->ioc) { - s->ioc = QIO_CHANNEL(sioc); + s->ioc = QIO_CHANNEL(s->sioc); object_ref(OBJECT(s->ioc)); } @@ -1851,9 +1875,11 @@ static int nbd_client_handshake(BlockDriverState *bs, QIOChannelSocket *sioc, { NBDRequest request = { .type = NBD_CMD_DISC }; - nbd_send_request(s->ioc ?: QIO_CHANNEL(sioc), &request); + nbd_send_request(s->ioc ?: QIO_CHANNEL(s->sioc), &request); - object_unref(OBJECT(sioc)); + yank_unregister_function(BLOCKDEV_YANK_INSTANCE(bs->node_name), + nbd_yank, bs); + object_unref(OBJECT(s->sioc)); s->sioc = NULL; return ret; @@ -2245,7 +2271,6 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags, { int ret; BDRVNBDState *s = (BDRVNBDState *)bs->opaque; - QIOChannelSocket *sioc; ret = nbd_process_options(bs, options, errp); if (ret < 0) { @@ -2256,17 +2281,23 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags, qemu_co_mutex_init(&s->send_mutex); qemu_co_queue_init(&s->free_sema); + yank_register_instance(BLOCKDEV_YANK_INSTANCE(bs->node_name), errp); + if (*errp) { + return -EEXIST; + } + /* * establish TCP connection, return error if it fails * TODO: Configurable retry-until-timeout behaviour. */ - sioc = nbd_establish_connection(s->saddr, errp); - if (!sioc) { + if (nbd_establish_connection(bs, s->saddr, errp) < 0) { + yank_unregister_instance(BLOCKDEV_YANK_INSTANCE(bs->node_name)); return -ECONNREFUSED; } - ret = nbd_client_handshake(bs, sioc, errp); + ret = nbd_client_handshake(bs, errp); if (ret < 0) { + yank_unregister_instance(BLOCKDEV_YANK_INSTANCE(bs->node_name)); nbd_clear_bdrvstate(s); return ret; } @@ -2326,6 +2357,7 @@ static void nbd_close(BlockDriverState *bs) BDRVNBDState *s = bs->opaque; nbd_client_close(bs); + yank_unregister_instance(BLOCKDEV_YANK_INSTANCE(bs->node_name)); nbd_clear_bdrvstate(s); } From patchwork Sun Nov 15 11:36:09 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1400427 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=nongnu.org (client-ip=209.51.188.17; helo=lists.gnu.org; envelope-from=qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=web.de Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; secure) header.d=web.de header.i=@web.de header.a=rsa-sha256 header.s=dbaedf251592 header.b=gbWlrSeH; dkim-atps=neutral Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4CYqtP5H01z9sRK for ; Sun, 15 Nov 2020 22:37:01 +1100 (AEDT) Received: from localhost ([::1]:49330 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1keGL5-00056r-De for incoming@patchwork.ozlabs.org; Sun, 15 Nov 2020 06:36:59 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:57028) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKR-00051x-2B; Sun, 15 Nov 2020 06:36:19 -0500 Received: from mout.web.de ([212.227.17.11]:37535) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKP-0008GO-2F; Sun, 15 Nov 2020 06:36:18 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1605440171; bh=FbHZ1OXiBweTFVG2ZYn66/YFqMCzwwjYRQFr7/zvHnw=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=gbWlrSeHOgqI3yv7bKb+vv77M8JGgYAmH1ZCXD2vFDMFpOpAXv6zI2qbZyZWuPhV/ Zi7kS3MBlpGsDVfbTDx/vISIBHzJlRKmdI7QfFMuonvcnYoBMK6CSJgcrPg6aEDVmU Td2PIzVi8he3orQDVuOH6+ef+MLZaRWQT5FSwedY= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.172]) by smtp.web.de (mrweb103 [213.165.67.124]) with ESMTPSA (Nemesis) id 0MI63m-1ki7fw3KaU-003szT; Sun, 15 Nov 2020 12:36:10 +0100 Date: Sun, 15 Nov 2020 12:36:09 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v11 3/7] chardev/char-socket.c: Add yank feature Message-ID: <0c8b573bc608df476767a612f4303eb2dfc3b7bd.1605439674.git.lukasstraub2@web.de> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:XtcSClyQ7xHcMubuEVGRkheh4pGtJZdcCIpa1N03iLLZCPrRGZg 6KhF2OwFCEAx2U/oigUZXWI5XO2KqD93Tfj5cRZ3DgxCQFctq/+MfBNcQI6g/9VrAD3g5AF 4DeXiQ3eEcSW8aHWZMlOvGNxm5fbFbobWNy71Z75wQROqRwiz7dSlhRNOh4shNMpdYVysOQ yGU2zvD6am+BTYXc8Ijdw== X-UI-Out-Filterresults: notjunk:1;V03:K0:wN2oaNoW1ao=:F3T9i3WIVNXsspJbm+OKsz DVN1ScdMDc6zz1Isj4hDRgNnKkae9rzDisjQwDDwWi3IWB40PpSv1k+2ZLFqCZbFDaulI5PlY //VOnDwHmL0v/MB+PKL3JgCyPWOBMf9pv1u1/2vjeGuyUSd2I7itcj+FnooMCPx72I0/5MvpM nr+fQDxYUOlThjnp5kcajG35gvEd8H89qdNQV9hzhzzgOz7EarYnxq2mGV58Mr6emdazZ1X2m I4jD11DUUk0EMSwkwiR0E5GP7LnhYxbDGb57JQIJDO/ByCIcd1O4ffKs6j+ngt/BhguTDcgYP pLBjb1P1QSFthUWm/Uf0byE43IeSCMmKqjc6a6wW/5coFjuxBLbbS2Qa6l0HrDqRihX8q4IS2 p+eKW25rozlBPWuo4nlFWvJvi7GNiKhvGerHx/NeItnzlMbiZbtYpXeS215kVriHv2oL5zE4R b3KjZwCgdtDK/bi0mqq5zqtoKeSXzZBjH5CNCu/yCF4gYIx5cBZUJaOS+0YmtRx/mQGIKpkEF oMWKa6t8aWopPvdQgEhKL6ifTTA/34URljHpyAxyVnnTHIS5g33uISQGscYK5M+SLfB+Xw/W+ IhFM86rP26GP/ExVKs+IzMIsdHwlw0Sue7cZrNu3PDJD+wVcjVy8lopN3GIW6k7YLoLc92OAt ahZxaT+0lEsvLu9rfEFBaOvEB8ixa6wEIlVq+feFLC3Xlv09p/EAxqrB0GWO55Nr096arbXne 8xpe5fn15JuRFxhtbyzI0Bxh4gd6xdlvJxBr3Ni0hc2mLajiStCs+2aZwpB0x5E7+MlulTSgD vsO7Aihi6GJSQeJC+OGNNHwDKNkE1l5ON384gUtAkwujOWH0qM/+rl+zbXe5LGzfrpCsIHGOQ VAAErJS1hG93VOmmzDBw== Received-SPF: pass client-ip=212.227.17.11; envelope-from=lukasstraub2@web.de; helo=mout.web.de X-detected-operating-system: by eggs.gnu.org: First seen = 2020/11/15 06:19:18 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -24 X-Spam_score: -2.5 X-Spam_bar: -- X-Spam_report: (-2.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H3=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , "Daniel P. =?utf-8?b?QmVycmFuZ8Op?= " , qemu-block , Juan Quintela , Markus Armbruster , "Dr. David Alan Gilbert" , Max Reitz , Paolo Bonzini , =?utf-8?q?Marc-Andr=C3=A9?= Lureau Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: "Qemu-devel" Register a yank function to shutdown the socket on yank. Signed-off-by: Lukas Straub Acked-by: Stefan Hajnoczi --- chardev/char-socket.c | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) -- 2.20.1 diff --git a/chardev/char-socket.c b/chardev/char-socket.c index 213a4c8dd0..7f2ee9a338 100644 --- a/chardev/char-socket.c +++ b/chardev/char-socket.c @@ -34,6 +34,7 @@ #include "qapi/error.h" #include "qapi/clone-visitor.h" #include "qapi/qapi-visit-sockets.h" +#include "qemu/yank.h" #include "chardev/char-io.h" #include "qom/object.h" @@ -70,6 +71,7 @@ struct SocketChardev { size_t read_msgfds_num; int *write_msgfds; size_t write_msgfds_num; + bool registered_yank; SocketAddress *addr; bool is_listen; @@ -415,6 +417,12 @@ static void tcp_chr_free_connection(Chardev *chr) tcp_set_msgfds(chr, NULL, 0); remove_fd_in_watch(chr); + if (s->state == TCP_CHARDEV_STATE_CONNECTING + || s->state == TCP_CHARDEV_STATE_CONNECTED) { + yank_unregister_function(CHARDEV_YANK_INSTANCE(chr->label), + yank_generic_iochannel, + QIO_CHANNEL(s->sioc)); + } object_unref(OBJECT(s->sioc)); s->sioc = NULL; object_unref(OBJECT(s->ioc)); @@ -932,6 +940,9 @@ static int tcp_chr_add_client(Chardev *chr, int fd) } tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING); tcp_chr_set_client_ioc_name(chr, sioc); + yank_register_function(CHARDEV_YANK_INSTANCE(chr->label), + yank_generic_iochannel, + QIO_CHANNEL(sioc)); ret = tcp_chr_new_client(chr, sioc); object_unref(OBJECT(sioc)); return ret; @@ -946,6 +957,9 @@ static void tcp_chr_accept(QIONetListener *listener, tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING); tcp_chr_set_client_ioc_name(chr, cioc); + yank_register_function(CHARDEV_YANK_INSTANCE(chr->label), + yank_generic_iochannel, + QIO_CHANNEL(cioc)); tcp_chr_new_client(chr, cioc); } @@ -961,6 +975,9 @@ static int tcp_chr_connect_client_sync(Chardev *chr, Error **errp) object_unref(OBJECT(sioc)); return -1; } + yank_register_function(CHARDEV_YANK_INSTANCE(chr->label), + yank_generic_iochannel, + QIO_CHANNEL(sioc)); tcp_chr_new_client(chr, sioc); object_unref(OBJECT(sioc)); return 0; @@ -976,6 +993,9 @@ static void tcp_chr_accept_server_sync(Chardev *chr) tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING); sioc = qio_net_listener_wait_client(s->listener); tcp_chr_set_client_ioc_name(chr, sioc); + yank_register_function(CHARDEV_YANK_INSTANCE(chr->label), + yank_generic_iochannel, + QIO_CHANNEL(sioc)); tcp_chr_new_client(chr, sioc); object_unref(OBJECT(sioc)); } @@ -1086,6 +1106,9 @@ static void char_socket_finalize(Object *obj) object_unref(OBJECT(s->tls_creds)); } g_free(s->tls_authz); + if (s->registered_yank) { + yank_unregister_instance(CHARDEV_YANK_INSTANCE(chr->label)); + } qemu_chr_be_event(chr, CHR_EVENT_CLOSED); } @@ -1101,6 +1124,9 @@ static void qemu_chr_socket_connected(QIOTask *task, void *opaque) if (qio_task_propagate_error(task, &err)) { tcp_chr_change_state(s, TCP_CHARDEV_STATE_DISCONNECTED); + yank_unregister_function(CHARDEV_YANK_INSTANCE(chr->label), + yank_generic_iochannel, + QIO_CHANNEL(sioc)); check_report_connect_error(chr, err); goto cleanup; } @@ -1134,6 +1160,9 @@ static void tcp_chr_connect_client_async(Chardev *chr) tcp_chr_change_state(s, TCP_CHARDEV_STATE_CONNECTING); sioc = qio_channel_socket_new(); tcp_chr_set_client_ioc_name(chr, sioc); + yank_register_function(CHARDEV_YANK_INSTANCE(chr->label), + yank_generic_iochannel, + QIO_CHANNEL(sioc)); /* * Normally code would use the qio_channel_socket_connect_async * method which uses a QIOTask + qio_task_set_error internally @@ -1376,6 +1405,12 @@ static void qmp_chardev_open_socket(Chardev *chr, qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_FD_PASS); } + yank_register_instance(CHARDEV_YANK_INSTANCE(chr->label), errp); + if (*errp) { + return; + } + s->registered_yank = true; + /* be isn't opened until we get a connection */ *be_opened = false; From patchwork Sun Nov 15 11:36:13 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1400430 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=nongnu.org (client-ip=209.51.188.17; helo=lists.gnu.org; envelope-from=qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=web.de Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; secure) header.d=web.de header.i=@web.de header.a=rsa-sha256 header.s=dbaedf251592 header.b=OAqw/Zzj; dkim-atps=neutral Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4CYqxV612lz9sRK for ; Sun, 15 Nov 2020 22:39:42 +1100 (AEDT) Received: from localhost ([::1]:57572 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1keGNg-0008TA-Me for incoming@patchwork.ozlabs.org; Sun, 15 Nov 2020 06:39:40 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:57040) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKU-0005A1-Da; Sun, 15 Nov 2020 06:36:22 -0500 Received: from mout.web.de ([212.227.15.3]:51063) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKS-0008HQ-9Z; Sun, 15 Nov 2020 06:36:22 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1605440174; bh=aOQZxDWLmA3ottt++HvQsb09XxJx64I2LDDCqr2+C3Q=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=OAqw/ZzjdvuCZ9tSBiXHSAw38C+gcz5IiFPpMNjav/t1dPIQn0onvVb02HG6r1Oc3 42aue7wf9M4Ybri2XvI0mPqL7GvvHVp8Y/IoSw6Bw8CHgLony0GfWGjqOd+ndY1I1e CQlVUtOVl0pg72/kjjCoPHpHPATjb+NacVMqA9S8= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.172]) by smtp.web.de (mrweb004 [213.165.67.108]) with ESMTPSA (Nemesis) id 0MP2Sl-1kbDvV0KRz-006R2I; Sun, 15 Nov 2020 12:36:14 +0100 Date: Sun, 15 Nov 2020 12:36:13 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v11 4/7] migration: Add yank feature Message-ID: <483f47c06989ca8bf39ec2fd2233f429c677c5c9.1605439674.git.lukasstraub2@web.de> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:mWoH5/HcwcRKM0Np/7jisdUpxLgKel3/Bq2HWGoTcCiZebGz5Tp uvgm0fKpERkMbprrEYRTEWGXBIHUd4E2w2pPFwLJVkdCZpc0ROdRP73UrkD0I897tRGzax+ rf73ehmMZwE/BwfcjizC63s2psBZmR8yQBBC1DgMzDluFvBcMn0PfRyfC+BzijXaiQ8ZjfV 4bY/7bYzTyvS+RICl9+4w== X-UI-Out-Filterresults: notjunk:1;V03:K0:0ZyHuWxBLxo=:JCYFZnJgMItf++0oi9Bqss 0G9wUwQ9d3cit890S4mi/vDiARro3Yhpzt64HM82GKfStRjkKesCO5x3I1CxL6Kke8P9trGyX 8bluvtM0zSwcj4ewXEbIl8ex1B07tkYlXnDUA2qMZ9TpyHbcyxst0PEjSbcxPysei02RaUAdk zKR+oiUU+BMzIhGgm6MbnOoWZ4BiX4vUjyZV+gWBSjfZGuw2FnBccgKl4D958n7schD1E6lXM gxEc5dXNd/J1RsvlezhMZmoxXlDHS7ThWrfUMnJEAwlRM0DvNI5lthPuowf/11vXRacnwLKh9 iixiWz3cHxzq77AIIJU56rCWw8V0h98pLX8gIT8m5ynIcEBIarP76Dm4ndihYNeqCPFF+jchb bX2zTyZUXQ8X4O876as8mq4h7PNMUK+Q/2pwn299oFDhgPsNj0M5n3+s3nhlqhA9AdNO59kxB 9uutchKVqH6oomaIvoG8crMd/GeKOKbmFK3JHgs38WJA9+VS2gehhcuAcqQMPBhN488GJH63L U2dBsUW+3vhCu2vtJee8dy70sLvt+Egl83NWS+fflgcSjI19mlDS+XgjgVEeGlAtL5jmUVocp I0gFgVE+qokk2fsVMAAnl2ajK0ktqerbSE+wfZgLeBeOWNr15H0StdQT/fE16pQz5nD8BMYoI hiWT9FXfowV9rlHy+aJJguFO/07SvMkuK7CVKLIBtU9LKDiE3B5RsHMxeBvkQZkgFVZTqpgWY EvZUgUdM4Y9BBU9xle249Qs1TYMbQRq3P6JhUjDTy7OAjWepQ8OUmiOvYYX2pkEqxg/ng3oB2 Q69RVd7WUzf1yvW5mRKL8FZL+GAVQE8/ODM6xZ7OSlKPDRjYgdYt1ijmD6zTgYvBnpI99/kIH /UBilirGGYYGmeYnV/ig== Received-SPF: pass client-ip=212.227.15.3; envelope-from=lukasstraub2@web.de; helo=mout.web.de X-detected-operating-system: by eggs.gnu.org: First seen = 2020/11/15 06:36:18 X-ACL-Warn: Detected OS = Linux 3.11 and newer [fuzzy] X-Spam_score_int: -24 X-Spam_score: -2.5 X-Spam_bar: -- X-Spam_report: (-2.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H3=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , "Daniel P. =?utf-8?b?QmVycmFuZ8Op?= " , qemu-block , Juan Quintela , Markus Armbruster , "Dr. David Alan Gilbert" , Max Reitz , Paolo Bonzini , =?utf-8?q?Marc-Andr=C3=A9?= Lureau Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: "Qemu-devel" Register yank functions on sockets to shut them down. Signed-off-by: Lukas Straub Acked-by: Stefan Hajnoczi Acked-by: Dr. David Alan Gilbert --- migration/channel.c | 13 +++++++++++++ migration/migration.c | 25 +++++++++++++++++++++++++ migration/multifd.c | 10 ++++++++++ migration/qemu-file-channel.c | 7 +++++++ migration/savevm.c | 6 ++++++ 5 files changed, 61 insertions(+) -- 2.20.1 diff --git a/migration/channel.c b/migration/channel.c index 8a783baa0b..35fe234e9c 100644 --- a/migration/channel.c +++ b/migration/channel.c @@ -18,6 +18,8 @@ #include "trace.h" #include "qapi/error.h" #include "io/channel-tls.h" +#include "io/channel-socket.h" +#include "qemu/yank.h" /** * @migration_channel_process_incoming - Create new incoming migration channel @@ -35,6 +37,11 @@ void migration_channel_process_incoming(QIOChannel *ioc) trace_migration_set_incoming_channel( ioc, object_get_typename(OBJECT(ioc))); + if (object_dynamic_cast(OBJECT(ioc), TYPE_QIO_CHANNEL_SOCKET)) { + yank_register_function(MIGRATION_YANK_INSTANCE, yank_generic_iochannel, + QIO_CHANNEL(ioc)); + } + if (s->parameters.tls_creds && *s->parameters.tls_creds && !object_dynamic_cast(OBJECT(ioc), @@ -67,6 +74,12 @@ void migration_channel_connect(MigrationState *s, ioc, object_get_typename(OBJECT(ioc)), hostname, error); if (!error) { + if (object_dynamic_cast(OBJECT(ioc), TYPE_QIO_CHANNEL_SOCKET)) { + yank_register_function(MIGRATION_YANK_INSTANCE, + yank_generic_iochannel, + QIO_CHANNEL(ioc)); + } + if (s->parameters.tls_creds && *s->parameters.tls_creds && !object_dynamic_cast(OBJECT(ioc), diff --git a/migration/migration.c b/migration/migration.c index 87a9b59f83..a5add9d17d 100644 --- a/migration/migration.c +++ b/migration/migration.c @@ -56,6 +56,7 @@ #include "net/announce.h" #include "qemu/queue.h" #include "multifd.h" +#include "qemu/yank.h" #ifdef CONFIG_VFIO #include "hw/vfio/vfio-common.h" @@ -252,6 +253,8 @@ void migration_incoming_state_destroy(void) qapi_free_SocketAddressList(mis->socket_address_list); mis->socket_address_list = NULL; } + + yank_unregister_instance(MIGRATION_YANK_INSTANCE); } static void migrate_generate_event(int new_state) @@ -429,8 +432,14 @@ void qemu_start_incoming_migration(const char *uri, Error **errp) { const char *p = NULL; + yank_register_instance(MIGRATION_YANK_INSTANCE, errp); + if (*errp) { + return; + } + qapi_event_send_migration(MIGRATION_STATUS_SETUP); if (!strcmp(uri, "defer")) { + yank_unregister_instance(MIGRATION_YANK_INSTANCE); deferred_incoming_migration(errp); } else if (strstart(uri, "tcp:", &p) || strstart(uri, "unix:", NULL) || @@ -445,6 +454,7 @@ void qemu_start_incoming_migration(const char *uri, Error **errp) } else if (strstart(uri, "fd:", &p)) { fd_start_incoming_migration(p, errp); } else { + yank_unregister_instance(MIGRATION_YANK_INSTANCE); error_setg(errp, "unknown migration protocol: %s", uri); } } @@ -1750,6 +1760,7 @@ static void migrate_fd_cleanup(MigrationState *s) } notifier_list_notify(&migration_state_notifiers, s); block_cleanup_parameters(s); + yank_unregister_instance(MIGRATION_YANK_INSTANCE); } static void migrate_fd_cleanup_schedule(MigrationState *s) @@ -2024,6 +2035,7 @@ void qmp_migrate_recover(const char *uri, Error **errp) * only re-setup the migration stream and poke existing migration * to continue using that newly established channel. */ + yank_unregister_instance(MIGRATION_YANK_INSTANCE); qemu_start_incoming_migration(uri, errp); } @@ -2161,6 +2173,13 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, return; } + if (!(has_resume && resume)) { + yank_register_instance(MIGRATION_YANK_INSTANCE, errp); + if (*errp) { + return; + } + } + if (strstart(uri, "tcp:", &p) || strstart(uri, "unix:", NULL) || strstart(uri, "vsock:", NULL)) { @@ -2174,6 +2193,9 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, } else if (strstart(uri, "fd:", &p)) { fd_start_outgoing_migration(s, p, &local_err); } else { + if (!(has_resume && resume)) { + yank_unregister_instance(MIGRATION_YANK_INSTANCE); + } error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "uri", "a valid migration protocol"); migrate_set_state(&s->state, MIGRATION_STATUS_SETUP, @@ -2183,6 +2205,9 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, } if (local_err) { + if (!(has_resume && resume)) { + yank_unregister_instance(MIGRATION_YANK_INSTANCE); + } migrate_fd_error(s, local_err); error_propagate(errp, local_err); return; diff --git a/migration/multifd.c b/migration/multifd.c index 45c690aa11..1a1e589064 100644 --- a/migration/multifd.c +++ b/migration/multifd.c @@ -25,6 +25,9 @@ #include "trace.h" #include "multifd.h" +#include "qemu/yank.h" +#include "io/channel-socket.h" + /* Multiple fd's */ #define MULTIFD_MAGIC 0x11223344U @@ -974,6 +977,13 @@ int multifd_load_cleanup(Error **errp) for (i = 0; i < migrate_multifd_channels(); i++) { MultiFDRecvParams *p = &multifd_recv_state->params[i]; + if (object_dynamic_cast(OBJECT(p->c), TYPE_QIO_CHANNEL_SOCKET) + && OBJECT(p->c)->ref == 1) { + yank_unregister_function(MIGRATION_YANK_INSTANCE, + yank_generic_iochannel, + QIO_CHANNEL(p->c)); + } + object_unref(OBJECT(p->c)); p->c = NULL; qemu_mutex_destroy(&p->mutex); diff --git a/migration/qemu-file-channel.c b/migration/qemu-file-channel.c index d2ce32f4b9..afc3a7f642 100644 --- a/migration/qemu-file-channel.c +++ b/migration/qemu-file-channel.c @@ -27,6 +27,7 @@ #include "qemu-file.h" #include "io/channel-socket.h" #include "qemu/iov.h" +#include "qemu/yank.h" static ssize_t channel_writev_buffer(void *opaque, @@ -104,6 +105,12 @@ static int channel_close(void *opaque, Error **errp) int ret; QIOChannel *ioc = QIO_CHANNEL(opaque); ret = qio_channel_close(ioc, errp); + if (object_dynamic_cast(OBJECT(ioc), TYPE_QIO_CHANNEL_SOCKET) + && OBJECT(ioc)->ref == 1) { + yank_unregister_function(MIGRATION_YANK_INSTANCE, + yank_generic_iochannel, + QIO_CHANNEL(ioc)); + } object_unref(OBJECT(ioc)); return ret; } diff --git a/migration/savevm.c b/migration/savevm.c index 5f937a2762..1a3808998e 100644 --- a/migration/savevm.c +++ b/migration/savevm.c @@ -62,6 +62,7 @@ #include "migration/colo.h" #include "qemu/bitmap.h" #include "net/announce.h" +#include "qemu/yank.h" const unsigned int postcopy_ram_discard_version; @@ -3008,6 +3009,11 @@ int load_snapshot(const char *name, Error **errp) qemu_system_reset(SHUTDOWN_CAUSE_NONE); mis->from_src_file = f; + yank_register_instance(MIGRATION_YANK_INSTANCE, errp); + if (*errp) { + ret = -EINVAL; + goto err_drain; + } aio_context_acquire(aio_context); ret = qemu_loadvm_state(f); migration_incoming_state_destroy(); From patchwork Sun Nov 15 11:36:16 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1400431 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=nongnu.org (client-ip=209.51.188.17; helo=lists.gnu.org; envelope-from=qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=web.de Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; secure) header.d=web.de header.i=@web.de header.a=rsa-sha256 header.s=dbaedf251592 header.b=cwA8nxX+; dkim-atps=neutral Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4CYqxm1f6jz9sRK for ; Sun, 15 Nov 2020 22:39:56 +1100 (AEDT) Received: from localhost ([::1]:58608 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1keGNu-0000TU-7Q for incoming@patchwork.ozlabs.org; Sun, 15 Nov 2020 06:39:54 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:57054) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKX-0005GA-Bz; Sun, 15 Nov 2020 06:36:27 -0500 Received: from mout.web.de ([217.72.192.78]:37707) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKV-0008Ig-Jd; Sun, 15 Nov 2020 06:36:25 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1605440178; bh=9ZKQH1Famksq6matfj22LsnulMjl2YZVLuwzqiiJrag=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=cwA8nxX+Nx5LsZbc1CNdkTgIzPwubBweEoBesNjgmpmUhLagv6PFbMCuRygJ9Fff3 BOUYEVGc9G4nWslW6hx0ePYd867NkJmZgK+bM5mXvYzDVFXNlptZQ5uqpm2mNOxHR4 5ftqcN3DgELZ9PKS6JpJi7RWp2s3A9Psf86aBAIE= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.172]) by smtp.web.de (mrweb105 [213.165.67.124]) with ESMTPSA (Nemesis) id 1MT7aP-1kqkfN08Q3-00UcC6; Sun, 15 Nov 2020 12:36:18 +0100 Date: Sun, 15 Nov 2020 12:36:16 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v11 5/7] io/channel-tls.c: make qio_channel_tls_shutdown thread-safe Message-ID: In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:LKalL2J9P/p2G31XSWBsqgLXDL5YVCVAUrhGHYo+EypkPH1tD9m JBk3LutzgXL3PO11xYj9NrPLWGeMZ8MVJTrOE0UIK1JiFXNJZIY611RprBl7d/9BHhvF7L9 M9uHCGWwAEbLcIRCF9tFA+W6TlqfzgCrIzl9tCcPtnCF2qJrHxvxz42VmoQBuj3tXFBX5+X d7gFVzTtR9E6iwBwBH51Q== X-UI-Out-Filterresults: notjunk:1;V03:K0:07OHfzW9+VM=:2u/RlV8WzSB1n1lz5JPGn3 1gpxeUXrwbK/pEutoatLTlADNyxtvxjaksgzkr/qVZeOGgmZB3ewssX+jUxQz+MSqIXweK/Np MQMUOsh3TV3pUmUIcxp5J8p/d6ZMtFv6y4/8t9H/iKAEIklJHQhM3KrZUq/kDX7oBqs8rCLLU rDCUgoOg8Z/xaMZD7ifYjaK17r3d6s0ptRji325hUO7H0mPw6Nsuk4TwWaQ+zr2KE1NUm19TN LA79OpMPJuU4XrmRFWPd7gTSojebxr5doi6LgDTXv8omGck81596k0TnleXDdmyBCc+A8pYPE kfcdM+hkkkC7hNj4wofodlNsAOV0WxAcULsdLUlATHIMIJXAd+eQ05DtLjLpnwdtDqLNs6MRJ lk0cH1bGay7nRk7X+ZIOW65UdWTuACWbe/Dl7wUFfFfiNham67eoRQrYIUxjybUwKMSvLj+W/ vQRAd+kkmcfL/LTDKY2FvCYAdJTnXqMKZ6a+n9BTsJ4xkviZqhLboGus21bcwQmEGU4QIwiJp 3UTDHxf2l/rotZsrfMgnEtKG4+jds1yIgJ7sa7N5DAtH2LZmJVhB6R20I22pHSO8aiE91RHtZ 33tifZSqqUe2RSFkAS3doo3R2R9Fq9WbStmIsLHzzRBoyxJrq3GVw737DqsT1iuUaoNJmSxSw Q9fgdWRWlKWAN//Q52kLyhFki+VA/HLVWPsHvniEP4QFA4pRxVjkUknCatoZCUu85LNWTOGX/ 1wfEAAl03sgPh6yRMhcwVwCYb0qMcLtx7cRiYkDmCUAnQc/xsBQ2WFZPf7SoWyj6TJWZi0D49 U4qhh/aREjHVjldzG4pMKppi1Sey2SeFqRlVaSQ9bwiHTqp+vg4IMyOCinvecd2uvi3ZiGcpE sXvqsGM+5r4SUA81qwOA== Received-SPF: pass client-ip=217.72.192.78; envelope-from=lukasstraub2@web.de; helo=mout.web.de X-detected-operating-system: by eggs.gnu.org: First seen = 2020/11/15 05:44:48 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -24 X-Spam_score: -2.5 X-Spam_bar: -- X-Spam_report: (-2.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H2=-0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , "Daniel P. =?utf-8?b?QmVycmFuZ8Op?= " , qemu-block , Juan Quintela , Markus Armbruster , "Dr. David Alan Gilbert" , Max Reitz , Paolo Bonzini , =?utf-8?q?Marc-Andr=C3=A9?= Lureau Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: "Qemu-devel" Make qio_channel_tls_shutdown thread-safe by using atomics when accessing tioc->shutdown. Signed-off-by: Lukas Straub Acked-by: Stefan Hajnoczi Reviewed-by: Daniel P. Berrangé --- io/channel-tls.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) -- 2.20.1 diff --git a/io/channel-tls.c b/io/channel-tls.c index 388f019977..2ae1b92fc0 100644 --- a/io/channel-tls.c +++ b/io/channel-tls.c @@ -23,6 +23,7 @@ #include "qemu/module.h" #include "io/channel-tls.h" #include "trace.h" +#include "qemu/atomic.h" static ssize_t qio_channel_tls_write_handler(const char *buf, @@ -277,7 +278,8 @@ static ssize_t qio_channel_tls_readv(QIOChannel *ioc, return QIO_CHANNEL_ERR_BLOCK; } } else if (errno == ECONNABORTED && - (tioc->shutdown & QIO_CHANNEL_SHUTDOWN_READ)) { + (qatomic_load_acquire(&tioc->shutdown) & + QIO_CHANNEL_SHUTDOWN_READ)) { return 0; } @@ -361,7 +363,7 @@ static int qio_channel_tls_shutdown(QIOChannel *ioc, { QIOChannelTLS *tioc = QIO_CHANNEL_TLS(ioc); - tioc->shutdown |= how; + qatomic_or(&tioc->shutdown, how); return qio_channel_shutdown(tioc->master, how, errp); } From patchwork Sun Nov 15 11:36:20 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1400432 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=nongnu.org (client-ip=209.51.188.17; helo=lists.gnu.org; envelope-from=qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=web.de Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; secure) header.d=web.de header.i=@web.de header.a=rsa-sha256 header.s=dbaedf251592 header.b=eHd10ePV; dkim-atps=neutral Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4CYqxn022sz9sT6 for ; Sun, 15 Nov 2020 22:39:57 +1100 (AEDT) Received: from localhost ([::1]:58700 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1keGNu-0000Vh-Uk for incoming@patchwork.ozlabs.org; Sun, 15 Nov 2020 06:39:54 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:57074) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKd-0005IP-7B; Sun, 15 Nov 2020 06:36:32 -0500 Received: from mout.web.de ([212.227.15.14]:57959) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKZ-0008KB-C3; Sun, 15 Nov 2020 06:36:30 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1605440181; bh=Tgofz4TqQkbVOqI6lXeE1WM4V8ken3CEM4N4qkKocwc=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=eHd10ePVu7sVpvcWm71rMgc8xXXTm7VAR+g9mvhjZ+hy+NJ1diExXpy8H2GQJXL5A qvi/vlwMcIiAYtXYE21Ul6v+OswT49scMenCHl6+drNCNPeWPbz2OUU/Z2yn9vcVbT VYR2nuaS+z2dAwTlT1zavqwYAG6gZU7Ywcj5whlQ= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.172]) by smtp.web.de (mrweb003 [213.165.67.108]) with ESMTPSA (Nemesis) id 0MOAmi-1kawwD1Zlk-005biZ; Sun, 15 Nov 2020 12:36:21 +0100 Date: Sun, 15 Nov 2020 12:36:20 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v11 6/7] io: Document qmp oob suitability of qio_channel_shutdown and io_shutdown Message-ID: In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:4WA08NBdqkAsO9E/3zg0TxOLscciiFJKvLnGw9ZdPa9t154hdWd 3VFaoODXvStoeeyXfaZJXgaAYsI8zWl+X3B5DGSnVbNkaAUqdCU7EUpHB3uutO6wz4T5XVN c/GTxZZDr0L0hs4niJrBkhfv3OiAB3DvCqt+CtjOP8ek14qu/5KJcNJC6aiGzh3iT4+9vAr Y/jPIs0KJu3Wn4WJE+K+g== X-UI-Out-Filterresults: notjunk:1;V03:K0:1einL2Cuem8=:TdVj3uetgao/9HQHdBp6zg ESpwNPe7HfQ+8HrK3Pm7xySZtJ5F89ulI+H2AiyvLnr4s9j5blhYn2b0Iju3tC2XZ97Pe+8xL EUBYkcmyRaV/62vy3QcYgcK8vurLbJCVrwKrTAzzYleWUTpKa7CXUwnQgll1me6hH50AbMBo2 04s0zNXrCe6jG/BVCmbI/Bk4IzAKq/xabN6cfK0X3UrdUcIZoHu/B1ZW5gqVvR19haKmyoXt2 /ln2Ugy4rW6OXvSmu+C7IHyRx3HEFO22xbu3CIr5S1W20I7srSkLqeNdeCtW6hrCMX9mEwDup I7WvEzRCagRVOCNAoY9UbfTzrKoKmDAIYCzvrvuIK1+bsg8FeytSHjL5YT5DjfAdWwEHyh/Cg bg6/2nDk5T54CSB3qa+PIqk4GlVrBxM1/CHta+2Ju3lxzaitFFnbQsXqC83GebybfqyABB+/n 29MKj19i5TxHg6dpVHEbUquMU+DVgDHB1ZIQqnxOdHT0pb+KUJAXHwssLGDTi0HtSPoP4TmZb lDHPvQ5RwoQiB/5dwU20NYeRGHMAvPk/m+FmDaLFbibrel1vyV9b2QDrfBHWgGt5CGX11bg9A vHuSf2hA1XgJe/h02SMxkKTQ59tuWWwugmOTK7MgIQ/IFIgKGXhiqYigxK3l81Nh+cHG2wwnF kYyFtGZ+iZZaWZE9Ar5CIqYHUKTBv3xiU3wPOwFuUTlYkgZWTh8C6xJtUNgqAUEDGCY92RP8o FedAg97D1MYEXmdoXdGeqsLdfU9YpXMHrRLvXcgISjaYeqZUxpC5XiJNQaghKlFxxGdQ61d9X F5OT34pLplvGwaenJxoiGEDZ7TeDA6SCNvTen/6Zi4GvmTlC60xQEBg0521FpK8FWCTdABqfx A1OkqDIVstZz0RZbx1BA== Received-SPF: pass client-ip=212.227.15.14; envelope-from=lukasstraub2@web.de; helo=mout.web.de X-detected-operating-system: by eggs.gnu.org: First seen = 2020/11/15 06:36:03 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -24 X-Spam_score: -2.5 X-Spam_bar: -- X-Spam_report: (-2.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H2=-0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , "Daniel P. =?utf-8?b?QmVycmFuZ8Op?= " , qemu-block , Juan Quintela , Markus Armbruster , "Dr. David Alan Gilbert" , Max Reitz , Paolo Bonzini , =?utf-8?q?Marc-Andr=C3=A9?= Lureau Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: "Qemu-devel" Migration and yank code assume that qio_channel_shutdown is thread -safe and can be called from qmp oob handler. Document this after checking the code. Signed-off-by: Lukas Straub Acked-by: Stefan Hajnoczi Reviewed-by: Daniel P. Berrangé --- include/io/channel.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) -- 2.20.1 diff --git a/include/io/channel.h b/include/io/channel.h index 4d6fe45f63..ab9ea77959 100644 --- a/include/io/channel.h +++ b/include/io/channel.h @@ -92,7 +92,8 @@ struct QIOChannel { * provide additional optional features. * * Consult the corresponding public API docs for a description - * of the semantics of each callback + * of the semantics of each callback. io_shutdown in particular + * must be thread-safe, terminate quickly and must not block. */ struct QIOChannelClass { ObjectClass parent; @@ -510,6 +511,8 @@ int qio_channel_close(QIOChannel *ioc, * QIO_CHANNEL_FEATURE_SHUTDOWN prior to calling * this method. * + * This function is thread-safe, terminates quickly and does not block. + * * Returns: 0 on success, -1 on error */ int qio_channel_shutdown(QIOChannel *ioc, From patchwork Sun Nov 15 11:36:23 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1400433 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=nongnu.org (client-ip=209.51.188.17; helo=lists.gnu.org; envelope-from=qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=web.de Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; secure) header.d=web.de header.i=@web.de header.a=rsa-sha256 header.s=dbaedf251592 header.b=JX5yhI1S; dkim-atps=neutral Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4CYr0k2dYHz9sRK for ; Sun, 15 Nov 2020 22:42:28 +1100 (AEDT) Received: from localhost ([::1]:39190 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1keGQL-00047p-Cu for incoming@patchwork.ozlabs.org; Sun, 15 Nov 2020 06:42:25 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:57086) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKh-0005MM-90; Sun, 15 Nov 2020 06:36:35 -0500 Received: from mout.web.de ([212.227.17.12]:43159) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1keGKe-0008L7-V0; Sun, 15 Nov 2020 06:36:35 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1605440185; bh=JmiqDl6XpRwd1d8HX6JcVAODaYhiNxH8lCQr3soufF8=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=JX5yhI1SeTQ9SLHqcYZgQjpRANVAQiISnXb1edk0t1zw2xaPeSajklRH9m5MTMSTr oJr7gxg8O9Ib6z0Da5/A9ONnvJRJNx17vm1lO6aI4Ne09xyeU5j+AOGb8+aCBHR1ni gCGDA99xvoMde71cL90Yn4T/gEGvmaM+4Ua0E330= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.172]) by smtp.web.de (mrweb101 [213.165.67.124]) with ESMTPSA (Nemesis) id 0MVtxM-1kkxMn2TTE-00X27P; Sun, 15 Nov 2020 12:36:25 +0100 Date: Sun, 15 Nov 2020 12:36:23 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v11 7/7] tests/test-char.c: Wait for the chardev to connect in char_socket_client_dupid_test Message-ID: <1318bc2b2d8254b972bc9f2a5fcc05cd79eee513.1605439674.git.lukasstraub2@web.de> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:9wFlkpRheyIy9h6oIeWXW2Ov7DXp3V8BQLa9zJNStbbkZE6iXeK L8uJoaO9guY41UgkqwSNs7srRUZBZoYDashCBjvsa4HmboQoS7bGbV0sIrJ2gf4ylLOC+/z UBcOLEAU9H8XcytdCwpCZOpDCxRLyPaqRVoWqigGoD48lS0eQQK6k9KmQBa9Tu25xKH4/HK C5cLcWXzi/jZPa2kIDCaw== X-UI-Out-Filterresults: notjunk:1;V03:K0:/DRjsa7S6Os=:vP6F0VYDJVzWwzM5KFCooc Zfn17Fcp3+nwK08UBJdtDMHPW/84V1Ns+pr87ukSqR9u1ASNXt7byttMEiuRxaLmYJp1LMrBD 8KyBu4X1rN8WAQ1iqec/7SC0y0Kao8AdVwXBRpTUcMzLYJxhJKAU6rFxdESKepJ0jJVnP5eLc a7rKl4OMiTrkM48n4TCoUKl45gvLsXepe/Lt1ouxQzKBWzcx69N3lj6kCElKZ2b00mWL3KhAu m+aKlfrSCuBTMyXea6vnarQOUg9MnPAJH+wlvPX+PMg3xC1sOh5xh7yFr3NiQnJvholejUcxD mWvqQdF46esUofh/ygJXMytu4nxDDaqmoF7gFc8LDhET1ROUDdTkv/GNIp8HisBTgjkPQ5KjC B+8W5bNPKEMVWKTPJQyaHSjPAjiMs/S1UbRgbAW7syyYP1twQlRSrulqSY9KDzYkOpTSq3FMX 8hsDw+1L19+tudhNm66m215+qZU7X1+zhiPaTUl+O4VrOPjHrfapUuWxzGv690qkNqicT9Owx SfkK9yHLQOZ8yk2eBtTg2rfLzLW+czHl26hQAxySLFPT3UPSG4Ke2dgq1GQ8Z37YWDV5DyIRM NEYQ7U8iqe5/rA/uHPBjaZhzNkdxN9nuOSFZB5AfP6+UYIXU/E6tCa7sFd2VmyAvHy0pSHUJO O3i3K7gHxQkjYYn6zmowbggAI0vHWT6d80HQxCeCoffX6CFbf0jkM38cFLwEDVohP2TIZ8+zi IPOcT/0lBGKoA4+S4LQCMkqpKtXjNjJ6xPfuHXp+wFTweBxax3mSqEjn3eNIBSWU3C+PCdGtf 24L8eD9hZs7a5MKKsWy06+FI9w/xBzbra6Qn8P68WWnTAQRVMRzPX8fwPD3LngbhnV63HPzrU hrRHi13WRnvG32WnOLUg== Received-SPF: pass client-ip=212.227.17.12; envelope-from=lukasstraub2@web.de; helo=mout.web.de X-detected-operating-system: by eggs.gnu.org: First seen = 2020/11/15 06:36:31 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: -24 X-Spam_score: -2.5 X-Spam_bar: -- X-Spam_report: (-2.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H3=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , "Daniel P. =?utf-8?b?QmVycmFuZ8Op?= " , qemu-block , Juan Quintela , Markus Armbruster , "Dr. David Alan Gilbert" , Max Reitz , Paolo Bonzini , =?utf-8?q?Marc-Andr=C3=A9?= Lureau Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: "Qemu-devel" A connecting chardev object has an additional reference by the connecting thread, so if the chardev is still connecting by the end of the test, then the chardev object won't be freed. This in turn means that the yank instance won't be unregistered and when running the next test-case yank_register_instance will abort, because the yank instance is already/still registered. Signed-off-by: Lukas Straub Reviewed-by: Daniel P. Berrangé --- tests/test-char.c | 1 + 1 file changed, 1 insertion(+) -- 2.20.1 diff --git a/tests/test-char.c b/tests/test-char.c index 9196e566e9..aedb5c9eda 100644 --- a/tests/test-char.c +++ b/tests/test-char.c @@ -937,6 +937,7 @@ static void char_socket_client_dupid_test(gconstpointer opaque) g_assert_nonnull(opts); chr1 = qemu_chr_new_from_opts(opts, NULL, &error_abort); g_assert_nonnull(chr1); + qemu_chr_wait_connected(chr1, &error_abort); chr2 = qemu_chr_new_from_opts(opts, NULL, &local_err); g_assert_null(chr2);