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 lists.sourceforge.net (lists.sourceforge.net [216.105.38.7]) (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 5F3C2C77B7D for ; Thu, 18 May 2023 07:51:03 +0000 (UTC) Received: from [127.0.0.1] (helo=sfs-ml-1.v29.lw.sourceforge.com) by sfs-ml-1.v29.lw.sourceforge.com with esmtp (Exim 4.95) (envelope-from ) id 1pzYPb-0000HJ-2H; Thu, 18 May 2023 07:50:59 +0000 Received: from [172.30.20.202] (helo=mx.sourceforge.net) by sfs-ml-1.v29.lw.sourceforge.com with esmtps (TLS1.2) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.95) (envelope-from ) id 1pzYPa-0000HD-AV for linux-f2fs-devel@lists.sourceforge.net; Thu, 18 May 2023 07:50:59 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sourceforge.net; s=x; h=Content-Transfer-Encoding:Content-Type:MIME-Version :Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:In-Reply-To:References:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=NbVCYeRUFr8vrl8toQBMMjXMVKk793Wk+oDzilMw+vU=; b=H/ypaEbXLw1UTp/Rt/o5YdfRQN LJrwt3l15xcWeUW4erGuYwS33U6VIqi8Lx3q6jzn2yE2DLE3hutVyWoBxGxnOQrS2khsObv6hA8bu Cj3HgL38d0ZSCr+wva8aiH3Z82pzo/TbCR8sJ+ndXAZpfMd8zDFwzYarUPFHT+9Ktilg=; DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sf.net; s=x ; h=Content-Transfer-Encoding:Content-Type:MIME-Version:Message-Id:Date: Subject:Cc:To:From:Sender:Reply-To:Content-ID:Content-Description:Resent-Date :Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To: References:List-Id:List-Help:List-Unsubscribe:List-Subscribe:List-Post: List-Owner:List-Archive; bh=NbVCYeRUFr8vrl8toQBMMjXMVKk793Wk+oDzilMw+vU=; b=J VAbDk0FNqcQJcoJLpJju/AS/fFTEV+rEJ2p6NjpYJ7zNH39v2ks53I8llUWnFRgfciZBDOTM+dCMX MX9HDX5PzpN5p1gABI3ldfId1R2j2JETqcjjlgUbK6B0vGUxXCgsvHI1YPWnFytux0flNM1rgHiHs 7Bcuvubt3kzrvNfA=; Received: from dfw.source.kernel.org ([139.178.84.217]) by sfi-mx-1.v28.lw.sourceforge.com with esmtps (TLS1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.95) id 1pzYPa-00C4tf-8f for linux-f2fs-devel@lists.sourceforge.net; Thu, 18 May 2023 07:50:59 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 0835A64CF6; Thu, 18 May 2023 07:50:52 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 45A60C433EF; Thu, 18 May 2023 07:50:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1684396251; bh=gX+Be+fV7upnPUuap1LrRfsLMGHN89kol6H009qPnqg=; h=From:To:Cc:Subject:Date:From; b=adQoqBnk3GN3ctAx4FDL/usWgsVM//LCjHhS2SZS4Ffu/4RGOxmys1L3YJ33u4/uy EZJ7H0s2jJ6H3MIPM6FgWvOlOr0bJ1xXajrH7gM7Jt6myBqYPs8d+RCC7iHHVMke8n Zpi95wXHXNT7flHjFWPp/7pPQtU6HINshO6QwPnFJ3eMj3We3OY/pdu6Lr2joImWL9 guICjWCtZ5RMO6zMPLeS1By9QEHBVeEPBVlBripMWRsge6yagX4EN64vJl+ywI3Et0 066cgoP0ohin1XJTs7JrFnikYJLD1lB0Z05h/aF7oPQAtnE69A8rjDqAekbtNG0o2A b/s9/lyInwE9w== From: Chao Yu To: jaegeuk@kernel.org Date: Thu, 18 May 2023 15:50:41 +0800 Message-Id: <20230518075041.38786-1-chao@kernel.org> X-Mailer: git-send-email 2.40.1 MIME-Version: 1.0 X-Headers-End: 1pzYPa-00C4tf-8f Subject: [f2fs-dev] [PATCH] f2fs: support background_gc=adjust mount option X-BeenThere: linux-f2fs-devel@lists.sourceforge.net X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-kernel@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: linux-f2fs-devel-bounces@lists.sourceforge.net QXMgSnVIeXVuZyByZXBvcnRlZCBpbiBbMV06CgoiSW4gbW9zdCBjb25zdW1lci1ncmFkZSBibGFj a2JveCBTU0RzLCBkZXZpY2Utc2lkZSBHQ3MgYXJlIGhhbmRsZWQKYXV0b21hdGljYWxseSBmb3Ig dmFyaW91cyB3b3JrbG9hZHMuIGYyZnMsIGhvd2V2ZXIsIGxlYXZlcyB0aGF0CnJlc3BvbnNpYmls aXR5IHRvIHRoZSB1c2Vyc3BhY2Ugd2l0aCBjb25zZXJ2YXRpdmUgdHVuaW5nIG9uIHRoZQprZXJu ZWwtc2lkZSBieSBkZWZhdWx0LiBBbmRyb2lkIGhhbmRsZXMgdGhpcyBieSBpbml0LnJjIHR1bmlu Z3MgYW5kIGEKc2VwYXJhdGUgY29kZSBydW5uaW5nIGluIHZvbGQgdG8gdHJpZ2dlciBnY191cmdl bnQuCgpGb3IgcmVndWxhciBMaW51eCBkZXNrdG9wIGRpc3Ryb3MsIGYyZnMganVzdCBydW5zIG9u IHRoZSBkZWZhdWx0CmNvbmZpZ3VyYXRpb24gc2V0IG9uIHRoZSBrZXJuZWwgYW5kIHVubGVzcyBp dOKAmXMgcnVubmluZyAyNC83IHdpdGgKcGxlbnRpZnVsIGlkbGUgdGltZSwgaXQgcXVpY2tseSBy dW5zIG91dCBvZiBmcmVlIHNlZ21lbnRzIGFuZCBzdGFydHMKdHJpZ2dlcmluZyBmb3JlZ3JvdW5k IEdDLiBUaGlzIGlzIGdpdmluZyBwZW9wbGUgdGhlIHdyb25nIGltcHJlc3Npb24KdGhhdCBmMmZz IHNsb3dzIGRvd24gZmFyIGRyYXN0aWNhbGx5IHRoYW4gb3RoZXIgZmlsZS1zeXN0ZW1zIHdoZW4K dGhhdOKAmXMgcXVpdGUgdGhlIGNvbnRyYXJ5IChpLmUuLCBsZXNzIGZyYWdtZW50YXRpb24gb3Zl cnRpbWUpLiIKClRoaXMgcGF0Y2ggc3VwcG9ydHMgYmFja2dyb3VuZF9nYz1hZGp1c3QgbW91bnQg b3B0aW9uLgoKSWYgYmFja2dyb3VuZF9nYz1hZGp1c3QsIGdjIHdpbGwgYWRqdXN0IGl0cyBwb2xp Y3kgZGVwZW5kcwpvbiBjb25kaXRpb25zOiBzcGVlZCB1cCBpZiB0aGVyZSBubyBmcmVlIHNlZ21l bnRzLCBhbmQgc2xvdwpkb3duIGlmIHRoZXJlIGlzIG5vIGZyZWUgc3BhY2UuCgpUaGUgbWFpbiBs b2dpYyBpcyBhcyBiZWxvdzoKCjEuIHBlcmZvcm1hbmNlIG1vZGUKLSBjb25kaXRpb246IGlmIGZy ZWVfc2VnbWVudHMgaXMgbGVzcyB0aGFuIDEwICogb3ZwX3NlZ21lbnRzIGFuZApyZWNsYWltYWJs ZV9ibG9jayBpcyBtb3JlIHRoYW4gMjAgKiB1bnVzZWRfdXNlcl9ibG9jawotIGFjdGlvbjogcmVk dWNlIHNsZWVwIHRpbWUgb2YgR0MgdGhyZWFkIGJhc2VkIG9uIGZyZWUgdXNlciBibG9jawpyYXRp bywgdGhhdCBpcyB0byBzYXksIHRoZSBtb3JlIHJlY2xhaW1hYmxlIGJsb2NrcywgdGhlIGxlc3Mg dGltZQp0aHJlYWQgd2lsbCBzbGVlcAoKMi4gbGlmZXRpbWUgbW9kZToKLSBjb25kaXRpb246IGlm IGZyZWUgc3BhY2UgaXMgbGVzcyB0aGFuIDkwJQotIGFjdGlvbjoKIGEpIHJlc2V0IG1pbl9zbGVl cF90aW1lIHRvIGRlZmF1bHQgMzAwMDAgbXMKIGIpIHJlZHVjZSBjb3N0IHdlaWdodCBvZiBhZ2Ug d2hlbiBjYWNsdWF0aW5nIGNvc3Qgb2YgZGlydHkKIHNlZ21lbnQsIHNvIHRoYXQgR0MgbWF5IHNl bGVjdCB2aWN0aW0gd2hpY2ggY29udGFpbnMgbGVzcyBibG9ja3MKCjMuIGJhbGFuY2UgbW9kZQot IGNvbmRpdGlvbjogaXQgaXMgZGVmYXVsdCBtb2RlCi0gYWN0aW9uOiByZWR1Y2UgbWluX3NsZWVw X3RpbWUgZnJvbSAzMDAwMCBtcyB0byAxMDAwMCBtcwoKWzFdIGh0dHBzOi8vbG9yZS5rZXJuZWwu b3JnL2xpbnV4LWYyZnMtZGV2ZWwvQ0FEMTQrZjN6PWtTOUUrTlRLSDd0MUoyeEwxUHBMT1ZNTng9 Q2FiRF90Mks2VT1UOXVRQG1haWwuZ21haWwuY29tCgpPcmlnaW5hbCBwYXRjaCB3YXMgZGV2ZWxv cGVkIGJ5IFdlaWNoYW8gR3VvLCBJIHJlZmFjdG9yIGl0IGEgYml0IGFuZApyZWJhc2UgdGhlIGNv ZGUuCgpTaWduZWQtb2ZmLWJ5OiBXZWljaGFvIEd1byA8Z3Vvd2VpY2hhb0BvcHBvLmNvbT4KU2ln bmVkLW9mZi1ieTogQ2hhbyBZdSA8Y2hhb0BrZXJuZWwub3JnPgotLS0KIERvY3VtZW50YXRpb24v ZmlsZXN5c3RlbXMvZjJmcy5yc3QgfCAgNyArKy0KIGZzL2YyZnMvZjJmcy5oICAgICAgICAgICAg ICAgICAgICAgfCAgNCArKwogZnMvZjJmcy9nYy5jICAgICAgICAgICAgICAgICAgICAgICB8IDky ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQogZnMvZjJmcy9nYy5oICAgICAgICAgICAg ICAgICAgICAgICB8IDIzICsrKysrKysrCiBmcy9mMmZzL3N1cGVyLmMgICAgICAgICAgICAgICAg ICAgIHwgIDQgKysKIDUgZmlsZXMgY2hhbmdlZCwgMTI2IGluc2VydGlvbnMoKyksIDQgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9mMmZzLnJzdCBi L0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvZjJmcy5yc3QKaW5kZXggOTM1OTk3OGE1YWYyLi43 NjQzMDFmNzM5MWUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvZjJmcy5y c3QKKysrIGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9mMmZzLnJzdApAQCAtMTEyLDggKzEx MiwxMSBAQCBiYWNrZ3JvdW5kX2djPSVzCSBUdXJuIG9uL29mZiBjbGVhbmluZyBvcGVyYXRpb25z LCBuYW1lbHkgZ2FyYmFnZQogCQkJIGNvbGxlY3Rpb24gYW5kIGlmIGJhY2tncm91bmRfZ2M9b2Zm LCBnYXJiYWdlIGNvbGxlY3Rpb24KIAkJCSB3aWxsIGJlIHR1cm5lZCBvZmYuIElmIGJhY2tncm91 bmRfZ2M9c3luYywgaXQgd2lsbCB0dXJuCiAJCQkgb24gc3luY2hyb25vdXMgZ2FyYmFnZSBjb2xs ZWN0aW9uIHJ1bm5pbmcgaW4gYmFja2dyb3VuZC4KLQkJCSBEZWZhdWx0IHZhbHVlIGZvciB0aGlz IG9wdGlvbiBpcyBvbi4gU28gZ2FyYmFnZQotCQkJIGNvbGxlY3Rpb24gaXMgb24gYnkgZGVmYXVs dC4KKwkJCSBJZiBiYWNrZ3JvdW5kX2djPWFkanVzdCwgZ2Mgd2lsbCBhZGp1c3QgaXRzIHBvbGlj eSBkZXBlbmRzCisJCQkgb24gY29uZGl0aW9uczogc3BlZWQgdXAgaWYgdGhlcmUgbm8gZnJlZSBz ZWdtZW50cywgYW5kIHNsb3cKKwkJCSBkb3duIGlmIHRoZXJlIGlzIG5vIGZyZWUgc3BhY2UuCisJ CQkgRGVmYXVsdCB2YWx1ZSBmb3IgdGhpcyBvcHRpb24gaXMgb24uIFNvIGdhcmJhZ2UgY29sbGVj dGlvbgorCQkJIGlzIG9uIGJ5IGRlZmF1bHQuCiBnY19tZXJnZQkJIFdoZW4gYmFja2dyb3VuZF9n YyBpcyBvbiwgdGhpcyBvcHRpb24gY2FuIGJlIGVuYWJsZWQgdG8KIAkJCSBsZXQgYmFja2dyb3Vu ZCBHQyB0aHJlYWQgdG8gaGFuZGxlIGZvcmVncm91bmQgR0MgcmVxdWVzdHMsCiAJCQkgaXQgY2Fu IGVsaW1pbmF0ZSB0aGUgc2x1Z2dpc2ggaXNzdWUgY2F1c2VkIGJ5IHNsb3cgZm9yZWdyb3VuZApk aWZmIC0tZ2l0IGEvZnMvZjJmcy9mMmZzLmggYi9mcy9mMmZzL2YyZnMuaAppbmRleCA4ZDRlYWY0 ZDIyNDYuLjRjMmY2NWQzYzIwOCAxMDA2NDQKLS0tIGEvZnMvZjJmcy9mMmZzLmgKKysrIGIvZnMv ZjJmcy9mMmZzLmgKQEAgLTEzMzMsNiArMTMzMywxMCBAQCBlbnVtIHsKIAkJCQkgKiBiYWNrZ3Jv dW5kIGdjIGlzIG9uLCBtaWdyYXRpbmcgYmxvY2tzCiAJCQkJICogbGlrZSBmb3JlZ3JvdW5kIGdj CiAJCQkJICovCisJQkdHQ19NT0RFX0FESlVTVCwJLyoKKwkJCQkgKiBiYWNrZ3JvdW5kIGdjIGlz IG9uLCBhbmQgdHVuZSBpdHMgc3BlZWQKKwkJCQkgKiBkZXBlbmRzbyBuIGNvbmRpdGlvbnMKKwkJ CQkgKi8KIH07CiAKIGVudW0gewpkaWZmIC0tZ2l0IGEvZnMvZjJmcy9nYy5jIGIvZnMvZjJmcy9n Yy5jCmluZGV4IDUxZDdlOGQyOWJmMS4uNDNmOTM1YzI1MDJhIDEwMDY0NAotLS0gYS9mcy9mMmZz L2djLmMKKysrIGIvZnMvZjJmcy9nYy5jCkBAIC0yOCw2ICsyOCw2NyBAQCBzdGF0aWMgc3RydWN0 IGttZW1fY2FjaGUgKnZpY3RpbV9lbnRyeV9zbGFiOwogc3RhdGljIHVuc2lnbmVkIGludCBjb3Vu dF9iaXRzKGNvbnN0IHVuc2lnbmVkIGxvbmcgKmFkZHIsCiAJCQkJdW5zaWduZWQgaW50IG9mZnNl dCwgdW5zaWduZWQgaW50IGxlbik7CiAKK3N0YXRpYyBpbmxpbmUgaW50IGZyZWVfdXNlcl9ibG9j a19yYXRpbyhzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmkpCit7CisJYmxvY2tfdCB1bnVzZWRfdXNl cl9ibG9ja3MgPSBzYmktPnVzZXJfYmxvY2tfY291bnQgLQorCQkJCQl3cml0dGVuX2Jsb2NrX2Nv dW50KHNiaSk7CisJcmV0dXJuIHVudXNlZF91c2VyX2Jsb2NrcyA9PSAwID8gMTAwIDoKKwkJKDEw MCAqIGZyZWVfdXNlcl9ibG9ja3Moc2JpKSAvIHVudXNlZF91c2VyX2Jsb2Nrcyk7Cit9CisKK3N0 YXRpYyBib29sIGhhc19mZXdfZnJlZV9zZWdtZW50cyhzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmkp Cit7CisJdW5zaWduZWQgaW50IGZyZWVfc2VncyA9IGZyZWVfc2VnbWVudHMoc2JpKTsKKwl1bnNp Z25lZCBpbnQgb3ZwX3NlZ3MgPSBvdmVycHJvdmlzaW9uX3NlZ21lbnRzKHNiaSk7CisKKwlyZXR1 cm4gZnJlZV9zZWdzIDw9IERFRl9GRVdfRlJFRV9TRUdNRU5UX01VTFRJUExFICogb3ZwX3NlZ3M7 Cit9CisKK3N0YXRpYyBib29sIGhhc19mZXdfZnJlZV9zcGFjZShzdHJ1Y3QgZjJmc19zYl9pbmZv ICpzYmkpCit7CisJYmxvY2tfdCB0b3RhbF91c2VyX2Jsb2NrID0gc2JpLT51c2VyX2Jsb2NrX2Nv dW50OworCWJsb2NrX3QgZnJlZV91c2VyX2Jsb2NrcyA9IHRvdGFsX3VzZXJfYmxvY2sgLSB3cml0 dGVuX2Jsb2NrX2NvdW50KHNiaSk7CisKKwlyZXR1cm4gMTAwICogZnJlZV91c2VyX2Jsb2NrcyAv IHRvdGFsX3VzZXJfYmxvY2sgPD0KKwkJCQkJREVGX0ZFV19GUkVFX1NQQUNFX1JBVElPOworfQor CitzdGF0aWMgYm9vbCBoYXNfZW5vdWdoX3JlY2xhaW1hYmxlX2Jsb2NrcyhzdHJ1Y3QgZjJmc19z Yl9pbmZvICpzYmkpCit7CisJcmV0dXJuIDEwMCAtIGZyZWVfdXNlcl9ibG9ja19yYXRpbyhzYmkp ID49CisJCQlERUZfRU5PVUdIX1JFQ0xBSU1BQkxFX0JMT0NLX1JBVElPOworfQorCitzdGF0aWMg dm9pZCBhZGp1c3RfZ2NfcGVyZmVyZW5jZShzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmksCisJCQkJ CQl1bnNpZ25lZCBpbnQgKndhaXRfbXMpCit7CisJc3RydWN0IGYyZnNfZ2Nfa3RocmVhZCAqZ2Nf dGggPSBzYmktPmdjX3RocmVhZDsKKworCWlmIChoYXNfZmV3X2ZyZWVfc3BhY2Uoc2JpKSkKKwkJ Z2NfdGgtPmdjX3ByZWZlcmVuY2UgPSBHQ19MSUZFVElNRV9NT0RFOworCWVsc2UgaWYgKGhhc19m ZXdfZnJlZV9zZWdtZW50cyhzYmkpICYmCisJCQloYXNfZW5vdWdoX3JlY2xhaW1hYmxlX2Jsb2Nr cyhzYmkpKQorCQlnY190aC0+Z2NfcHJlZmVyZW5jZSA9IEdDX1BFUkZPUk1BTkNFX01PREU7CisJ ZWxzZQorCQlnY190aC0+Z2NfcHJlZmVyZW5jZSA9IEdDX0JBTEFOQ0VfTU9ERTsKKworCXN3aXRj aCAoZ2NfdGgtPmdjX3ByZWZlcmVuY2UpIHsKKwljYXNlIEdDX1BFUkZPUk1BTkNFX01PREU6CisJ CSp3YWl0X21zID0gbWF4KERFRl9HQ19CQUxBTkNFX01JTl9TTEVFUF9USU1FICoKKwkJCQkJZnJl ZV91c2VyX2Jsb2NrX3JhdGlvKHNiaSkgLyAxMDAsCisJCQkJCURFRl9HQ19QRVJGT1JNQU5DRV9N SU5fU0xFRVBfVElNRSk7CisJCWJyZWFrOworCWNhc2UgR0NfTElGRVRJTUVfTU9ERToKKwkJZ2Nf dGgtPm1pbl9zbGVlcF90aW1lID0gREVGX0dDX1RIUkVBRF9NSU5fU0xFRVBfVElNRTsKKwkJYnJl YWs7CisJY2FzZSBHQ19CQUxBTkNFX01PREU6CisJCWdjX3RoLT5taW5fc2xlZXBfdGltZSA9IERF Rl9HQ19CQUxBTkNFX01JTl9TTEVFUF9USU1FOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlmMmZz X2J1Z19vbihzYmksIDEpOworCX0KK30KKwogc3RhdGljIGludCBnY190aHJlYWRfZnVuYyh2b2lk ICpkYXRhKQogewogCXN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSA9IGRhdGE7CkBAIC00Niw2ICsx MDcsOSBAQCBzdGF0aWMgaW50IGdjX3RocmVhZF9mdW5jKHZvaWQgKmRhdGEpCiAJZG8gewogCQli b29sIHN5bmNfbW9kZSwgZm9yZWdyb3VuZCA9IGZhbHNlOwogCisJCWlmIChGMkZTX09QVElPTihz YmkpLmJnZ2NfbW9kZSA9PSBCR0dDX01PREVfQURKVVNUKQorCQkJYWRqdXN0X2djX3BlcmZlcmVu Y2Uoc2JpLCAmd2FpdF9tcyk7CisKIAkJd2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlX3RpbWVvdXQo KndxLAogCQkJCWt0aHJlYWRfc2hvdWxkX3N0b3AoKSB8fCBmcmVlemluZyhjdXJyZW50KSB8fAog CQkJCXdhaXRxdWV1ZV9hY3RpdmUoZmdnY193cSkgfHwKQEAgLTEwOSw3ICsxNzMsOCBAQCBzdGF0 aWMgaW50IGdjX3RocmVhZF9mdW5jKHZvaWQgKmRhdGEpCiAJCQlnb3RvIG5leHQ7CiAJCX0KIAot CQlpZiAoIWlzX2lkbGUoc2JpLCBHQ19USU1FKSkgeworCQlpZiAoIWlzX2lkbGUoc2JpLCBHQ19U SU1FKSAmJgorCQkJRjJGU19PUFRJT04oc2JpKS5iZ2djX21vZGUgIT0gQkdHQ19NT0RFX0FESlVT VCkgewogCQkJaW5jcmVhc2Vfc2xlZXBfdGltZShnY190aCwgJndhaXRfbXMpOwogCQkJZjJmc191 cF93cml0ZSgmc2JpLT5nY19sb2NrKTsKIAkJCXN0YXRfaW9fc2tpcF9iZ2djX2NvdW50KHNiaSk7 CkBAIC0xODMsNiArMjQ4LDggQEAgaW50IGYyZnNfc3RhcnRfZ2NfdGhyZWFkKHN0cnVjdCBmMmZz X3NiX2luZm8gKnNiaSkKIAlnY190aC0+bWF4X3NsZWVwX3RpbWUgPSBERUZfR0NfVEhSRUFEX01B WF9TTEVFUF9USU1FOwogCWdjX3RoLT5ub19nY19zbGVlcF90aW1lID0gREVGX0dDX1RIUkVBRF9O T0dDX1NMRUVQX1RJTUU7CiAKKwlnY190aC0+Z2NfcHJlZmVyZW5jZSA9IEdDX0JBTEFOQ0VfTU9E RTsKKwogCWdjX3RoLT5nY193YWtlID0gZmFsc2U7CiAKIAlzYmktPmdjX3RocmVhZCA9IGdjX3Ro OwpAQCAtMzI5LDYgKzM5NiwyMyBAQCBzdGF0aWMgdW5zaWduZWQgaW50IGNoZWNrX2JnX3ZpY3Rp bXMoc3RydWN0IGYyZnNfc2JfaW5mbyAqc2JpKQogCXJldHVybiBOVUxMX1NFR05POwogfQogCitz dGF0aWMgdW5zaWduZWQgY2hhciBnZXRfbWF4X2FnZShzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmkp Cit7CisJc3RydWN0IGYyZnNfZ2Nfa3RocmVhZCAqZ2NfdGggPSBzYmktPmdjX3RocmVhZDsKKwl1 bnNpZ25lZCBjaGFyIG1heF9hZ2UgPSAxMDA7CisJdW5zaWduZWQgY2hhciByYXRpbzsKKworCWlm ICghZ2NfdGggfHwgZ2NfdGgtPmdjX3ByZWZlcmVuY2UgIT0gR0NfTElGRVRJTUVfTU9ERSkKKwkJ Z290byBvdXQ7CisKKwkvKiBpZiBmcmVlIGJsb2NrIGNvdW50IGlzIGxlc3MgdGhhbiAxMCUsIHJl ZHVjZSBjb3N0IHdlaWdodCBvZiBhZ2UgKi8KKwlyYXRpbyA9IGZyZWVfdXNlcl9ibG9ja19yYXRp byhzYmkpOworCWlmIChyYXRpbyA8PSBERUZfRkVXX0ZSRUVfU0VHTUVOVF9SQVRJTykKKwkJbWF4 X2FnZSA9IG1heCgxMCAqIHJhdGlvLCAxKTsKK291dDoKKwlyZXR1cm4gbWF4X2FnZTsKK30KKwog c3RhdGljIHVuc2lnbmVkIGludCBnZXRfY2JfY29zdChzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmks IHVuc2lnbmVkIGludCBzZWdubykKIHsKIAlzdHJ1Y3Qgc2l0X2luZm8gKnNpdF9pID0gU0lUX0ko c2JpKTsKQEAgLTMzNiw2ICs0MjAsNyBAQCBzdGF0aWMgdW5zaWduZWQgaW50IGdldF9jYl9jb3N0 KHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSwgdW5zaWduZWQgaW50IHNlZ25vKQogCXVuc2lnbmVk IGludCBzdGFydCA9IEdFVF9TRUdfRlJPTV9TRUMoc2JpLCBzZWNubyk7CiAJdW5zaWduZWQgbG9u ZyBsb25nIG10aW1lID0gMDsKIAl1bnNpZ25lZCBpbnQgdmJsb2NrczsKKwl1bnNpZ25lZCBjaGFy IG1heF9hZ2U7CiAJdW5zaWduZWQgY2hhciBhZ2UgPSAwOwogCXVuc2lnbmVkIGNoYXIgdTsKIAl1 bnNpZ25lZCBpbnQgaTsKQEAgLTM1NSw4ICs0NDAsMTEgQEAgc3RhdGljIHVuc2lnbmVkIGludCBn ZXRfY2JfY29zdChzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmksIHVuc2lnbmVkIGludCBzZWdubykK IAkJc2l0X2ktPm1pbl9tdGltZSA9IG10aW1lOwogCWlmIChtdGltZSA+IHNpdF9pLT5tYXhfbXRp bWUpCiAJCXNpdF9pLT5tYXhfbXRpbWUgPSBtdGltZTsKKworCW1heF9hZ2UgPSBnZXRfbWF4X2Fn ZShzYmkpOworCiAJaWYgKHNpdF9pLT5tYXhfbXRpbWUgIT0gc2l0X2ktPm1pbl9tdGltZSkKLQkJ YWdlID0gMTAwIC0gZGl2NjRfdTY0KDEwMCAqIChtdGltZSAtIHNpdF9pLT5taW5fbXRpbWUpLAor CQlhZ2UgPSBtYXhfYWdlIC0gZGl2NjRfdTY0KG1heF9hZ2UgKiAobXRpbWUgLSBzaXRfaS0+bWlu X210aW1lKSwKIAkJCQlzaXRfaS0+bWF4X210aW1lIC0gc2l0X2ktPm1pbl9tdGltZSk7CiAKIAly ZXR1cm4gVUlOVF9NQVggLSAoKDEwMCAqICgxMDAgLSB1KSAqIGFnZSkgLyAoMTAwICsgdSkpOwpk aWZmIC0tZ2l0IGEvZnMvZjJmcy9nYy5oIGIvZnMvZjJmcy9nYy5oCmluZGV4IDI4YTAwOTQyODAy Yy4uNjZmNmEzMGRkNDk0IDEwMDY0NAotLS0gYS9mcy9mMmZzL2djLmgKKysrIGIvZnMvZjJmcy9n Yy5oCkBAIC0xNSw2ICsxNSwxNCBAQAogI2RlZmluZSBERUZfR0NfVEhSRUFEX01BWF9TTEVFUF9U SU1FCTYwMDAwCiAjZGVmaW5lIERFRl9HQ19USFJFQURfTk9HQ19TTEVFUF9USU1FCTMwMDAwMAkv KiB3YWl0IDUgbWluICovCiAKKy8qIGZvciBCR0dDX01PREVfQURKVVNUICovCisjZGVmaW5lIERF Rl9HQ19QRVJGT1JNQU5DRV9NSU5fU0xFRVBfVElNRQkxMDAJLyogMTAwIG1zICovCisjZGVmaW5l IERFRl9HQ19CQUxBTkNFX01JTl9TTEVFUF9USU1FCQkxMDAwMAkvKiAxMCBzZWMgKi8KKyNkZWZp bmUgREVGX0ZFV19GUkVFX1NQQUNFX1JBVElPCQkxMAkvKiBmZXcgZnJlZSBzcGFjZSByYXRpbyAq LworI2RlZmluZSBERUZfRkVXX0ZSRUVfU0VHTUVOVF9NVUxUSVBMRQkJMTAJLyogZmV3IGZyZWUg c2VnbWVudHMgbXVsdGlwbGUgKi8KKyNkZWZpbmUgREVGX0VOT1VHSF9SRUNMQUlNQUJMRV9CTE9D S19SQVRJTwkyMAkvKiBlbm91Z2ggcmVjbGFpbWFibGUgYmxvY2sgcmF0aW8gKi8KKyNkZWZpbmUg REVGX0ZFV19GUkVFX1NFR01FTlRfUkFUSU8JCTEwCS8qIGZldyBmcmVlIHNlZ21lbnQgcmF0aW8g Ki8KKwogLyogY2hvb3NlIGNhbmRpZGF0ZXMgZnJvbSBzZWN0aW9ucyB3aGljaCBoYXMgYWdlIG9m IG1vcmUgdGhhbiA3IGRheXMgKi8KICNkZWZpbmUgREVGX0dDX1RIUkVBRF9BR0VfVEhSRVNIT0xE CQkoNjAgKiA2MCAqIDI0ICogNykKICNkZWZpbmUgREVGX0dDX1RIUkVBRF9DQU5ESURBVEVfUkFU SU8JCTIwCS8qIHNlbGVjdCAyMCUgb2xkZXN0IHNlY3Rpb25zIGFzIGNhbmRpZGF0ZXMgKi8KQEAg LTMyLDYgKzQwLDE5IEBACiAKICNkZWZpbmUgTlJfR0NfQ0hFQ0tQT0lOVF9TRUNTICgzKQkvKiBk YXRhL25vZGUvZGVudHJ5IHNlY3Rpb25zICovCiAKKy8qIEdDIHByZWZlcmVuY2UgKi8KK2VudW0g eworCUdDX1BFUkZPUk1BTkNFX01PREUsCQkvKgorCQkJCQkgKiBzcGVlZCB1cCBiYWNrZ3JvdW5k IGdjIHRvIHJlY3ljbGUKKwkJCQkJICogc2xhY2sgc3BhY2UgZm9yIGJldHRlciBwZXJmb3JtYW5j ZQorCQkJCQkgKi8KKwlHQ19MSUZFVElNRV9NT0RFLAkJLyoKKwkJCQkJICogc2xvdyBkb3duIGJh Y2tncm91bmQgZ2MgdG8gYXZvaWQgaGlnaAorCQkJCQkgKiBXQUYgaWYgdGhlcmUgaXMgbGVzcyBm cmVlIHNwYWNlLgorCQkJCQkgKi8KKwlHQ19CQUxBTkNFX01PREUsCQkvKiB0cmFkZW9mZiBpbiBi ZXR3ZWVuIHBlcmYgYW5kIGxpZmV0aW1lICovCit9OworCiBzdHJ1Y3QgZjJmc19nY19rdGhyZWFk IHsKIAlzdHJ1Y3QgdGFza19zdHJ1Y3QgKmYyZnNfZ2NfdGFzazsKIAl3YWl0X3F1ZXVlX2hlYWRf dCBnY193YWl0X3F1ZXVlX2hlYWQ7CkBAIC00Miw2ICs2Myw4IEBAIHN0cnVjdCBmMmZzX2djX2t0 aHJlYWQgewogCXVuc2lnbmVkIGludCBtYXhfc2xlZXBfdGltZTsKIAl1bnNpZ25lZCBpbnQgbm9f Z2Nfc2xlZXBfdGltZTsKIAorCXVuc2lnbmVkIGNoYXIgZ2NfcHJlZmVyZW5jZTsJLyogZ2MgcGVy ZmVyZW5jZSAqLworCiAJLyogZm9yIGNoYW5naW5nIGdjIG1vZGUgKi8KIAlib29sIGdjX3dha2U7 CiAKZGlmZiAtLWdpdCBhL2ZzL2YyZnMvc3VwZXIuYyBiL2ZzL2YyZnMvc3VwZXIuYwppbmRleCBm MTkyMTcyMTljM2IuLjgwNmM4MTE5ZjAyMSAxMDA2NDQKLS0tIGEvZnMvZjJmcy9zdXBlci5jCisr KyBiL2ZzL2YyZnMvc3VwZXIuYwpAQCAtNjkzLDYgKzY5Myw4IEBAIHN0YXRpYyBpbnQgcGFyc2Vf b3B0aW9ucyhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBjaGFyICpvcHRpb25zLCBib29sIGlzX3Jl bW91bnQpCiAJCQkJRjJGU19PUFRJT04oc2JpKS5iZ2djX21vZGUgPSBCR0dDX01PREVfT0ZGOwog CQkJfSBlbHNlIGlmICghc3RyY21wKG5hbWUsICJzeW5jIikpIHsKIAkJCQlGMkZTX09QVElPTihz YmkpLmJnZ2NfbW9kZSA9IEJHR0NfTU9ERV9TWU5DOworCQkJfSBlbHNlIGlmICghc3RyY21wKG5h bWUsICJhZGp1c3QiKSkgeworCQkJCUYyRlNfT1BUSU9OKHNiaSkuYmdnY19tb2RlID0gQkdHQ19N T0RFX0FESlVTVDsKIAkJCX0gZWxzZSB7CiAJCQkJa2ZyZWUobmFtZSk7CiAJCQkJcmV0dXJuIC1F SU5WQUw7CkBAIC0xOTI3LDYgKzE5MjksOCBAQCBzdGF0aWMgaW50IGYyZnNfc2hvd19vcHRpb25z KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCBzdHJ1Y3QgZGVudHJ5ICpyb290KQogCQlzZXFfcHJpbnRm KHNlcSwgIixiYWNrZ3JvdW5kX2djPSVzIiwgIm9uIik7CiAJZWxzZSBpZiAoRjJGU19PUFRJT04o c2JpKS5iZ2djX21vZGUgPT0gQkdHQ19NT0RFX09GRikKIAkJc2VxX3ByaW50ZihzZXEsICIsYmFj a2dyb3VuZF9nYz0lcyIsICJvZmYiKTsKKwllbHNlIGlmIChGMkZTX09QVElPTihzYmkpLmJnZ2Nf bW9kZSA9PSBCR0dDX01PREVfQURKVVNUKQorCQlzZXFfcHJpbnRmKHNlcSwgIixiYWNrZ3JvdW5k X2djPSVzIiwgImFkanVzdCIpOwogCiAJaWYgKHRlc3Rfb3B0KHNiaSwgR0NfTUVSR0UpKQogCQlz ZXFfcHV0cyhzZXEsICIsZ2NfbWVyZ2UiKTsKLS0gCjIuNDAuMQoKCgpfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eC1mMmZzLWRldmVsIG1haWxpbmcg bGlzdApMaW51eC1mMmZzLWRldmVsQGxpc3RzLnNvdXJjZWZvcmdlLm5ldApodHRwczovL2xpc3Rz LnNvdXJjZWZvcmdlLm5ldC9saXN0cy9saXN0aW5mby9saW51eC1mMmZzLWRldmVsCg== 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 25D6CC77B7A for ; Thu, 18 May 2023 07:51:14 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229529AbjERHvM (ORCPT ); Thu, 18 May 2023 03:51:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40190 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230099AbjERHu7 (ORCPT ); Thu, 18 May 2023 03:50:59 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 86ED02690 for ; Thu, 18 May 2023 00:50:54 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 0D98264D75 for ; Thu, 18 May 2023 07:50:52 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 45A60C433EF; Thu, 18 May 2023 07:50:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1684396251; bh=gX+Be+fV7upnPUuap1LrRfsLMGHN89kol6H009qPnqg=; h=From:To:Cc:Subject:Date:From; b=adQoqBnk3GN3ctAx4FDL/usWgsVM//LCjHhS2SZS4Ffu/4RGOxmys1L3YJ33u4/uy EZJ7H0s2jJ6H3MIPM6FgWvOlOr0bJ1xXajrH7gM7Jt6myBqYPs8d+RCC7iHHVMke8n Zpi95wXHXNT7flHjFWPp/7pPQtU6HINshO6QwPnFJ3eMj3We3OY/pdu6Lr2joImWL9 guICjWCtZ5RMO6zMPLeS1By9QEHBVeEPBVlBripMWRsge6yagX4EN64vJl+ywI3Et0 066cgoP0ohin1XJTs7JrFnikYJLD1lB0Z05h/aF7oPQAtnE69A8rjDqAekbtNG0o2A b/s9/lyInwE9w== From: Chao Yu To: jaegeuk@kernel.org Cc: linux-f2fs-devel@lists.sourceforge.net, linux-kernel@vger.kernel.org, Chao Yu , Weichao Guo Subject: [PATCH] f2fs: support background_gc=adjust mount option Date: Thu, 18 May 2023 15:50:41 +0800 Message-Id: <20230518075041.38786-1-chao@kernel.org> X-Mailer: git-send-email 2.40.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org As JuHyung reported in [1]: "In most consumer-grade blackbox SSDs, device-side GCs are handled automatically for various workloads. f2fs, however, leaves that responsibility to the userspace with conservative tuning on the kernel-side by default. Android handles this by init.rc tunings and a separate code running in vold to trigger gc_urgent. For regular Linux desktop distros, f2fs just runs on the default configuration set on the kernel and unless it’s running 24/7 with plentiful idle time, it quickly runs out of free segments and starts triggering foreground GC. This is giving people the wrong impression that f2fs slows down far drastically than other file-systems when that’s quite the contrary (i.e., less fragmentation overtime)." This patch supports background_gc=adjust mount option. If background_gc=adjust, gc will adjust its policy depends on conditions: speed up if there no free segments, and slow down if there is no free space. The main logic is as below: 1. performance mode - condition: if free_segments is less than 10 * ovp_segments and reclaimable_block is more than 20 * unused_user_block - action: reduce sleep time of GC thread based on free user block ratio, that is to say, the more reclaimable blocks, the less time thread will sleep 2. lifetime mode: - condition: if free space is less than 90% - action: a) reset min_sleep_time to default 30000 ms b) reduce cost weight of age when cacluating cost of dirty segment, so that GC may select victim which contains less blocks 3. balance mode - condition: it is default mode - action: reduce min_sleep_time from 30000 ms to 10000 ms [1] https://lore.kernel.org/linux-f2fs-devel/CAD14+f3z=kS9E+NTKH7t1J2xL1PpLOVMNx=CabD_t2K6U=T9uQ@mail.gmail.com Original patch was developed by Weichao Guo, I refactor it a bit and rebase the code. Signed-off-by: Weichao Guo Signed-off-by: Chao Yu --- Documentation/filesystems/f2fs.rst | 7 ++- fs/f2fs/f2fs.h | 4 ++ fs/f2fs/gc.c | 92 +++++++++++++++++++++++++++++- fs/f2fs/gc.h | 23 ++++++++ fs/f2fs/super.c | 4 ++ 5 files changed, 126 insertions(+), 4 deletions(-) diff --git a/Documentation/filesystems/f2fs.rst b/Documentation/filesystems/f2fs.rst index 9359978a5af2..764301f7391e 100644 --- a/Documentation/filesystems/f2fs.rst +++ b/Documentation/filesystems/f2fs.rst @@ -112,8 +112,11 @@ background_gc=%s Turn on/off cleaning operations, namely garbage collection and if background_gc=off, garbage collection will be turned off. If background_gc=sync, it will turn on synchronous garbage collection running in background. - Default value for this option is on. So garbage - collection is on by default. + If background_gc=adjust, gc will adjust its policy depends + on conditions: speed up if there no free segments, and slow + down if there is no free space. + Default value for this option is on. So garbage collection + is on by default. gc_merge When background_gc is on, this option can be enabled to let background GC thread to handle foreground GC requests, it can eliminate the sluggish issue caused by slow foreground diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index 8d4eaf4d2246..4c2f65d3c208 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -1333,6 +1333,10 @@ enum { * background gc is on, migrating blocks * like foreground gc */ + BGGC_MODE_ADJUST, /* + * background gc is on, and tune its speed + * dependso n conditions + */ }; enum { diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 51d7e8d29bf1..43f935c2502a 100644 --- a/fs/f2fs/gc.c +++ b/fs/f2fs/gc.c @@ -28,6 +28,67 @@ static struct kmem_cache *victim_entry_slab; static unsigned int count_bits(const unsigned long *addr, unsigned int offset, unsigned int len); +static inline int free_user_block_ratio(struct f2fs_sb_info *sbi) +{ + block_t unused_user_blocks = sbi->user_block_count - + written_block_count(sbi); + return unused_user_blocks == 0 ? 100 : + (100 * free_user_blocks(sbi) / unused_user_blocks); +} + +static bool has_few_free_segments(struct f2fs_sb_info *sbi) +{ + unsigned int free_segs = free_segments(sbi); + unsigned int ovp_segs = overprovision_segments(sbi); + + return free_segs <= DEF_FEW_FREE_SEGMENT_MULTIPLE * ovp_segs; +} + +static bool has_few_free_space(struct f2fs_sb_info *sbi) +{ + block_t total_user_block = sbi->user_block_count; + block_t free_user_blocks = total_user_block - written_block_count(sbi); + + return 100 * free_user_blocks / total_user_block <= + DEF_FEW_FREE_SPACE_RATIO; +} + +static bool has_enough_reclaimable_blocks(struct f2fs_sb_info *sbi) +{ + return 100 - free_user_block_ratio(sbi) >= + DEF_ENOUGH_RECLAIMABLE_BLOCK_RATIO; +} + +static void adjust_gc_perference(struct f2fs_sb_info *sbi, + unsigned int *wait_ms) +{ + struct f2fs_gc_kthread *gc_th = sbi->gc_thread; + + if (has_few_free_space(sbi)) + gc_th->gc_preference = GC_LIFETIME_MODE; + else if (has_few_free_segments(sbi) && + has_enough_reclaimable_blocks(sbi)) + gc_th->gc_preference = GC_PERFORMANCE_MODE; + else + gc_th->gc_preference = GC_BALANCE_MODE; + + switch (gc_th->gc_preference) { + case GC_PERFORMANCE_MODE: + *wait_ms = max(DEF_GC_BALANCE_MIN_SLEEP_TIME * + free_user_block_ratio(sbi) / 100, + DEF_GC_PERFORMANCE_MIN_SLEEP_TIME); + break; + case GC_LIFETIME_MODE: + gc_th->min_sleep_time = DEF_GC_THREAD_MIN_SLEEP_TIME; + break; + case GC_BALANCE_MODE: + gc_th->min_sleep_time = DEF_GC_BALANCE_MIN_SLEEP_TIME; + break; + default: + f2fs_bug_on(sbi, 1); + } +} + static int gc_thread_func(void *data) { struct f2fs_sb_info *sbi = data; @@ -46,6 +107,9 @@ static int gc_thread_func(void *data) do { bool sync_mode, foreground = false; + if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_ADJUST) + adjust_gc_perference(sbi, &wait_ms); + wait_event_interruptible_timeout(*wq, kthread_should_stop() || freezing(current) || waitqueue_active(fggc_wq) || @@ -109,7 +173,8 @@ static int gc_thread_func(void *data) goto next; } - if (!is_idle(sbi, GC_TIME)) { + if (!is_idle(sbi, GC_TIME) && + F2FS_OPTION(sbi).bggc_mode != BGGC_MODE_ADJUST) { increase_sleep_time(gc_th, &wait_ms); f2fs_up_write(&sbi->gc_lock); stat_io_skip_bggc_count(sbi); @@ -183,6 +248,8 @@ int f2fs_start_gc_thread(struct f2fs_sb_info *sbi) gc_th->max_sleep_time = DEF_GC_THREAD_MAX_SLEEP_TIME; gc_th->no_gc_sleep_time = DEF_GC_THREAD_NOGC_SLEEP_TIME; + gc_th->gc_preference = GC_BALANCE_MODE; + gc_th->gc_wake = false; sbi->gc_thread = gc_th; @@ -329,6 +396,23 @@ static unsigned int check_bg_victims(struct f2fs_sb_info *sbi) return NULL_SEGNO; } +static unsigned char get_max_age(struct f2fs_sb_info *sbi) +{ + struct f2fs_gc_kthread *gc_th = sbi->gc_thread; + unsigned char max_age = 100; + unsigned char ratio; + + if (!gc_th || gc_th->gc_preference != GC_LIFETIME_MODE) + goto out; + + /* if free block count is less than 10%, reduce cost weight of age */ + ratio = free_user_block_ratio(sbi); + if (ratio <= DEF_FEW_FREE_SEGMENT_RATIO) + max_age = max(10 * ratio, 1); +out: + return max_age; +} + static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno) { struct sit_info *sit_i = SIT_I(sbi); @@ -336,6 +420,7 @@ static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno) unsigned int start = GET_SEG_FROM_SEC(sbi, secno); unsigned long long mtime = 0; unsigned int vblocks; + unsigned char max_age; unsigned char age = 0; unsigned char u; unsigned int i; @@ -355,8 +440,11 @@ static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno) sit_i->min_mtime = mtime; if (mtime > sit_i->max_mtime) sit_i->max_mtime = mtime; + + max_age = get_max_age(sbi); + if (sit_i->max_mtime != sit_i->min_mtime) - age = 100 - div64_u64(100 * (mtime - sit_i->min_mtime), + age = max_age - div64_u64(max_age * (mtime - sit_i->min_mtime), sit_i->max_mtime - sit_i->min_mtime); return UINT_MAX - ((100 * (100 - u) * age) / (100 + u)); diff --git a/fs/f2fs/gc.h b/fs/f2fs/gc.h index 28a00942802c..66f6a30dd494 100644 --- a/fs/f2fs/gc.h +++ b/fs/f2fs/gc.h @@ -15,6 +15,14 @@ #define DEF_GC_THREAD_MAX_SLEEP_TIME 60000 #define DEF_GC_THREAD_NOGC_SLEEP_TIME 300000 /* wait 5 min */ +/* for BGGC_MODE_ADJUST */ +#define DEF_GC_PERFORMANCE_MIN_SLEEP_TIME 100 /* 100 ms */ +#define DEF_GC_BALANCE_MIN_SLEEP_TIME 10000 /* 10 sec */ +#define DEF_FEW_FREE_SPACE_RATIO 10 /* few free space ratio */ +#define DEF_FEW_FREE_SEGMENT_MULTIPLE 10 /* few free segments multiple */ +#define DEF_ENOUGH_RECLAIMABLE_BLOCK_RATIO 20 /* enough reclaimable block ratio */ +#define DEF_FEW_FREE_SEGMENT_RATIO 10 /* few free segment ratio */ + /* choose candidates from sections which has age of more than 7 days */ #define DEF_GC_THREAD_AGE_THRESHOLD (60 * 60 * 24 * 7) #define DEF_GC_THREAD_CANDIDATE_RATIO 20 /* select 20% oldest sections as candidates */ @@ -32,6 +40,19 @@ #define NR_GC_CHECKPOINT_SECS (3) /* data/node/dentry sections */ +/* GC preference */ +enum { + GC_PERFORMANCE_MODE, /* + * speed up background gc to recycle + * slack space for better performance + */ + GC_LIFETIME_MODE, /* + * slow down background gc to avoid high + * WAF if there is less free space. + */ + GC_BALANCE_MODE, /* tradeoff in between perf and lifetime */ +}; + struct f2fs_gc_kthread { struct task_struct *f2fs_gc_task; wait_queue_head_t gc_wait_queue_head; @@ -42,6 +63,8 @@ struct f2fs_gc_kthread { unsigned int max_sleep_time; unsigned int no_gc_sleep_time; + unsigned char gc_preference; /* gc perference */ + /* for changing gc mode */ bool gc_wake; diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c index f19217219c3b..806c8119f021 100644 --- a/fs/f2fs/super.c +++ b/fs/f2fs/super.c @@ -693,6 +693,8 @@ static int parse_options(struct super_block *sb, char *options, bool is_remount) F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_OFF; } else if (!strcmp(name, "sync")) { F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC; + } else if (!strcmp(name, "adjust")) { + F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ADJUST; } else { kfree(name); return -EINVAL; @@ -1927,6 +1929,8 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root) seq_printf(seq, ",background_gc=%s", "on"); else if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF) seq_printf(seq, ",background_gc=%s", "off"); + else if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_ADJUST) + seq_printf(seq, ",background_gc=%s", "adjust"); if (test_opt(sbi, GC_MERGE)) seq_puts(seq, ",gc_merge"); -- 2.40.1