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=-9.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,USER_AGENT_GIT 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 0476FC43219 for ; Wed, 1 May 2019 14:03:12 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id A2A8621670 for ; Wed, 1 May 2019 14:03:11 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A2A8621670 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 68A666B000C; Wed, 1 May 2019 10:03:07 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 63E486B000D; Wed, 1 May 2019 10:03:07 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 4DBD16B000E; Wed, 1 May 2019 10:03:07 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from mail-pg1-f198.google.com (mail-pg1-f198.google.com [209.85.215.198]) by kanga.kvack.org (Postfix) with ESMTP id 13CE06B000C for ; Wed, 1 May 2019 10:03:07 -0400 (EDT) Received: by mail-pg1-f198.google.com with SMTP id d1so10929590pgk.21 for ; Wed, 01 May 2019 07:03:07 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-original-authentication-results:x-gm-message-state:from:to :subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=A7SFuJbJ0Uz+80lz/JGgS9jWr30zBIqu8J3bqFaW1VQ=; b=Rp6itI97yvFtc5xayfXv7n4nOPJsutx4U+rVu52slqnpE5FYUPBvPedChhRNUn5GlQ jyy2Z+yawIjKNlFXiD3ENyNdAlu2cKhGvDptqiE9lNMwLmKDry89DbB3PsMUreIJQnV5 pFQJxqTj1g9cuwo1Ep/sxdAn7qxyMVvYQbmFt5gGCGtyEWnakBAeYsfEdZGeqCHB4qMK h3NHHnae1s7RFs7vSj5R8ZKQPddlcLA9vLSo2do4G61UHr+22UY2XTkLwfzbPu4B303i vuw7HPUJCzA8rEWQvJi7GCw/LjBfZdxrbNijY/CSwZjAzKQNRqwHOSOUWbA3HcCy5IPC GoAg== X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of brian.welty@intel.com designates 192.55.52.43 as permitted sender) smtp.mailfrom=brian.welty@intel.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com X-Gm-Message-State: APjAAAV5Ykiac6QsJ/81YsK32YClkkixg39kiHa5KS1f0DHsvjgN9oXG 0VBFW0RklDzMHi/B9YqvwOYuBc4gH3NQbHEJqJ7/Ab/7UAISJndTUdZPDdcRnt1oeWUZ+vflfMr Ozygzicj+KtpdogWBXFUC9f+o0TDj5tlF4UHH5afkGa6NFD5j91cxgKhL0JMWXldpbg== X-Received: by 2002:a17:902:4101:: with SMTP id e1mr79389527pld.25.1556719386667; Wed, 01 May 2019 07:03:06 -0700 (PDT) X-Google-Smtp-Source: APXvYqzsV3MP65nzKxToax1oFV4Ytd5XP+9AuC2WOQ0B3+IWY1clVtyUMq8otdanxqAXIPAz2Ozx X-Received: by 2002:a17:902:4101:: with SMTP id e1mr79389304pld.25.1556719384902; Wed, 01 May 2019 07:03:04 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1556719384; cv=none; d=google.com; s=arc-20160816; b=CK8y8Zx6UPaPdMQ5tU+tcMTsGQ/YTohbVAh2084MhUjXkkLnpY2acHHRF9zZwa0EEQ yE0Wlve77UQ8TkTwuqyENuJZwaiufBIaXbEd6sDqezUx2D+OWgE4behy8Hdy76Oug9IX 22CPV2IotbxE9n59UyJvwwUp24SX1R3VQnXxaca0kCn04rOwN2PoB9kO5/X2Wpje4Mf9 JezFk8kqoH1svKw1UOGaFr0VmF5lf+B4ilasXDSe+JzVBf05akfegtpHqxzRPXba+Tdg IMTKgW6c+a40Sx4CLRQLKh8jq4YCSBuMS3jC3GQMbsdal2uGnGd9ytmREiSY4HNC9iPV emMA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from; bh=A7SFuJbJ0Uz+80lz/JGgS9jWr30zBIqu8J3bqFaW1VQ=; b=l6w4PU8dCb/pvUVbBJ+iop4LmyCrAzUA/Ca9Oj7MZ/z8GTkdDRu3SrsyywaL4rL4yC Qq7gDtrmqYa48DWWe9r7hRLtEDU4QDPFwA1QoTfe4XWKyei/itMS130Ia+/fw9hhcJl/ ccMcnuPH3/znjFg3cD/2u7JMu0kmzy6XgjDXhqmBHkcQLV27AChTSvWqH9YN8yb1tTQU UCUvI+YUOQiOe3J6Mfxft36bGcsO8pxhVJFDDFbDt+KcToJsOVDUOdmKmGfsDmwwCIUc dSt/ppdXGyPaMKR7auXCm9810G73HYMTTxiXuHZD9FR5M47PVJSI2Ahpm26034BjD0En Nksg== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of brian.welty@intel.com designates 192.55.52.43 as permitted sender) smtp.mailfrom=brian.welty@intel.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: from mga05.intel.com (mga05.intel.com. [192.55.52.43]) by mx.google.com with ESMTPS id q25si38000486pgv.534.2019.05.01.07.03.04 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 01 May 2019 07:03:04 -0700 (PDT) Received-SPF: pass (google.com: domain of brian.welty@intel.com designates 192.55.52.43 as permitted sender) client-ip=192.55.52.43; Authentication-Results: mx.google.com; spf=pass (google.com: domain of brian.welty@intel.com designates 192.55.52.43 as permitted sender) smtp.mailfrom=brian.welty@intel.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by fmsmga105.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 01 May 2019 07:03:04 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.60,417,1549958400"; d="scan'208";a="145141406" Received: from nperf12.hd.intel.com ([10.127.88.161]) by fmsmga008.fm.intel.com with ESMTP; 01 May 2019 07:03:03 -0700 From: Brian Welty To: cgroups@vger.kernel.org, Tejun Heo , Li Zefan , Johannes Weiner , linux-mm@kvack.org, Michal Hocko , Vladimir Davydov , dri-devel@lists.freedesktop.org, David Airlie , Daniel Vetter , intel-gfx@lists.freedesktop.org, Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , =?UTF-8?q?Christian=20K=C3=B6nig?= , Alex Deucher , ChunMing Zhou , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= Subject: [RFC PATCH 3/5] memcg: Add per-device support to memory cgroup subsystem Date: Wed, 1 May 2019 10:04:36 -0400 Message-Id: <20190501140438.9506-4-brian.welty@intel.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190501140438.9506-1-brian.welty@intel.com> References: <20190501140438.9506-1-brian.welty@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: Here we update memory cgroup to enable the newly introduced per-device framework. As mentioned in the prior patch, the intent here is to allow drivers to have their own private cgroup controls (such as memory limit) to be applied to device resources instead of host system resources. In summary, to enable device registration for memory cgroup subsystem: * set .allow_devices to true * add new exported device register and device unregister functions to register a device with the cgroup subsystem * implement the .device_css_alloc callback to create device specific cgroups_subsys_state within a cgroup As cgroup is created and for current registered devices, one will see in the cgroup filesystem these additional files: mount//memory.devices// Registration of a new device is performed in device drivers using new mem_cgroup_device_register(). This will create above files in existing cgroups. And for runtime charging to the cgroup, we add the following: * add new routine to lookup the device-specific cgroup_subsys_state which is within the task's cgroup (mem_cgroup_device_from_task) * add new functions for device specific 'direct' charging The last point above involves adding new mem_cgroup_try_charge_direct and mem_cgroup_uncharge_direct functions. The 'direct' name is to say that we are charging the specified cgroup state directly and not using any associated page or mm_struct. We are called within device specific memory management routines, where the device driver will track which cgroup to charge within its own private data structures. With this initial submission, support for memory accounting and charging is functional. Nested cgroups will correctly maintain the parent for device-specific state as well, such that hierarchial charging to device files is supported. Cc: cgroups@vger.kernel.org Cc: linux-mm@kvack.org Cc: dri-devel@lists.freedesktop.org Cc: Matt Roper Signed-off-by: Brian Welty --- include/linux/memcontrol.h | 10 ++ mm/memcontrol.c | 183 ++++++++++++++++++++++++++++++++++--- 2 files changed, 178 insertions(+), 15 deletions(-) diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index dbb6118370c1..711669b613dc 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -348,6 +348,11 @@ void mem_cgroup_cancel_charge(struct page *page, struct mem_cgroup *memcg, bool compound); void mem_cgroup_uncharge(struct page *page); void mem_cgroup_uncharge_list(struct list_head *page_list); +/* direct charging to mem_cgroup is primarily for device driver usage */ +int mem_cgroup_try_charge_direct(struct mem_cgroup *memcg, + unsigned long nr_pages); +void mem_cgroup_uncharge_direct(struct mem_cgroup *memcg, + unsigned long nr_pages); void mem_cgroup_migrate(struct page *oldpage, struct page *newpage); @@ -395,6 +400,11 @@ struct lruvec *mem_cgroup_page_lruvec(struct page *, struct pglist_data *); bool task_in_mem_cgroup(struct task_struct *task, struct mem_cgroup *memcg); struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p); +struct mem_cgroup *mem_cgroup_device_from_task(unsigned long id, + struct task_struct *p); +int mem_cgroup_device_register(struct device *dev, unsigned long *dev_id); +void mem_cgroup_device_unregister(unsigned long dev_id); + struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm); struct mem_cgroup *get_mem_cgroup_from_page(struct page *page); diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 81a0d3914ec9..2c8407aed0f5 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -823,6 +823,47 @@ struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p) } EXPORT_SYMBOL(mem_cgroup_from_task); +int mem_cgroup_device_register(struct device *dev, unsigned long *dev_id) +{ + return cgroup_device_register(&memory_cgrp_subsys, dev, dev_id); +} +EXPORT_SYMBOL(mem_cgroup_device_register); + +void mem_cgroup_device_unregister(unsigned long dev_id) +{ + cgroup_device_unregister(&memory_cgrp_subsys, dev_id); +} +EXPORT_SYMBOL(mem_cgroup_device_unregister); + +/** + * mem_cgroup_device_from_task: Lookup device-specific memcg + * @id: device-specific id returned from mem_cgroup_device_register + * @p: task to lookup the memcg + * + * First use mem_cgroup_from_task to lookup and obtain a reference on + * the memcg associated with this task @p. Within this memcg, find the + * device-specific one associated with @id. + * However if mem_cgroup is disabled, NULL is returned. + */ +struct mem_cgroup *mem_cgroup_device_from_task(unsigned long id, + struct task_struct *p) +{ + struct mem_cgroup *memcg; + struct mem_cgroup *dev_memcg = NULL; + + if (mem_cgroup_disabled()) + return NULL; + + rcu_read_lock(); + memcg = mem_cgroup_from_task(p); + if (memcg) + dev_memcg = idr_find(&memcg->css.device_css_idr, id); + rcu_read_unlock(); + + return dev_memcg; +} +EXPORT_SYMBOL(mem_cgroup_device_from_task); + /** * get_mem_cgroup_from_mm: Obtain a reference on given mm_struct's memcg. * @mm: mm from which memcg should be extracted. It can be NULL. @@ -2179,13 +2220,31 @@ void mem_cgroup_handle_over_high(void) current->memcg_nr_pages_over_high = 0; } +static bool __try_charge(struct mem_cgroup *memcg, unsigned int nr_pages, + struct mem_cgroup **mem_over_limit) +{ + struct page_counter *counter; + + if (!do_memsw_account() || + page_counter_try_charge(&memcg->memsw, nr_pages, &counter)) { + if (page_counter_try_charge(&memcg->memory, nr_pages, &counter)) + return true; + if (do_memsw_account()) + page_counter_uncharge(&memcg->memsw, nr_pages); + *mem_over_limit = mem_cgroup_from_counter(counter, memory); + } else { + *mem_over_limit = mem_cgroup_from_counter(counter, memsw); + } + + return false; +} + static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask, unsigned int nr_pages) { unsigned int batch = max(MEMCG_CHARGE_BATCH, nr_pages); int nr_retries = MEM_CGROUP_RECLAIM_RETRIES; struct mem_cgroup *mem_over_limit; - struct page_counter *counter; unsigned long nr_reclaimed; bool may_swap = true; bool drained = false; @@ -2198,17 +2257,10 @@ static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask, if (consume_stock(memcg, nr_pages)) return 0; - if (!do_memsw_account() || - page_counter_try_charge(&memcg->memsw, batch, &counter)) { - if (page_counter_try_charge(&memcg->memory, batch, &counter)) - goto done_restock; - if (do_memsw_account()) - page_counter_uncharge(&memcg->memsw, batch); - mem_over_limit = mem_cgroup_from_counter(counter, memory); - } else { - mem_over_limit = mem_cgroup_from_counter(counter, memsw); - may_swap = false; - } + if (__try_charge(memcg, batch, &mem_over_limit)) + goto done_restock; + else + may_swap = !do_memsw_account(); if (batch > nr_pages) { batch = nr_pages; @@ -2892,6 +2944,9 @@ static int mem_cgroup_force_empty(struct mem_cgroup *memcg) { int nr_retries = MEM_CGROUP_RECLAIM_RETRIES; + if (memcg->css.device) + return 0; + /* we call try-to-free pages for make this cgroup empty */ lru_add_drain_all(); @@ -4496,7 +4551,7 @@ static struct mem_cgroup *mem_cgroup_alloc(void) } static struct cgroup_subsys_state * __ref -mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css) +__mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css, bool is_device) { struct mem_cgroup *parent = mem_cgroup_from_css(parent_css); struct mem_cgroup *memcg; @@ -4530,11 +4585,13 @@ mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css) * much sense so let cgroup subsystem know about this * unfortunate state in our controller. */ - if (parent != root_mem_cgroup) + if (!is_device && parent != root_mem_cgroup) memory_cgrp_subsys.broken_hierarchy = true; } - /* The following stuff does not apply to the root */ + /* The following stuff does not apply to devices or the root */ + if (is_device) + return &memcg->css; if (!parent) { root_mem_cgroup = memcg; return &memcg->css; @@ -4554,6 +4611,34 @@ mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css) return ERR_PTR(-ENOMEM); } +static struct cgroup_subsys_state * __ref +mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css) +{ + return __mem_cgroup_css_alloc(parent_css, false); +} + +/* + * For given @cgroup_css, we create and return new device-specific css. + * + * @device and @cgroup_css are unused here, but they are provided as other + * cgroup subsystems might require them. + */ +static struct cgroup_subsys_state * __ref +mem_cgroup_device_css_alloc(struct device *device, + struct cgroup_subsys_state *cgroup_css, + struct cgroup_subsys_state *parent_device_css) +{ + /* + * For hierarchial page counters to work correctly, we specify + * parent here as the device-specific css from our parent css + * (@parent_device_css). In other words, for nested cgroups, + * the device-specific charging structures are also nested. + * Note, caller will itself set .device and .parent in returned + * structure. + */ + return __mem_cgroup_css_alloc(parent_device_css, true); +} + static int mem_cgroup_css_online(struct cgroup_subsys_state *css) { struct mem_cgroup *memcg = mem_cgroup_from_css(css); @@ -4613,6 +4698,9 @@ static void mem_cgroup_css_free(struct cgroup_subsys_state *css) { struct mem_cgroup *memcg = mem_cgroup_from_css(css); + if (css->device) + goto free_cgrp; + if (cgroup_subsys_on_dfl(memory_cgrp_subsys) && !cgroup_memory_nosocket) static_branch_dec(&memcg_sockets_enabled_key); @@ -4624,6 +4712,7 @@ static void mem_cgroup_css_free(struct cgroup_subsys_state *css) mem_cgroup_remove_from_trees(memcg); memcg_free_shrinker_maps(memcg); memcg_free_kmem(memcg); +free_cgrp: mem_cgroup_free(memcg); } @@ -5720,6 +5809,7 @@ static struct cftype memory_files[] = { struct cgroup_subsys memory_cgrp_subsys = { .css_alloc = mem_cgroup_css_alloc, + .device_css_alloc = mem_cgroup_device_css_alloc, .css_online = mem_cgroup_css_online, .css_offline = mem_cgroup_css_offline, .css_released = mem_cgroup_css_released, @@ -5732,6 +5822,7 @@ struct cgroup_subsys memory_cgrp_subsys = { .dfl_cftypes = memory_files, .legacy_cftypes = mem_cgroup_legacy_files, .early_init = 0, + .allow_devices = true, }; /** @@ -6031,6 +6122,68 @@ void mem_cgroup_cancel_charge(struct page *page, struct mem_cgroup *memcg, cancel_charge(memcg, nr_pages); } +/** + * mem_cgroup_try_charge_direct - try charging nr_pages to memcg + * @memcg: memcgto charge + * @nr_pages: number of pages to charge + * + * Try to charge @nr_pages to specified @memcg. This variant is intended + * where the memcg is known and can be directly charged, with the primary + * use case being in device drivers that have registered with the subsys. + * Device drivers that implement their own device-specific memory manager + * will use these direct charging functions to make charges against their + * device-private state (@memcg) within the cgroup. + * + * There is no separate mem_cgroup_commit_charge() in this use case, as the + * device driver is not using page structs. Reclaim is not needed internally + * here, as the caller can decide to attempt memory reclaim on error. + * + * Returns 0 on success. Otherwise, an error code is returned. + * + * To uncharge (or cancel charge), call mem_cgroup_uncharge_direct(). + */ +int mem_cgroup_try_charge_direct(struct mem_cgroup *memcg, + unsigned long nr_pages) +{ + struct mem_cgroup *mem_over_limit; + int ret = 0; + + if (!memcg || mem_cgroup_disabled() || mem_cgroup_is_root(memcg)) + return 0; + + if (__try_charge(memcg, nr_pages, &mem_over_limit)) { + css_get_many(&memcg->css, nr_pages); + } else { + memcg_memory_event(mem_over_limit, MEMCG_MAX); + ret = -ENOMEM; + } + return ret; +} +EXPORT_SYMBOL(mem_cgroup_try_charge_direct); + +/** + * mem_cgroup_uncharge_direct - uncharge nr_pages to memcg + * @memcg: memcg to charge + * @nr_pages: number of pages to charge + * + * Uncharge @nr_pages to specified @memcg. This variant is intended + * where the memcg is known and can directly uncharge, with the primary + * use case being in device drivers that have registered with the subsys. + * Device drivers use these direct charging functions to make charges + * against their device-private state (@memcg) within the cgroup. + * + * Returns 0 on success. Otherwise, an error code is returned. + */ +void mem_cgroup_uncharge_direct(struct mem_cgroup *memcg, + unsigned long nr_pages) +{ + if (!memcg || mem_cgroup_disabled()) + return; + + cancel_charge(memcg, nr_pages); +} +EXPORT_SYMBOL(mem_cgroup_uncharge_direct); + struct uncharge_gather { struct mem_cgroup *memcg; unsigned long pgpgout; -- 2.21.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Brian Welty Subject: [RFC PATCH 3/5] memcg: Add per-device support to memory cgroup subsystem Date: Wed, 1 May 2019 10:04:36 -0400 Message-ID: <20190501140438.9506-4-brian.welty@intel.com> References: <20190501140438.9506-1-brian.welty@intel.com> Mime-Version: 1.0 Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190501140438.9506-1-brian.welty@intel.com> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Content-Type: text/plain; charset="us-ascii" To: cgroups@vger.kernel.org, Tejun Heo , Li Zefan , Johannes Weiner , linux-mm@kvack.org, Michal Hocko , Vladimir Davydov , dri-devel@lists.freedesktop.org, David Airlie , Daniel Vetter , intel-gfx@lists.freedesktop.org, Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , =?UTF-8?q?Christian=20K=C3=B6nig?= , Alex Deucher , ChunMing Zhou , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= SGVyZSB3ZSB1cGRhdGUgbWVtb3J5IGNncm91cCB0byBlbmFibGUgdGhlIG5ld2x5IGludHJvZHVj ZWQgcGVyLWRldmljZQpmcmFtZXdvcmsuICBBcyBtZW50aW9uZWQgaW4gdGhlIHByaW9yIHBhdGNo LCB0aGUgaW50ZW50IGhlcmUgaXMgdG8gYWxsb3cKZHJpdmVycyB0byBoYXZlIHRoZWlyIG93biBw cml2YXRlIGNncm91cCBjb250cm9scyAoc3VjaCBhcyBtZW1vcnkgbGltaXQpCnRvIGJlIGFwcGxp ZWQgdG8gZGV2aWNlIHJlc291cmNlcyBpbnN0ZWFkIG9mIGhvc3Qgc3lzdGVtIHJlc291cmNlcy4K CkluIHN1bW1hcnksIHRvIGVuYWJsZSBkZXZpY2UgcmVnaXN0cmF0aW9uIGZvciBtZW1vcnkgY2dy b3VwIHN1YnN5c3RlbToKICAqICBzZXQgLmFsbG93X2RldmljZXMgdG8gdHJ1ZQogICogIGFkZCBu ZXcgZXhwb3J0ZWQgZGV2aWNlIHJlZ2lzdGVyIGFuZCBkZXZpY2UgdW5yZWdpc3RlciBmdW5jdGlv bnMKICAgICB0byByZWdpc3RlciBhIGRldmljZSB3aXRoIHRoZSBjZ3JvdXAgc3Vic3lzdGVtCiAg KiAgaW1wbGVtZW50IHRoZSAuZGV2aWNlX2Nzc19hbGxvYyBjYWxsYmFjayB0byBjcmVhdGUgZGV2 aWNlCiAgICAgc3BlY2lmaWMgY2dyb3Vwc19zdWJzeXNfc3RhdGUgd2l0aGluIGEgY2dyb3VwCgpB cyBjZ3JvdXAgaXMgY3JlYXRlZCBhbmQgZm9yIGN1cnJlbnQgcmVnaXN0ZXJlZCBkZXZpY2VzLCBv bmUgd2lsbCBzZWUgaW4KdGhlIGNncm91cCBmaWxlc3lzdGVtIHRoZXNlIGFkZGl0aW9uYWwgZmls ZXM6CiAgbW91bnQvPGNncm91cF9uYW1lPi9tZW1vcnkuZGV2aWNlcy88ZGV2X25hbWU+LzxtZW1f Y2dycCBhdHRyaWJ1dGVzPgoKUmVnaXN0cmF0aW9uIG9mIGEgbmV3IGRldmljZSBpcyBwZXJmb3Jt ZWQgaW4gZGV2aWNlIGRyaXZlcnMgdXNpbmcgbmV3Cm1lbV9jZ3JvdXBfZGV2aWNlX3JlZ2lzdGVy KCkuIFRoaXMgd2lsbCBjcmVhdGUgYWJvdmUgZmlsZXMgaW4gZXhpc3RpbmcKY2dyb3Vwcy4KCkFu ZCBmb3IgcnVudGltZSBjaGFyZ2luZyB0byB0aGUgY2dyb3VwLCB3ZSBhZGQgdGhlIGZvbGxvd2lu ZzoKICAqICBhZGQgbmV3IHJvdXRpbmUgdG8gbG9va3VwIHRoZSBkZXZpY2Utc3BlY2lmaWMgY2dy b3VwX3N1YnN5c19zdGF0ZQogICAgIHdoaWNoIGlzIHdpdGhpbiB0aGUgdGFzaydzIGNncm91cCAo bWVtX2Nncm91cF9kZXZpY2VfZnJvbV90YXNrKQogICogIGFkZCBuZXcgZnVuY3Rpb25zIGZvciBk ZXZpY2Ugc3BlY2lmaWMgJ2RpcmVjdCcgY2hhcmdpbmcKClRoZSBsYXN0IHBvaW50IGFib3ZlIGlu dm9sdmVzIGFkZGluZyBuZXcgbWVtX2Nncm91cF90cnlfY2hhcmdlX2RpcmVjdAphbmQgbWVtX2Nn cm91cF91bmNoYXJnZV9kaXJlY3QgZnVuY3Rpb25zLiAgVGhlICdkaXJlY3QnIG5hbWUgaXMgdG8g c2F5CnRoYXQgd2UgYXJlIGNoYXJnaW5nIHRoZSBzcGVjaWZpZWQgY2dyb3VwIHN0YXRlIGRpcmVj dGx5IGFuZCBub3QgdXNpbmcKYW55IGFzc29jaWF0ZWQgcGFnZSBvciBtbV9zdHJ1Y3QuICBXZSBh cmUgY2FsbGVkIHdpdGhpbiBkZXZpY2Ugc3BlY2lmaWMKbWVtb3J5IG1hbmFnZW1lbnQgcm91dGlu ZXMsIHdoZXJlIHRoZSBkZXZpY2UgZHJpdmVyIHdpbGwgdHJhY2sgd2hpY2gKY2dyb3VwIHRvIGNo YXJnZSB3aXRoaW4gaXRzIG93biBwcml2YXRlIGRhdGEgc3RydWN0dXJlcy4KCldpdGggdGhpcyBp bml0aWFsIHN1Ym1pc3Npb24sIHN1cHBvcnQgZm9yIG1lbW9yeSBhY2NvdW50aW5nIGFuZCBjaGFy Z2luZwppcyBmdW5jdGlvbmFsLiAgTmVzdGVkIGNncm91cHMgd2lsbCBjb3JyZWN0bHkgbWFpbnRh aW4gdGhlIHBhcmVudCBmb3IKZGV2aWNlLXNwZWNpZmljIHN0YXRlIGFzIHdlbGwsIHN1Y2ggdGhh dCBoaWVyYXJjaGlhbCBjaGFyZ2luZyB0byBkZXZpY2UKZmlsZXMgaXMgc3VwcG9ydGVkLgoKQ2M6 IGNncm91cHNAdmdlci5rZXJuZWwub3JnCkNjOiBsaW51eC1tbUBrdmFjay5vcmcKQ2M6IGRyaS1k ZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKQ2M6IE1hdHQgUm9wZXIgPG1hdHRoZXcuZC5yb3Bl ckBpbnRlbC5jb20+ClNpZ25lZC1vZmYtYnk6IEJyaWFuIFdlbHR5IDxicmlhbi53ZWx0eUBpbnRl bC5jb20+Ci0tLQogaW5jbHVkZS9saW51eC9tZW1jb250cm9sLmggfCAgMTAgKysKIG1tL21lbWNv bnRyb2wuYyAgICAgICAgICAgIHwgMTgzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KystLS0KIDIgZmlsZXMgY2hhbmdlZCwgMTc4IGluc2VydGlvbnMoKyksIDE1IGRlbGV0aW9ucygt KQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWVtY29udHJvbC5oIGIvaW5jbHVkZS9saW51 eC9tZW1jb250cm9sLmgKaW5kZXggZGJiNjExODM3MGMxLi43MTE2NjliNjEzZGMgMTAwNjQ0Ci0t LSBhL2luY2x1ZGUvbGludXgvbWVtY29udHJvbC5oCisrKyBiL2luY2x1ZGUvbGludXgvbWVtY29u dHJvbC5oCkBAIC0zNDgsNiArMzQ4LDExIEBAIHZvaWQgbWVtX2Nncm91cF9jYW5jZWxfY2hhcmdl KHN0cnVjdCBwYWdlICpwYWdlLCBzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2csCiAJCWJvb2wgY29t cG91bmQpOwogdm9pZCBtZW1fY2dyb3VwX3VuY2hhcmdlKHN0cnVjdCBwYWdlICpwYWdlKTsKIHZv aWQgbWVtX2Nncm91cF91bmNoYXJnZV9saXN0KHN0cnVjdCBsaXN0X2hlYWQgKnBhZ2VfbGlzdCk7 CisvKiBkaXJlY3QgY2hhcmdpbmcgdG8gbWVtX2Nncm91cCBpcyBwcmltYXJpbHkgZm9yIGRldmlj ZSBkcml2ZXIgdXNhZ2UgKi8KK2ludCBtZW1fY2dyb3VwX3RyeV9jaGFyZ2VfZGlyZWN0KHN0cnVj dCBtZW1fY2dyb3VwICptZW1jZywKKwkJCQkgdW5zaWduZWQgbG9uZyBucl9wYWdlcyk7Cit2b2lk IG1lbV9jZ3JvdXBfdW5jaGFyZ2VfZGlyZWN0KHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZywKKwkJ CQl1bnNpZ25lZCBsb25nIG5yX3BhZ2VzKTsKIAogdm9pZCBtZW1fY2dyb3VwX21pZ3JhdGUoc3Ry dWN0IHBhZ2UgKm9sZHBhZ2UsIHN0cnVjdCBwYWdlICpuZXdwYWdlKTsKIApAQCAtMzk1LDYgKzQw MCwxMSBAQCBzdHJ1Y3QgbHJ1dmVjICptZW1fY2dyb3VwX3BhZ2VfbHJ1dmVjKHN0cnVjdCBwYWdl ICosIHN0cnVjdCBwZ2xpc3RfZGF0YSAqKTsKIGJvb2wgdGFza19pbl9tZW1fY2dyb3VwKHN0cnVj dCB0YXNrX3N0cnVjdCAqdGFzaywgc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnKTsKIHN0cnVjdCBt ZW1fY2dyb3VwICptZW1fY2dyb3VwX2Zyb21fdGFzayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApOwog CitzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtX2Nncm91cF9kZXZpY2VfZnJvbV90YXNrKHVuc2lnbmVk IGxvbmcgaWQsCisJCQkJCSAgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApOworaW50IG1lbV9j Z3JvdXBfZGV2aWNlX3JlZ2lzdGVyKHN0cnVjdCBkZXZpY2UgKmRldiwgdW5zaWduZWQgbG9uZyAq ZGV2X2lkKTsKK3ZvaWQgbWVtX2Nncm91cF9kZXZpY2VfdW5yZWdpc3Rlcih1bnNpZ25lZCBsb25n IGRldl9pZCk7CisKIHN0cnVjdCBtZW1fY2dyb3VwICpnZXRfbWVtX2Nncm91cF9mcm9tX21tKHN0 cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKIAogc3RydWN0IG1lbV9jZ3JvdXAgKmdldF9tZW1fY2dyb3Vw X2Zyb21fcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSk7CmRpZmYgLS1naXQgYS9tbS9tZW1jb250cm9s LmMgYi9tbS9tZW1jb250cm9sLmMKaW5kZXggODFhMGQzOTE0ZWM5Li4yYzg0MDdhZWQwZjUgMTAw NjQ0Ci0tLSBhL21tL21lbWNvbnRyb2wuYworKysgYi9tbS9tZW1jb250cm9sLmMKQEAgLTgyMyw2 ICs4MjMsNDcgQEAgc3RydWN0IG1lbV9jZ3JvdXAgKm1lbV9jZ3JvdXBfZnJvbV90YXNrKHN0cnVj dCB0YXNrX3N0cnVjdCAqcCkKIH0KIEVYUE9SVF9TWU1CT0wobWVtX2Nncm91cF9mcm9tX3Rhc2sp OwogCitpbnQgbWVtX2Nncm91cF9kZXZpY2VfcmVnaXN0ZXIoc3RydWN0IGRldmljZSAqZGV2LCB1 bnNpZ25lZCBsb25nICpkZXZfaWQpCit7CisJcmV0dXJuIGNncm91cF9kZXZpY2VfcmVnaXN0ZXIo Jm1lbW9yeV9jZ3JwX3N1YnN5cywgZGV2LCBkZXZfaWQpOworfQorRVhQT1JUX1NZTUJPTChtZW1f Y2dyb3VwX2RldmljZV9yZWdpc3Rlcik7CisKK3ZvaWQgbWVtX2Nncm91cF9kZXZpY2VfdW5yZWdp c3Rlcih1bnNpZ25lZCBsb25nIGRldl9pZCkKK3sKKwljZ3JvdXBfZGV2aWNlX3VucmVnaXN0ZXIo Jm1lbW9yeV9jZ3JwX3N1YnN5cywgZGV2X2lkKTsKK30KK0VYUE9SVF9TWU1CT0wobWVtX2Nncm91 cF9kZXZpY2VfdW5yZWdpc3Rlcik7CisKKy8qKgorICogbWVtX2Nncm91cF9kZXZpY2VfZnJvbV90 YXNrOiBMb29rdXAgZGV2aWNlLXNwZWNpZmljIG1lbWNnCisgKiBAaWQ6IGRldmljZS1zcGVjaWZp YyBpZCByZXR1cm5lZCBmcm9tIG1lbV9jZ3JvdXBfZGV2aWNlX3JlZ2lzdGVyCisgKiBAcDogdGFz ayB0byBsb29rdXAgdGhlIG1lbWNnCisgKgorICogRmlyc3QgdXNlIG1lbV9jZ3JvdXBfZnJvbV90 YXNrIHRvIGxvb2t1cCBhbmQgb2J0YWluIGEgcmVmZXJlbmNlIG9uCisgKiB0aGUgbWVtY2cgYXNz b2NpYXRlZCB3aXRoIHRoaXMgdGFzayBAcC4gIFdpdGhpbiB0aGlzIG1lbWNnLCBmaW5kIHRoZQor ICogZGV2aWNlLXNwZWNpZmljIG9uZSBhc3NvY2lhdGVkIHdpdGggQGlkLgorICogSG93ZXZlciBp ZiBtZW1fY2dyb3VwIGlzIGRpc2FibGVkLCBOVUxMIGlzIHJldHVybmVkLgorICovCitzdHJ1Y3Qg bWVtX2Nncm91cCAqbWVtX2Nncm91cF9kZXZpY2VfZnJvbV90YXNrKHVuc2lnbmVkIGxvbmcgaWQs CisJCQkJCSAgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApCit7CisJc3RydWN0IG1lbV9jZ3Jv dXAgKm1lbWNnOworCXN0cnVjdCBtZW1fY2dyb3VwICpkZXZfbWVtY2cgPSBOVUxMOworCisJaWYg KG1lbV9jZ3JvdXBfZGlzYWJsZWQoKSkKKwkJcmV0dXJuIE5VTEw7CisKKwlyY3VfcmVhZF9sb2Nr KCk7CisJbWVtY2cgID0gbWVtX2Nncm91cF9mcm9tX3Rhc2socCk7CisJaWYgKG1lbWNnKQorCQlk ZXZfbWVtY2cgPSBpZHJfZmluZCgmbWVtY2ctPmNzcy5kZXZpY2VfY3NzX2lkciwgaWQpOworCXJj dV9yZWFkX3VubG9jaygpOworCisJcmV0dXJuIGRldl9tZW1jZzsKK30KK0VYUE9SVF9TWU1CT0wo bWVtX2Nncm91cF9kZXZpY2VfZnJvbV90YXNrKTsKKwogLyoqCiAgKiBnZXRfbWVtX2Nncm91cF9m cm9tX21tOiBPYnRhaW4gYSByZWZlcmVuY2Ugb24gZ2l2ZW4gbW1fc3RydWN0J3MgbWVtY2cuCiAg KiBAbW06IG1tIGZyb20gd2hpY2ggbWVtY2cgc2hvdWxkIGJlIGV4dHJhY3RlZC4gSXQgY2FuIGJl IE5VTEwuCkBAIC0yMTc5LDEzICsyMjIwLDMxIEBAIHZvaWQgbWVtX2Nncm91cF9oYW5kbGVfb3Zl cl9oaWdoKHZvaWQpCiAJY3VycmVudC0+bWVtY2dfbnJfcGFnZXNfb3Zlcl9oaWdoID0gMDsKIH0K IAorc3RhdGljIGJvb2wgX190cnlfY2hhcmdlKHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZywgdW5z aWduZWQgaW50IG5yX3BhZ2VzLAorCQkJIHN0cnVjdCBtZW1fY2dyb3VwICoqbWVtX292ZXJfbGlt aXQpCit7CisJc3RydWN0IHBhZ2VfY291bnRlciAqY291bnRlcjsKKworCWlmICghZG9fbWVtc3df YWNjb3VudCgpIHx8CisJICAgIHBhZ2VfY291bnRlcl90cnlfY2hhcmdlKCZtZW1jZy0+bWVtc3cs IG5yX3BhZ2VzLCAmY291bnRlcikpIHsKKwkJaWYgKHBhZ2VfY291bnRlcl90cnlfY2hhcmdlKCZt ZW1jZy0+bWVtb3J5LCBucl9wYWdlcywgJmNvdW50ZXIpKQorCQkJcmV0dXJuIHRydWU7CisJCWlm IChkb19tZW1zd19hY2NvdW50KCkpCisJCQlwYWdlX2NvdW50ZXJfdW5jaGFyZ2UoJm1lbWNnLT5t ZW1zdywgbnJfcGFnZXMpOworCQkqbWVtX292ZXJfbGltaXQgPSBtZW1fY2dyb3VwX2Zyb21fY291 bnRlcihjb3VudGVyLCBtZW1vcnkpOworCX0gZWxzZSB7CisJCSptZW1fb3Zlcl9saW1pdCA9IG1l bV9jZ3JvdXBfZnJvbV9jb3VudGVyKGNvdW50ZXIsIG1lbXN3KTsKKwl9CisKKwlyZXR1cm4gZmFs c2U7Cit9CisKIHN0YXRpYyBpbnQgdHJ5X2NoYXJnZShzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2cs IGdmcF90IGdmcF9tYXNrLAogCQkgICAgICB1bnNpZ25lZCBpbnQgbnJfcGFnZXMpCiB7CiAJdW5z aWduZWQgaW50IGJhdGNoID0gbWF4KE1FTUNHX0NIQVJHRV9CQVRDSCwgbnJfcGFnZXMpOwogCWlu dCBucl9yZXRyaWVzID0gTUVNX0NHUk9VUF9SRUNMQUlNX1JFVFJJRVM7CiAJc3RydWN0IG1lbV9j Z3JvdXAgKm1lbV9vdmVyX2xpbWl0OwotCXN0cnVjdCBwYWdlX2NvdW50ZXIgKmNvdW50ZXI7CiAJ dW5zaWduZWQgbG9uZyBucl9yZWNsYWltZWQ7CiAJYm9vbCBtYXlfc3dhcCA9IHRydWU7CiAJYm9v bCBkcmFpbmVkID0gZmFsc2U7CkBAIC0yMTk4LDE3ICsyMjU3LDEwIEBAIHN0YXRpYyBpbnQgdHJ5 X2NoYXJnZShzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2csIGdmcF90IGdmcF9tYXNrLAogCWlmIChj b25zdW1lX3N0b2NrKG1lbWNnLCBucl9wYWdlcykpCiAJCXJldHVybiAwOwogCi0JaWYgKCFkb19t ZW1zd19hY2NvdW50KCkgfHwKLQkgICAgcGFnZV9jb3VudGVyX3RyeV9jaGFyZ2UoJm1lbWNnLT5t ZW1zdywgYmF0Y2gsICZjb3VudGVyKSkgewotCQlpZiAocGFnZV9jb3VudGVyX3RyeV9jaGFyZ2Uo Jm1lbWNnLT5tZW1vcnksIGJhdGNoLCAmY291bnRlcikpCi0JCQlnb3RvIGRvbmVfcmVzdG9jazsK LQkJaWYgKGRvX21lbXN3X2FjY291bnQoKSkKLQkJCXBhZ2VfY291bnRlcl91bmNoYXJnZSgmbWVt Y2ctPm1lbXN3LCBiYXRjaCk7Ci0JCW1lbV9vdmVyX2xpbWl0ID0gbWVtX2Nncm91cF9mcm9tX2Nv dW50ZXIoY291bnRlciwgbWVtb3J5KTsKLQl9IGVsc2UgewotCQltZW1fb3Zlcl9saW1pdCA9IG1l bV9jZ3JvdXBfZnJvbV9jb3VudGVyKGNvdW50ZXIsIG1lbXN3KTsKLQkJbWF5X3N3YXAgPSBmYWxz ZTsKLQl9CisJaWYgKF9fdHJ5X2NoYXJnZShtZW1jZywgYmF0Y2gsICZtZW1fb3Zlcl9saW1pdCkp CisJCWdvdG8gZG9uZV9yZXN0b2NrOworCWVsc2UKKwkJbWF5X3N3YXAgPSAhZG9fbWVtc3dfYWNj b3VudCgpOwogCiAJaWYgKGJhdGNoID4gbnJfcGFnZXMpIHsKIAkJYmF0Y2ggPSBucl9wYWdlczsK QEAgLTI4OTIsNiArMjk0NCw5IEBAIHN0YXRpYyBpbnQgbWVtX2Nncm91cF9mb3JjZV9lbXB0eShz dHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2cpCiB7CiAJaW50IG5yX3JldHJpZXMgPSBNRU1fQ0dST1VQ X1JFQ0xBSU1fUkVUUklFUzsKIAorCWlmIChtZW1jZy0+Y3NzLmRldmljZSkKKwkJcmV0dXJuIDA7 CisKIAkvKiB3ZSBjYWxsIHRyeS10by1mcmVlIHBhZ2VzIGZvciBtYWtlIHRoaXMgY2dyb3VwIGVt cHR5ICovCiAJbHJ1X2FkZF9kcmFpbl9hbGwoKTsKIApAQCAtNDQ5Niw3ICs0NTUxLDcgQEAgc3Rh dGljIHN0cnVjdCBtZW1fY2dyb3VwICptZW1fY2dyb3VwX2FsbG9jKHZvaWQpCiB9CiAKIHN0YXRp YyBzdHJ1Y3QgY2dyb3VwX3N1YnN5c19zdGF0ZSAqIF9fcmVmCi1tZW1fY2dyb3VwX2Nzc19hbGxv YyhzdHJ1Y3QgY2dyb3VwX3N1YnN5c19zdGF0ZSAqcGFyZW50X2NzcykKK19fbWVtX2Nncm91cF9j c3NfYWxsb2Moc3RydWN0IGNncm91cF9zdWJzeXNfc3RhdGUgKnBhcmVudF9jc3MsIGJvb2wgaXNf ZGV2aWNlKQogewogCXN0cnVjdCBtZW1fY2dyb3VwICpwYXJlbnQgPSBtZW1fY2dyb3VwX2Zyb21f Y3NzKHBhcmVudF9jc3MpOwogCXN0cnVjdCBtZW1fY2dyb3VwICptZW1jZzsKQEAgLTQ1MzAsMTEg KzQ1ODUsMTMgQEAgbWVtX2Nncm91cF9jc3NfYWxsb2Moc3RydWN0IGNncm91cF9zdWJzeXNfc3Rh dGUgKnBhcmVudF9jc3MpCiAJCSAqIG11Y2ggc2Vuc2Ugc28gbGV0IGNncm91cCBzdWJzeXN0ZW0g a25vdyBhYm91dCB0aGlzCiAJCSAqIHVuZm9ydHVuYXRlIHN0YXRlIGluIG91ciBjb250cm9sbGVy LgogCQkgKi8KLQkJaWYgKHBhcmVudCAhPSByb290X21lbV9jZ3JvdXApCisJCWlmICghaXNfZGV2 aWNlICYmIHBhcmVudCAhPSByb290X21lbV9jZ3JvdXApCiAJCQltZW1vcnlfY2dycF9zdWJzeXMu YnJva2VuX2hpZXJhcmNoeSA9IHRydWU7CiAJfQogCi0JLyogVGhlIGZvbGxvd2luZyBzdHVmZiBk b2VzIG5vdCBhcHBseSB0byB0aGUgcm9vdCAqLworCS8qIFRoZSBmb2xsb3dpbmcgc3R1ZmYgZG9l cyBub3QgYXBwbHkgdG8gZGV2aWNlcyBvciB0aGUgcm9vdCAqLworCWlmIChpc19kZXZpY2UpCisJ CXJldHVybiAmbWVtY2ctPmNzczsKIAlpZiAoIXBhcmVudCkgewogCQlyb290X21lbV9jZ3JvdXAg PSBtZW1jZzsKIAkJcmV0dXJuICZtZW1jZy0+Y3NzOwpAQCAtNDU1NCw2ICs0NjExLDM0IEBAIG1l bV9jZ3JvdXBfY3NzX2FsbG9jKHN0cnVjdCBjZ3JvdXBfc3Vic3lzX3N0YXRlICpwYXJlbnRfY3Nz KQogCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwogfQogCitzdGF0aWMgc3RydWN0IGNncm91cF9z dWJzeXNfc3RhdGUgKiBfX3JlZgorbWVtX2Nncm91cF9jc3NfYWxsb2Moc3RydWN0IGNncm91cF9z dWJzeXNfc3RhdGUgKnBhcmVudF9jc3MpCit7CisJcmV0dXJuIF9fbWVtX2Nncm91cF9jc3NfYWxs b2MocGFyZW50X2NzcywgZmFsc2UpOworfQorCisvKgorICogRm9yIGdpdmVuIEBjZ3JvdXBfY3Nz LCB3ZSBjcmVhdGUgYW5kIHJldHVybiBuZXcgZGV2aWNlLXNwZWNpZmljIGNzcy4KKyAqCisgKiBA ZGV2aWNlIGFuZCBAY2dyb3VwX2NzcyBhcmUgdW51c2VkIGhlcmUsIGJ1dCB0aGV5IGFyZSBwcm92 aWRlZCBhcyBvdGhlcgorICogY2dyb3VwIHN1YnN5c3RlbXMgbWlnaHQgcmVxdWlyZSB0aGVtLgor ICovCitzdGF0aWMgc3RydWN0IGNncm91cF9zdWJzeXNfc3RhdGUgKiBfX3JlZgorbWVtX2Nncm91 cF9kZXZpY2VfY3NzX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRldmljZSwKKwkJCSAgICBzdHJ1Y3Qg Y2dyb3VwX3N1YnN5c19zdGF0ZSAqY2dyb3VwX2NzcywKKwkJCSAgICBzdHJ1Y3QgY2dyb3VwX3N1 YnN5c19zdGF0ZSAqcGFyZW50X2RldmljZV9jc3MpCit7CisJLyoKKwkgKiBGb3IgaGllcmFyY2hp YWwgcGFnZSBjb3VudGVycyB0byB3b3JrIGNvcnJlY3RseSwgd2Ugc3BlY2lmeQorCSAqIHBhcmVu dCBoZXJlIGFzIHRoZSBkZXZpY2Utc3BlY2lmaWMgY3NzIGZyb20gb3VyIHBhcmVudCBjc3MKKwkg KiAoQHBhcmVudF9kZXZpY2VfY3NzKS4gIEluIG90aGVyIHdvcmRzLCBmb3IgbmVzdGVkIGNncm91 cHMsCisJICogdGhlIGRldmljZS1zcGVjaWZpYyBjaGFyZ2luZyBzdHJ1Y3R1cmVzIGFyZSBhbHNv IG5lc3RlZC4KKwkgKiBOb3RlLCBjYWxsZXIgd2lsbCBpdHNlbGYgc2V0IC5kZXZpY2UgYW5kIC5w YXJlbnQgaW4gcmV0dXJuZWQKKwkgKiBzdHJ1Y3R1cmUuCisJICovCisJcmV0dXJuIF9fbWVtX2Nn cm91cF9jc3NfYWxsb2MocGFyZW50X2RldmljZV9jc3MsIHRydWUpOworfQorCiBzdGF0aWMgaW50 IG1lbV9jZ3JvdXBfY3NzX29ubGluZShzdHJ1Y3QgY2dyb3VwX3N1YnN5c19zdGF0ZSAqY3NzKQog ewogCXN0cnVjdCBtZW1fY2dyb3VwICptZW1jZyA9IG1lbV9jZ3JvdXBfZnJvbV9jc3MoY3NzKTsK QEAgLTQ2MTMsNiArNDY5OCw5IEBAIHN0YXRpYyB2b2lkIG1lbV9jZ3JvdXBfY3NzX2ZyZWUoc3Ry dWN0IGNncm91cF9zdWJzeXNfc3RhdGUgKmNzcykKIHsKIAlzdHJ1Y3QgbWVtX2Nncm91cCAqbWVt Y2cgPSBtZW1fY2dyb3VwX2Zyb21fY3NzKGNzcyk7CiAKKwlpZiAoY3NzLT5kZXZpY2UpCisJCWdv dG8gZnJlZV9jZ3JwOworCiAJaWYgKGNncm91cF9zdWJzeXNfb25fZGZsKG1lbW9yeV9jZ3JwX3N1 YnN5cykgJiYgIWNncm91cF9tZW1vcnlfbm9zb2NrZXQpCiAJCXN0YXRpY19icmFuY2hfZGVjKCZt ZW1jZ19zb2NrZXRzX2VuYWJsZWRfa2V5KTsKIApAQCAtNDYyNCw2ICs0NzEyLDcgQEAgc3RhdGlj IHZvaWQgbWVtX2Nncm91cF9jc3NfZnJlZShzdHJ1Y3QgY2dyb3VwX3N1YnN5c19zdGF0ZSAqY3Nz KQogCW1lbV9jZ3JvdXBfcmVtb3ZlX2Zyb21fdHJlZXMobWVtY2cpOwogCW1lbWNnX2ZyZWVfc2hy aW5rZXJfbWFwcyhtZW1jZyk7CiAJbWVtY2dfZnJlZV9rbWVtKG1lbWNnKTsKK2ZyZWVfY2dycDoK IAltZW1fY2dyb3VwX2ZyZWUobWVtY2cpOwogfQogCkBAIC01NzIwLDYgKzU4MDksNyBAQCBzdGF0 aWMgc3RydWN0IGNmdHlwZSBtZW1vcnlfZmlsZXNbXSA9IHsKIAogc3RydWN0IGNncm91cF9zdWJz eXMgbWVtb3J5X2NncnBfc3Vic3lzID0gewogCS5jc3NfYWxsb2MgPSBtZW1fY2dyb3VwX2Nzc19h bGxvYywKKwkuZGV2aWNlX2Nzc19hbGxvYyA9IG1lbV9jZ3JvdXBfZGV2aWNlX2Nzc19hbGxvYywK IAkuY3NzX29ubGluZSA9IG1lbV9jZ3JvdXBfY3NzX29ubGluZSwKIAkuY3NzX29mZmxpbmUgPSBt ZW1fY2dyb3VwX2Nzc19vZmZsaW5lLAogCS5jc3NfcmVsZWFzZWQgPSBtZW1fY2dyb3VwX2Nzc19y ZWxlYXNlZCwKQEAgLTU3MzIsNiArNTgyMiw3IEBAIHN0cnVjdCBjZ3JvdXBfc3Vic3lzIG1lbW9y eV9jZ3JwX3N1YnN5cyA9IHsKIAkuZGZsX2NmdHlwZXMgPSBtZW1vcnlfZmlsZXMsCiAJLmxlZ2Fj eV9jZnR5cGVzID0gbWVtX2Nncm91cF9sZWdhY3lfZmlsZXMsCiAJLmVhcmx5X2luaXQgPSAwLAor CS5hbGxvd19kZXZpY2VzID0gdHJ1ZSwKIH07CiAKIC8qKgpAQCAtNjAzMSw2ICs2MTIyLDY4IEBA IHZvaWQgbWVtX2Nncm91cF9jYW5jZWxfY2hhcmdlKHN0cnVjdCBwYWdlICpwYWdlLCBzdHJ1Y3Qg bWVtX2Nncm91cCAqbWVtY2csCiAJY2FuY2VsX2NoYXJnZShtZW1jZywgbnJfcGFnZXMpOwogfQog CisvKioKKyAqIG1lbV9jZ3JvdXBfdHJ5X2NoYXJnZV9kaXJlY3QgLSB0cnkgY2hhcmdpbmcgbnJf cGFnZXMgdG8gbWVtY2cKKyAqIEBtZW1jZzogbWVtY2d0byBjaGFyZ2UKKyAqIEBucl9wYWdlczog bnVtYmVyIG9mIHBhZ2VzIHRvIGNoYXJnZQorICoKKyAqIFRyeSB0byBjaGFyZ2UgQG5yX3BhZ2Vz IHRvIHNwZWNpZmllZCBAbWVtY2cuIFRoaXMgdmFyaWFudCBpcyBpbnRlbmRlZAorICogd2hlcmUg dGhlIG1lbWNnIGlzIGtub3duIGFuZCBjYW4gYmUgZGlyZWN0bHkgY2hhcmdlZCwgd2l0aCB0aGUg cHJpbWFyeQorICogdXNlIGNhc2UgYmVpbmcgaW4gZGV2aWNlIGRyaXZlcnMgdGhhdCBoYXZlIHJl Z2lzdGVyZWQgd2l0aCB0aGUgc3Vic3lzLgorICogRGV2aWNlIGRyaXZlcnMgdGhhdCBpbXBsZW1l bnQgdGhlaXIgb3duIGRldmljZS1zcGVjaWZpYyBtZW1vcnkgbWFuYWdlcgorICogd2lsbCB1c2Ug dGhlc2UgZGlyZWN0IGNoYXJnaW5nIGZ1bmN0aW9ucyB0byBtYWtlIGNoYXJnZXMgYWdhaW5zdCB0 aGVpcgorICogZGV2aWNlLXByaXZhdGUgc3RhdGUgKEBtZW1jZykgd2l0aGluIHRoZSBjZ3JvdXAu CisgKgorICogVGhlcmUgaXMgbm8gc2VwYXJhdGUgbWVtX2Nncm91cF9jb21taXRfY2hhcmdlKCkg aW4gdGhpcyB1c2UgY2FzZSwgYXMgdGhlCisgKiBkZXZpY2UgZHJpdmVyIGlzIG5vdCB1c2luZyBw YWdlIHN0cnVjdHMuIFJlY2xhaW0gaXMgbm90IG5lZWRlZCBpbnRlcm5hbGx5CisgKiBoZXJlLCBh cyB0aGUgY2FsbGVyIGNhbiBkZWNpZGUgdG8gYXR0ZW1wdCBtZW1vcnkgcmVjbGFpbSBvbiBlcnJv ci4KKyAqCisgKiBSZXR1cm5zIDAgb24gc3VjY2Vzcy4gIE90aGVyd2lzZSwgYW4gZXJyb3IgY29k ZSBpcyByZXR1cm5lZC4KKyAqCisgKiBUbyB1bmNoYXJnZSAob3IgY2FuY2VsIGNoYXJnZSksIGNh bGwgbWVtX2Nncm91cF91bmNoYXJnZV9kaXJlY3QoKS4KKyAqLworaW50IG1lbV9jZ3JvdXBfdHJ5 X2NoYXJnZV9kaXJlY3Qoc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnLAorCQkJCSB1bnNpZ25lZCBs b25nIG5yX3BhZ2VzKQoreworCXN0cnVjdCBtZW1fY2dyb3VwICptZW1fb3Zlcl9saW1pdDsKKwlp bnQgcmV0ID0gMDsKKworCWlmICghbWVtY2cgfHwgbWVtX2Nncm91cF9kaXNhYmxlZCgpIHx8IG1l bV9jZ3JvdXBfaXNfcm9vdChtZW1jZykpCisJCXJldHVybiAwOworCisJaWYgKF9fdHJ5X2NoYXJn ZShtZW1jZywgbnJfcGFnZXMsICZtZW1fb3Zlcl9saW1pdCkpIHsKKwkJY3NzX2dldF9tYW55KCZt ZW1jZy0+Y3NzLCBucl9wYWdlcyk7CisJfSBlbHNlIHsKKwkJbWVtY2dfbWVtb3J5X2V2ZW50KG1l bV9vdmVyX2xpbWl0LCBNRU1DR19NQVgpOworCQlyZXQgPSAtRU5PTUVNOworCX0KKwlyZXR1cm4g cmV0OworfQorRVhQT1JUX1NZTUJPTChtZW1fY2dyb3VwX3RyeV9jaGFyZ2VfZGlyZWN0KTsKKwor LyoqCisgKiBtZW1fY2dyb3VwX3VuY2hhcmdlX2RpcmVjdCAtIHVuY2hhcmdlIG5yX3BhZ2VzIHRv IG1lbWNnCisgKiBAbWVtY2c6IG1lbWNnIHRvIGNoYXJnZQorICogQG5yX3BhZ2VzOiBudW1iZXIg b2YgcGFnZXMgdG8gY2hhcmdlCisgKgorICogVW5jaGFyZ2UgQG5yX3BhZ2VzIHRvIHNwZWNpZmll ZCBAbWVtY2cuIFRoaXMgdmFyaWFudCBpcyBpbnRlbmRlZAorICogd2hlcmUgdGhlIG1lbWNnIGlz IGtub3duIGFuZCBjYW4gZGlyZWN0bHkgdW5jaGFyZ2UsIHdpdGggdGhlIHByaW1hcnkKKyAqIHVz ZSBjYXNlIGJlaW5nIGluIGRldmljZSBkcml2ZXJzIHRoYXQgaGF2ZSByZWdpc3RlcmVkIHdpdGgg dGhlIHN1YnN5cy4KKyAqIERldmljZSBkcml2ZXJzIHVzZSB0aGVzZSBkaXJlY3QgY2hhcmdpbmcg ZnVuY3Rpb25zIHRvIG1ha2UgY2hhcmdlcworICogYWdhaW5zdCB0aGVpciBkZXZpY2UtcHJpdmF0 ZSBzdGF0ZSAoQG1lbWNnKSB3aXRoaW4gdGhlIGNncm91cC4KKyAqCisgKiBSZXR1cm5zIDAgb24g c3VjY2Vzcy4gIE90aGVyd2lzZSwgYW4gZXJyb3IgY29kZSBpcyByZXR1cm5lZC4KKyAqLwordm9p ZCBtZW1fY2dyb3VwX3VuY2hhcmdlX2RpcmVjdChzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2csCisJ CQkJdW5zaWduZWQgbG9uZyBucl9wYWdlcykKK3sKKwlpZiAoIW1lbWNnIHx8IG1lbV9jZ3JvdXBf ZGlzYWJsZWQoKSkKKwkJcmV0dXJuOworCisJY2FuY2VsX2NoYXJnZShtZW1jZywgbnJfcGFnZXMp OworfQorRVhQT1JUX1NZTUJPTChtZW1fY2dyb3VwX3VuY2hhcmdlX2RpcmVjdCk7CisKIHN0cnVj dCB1bmNoYXJnZV9nYXRoZXIgewogCXN0cnVjdCBtZW1fY2dyb3VwICptZW1jZzsKIAl1bnNpZ25l ZCBsb25nIHBncGdvdXQ7Ci0tIAoyLjIxLjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2RyaS1kZXZlbA==