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 X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 42BB5C43381 for ; Wed, 27 Mar 2019 23:47:26 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 1276F20651 for ; Wed, 27 Mar 2019 23:47:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387736AbfC0XrY (ORCPT ); Wed, 27 Mar 2019 19:47:24 -0400 Received: from mx1.redhat.com ([209.132.183.28]:40968 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731579AbfC0XrW (ORCPT ); Wed, 27 Mar 2019 19:47:22 -0400 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 0E93830FE5C4; Wed, 27 Mar 2019 23:47:21 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-121-98.rdu2.redhat.com [10.10.121.98]) by smtp.corp.redhat.com (Postfix) with ESMTP id 892485D9C5; Wed, 27 Mar 2019 23:47:19 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [RFC PATCH 53/68] vfs: Convert functionfs to use the new mount API From: David Howells To: viro@zeniv.linux.org.uk Cc: Felipe Balbi , =?utf-8?q?Micha=C5=82?= Nazarewicz , linux-usb@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, dhowells@redhat.com Date: Wed, 27 Mar 2019 23:47:18 +0000 Message-ID: <155373043876.7602.1318289599022013332.stgit@warthog.procyon.org.uk> In-Reply-To: <155372999953.7602.13784796495137723805.stgit@warthog.procyon.org.uk> References: <155372999953.7602.13784796495137723805.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.47]); Wed, 27 Mar 2019 23:47:21 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Convert the functionfs filesystem to the new internal mount API as the old one will be obsoleted and removed. This allows greater flexibility in communication of mount parameters between userspace, the VFS and the filesystem. See Documentation/filesystems/mount_api.txt for more information. Signed-off-by: David Howells cc: Felipe Balbi cc: Michał Nazarewicz cc: linux-usb@vger.kernel.org --- drivers/usb/gadget/function/f_fs.c | 233 +++++++++++++++++++----------------- 1 file changed, 120 insertions(+), 113 deletions(-) diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c index 20413c276c61..796c8b688477 100644 --- a/drivers/usb/gadget/function/f_fs.c +++ b/drivers/usb/gadget/function/f_fs.c @@ -17,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -1447,9 +1448,9 @@ struct ffs_sb_fill_data { struct ffs_data *ffs_data; }; -static int ffs_sb_fill(struct super_block *sb, void *_data, int silent) +static int ffs_sb_fill(struct super_block *sb, struct fs_context *fc) { - struct ffs_sb_fill_data *data = _data; + struct ffs_sb_fill_data *data = fc->fs_private; struct inode *inode; struct ffs_data *ffs = data->ffs_data; @@ -1482,147 +1483,152 @@ static int ffs_sb_fill(struct super_block *sb, void *_data, int silent) return 0; } -static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts) -{ - ENTER(); +enum { + Opt_no_disconnect, + Opt_rmode, + Opt_fmode, + Opt_mode, + Opt_uid, + Opt_gid, +}; - if (!opts || !*opts) - return 0; +static const struct fs_parameter_spec ffs_fs_param_specs[] = { + fsparam_bool ("no_disconnect", Opt_no_disconnect), + fsparam_u32 ("rmode", Opt_rmode), + fsparam_u32 ("fmode", Opt_fmode), + fsparam_u32 ("mode", Opt_mode), + fsparam_u32 ("uid", Opt_uid), + fsparam_u32 ("gid", Opt_gid), + {} +}; - for (;;) { - unsigned long value; - char *eq, *comma; - - /* Option limit */ - comma = strchr(opts, ','); - if (comma) - *comma = 0; - - /* Value limit */ - eq = strchr(opts, '='); - if (unlikely(!eq)) { - pr_err("'=' missing in %s\n", opts); - return -EINVAL; - } - *eq = 0; +static const struct fs_parameter_description ffs_fs_fs_parameters = { + .name = "kAFS", + .specs = ffs_fs_param_specs, +}; - /* Parse value */ - if (kstrtoul(eq + 1, 0, &value)) { - pr_err("%s: invalid value: %s\n", opts, eq + 1); - return -EINVAL; - } +static int ffs_fs_parse_param(struct fs_context *fc, struct fs_parameter *param) +{ + struct ffs_sb_fill_data *data = fc->fs_private; + struct fs_parse_result result; + int opt; - /* Interpret option */ - switch (eq - opts) { - case 13: - if (!memcmp(opts, "no_disconnect", 13)) - data->no_disconnect = !!value; - else - goto invalid; - break; - case 5: - if (!memcmp(opts, "rmode", 5)) - data->root_mode = (value & 0555) | S_IFDIR; - else if (!memcmp(opts, "fmode", 5)) - data->perms.mode = (value & 0666) | S_IFREG; - else - goto invalid; - break; + ENTER(); - case 4: - if (!memcmp(opts, "mode", 4)) { - data->root_mode = (value & 0555) | S_IFDIR; - data->perms.mode = (value & 0666) | S_IFREG; - } else { - goto invalid; - } - break; + opt = fs_parse(fc, &ffs_fs_fs_parameters, param, &result); + if (opt < 0) + return opt; - case 3: - if (!memcmp(opts, "uid", 3)) { - data->perms.uid = make_kuid(current_user_ns(), value); - if (!uid_valid(data->perms.uid)) { - pr_err("%s: unmapped value: %lu\n", opts, value); - return -EINVAL; - } - } else if (!memcmp(opts, "gid", 3)) { - data->perms.gid = make_kgid(current_user_ns(), value); - if (!gid_valid(data->perms.gid)) { - pr_err("%s: unmapped value: %lu\n", opts, value); - return -EINVAL; - } - } else { - goto invalid; - } - break; + switch (opt) { + case Opt_no_disconnect: + data->no_disconnect = result.boolean; + break; + case Opt_rmode: + data->root_mode = (result.uint_32 & 0555) | S_IFDIR; + break; + case Opt_fmode: + data->perms.mode = (result.uint_32 & 0666) | S_IFREG; + break; + case Opt_mode: + data->root_mode = (result.uint_32 & 0555) | S_IFDIR; + data->perms.mode = (result.uint_32 & 0666) | S_IFREG; + break; - default: -invalid: - pr_err("%s: invalid option\n", opts); - return -EINVAL; - } + case Opt_uid: + data->perms.uid = make_kuid(current_user_ns(), result.uint_32); + if (!uid_valid(data->perms.uid)) + goto unmapped_value; + break; + case Opt_gid: + data->perms.gid = make_kgid(current_user_ns(), result.uint_32); + if (!gid_valid(data->perms.gid)) + goto unmapped_value; + break; - /* Next iteration */ - if (!comma) - break; - opts = comma + 1; + default: + return -ENOPARAM; } return 0; -} -/* "mount -t functionfs dev_name /dev/function" ends up here */ +unmapped_value: + return invalf(fc, "%s: unmapped value: %u", param->key, result.uint_32); +} -static struct dentry * -ffs_fs_mount(struct file_system_type *t, int flags, - const char *dev_name, void *opts) -{ - struct ffs_sb_fill_data data = { - .perms = { - .mode = S_IFREG | 0600, - .uid = GLOBAL_ROOT_UID, - .gid = GLOBAL_ROOT_GID, - }, - .root_mode = S_IFDIR | 0500, - .no_disconnect = false, - }; - struct dentry *rv; - int ret; +/* + * Set up the superblock for a mount. + */ +static int ffs_fs_get_tree(struct fs_context *fc) +{ + struct ffs_sb_fill_data *ctx = fc->fs_private; void *ffs_dev; struct ffs_data *ffs; ENTER(); - ret = ffs_fs_parse_opts(&data, opts); - if (unlikely(ret < 0)) - return ERR_PTR(ret); + if (!fc->source) + return invalf(fc, "No source specified"); - ffs = ffs_data_new(dev_name); + ffs = ffs_data_new(fc->source); if (unlikely(!ffs)) - return ERR_PTR(-ENOMEM); - ffs->file_perms = data.perms; - ffs->no_disconnect = data.no_disconnect; + return -ENOMEM; + ffs->file_perms = ctx->perms; + ffs->no_disconnect = ctx->no_disconnect; - ffs->dev_name = kstrdup(dev_name, GFP_KERNEL); + ffs->dev_name = kstrdup(fc->source, GFP_KERNEL); if (unlikely(!ffs->dev_name)) { ffs_data_put(ffs); - return ERR_PTR(-ENOMEM); + return -ENOMEM; } - ffs_dev = ffs_acquire_dev(dev_name); + ffs_dev = ffs_acquire_dev(ffs->dev_name); if (IS_ERR(ffs_dev)) { ffs_data_put(ffs); - return ERR_CAST(ffs_dev); + return PTR_ERR(ffs_dev); } + ffs->private_data = ffs_dev; - data.ffs_data = ffs; + ctx->ffs_data = ffs; + return vfs_get_super(fc, vfs_get_independent_super, ffs_sb_fill); +} + +static void ffs_fs_free_fc(struct fs_context *fc) +{ + struct ffs_sb_fill_data *ctx = fc->fs_private; + + if (ctx) { + if (ctx->ffs_data) { + ffs_release_dev(ctx->ffs_data); + ffs_data_put(ctx->ffs_data); + } - rv = mount_nodev(t, flags, &data, ffs_sb_fill); - if (IS_ERR(rv) && data.ffs_data) { - ffs_release_dev(data.ffs_data); - ffs_data_put(data.ffs_data); + kfree(ctx); } - return rv; +} + +static const struct fs_context_operations ffs_fs_context_ops = { + .free = ffs_fs_free_fc, + .parse_param = ffs_fs_parse_param, + .get_tree = ffs_fs_get_tree, +}; + +static int ffs_fs_init_fs_context(struct fs_context *fc) +{ + struct ffs_sb_fill_data *ctx; + + ctx = kzalloc(sizeof(struct ffs_sb_fill_data), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + ctx->perms.mode = S_IFREG | 0600; + ctx->perms.uid = GLOBAL_ROOT_UID; + ctx->perms.gid = GLOBAL_ROOT_GID; + ctx->root_mode = S_IFDIR | 0500; + ctx->no_disconnect = false; + + fc->fs_private = ctx; + fc->ops = &ffs_fs_context_ops; + return 0; } static void @@ -1640,7 +1646,8 @@ ffs_fs_kill_sb(struct super_block *sb) static struct file_system_type ffs_fs_type = { .owner = THIS_MODULE, .name = "functionfs", - .mount = ffs_fs_mount, + .init_fs_context = ffs_fs_init_fs_context, + .parameters = &ffs_fs_fs_parameters, .kill_sb = ffs_fs_kill_sb, }; MODULE_ALIAS_FS("functionfs"); From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [RFC,53/68] vfs: Convert functionfs to use the new mount API From: David Howells Message-Id: <155373043876.7602.1318289599022013332.stgit@warthog.procyon.org.uk> Date: Wed, 27 Mar 2019 23:47:18 +0000 To: viro@zeniv.linux.org.uk Cc: Felipe Balbi , =?utf-8?q?Micha=C5=82?= Nazarewicz , linux-usb@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, dhowells@redhat.com List-ID: Q29udmVydCB0aGUgZnVuY3Rpb25mcyBmaWxlc3lzdGVtIHRvIHRoZSBuZXcgaW50ZXJuYWwgbW91 bnQgQVBJIGFzIHRoZSBvbGQKb25lIHdpbGwgYmUgb2Jzb2xldGVkIGFuZCByZW1vdmVkLiAgVGhp cyBhbGxvd3MgZ3JlYXRlciBmbGV4aWJpbGl0eSBpbgpjb21tdW5pY2F0aW9uIG9mIG1vdW50IHBh cmFtZXRlcnMgYmV0d2VlbiB1c2Vyc3BhY2UsIHRoZSBWRlMgYW5kIHRoZQpmaWxlc3lzdGVtLgoK U2VlIERvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvbW91bnRfYXBpLnR4dCBmb3IgbW9yZSBpbmZv cm1hdGlvbi4KClNpZ25lZC1vZmYtYnk6IERhdmlkIEhvd2VsbHMgPGRob3dlbGxzQHJlZGhhdC5j b20+CmNjOiBGZWxpcGUgQmFsYmkgPGJhbGJpQGtlcm5lbC5vcmc+CmNjOiBNaWNoYcWCIE5hemFy ZXdpY3ogPG1pbmE4NkBtaW5hODYuY29tPgpjYzogbGludXgtdXNiQHZnZXIua2VybmVsLm9yZwot LS0KCiBkcml2ZXJzL3VzYi9nYWRnZXQvZnVuY3Rpb24vZl9mcy5jIHwgIDIzMyArKysrKysrKysr KysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAxMjAgaW5zZXJ0aW9u cygrKSwgMTEzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2dhZGdldC9m dW5jdGlvbi9mX2ZzLmMgYi9kcml2ZXJzL3VzYi9nYWRnZXQvZnVuY3Rpb24vZl9mcy5jCmluZGV4 IDIwNDEzYzI3NmM2MS4uNzk2YzhiNjg4NDc3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRn ZXQvZnVuY3Rpb24vZl9mcy5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9mdW5jdGlvbi9mX2Zz LmMKQEAgLTE3LDYgKzE3LDcgQEAKICNpbmNsdWRlIDxsaW51eC9ibGtkZXYuaD4KICNpbmNsdWRl IDxsaW51eC9wYWdlbWFwLmg+CiAjaW5jbHVkZSA8bGludXgvZXhwb3J0Lmg+CisjaW5jbHVkZSA8 bGludXgvZnNfcGFyc2VyLmg+CiAjaW5jbHVkZSA8bGludXgvaGlkLmg+CiAjaW5jbHVkZSA8bGlu dXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KQEAgLTE0NDcsOSArMTQ0OCw5IEBA IHN0cnVjdCBmZnNfc2JfZmlsbF9kYXRhIHsKIAlzdHJ1Y3QgZmZzX2RhdGEgKmZmc19kYXRhOwog fTsKIAotc3RhdGljIGludCBmZnNfc2JfZmlsbChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB2b2lk ICpfZGF0YSwgaW50IHNpbGVudCkKK3N0YXRpYyBpbnQgZmZzX3NiX2ZpbGwoc3RydWN0IHN1cGVy X2Jsb2NrICpzYiwgc3RydWN0IGZzX2NvbnRleHQgKmZjKQogewotCXN0cnVjdCBmZnNfc2JfZmls bF9kYXRhICpkYXRhID0gX2RhdGE7CisJc3RydWN0IGZmc19zYl9maWxsX2RhdGEgKmRhdGEgPSBm Yy0+ZnNfcHJpdmF0ZTsKIAlzdHJ1Y3QgaW5vZGUJKmlub2RlOwogCXN0cnVjdCBmZnNfZGF0YQkq ZmZzID0gZGF0YS0+ZmZzX2RhdGE7CiAKQEAgLTE0ODIsMTQ3ICsxNDgzLDE1MiBAQCBzdGF0aWMg aW50IGZmc19zYl9maWxsKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHZvaWQgKl9kYXRhLCBpbnQg c2lsZW50KQogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IGZmc19mc19wYXJzZV9vcHRzKHN0 cnVjdCBmZnNfc2JfZmlsbF9kYXRhICpkYXRhLCBjaGFyICpvcHRzKQotewotCUVOVEVSKCk7Citl bnVtIHsKKwlPcHRfbm9fZGlzY29ubmVjdCwKKwlPcHRfcm1vZGUsCisJT3B0X2Ztb2RlLAorCU9w dF9tb2RlLAorCU9wdF91aWQsCisJT3B0X2dpZCwKK307CiAKLQlpZiAoIW9wdHMgfHwgISpvcHRz KQotCQlyZXR1cm4gMDsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZnNfcGFyYW1ldGVyX3NwZWMgZmZz X2ZzX3BhcmFtX3NwZWNzW10gPSB7CisJZnNwYXJhbV9ib29sCSgibm9fZGlzY29ubmVjdCIsCU9w dF9ub19kaXNjb25uZWN0KSwKKwlmc3BhcmFtX3UzMgkoInJtb2RlIiwJCU9wdF9ybW9kZSksCisJ ZnNwYXJhbV91MzIJKCJmbW9kZSIsCQlPcHRfZm1vZGUpLAorCWZzcGFyYW1fdTMyCSgibW9kZSIs CQlPcHRfbW9kZSksCisJZnNwYXJhbV91MzIJKCJ1aWQiLAkJCU9wdF91aWQpLAorCWZzcGFyYW1f dTMyCSgiZ2lkIiwJCQlPcHRfZ2lkKSwKKwl7fQorfTsKIAotCWZvciAoOzspIHsKLQkJdW5zaWdu ZWQgbG9uZyB2YWx1ZTsKLQkJY2hhciAqZXEsICpjb21tYTsKLQotCQkvKiBPcHRpb24gbGltaXQg Ki8KLQkJY29tbWEgPSBzdHJjaHIob3B0cywgJywnKTsKLQkJaWYgKGNvbW1hKQotCQkJKmNvbW1h ID0gMDsKLQotCQkvKiBWYWx1ZSBsaW1pdCAqLwotCQllcSA9IHN0cmNocihvcHRzLCAnPScpOwot CQlpZiAodW5saWtlbHkoIWVxKSkgewotCQkJcHJfZXJyKCInPScgbWlzc2luZyBpbiAlc1xuIiwg b3B0cyk7Ci0JCQlyZXR1cm4gLUVJTlZBTDsKLQkJfQotCQkqZXEgPSAwOworc3RhdGljIGNvbnN0 IHN0cnVjdCBmc19wYXJhbWV0ZXJfZGVzY3JpcHRpb24gZmZzX2ZzX2ZzX3BhcmFtZXRlcnMgPSB7 CisJLm5hbWUJCT0gImtBRlMiLAorCS5zcGVjcwkJPSBmZnNfZnNfcGFyYW1fc3BlY3MsCit9Owog Ci0JCS8qIFBhcnNlIHZhbHVlICovCi0JCWlmIChrc3RydG91bChlcSArIDEsIDAsICZ2YWx1ZSkp IHsKLQkJCXByX2VycigiJXM6IGludmFsaWQgdmFsdWU6ICVzXG4iLCBvcHRzLCBlcSArIDEpOwot CQkJcmV0dXJuIC1FSU5WQUw7Ci0JCX0KK3N0YXRpYyBpbnQgZmZzX2ZzX3BhcnNlX3BhcmFtKHN0 cnVjdCBmc19jb250ZXh0ICpmYywgc3RydWN0IGZzX3BhcmFtZXRlciAqcGFyYW0pCit7CisJc3Ry dWN0IGZmc19zYl9maWxsX2RhdGEgKmRhdGEgPSBmYy0+ZnNfcHJpdmF0ZTsKKwlzdHJ1Y3QgZnNf cGFyc2VfcmVzdWx0IHJlc3VsdDsKKwlpbnQgb3B0OwogCi0JCS8qIEludGVycHJldCBvcHRpb24g Ki8KLQkJc3dpdGNoIChlcSAtIG9wdHMpIHsKLQkJY2FzZSAxMzoKLQkJCWlmICghbWVtY21wKG9w dHMsICJub19kaXNjb25uZWN0IiwgMTMpKQotCQkJCWRhdGEtPm5vX2Rpc2Nvbm5lY3QgPSAhIXZh bHVlOwotCQkJZWxzZQotCQkJCWdvdG8gaW52YWxpZDsKLQkJCWJyZWFrOwotCQljYXNlIDU6Ci0J CQlpZiAoIW1lbWNtcChvcHRzLCAicm1vZGUiLCA1KSkKLQkJCQlkYXRhLT5yb290X21vZGUgID0g KHZhbHVlICYgMDU1NSkgfCBTX0lGRElSOwotCQkJZWxzZSBpZiAoIW1lbWNtcChvcHRzLCAiZm1v ZGUiLCA1KSkKLQkJCQlkYXRhLT5wZXJtcy5tb2RlID0gKHZhbHVlICYgMDY2NikgfCBTX0lGUkVH OwotCQkJZWxzZQotCQkJCWdvdG8gaW52YWxpZDsKLQkJCWJyZWFrOworCUVOVEVSKCk7CiAKLQkJ Y2FzZSA0OgotCQkJaWYgKCFtZW1jbXAob3B0cywgIm1vZGUiLCA0KSkgewotCQkJCWRhdGEtPnJv b3RfbW9kZSAgPSAodmFsdWUgJiAwNTU1KSB8IFNfSUZESVI7Ci0JCQkJZGF0YS0+cGVybXMubW9k ZSA9ICh2YWx1ZSAmIDA2NjYpIHwgU19JRlJFRzsKLQkJCX0gZWxzZSB7Ci0JCQkJZ290byBpbnZh bGlkOwotCQkJfQotCQkJYnJlYWs7CisJb3B0ID0gZnNfcGFyc2UoZmMsICZmZnNfZnNfZnNfcGFy YW1ldGVycywgcGFyYW0sICZyZXN1bHQpOworCWlmIChvcHQgPCAwKQorCQlyZXR1cm4gb3B0Owog Ci0JCWNhc2UgMzoKLQkJCWlmICghbWVtY21wKG9wdHMsICJ1aWQiLCAzKSkgewotCQkJCWRhdGEt PnBlcm1zLnVpZCA9IG1ha2Vfa3VpZChjdXJyZW50X3VzZXJfbnMoKSwgdmFsdWUpOwotCQkJCWlm ICghdWlkX3ZhbGlkKGRhdGEtPnBlcm1zLnVpZCkpIHsKLQkJCQkJcHJfZXJyKCIlczogdW5tYXBw ZWQgdmFsdWU6ICVsdVxuIiwgb3B0cywgdmFsdWUpOwotCQkJCQlyZXR1cm4gLUVJTlZBTDsKLQkJ CQl9Ci0JCQl9IGVsc2UgaWYgKCFtZW1jbXAob3B0cywgImdpZCIsIDMpKSB7Ci0JCQkJZGF0YS0+ cGVybXMuZ2lkID0gbWFrZV9rZ2lkKGN1cnJlbnRfdXNlcl9ucygpLCB2YWx1ZSk7Ci0JCQkJaWYg KCFnaWRfdmFsaWQoZGF0YS0+cGVybXMuZ2lkKSkgewotCQkJCQlwcl9lcnIoIiVzOiB1bm1hcHBl ZCB2YWx1ZTogJWx1XG4iLCBvcHRzLCB2YWx1ZSk7Ci0JCQkJCXJldHVybiAtRUlOVkFMOwotCQkJ CX0KLQkJCX0gZWxzZSB7Ci0JCQkJZ290byBpbnZhbGlkOwotCQkJfQotCQkJYnJlYWs7CisJc3dp dGNoIChvcHQpIHsKKwljYXNlIE9wdF9ub19kaXNjb25uZWN0OgorCQlkYXRhLT5ub19kaXNjb25u ZWN0ID0gcmVzdWx0LmJvb2xlYW47CisJCWJyZWFrOworCWNhc2UgT3B0X3Jtb2RlOgorCQlkYXRh LT5yb290X21vZGUgID0gKHJlc3VsdC51aW50XzMyICYgMDU1NSkgfCBTX0lGRElSOworCQlicmVh azsKKwljYXNlIE9wdF9mbW9kZToKKwkJZGF0YS0+cGVybXMubW9kZSA9IChyZXN1bHQudWludF8z MiAmIDA2NjYpIHwgU19JRlJFRzsKKwkJYnJlYWs7CisJY2FzZSBPcHRfbW9kZToKKwkJZGF0YS0+ cm9vdF9tb2RlICA9IChyZXN1bHQudWludF8zMiAmIDA1NTUpIHwgU19JRkRJUjsKKwkJZGF0YS0+ cGVybXMubW9kZSA9IChyZXN1bHQudWludF8zMiAmIDA2NjYpIHwgU19JRlJFRzsKKwkJYnJlYWs7 CiAKLQkJZGVmYXVsdDoKLWludmFsaWQ6Ci0JCQlwcl9lcnIoIiVzOiBpbnZhbGlkIG9wdGlvblxu Iiwgb3B0cyk7Ci0JCQlyZXR1cm4gLUVJTlZBTDsKLQkJfQorCWNhc2UgT3B0X3VpZDoKKwkJZGF0 YS0+cGVybXMudWlkID0gbWFrZV9rdWlkKGN1cnJlbnRfdXNlcl9ucygpLCByZXN1bHQudWludF8z Mik7CisJCWlmICghdWlkX3ZhbGlkKGRhdGEtPnBlcm1zLnVpZCkpCisJCQlnb3RvIHVubWFwcGVk X3ZhbHVlOworCQlicmVhazsKKwljYXNlIE9wdF9naWQ6CisJCWRhdGEtPnBlcm1zLmdpZCA9IG1h a2Vfa2dpZChjdXJyZW50X3VzZXJfbnMoKSwgcmVzdWx0LnVpbnRfMzIpOworCQlpZiAoIWdpZF92 YWxpZChkYXRhLT5wZXJtcy5naWQpKQorCQkJZ290byB1bm1hcHBlZF92YWx1ZTsKKwkJYnJlYWs7 CiAKLQkJLyogTmV4dCBpdGVyYXRpb24gKi8KLQkJaWYgKCFjb21tYSkKLQkJCWJyZWFrOwotCQlv cHRzID0gY29tbWEgKyAxOworCWRlZmF1bHQ6CisJCXJldHVybiAtRU5PUEFSQU07CiAJfQogCiAJ cmV0dXJuIDA7Ci19CiAKLS8qICJtb3VudCAtdCBmdW5jdGlvbmZzIGRldl9uYW1lIC9kZXYvZnVu Y3Rpb24iIGVuZHMgdXAgaGVyZSAqLwordW5tYXBwZWRfdmFsdWU6CisJcmV0dXJuIGludmFsZihm YywgIiVzOiB1bm1hcHBlZCB2YWx1ZTogJXUiLCBwYXJhbS0+a2V5LCByZXN1bHQudWludF8zMik7 Cit9CiAKLXN0YXRpYyBzdHJ1Y3QgZGVudHJ5ICoKLWZmc19mc19tb3VudChzdHJ1Y3QgZmlsZV9z eXN0ZW1fdHlwZSAqdCwgaW50IGZsYWdzLAotCSAgICAgIGNvbnN0IGNoYXIgKmRldl9uYW1lLCB2 b2lkICpvcHRzKQotewotCXN0cnVjdCBmZnNfc2JfZmlsbF9kYXRhIGRhdGEgPSB7Ci0JCS5wZXJt cyA9IHsKLQkJCS5tb2RlID0gU19JRlJFRyB8IDA2MDAsCi0JCQkudWlkID0gR0xPQkFMX1JPT1Rf VUlELAotCQkJLmdpZCA9IEdMT0JBTF9ST09UX0dJRCwKLQkJfSwKLQkJLnJvb3RfbW9kZSA9IFNf SUZESVIgfCAwNTAwLAotCQkubm9fZGlzY29ubmVjdCA9IGZhbHNlLAotCX07Ci0Jc3RydWN0IGRl bnRyeSAqcnY7Ci0JaW50IHJldDsKKy8qCisgKiBTZXQgdXAgdGhlIHN1cGVyYmxvY2sgZm9yIGEg bW91bnQuCisgKi8KK3N0YXRpYyBpbnQgZmZzX2ZzX2dldF90cmVlKHN0cnVjdCBmc19jb250ZXh0 ICpmYykKK3sKKwlzdHJ1Y3QgZmZzX3NiX2ZpbGxfZGF0YSAqY3R4ID0gZmMtPmZzX3ByaXZhdGU7 CiAJdm9pZCAqZmZzX2RldjsKIAlzdHJ1Y3QgZmZzX2RhdGEJKmZmczsKIAogCUVOVEVSKCk7CiAK LQlyZXQgPSBmZnNfZnNfcGFyc2Vfb3B0cygmZGF0YSwgb3B0cyk7Ci0JaWYgKHVubGlrZWx5KHJl dCA8IDApKQotCQlyZXR1cm4gRVJSX1BUUihyZXQpOworCWlmICghZmMtPnNvdXJjZSkKKwkJcmV0 dXJuIGludmFsZihmYywgIk5vIHNvdXJjZSBzcGVjaWZpZWQiKTsKIAotCWZmcyA9IGZmc19kYXRh X25ldyhkZXZfbmFtZSk7CisJZmZzID0gZmZzX2RhdGFfbmV3KGZjLT5zb3VyY2UpOwogCWlmICh1 bmxpa2VseSghZmZzKSkKLQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Ci0JZmZzLT5maWxlX3Bl cm1zID0gZGF0YS5wZXJtczsKLQlmZnMtPm5vX2Rpc2Nvbm5lY3QgPSBkYXRhLm5vX2Rpc2Nvbm5l Y3Q7CisJCXJldHVybiAtRU5PTUVNOworCWZmcy0+ZmlsZV9wZXJtcyA9IGN0eC0+cGVybXM7CisJ ZmZzLT5ub19kaXNjb25uZWN0ID0gY3R4LT5ub19kaXNjb25uZWN0OwogCi0JZmZzLT5kZXZfbmFt ZSA9IGtzdHJkdXAoZGV2X25hbWUsIEdGUF9LRVJORUwpOworCWZmcy0+ZGV2X25hbWUgPSBrc3Ry ZHVwKGZjLT5zb3VyY2UsIEdGUF9LRVJORUwpOwogCWlmICh1bmxpa2VseSghZmZzLT5kZXZfbmFt ZSkpIHsKIAkJZmZzX2RhdGFfcHV0KGZmcyk7Ci0JCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwor CQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKLQlmZnNfZGV2ID0gZmZzX2FjcXVpcmVfZGV2KGRldl9u YW1lKTsKKwlmZnNfZGV2ID0gZmZzX2FjcXVpcmVfZGV2KGZmcy0+ZGV2X25hbWUpOwogCWlmIChJ U19FUlIoZmZzX2RldikpIHsKIAkJZmZzX2RhdGFfcHV0KGZmcyk7Ci0JCXJldHVybiBFUlJfQ0FT VChmZnNfZGV2KTsKKwkJcmV0dXJuIFBUUl9FUlIoZmZzX2Rldik7CiAJfQorCiAJZmZzLT5wcml2 YXRlX2RhdGEgPSBmZnNfZGV2OwotCWRhdGEuZmZzX2RhdGEgPSBmZnM7CisJY3R4LT5mZnNfZGF0 YSA9IGZmczsKKwlyZXR1cm4gdmZzX2dldF9zdXBlcihmYywgdmZzX2dldF9pbmRlcGVuZGVudF9z dXBlciwgZmZzX3NiX2ZpbGwpOworfQorCitzdGF0aWMgdm9pZCBmZnNfZnNfZnJlZV9mYyhzdHJ1 Y3QgZnNfY29udGV4dCAqZmMpCit7CisJc3RydWN0IGZmc19zYl9maWxsX2RhdGEgKmN0eCA9IGZj LT5mc19wcml2YXRlOworCisJaWYgKGN0eCkgeworCQlpZiAoY3R4LT5mZnNfZGF0YSkgeworCQkJ ZmZzX3JlbGVhc2VfZGV2KGN0eC0+ZmZzX2RhdGEpOworCQkJZmZzX2RhdGFfcHV0KGN0eC0+ZmZz X2RhdGEpOworCQl9CiAKLQlydiA9IG1vdW50X25vZGV2KHQsIGZsYWdzLCAmZGF0YSwgZmZzX3Ni X2ZpbGwpOwotCWlmIChJU19FUlIocnYpICYmIGRhdGEuZmZzX2RhdGEpIHsKLQkJZmZzX3JlbGVh c2VfZGV2KGRhdGEuZmZzX2RhdGEpOwotCQlmZnNfZGF0YV9wdXQoZGF0YS5mZnNfZGF0YSk7CisJ CWtmcmVlKGN0eCk7CiAJfQotCXJldHVybiBydjsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBm c19jb250ZXh0X29wZXJhdGlvbnMgZmZzX2ZzX2NvbnRleHRfb3BzID0geworCS5mcmVlCQk9IGZm c19mc19mcmVlX2ZjLAorCS5wYXJzZV9wYXJhbQk9IGZmc19mc19wYXJzZV9wYXJhbSwKKwkuZ2V0 X3RyZWUJPSBmZnNfZnNfZ2V0X3RyZWUsCit9OworCitzdGF0aWMgaW50IGZmc19mc19pbml0X2Zz X2NvbnRleHQoc3RydWN0IGZzX2NvbnRleHQgKmZjKQoreworCXN0cnVjdCBmZnNfc2JfZmlsbF9k YXRhICpjdHg7CisKKwljdHggPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgZmZzX3NiX2ZpbGxfZGF0 YSksIEdGUF9LRVJORUwpOworCWlmICghY3R4KQorCQlyZXR1cm4gLUVOT01FTTsKKworCWN0eC0+ cGVybXMubW9kZSA9IFNfSUZSRUcgfCAwNjAwOworCWN0eC0+cGVybXMudWlkID0gR0xPQkFMX1JP T1RfVUlEOworCWN0eC0+cGVybXMuZ2lkID0gR0xPQkFMX1JPT1RfR0lEOworCWN0eC0+cm9vdF9t b2RlID0gU19JRkRJUiB8IDA1MDA7CisJY3R4LT5ub19kaXNjb25uZWN0ID0gZmFsc2U7CisKKwlm Yy0+ZnNfcHJpdmF0ZSA9IGN0eDsKKwlmYy0+b3BzID0gJmZmc19mc19jb250ZXh0X29wczsKKwly ZXR1cm4gMDsKIH0KIAogc3RhdGljIHZvaWQKQEAgLTE2NDAsNyArMTY0Niw4IEBAIGZmc19mc19r aWxsX3NiKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCiBzdGF0aWMgc3RydWN0IGZpbGVfc3lzdGVt X3R5cGUgZmZzX2ZzX3R5cGUgPSB7CiAJLm93bmVyCQk9IFRISVNfTU9EVUxFLAogCS5uYW1lCQk9 ICJmdW5jdGlvbmZzIiwKLQkubW91bnQJCT0gZmZzX2ZzX21vdW50LAorCS5pbml0X2ZzX2NvbnRl eHQgPSBmZnNfZnNfaW5pdF9mc19jb250ZXh0LAorCS5wYXJhbWV0ZXJzCT0gJmZmc19mc19mc19w YXJhbWV0ZXJzLAogCS5raWxsX3NiCT0gZmZzX2ZzX2tpbGxfc2IsCiB9OwogTU9EVUxFX0FMSUFT X0ZTKCJmdW5jdGlvbmZzIik7Cg==