From patchwork Fri Oct 30 16:41:08 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1391155 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=YQIYX7XD; 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 4CN7QL61CQz9s0b for ; Sat, 31 Oct 2020 03:42:34 +1100 (AEDT) Received: from localhost ([::1]:60418 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kYXU0-0004hW-Ft for incoming@patchwork.ozlabs.org; Fri, 30 Oct 2020 12:42:32 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:55780) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXSv-0004R8-7E; Fri, 30 Oct 2020 12:41:28 -0400 Received: from mout.web.de ([212.227.15.14]:42949) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXSm-0002z6-8h; Fri, 30 Oct 2020 12:41:24 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1604076070; bh=oR7eWk0m4L2PKomamyzxI8Kt4wkjcH6V3b2Zzh0NqeI=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=YQIYX7XDv1y8tozm6cOsKvowuokGfEogdmk8EOzLN9LSsUw/WtWnHGdsgtnW2TnDs cqGhO0OXcugIMVwq6rxtfzegrDPHA/nkimCgIfjaZGbYtYQdxxHHoVlHG0DsqN2pbD eiVzWBVIejDLfQyXHh5B+a+T+2sLCocR9d7uBiEc= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.100]) by smtp.web.de (mrweb005 [213.165.67.108]) with ESMTPSA (Nemesis) id 1N79NA-1kIApe0IJQ-017LWi; Fri, 30 Oct 2020 17:41:10 +0100 Date: Fri, 30 Oct 2020 17:41:08 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v10 1/8] Introduce yank feature Message-ID: <20201030174108.1c88195b@luklap> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:kXSGI1mIsEvfRuqdVE1BXzhaMa4EOzibVz0C7rDVDtapXMSPxNN ooM5OyCaoceMdU33ABMtE0rSauK3DSqV6aqnz3rMw0JgIobzgvFROQlehLaK/d+HIGkoKY0 a/SUNA8gFPCsw4RWtrAN5YNenLfgSxiVVngC6e947I4NH136maDyhZjOErvZCCNCenxIpyV 2IXr2Gwm5vIURhulRzyaw== X-UI-Out-Filterresults: notjunk:1;V03:K0:CU3cQd23/0s=:oUtbNbuLHGz+s+nvKIdaz3 /vGRy553jEeBUE2ekHRiW9HroaNTZWnrZjtubcnXj6oj3xHMKwMwGacUqtPEQIFkglN+mpSqP ExvrmLgAgV+o1UN3ql9kWX8sx7cpazKYrTR4kE2aIAtsjf7WNNwNwo0UF/q5yBIpLZYW68ieZ mkcHJAv8ZDlEMAI5n3YkmxMnIPPQNKP1ehMc7lW5+oKBrkW9OIsr7mdIiiDXqzDh873QNFD/7 p8Hxa2bFA6VtSdE3g14gXUVb4bbAnQ7LyuC1Cmt2E0Eh2xKwhQ5UxK/CXf5XPrKlZ1cM3jrM3 oqyXAx310BgmlDPpjk5RCAelqND9SQMgkWKFjEuXEXD+ozdpVqDQhsFFwzKcMhscWF5tM4KlB aKbapPLkOsNtGbvzWnX9Fv4MAcQd/FY4AZZrXakdhqjPGXVlg4Q5Jft4va3TSr8SeF80g3bMT +XsKuN+KXx1/KHtE/oR9URIjrL/IomFfM60nvOYjx7a7VIeZaGnYCGwG57B3/3qiniQ1WeFIi yvOElnDNskM56nw10KAdkzPz21+QRnQ4isa39UBnrgj/UQxfcaMpDkh+pwXvdjkrkkUGj/eKR NxepElpR4CSVkTHs1v74/eT+/ecM19s+tnDtJk+EaMATLBSrizBUhH0BFFUeVMAwfvm0YhSo1 zjeksSjt3N95OWWJeh54lU5/KGiffRepU49H7VhbKOipw1gGJXFi42UFjb48+XAMBx/N47AKn Xdyp2DrF8OcC5AVlcLRZs2zKe5SWwDlB0U1WCL0x6bEuGO9BaYksAQNqY4DWtk6f+bMofjIgc Zbe/qR+QkEDLIJSYTPBnhsmkokUokOTg6YE+y9JmoxqvWv2i/2xGkFGmkBesvNDsPgLqQWDEc W1uKggqB1NL/ilGN+PnA== 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/10/30 12:41:14 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 --- include/qemu/yank.h | 95 +++++++++++++++++++ qapi/meson.build | 1 + qapi/qapi-schema.json | 1 + qapi/yank.json | 115 ++++++++++++++++++++++ util/meson.build | 1 + util/yank.c | 216 ++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 429 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/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..79c1705ed7 100644 --- a/qapi/qapi-schema.json +++ b/qapi/qapi-schema.json @@ -91,3 +91,4 @@ { 'include': 'audio.json' } { 'include': 'acpi.json' } { 'include': 'pci.json' } +{ 'include': 'yank.json' } diff --git a/qapi/yank.json b/qapi/yank.json new file mode 100644 index 0000000000..1964a2202e --- /dev/null +++ b/qapi/yank.json @@ -0,0 +1,115 @@ +# -*- Mode: Python -*- +# vim: filetype=python +# + +## +# @YankInstanceType: +# +# An enumeration of yank instance types. See @YankInstance for more +# information. +# +# Since: 5.2 +## +{ '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: 5.2 +## +{ 'struct': 'YankInstanceBlockNode', + 'data': { 'node-name': 'str' } } + +## +# @YankInstanceChardev: +# +# Specifies which character device to yank. See @YankInstance for more +# information. +# +# @id: the chardev's ID +# +# Since: 5.2 +## +{ '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: 5.2 +## +{ '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: 5.2 +## +{ '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: 5.2 +## +{ 'command': 'query-yank', + 'returns': ['YankInstance'], + 'allow-oob': true } diff --git a/util/meson.build b/util/meson.build index c5159ad79d..dbda9d9123 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 Fri Oct 30 16:41:12 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1391154 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=in99GgBg; 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 4CN7Px61l3z9s0b for ; Sat, 31 Oct 2020 03:42:13 +1100 (AEDT) Received: from localhost ([::1]:60014 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kYXTf-0004VA-QA for incoming@patchwork.ozlabs.org; Fri, 30 Oct 2020 12:42:11 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:55796) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXSy-0004RN-NK; Fri, 30 Oct 2020 12:41:32 -0400 Received: from mout.web.de ([217.72.192.78]:47603) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXSs-0002zE-S2; Fri, 30 Oct 2020 12:41:26 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1604076074; bh=ZlyN7gxVBbpgtpNBTBBtmZNalK4lXGvQblkMYsSD9lw=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=in99GgBg2FEVrMzQgNEAiGgG1HraMwfbwmHaIRahwLWS0hk9fULzF0jgON0H1XVar bl41X49EAfHeW8Dss4K38/I2VvNz+RZHLjsmeVmoNJ0Wf3GpZJKS4xU+qYPTyFDMQA NvOg0oruqDEStG/7VCWt6yDb1iRsYBAM2Kb+SCPE= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.100]) by smtp.web.de (mrweb103 [213.165.67.124]) with ESMTPSA (Nemesis) id 0LsyRS-1kOCR93NF4-012Yhi; Fri, 30 Oct 2020 17:41:13 +0100 Date: Fri, 30 Oct 2020 17:41:12 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v10 2/8] block/nbd.c: Add yank feature Message-ID: <20201030174112.78a52061@luklap> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:PFYwBbeDLc1kac4Z+LD75XXFdsyLEU7EgfU2E8EPQr8a1RSaASX 1TkDTc4plMjJjynHijXJOran+EU9aSvA2gWr7p6BhOpmyFUk9wS/UvPGVvCNYEWdpEl7zxn 3FRsysQeOH2z5mdZd+ErMxsHUbVmJfEL/NwTShpawjw49rujrN4Z3iBBnpKClx1xVFRMfoR eAsXgq8rKClXZeIWCxY/Q== X-UI-Out-Filterresults: notjunk:1;V03:K0:YKuO6yo8YME=:LOUK36aQ8JOBIWSN1Nr0iE YAY6mmq5S2xP0uhYk5tiLlBa1pPC4A9WnCznlPzrWv2DTyvYOC3x7Avx2nTkWwjaaJNaj9NWt UmtN1j7m3sPZKLqfmezh0cuQD5b3iXufNYs5kY84vH29epQMD54iX0DH9KT0sMltIp1mo5gU9 1Gnw0UK4pRomuhowjvbIR82g7VK9WBN7OwvzEX19ThAB4itwliWPRk310AeA0zaJKTm2S/P/i aaE5r4LkYOPhYnIfqGs+5BGA30Vr2bglwG2GOYqhHaW/fzzEXdJB/SP4ryhXl/0M64qZcHFLW VNYGeGqBz42j6rcQqWZSev2lVMCOBDIXisLb23pX/4WOm8/MNrH3oOkpSwwbtBwF2tlB4VF65 34ids1GU+etWhG3LF1ex3MDkCFUOX2E2pIpgLz8ZEh4Fb0dUHvxmjAbP5gl0LAUXZU9/Wfk80 rtyZahmzhlI40wo/rxyndAHPv0U8YJk71M2+mTOttgnYJf3bZ1nM53INFnzO26mgde9OYJZYM rSKc6MLwn2iYGQqap1heEBbfc+x5ho+0qsWRPvoriCkpmunhwvklPc7Xj7cCH7S3O6GAoarH/ gzZjXluycexdFHDpuz6NlG7PI2qgKbAyNKleK1dT4mCYiFkHEoTZ3+1yCdho20ohEl2CvS5yr CSrztjjBfxwk/RwJpw6rPzdSC6tndFETLpRJAWXPa5nxlt3QhJelAUzJng2rD/gniXZpCrx4W yb4O7R6eDX7XGZeEJtXX1Jz2aGmZbiQ9oaXo3hWjzhgqS9YxW89HoLVIAQm8+1/Pw76uFjWyw CaWkjnKMKqPqB90abKmVWn9zd66On9JYVldBr7hBYxsKn2xFI7rP3OwExKF666fjq6s6YhVlA auSed0KKDWuJLswtI0vg== 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/10/30 12:41:09 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" 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 --- 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 4548046cd7..d66c84ee40 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 @@ -140,14 +143,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) { @@ -165,12 +167,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; @@ -203,7 +205,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 */ @@ -215,7 +217,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; } @@ -260,7 +262,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); } @@ -286,7 +288,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); } @@ -337,13 +339,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) @@ -423,12 +426,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); @@ -445,10 +448,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; @@ -480,8 +485,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: @@ -490,7 +500,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; @@ -507,7 +517,7 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp) qemu_mutex_unlock(&thr->mutex); - return res; + return ret; } /* @@ -560,7 +570,6 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) { int ret; Error *local_err = NULL; - QIOChannelSocket *sioc; if (!nbd_client_connecting(s)) { return; @@ -593,21 +602,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; @@ -639,7 +649,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); } @@ -682,7 +692,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 @@ -697,7 +707,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; } @@ -752,6 +762,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)); @@ -776,7 +788,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; } @@ -803,7 +815,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; @@ -1118,7 +1131,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; } @@ -1277,7 +1290,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; @@ -1302,7 +1315,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; } @@ -1734,6 +1748,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; @@ -1746,52 +1769,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; } @@ -1819,7 +1843,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)); } @@ -1835,9 +1859,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; @@ -2229,7 +2255,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) { @@ -2240,17 +2265,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; } @@ -2310,6 +2341,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 Fri Oct 30 16:41:16 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1391157 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=MMvyqfaW; 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 4CN7SS60dRz9s0b for ; Sat, 31 Oct 2020 03:44:24 +1100 (AEDT) Received: from localhost ([::1]:39922 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kYXVm-0007uT-NY for incoming@patchwork.ozlabs.org; Fri, 30 Oct 2020 12:44:22 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:55798) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXSz-0004RR-QH; Fri, 30 Oct 2020 12:41:32 -0400 Received: from mout.web.de ([212.227.15.4]:43665) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXSv-0002zN-5j; Fri, 30 Oct 2020 12:41:28 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1604076077; bh=XGA0O70u6TLS3an16/oRND8bYIhBPrkrTegb9iYzn/I=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=MMvyqfaWJ1sxxM4mrmlNOG5bY0M3ozqQC4q3LDWS5VrboHsjoIKQ0aEywgi1/82Nr oyvNbMrQMO/gyGPYYeITpRuDcXTXMKQcDEL1+34VstixBubcFibEp+CzFmj/w7mEzO QnHGQUu6J357MNOoGuFGH+f0n4nOY+NY2Hy1FT8Q= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.100]) by smtp.web.de (mrweb001 [213.165.67.108]) with ESMTPSA (Nemesis) id 0MRTvU-1kwiAv1hRw-00SccY; Fri, 30 Oct 2020 17:41:17 +0100 Date: Fri, 30 Oct 2020 17:41:16 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v10 3/8] chardev/char-socket.c: Add yank feature Message-ID: <20201030174116.4a23adc2@luklap> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:WUiHWDMS+dgyktVXrDUnsHIFIVG9yBvM9T+O7EZmY55hwJ2m9wZ Y0wxb7t51i/wqpeRNwLs/wYwpIhcy3YLJ7NJWtVPQ4t8z3giDt212sz91c9zNEkc5D1LKZj YVTGtLgCTKXAC7EWBa8y7omRQ6tUagGpmvoUPU2E5Iwj96yGUA41QBEG+weLvxmu/B/2tdd 0cc4FItvQrzlQPzJZq4OA== X-UI-Out-Filterresults: notjunk:1;V03:K0:8Q9UIPY1Vvg=:beJqlo/glAoLvVi8w5VKmC CFfTQdHZPa8WUoPmVpaCrHU+dFxvvEbua6ltBeOo0d9NpRPRTU6yg/ib7OS7MX3vLCKh7kJY/ +slhpBZBFjXf7pjZX112u/5m6XgWIrm7IL1XJFNHiASDyVIMyFg3XuV99JA4PJ9ckBGpc+N7R cZsPm9EYaAlrRAnFHisosouwDk9bf68g7pHXvuAun072ewam0pjxNl9n3fRwkK7gqb5AO5dpN PHLwFy3sRkJTt0TCEM8yAxYi3Sh78kzqrLylugIEBxls+59yESPWaHYyGgB3hkoXtAJh7WkL4 xy8EVx0BU3DGOCjiZ9F5IVAXsIYQ7zlasadk2ZtvOtI54BUkUU+gVdo3PlBeNOxhnmmUCAA6B vTVf6FNq5KmC36Enrqu0braumZ315JVmd71yCDv+T3RN6oQkpo5lh2wZjfmvvHssLSJATFzRl Sttmv/SdbVdG4fhL9CaHBk3UUozs9PHTmKc/AnGzdUkdgha2+iqOlW+gD27BzkJ0bMrDJfpKR qb6KAF9nnIzL957vAYVbe+gaPkKenUL1k7YKRT2YG2BEbEDNP/+RSChmilDVkR/eW1gnjlkbY B6vCKWTAseS62dqFoeBjWdcPiAPsua39In1WqH0u942bh4rDG8/EYTdzWdk8sEsoNeojHPedP rXZ730yXK6juSIskkZEjCYTvtFjV7oA9aZJ6rpk5ivPJB7s8WcpKYjjd+rrV+ipU8NbpvO5WA KdtYJbCERopU7BxG8kVJjM/lScIpgvOAy4RzE+Ld6Q0gOSTknG9Ls07F1oxEYqo9FAjZTw+Rv oxLuufMdkGr6H42KbaDKt87JtFUG/L+FNP/Qm7gjQn2zocduq5g01R+ezF2ZvaVQ5Lpt856cj KIKxplFCUJvikc2ISrYQ== 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/10/30 12:41:21 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 95e45812d5..5947cbe8bb 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)); @@ -918,6 +926,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; @@ -932,6 +943,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); } @@ -947,6 +961,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; @@ -962,6 +979,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)); } @@ -1072,6 +1092,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); } @@ -1087,6 +1110,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; } @@ -1120,6 +1146,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 @@ -1362,6 +1391,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 Fri Oct 30 16:41:21 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1391158 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=IaLSFMR1; 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 4CN7Sv4M9Kz9s0b for ; Sat, 31 Oct 2020 03:44:47 +1100 (AEDT) Received: from localhost ([::1]:40806 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kYXW9-0008GL-LE for incoming@patchwork.ozlabs.org; Fri, 30 Oct 2020 12:44:45 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:55826) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXT4-0004Tg-J6; Fri, 30 Oct 2020 12:41:35 -0400 Received: from mout.web.de ([217.72.192.78]:53387) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXSz-0002zq-RW; Fri, 30 Oct 2020 12:41:34 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1604076082; bh=XXnUryT8gdPGNoVe2QLH8UCrQg46bXT2bnTQntl8b2Q=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=IaLSFMR1tJk+a2jazFth8TQNkP8aPllWHHAg3VqODXB/g/1X0HljEOilNwVS6WPWh g2elSIWw1VEW4BnNOQZ2Mog7Y9FGGnzk5CyEQ3/0UvqsjqHp3Ov6+MYVxv/iY6rFAq VIOs92mjO0VlxsRTQn519wtOXgdAc+f5mNFjXyRY= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.100]) by smtp.web.de (mrweb105 [213.165.67.124]) with ESMTPSA (Nemesis) id 1MDv9a-1kgHDy1Iiy-009vOZ; Fri, 30 Oct 2020 17:41:22 +0100 Date: Fri, 30 Oct 2020 17:41:21 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v10 4/8] migration: Add yank feature Message-ID: <20201030174121.6b7816a3@luklap> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:gZqh8ooBa1Wucd9F5pX+N8o7EKylSDekYcSjEGH2zGg/nbyxzvm MucgYDms1zz6fDlK9C2Y6MwboP7IskjrOnXLvN74fyK+XW8fhUfawc3DsbWW/SkGM+cerOr +rEfoSdkXXOPFNP9f4xu0Z+nRNBELeIOUwRE8hwT75/heKfyDIwUxmalMXl7FmfGPT9aVAb iHUdAl6nwe+KW8vxDZZYg== X-UI-Out-Filterresults: notjunk:1;V03:K0:IKy15FUJsLM=:90FFpr3LpWgw+TsfahkqdM ykU3OpZkBtcp0OYfKJ/sstacsCo77E4m/R700jyQpGQRfJIA3KdU/UYRGmMG5X+3HtXCjh8fA rydbCwoO8HHbAbD7iMFhu5T/VyCytdmnjtkW7SY6C54Dg5Eakt2K1q/pvGo4x/HDnAwYYTBrC owgR3gHmi3OoqhtsQhjstSbdAKJOMXUQed+dgiopsg+tJckKRfVAR0PlvsnFIevrke+lesVjA RwAmXhPcfGx8jvJBODK/lFp737dStFSLow85uX//KYRZnSOwXqG32oF/fFTC29sq2p2zhk/PF pvhnPBHNs4ZdC4AbPQ/PQfz1T/M/dGZh7iip5xvi+UwXddl7BtbLoLO7ebwg+eR4/ZUek3Ojb eBCUL9oEpyVePaJ9rH1zTn6I2fGyhAiQdyzSUYwH1tU8v5J69cbefmsfyduE37cO0/Xh8hlzz 1ZtyHdmIIb7t/gALCAgO8l0SZmyMW5u7G//hxxBzD1Qk0ReaxZ1/Wjk+eN1WAYQ8PTQzHg0L2 sTCZWA/dug1lAQfPy21RB9JWCwDaia9rI9Op+NSVmh3/5Duiwv0+3El345A9TXgnjYHiRxHPh Ak4as4jKR00S5cEQ+nMMg/YJlJYkA08FX5FT/D4WvYLNZc5kvFpQw/yAYvlLM1G9QUVuPRVQg 4f9vPWAQ2fJ1kCSdezEquqjH4ww4ke3wiWkyfK0bmRdQ3U+JqkYIUHZ+YbAfzkidLRtux7Swb 7hw9CN6f+9PXvpb7kEML15eGtVxoeZUP7CX7tz4ypOwgBEra9hTAxR7lPfska6E+YSsWXwqCM ZnVx+d9FbaRCD30sQIMLHH62OCWy3AV+LJb7ERsExtlopI5vUO9SF5A8GVWzc7F6KROpN9W7u FSrmzCGEawjaeLVTpgrw== 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/10/30 12:41:09 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" 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 9bb4fee5ac..0b0442df37 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" #define MAX_THROTTLE (128 << 20) /* Migration transfer speed throttling */ @@ -248,6 +249,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) @@ -425,8 +428,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) || @@ -441,6 +450,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); } } @@ -1733,6 +1743,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) @@ -2007,6 +2018,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); } @@ -2144,6 +2156,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)) { @@ -2157,6 +2176,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, @@ -2166,6 +2188,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 68b171fb61..620b55f5d9 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 @@ -962,6 +965,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 21ccba9fb3..c7648a9388 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; @@ -2997,6 +2998,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 Fri Oct 30 16:41:24 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1391156 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=itVtAkjT; 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 4CN7Rz6WBGz9s0b for ; Sat, 31 Oct 2020 03:43:59 +1100 (AEDT) Received: from localhost ([::1]:38022 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kYXVN-00076T-PA for incoming@patchwork.ozlabs.org; Fri, 30 Oct 2020 12:43:57 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:55886) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXT9-0004ZR-7T; Fri, 30 Oct 2020 12:41:39 -0400 Received: from mout.web.de ([212.227.15.4]:47101) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXT4-00030J-KZ; Fri, 30 Oct 2020 12:41:38 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1604076086; bh=WbYUVUmQ4bxoNlZ39tsJOBftsWsUATGdtkCVQCitbF0=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=itVtAkjTg5OTk7wmsjzTCqWyPx+iRN0fL6hhDD2LdLKlWflG+5Jq1sS001Yf3ReSB QcwIQg4hf0aEvqYZgFVnquVZnfjLSdIGag6JYvTlRI25ekwJkusogaUUsspXwkhYLV 1zreDZgOZs0Em91zpu7U128/f1JzmfZJ3sXPlMKw= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.100]) by smtp.web.de (mrweb005 [213.165.67.108]) with ESMTPSA (Nemesis) id 1MvKbd-1kHHlP1inx-00r5Sg; Fri, 30 Oct 2020 17:41:26 +0100 Date: Fri, 30 Oct 2020 17:41:24 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v10 5/8] io/channel-tls.c: make qio_channel_tls_shutdown thread-safe Message-ID: <20201030174124.38566940@luklap> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:1w3ebkSUG3wFeqbjCnutZogDcsFUtR9nrIKFeont3zStixaDAZR 8BdiRKyDGpE4a07zDyccXE37zcWI2qitAoYVCvB9wCrqjJFZqNZgo1xpEb87Tzv0KNt95WN NdIJ3zui5J0M1yHL2AZOtCzVa1TGgxwcPKqw9znpHxB8yQheXPVPk57ZdNg54k/9DGi5Kfv Fsd/iHAb6L5iJem5SjUzQ== X-UI-Out-Filterresults: notjunk:1;V03:K0:obYvn5c3dGE=:3hiXfvKvXDM3YQBxMgSmJu iaPddKlueTmzMkE3LRguteZL4mGmxzhJMm506ZEXayOEvKyxRb4iNUPkSeiNaLlXaSLgeGDIg oEkt2tckId/UW60t5YNt2lcNtS7eUAe1CjtYU7kO++d2tyE4y/5likLX8T85IpeI+iS/yIri5 61tngiHhaTLRSwUa9YVVVXQfs7LjgEnggRXXYcfdWKXX57/0F7y2LFeM5wb23gKo2I4QN4x86 HzpQpMUAUngzWEFPwTFted7/KKY5skW/fTPn8Voh27pX6nUrn6WFRaZqxbYKi3qM2ttoanyh8 WwvBS3IlV30E2CanHoAmcJIqWqa/gTMOOhZT278FmsrFyLNeLO9kuBgA1TZGbpx1Fq36M7G5i lPX7zLm7Lq4dCDuncn4ZZfFMi9tvWQsBeE/7M1DEPHZbpkQLRqSPwUUH+zKPLt0VMf2uKNZJ1 goYODcZE2ASwTWIAgKPeiEPn5oprZlExgMvYpscDu6sAjocr0oUr57LEzqXXbzihSwQSiO/QJ PMVV63/oxXDRWc7GA0LgGXe3eH79t0Ajggjey3LDfYf0YYltszrEK295PFpNsgRwvIC5XK4+N YcXydmQ80IIZqMISQDcXnJyvqwTQghsT+jfAWgejfLo71a2jXzUKLjj+t1H2Ek6v+olGwi4wO oIOAseKvaxR0SuhHLEKytRqfpUgVVc/j/iCLsIg8+1Paw2iY9kgmC4N6W894Nj44ocLQC6qQo 2ARCExboy4fJULMylhi/7rHm03S9N5plTLyANBMaU9TCyVRswIv6NpWf4OUojHjBZNMcke1xV /MbZpgVA7hc2DYysqU0f9Mf4Pm6YUMQC+P7DmyLm1A+PSilfSk0kroup6jJnKMMrzdAqg7ESI QyGGuh2gH2KMpQh+XQ1w== 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/10/30 12:41:21 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" 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 7ec8ceff2f..10d0bf59aa 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 Fri Oct 30 16:41:34 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1391161 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=XrCobd9q; 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 4CN7X76TQDz9s0b for ; Sat, 31 Oct 2020 03:47:35 +1100 (AEDT) Received: from localhost ([::1]:48224 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kYXYr-000351-8t for incoming@patchwork.ozlabs.org; Fri, 30 Oct 2020 12:47:33 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:55908) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXTF-0004qA-QK; Fri, 30 Oct 2020 12:41:45 -0400 Received: from mout.web.de ([212.227.17.11]:33509) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXTD-00031J-V0; Fri, 30 Oct 2020 12:41:45 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1604076096; bh=X7NTJwhv339GojGnpIWvTWY2vjpKyTMPXb5fxDVgfME=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=XrCobd9qYSkI5vMWkHWErBjadoIzk2DrPx1xpX8aSq+9GiC4sYcqQSYSf1rOdZbEa AWHmdE2hkljCap+W4Oed2eJnATcpSCt7R4EiNxfPCzsIVUPESk27Ca0RDUojoddu20 Bw9Th7gQjV0aVPnqdSTgQmjXOQ8ZR/VDtggKeOrg= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.100]) by smtp.web.de (mrweb105 [213.165.67.124]) with ESMTPSA (Nemesis) id 1MXGK4-1krmUY1bva-00Yiek; Fri, 30 Oct 2020 17:41:36 +0100 Date: Fri, 30 Oct 2020 17:41:34 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v10 6/8] io: Document qmp oob suitability of qio_channel_shutdown and io_shutdown Message-ID: <20201030174134.531eed50@luklap> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:/6QXYb2vV0dW0aZhPO9ZwUQTEa4PFsnCwGKwvflxPve9zGKf/VY 6i4gFx5JOGB0NPvy2q63KvRyCNJQA4w8gQhhKdBqORajrbP9F+cTdHv+FBpnGwciREMgNj/ cEBZnQ+GaRMxnaTvF00wWzRWJv3rp8g7SYEGJFsDpjGXX15btmoOuCd50ZttEMQNgnsisRP IFp3WMKX1bMxA6x3j/D9g== X-UI-Out-Filterresults: notjunk:1;V03:K0:F1jVa089wr8=:phEhAUtDD42ipz2kscGEsQ PEXWXvuvneozr2aoprv4W5bHF1y01xsLztGqd9/dHQVmYLtUAOUgl9PhtlsabnUZmQLk+GrqN WpWN/gdsXbunTY0tTaK6haAEVdTW2m11jEhIPlEhC40cgp44t08jEpX8yIPAc7+KrBFEWXved gFtiIMtBhUKWWm1OkrepAIIhqOdf27XtbxABQnvLF5jF7FPN03/SBjIcxWVbCFWgpopQ6eBhE liFCFz+30vbfWXJ6df+1bazUU/osCKhpHj6vPp09OJeMOy7a2blV5lwUG7mXpnD/OMLbi7FaZ gCw3ySHLeosYwwda2AmXrCWlYFPLitsi8YSp426mMmcQqF7MjcAr8i+h6yRKdng7KREZvYR+2 pwvc7gCPA4SG4AGAhRanAK7lsKDxrH++Xj0W5fqBX5ogvhWBza/Ov6RZ+IU8yfRDHDn+j7EZx 5Lpq8MV7zn9e0ZTrhPvtSlOw58a6u+JwEQkHsSk/ohZWJgW2Y/InBDjywL1lf69QirIb8hvZy q9vCzBstGyqh7KPzZpgyncX5lCov8y6mj/YMHk4kbn24DORtgKus/o4nR3hcPtBZrPH5LnyiN A0sZxk1tonga11aOQGsI5d3pSTXGjnM+5tvvYeiH/z8vMO+SW6dCy/X4OkleBHPGQdPDo1+sM vF4oE12mPHnvE3eMZTwITfJHkQK3JdgRl8nLLB5AmCe2eE4Vif1ijUKIpR76LXgBJPXiOxWfR vI4qD9UF5n8UUTecVXMeoKhmwtOoJtB7KzEorrEzz/xESa4xHCWvBmzRz7jn9WbW1j4DOzCnH viEXajpJ/nzLAukug1Tcyd6kWSX1y7OBYtwF1eGs/PO+IrWafNyK7Bm8j2Fq194wVovGL2g7T bt1XrYO4oh3acEycy2NA== 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/10/30 11:19:30 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" 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 3c04f0edda..e0b9fc615d 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 Fri Oct 30 16:41:38 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1391159 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=WKtspLhd; 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 4CN7W91Q6pz9s0b for ; Sat, 31 Oct 2020 03:46:41 +1100 (AEDT) Received: from localhost ([::1]:45376 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kYXXy-0001t0-HZ for incoming@patchwork.ozlabs.org; Fri, 30 Oct 2020 12:46:38 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:55920) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXTH-0004uL-Mf; Fri, 30 Oct 2020 12:41:47 -0400 Received: from mout.web.de ([212.227.15.4]:41417) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXTF-00031T-Sp; Fri, 30 Oct 2020 12:41:47 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1604076100; bh=E3cjhVZ0qInkcGgTms1XBFQVnv7r83tm0k3kWyQW0XM=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=WKtspLhdDDMVTbQJfaB2aB43P2WGTjVg+evJNd9x7j1MUmr3VEUB/QA4NQ7+jWqXn AUCh9z1RLqGsI3lxca9l6U3m6s4FfToEzTNV6sSoXSMFDxuGvs0gzMG/gKC7rFH2Wj DNAFb5ifrH9pE4hcQLZJFVXX6Q5LBZBLbARd2CvE= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.100]) by smtp.web.de (mrweb004 [213.165.67.108]) with ESMTPSA (Nemesis) id 0MVpJg-1ksKSK07xI-00X0Tp; Fri, 30 Oct 2020 17:41:40 +0100 Date: Fri, 30 Oct 2020 17:41:38 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v10 7/8] MAINTAINERS: Add myself as maintainer for yank feature Message-ID: <20201030174138.071af6a3@luklap> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:YimthprSUS4Dscwv4EEJCAt46J9hIgTJxKB2tAXFkIhwePT5ty7 NxyAU3GIIGDZI7QiH4wSWbi248a7nJlN9mChEXnFNVh3lc8w0H2KeCztILt/Z8Iu9jbYK7f gWBefNR7uJKR5FZOt12yLBdpCdK0+mKJAWQ5j1llPrn3Y3QNhrq14pVFXV9kjADFiS3l9sm u0zboYqlHlWefieq7cM/Q== X-UI-Out-Filterresults: notjunk:1;V03:K0:vx9iMk0uaUc=:PcJYdQCwAw9QV5NRZDcBhT s2e/LcD3UR/ItsY3r9xjWH+N6jtCMTrU5TCDk2ssnQvee7FBki4/12zA74aPosX99oD3zQLPl xxCoyoombem4eniXw1PDct3jDHHyotJjbcTi6s0UISIUO8onmkDX2TNzEUHkdp9T9VXGLEoQV EIXdPLA63069i+xpIyws+ZFht5ORngImNRMA+0hFmwZ+INHi1c0xT3EFZ6uL/G9dnXfWsBOjy nm84LDJNUl+krVYK3djypxyBS4cTJH1mIQhTN4PnyWLpdWRQzpTC3RbKlzvCT33B47eUNlKgw imYAxdVMPmVWE5Rr+NXN8ZgFg3e9Z73RyFV+twq3GJnMWACM+PrXTfDNzK+BtQ3hddnjS5h3J f2X2/b6u1yiyzql8oV/3a3IRg83GRgLAGPw5/2RofpgXXPUItnWp8xfxx8SEEhBstrvxx4eAm Mo7uv4FYHBvdD1gHtYQeEqFXUa15nz1C8Fv5SAlfZo2MgkaDue8NoFvyl36+eEWIwq6UB7ImS +Gacc2Lu6NmJWftb967SBFaWzUkxknOFXYrN/wcLRMdtrGQH4eTOcOqOHx88FqUEqlcxipCES lNQIM162O9rJgBrHFEmaY4VaVIB6J4RcsXY2wIPQiTlt5SZ4EMmslpaXnP0yMZg/lrQ6UDt4T hFIvSaE7laOdf9Df4TwLMk68zbWHs5lmbiEEPOp+NKxBS4UnWcXdx4HTePTrPwGTLOWK4lkEA WZUpj9ollovcFp6diNRYR/Z3iEc8I/jug1FVv716fR8emuKUsxJa+6P8PZoQxhdahGBab+IDD +/te2kJPJYve1UyHT7B3D7P/dVVVmJMQ9qTjlgGxxCnmQ5RgPl6fSGtKlQi20IJKXgJdpiwQX r8PgK+JnGpc795OYETRw== 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/10/30 12:41:21 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" I'll maintain this for now as the colo usecase is the first user of this functionality. Signed-off-by: Lukas Straub Acked-by: Stefan Hajnoczi Reviewed-by: Markus Armbruster --- MAINTAINERS | 7 +++++++ 1 file changed, 7 insertions(+) -- 2.20.1 diff --git a/MAINTAINERS b/MAINTAINERS index 8c744a9bdf..81288fd219 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -2676,6 +2676,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 From patchwork Fri Oct 30 16:41:43 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Lukas Straub X-Patchwork-Id: 1391160 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=Vset/olP; 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 4CN7X35rt8z9s0b for ; Sat, 31 Oct 2020 03:47:31 +1100 (AEDT) Received: from localhost ([::1]:47984 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kYXYn-0002z6-Qv for incoming@patchwork.ozlabs.org; Fri, 30 Oct 2020 12:47:29 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:55944) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXTM-00053q-17; Fri, 30 Oct 2020 12:41:52 -0400 Received: from mout.web.de ([212.227.17.11]:40829) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kYXTK-00031o-00; Fri, 30 Oct 2020 12:41:51 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=web.de; s=dbaedf251592; t=1604076104; bh=+FKqBqao7ItTK71ZCGq6sHXUeOqTRGtg3DJ0zS0YP10=; h=X-UI-Sender-Class:Date:From:To:Cc:Subject:In-Reply-To:References; b=Vset/olPEF0ONfW62YdhkiNhkvz2e822mHNlyr+AsRfReKScyxvJRCjDP2K+yHo1W t/hK7UR4x7gGj3XmDbtYB+3WHiPiUTXVOAS0JbAeRBUNyL6akKkYD0M8VqEe9PGgxn sTPvn56lRRKYa2G0PwfHWg7s7PctykEq4wfxJUtU= X-UI-Sender-Class: c548c8c5-30a9-4db5-a2e7-cb6cb037b8f9 Received: from luklap ([87.123.206.100]) by smtp.web.de (mrweb101 [213.165.67.124]) with ESMTPSA (Nemesis) id 0M1X0v-1kF5sH1qjR-00tQcT; Fri, 30 Oct 2020 17:41:44 +0100 Date: Fri, 30 Oct 2020 17:41:43 +0100 From: Lukas Straub To: qemu-devel Subject: [PATCH v10 8/8] tests/test-char.c: Wait for the chardev to connect in char_socket_client_dupid_test Message-ID: <20201030174143.0269a488@luklap> In-Reply-To: References: MIME-Version: 1.0 X-Provags-ID: V03:K1:sOrMWSQPC62ykrJxQ16jjdCfqRo5qIBQdcam8vzgVCIg6rhdCZP fZJtgDAg7DO01VJ5WMbRGzdZ89/vKE+X5T9Kg/kr7X0HLWXFODZebh6vAMyYqwzz6f/5tBV l3BK2r9vOrZdM7RgN2FzcRLUcnQiM6PcuIs70paY6ePA1l3/np99QVWpaxshzD1nLq6k2zM pn2tcvgNh1UOJOQFP8Gnw== X-UI-Out-Filterresults: notjunk:1;V03:K0:H+NixxWgGqA=:NJWtyplGuMoxEnyPXYlyfP 5Tyciu7S+UW94z+V3OYnNv+GMmiFHNa0ZUTXfgMB/nfS9y9VlxP0wNnbBwBiE4IBfq+sqx2ga Aj+577QWhPo2vrfcn71bJJvhnRtfS1/RazIvZdmrON0g1wBfdozcXjZkecTpzs8/vp5ITmgrC CSbeCsQVJDsRJni03Xfw6M8F+DCUSXIDIRZu1bV9Ss16wWjPbdNifr2UCpg4uK+rFWHxPo83u qNJgFekWtS7yeg01Bd+sD6Slxylfi5Pp6ZeBFY+KHdEb475ou1u0AJWoftxhOO87WQ/pmhRT8 4zT7ZTGBN+O3A/ccCELxij9rmWVHh2TMfFqHOJhyeamKSRb8bii4P6dvOixmuHOB8Cwf65+9x 72oZB4W+bSPs+3721ndeGiUcc5G+ADPP9/hQZmQ5ywosnQHD8lH9YBZMPi2pnSG1WgzKZ44n8 mr/LNkcs8pdQaJBpOEGGhrBav+izvZYBtYhpw/jeKwGJ6D7AEdXeZFg6eH8c1PSbJvG6nEySz Jt9hKB3b404W3gjKu5NNhhSps7FFtBJBNxnOvdmChGq43SqwXK+80r3fPuNvX+33l1rgGYhZ2 D2+Qv2GbR+gmUIPk9KgXygmVymYsYN+0buVEGMGxKsoPRsCU3SbNzP4W8TTq9I/tC0BOYQG2p KR1ykVVw7noIzYdtq9+SqWzIvG5YcCE4Pe4x119TMglhfo1WrMZ+Nay+NTpYo3eXFDl3+dmIy QGQXV9532th9Nmx3euEk1YyDylqQTRylZAZSXJEAqlC1iwdp6k9JBjJKuvRHV+Go0dQwo5v3B ruV96QsiAJQSJ0WsdmVMdQl9diPqdm63EkRxVmOGrP4J4IHBc5HLZR0FgLbYz7ZGpflt7toyj xSxB3zQqbEgQD/BDO6pQ== 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/10/30 11:19:30 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);