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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A36E0C43219 for ; Wed, 9 Mar 2022 02:13:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231421AbiCICOt (ORCPT ); Tue, 8 Mar 2022 21:14:49 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54226 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231358AbiCICO1 (ORCPT ); Tue, 8 Mar 2022 21:14:27 -0500 Received: from mail-yb1-xb4a.google.com (mail-yb1-xb4a.google.com [IPv6:2607:f8b0:4864:20::b4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 785F85F50 for ; Tue, 8 Mar 2022 18:13:28 -0800 (PST) Received: by mail-yb1-xb4a.google.com with SMTP id h8-20020a25e208000000b00628c0565607so723925ybe.0 for ; Tue, 08 Mar 2022 18:13:28 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc:content-transfer-encoding; bh=tbwoXRX83Ugtjl0wsQRtV4AtFgtOhQymRgtKRped+Rs=; b=pLFQa/wKjKqXgdsL9YiwrP0+4reCH1GcLyINgxZNtig9j/bjAVckpQsJyaBnor0YRw QT2Ac1pu6uKNK6dq3AxLwkoMtLj0ope4YAhwbD9RAur21DuvwwLjt5nL6WK8HOmcZRTW kQTvRZvoorV1jUVWyonAOg5ot2L0Njc/Quui+Rsm+QkO8SYd/XiXTXzITrf8pNeD7DKb Bs6YJ9Flc0XidjI+XVdANJ7OqaxegiDFx1i1VCkB6P2/hhXQPmI601dIZabsUqjvvqCD LcEIl3S7r7V0lxzmjq8nghaOflNK4aSlm1LUnxV/ehLldVyMdLzD1LprJE6zqKUPp0nv +QCQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc:content-transfer-encoding; bh=tbwoXRX83Ugtjl0wsQRtV4AtFgtOhQymRgtKRped+Rs=; b=tg+we6uiT1TE4M9mv6Nh/sTMl1hVA3/UrlyjyzDGuvLUg90vSNF81Orqj9zdDY1bTG ZlbkORAUbdI0AXJCgu8es0ZtPvQ9V6YgkaoiKESf5NY2iTLImcIRUqJKbqt/QZe7NK9V qKWXT5phBfDwNtuAlmdUnxf/FYrk6ahqpYeLgzAbNIke0WGAhsO8tfDgxt4LEfcO9/Z8 /jvQ1/TZ9fhdy4+UHHcuR98J4RTrVaOxTlrCC2GeKfM7a+tJ20eRGt4vW6sCkg9PWUs7 YL/Rd/c0tOJzmzJTLcjX0FZE1eh+p32AKjj8TJKrQ/1Ph8tQI9KW6wqzFE+uGZQ6o+5S NlsQ== X-Gm-Message-State: AOAM5317OIsoUfAGxRoEzn8WOfxeOzPiBbFmfoLrpe2TpY9s7bAu26Ut 7bmVHVgezmDUYxDJbuS0hZasiBqkPRA= X-Google-Smtp-Source: ABdhPJybwfKOM4+AVo0DqHtjLhmb1d5wOQcFRE4U5L8Mjs0RnbwQmHOxDglMablpfKjVYbJ0qFN8SFiMhLA= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:57a6:54a6:aad1:c0a8]) (user=yuzhao job=sendgmr) by 2002:a81:3617:0:b0:2dd:2c4f:2685 with SMTP id d23-20020a813617000000b002dd2c4f2685mr2781305ywa.107.1646792007540; Tue, 08 Mar 2022 18:13:27 -0800 (PST) Date: Tue, 8 Mar 2022 19:12:20 -0700 In-Reply-To: <20220309021230.721028-1-yuzhao@google.com> Message-Id: <20220309021230.721028-4-yuzhao@google.com> Mime-Version: 1.0 References: <20220309021230.721028-1-yuzhao@google.com> X-Mailer: git-send-email 2.35.1.616.g0bdcbb4464-goog Subject: [PATCH v9 03/14] mm/vmscan.c: refactor shrink_node() From: Yu Zhao To: Andrew Morton , Linus Torvalds Cc: Andi Kleen , Aneesh Kumar , Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Jesse Barnes , Johannes Weiner , Jonathan Corbet , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Rik van Riel , Vlastimil Babka , Will Deacon , Ying Huang , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, page-reclaim@google.com, x86@kernel.org, Yu Zhao , Brian Geffon , Jan Alexander Steffens , Oleksandr Natalenko , Steven Barrett , Suleiman Souhlal , Daniel Byrne , Donald Carr , "=?UTF-8?q?Holger=20Hoffst=C3=A4tte?=" , Konstantin Kharlamov , Shuang Zhai , Sofia Trinh , Vaibhav Jain Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch refactors shrink_node() to improve readability for the upcoming changes to mm/vmscan.c. Signed-off-by: Yu Zhao Acked-by: Brian Geffon Acked-by: Jan Alexander Steffens (heftig) Acked-by: Oleksandr Natalenko Acked-by: Steven Barrett Acked-by: Suleiman Souhlal Tested-by: Daniel Byrne Tested-by: Donald Carr Tested-by: Holger Hoffst=C3=A4tte Tested-by: Konstantin Kharlamov Tested-by: Shuang Zhai Tested-by: Sofia Trinh Tested-by: Vaibhav Jain --- mm/vmscan.c | 198 +++++++++++++++++++++++++++------------------------- 1 file changed, 104 insertions(+), 94 deletions(-) diff --git a/mm/vmscan.c b/mm/vmscan.c index 59b14e0d696c..8e744cdf802f 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -2718,6 +2718,109 @@ enum scan_balance { SCAN_FILE, }; =20 +static void prepare_scan_count(pg_data_t *pgdat, struct scan_control *sc) +{ + unsigned long file; + struct lruvec *target_lruvec; + + target_lruvec =3D mem_cgroup_lruvec(sc->target_mem_cgroup, pgdat); + + /* + * Flush the memory cgroup stats, so that we read accurate per-memcg + * lruvec stats for heuristics. + */ + mem_cgroup_flush_stats(); + + /* + * Determine the scan balance between anon and file LRUs. + */ + spin_lock_irq(&target_lruvec->lru_lock); + sc->anon_cost =3D target_lruvec->anon_cost; + sc->file_cost =3D target_lruvec->file_cost; + spin_unlock_irq(&target_lruvec->lru_lock); + + /* + * Target desirable inactive:active list ratios for the anon + * and file LRU lists. + */ + if (!sc->force_deactivate) { + unsigned long refaults; + + refaults =3D lruvec_page_state(target_lruvec, + WORKINGSET_ACTIVATE_ANON); + if (refaults !=3D target_lruvec->refaults[0] || + inactive_is_low(target_lruvec, LRU_INACTIVE_ANON)) + sc->may_deactivate |=3D DEACTIVATE_ANON; + else + sc->may_deactivate &=3D ~DEACTIVATE_ANON; + + /* + * When refaults are being observed, it means a new + * workingset is being established. Deactivate to get + * rid of any stale active pages quickly. + */ + refaults =3D lruvec_page_state(target_lruvec, + WORKINGSET_ACTIVATE_FILE); + if (refaults !=3D target_lruvec->refaults[1] || + inactive_is_low(target_lruvec, LRU_INACTIVE_FILE)) + sc->may_deactivate |=3D DEACTIVATE_FILE; + else + sc->may_deactivate &=3D ~DEACTIVATE_FILE; + } else + sc->may_deactivate =3D DEACTIVATE_ANON | DEACTIVATE_FILE; + + /* + * If we have plenty of inactive file pages that aren't + * thrashing, try to reclaim those first before touching + * anonymous pages. + */ + file =3D lruvec_page_state(target_lruvec, NR_INACTIVE_FILE); + if (file >> sc->priority && !(sc->may_deactivate & DEACTIVATE_FILE)) + sc->cache_trim_mode =3D 1; + else + sc->cache_trim_mode =3D 0; + + /* + * Prevent the reclaimer from falling into the cache trap: as + * cache pages start out inactive, every cache fault will tip + * the scan balance towards the file LRU. And as the file LRU + * shrinks, so does the window for rotation from references. + * This means we have a runaway feedback loop where a tiny + * thrashing file LRU becomes infinitely more attractive than + * anon pages. Try to detect this based on file LRU size. + */ + if (!cgroup_reclaim(sc)) { + unsigned long total_high_wmark =3D 0; + unsigned long free, anon; + int z; + + free =3D sum_zone_node_page_state(pgdat->node_id, NR_FREE_PAGES); + file =3D node_page_state(pgdat, NR_ACTIVE_FILE) + + node_page_state(pgdat, NR_INACTIVE_FILE); + + for (z =3D 0; z < MAX_NR_ZONES; z++) { + struct zone *zone =3D &pgdat->node_zones[z]; + + if (!managed_zone(zone)) + continue; + + total_high_wmark +=3D high_wmark_pages(zone); + } + + /* + * Consider anon: if that's low too, this isn't a + * runaway file reclaim problem, but rather just + * extreme pressure. Reclaim as per usual then. + */ + anon =3D node_page_state(pgdat, NR_INACTIVE_ANON); + + sc->file_is_tiny =3D + file + free <=3D total_high_wmark && + !(sc->may_deactivate & DEACTIVATE_ANON) && + anon >> sc->priority; + } +} + /* * Determine how aggressively the anon and file LRU lists should be * scanned. The relative value of each set of LRU lists is determined @@ -3188,109 +3291,16 @@ static void shrink_node(pg_data_t *pgdat, struct s= can_control *sc) unsigned long nr_reclaimed, nr_scanned; struct lruvec *target_lruvec; bool reclaimable =3D false; - unsigned long file; =20 target_lruvec =3D mem_cgroup_lruvec(sc->target_mem_cgroup, pgdat); =20 again: - /* - * Flush the memory cgroup stats, so that we read accurate per-memcg - * lruvec stats for heuristics. - */ - mem_cgroup_flush_stats(); - memset(&sc->nr, 0, sizeof(sc->nr)); =20 nr_reclaimed =3D sc->nr_reclaimed; nr_scanned =3D sc->nr_scanned; =20 - /* - * Determine the scan balance between anon and file LRUs. - */ - spin_lock_irq(&target_lruvec->lru_lock); - sc->anon_cost =3D target_lruvec->anon_cost; - sc->file_cost =3D target_lruvec->file_cost; - spin_unlock_irq(&target_lruvec->lru_lock); - - /* - * Target desirable inactive:active list ratios for the anon - * and file LRU lists. - */ - if (!sc->force_deactivate) { - unsigned long refaults; - - refaults =3D lruvec_page_state(target_lruvec, - WORKINGSET_ACTIVATE_ANON); - if (refaults !=3D target_lruvec->refaults[0] || - inactive_is_low(target_lruvec, LRU_INACTIVE_ANON)) - sc->may_deactivate |=3D DEACTIVATE_ANON; - else - sc->may_deactivate &=3D ~DEACTIVATE_ANON; - - /* - * When refaults are being observed, it means a new - * workingset is being established. Deactivate to get - * rid of any stale active pages quickly. - */ - refaults =3D lruvec_page_state(target_lruvec, - WORKINGSET_ACTIVATE_FILE); - if (refaults !=3D target_lruvec->refaults[1] || - inactive_is_low(target_lruvec, LRU_INACTIVE_FILE)) - sc->may_deactivate |=3D DEACTIVATE_FILE; - else - sc->may_deactivate &=3D ~DEACTIVATE_FILE; - } else - sc->may_deactivate =3D DEACTIVATE_ANON | DEACTIVATE_FILE; - - /* - * If we have plenty of inactive file pages that aren't - * thrashing, try to reclaim those first before touching - * anonymous pages. - */ - file =3D lruvec_page_state(target_lruvec, NR_INACTIVE_FILE); - if (file >> sc->priority && !(sc->may_deactivate & DEACTIVATE_FILE)) - sc->cache_trim_mode =3D 1; - else - sc->cache_trim_mode =3D 0; - - /* - * Prevent the reclaimer from falling into the cache trap: as - * cache pages start out inactive, every cache fault will tip - * the scan balance towards the file LRU. And as the file LRU - * shrinks, so does the window for rotation from references. - * This means we have a runaway feedback loop where a tiny - * thrashing file LRU becomes infinitely more attractive than - * anon pages. Try to detect this based on file LRU size. - */ - if (!cgroup_reclaim(sc)) { - unsigned long total_high_wmark =3D 0; - unsigned long free, anon; - int z; - - free =3D sum_zone_node_page_state(pgdat->node_id, NR_FREE_PAGES); - file =3D node_page_state(pgdat, NR_ACTIVE_FILE) + - node_page_state(pgdat, NR_INACTIVE_FILE); - - for (z =3D 0; z < MAX_NR_ZONES; z++) { - struct zone *zone =3D &pgdat->node_zones[z]; - if (!managed_zone(zone)) - continue; - - total_high_wmark +=3D high_wmark_pages(zone); - } - - /* - * Consider anon: if that's low too, this isn't a - * runaway file reclaim problem, but rather just - * extreme pressure. Reclaim as per usual then. - */ - anon =3D node_page_state(pgdat, NR_INACTIVE_ANON); - - sc->file_is_tiny =3D - file + free <=3D total_high_wmark && - !(sc->may_deactivate & DEACTIVATE_ANON) && - anon >> sc->priority; - } + prepare_scan_count(pgdat, sc); =20 shrink_node_memcgs(pgdat, sc); =20 --=20 2.35.1.616.g0bdcbb4464-goog 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 2A7BFC433EF for ; Wed, 9 Mar 2022 02:16:34 +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-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:From:Subject:References: Mime-Version:Message-Id:In-Reply-To:Date:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=XTuD3EhW3HY9otkmW1+X2VIcM/5lAhHyYJDMB3KRzgQ=; b=ADn5VcBY7hzIFRlLoNG2eixhRl 0hbCTvJK/q3jwjKMvT9Zlcz5Q1hl0KX3pz6vZ8vQK8RU9wwvcTvRjbvsc7q78hzkDcrJTJxZAQgBG k+FXvR3Yx+LQAcikCJAGQOgvXYZXlBzigtSb3jCFI/YGzrvGB5EUYMWjaSJaR00QL2WVY43v7kgkC w2bYQSrrjzJzhINgjYV5FNK846scEmnEAQXxW35lWkS6Gd01jriz9O3RnVlS486BqZSapUGsPPfEa p6cMY1gZojp9XRz9nc0UOIYSS5+OkRYvFPu+MQ3NnDUTFg9Oa45qtu26d1z0N2+pNfLGkGcjeNct2 THFSTMCA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nRlqs-006utA-Av; Wed, 09 Mar 2022 02:14:58 +0000 Received: from mail-yb1-xb49.google.com ([2607:f8b0:4864:20::b49]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nRlpR-006uJn-5h for linux-arm-kernel@lists.infradead.org; Wed, 09 Mar 2022 02:13:34 +0000 Received: by mail-yb1-xb49.google.com with SMTP id v1-20020a25fc01000000b006289a83ed20so677243ybd.7 for ; Tue, 08 Mar 2022 18:13:28 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc:content-transfer-encoding; bh=tbwoXRX83Ugtjl0wsQRtV4AtFgtOhQymRgtKRped+Rs=; b=pLFQa/wKjKqXgdsL9YiwrP0+4reCH1GcLyINgxZNtig9j/bjAVckpQsJyaBnor0YRw QT2Ac1pu6uKNK6dq3AxLwkoMtLj0ope4YAhwbD9RAur21DuvwwLjt5nL6WK8HOmcZRTW kQTvRZvoorV1jUVWyonAOg5ot2L0Njc/Quui+Rsm+QkO8SYd/XiXTXzITrf8pNeD7DKb Bs6YJ9Flc0XidjI+XVdANJ7OqaxegiDFx1i1VCkB6P2/hhXQPmI601dIZabsUqjvvqCD LcEIl3S7r7V0lxzmjq8nghaOflNK4aSlm1LUnxV/ehLldVyMdLzD1LprJE6zqKUPp0nv +QCQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc:content-transfer-encoding; bh=tbwoXRX83Ugtjl0wsQRtV4AtFgtOhQymRgtKRped+Rs=; b=ALIPDSk2hdGgWwTWV3xXaJEcGFNqQ2Q77LIXO/TA5s90RcRZYB4YlBn+Nl3V8pMhh2 3g0kuTAFf9wvZ38J0wisSObZhP+osCTP9Mn9BVlyRxqQY2eLl+k6jfuTfd0992xHeD6K ohO3qdLFISPQi0VK7GV8PV0SHnM49YIQ/7TViOmfcUo3osqM3h4JQAdnFgF4ptswj94J vspQ0igHBEInrH6+AQw3v4OL/5Ouk2fMxf1vyNF3gT9gPDthsAS+3Bvb2wPC0K8v84wj W5D1wVYAChIAtu8ScMIEyrX5sxcfwtwNpZr8leTbJgMYjCLW23qbWcpL4JS14NnkWxdF zlyg== X-Gm-Message-State: AOAM531xL9BZrO664mW1kE77r5oEbnhiLMJDqzGfh4HzQRpb2bWOetvR PE/gaxg8J/Hf+z2AArUMuv0mPNF3eBc= X-Google-Smtp-Source: ABdhPJybwfKOM4+AVo0DqHtjLhmb1d5wOQcFRE4U5L8Mjs0RnbwQmHOxDglMablpfKjVYbJ0qFN8SFiMhLA= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:57a6:54a6:aad1:c0a8]) (user=yuzhao job=sendgmr) by 2002:a81:3617:0:b0:2dd:2c4f:2685 with SMTP id d23-20020a813617000000b002dd2c4f2685mr2781305ywa.107.1646792007540; Tue, 08 Mar 2022 18:13:27 -0800 (PST) Date: Tue, 8 Mar 2022 19:12:20 -0700 In-Reply-To: <20220309021230.721028-1-yuzhao@google.com> Message-Id: <20220309021230.721028-4-yuzhao@google.com> Mime-Version: 1.0 References: <20220309021230.721028-1-yuzhao@google.com> X-Mailer: git-send-email 2.35.1.616.g0bdcbb4464-goog Subject: [PATCH v9 03/14] mm/vmscan.c: refactor shrink_node() From: Yu Zhao To: Andrew Morton , Linus Torvalds Cc: Andi Kleen , Aneesh Kumar , Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Jesse Barnes , Johannes Weiner , Jonathan Corbet , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Rik van Riel , Vlastimil Babka , Will Deacon , Ying Huang , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, page-reclaim@google.com, x86@kernel.org, Yu Zhao , Brian Geffon , Jan Alexander Steffens , Oleksandr Natalenko , Steven Barrett , Suleiman Souhlal , Daniel Byrne , Donald Carr , "=?UTF-8?q?Holger=20Hoffst=C3=A4tte?=" , Konstantin Kharlamov , Shuang Zhai , Sofia Trinh , Vaibhav Jain X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220308_181329_263515_31B1AFE4 X-CRM114-Status: GOOD ( 22.48 ) X-BeenThere: linux-arm-kernel@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: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org VGhpcyBwYXRjaCByZWZhY3RvcnMgc2hyaW5rX25vZGUoKSB0byBpbXByb3ZlIHJlYWRhYmlsaXR5 IGZvciB0aGUKdXBjb21pbmcgY2hhbmdlcyB0byBtbS92bXNjYW4uYy4KClNpZ25lZC1vZmYtYnk6 IFl1IFpoYW8gPHl1emhhb0Bnb29nbGUuY29tPgpBY2tlZC1ieTogQnJpYW4gR2VmZm9uIDxiZ2Vm Zm9uQGdvb2dsZS5jb20+CkFja2VkLWJ5OiBKYW4gQWxleGFuZGVyIFN0ZWZmZW5zIChoZWZ0aWcp IDxoZWZ0aWdAYXJjaGxpbnV4Lm9yZz4KQWNrZWQtYnk6IE9sZWtzYW5kciBOYXRhbGVua28gPG9s ZWtzYW5kckBuYXRhbGVua28ubmFtZT4KQWNrZWQtYnk6IFN0ZXZlbiBCYXJyZXR0IDxzdGV2ZW5A bGlxdW9yaXgubmV0PgpBY2tlZC1ieTogU3VsZWltYW4gU291aGxhbCA8c3VsZWltYW5AZ29vZ2xl LmNvbT4KVGVzdGVkLWJ5OiBEYW5pZWwgQnlybmUgPGRqYnlybmVAbXR1LmVkdT4KVGVzdGVkLWJ5 OiBEb25hbGQgQ2FyciA8ZEBjaGFvcy1yZWlucy5jb20+ClRlc3RlZC1ieTogSG9sZ2VyIEhvZmZz dMOkdHRlIDxob2xnZXJAYXBwbGllZC1hc3luY2hyb255LmNvbT4KVGVzdGVkLWJ5OiBLb25zdGFu dGluIEtoYXJsYW1vdiA8SGktQW5nZWxAeWFuZGV4LnJ1PgpUZXN0ZWQtYnk6IFNodWFuZyBaaGFp IDxzemhhaTJAY3Mucm9jaGVzdGVyLmVkdT4KVGVzdGVkLWJ5OiBTb2ZpYSBUcmluaCA8c29maWEu dHJpbmhAZWRpLndvcmtzPgpUZXN0ZWQtYnk6IFZhaWJoYXYgSmFpbiA8dmFpYmhhdkBsaW51eC5p Ym0uY29tPgotLS0KIG1tL3Ztc2Nhbi5jIHwgMTk4ICsrKysrKysrKysrKysrKysrKysrKysrKysr Ky0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAxMDQgaW5zZXJ0aW9u cygrKSwgOTQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvbW0vdm1zY2FuLmMgYi9tbS92bXNj YW4uYwppbmRleCA1OWIxNGUwZDY5NmMuLjhlNzQ0Y2RmODAyZiAxMDA2NDQKLS0tIGEvbW0vdm1z Y2FuLmMKKysrIGIvbW0vdm1zY2FuLmMKQEAgLTI3MTgsNiArMjcxOCwxMDkgQEAgZW51bSBzY2Fu X2JhbGFuY2UgewogCVNDQU5fRklMRSwKIH07CiAKK3N0YXRpYyB2b2lkIHByZXBhcmVfc2Nhbl9j b3VudChwZ19kYXRhX3QgKnBnZGF0LCBzdHJ1Y3Qgc2Nhbl9jb250cm9sICpzYykKK3sKKwl1bnNp Z25lZCBsb25nIGZpbGU7CisJc3RydWN0IGxydXZlYyAqdGFyZ2V0X2xydXZlYzsKKworCXRhcmdl dF9scnV2ZWMgPSBtZW1fY2dyb3VwX2xydXZlYyhzYy0+dGFyZ2V0X21lbV9jZ3JvdXAsIHBnZGF0 KTsKKworCS8qCisJICogRmx1c2ggdGhlIG1lbW9yeSBjZ3JvdXAgc3RhdHMsIHNvIHRoYXQgd2Ug cmVhZCBhY2N1cmF0ZSBwZXItbWVtY2cKKwkgKiBscnV2ZWMgc3RhdHMgZm9yIGhldXJpc3RpY3Mu CisJICovCisJbWVtX2Nncm91cF9mbHVzaF9zdGF0cygpOworCisJLyoKKwkgKiBEZXRlcm1pbmUg dGhlIHNjYW4gYmFsYW5jZSBiZXR3ZWVuIGFub24gYW5kIGZpbGUgTFJVcy4KKwkgKi8KKwlzcGlu X2xvY2tfaXJxKCZ0YXJnZXRfbHJ1dmVjLT5scnVfbG9jayk7CisJc2MtPmFub25fY29zdCA9IHRh cmdldF9scnV2ZWMtPmFub25fY29zdDsKKwlzYy0+ZmlsZV9jb3N0ID0gdGFyZ2V0X2xydXZlYy0+ ZmlsZV9jb3N0OworCXNwaW5fdW5sb2NrX2lycSgmdGFyZ2V0X2xydXZlYy0+bHJ1X2xvY2spOwor CisJLyoKKwkgKiBUYXJnZXQgZGVzaXJhYmxlIGluYWN0aXZlOmFjdGl2ZSBsaXN0IHJhdGlvcyBm b3IgdGhlIGFub24KKwkgKiBhbmQgZmlsZSBMUlUgbGlzdHMuCisJICovCisJaWYgKCFzYy0+Zm9y Y2VfZGVhY3RpdmF0ZSkgeworCQl1bnNpZ25lZCBsb25nIHJlZmF1bHRzOworCisJCXJlZmF1bHRz ID0gbHJ1dmVjX3BhZ2Vfc3RhdGUodGFyZ2V0X2xydXZlYywKKwkJCQlXT1JLSU5HU0VUX0FDVElW QVRFX0FOT04pOworCQlpZiAocmVmYXVsdHMgIT0gdGFyZ2V0X2xydXZlYy0+cmVmYXVsdHNbMF0g fHwKKwkJCWluYWN0aXZlX2lzX2xvdyh0YXJnZXRfbHJ1dmVjLCBMUlVfSU5BQ1RJVkVfQU5PTikp CisJCQlzYy0+bWF5X2RlYWN0aXZhdGUgfD0gREVBQ1RJVkFURV9BTk9OOworCQllbHNlCisJCQlz Yy0+bWF5X2RlYWN0aXZhdGUgJj0gfkRFQUNUSVZBVEVfQU5PTjsKKworCQkvKgorCQkgKiBXaGVu IHJlZmF1bHRzIGFyZSBiZWluZyBvYnNlcnZlZCwgaXQgbWVhbnMgYSBuZXcKKwkJICogd29ya2lu Z3NldCBpcyBiZWluZyBlc3RhYmxpc2hlZC4gRGVhY3RpdmF0ZSB0byBnZXQKKwkJICogcmlkIG9m IGFueSBzdGFsZSBhY3RpdmUgcGFnZXMgcXVpY2tseS4KKwkJICovCisJCXJlZmF1bHRzID0gbHJ1 dmVjX3BhZ2Vfc3RhdGUodGFyZ2V0X2xydXZlYywKKwkJCQlXT1JLSU5HU0VUX0FDVElWQVRFX0ZJ TEUpOworCQlpZiAocmVmYXVsdHMgIT0gdGFyZ2V0X2xydXZlYy0+cmVmYXVsdHNbMV0gfHwKKwkJ ICAgIGluYWN0aXZlX2lzX2xvdyh0YXJnZXRfbHJ1dmVjLCBMUlVfSU5BQ1RJVkVfRklMRSkpCisJ CQlzYy0+bWF5X2RlYWN0aXZhdGUgfD0gREVBQ1RJVkFURV9GSUxFOworCQllbHNlCisJCQlzYy0+ bWF5X2RlYWN0aXZhdGUgJj0gfkRFQUNUSVZBVEVfRklMRTsKKwl9IGVsc2UKKwkJc2MtPm1heV9k ZWFjdGl2YXRlID0gREVBQ1RJVkFURV9BTk9OIHwgREVBQ1RJVkFURV9GSUxFOworCisJLyoKKwkg KiBJZiB3ZSBoYXZlIHBsZW50eSBvZiBpbmFjdGl2ZSBmaWxlIHBhZ2VzIHRoYXQgYXJlbid0CisJ ICogdGhyYXNoaW5nLCB0cnkgdG8gcmVjbGFpbSB0aG9zZSBmaXJzdCBiZWZvcmUgdG91Y2hpbmcK KwkgKiBhbm9ueW1vdXMgcGFnZXMuCisJICovCisJZmlsZSA9IGxydXZlY19wYWdlX3N0YXRlKHRh cmdldF9scnV2ZWMsIE5SX0lOQUNUSVZFX0ZJTEUpOworCWlmIChmaWxlID4+IHNjLT5wcmlvcml0 eSAmJiAhKHNjLT5tYXlfZGVhY3RpdmF0ZSAmIERFQUNUSVZBVEVfRklMRSkpCisJCXNjLT5jYWNo ZV90cmltX21vZGUgPSAxOworCWVsc2UKKwkJc2MtPmNhY2hlX3RyaW1fbW9kZSA9IDA7CisKKwkv KgorCSAqIFByZXZlbnQgdGhlIHJlY2xhaW1lciBmcm9tIGZhbGxpbmcgaW50byB0aGUgY2FjaGUg dHJhcDogYXMKKwkgKiBjYWNoZSBwYWdlcyBzdGFydCBvdXQgaW5hY3RpdmUsIGV2ZXJ5IGNhY2hl IGZhdWx0IHdpbGwgdGlwCisJICogdGhlIHNjYW4gYmFsYW5jZSB0b3dhcmRzIHRoZSBmaWxlIExS VS4gIEFuZCBhcyB0aGUgZmlsZSBMUlUKKwkgKiBzaHJpbmtzLCBzbyBkb2VzIHRoZSB3aW5kb3cg Zm9yIHJvdGF0aW9uIGZyb20gcmVmZXJlbmNlcy4KKwkgKiBUaGlzIG1lYW5zIHdlIGhhdmUgYSBy dW5hd2F5IGZlZWRiYWNrIGxvb3Agd2hlcmUgYSB0aW55CisJICogdGhyYXNoaW5nIGZpbGUgTFJV IGJlY29tZXMgaW5maW5pdGVseSBtb3JlIGF0dHJhY3RpdmUgdGhhbgorCSAqIGFub24gcGFnZXMu ICBUcnkgdG8gZGV0ZWN0IHRoaXMgYmFzZWQgb24gZmlsZSBMUlUgc2l6ZS4KKwkgKi8KKwlpZiAo IWNncm91cF9yZWNsYWltKHNjKSkgeworCQl1bnNpZ25lZCBsb25nIHRvdGFsX2hpZ2hfd21hcmsg PSAwOworCQl1bnNpZ25lZCBsb25nIGZyZWUsIGFub247CisJCWludCB6OworCisJCWZyZWUgPSBz dW1fem9uZV9ub2RlX3BhZ2Vfc3RhdGUocGdkYXQtPm5vZGVfaWQsIE5SX0ZSRUVfUEFHRVMpOwor CQlmaWxlID0gbm9kZV9wYWdlX3N0YXRlKHBnZGF0LCBOUl9BQ1RJVkVfRklMRSkgKworCQkJICAg bm9kZV9wYWdlX3N0YXRlKHBnZGF0LCBOUl9JTkFDVElWRV9GSUxFKTsKKworCQlmb3IgKHogPSAw OyB6IDwgTUFYX05SX1pPTkVTOyB6KyspIHsKKwkJCXN0cnVjdCB6b25lICp6b25lID0gJnBnZGF0 LT5ub2RlX3pvbmVzW3pdOworCisJCQlpZiAoIW1hbmFnZWRfem9uZSh6b25lKSkKKwkJCQljb250 aW51ZTsKKworCQkJdG90YWxfaGlnaF93bWFyayArPSBoaWdoX3dtYXJrX3BhZ2VzKHpvbmUpOwor CQl9CisKKwkJLyoKKwkJICogQ29uc2lkZXIgYW5vbjogaWYgdGhhdCdzIGxvdyB0b28sIHRoaXMg aXNuJ3QgYQorCQkgKiBydW5hd2F5IGZpbGUgcmVjbGFpbSBwcm9ibGVtLCBidXQgcmF0aGVyIGp1 c3QKKwkJICogZXh0cmVtZSBwcmVzc3VyZS4gUmVjbGFpbSBhcyBwZXIgdXN1YWwgdGhlbi4KKwkJ ICovCisJCWFub24gPSBub2RlX3BhZ2Vfc3RhdGUocGdkYXQsIE5SX0lOQUNUSVZFX0FOT04pOwor CisJCXNjLT5maWxlX2lzX3RpbnkgPQorCQkJZmlsZSArIGZyZWUgPD0gdG90YWxfaGlnaF93bWFy ayAmJgorCQkJIShzYy0+bWF5X2RlYWN0aXZhdGUgJiBERUFDVElWQVRFX0FOT04pICYmCisJCQlh bm9uID4+IHNjLT5wcmlvcml0eTsKKwl9Cit9CisKIC8qCiAgKiBEZXRlcm1pbmUgaG93IGFnZ3Jl c3NpdmVseSB0aGUgYW5vbiBhbmQgZmlsZSBMUlUgbGlzdHMgc2hvdWxkIGJlCiAgKiBzY2FubmVk LiAgVGhlIHJlbGF0aXZlIHZhbHVlIG9mIGVhY2ggc2V0IG9mIExSVSBsaXN0cyBpcyBkZXRlcm1p bmVkCkBAIC0zMTg4LDEwOSArMzI5MSwxNiBAQCBzdGF0aWMgdm9pZCBzaHJpbmtfbm9kZShwZ19k YXRhX3QgKnBnZGF0LCBzdHJ1Y3Qgc2Nhbl9jb250cm9sICpzYykKIAl1bnNpZ25lZCBsb25nIG5y X3JlY2xhaW1lZCwgbnJfc2Nhbm5lZDsKIAlzdHJ1Y3QgbHJ1dmVjICp0YXJnZXRfbHJ1dmVjOwog CWJvb2wgcmVjbGFpbWFibGUgPSBmYWxzZTsKLQl1bnNpZ25lZCBsb25nIGZpbGU7CiAKIAl0YXJn ZXRfbHJ1dmVjID0gbWVtX2Nncm91cF9scnV2ZWMoc2MtPnRhcmdldF9tZW1fY2dyb3VwLCBwZ2Rh dCk7CiAKIGFnYWluOgotCS8qCi0JICogRmx1c2ggdGhlIG1lbW9yeSBjZ3JvdXAgc3RhdHMsIHNv IHRoYXQgd2UgcmVhZCBhY2N1cmF0ZSBwZXItbWVtY2cKLQkgKiBscnV2ZWMgc3RhdHMgZm9yIGhl dXJpc3RpY3MuCi0JICovCi0JbWVtX2Nncm91cF9mbHVzaF9zdGF0cygpOwotCiAJbWVtc2V0KCZz Yy0+bnIsIDAsIHNpemVvZihzYy0+bnIpKTsKIAogCW5yX3JlY2xhaW1lZCA9IHNjLT5ucl9yZWNs YWltZWQ7CiAJbnJfc2Nhbm5lZCA9IHNjLT5ucl9zY2FubmVkOwogCi0JLyoKLQkgKiBEZXRlcm1p bmUgdGhlIHNjYW4gYmFsYW5jZSBiZXR3ZWVuIGFub24gYW5kIGZpbGUgTFJVcy4KLQkgKi8KLQlz cGluX2xvY2tfaXJxKCZ0YXJnZXRfbHJ1dmVjLT5scnVfbG9jayk7Ci0Jc2MtPmFub25fY29zdCA9 IHRhcmdldF9scnV2ZWMtPmFub25fY29zdDsKLQlzYy0+ZmlsZV9jb3N0ID0gdGFyZ2V0X2xydXZl Yy0+ZmlsZV9jb3N0OwotCXNwaW5fdW5sb2NrX2lycSgmdGFyZ2V0X2xydXZlYy0+bHJ1X2xvY2sp OwotCi0JLyoKLQkgKiBUYXJnZXQgZGVzaXJhYmxlIGluYWN0aXZlOmFjdGl2ZSBsaXN0IHJhdGlv cyBmb3IgdGhlIGFub24KLQkgKiBhbmQgZmlsZSBMUlUgbGlzdHMuCi0JICovCi0JaWYgKCFzYy0+ Zm9yY2VfZGVhY3RpdmF0ZSkgewotCQl1bnNpZ25lZCBsb25nIHJlZmF1bHRzOwotCi0JCXJlZmF1 bHRzID0gbHJ1dmVjX3BhZ2Vfc3RhdGUodGFyZ2V0X2xydXZlYywKLQkJCQlXT1JLSU5HU0VUX0FD VElWQVRFX0FOT04pOwotCQlpZiAocmVmYXVsdHMgIT0gdGFyZ2V0X2xydXZlYy0+cmVmYXVsdHNb MF0gfHwKLQkJCWluYWN0aXZlX2lzX2xvdyh0YXJnZXRfbHJ1dmVjLCBMUlVfSU5BQ1RJVkVfQU5P TikpCi0JCQlzYy0+bWF5X2RlYWN0aXZhdGUgfD0gREVBQ1RJVkFURV9BTk9OOwotCQllbHNlCi0J CQlzYy0+bWF5X2RlYWN0aXZhdGUgJj0gfkRFQUNUSVZBVEVfQU5PTjsKLQotCQkvKgotCQkgKiBX aGVuIHJlZmF1bHRzIGFyZSBiZWluZyBvYnNlcnZlZCwgaXQgbWVhbnMgYSBuZXcKLQkJICogd29y a2luZ3NldCBpcyBiZWluZyBlc3RhYmxpc2hlZC4gRGVhY3RpdmF0ZSB0byBnZXQKLQkJICogcmlk IG9mIGFueSBzdGFsZSBhY3RpdmUgcGFnZXMgcXVpY2tseS4KLQkJICovCi0JCXJlZmF1bHRzID0g bHJ1dmVjX3BhZ2Vfc3RhdGUodGFyZ2V0X2xydXZlYywKLQkJCQlXT1JLSU5HU0VUX0FDVElWQVRF X0ZJTEUpOwotCQlpZiAocmVmYXVsdHMgIT0gdGFyZ2V0X2xydXZlYy0+cmVmYXVsdHNbMV0gfHwK LQkJICAgIGluYWN0aXZlX2lzX2xvdyh0YXJnZXRfbHJ1dmVjLCBMUlVfSU5BQ1RJVkVfRklMRSkp Ci0JCQlzYy0+bWF5X2RlYWN0aXZhdGUgfD0gREVBQ1RJVkFURV9GSUxFOwotCQllbHNlCi0JCQlz Yy0+bWF5X2RlYWN0aXZhdGUgJj0gfkRFQUNUSVZBVEVfRklMRTsKLQl9IGVsc2UKLQkJc2MtPm1h eV9kZWFjdGl2YXRlID0gREVBQ1RJVkFURV9BTk9OIHwgREVBQ1RJVkFURV9GSUxFOwotCi0JLyoK LQkgKiBJZiB3ZSBoYXZlIHBsZW50eSBvZiBpbmFjdGl2ZSBmaWxlIHBhZ2VzIHRoYXQgYXJlbid0 Ci0JICogdGhyYXNoaW5nLCB0cnkgdG8gcmVjbGFpbSB0aG9zZSBmaXJzdCBiZWZvcmUgdG91Y2hp bmcKLQkgKiBhbm9ueW1vdXMgcGFnZXMuCi0JICovCi0JZmlsZSA9IGxydXZlY19wYWdlX3N0YXRl KHRhcmdldF9scnV2ZWMsIE5SX0lOQUNUSVZFX0ZJTEUpOwotCWlmIChmaWxlID4+IHNjLT5wcmlv cml0eSAmJiAhKHNjLT5tYXlfZGVhY3RpdmF0ZSAmIERFQUNUSVZBVEVfRklMRSkpCi0JCXNjLT5j YWNoZV90cmltX21vZGUgPSAxOwotCWVsc2UKLQkJc2MtPmNhY2hlX3RyaW1fbW9kZSA9IDA7Ci0K LQkvKgotCSAqIFByZXZlbnQgdGhlIHJlY2xhaW1lciBmcm9tIGZhbGxpbmcgaW50byB0aGUgY2Fj aGUgdHJhcDogYXMKLQkgKiBjYWNoZSBwYWdlcyBzdGFydCBvdXQgaW5hY3RpdmUsIGV2ZXJ5IGNh Y2hlIGZhdWx0IHdpbGwgdGlwCi0JICogdGhlIHNjYW4gYmFsYW5jZSB0b3dhcmRzIHRoZSBmaWxl IExSVS4gIEFuZCBhcyB0aGUgZmlsZSBMUlUKLQkgKiBzaHJpbmtzLCBzbyBkb2VzIHRoZSB3aW5k b3cgZm9yIHJvdGF0aW9uIGZyb20gcmVmZXJlbmNlcy4KLQkgKiBUaGlzIG1lYW5zIHdlIGhhdmUg YSBydW5hd2F5IGZlZWRiYWNrIGxvb3Agd2hlcmUgYSB0aW55Ci0JICogdGhyYXNoaW5nIGZpbGUg TFJVIGJlY29tZXMgaW5maW5pdGVseSBtb3JlIGF0dHJhY3RpdmUgdGhhbgotCSAqIGFub24gcGFn ZXMuICBUcnkgdG8gZGV0ZWN0IHRoaXMgYmFzZWQgb24gZmlsZSBMUlUgc2l6ZS4KLQkgKi8KLQlp ZiAoIWNncm91cF9yZWNsYWltKHNjKSkgewotCQl1bnNpZ25lZCBsb25nIHRvdGFsX2hpZ2hfd21h cmsgPSAwOwotCQl1bnNpZ25lZCBsb25nIGZyZWUsIGFub247Ci0JCWludCB6OwotCi0JCWZyZWUg PSBzdW1fem9uZV9ub2RlX3BhZ2Vfc3RhdGUocGdkYXQtPm5vZGVfaWQsIE5SX0ZSRUVfUEFHRVMp OwotCQlmaWxlID0gbm9kZV9wYWdlX3N0YXRlKHBnZGF0LCBOUl9BQ1RJVkVfRklMRSkgKwotCQkJ ICAgbm9kZV9wYWdlX3N0YXRlKHBnZGF0LCBOUl9JTkFDVElWRV9GSUxFKTsKLQotCQlmb3IgKHog PSAwOyB6IDwgTUFYX05SX1pPTkVTOyB6KyspIHsKLQkJCXN0cnVjdCB6b25lICp6b25lID0gJnBn ZGF0LT5ub2RlX3pvbmVzW3pdOwotCQkJaWYgKCFtYW5hZ2VkX3pvbmUoem9uZSkpCi0JCQkJY29u dGludWU7Ci0KLQkJCXRvdGFsX2hpZ2hfd21hcmsgKz0gaGlnaF93bWFya19wYWdlcyh6b25lKTsK LQkJfQotCi0JCS8qCi0JCSAqIENvbnNpZGVyIGFub246IGlmIHRoYXQncyBsb3cgdG9vLCB0aGlz IGlzbid0IGEKLQkJICogcnVuYXdheSBmaWxlIHJlY2xhaW0gcHJvYmxlbSwgYnV0IHJhdGhlciBq dXN0Ci0JCSAqIGV4dHJlbWUgcHJlc3N1cmUuIFJlY2xhaW0gYXMgcGVyIHVzdWFsIHRoZW4uCi0J CSAqLwotCQlhbm9uID0gbm9kZV9wYWdlX3N0YXRlKHBnZGF0LCBOUl9JTkFDVElWRV9BTk9OKTsK LQotCQlzYy0+ZmlsZV9pc190aW55ID0KLQkJCWZpbGUgKyBmcmVlIDw9IHRvdGFsX2hpZ2hfd21h cmsgJiYKLQkJCSEoc2MtPm1heV9kZWFjdGl2YXRlICYgREVBQ1RJVkFURV9BTk9OKSAmJgotCQkJ YW5vbiA+PiBzYy0+cHJpb3JpdHk7Ci0JfQorCXByZXBhcmVfc2Nhbl9jb3VudChwZ2RhdCwgc2Mp OwogCiAJc2hyaW5rX25vZGVfbWVtY2dzKHBnZGF0LCBzYyk7CiAKLS0gCjIuMzUuMS42MTYuZzBi ZGNiYjQ0NjQtZ29vZwoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlz dHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xpbnV4LWFybS1rZXJuZWwK