From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 010A8C7EE3A for ; Fri, 3 Mar 2023 07:15:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:Content-Type: List-Subscribe:List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Cc: To:Subject:Message-ID:Date:From:In-Reply-To:References:MIME-Version:Reply-To: Content-Transfer-Encoding:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=Vmo2EjID+m/CdXk1LVKi20GABoEmHk6YyScOmdG7bWM=; b=M7t83//mIGE4eUtRlt02Uaxmxp 84YIR67Bkum/NTqYlW688T8Qvm2IUU+766VMYwATNEhSQJ7sySMl5GzHrSshTJsffYi3ydO4DBPMm 3dcQnzltH4631ITEc2Ze5kUQhj6ErOldGDNRadh1TwIdSwrosra+OvYZg2+zxCw6T5a+v5ED6qAKF 9lG09QH1/DNLVGj+ThaNlLGSg4X7/+6ZuGtTABiQ9Tqy7jAHK9zxAFtA4mKd4j4jViT65Vh4/QtWT 4S1jPj14WjaGoj5i7PtCQPV81xEqEuLixlX/segZOmMSaMswD6dslnVYfulOKu4DkxwHDrhmPb2Kn wfSaxcTw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1pXzdw-005Cyl-BB; Fri, 03 Mar 2023 07:15:52 +0000 Received: from mail-ua1-x934.google.com ([2607:f8b0:4864:20::934]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1pXzds-005Cxd-96 for linux-um@lists.infradead.org; Fri, 03 Mar 2023 07:15:50 +0000 Received: by mail-ua1-x934.google.com with SMTP id x1so1010344uav.9 for ; Thu, 02 Mar 2023 23:15:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; t=1677827747; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=Sl0EPE+OLn//dbjf8d3XdQGxSVGfhQgXso+pNbwk7MQ=; b=tJ9/+3Rl4iX0ZCQ5dwbZutcZOUpR7QEUM6xIrX/Khgf+ExVUvz7GsKuJVSOEOlErGe bjQgGmYT5iebPpR5ccuRXgnsQ6v8pg+hfZigjO2nZwPcb8iXsFtx6UpL+1O7uRMxtBr5 q1EUSMojKL0Deh9Uy48HsL9ihs4Q+IXeH7W1+3hBZuByNmGqHxtLUmFH7VvdoirGmQTf ySC8btKgiy1hv3m6B+XietKJ1CUlQwkkzvUFx/2dnrDbZCRsoePVxUDuQtamW4Hd7k4W kao7+LNMf9SV5oo5oEYe79iK387tyd15lkJao4VamkbKjqZNaq7HZ/pk5quq3CefgyNL ITLQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1677827747; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=Sl0EPE+OLn//dbjf8d3XdQGxSVGfhQgXso+pNbwk7MQ=; b=NEnZnuASaaAftGDSfCqUHiiD7lOZlYLfmjYtKKMHpnGZPqYY0Gs8+B6akR2GXRGlqN UKsSUZVKYC9Cioq7uvX8pwOSLmEfzryhZM1LI/IYxU3l/8b5xEwtINq4zpW758eV/sR/ VmHP4KUboZbJlPtgJIBJ2DOvRfbTdEQWZnLQ++5leY0GJKWv40IW5xXKZCVrBU4X0JKA wZgnnUq/FcSsQCzK9B3wwLtaBT5f2fc2Y9AuwKTc8FTQghbWzddh7zk/FCLL0IdVtuhf /Ghfsf8aOQcCIsx2dbuTfiRU2xx9+BUP5IPMIxGy36HDqp35pS0mzy4ZQ1tmp3hUYYKP 9vhA== X-Gm-Message-State: AO0yUKUYvb4P3eOcXiuEXa/OMdSIIyfvVjNmSPji9C6KbxI8hfysHFaI 9ZSfmPcbJHozwyYH4pF3oe5u4dhu0KTVjj58wcyLOQ== X-Google-Smtp-Source: AK7set/bN9C6HBcxnjApEpQsg3NaD3xIN+2ANP4rH5d9w2F1VZi+ht+kHalYAc57BAdtUaXkq/R/04pPHLyCSsnNFZM= X-Received: by 2002:a1f:3f8f:0:b0:3ea:b7e1:fb29 with SMTP id m137-20020a1f3f8f000000b003eab7e1fb29mr394575vka.0.1677827746715; Thu, 02 Mar 2023 23:15:46 -0800 (PST) MIME-Version: 1.0 References: <20230302013822.1808711-1-sboyd@kernel.org> <20230302013822.1808711-5-sboyd@kernel.org> In-Reply-To: <20230302013822.1808711-5-sboyd@kernel.org> From: David Gow Date: Fri, 3 Mar 2023 15:15:35 +0800 Message-ID: Subject: Re: [PATCH 4/8] clk: Add test managed clk provider/consumer APIs To: Stephen Boyd Cc: Michael Turquette , linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org, patches@lists.linux.dev, Brendan Higgins , Greg Kroah-Hartman , "Rafael J . Wysocki" , Richard Weinberger , Anton Ivanov , Johannes Berg , Vincent Whitchurch , Rob Herring , Frank Rowand , Christian Marangi , Krzysztof Kozlowski , devicetree@vger.kernel.org, linux-um@lists.infradead.org, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230302_231548_373203_2D5F0C3C X-CRM114-Status: GOOD ( 37.09 ) X-BeenThere: linux-um@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: multipart/mixed; boundary="===============1271986055795827145==" Sender: "linux-um" Errors-To: linux-um-bounces+linux-um=archiver.kernel.org@lists.infradead.org --===============1271986055795827145== Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg=sha-256; boundary="000000000000dcb39f05f5f9b64b" --000000000000dcb39f05f5f9b64b Content-Type: text/plain; charset="UTF-8" On Thu, 2 Mar 2023 at 09:38, Stephen Boyd wrote: > > Unit tests are more ergonomic and simpler to understand if they don't > have to hoist a bunch of code into the test harness init and exit > functions. Add some test managed wrappers for the clk APIs so that clk > unit tests can write more code in the actual test and less code in the > harness. > > Only add APIs that are used for now. More wrappers can be added in the > future as necessary. > > Cc: Brendan Higgins > Cc: David Gow > Signed-off-by: Stephen Boyd > --- Looks good, modulo bikeshedding below. > drivers/clk/Makefile | 5 + > drivers/clk/clk-kunit.c | 204 ++++++++++++++++++++++++++++++++++++++++ > drivers/clk/clk-kunit.h | 28 ++++++ > 3 files changed, 237 insertions(+) > create mode 100644 drivers/clk/clk-kunit.c > create mode 100644 drivers/clk/clk-kunit.h > > diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile > index e3ca0d058a25..7efce649b0d3 100644 > --- a/drivers/clk/Makefile > +++ b/drivers/clk/Makefile > @@ -17,6 +17,11 @@ ifeq ($(CONFIG_OF), y) > obj-$(CONFIG_COMMON_CLK) += clk-conf.o > endif > > +# KUnit specific helpers > +ifeq ($(CONFIG_COMMON_CLK), y) > +obj-$(CONFIG_KUNIT) += clk-kunit.o Do we want to compile these in whenever KUnit is enabled, or only when we're building clk tests specifically? I suspect this would be served better by being under a CLK_KUNIT config option, which all of the tests then depend on. (Whether that's the existing CONFIG_CLK_KUNIT_TEST, and all of the clk tests live under the same config option, or a separate parent option would be up to you). Equally, this could be a bit interesting if CONFIG_KUNIT=m. Given CONFIG_COMMON_CLK=y, this would end up as a clk-kunit module, no? > +endif > + > # hardware specific clock types > # please keep this section sorted lexicographically by file path name > obj-$(CONFIG_COMMON_CLK_APPLE_NCO) += clk-apple-nco.o > diff --git a/drivers/clk/clk-kunit.c b/drivers/clk/clk-kunit.c > new file mode 100644 > index 000000000000..78d85b3a7a4a > --- /dev/null > +++ b/drivers/clk/clk-kunit.c > @@ -0,0 +1,204 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * KUnit helpers for clk tests > + */ > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +#include "clk-kunit.h" > + > +static void kunit_clk_disable_unprepare(struct kunit_resource *res) We need to decide on the naming scheme of these, and in particular if they should be kunit_clk or clk_kunit (or something else). I'd lean to clk_kunit, if only to match DRM's KUnit helpers being drm_kunit_helper better, and so that these are more tightly bound to the subsystem being tested. (i.e., so I don't have to scroll through every subsystem's helpers when autocompleting kunit_). > +{ > + struct clk *clk = res->data; > + > + clk_disable_unprepare(clk); > +} > + > +/** > + * kunit_clk_prepare_enable() - Test managed clk_prepare_enable() > + * @test: The test context > + * @clk: clk to prepare and enable > + * > + * Returns: 0 on success, or negative errno on failure. > + */ > +int kunit_clk_prepare_enable(struct kunit *test, struct clk *clk) > +{ > + if (!kunit_alloc_resource(test, NULL, kunit_clk_disable_unprepare, > + GFP_KERNEL, clk)) > + return -EINVAL; > + > + return clk_prepare_enable(clk); > +} > +EXPORT_SYMBOL_GPL(kunit_clk_prepare_enable); > + > +static void kunit_clk_put(struct kunit_resource *res) > +{ > + struct clk *clk = res->data; > + > + clk_put(clk); > +} > + > +/** > + * kunit_clk_get() - Test managed clk_get() > + * @test: The test context > + * @dev: device for clock "consumer" > + * @id: clock consumer ID > + * > + * Returns: new clk consumer or ERR_PTR on failure > + */ > +struct clk * > +kunit_clk_get(struct kunit *test, struct device *dev, const char *con_id) > +{ > + struct clk *clk; > + > + clk = clk_get(dev, con_id); > + if (IS_ERR(clk)) > + return clk; > + > + if (!kunit_alloc_resource(test, NULL, kunit_clk_put, GFP_KERNEL, clk)) { > + clk_put(clk); > + return ERR_PTR(-EINVAL); > + } > + > + return clk; > +} > +EXPORT_SYMBOL_GPL(kunit_clk_get); > + > +/** > + * kunit_of_clk_get() - Test managed of_clk_get() > + * @test: The test context > + * @np: device_node for clock "consumer" > + * @index: index in 'clocks' property of @np > + * > + * Returns: new clk consumer or ERR_PTR on failure > + */ > +struct clk * > +kunit_of_clk_get(struct kunit *test, struct device_node *np, int index) > +{ > + struct clk *clk; > + > + clk = of_clk_get(np, index); > + if (IS_ERR(clk)) > + return clk; > + > + if (!kunit_alloc_resource(test, NULL, kunit_clk_put, GFP_KERNEL, clk)) { > + clk_put(clk); > + return ERR_PTR(-EINVAL); > + } > + > + return clk; > +} > +EXPORT_SYMBOL_GPL(kunit_of_clk_get); > + > +/** > + * kunit_clk_hw_get_clk() - Test managed clk_hw_get_clk() > + * @test: The test context > + * @hw: clk_hw associated with the clk being consumed > + * @con_id: connection ID string on device > + * > + * Returns: new clk consumer or ERR_PTR on failure > + */ > +struct clk * > +kunit_clk_hw_get_clk(struct kunit *test, struct clk_hw *hw, const char *con_id) > +{ > + struct clk *clk; > + > + clk = clk_hw_get_clk(hw, con_id); > + if (IS_ERR(clk)) > + return clk; > + > + if (!kunit_alloc_resource(test, NULL, kunit_clk_put, GFP_KERNEL, clk)) { > + clk_put(clk); > + return ERR_PTR(-EINVAL); > + } > + > + return clk; > +} > +EXPORT_SYMBOL_GPL(kunit_clk_hw_get_clk); > + > +/** > + * kunit_clk_hw_get_clk_prepared_enabled() - Test managed clk_hw_get_clk() + clk_prepare_enable() > + * @test: The test context > + * @hw: clk_hw associated with the clk being consumed > + * @con_id: connection ID string on device > + * > + * Returns: new clk consumer that is prepared and enabled or ERR_PTR on failure > + */ > +struct clk * > +kunit_clk_hw_get_clk_prepared_enabled(struct kunit *test, struct clk_hw *hw, > + const char *con_id) > +{ > + int ret; > + struct clk *clk; > + > + clk = kunit_clk_hw_get_clk(test, hw, con_id); > + if (IS_ERR(clk)) > + return clk; > + > + ret = kunit_clk_prepare_enable(test, clk); > + if (ret) > + return ERR_PTR(ret); > + > + return clk; > +} > +EXPORT_SYMBOL_GPL(kunit_clk_hw_get_clk_prepared_enabled); > + > +static void kunit_clk_hw_unregister(struct kunit_resource *res) > +{ > + struct clk_hw *hw = res->data; > + > + clk_hw_unregister(hw); > +} > + > +/** > + * kunit_clk_hw_register() - Test managed clk_hw_register() > + * @test: The test context > + * @dev: device that is registering this clock > + * @hw: link to hardware-specific clock data > + * > + * Returns: 0 on success or a negative errno value on failure > + */ > +int kunit_clk_hw_register(struct kunit *test, struct device *dev, struct clk_hw *hw) > +{ > + int ret; > + > + ret = clk_hw_register(dev, hw); > + if (ret) > + return ret; > + > + if (!kunit_alloc_resource(test, NULL, kunit_clk_hw_unregister, GFP_KERNEL, hw)) { > + clk_hw_unregister(hw); > + return -EINVAL; > + } > + > + return 0; > +} > + > +/** > + * kunit_of_clk_hw_register() - Test managed of_clk_hw_register() > + * @test: The test context > + * @node: device_node of device that is registering this clock > + * @hw: link to hardware-specific clock data > + * > + * Returns: 0 on success or a negative errno value on failure > + */ > +int kunit_of_clk_hw_register(struct kunit *test, struct device_node *node, struct clk_hw *hw) > +{ > + int ret; > + > + ret = of_clk_hw_register(node, hw); > + if (ret) > + return ret; > + > + if (!kunit_alloc_resource(test, NULL, kunit_clk_hw_unregister, GFP_KERNEL, hw)) { > + clk_hw_unregister(hw); > + return -EINVAL; > + } > + > + return 0; > +} > diff --git a/drivers/clk/clk-kunit.h b/drivers/clk/clk-kunit.h > new file mode 100644 > index 000000000000..153597d69269 > --- /dev/null > +++ b/drivers/clk/clk-kunit.h > @@ -0,0 +1,28 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +#ifndef _CLK_KUNIT_H > +#define _CLK_KUNIT_H > + > +struct clk; > +struct clk_hw; > +struct device; > +struct device_node; > +struct kunit; > + > +struct clk * > +kunit_clk_get(struct kunit *test, struct device *dev, const char *con_id); > +struct clk * > +kunit_of_clk_get(struct kunit *test, struct device_node *np, int index); > + > +struct clk * > +kunit_clk_hw_get_clk(struct kunit *test, struct clk_hw *hw, const char *con_id); > +struct clk * > +kunit_clk_hw_get_clk_prepared_enabled(struct kunit *test, struct clk_hw *hw, > + const char *con_id); > + > +int kunit_clk_prepare_enable(struct kunit *test, struct clk *clk); > + > +int kunit_clk_hw_register(struct kunit *test, struct device *dev, struct clk_hw *hw); > +int kunit_of_clk_hw_register(struct kunit *test, struct device_node *node, > + struct clk_hw *hw); > + > +#endif > -- > https://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git/ > https://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git > --000000000000dcb39f05f5f9b64b Content-Type: application/pkcs7-signature; name="smime.p7s" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="smime.p7s" Content-Description: S/MIME Cryptographic Signature MIIPnwYJKoZIhvcNAQcCoIIPkDCCD4wCAQExDzANBglghkgBZQMEAgEFADALBgkqhkiG9w0BBwGg ggz5MIIEtjCCA56gAwIBAgIQeAMYYHb81ngUVR0WyMTzqzANBgkqhkiG9w0BAQsFADBMMSAwHgYD VQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UE AxMKR2xvYmFsU2lnbjAeFw0yMDA3MjgwMDAwMDBaFw0yOTAzMTgwMDAwMDBaMFQxCzAJBgNVBAYT AkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSowKAYDVQQDEyFHbG9iYWxTaWduIEF0bGFz IFIzIFNNSU1FIENBIDIwMjAwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvLe9xPU9W dpiHLAvX7kFnaFZPuJLey7LYaMO8P/xSngB9IN73mVc7YiLov12Fekdtn5kL8PjmDBEvTYmWsuQS 6VBo3vdlqqXZ0M9eMkjcKqijrmDRleudEoPDzTumwQ18VB/3I+vbN039HIaRQ5x+NHGiPHVfk6Rx c6KAbYceyeqqfuJEcq23vhTdium/Bf5hHqYUhuJwnBQ+dAUcFndUKMJrth6lHeoifkbw2bv81zxJ I9cvIy516+oUekqiSFGfzAqByv41OrgLV4fLGCDH3yRh1tj7EtV3l2TngqtrDLUs5R+sWIItPa/4 AJXB1Q3nGNl2tNjVpcSn0uJ7aFPbAgMBAAGjggGKMIIBhjAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0l BBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMEMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFHzM CmjXouseLHIb0c1dlW+N+/JjMB8GA1UdIwQYMBaAFI/wS3+oLkUkrk1Q+mOai97i3Ru8MHsGCCsG AQUFBwEBBG8wbTAuBggrBgEFBQcwAYYiaHR0cDovL29jc3AyLmdsb2JhbHNpZ24uY29tL3Jvb3Ry MzA7BggrBgEFBQcwAoYvaHR0cDovL3NlY3VyZS5nbG9iYWxzaWduLmNvbS9jYWNlcnQvcm9vdC1y My5jcnQwNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5nbG9iYWxzaWduLmNvbS9yb290LXIz LmNybDBMBgNVHSAERTBDMEEGCSsGAQQBoDIBKDA0MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5n bG9iYWxzaWduLmNvbS9yZXBvc2l0b3J5LzANBgkqhkiG9w0BAQsFAAOCAQEANyYcO+9JZYyqQt41 TMwvFWAw3vLoLOQIfIn48/yea/ekOcParTb0mbhsvVSZ6sGn+txYAZb33wIb1f4wK4xQ7+RUYBfI TuTPL7olF9hDpojC2F6Eu8nuEf1XD9qNI8zFd4kfjg4rb+AME0L81WaCL/WhP2kDCnRU4jm6TryB CHhZqtxkIvXGPGHjwJJazJBnX5NayIce4fGuUEJ7HkuCthVZ3Rws0UyHSAXesT/0tXATND4mNr1X El6adiSQy619ybVERnRi5aDe1PTwE+qNiotEEaeujz1a/+yYaaTY+k+qJcVxi7tbyQ0hi0UB3myM A/z2HmGEwO8hx7hDjKmKbDCCA18wggJHoAMCAQICCwQAAAAAASFYUwiiMA0GCSqGSIb3DQEBCwUA MEwxIDAeBgNVBAsTF0dsb2JhbFNpZ24gUm9vdCBDQSAtIFIzMRMwEQYDVQQKEwpHbG9iYWxTaWdu MRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTA5MDMxODEwMDAwMFoXDTI5MDMxODEwMDAwMFowTDEg MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNpZ24xEzAR BgNVBAMTCkdsb2JhbFNpZ24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDMJXaQeQZ4 Ihb1wIO2hMoonv0FdhHFrYhy/EYCQ8eyip0EXyTLLkvhYIJG4VKrDIFHcGzdZNHr9SyjD4I9DCuu l9e2FIYQebs7E4B3jAjhSdJqYi8fXvqWaN+JJ5U4nwbXPsnLJlkNc96wyOkmDoMVxu9bi9IEYMpJ pij2aTv2y8gokeWdimFXN6x0FNx04Druci8unPvQu7/1PQDhBjPogiuuU6Y6FnOM3UEOIDrAtKeh 6bJPkC4yYOlXy7kEkmho5TgmYHWyn3f/kRTvriBJ/K1AFUjRAjFhGV64l++td7dkmnq/X8ET75ti +w1s4FRpFqkD2m7pg5NxdsZphYIXAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E BTADAQH/MB0GA1UdDgQWBBSP8Et/qC5FJK5NUPpjmove4t0bvDANBgkqhkiG9w0BAQsFAAOCAQEA S0DbwFCq/sgM7/eWVEVJu5YACUGssxOGhigHM8pr5nS5ugAtrqQK0/Xx8Q+Kv3NnSoPHRHt44K9u bG8DKY4zOUXDjuS5V2yq/BKW7FPGLeQkbLmUY/vcU2hnVj6DuM81IcPJaP7O2sJTqsyQiunwXUaM ld16WCgaLx3ezQA3QY/tRG3XUyiXfvNnBB4V14qWtNPeTCekTBtzc3b0F5nCH3oO4y0IrQocLP88 q1UOD5F+NuvDV0m+4S4tfGCLw0FREyOdzvcya5QBqJnnLDMfOjsl0oZAzjsshnjJYS8Uuu7bVW/f hO4FCU29KNhyztNiUGUe65KXgzHZs7XKR1g/XzCCBNgwggPAoAMCAQICEAHHLXCbS0CYcocWQtL1 FY8wDQYJKoZIhvcNAQELBQAwVDELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYt c2ExKjAoBgNVBAMTIUdsb2JhbFNpZ24gQXRsYXMgUjMgU01JTUUgQ0EgMjAyMDAeFw0yMzAxMjkw NjQ2MThaFw0yMzA3MjgwNjQ2MThaMCQxIjAgBgkqhkiG9w0BCQEWE2RhdmlkZ293QGdvb2dsZS5j b20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+31G8qfgjYj6KzASqulKfP5LGLw1o hZ6j8Uv9o+fA+zL+2wOPYHLNIb6jyAS16+FwevgTr7d9QynTPBiCGE9Wb/i2ob9aBcupQVtBjlJZ I6qUXdVBlo5zsORdNV7/XEqlpu+X5MK5gNHlWhe8gNpAhADSib2H4rjBvFF2yi9BHBAYZU95f0IN cSS0WDNSSCktPaXtAGsI3tslroyjFYUluwGklmQms/tV8f/52zc7A5lzX+hxnnJdsRgirJRI9Sb6 Uypzk06KLxOO2Pg9SFn6MwbAO6LuInpokhxcULUz3g/CMQBmEMSEzPPnfDIAqwDI0Kqh0NAin+V4 fQxJfDCZAgMBAAGjggHUMIIB0DAeBgNVHREEFzAVgRNkYXZpZGdvd0Bnb29nbGUuY29tMA4GA1Ud DwEB/wQEAwIFoDAdBgNVHSUEFjAUBggrBgEFBQcDBAYIKwYBBQUHAwIwHQYDVR0OBBYEFJyglaiY 64VRg2IjDI2fJVE9RD6aMEwGA1UdIARFMEMwQQYJKwYBBAGgMgEoMDQwMgYIKwYBBQUHAgEWJmh0 dHBzOi8vd3d3Lmdsb2JhbHNpZ24uY29tL3JlcG9zaXRvcnkvMAwGA1UdEwEB/wQCMAAwgZoGCCsG AQUFBwEBBIGNMIGKMD4GCCsGAQUFBzABhjJodHRwOi8vb2NzcC5nbG9iYWxzaWduLmNvbS9jYS9n c2F0bGFzcjNzbWltZWNhMjAyMDBIBggrBgEFBQcwAoY8aHR0cDovL3NlY3VyZS5nbG9iYWxzaWdu LmNvbS9jYWNlcnQvZ3NhdGxhc3Izc21pbWVjYTIwMjAuY3J0MB8GA1UdIwQYMBaAFHzMCmjXouse LHIb0c1dlW+N+/JjMEYGA1UdHwQ/MD0wO6A5oDeGNWh0dHA6Ly9jcmwuZ2xvYmFsc2lnbi5jb20v Y2EvZ3NhdGxhc3Izc21pbWVjYTIwMjAuY3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA2lZLYRLu7foeR cHo1VeNA974FZBiCm08Kd44/aCMEzdTJvxAE9xbUJf7hS1i6eW49qxuSp3/YLn6U7uatwAcmZcwp Zma19ftf3LH+9Hvffk+X8fbPKe6uHkJhR2LktrhRzF159jj67NvXyGQv8J4n7UNeEVP0d5ByvRwv tF2bJwlOwRGLoxasKSyDHIyUpwTfWYPq7XvjoGqQ/tDS7Khcc5WncJl0/ZEj7EKjtoGbsDbLdXEF m/6vdcYKJzF9ghHewtV3YIU4RE3pEM4aCWWRtJwbExzeue6fI7RqURbNCAyQuSpWv0YQvzsX3ZX3 c1otrs50n1N0Sf8/rfJxq7sWMYICajCCAmYCAQEwaDBUMQswCQYDVQQGEwJCRTEZMBcGA1UEChMQ R2xvYmFsU2lnbiBudi1zYTEqMCgGA1UEAxMhR2xvYmFsU2lnbiBBdGxhcyBSMyBTTUlNRSBDQSAy MDIwAhABxy1wm0tAmHKHFkLS9RWPMA0GCWCGSAFlAwQCAQUAoIHUMC8GCSqGSIb3DQEJBDEiBCD5 86CIRULPEMwUWZV/a7qUqBMFmJMb3MpZWMzCa1wifzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcB MBwGCSqGSIb3DQEJBTEPFw0yMzAzMDMwNzE1NDdaMGkGCSqGSIb3DQEJDzFcMFowCwYJYIZIAWUD BAEqMAsGCWCGSAFlAwQBFjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwCwYJKoZIhvcNAQEKMAsG CSqGSIb3DQEBBzALBglghkgBZQMEAgEwDQYJKoZIhvcNAQEBBQAEggEAXg8QKWbCmPKSbx9mAPkg XSGrxqlvX0RljB4aUIXjGIeX3QMo3YK5BPWT5c14xEOxCef6Bd9CEPmd23gYoo7Be2vL/x5CDFLZ YrAohFVv6eDqxkkZdGhScJ5Bj+PN53MGatRg6+eSG9tXepY+AY8LdFil5Jv9UClQOA57IvUnuwBt Kwkasd/3WK9AJv+VECcUX6TeTTYoEnysvaZj6sqiPs2mLBZKsP0WcdrR2izwfA+0R2VRJmr6FmFP 8PZw6Ns1MZBVwS3unAdfThhssW+8OFzQ4LO38ydVM7cV9gapSDskNEK2snM5aSvHb0aP8ym1jszl 7lD94kHm/oTww4GACg== --000000000000dcb39f05f5f9b64b-- --===============1271986055795827145== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ linux-um mailing list linux-um@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-um --===============1271986055795827145==--