From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pf1-f193.google.com (mail-pf1-f193.google.com [209.85.210.193]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 398941BE22D; Tue, 1 Oct 2024 07:59:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.193 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769557; cv=none; b=ttcunFzYzQkugoZUiqguNr/zPDthFyoX+9GxJ46rsBVWqgKh6HuiKuKTPU1o7uQPwrcaApnLFnbJQmuGZI9mZVfGGSKExBsPi1UFGy0EU4gCZ0Hlk80AeURUHd46lYsi1maOg/nCA0JWvEYbMSjGnh4hXEHEKk2QEOIzYKmMUWI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769557; c=relaxed/simple; bh=210RnZGvLfX/JWrOc+SRR4kZZTUG1Hxbx7qRdtSW4VI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=maOzlF8g3Yr20PGlTwZA/9nqJy5xWjDFHD64FgJhMJX97Fkj5+FKKMI667+rWEdDyfIQdhdR/z9LSpxytZ5hFpoA1YpQPyIRuXbFjFfe23RMDasKZk292IutJRdkX2k/FpEY2HdwLaaIZB9/sXS0GjwRslTdw8V9ubnbY5P+oyE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=SPrE2/cE; arc=none smtp.client-ip=209.85.210.193 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="SPrE2/cE" Received: by mail-pf1-f193.google.com with SMTP id d2e1a72fcca58-7178df70f28so4090432b3a.2; Tue, 01 Oct 2024 00:59:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769554; x=1728374354; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=H586TTxS7HHj3h80507DWrTpplgeZKusQMfeMa39Y/Q=; b=SPrE2/cEW5dPWKOeG/3b2MlWd7CplRnls5Cg6antGRXtYubdTmwH2SIwwNQuiDavGb XHglfMwxQ4hE/MaQ5PtpNKsZp6kZRB8N/l49/LJE7nY/yuJvP0gtFuIi9jEtDuNME34U aM3aSBmjbhKzRljsvO4kwN53T1Ngh0kesCrjV2dWpRk6IAzHKictkUV0ynoX5Hh7ZnlZ 5wjn79MFsEFg4MG5LpuA5p3r93/6zQ9LwdFVIltCfWry3Wwvmd6XQAZjaxSYKnEqrQ2h stN1O07r/R3PfwgVLYiWdVyEVmaJl2c5BFkR5dJr677Oist//lzowo0pJubGyo7b1ROx VkNQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769554; x=1728374354; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=H586TTxS7HHj3h80507DWrTpplgeZKusQMfeMa39Y/Q=; b=iegkcCoBlDMNTnUjysZln38ZyNYDlBaAGP5Yhso5qviNMUBmZrVZRe5WkR37qfAOe5 y/RTOlYIVC7VtT0HAe6s8VQjejt4ktJKEDb5jFMGSszFB7T3E9/GRq4IL1oPMrd6F2oa TGsxmNTw+S7y5OFcrZa05roVfQ7C7ps026xU4vx8j+7zn/TEX9FlbymW+82tjcwfAfiS lcnJ3Ts9kWRAYb5+Xr5LxCM/vTjl6YzxxcfH3YiMCRwHnnvZ0Gyoz1gGdMw5wucHo8bp Jo4bvs0eNhWPTqo5ZCOpbSk+kgW3QGfXMz4p0GkboVjk0IaED0GGM0h2M5nMQygpKFoV ly+g== X-Forwarded-Encrypted: i=1; AJvYcCU6mqexEnWoGGRKiA+Oplrle/YgmJNgA+dd2+/TuJIotxKhD2Gu9yM/rUi1BZZ7RgPIFAIuCSYCWltPEZc=@vger.kernel.org, AJvYcCWaOwoOUzsSiZQceD3lXyQGZnKz+pwY30ht2vSDMjT3LCGWWWKUjRyE+Zrulmquv66Sj1N/+Q9c1XLlAziCJfbR@vger.kernel.org X-Gm-Message-State: AOJu0YzBjcFcHZZTRam34Qn3dH5fO6QcQ9fdKRuYokZRsQJnXZvd6xz9 N+nmIyD/nX19Tb4+6+sAjJPNQgOeGRy/vY/6wc6ZCjb3TXeGR9Rzw2OkTsafujc= X-Google-Smtp-Source: AGHT+IFUHxqszULLRLQpplxPUD5qSMOLhqfZNILyVQvIkZOeh87qa37mKjy54ctMsxpD3dVg4Eh9qQ== X-Received: by 2002:a05:6a21:3489:b0:1c6:fb2a:4696 with SMTP id adf61e73a8af0-1d4fa68768bmr23506067637.19.1727769554166; Tue, 01 Oct 2024 00:59:14 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.00.59.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 00:59:13 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Alexander Duyck , Andrew Morton , Shuah Khan , linux-mm@kvack.org, linux-kselftest@vger.kernel.org Subject: [PATCH net-next v19 01/14] mm: page_frag: add a test module for page_frag Date: Tue, 1 Oct 2024 15:58:44 +0800 Message-Id: <20241001075858.48936-2-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The testing is done by ensuring that the fragment allocated from a frag_frag_cache instance is pushed into a ptr_ring instance in a kthread binded to a specified cpu, and a kthread binded to a specified cpu will pop the fragment from the ptr_ring and free the fragment. CC: Alexander Duyck Signed-off-by: Yunsheng Lin Reviewed-by: Alexander Duyck --- tools/testing/selftests/mm/Makefile | 3 + tools/testing/selftests/mm/page_frag/Makefile | 18 ++ .../selftests/mm/page_frag/page_frag_test.c | 173 ++++++++++++++++++ tools/testing/selftests/mm/run_vmtests.sh | 8 + tools/testing/selftests/mm/test_page_frag.sh | 171 +++++++++++++++++ 5 files changed, 373 insertions(+) create mode 100644 tools/testing/selftests/mm/page_frag/Makefile create mode 100644 tools/testing/selftests/mm/page_frag/page_frag_test.c create mode 100755 tools/testing/selftests/mm/test_page_frag.sh diff --git a/tools/testing/selftests/mm/Makefile b/tools/testing/selftests/= mm/Makefile index 02e1204971b0..acec529baaca 100644 --- a/tools/testing/selftests/mm/Makefile +++ b/tools/testing/selftests/mm/Makefile @@ -36,6 +36,8 @@ MAKEFLAGS +=3D --no-builtin-rules CFLAGS =3D -Wall -I $(top_srcdir) $(EXTRA_CFLAGS) $(KHDR_INCLUDES) $(TOOLS= _INCLUDES) LDLIBS =3D -lrt -lpthread -lm =20 +TEST_GEN_MODS_DIR :=3D page_frag + TEST_GEN_FILES =3D cow TEST_GEN_FILES +=3D compaction_test TEST_GEN_FILES +=3D gup_longterm @@ -126,6 +128,7 @@ TEST_FILES +=3D test_hmm.sh TEST_FILES +=3D va_high_addr_switch.sh TEST_FILES +=3D charge_reserved_hugetlb.sh TEST_FILES +=3D hugetlb_reparenting_test.sh +TEST_FILES +=3D test_page_frag.sh =20 # required by charge_reserved_hugetlb.sh TEST_FILES +=3D write_hugetlb_memory.sh diff --git a/tools/testing/selftests/mm/page_frag/Makefile b/tools/testing/= selftests/mm/page_frag/Makefile new file mode 100644 index 000000000000..58dda74d50a3 --- /dev/null +++ b/tools/testing/selftests/mm/page_frag/Makefile @@ -0,0 +1,18 @@ +PAGE_FRAG_TEST_DIR :=3D $(realpath $(dir $(abspath $(lastword $(MAKEFILE_L= IST))))) +KDIR ?=3D $(abspath $(PAGE_FRAG_TEST_DIR)/../../../../..) + +ifeq ($(V),1) +Q =3D +else +Q =3D @ +endif + +MODULES =3D page_frag_test.ko + +obj-m +=3D page_frag_test.o + +all: + +$(Q)make -C $(KDIR) M=3D$(PAGE_FRAG_TEST_DIR) modules + +clean: + +$(Q)make -C $(KDIR) M=3D$(PAGE_FRAG_TEST_DIR) clean diff --git a/tools/testing/selftests/mm/page_frag/page_frag_test.c b/tools/= testing/selftests/mm/page_frag/page_frag_test.c new file mode 100644 index 000000000000..eeb2b6bc681a --- /dev/null +++ b/tools/testing/selftests/mm/page_frag/page_frag_test.c @@ -0,0 +1,173 @@ +// SPDX-License-Identifier: GPL-2.0 + +/* + * Test module for page_frag cache + * + * Copyright (C) 2024 Yunsheng Lin + */ + +#include +#include +#include +#include +#include +#include + +static struct ptr_ring ptr_ring; +static int nr_objs =3D 512; +static atomic_t nthreads; +static struct completion wait; +static struct page_frag_cache test_nc; +static int test_popped; +static int test_pushed; + +static int nr_test =3D 2000000; +module_param(nr_test, int, 0); +MODULE_PARM_DESC(nr_test, "number of iterations to test"); + +static bool test_align; +module_param(test_align, bool, 0); +MODULE_PARM_DESC(test_align, "use align API for testing"); + +static int test_alloc_len =3D 2048; +module_param(test_alloc_len, int, 0); +MODULE_PARM_DESC(test_alloc_len, "alloc len for testing"); + +static int test_push_cpu; +module_param(test_push_cpu, int, 0); +MODULE_PARM_DESC(test_push_cpu, "test cpu for pushing fragment"); + +static int test_pop_cpu; +module_param(test_pop_cpu, int, 0); +MODULE_PARM_DESC(test_pop_cpu, "test cpu for popping fragment"); + +static int page_frag_pop_thread(void *arg) +{ + struct ptr_ring *ring =3D arg; + + pr_info("page_frag pop test thread begins on cpu %d\n", + smp_processor_id()); + + while (test_popped < nr_test) { + void *obj =3D __ptr_ring_consume(ring); + + if (obj) { + test_popped++; + page_frag_free(obj); + } else { + cond_resched(); + } + } + + if (atomic_dec_and_test(&nthreads)) + complete(&wait); + + pr_info("page_frag pop test thread exits on cpu %d\n", + smp_processor_id()); + + return 0; +} + +static int page_frag_push_thread(void *arg) +{ + struct ptr_ring *ring =3D arg; + + pr_info("page_frag push test thread begins on cpu %d\n", + smp_processor_id()); + + while (test_pushed < nr_test) { + void *va; + int ret; + + if (test_align) { + va =3D page_frag_alloc_align(&test_nc, test_alloc_len, + GFP_KERNEL, SMP_CACHE_BYTES); + + WARN_ONCE((unsigned long)va & (SMP_CACHE_BYTES - 1), + "unaligned va returned\n"); + } else { + va =3D page_frag_alloc(&test_nc, test_alloc_len, GFP_KERNEL); + } + + if (!va) + continue; + + ret =3D __ptr_ring_produce(ring, va); + if (ret) { + page_frag_free(va); + cond_resched(); + } else { + test_pushed++; + } + } + + pr_info("page_frag push test thread exits on cpu %d\n", + smp_processor_id()); + + if (atomic_dec_and_test(&nthreads)) + complete(&wait); + + return 0; +} + +static int __init page_frag_test_init(void) +{ + struct task_struct *tsk_push, *tsk_pop; + ktime_t start; + u64 duration; + int ret; + + test_nc.va =3D NULL; + atomic_set(&nthreads, 2); + init_completion(&wait); + + if (test_alloc_len > PAGE_SIZE || test_alloc_len <=3D 0 || + !cpu_active(test_push_cpu) || !cpu_active(test_pop_cpu)) + return -EINVAL; + + ret =3D ptr_ring_init(&ptr_ring, nr_objs, GFP_KERNEL); + if (ret) + return ret; + + tsk_push =3D kthread_create_on_cpu(page_frag_push_thread, &ptr_ring, + test_push_cpu, "page_frag_push"); + if (IS_ERR(tsk_push)) + return PTR_ERR(tsk_push); + + tsk_pop =3D kthread_create_on_cpu(page_frag_pop_thread, &ptr_ring, + test_pop_cpu, "page_frag_pop"); + if (IS_ERR(tsk_pop)) { + kthread_stop(tsk_push); + return PTR_ERR(tsk_pop); + } + + start =3D ktime_get(); + wake_up_process(tsk_push); + wake_up_process(tsk_pop); + + pr_info("waiting for test to complete\n"); + + while (!wait_for_completion_timeout(&wait, msecs_to_jiffies(10000))) + pr_info("page_frag_test progress: pushed =3D %d, popped =3D %d\n", + test_pushed, test_popped); + + duration =3D (u64)ktime_us_delta(ktime_get(), start); + pr_info("%d of iterations for %s testing took: %lluus\n", nr_test, + test_align ? "aligned" : "non-aligned", duration); + + ptr_ring_cleanup(&ptr_ring, NULL); + page_frag_cache_drain(&test_nc); + + return -EAGAIN; +} + +static void __exit page_frag_test_exit(void) +{ +} + +module_init(page_frag_test_init); +module_exit(page_frag_test_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Yunsheng Lin "); +MODULE_DESCRIPTION("Test module for page_frag"); diff --git a/tools/testing/selftests/mm/run_vmtests.sh b/tools/testing/self= tests/mm/run_vmtests.sh index c5797ad1d37b..2c5394584af4 100755 --- a/tools/testing/selftests/mm/run_vmtests.sh +++ b/tools/testing/selftests/mm/run_vmtests.sh @@ -75,6 +75,8 @@ separated by spaces: read-only VMAs - mdwe test prctl(PR_SET_MDWE, ...) +- page_frag + test handling of page fragment allocation and freeing =20 example: ./run_vmtests.sh -t "hmm mmap ksm" EOF @@ -456,6 +458,12 @@ CATEGORY=3D"mkdirty" run_test ./mkdirty =20 CATEGORY=3D"mdwe" run_test ./mdwe_test =20 +CATEGORY=3D"page_frag" run_test ./test_page_frag.sh smoke + +CATEGORY=3D"page_frag" run_test ./test_page_frag.sh aligned + +CATEGORY=3D"page_frag" run_test ./test_page_frag.sh nonaligned + echo "SUMMARY: PASS=3D${count_pass} SKIP=3D${count_skip} FAIL=3D${count_fa= il}" | tap_prefix echo "1..${count_total}" | tap_output =20 diff --git a/tools/testing/selftests/mm/test_page_frag.sh b/tools/testing/s= elftests/mm/test_page_frag.sh new file mode 100755 index 000000000000..d750d910c899 --- /dev/null +++ b/tools/testing/selftests/mm/test_page_frag.sh @@ -0,0 +1,171 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2024 Yunsheng Lin +# Copyright (C) 2018 Uladzislau Rezki (Sony) +# +# This is a test script for the kernel test driver to test the +# correctness and performance of page_frag's implementation. +# Therefore it is just a kernel module loader. You can specify +# and pass different parameters in order to: +# a) analyse performance of page fragment allocations; +# b) stressing and stability check of page_frag subsystem. + +DRIVER=3D"./page_frag/page_frag_test.ko" +CPU_LIST=3D$(grep -m 2 processor /proc/cpuinfo | cut -d ' ' -f 2) +TEST_CPU_0=3D$(echo $CPU_LIST | awk '{print $1}') + +if [ $(echo $CPU_LIST | wc -w) -gt 1 ]; then + TEST_CPU_1=3D$(echo $CPU_LIST | awk '{print $2}') + NR_TEST=3D100000000 +else + TEST_CPU_1=3D$TEST_CPU_0 + NR_TEST=3D1000000 +fi + +# 1 if fails +exitcode=3D1 + +# Kselftest framework requirement - SKIP code is 4. +ksft_skip=3D4 + +# +# Static templates for testing of page_frag APIs. +# Also it is possible to pass any supported parameters manually. +# +SMOKE_PARAM=3D"test_push_cpu=3D$TEST_CPU_0 test_pop_cpu=3D$TEST_CPU_1" +NONALIGNED_PARAM=3D"$SMOKE_PARAM test_alloc_len=3D75 nr_test=3D$NR_TEST" +ALIGNED_PARAM=3D"$NONALIGNED_PARAM test_align=3D1" + +check_test_requirements() +{ + uid=3D$(id -u) + if [ $uid -ne 0 ]; then + echo "$0: Must be run as root" + exit $ksft_skip + fi + + if ! which insmod > /dev/null 2>&1; then + echo "$0: You need insmod installed" + exit $ksft_skip + fi + + if [ ! -f $DRIVER ]; then + echo "$0: You need to compile page_frag_test module" + exit $ksft_skip + fi +} + +run_nonaligned_check() +{ + echo "Run performance tests to evaluate how fast nonaligned alloc API is." + + insmod $DRIVER $NONALIGNED_PARAM > /dev/null 2>&1 + echo "Done." + echo "Check the kernel ring buffer to see the summary." +} + +run_aligned_check() +{ + echo "Run performance tests to evaluate how fast aligned alloc API is." + + insmod $DRIVER $ALIGNED_PARAM > /dev/null 2>&1 + echo "Done." + echo "Check the kernel ring buffer to see the summary." +} + +run_smoke_check() +{ + echo "Run smoke test." + + insmod $DRIVER $SMOKE_PARAM > /dev/null 2>&1 + echo "Done." + echo "Check the kernel ring buffer to see the summary." +} + +usage() +{ + echo -n "Usage: $0 [ aligned ] | [ nonaligned ] | | [ smoke ] | " + echo "manual parameters" + echo + echo "Valid tests and parameters:" + echo + modinfo $DRIVER + echo + echo "Example usage:" + echo + echo "# Shows help message" + echo "$0" + echo + echo "# Smoke testing" + echo "$0 smoke" + echo + echo "# Performance testing for nonaligned alloc API" + echo "$0 nonaligned" + echo + echo "# Performance testing for aligned alloc API" + echo "$0 aligned" + echo + exit 0 +} + +function validate_passed_args() +{ + VALID_ARGS=3D`modinfo $DRIVER | awk '/parm:/ {print $2}' | sed 's/:.*//'` + + # + # Something has been passed, check it. + # + for passed_arg in $@; do + key=3D${passed_arg//=3D*/} + valid=3D0 + + for valid_arg in $VALID_ARGS; do + if [[ $key =3D $valid_arg ]]; then + valid=3D1 + break + fi + done + + if [[ $valid -ne 1 ]]; then + echo "Error: key is not correct: ${key}" + exit $exitcode + fi + done +} + +function run_manual_check() +{ + # + # Validate passed parameters. If there is wrong one, + # the script exists and does not execute further. + # + validate_passed_args $@ + + echo "Run the test with following parameters: $@" + insmod $DRIVER $@ > /dev/null 2>&1 + echo "Done." + echo "Check the kernel ring buffer to see the summary." +} + +function run_test() +{ + if [ $# -eq 0 ]; then + usage + else + if [[ "$1" =3D "smoke" ]]; then + run_smoke_check + elif [[ "$1" =3D "nonaligned" ]]; then + run_nonaligned_check + elif [[ "$1" =3D "aligned" ]]; then + run_aligned_check + else + run_manual_check $@ + fi + fi +} + +check_test_requirements +run_test $@ + +exit 0 --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pl1-f196.google.com (mail-pl1-f196.google.com [209.85.214.196]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4F30A1BDAB7; Tue, 1 Oct 2024 07:59:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.196 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769563; cv=none; b=LjkKn5kSjvsXd0qLAV5irQAuFRt6wh46i9l+UoENVhK60HOiWLwqB5PZK70bej1io9SAmmoSlwInArowJLmwhN2MQPS2KxphXh+ozE+rlreP0qc/VjTrxLTOqlkJmrxDKdqRHjiGsdcpsMqSWLKIKFNySvvMfXpwvcLQPs1hv8Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769563; c=relaxed/simple; bh=/sIbkyj9d5eoCeexWoWOedtLX1JUCXsrqYVzZwf83gQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=X/a2J43oer6uzjGR2RPwzk5sDe/vKpc3YD72WykvDXWcyz7Yu1njJB0UB79SGX4rgW4ypRBcD3QqeYGsieX8UnO9Iw2tl6tsgH/fXfVD1egu0zwea8YQWNYRQ5ZHRBroXbIQI9zoqPV/mC8BlrygfFigLLkEg4vpJynQkl4jypA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=UyoqSUdK; arc=none smtp.client-ip=209.85.214.196 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="UyoqSUdK" Received: by mail-pl1-f196.google.com with SMTP id d9443c01a7336-20b8be13cb1so19175975ad.1; Tue, 01 Oct 2024 00:59:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769560; x=1728374360; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=bJgMV83YGvWt1YNE++o8zIiouv7p8uQ7lLthenlKlXM=; b=UyoqSUdKWOp2ttuOKgO3Lnj6DRLdssEy4aMdcMDnmFUllRxd4j2Qow8BAvRHm1yO/7 j6fzGJlBxcEH8LTUDfPYrAfRFPW5ftOtLmwwPPI5gt/GgYX+zAy2fS0vTus0gpa3W87A /ACYcfnX8hxdT2R7t8GXRl6jGARGiBaNj3PnE9/sG2lL/nvmymzgqWx8p+cXnedh6zD3 4hUAC5lDzicttr2RPJiR2d3Kh1ymOtowdAL3cX8Ek6f7lAFHS6Q1Wib0UexEbxlWfwap AUQGQOrBYnP0ei4C5G5Dl9ICs5OqsmDzhoQJsC/dr8412W5npHRMGEX05lk307FIi7Dl oivw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769560; x=1728374360; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=bJgMV83YGvWt1YNE++o8zIiouv7p8uQ7lLthenlKlXM=; b=RywRKExi4eCr8zzclmerBWc0ZrpP03iIpHt6ap6BvNf0BrqCLo6qlLHoQ82Kj9/3bY CGC/l0THZtfZL39Bm8Stc3TmdtdiNvnXN73sTnCfmCnfSmqH9koK2U+7F0NEGqjNsdwS XWy3CE4rV04X6/dJUt+D4XOjnyTeDJaUdEZJQtL+JIBuTbmzqfPkqZWFgwpyH3ruODEt VN/qBStOAl4E9pa5nHY8fMJeu0IOE2rQ5nrnXMyCE+6JrSoEXG4rjeZOWbWdwUE1Sz55 ljGPOL+qWcDtimlOxtAQM0kBSuJiM6b0PjisE6niWJy66jAVbOtG8VopSPaJwYPLWe/S gKsA== X-Forwarded-Encrypted: i=1; AJvYcCUK/Pk0jleK264ufChp1qKLI1zrmEKMVACYs/47fdSrGPVxgD9jWJhbdzx7KVpO7VlxSRztCIS8pmsBpXs/mxRE@vger.kernel.org, AJvYcCWF96re8Zjmrqn/YGnZRpyoZKe0WW54PHdVHZ8gyvJOJculG5oYT53+lgpU5xpL5KPVZ3aGEHfWEZPi7t0=@vger.kernel.org X-Gm-Message-State: AOJu0YzJR0KK5IcQgIybrkViKHb5Y2bBkg9H7HdqzBbZwxiz5K/JiW+C Re28I32DIHJ41eE2H+vT8NhZr8ZucF7ecLwzS1u5ECzb4GzJADRR X-Google-Smtp-Source: AGHT+IHzcts/01i8+FgR6inTEYf/0bSOr5mGzvAa5EPSJQ1v0Y75HJyrMxr4NCeYxCPBTTipwb3fLA== X-Received: by 2002:a17:90a:2dc1:b0:2c9:9f2a:2b20 with SMTP id 98e67ed59e1d1-2e0b8b19a63mr17592544a91.22.1727769560412; Tue, 01 Oct 2024 00:59:20 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.00.59.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 00:59:20 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , David Howells , Alexander Duyck , Andrew Morton , Alexander Duyck , Eric Dumazet , Shuah Khan , linux-mm@kvack.org, linux-kselftest@vger.kernel.org Subject: [PATCH net-next v19 02/14] mm: move the page fragment allocator from page_alloc into its own file Date: Tue, 1 Oct 2024 15:58:45 +0800 Message-Id: <20241001075858.48936-3-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Inspired by [1], move the page fragment allocator from page_alloc into its own c file and header file, as we are about to make more change for it to replace another page_frag implementation in sock.c As this patchset is going to replace 'struct page_frag' with 'struct page_frag_cache' in sched.h, including page_frag_cache.h in sched.h has a compiler error caused by interdependence between mm_types.h and mm.h for asm-offsets.c, see [2]. So avoid the compiler error by moving 'struct page_frag_cache' to mm_types_task.h as suggested by Alexander, see [3]. 1. https://lore.kernel.org/all/20230411160902.4134381-3-dhowells@redhat.com/ 2. https://lore.kernel.org/all/15623dac-9358-4597-b3ee-3694a5956920@gmail.c= om/ 3. https://lore.kernel.org/all/CAKgT0UdH1yD=3DLSCXFJ=3DYM_aiA4OomD-2wXykO42= bizaWMt_HOA@mail.gmail.com/ CC: David Howells CC: Alexander Duyck Signed-off-by: Yunsheng Lin Acked-by: Andrew Morton Reviewed-by: Alexander Duyck --- include/linux/gfp.h | 22 --- include/linux/mm_types.h | 18 --- include/linux/mm_types_task.h | 18 +++ include/linux/page_frag_cache.h | 31 ++++ include/linux/skbuff.h | 1 + mm/Makefile | 1 + mm/page_alloc.c | 136 ---------------- mm/page_frag_cache.c | 145 ++++++++++++++++++ .../selftests/mm/page_frag/page_frag_test.c | 2 +- 9 files changed, 197 insertions(+), 177 deletions(-) create mode 100644 include/linux/page_frag_cache.h create mode 100644 mm/page_frag_cache.c diff --git a/include/linux/gfp.h b/include/linux/gfp.h index a951de920e20..a0a6d25f883f 100644 --- a/include/linux/gfp.h +++ b/include/linux/gfp.h @@ -371,28 +371,6 @@ __meminit void *alloc_pages_exact_nid_noprof(int nid, = size_t size, gfp_t gfp_mas extern void __free_pages(struct page *page, unsigned int order); extern void free_pages(unsigned long addr, unsigned int order); =20 -struct page_frag_cache; -void page_frag_cache_drain(struct page_frag_cache *nc); -extern void __page_frag_cache_drain(struct page *page, unsigned int count); -void *__page_frag_alloc_align(struct page_frag_cache *nc, unsigned int fra= gsz, - gfp_t gfp_mask, unsigned int align_mask); - -static inline void *page_frag_alloc_align(struct page_frag_cache *nc, - unsigned int fragsz, gfp_t gfp_mask, - unsigned int align) -{ - WARN_ON_ONCE(!is_power_of_2(align)); - return __page_frag_alloc_align(nc, fragsz, gfp_mask, -align); -} - -static inline void *page_frag_alloc(struct page_frag_cache *nc, - unsigned int fragsz, gfp_t gfp_mask) -{ - return __page_frag_alloc_align(nc, fragsz, gfp_mask, ~0u); -} - -extern void page_frag_free(void *addr); - #define __free_page(page) __free_pages((page), 0) #define free_page(addr) free_pages((addr), 0) =20 diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h index 6e3bdf8e38bc..92314ef2d978 100644 --- a/include/linux/mm_types.h +++ b/include/linux/mm_types.h @@ -521,9 +521,6 @@ static_assert(sizeof(struct ptdesc) <=3D sizeof(struct = page)); */ #define STRUCT_PAGE_MAX_SHIFT (order_base_2(sizeof(struct page))) =20 -#define PAGE_FRAG_CACHE_MAX_SIZE __ALIGN_MASK(32768, ~PAGE_MASK) -#define PAGE_FRAG_CACHE_MAX_ORDER get_order(PAGE_FRAG_CACHE_MAX_SIZE) - /* * page_private can be used on tail pages. However, PagePrivate is only * checked by the VM on the head page. So page_private on the tail pages @@ -542,21 +539,6 @@ static inline void *folio_get_private(struct folio *fo= lio) return folio->private; } =20 -struct page_frag_cache { - void * va; -#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) - __u16 offset; - __u16 size; -#else - __u32 offset; -#endif - /* we maintain a pagecount bias, so that we dont dirty cache line - * containing page->_refcount every time we allocate a fragment. - */ - unsigned int pagecnt_bias; - bool pfmemalloc; -}; - typedef unsigned long vm_flags_t; =20 /* diff --git a/include/linux/mm_types_task.h b/include/linux/mm_types_task.h index bff5706b76e1..0ac6daebdd5c 100644 --- a/include/linux/mm_types_task.h +++ b/include/linux/mm_types_task.h @@ -8,6 +8,7 @@ * (These are defined separately to decouple sched.h from mm_types.h as mu= ch as possible.) */ =20 +#include #include =20 #include @@ -43,6 +44,23 @@ struct page_frag { #endif }; =20 +#define PAGE_FRAG_CACHE_MAX_SIZE __ALIGN_MASK(32768, ~PAGE_MASK) +#define PAGE_FRAG_CACHE_MAX_ORDER get_order(PAGE_FRAG_CACHE_MAX_SIZE) +struct page_frag_cache { + void *va; +#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) + __u16 offset; + __u16 size; +#else + __u32 offset; +#endif + /* we maintain a pagecount bias, so that we dont dirty cache line + * containing page->_refcount every time we allocate a fragment. + */ + unsigned int pagecnt_bias; + bool pfmemalloc; +}; + /* Track pages that require TLB flushes */ struct tlbflush_unmap_batch { #ifdef CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH diff --git a/include/linux/page_frag_cache.h b/include/linux/page_frag_cach= e.h new file mode 100644 index 000000000000..67ac8626ed9b --- /dev/null +++ b/include/linux/page_frag_cache.h @@ -0,0 +1,31 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef _LINUX_PAGE_FRAG_CACHE_H +#define _LINUX_PAGE_FRAG_CACHE_H + +#include +#include +#include + +void page_frag_cache_drain(struct page_frag_cache *nc); +void __page_frag_cache_drain(struct page *page, unsigned int count); +void *__page_frag_alloc_align(struct page_frag_cache *nc, unsigned int fra= gsz, + gfp_t gfp_mask, unsigned int align_mask); + +static inline void *page_frag_alloc_align(struct page_frag_cache *nc, + unsigned int fragsz, gfp_t gfp_mask, + unsigned int align) +{ + WARN_ON_ONCE(!is_power_of_2(align)); + return __page_frag_alloc_align(nc, fragsz, gfp_mask, -align); +} + +static inline void *page_frag_alloc(struct page_frag_cache *nc, + unsigned int fragsz, gfp_t gfp_mask) +{ + return __page_frag_alloc_align(nc, fragsz, gfp_mask, ~0u); +} + +void page_frag_free(void *addr); + +#endif diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h index 39f1d16f3628..560e2b49f98b 100644 --- a/include/linux/skbuff.h +++ b/include/linux/skbuff.h @@ -31,6 +31,7 @@ #include #include #include +#include #include #if IS_ENABLED(CONFIG_NF_CONNTRACK) #include diff --git a/mm/Makefile b/mm/Makefile index d5639b036166..dba52bb0da8a 100644 --- a/mm/Makefile +++ b/mm/Makefile @@ -65,6 +65,7 @@ page-alloc-$(CONFIG_SHUFFLE_PAGE_ALLOCATOR) +=3D shuffle.o memory-hotplug-$(CONFIG_MEMORY_HOTPLUG) +=3D memory_hotplug.o =20 obj-y +=3D page-alloc.o +obj-y +=3D page_frag_cache.o obj-y +=3D init-mm.o obj-y +=3D memblock.o obj-y +=3D $(memory-hotplug-y) diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 8afab64814dc..6ca2abce857b 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -4836,142 +4836,6 @@ void free_pages(unsigned long addr, unsigned int or= der) =20 EXPORT_SYMBOL(free_pages); =20 -/* - * Page Fragment: - * An arbitrary-length arbitrary-offset area of memory which resides - * within a 0 or higher order page. Multiple fragments within that page - * are individually refcounted, in the page's reference counter. - * - * The page_frag functions below provide a simple allocation framework for - * page fragments. This is used by the network stack and network device - * drivers to provide a backing region of memory for use as either an - * sk_buff->head, or to be used in the "frags" portion of skb_shared_info. - */ -static struct page *__page_frag_cache_refill(struct page_frag_cache *nc, - gfp_t gfp_mask) -{ - struct page *page =3D NULL; - gfp_t gfp =3D gfp_mask; - -#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) - gfp_mask =3D (gfp_mask & ~__GFP_DIRECT_RECLAIM) | __GFP_COMP | - __GFP_NOWARN | __GFP_NORETRY | __GFP_NOMEMALLOC; - page =3D alloc_pages_node(NUMA_NO_NODE, gfp_mask, - PAGE_FRAG_CACHE_MAX_ORDER); - nc->size =3D page ? PAGE_FRAG_CACHE_MAX_SIZE : PAGE_SIZE; -#endif - if (unlikely(!page)) - page =3D alloc_pages_node(NUMA_NO_NODE, gfp, 0); - - nc->va =3D page ? page_address(page) : NULL; - - return page; -} - -void page_frag_cache_drain(struct page_frag_cache *nc) -{ - if (!nc->va) - return; - - __page_frag_cache_drain(virt_to_head_page(nc->va), nc->pagecnt_bias); - nc->va =3D NULL; -} -EXPORT_SYMBOL(page_frag_cache_drain); - -void __page_frag_cache_drain(struct page *page, unsigned int count) -{ - VM_BUG_ON_PAGE(page_ref_count(page) =3D=3D 0, page); - - if (page_ref_sub_and_test(page, count)) - free_unref_page(page, compound_order(page)); -} -EXPORT_SYMBOL(__page_frag_cache_drain); - -void *__page_frag_alloc_align(struct page_frag_cache *nc, - unsigned int fragsz, gfp_t gfp_mask, - unsigned int align_mask) -{ - unsigned int size =3D PAGE_SIZE; - struct page *page; - int offset; - - if (unlikely(!nc->va)) { -refill: - page =3D __page_frag_cache_refill(nc, gfp_mask); - if (!page) - return NULL; - -#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) - /* if size can vary use size else just use PAGE_SIZE */ - size =3D nc->size; -#endif - /* Even if we own the page, we do not use atomic_set(). - * This would break get_page_unless_zero() users. - */ - page_ref_add(page, PAGE_FRAG_CACHE_MAX_SIZE); - - /* reset page count bias and offset to start of new frag */ - nc->pfmemalloc =3D page_is_pfmemalloc(page); - nc->pagecnt_bias =3D PAGE_FRAG_CACHE_MAX_SIZE + 1; - nc->offset =3D size; - } - - offset =3D nc->offset - fragsz; - if (unlikely(offset < 0)) { - page =3D virt_to_page(nc->va); - - if (!page_ref_sub_and_test(page, nc->pagecnt_bias)) - goto refill; - - if (unlikely(nc->pfmemalloc)) { - free_unref_page(page, compound_order(page)); - goto refill; - } - -#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) - /* if size can vary use size else just use PAGE_SIZE */ - size =3D nc->size; -#endif - /* OK, page count is 0, we can safely set it */ - set_page_count(page, PAGE_FRAG_CACHE_MAX_SIZE + 1); - - /* reset page count bias and offset to start of new frag */ - nc->pagecnt_bias =3D PAGE_FRAG_CACHE_MAX_SIZE + 1; - offset =3D size - fragsz; - if (unlikely(offset < 0)) { - /* - * The caller is trying to allocate a fragment - * with fragsz > PAGE_SIZE but the cache isn't big - * enough to satisfy the request, this may - * happen in low memory conditions. - * We don't release the cache page because - * it could make memory pressure worse - * so we simply return NULL here. - */ - return NULL; - } - } - - nc->pagecnt_bias--; - offset &=3D align_mask; - nc->offset =3D offset; - - return nc->va + offset; -} -EXPORT_SYMBOL(__page_frag_alloc_align); - -/* - * Frees a page fragment allocated out of either a compound or order 0 pag= e. - */ -void page_frag_free(void *addr) -{ - struct page *page =3D virt_to_head_page(addr); - - if (unlikely(put_page_testzero(page))) - free_unref_page(page, compound_order(page)); -} -EXPORT_SYMBOL(page_frag_free); - static void *make_alloc_exact(unsigned long addr, unsigned int order, size_t size) { diff --git a/mm/page_frag_cache.c b/mm/page_frag_cache.c new file mode 100644 index 000000000000..609a485cd02a --- /dev/null +++ b/mm/page_frag_cache.c @@ -0,0 +1,145 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Page fragment allocator + * + * Page Fragment: + * An arbitrary-length arbitrary-offset area of memory which resides with= in a + * 0 or higher order page. Multiple fragments within that page are + * individually refcounted, in the page's reference counter. + * + * The page_frag functions provide a simple allocation framework for page + * fragments. This is used by the network stack and network device driver= s to + * provide a backing region of memory for use as either an sk_buff->head, = or to + * be used in the "frags" portion of skb_shared_info. + */ + +#include +#include +#include +#include +#include +#include "internal.h" + +static struct page *__page_frag_cache_refill(struct page_frag_cache *nc, + gfp_t gfp_mask) +{ + struct page *page =3D NULL; + gfp_t gfp =3D gfp_mask; + +#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) + gfp_mask =3D (gfp_mask & ~__GFP_DIRECT_RECLAIM) | __GFP_COMP | + __GFP_NOWARN | __GFP_NORETRY | __GFP_NOMEMALLOC; + page =3D alloc_pages_node(NUMA_NO_NODE, gfp_mask, + PAGE_FRAG_CACHE_MAX_ORDER); + nc->size =3D page ? PAGE_FRAG_CACHE_MAX_SIZE : PAGE_SIZE; +#endif + if (unlikely(!page)) + page =3D alloc_pages_node(NUMA_NO_NODE, gfp, 0); + + nc->va =3D page ? page_address(page) : NULL; + + return page; +} + +void page_frag_cache_drain(struct page_frag_cache *nc) +{ + if (!nc->va) + return; + + __page_frag_cache_drain(virt_to_head_page(nc->va), nc->pagecnt_bias); + nc->va =3D NULL; +} +EXPORT_SYMBOL(page_frag_cache_drain); + +void __page_frag_cache_drain(struct page *page, unsigned int count) +{ + VM_BUG_ON_PAGE(page_ref_count(page) =3D=3D 0, page); + + if (page_ref_sub_and_test(page, count)) + free_unref_page(page, compound_order(page)); +} +EXPORT_SYMBOL(__page_frag_cache_drain); + +void *__page_frag_alloc_align(struct page_frag_cache *nc, + unsigned int fragsz, gfp_t gfp_mask, + unsigned int align_mask) +{ + unsigned int size =3D PAGE_SIZE; + struct page *page; + int offset; + + if (unlikely(!nc->va)) { +refill: + page =3D __page_frag_cache_refill(nc, gfp_mask); + if (!page) + return NULL; + +#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) + /* if size can vary use size else just use PAGE_SIZE */ + size =3D nc->size; +#endif + /* Even if we own the page, we do not use atomic_set(). + * This would break get_page_unless_zero() users. + */ + page_ref_add(page, PAGE_FRAG_CACHE_MAX_SIZE); + + /* reset page count bias and offset to start of new frag */ + nc->pfmemalloc =3D page_is_pfmemalloc(page); + nc->pagecnt_bias =3D PAGE_FRAG_CACHE_MAX_SIZE + 1; + nc->offset =3D size; + } + + offset =3D nc->offset - fragsz; + if (unlikely(offset < 0)) { + page =3D virt_to_page(nc->va); + + if (!page_ref_sub_and_test(page, nc->pagecnt_bias)) + goto refill; + + if (unlikely(nc->pfmemalloc)) { + free_unref_page(page, compound_order(page)); + goto refill; + } + +#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) + /* if size can vary use size else just use PAGE_SIZE */ + size =3D nc->size; +#endif + /* OK, page count is 0, we can safely set it */ + set_page_count(page, PAGE_FRAG_CACHE_MAX_SIZE + 1); + + /* reset page count bias and offset to start of new frag */ + nc->pagecnt_bias =3D PAGE_FRAG_CACHE_MAX_SIZE + 1; + offset =3D size - fragsz; + if (unlikely(offset < 0)) { + /* + * The caller is trying to allocate a fragment + * with fragsz > PAGE_SIZE but the cache isn't big + * enough to satisfy the request, this may + * happen in low memory conditions. + * We don't release the cache page because + * it could make memory pressure worse + * so we simply return NULL here. + */ + return NULL; + } + } + + nc->pagecnt_bias--; + offset &=3D align_mask; + nc->offset =3D offset; + + return nc->va + offset; +} +EXPORT_SYMBOL(__page_frag_alloc_align); + +/* + * Frees a page fragment allocated out of either a compound or order 0 pag= e. + */ +void page_frag_free(void *addr) +{ + struct page *page =3D virt_to_head_page(addr); + + if (unlikely(put_page_testzero(page))) + free_unref_page(page, compound_order(page)); +} +EXPORT_SYMBOL(page_frag_free); diff --git a/tools/testing/selftests/mm/page_frag/page_frag_test.c b/tools/= testing/selftests/mm/page_frag/page_frag_test.c index eeb2b6bc681a..fdf204550c9a 100644 --- a/tools/testing/selftests/mm/page_frag/page_frag_test.c +++ b/tools/testing/selftests/mm/page_frag/page_frag_test.c @@ -6,12 +6,12 @@ * Copyright (C) 2024 Yunsheng Lin */ =20 -#include #include #include #include #include #include +#include =20 static struct ptr_ring ptr_ring; static int nr_objs =3D 512; --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pj1-f66.google.com (mail-pj1-f66.google.com [209.85.216.66]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B9D9C1BE226; Tue, 1 Oct 2024 07:59:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.66 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769567; cv=none; b=R+J6MbbaTi/gUrwLAMKuGGvUH+KyTj59c7fl5MCB8WG6BcGruKEK3imJFbpyQ4ak0VvPdIcu0w+B0StH3PguHle/iVHTIQCvDtYWFV9vvyZM4DgdiHQxIRqkRERPGB0ryd3IjEB5GeIf/pSz2DGjqzPChS6LqDlHmnr/7yDwfpQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769567; c=relaxed/simple; bh=UDY2Xjo48piYHKG82PIWe9HXrv7cuPypmF3vaFHwxNk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=G5v0QWaKB1ZhZHw4gWsWggiy+Mp11ggisIFb4a2axd65eDPjpo2FImcYwAb+YRp5Oj8X8duXJceRRFh0u0XpXFEXCPNYwM4gCk4gukiiHTJYkhBuGoxz1ZlaUjlAZlaQIPh1YNVoAb77xWjU4hvrDEdV/jgY4O3qvwAn5VS0n7s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=SOivs9YV; arc=none smtp.client-ip=209.85.216.66 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="SOivs9YV" Received: by mail-pj1-f66.google.com with SMTP id 98e67ed59e1d1-2e0b0142bbfso3267341a91.1; Tue, 01 Oct 2024 00:59:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769565; x=1728374365; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=jYCVdOudHYSEPLdfqa+bP8zA1NgdXBDfEGsBksPcr7U=; b=SOivs9YVDVhB6YcIdXBJQvXjv575YJVmZO6wFv2lWmqsgqxEWWlmy05DTGay8+nTx7 SMCjaGXjpROZHJsf5Ct2AwftW1a/3YdGK1TnaCNMhJbBpVQssCdojaXbKiRY8MrLqJTF iptGu4tVIWoPOjMOuwjEGAfQvajwNzI4MAHu8C+0O3314fg9ff9YnPvzgAaE86thqYbJ vOU7lo+j4hk0kqLnYECea7KuXNZ997PtjxfvxFRMVzJNihXtom8hoLoL/dAtQoCNv07/ TDYIGH0c3CQOYEcAoBnoJu+x1yyaJguBDkqVS5LriHYDednMgYFyFrTSBOcMMrwJbKm+ Yk2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769565; x=1728374365; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=jYCVdOudHYSEPLdfqa+bP8zA1NgdXBDfEGsBksPcr7U=; b=dFWQnclmPita0q9in29gzIzdfJDrgPg07k6NiiqBNjfSSBRcXjgt2cyeVx3tobbWnf aey7g9Id6xMnCxYJNUx7ynAo+XebjKXb4a+Ta+UGKUkXUsyMWW2Zk5I1nLmwIFVrN6g+ McpPEaH9D7dIhsWeBRjqwGk9wTU47xpJQcqU6gXCQv6aJOU3LbppJ4RZTxpwZWK5oGuA IT4Jkl3PUfNncYby/xnaAk0m8Zp7A0haP6kNOmcsAPp/g8ylOBNZ5mrOTs8QUAzcGGWC Zht0d+Xd7NepgBTASOr463zzUhH8LMc5ao9a8XIEMgP1n036cGT9qdqBJ42P/atlgDav dNXg== X-Forwarded-Encrypted: i=1; AJvYcCWQYSJd+PaTtmiXM1NNQNb7gfcXtHf5xFNDdJoR3jE59Lf02YEUQD7gVo5zy79M3KqE4nfen53IdDJBk8E=@vger.kernel.org X-Gm-Message-State: AOJu0YzKeh7bkyf+49ujTPCPoi39HzGH9Ax1zb5cYlXrGHqfYySJHwWI WeXPRi8c9Ahe993kh/F4IqnJoCpZopnd9LODc8dSextuJeaPX25i X-Google-Smtp-Source: AGHT+IGyubSkW0LS2Q/mlw0qfA+FvSuoj1p26auGSTL84vixBHJ3lx7Y9nlk/IPOdCecjBEq2pxNbw== X-Received: by 2002:a17:90b:4d04:b0:2e0:a9e8:bb95 with SMTP id 98e67ed59e1d1-2e15a19ec2dmr3403921a91.3.1727769564970; Tue, 01 Oct 2024 00:59:24 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.00.59.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 00:59:24 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Alexander Duyck , Andrew Morton , linux-mm@kvack.org Subject: [PATCH net-next v19 03/14] mm: page_frag: use initial zero offset for page_frag_alloc_align() Date: Tue, 1 Oct 2024 15:58:46 +0800 Message-Id: <20241001075858.48936-4-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" We are about to use page_frag_alloc_*() API to not just allocate memory for skb->data, but also use them to do the memory allocation for skb frag too. Currently the implementation of page_frag in mm subsystem is running the offset as a countdown rather than count-up value, there may have several advantages to that as mentioned in [1], but it may have some disadvantages, for example, it may disable skb frag coalescing and more correct cache prefetching We have a trade-off to make in order to have a unified implementation and API for page_frag, so use a initial zero offset in this patch, and the following patch will try to make some optimization to avoid the disadvantages as much as possible. 1. https://lore.kernel.org/all/f4abe71b3439b39d17a6fb2d410180f367cadf5c.cam= el@gmail.com/ CC: Alexander Duyck Signed-off-by: Yunsheng Lin Reviewed-by: Alexander Duyck --- mm/page_frag_cache.c | 46 ++++++++++++++++++++++---------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/mm/page_frag_cache.c b/mm/page_frag_cache.c index 609a485cd02a..4c8e04379cb3 100644 --- a/mm/page_frag_cache.c +++ b/mm/page_frag_cache.c @@ -63,9 +63,13 @@ void *__page_frag_alloc_align(struct page_frag_cache *nc, unsigned int fragsz, gfp_t gfp_mask, unsigned int align_mask) { +#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) + unsigned int size =3D nc->size; +#else unsigned int size =3D PAGE_SIZE; +#endif + unsigned int offset; struct page *page; - int offset; =20 if (unlikely(!nc->va)) { refill: @@ -85,11 +89,24 @@ void *__page_frag_alloc_align(struct page_frag_cache *n= c, /* reset page count bias and offset to start of new frag */ nc->pfmemalloc =3D page_is_pfmemalloc(page); nc->pagecnt_bias =3D PAGE_FRAG_CACHE_MAX_SIZE + 1; - nc->offset =3D size; + nc->offset =3D 0; } =20 - offset =3D nc->offset - fragsz; - if (unlikely(offset < 0)) { + offset =3D __ALIGN_KERNEL_MASK(nc->offset, ~align_mask); + if (unlikely(offset + fragsz > size)) { + if (unlikely(fragsz > PAGE_SIZE)) { + /* + * The caller is trying to allocate a fragment + * with fragsz > PAGE_SIZE but the cache isn't big + * enough to satisfy the request, this may + * happen in low memory conditions. + * We don't release the cache page because + * it could make memory pressure worse + * so we simply return NULL here. + */ + return NULL; + } + page =3D virt_to_page(nc->va); =20 if (!page_ref_sub_and_test(page, nc->pagecnt_bias)) @@ -100,33 +117,16 @@ void *__page_frag_alloc_align(struct page_frag_cache = *nc, goto refill; } =20 -#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) - /* if size can vary use size else just use PAGE_SIZE */ - size =3D nc->size; -#endif /* OK, page count is 0, we can safely set it */ set_page_count(page, PAGE_FRAG_CACHE_MAX_SIZE + 1); =20 /* reset page count bias and offset to start of new frag */ nc->pagecnt_bias =3D PAGE_FRAG_CACHE_MAX_SIZE + 1; - offset =3D size - fragsz; - if (unlikely(offset < 0)) { - /* - * The caller is trying to allocate a fragment - * with fragsz > PAGE_SIZE but the cache isn't big - * enough to satisfy the request, this may - * happen in low memory conditions. - * We don't release the cache page because - * it could make memory pressure worse - * so we simply return NULL here. - */ - return NULL; - } + offset =3D 0; } =20 nc->pagecnt_bias--; - offset &=3D align_mask; - nc->offset =3D offset; + nc->offset =3D offset + fragsz; =20 return nc->va + offset; } --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pj1-f65.google.com (mail-pj1-f65.google.com [209.85.216.65]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C40361BE233; Tue, 1 Oct 2024 07:59:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.65 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769577; cv=none; b=EM9PNPpxPJR/5NTUXMmZQJVfQ5LXmklreF/qlfy1zGxCzFcUJKh/jL5DRreMfuLqO+WTWk+LLApZM2Ww3sq+pgpFSAKpvVApMUWPlamAktdGpY+U3cL/0N240xukOQYiwhoY23V/Eky0g/HHB7yqkeEwIgZHVGSiOaDXcH1nqE8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769577; c=relaxed/simple; bh=7u9cByNn+AJUO28aQhpxRgxL9HZmWejhnVAxuPd9L1k=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=E4IfsA46EdGbBC24K4EjnSlFYrUZL6EqEQU0K7wOEnZXa/d94ylRT+DOVGqxU8Wj43whitm2KgnG7tKw7JNLVLRbI/H3+H/FTEoaFyUTnDm/+ZG5aj8Qrzi666FYmD9z8k5HETVqZRhYhoW6yB9YbrptRrgRS+iYtS3V/7dDk3I= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Xa/QMWAq; arc=none smtp.client-ip=209.85.216.65 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Xa/QMWAq" Received: by mail-pj1-f65.google.com with SMTP id 98e67ed59e1d1-2e0b93157caso2999958a91.0; Tue, 01 Oct 2024 00:59:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769574; x=1728374374; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=vktSfFznxxqxdyooYxAJtLpLR+uBOH4pDsLUZk+TldI=; b=Xa/QMWAqks6qScJW12s0S833sVNmt+nAJafSNF43CyInb/4ovUMob56d781hkMSw5v ZbJAGD2sZCo+65WzVpahoVSYtCbEeqHtfvsqY3R7lzEtwsMHKP+NGuRcMBfNcrC8y/q4 8Hdin0EkcZaqTBrSfUiUo7CW6Zjrf92tjYrq6GrJKlZx/xRcQn/OR/I7CMiJQLwY+p8w 7IUHf0hdq8LRfEQzwOFkTXR1tRlphNpewrOo0N2EHKOaSzmQthfyN7BzxGBCnaP9a/SL 5RSLz0XhkC7BKL+o85j/X0VC57RU7DPlLbY5w7L++Zd4QFsBHKuQwmThvG/Aun0paJKg nhpw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769574; x=1728374374; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=vktSfFznxxqxdyooYxAJtLpLR+uBOH4pDsLUZk+TldI=; b=c7KMF2IQASHCBS1rwMwfA4NG+Ui/qyhBGBRqAwIeviJR2sN0BylR6ceD7AK+PQ+sfJ 4GAG9E2T8BwW4qOgjGoy2dBATFPwzc6aOMz5dXYzUOUTCIsp+oQ0euE0+96KXKe7Ao9J uvm+H+eTXEEo8ZBG1qstx28veof5siHYh8kUAVndsR1jZC/J209veot9G2CkZT+5WWNm PGz+3/cJCKOgU6eobmAH0BJbZLjcG+fSWpT7wMOh6wKQOfDXqVVWYm60N08Wq/+MrSi0 zzpc4rAk7RmXykpzEarW5teOwEmgGy7CfrKFHZTsqr0FatlCF1Dcp+73BcEDqSUkN8kc 41Ng== X-Forwarded-Encrypted: i=1; AJvYcCUJ2qgfKZqP3TWW8lIf51hHl++qBjeiVByTwMEIIkSo2YLIHot5eoa8GC2xvoPcs4GVCpYjx/JlZFHN@vger.kernel.org, AJvYcCVjsVdmc2yDJ078YzHJsJLTOaAZHxBd8fhKOCv9jCpBb9JraCA7fApM7zzgj7rvY8SWQ08=@vger.kernel.org, AJvYcCWRqPZKKqEwre1g8uwjeeITxgUjNlJMnnrQLU9Vpczwz6c+84IuBJhh97Q4k2RTnz+XknuktLeI8luOx3vQ@vger.kernel.org, AJvYcCWdEcMha8DtqH/Ob2upuzntMvclFNIQQRqy3/PxGPKM4oJweE2gO2LI6ZZ/vfa2QxlD6tnWoxST2KHz/byVbHTS@vger.kernel.org X-Gm-Message-State: AOJu0Yw0b8ywHaOQAe1hOtw0juwsyG+EQvhnwOuBKVENSftESZQxg5cT epdSrCTAqt9WDNMe/D2cVtOwMd7IqUWswiHmRnaJFj7TNdngsSi1 X-Google-Smtp-Source: AGHT+IH1qx+VpqO/M0ZFFo8jx2Ltv6BvYYP7WVtyTnNPIJSUx7pF6s/8RS08Pp9OK0t2pqi6/zCT9A== X-Received: by 2002:a17:90a:2f65:b0:2d8:999a:bc37 with SMTP id 98e67ed59e1d1-2e15a34cfe8mr3372002a91.19.1727769574029; Tue, 01 Oct 2024 00:59:34 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.00.59.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 00:59:33 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Alexander Duyck , Chuck Lever , "Michael S. Tsirkin" , Jason Wang , =?UTF-8?q?Eugenio=20P=C3=A9rez?= , Andrew Morton , Eric Dumazet , David Howells , Marc Dionne , Trond Myklebust , Anna Schumaker , Jeff Layton , Neil Brown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Shuah Khan , kvm@vger.kernel.org, virtualization@lists.linux.dev, linux-mm@kvack.org, linux-afs@lists.infradead.org, linux-nfs@vger.kernel.org, linux-kselftest@vger.kernel.org Subject: [PATCH net-next v19 04/14] mm: page_frag: avoid caller accessing 'page_frag_cache' directly Date: Tue, 1 Oct 2024 15:58:47 +0800 Message-Id: <20241001075858.48936-5-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use appropriate frag_page API instead of caller accessing 'page_frag_cache' directly. CC: Alexander Duyck Signed-off-by: Yunsheng Lin Reviewed-by: Alexander Duyck Acked-by: Chuck Lever --- drivers/vhost/net.c | 2 +- include/linux/page_frag_cache.h | 10 ++++++++++ net/core/skbuff.c | 6 +++--- net/rxrpc/conn_object.c | 4 +--- net/rxrpc/local_object.c | 4 +--- net/sunrpc/svcsock.c | 6 ++---- tools/testing/selftests/mm/page_frag/page_frag_test.c | 2 +- 7 files changed, 19 insertions(+), 15 deletions(-) diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c index f16279351db5..9ad37c012189 100644 --- a/drivers/vhost/net.c +++ b/drivers/vhost/net.c @@ -1325,7 +1325,7 @@ static int vhost_net_open(struct inode *inode, struct= file *f) vqs[VHOST_NET_VQ_RX]); =20 f->private_data =3D n; - n->pf_cache.va =3D NULL; + page_frag_cache_init(&n->pf_cache); =20 return 0; } diff --git a/include/linux/page_frag_cache.h b/include/linux/page_frag_cach= e.h index 67ac8626ed9b..0a52f7a179c8 100644 --- a/include/linux/page_frag_cache.h +++ b/include/linux/page_frag_cache.h @@ -7,6 +7,16 @@ #include #include =20 +static inline void page_frag_cache_init(struct page_frag_cache *nc) +{ + nc->va =3D NULL; +} + +static inline bool page_frag_cache_is_pfmemalloc(struct page_frag_cache *n= c) +{ + return !!nc->pfmemalloc; +} + void page_frag_cache_drain(struct page_frag_cache *nc); void __page_frag_cache_drain(struct page *page, unsigned int count); void *__page_frag_alloc_align(struct page_frag_cache *nc, unsigned int fra= gsz, diff --git a/net/core/skbuff.c b/net/core/skbuff.c index 74149dc4ee31..ca01880c7ad0 100644 --- a/net/core/skbuff.c +++ b/net/core/skbuff.c @@ -753,14 +753,14 @@ struct sk_buff *__netdev_alloc_skb(struct net_device = *dev, unsigned int len, if (in_hardirq() || irqs_disabled()) { nc =3D this_cpu_ptr(&netdev_alloc_cache); data =3D page_frag_alloc(nc, len, gfp_mask); - pfmemalloc =3D nc->pfmemalloc; + pfmemalloc =3D page_frag_cache_is_pfmemalloc(nc); } else { local_bh_disable(); local_lock_nested_bh(&napi_alloc_cache.bh_lock); =20 nc =3D this_cpu_ptr(&napi_alloc_cache.page); data =3D page_frag_alloc(nc, len, gfp_mask); - pfmemalloc =3D nc->pfmemalloc; + pfmemalloc =3D page_frag_cache_is_pfmemalloc(nc); =20 local_unlock_nested_bh(&napi_alloc_cache.bh_lock); local_bh_enable(); @@ -850,7 +850,7 @@ struct sk_buff *napi_alloc_skb(struct napi_struct *napi= , unsigned int len) len =3D SKB_HEAD_ALIGN(len); =20 data =3D page_frag_alloc(&nc->page, len, gfp_mask); - pfmemalloc =3D nc->page.pfmemalloc; + pfmemalloc =3D page_frag_cache_is_pfmemalloc(&nc->page); } local_unlock_nested_bh(&napi_alloc_cache.bh_lock); =20 diff --git a/net/rxrpc/conn_object.c b/net/rxrpc/conn_object.c index 1539d315afe7..694c4df7a1a3 100644 --- a/net/rxrpc/conn_object.c +++ b/net/rxrpc/conn_object.c @@ -337,9 +337,7 @@ static void rxrpc_clean_up_connection(struct work_struc= t *work) */ rxrpc_purge_queue(&conn->rx_queue); =20 - if (conn->tx_data_alloc.va) - __page_frag_cache_drain(virt_to_page(conn->tx_data_alloc.va), - conn->tx_data_alloc.pagecnt_bias); + page_frag_cache_drain(&conn->tx_data_alloc); call_rcu(&conn->rcu, rxrpc_rcu_free_connection); } =20 diff --git a/net/rxrpc/local_object.c b/net/rxrpc/local_object.c index 504453c688d7..a8cffe47cf01 100644 --- a/net/rxrpc/local_object.c +++ b/net/rxrpc/local_object.c @@ -452,9 +452,7 @@ void rxrpc_destroy_local(struct rxrpc_local *local) #endif rxrpc_purge_queue(&local->rx_queue); rxrpc_purge_client_connections(local); - if (local->tx_alloc.va) - __page_frag_cache_drain(virt_to_page(local->tx_alloc.va), - local->tx_alloc.pagecnt_bias); + page_frag_cache_drain(&local->tx_alloc); } =20 /* diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c index 825ec5357691..b785425c3315 100644 --- a/net/sunrpc/svcsock.c +++ b/net/sunrpc/svcsock.c @@ -1608,7 +1608,6 @@ static void svc_tcp_sock_detach(struct svc_xprt *xprt) static void svc_sock_free(struct svc_xprt *xprt) { struct svc_sock *svsk =3D container_of(xprt, struct svc_sock, sk_xprt); - struct page_frag_cache *pfc =3D &svsk->sk_frag_cache; struct socket *sock =3D svsk->sk_sock; =20 trace_svcsock_free(svsk, sock); @@ -1618,8 +1617,7 @@ static void svc_sock_free(struct svc_xprt *xprt) sockfd_put(sock); else sock_release(sock); - if (pfc->va) - __page_frag_cache_drain(virt_to_head_page(pfc->va), - pfc->pagecnt_bias); + + page_frag_cache_drain(&svsk->sk_frag_cache); kfree(svsk); } diff --git a/tools/testing/selftests/mm/page_frag/page_frag_test.c b/tools/= testing/selftests/mm/page_frag/page_frag_test.c index fdf204550c9a..36543a129e40 100644 --- a/tools/testing/selftests/mm/page_frag/page_frag_test.c +++ b/tools/testing/selftests/mm/page_frag/page_frag_test.c @@ -117,7 +117,7 @@ static int __init page_frag_test_init(void) u64 duration; int ret; =20 - test_nc.va =3D NULL; + page_frag_cache_init(&test_nc); atomic_set(&nthreads, 2); init_completion(&wait); =20 --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pj1-f66.google.com (mail-pj1-f66.google.com [209.85.216.66]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A51611BE24A; Tue, 1 Oct 2024 07:59:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.66 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769581; cv=none; b=LsLuVLYMxzFExnRQwG9M92nIHNFwpKs83ojO/cPQe3ZKTHNpsEM3SS3rN8R5wjls8/8mhiHQS4zdOZf6ldFuXORD9xw8EoDxI2rDDEt6rLXqsMFOP5SaLsy+kJnRVTmpqGIQP0tnOn6/JWwAjUoQ2BAnYApPhtepweOLc/UVCi8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769581; c=relaxed/simple; bh=NtK2hGPktKlyk/2x5sS20q5yngdVO4+KhsIPU4dLYvg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=ODLeJ5Je3s1jJLheQdsdD64ljHa+V1DD08oGF2c+GD60W1Hq+qnJppz7E2FbeQ6g/CpTi74RSDn/r4crp44DcgkKxSptinwMWlLcxn0y+w33n+08Yd6n28sgj761/C7oftY+5ufX6kKlKxFQ/WWvP0nscPK6BsZtO6FsevFaYxM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=OxadbwLj; arc=none smtp.client-ip=209.85.216.66 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="OxadbwLj" Received: by mail-pj1-f66.google.com with SMTP id 98e67ed59e1d1-2e0a74ce880so4280592a91.2; Tue, 01 Oct 2024 00:59:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769579; x=1728374379; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=+RznI3L05JK1bZbiyr6s7rPTOWr3vTxyFhoEBxlvv1o=; b=OxadbwLjfLHhcMZzRRugjPi8D6CKBVRWTR09L1POpHxrOxT3F6JaIjHgM/nniUgFro p6ol70j8OJepyYHjt2AyvL7eZeUl/Ko4SNq5aYDPojNp7wPHACpHl5fesshA2jOtkYcU 7ThFbLNH+NdA0v3kRfdad+Pc3FY13zmERYgHEezdZI0uZfeGPWxkEZuGflnsbhLxhhKa 8WnrFyFR+aWaX5rtpLLL+XBGcPf+/YLBHYr1qrH8knaHFvYTP8roqUOpUBPH9/RfUvIm 1gvOkss3NA1Al5pp2wzx1uasuVooUutqpzzAxVO4mGMsd7sNW4TYnGtSmUjuLiV8DGRy alfQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769579; x=1728374379; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=+RznI3L05JK1bZbiyr6s7rPTOWr3vTxyFhoEBxlvv1o=; b=dFsS1YjoYwPXdIPk84Rv+KCqvlPO2Z8/yxf+tsFL/6kKKI2+FjvNn7645iDcQ6XL8y fYuZzeI9jVFZhyKSDA7500spZ6E3/p02ChJxw92ER/s0+wCjVF9UOQqjScgsHZyyIhaz ZpsX6OJEb63QTuDWtzgcKatbrrq2fPmFNHmox1GGz9ldNFh4ig5q2OXGw4TawAcoIpkc khvhfETls/VJeOsHXHMGd9z7nXeyKMPiS+L0w7mpSNRxAgBEbiFdsO1oawXa0jTelCKC 8coQ3KdjuzG/q2OmikfQnLjbY16JESrWKMuKeS9eLkoqzcIEeiGQ8AExBqGK9anCMyLr bWqg== X-Forwarded-Encrypted: i=1; AJvYcCUsc9qXYYxuOdu8Wjr1czmdpr0ClUmFfwqmZHpvouq853PisDTvGywby5Xr45m4C8x4RXFKhtzrd7n2V6E=@vger.kernel.org X-Gm-Message-State: AOJu0YxpPw2K5EDcDnwtEd7Gnibr/RdP4O2sPwHIpWLDlmPPfEBk9y0U cpBXG3uY8l6af1RxgPIalh+Ayu5bsyl4Scg11despG8ElJmR3MwN X-Google-Smtp-Source: AGHT+IHh5Q2dpV31K9qn7qcIqGa0E4bPCLWrnqG8WaQA27bq3t3Jru6lvAgsQ2LJq2Kbe+A5T9B44w== X-Received: by 2002:a17:90b:3587:b0:2d8:ca33:42a5 with SMTP id 98e67ed59e1d1-2e0b8ee5895mr14441412a91.40.1727769578855; Tue, 01 Oct 2024 00:59:38 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.00.59.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 00:59:38 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Max Filippov , Alexander Duyck , Chris Zankel Subject: [PATCH net-next v19 05/14] xtensa: remove the get_order() implementation Date: Tue, 1 Oct 2024 15:58:48 +0800 Message-Id: <20241001075858.48936-6-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" As the get_order() implemented by xtensa supporting 'nsau' instruction seems be the same as the generic implementation in include/asm-generic/getorder.h when size is not a constant value as the generic implementation calling the fls*() is also utilizing the 'nsau' instruction for xtensa. So remove the get_order() implemented by xtensa, as using the generic implementation may enable the compiler to do the computing when size is a constant value instead of runtime computing and enable the using of get_order() in BUILD_BUG_ON() macro in next patch. CC: Alexander Duyck Signed-off-by: Yunsheng Lin Acked-by: Max Filippov Reviewed-by: Alexander Duyck --- arch/xtensa/include/asm/page.h | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/arch/xtensa/include/asm/page.h b/arch/xtensa/include/asm/page.h index 4db56ef052d2..8665d57991dd 100644 --- a/arch/xtensa/include/asm/page.h +++ b/arch/xtensa/include/asm/page.h @@ -109,26 +109,8 @@ typedef struct page *pgtable_t; #define __pgd(x) ((pgd_t) { (x) } ) #define __pgprot(x) ((pgprot_t) { (x) } ) =20 -/* - * Pure 2^n version of get_order - * Use 'nsau' instructions if supported by the processor or the generic ve= rsion. - */ - -#if XCHAL_HAVE_NSA - -static inline __attribute_const__ int get_order(unsigned long size) -{ - int lz; - asm ("nsau %0, %1" : "=3Dr" (lz) : "r" ((size - 1) >> PAGE_SHIFT)); - return 32 - lz; -} - -#else - # include =20 -#endif - struct page; struct vm_area_struct; extern void clear_page(void *page); --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pg1-f196.google.com (mail-pg1-f196.google.com [209.85.215.196]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AC4111BDAA9; Tue, 1 Oct 2024 07:59:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.196 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769586; cv=none; b=jeHeT2uRr/XPzf7NwC+vQadLsx8cgUZ6wpsPn4enhlb0Mmq37qde34OjoYpFIYJD38mK0PdEXptBe3HCubs9fU4YKQE4lw7IWeLfCYAdmuo/l11oiCd9kPlUBJtV6kn8IqIqtsX9aqTdHZshc6OPVCMJ4srR+f2KLLNJHDiI15o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769586; c=relaxed/simple; bh=LmJmEvpcC2NZ7YL3p0jcWgycLVf5ESkFlh4tzYxfKcc=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=p3x+eKyjS2inRhZtQgdoiHyeu3GuTWx13EuLgGQTM4g9yLV7QiKBh32/bxBZOg5PEeVqpch6WKe9DK4LXJ1VQGpqaWJd2AjKDDsoR1gXlhbLsWQZquoHF0WgaKElV8gk2g2ol1UMviLogzTuP7VYQ2kmpIY7tg3+RdtK9aCeUUA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Mk83umPQ; arc=none smtp.client-ip=209.85.215.196 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Mk83umPQ" Received: by mail-pg1-f196.google.com with SMTP id 41be03b00d2f7-7d7a9200947so3522340a12.3; Tue, 01 Oct 2024 00:59:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769584; x=1728374384; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=h1flmiq1CIb5dWvur8o1cuFYGIlZjiDxQSttLTSZj20=; b=Mk83umPQbldx7US09B9b+C8Nv9bGRAqpEuRAzT4KQAZxc45/j19mMWglnbCfmewIBl 7i2S3p9qktWNR7TtihU3EvGZtRUDkzTaK8kkPcZWeiMk5b597THSzjB+4SBiWmSAkr3C SQn0Gc1HNbrXrXkv5vdA0fiNux055/J0gheNE9wc/Rpa9ZEggATH/GdfRS5vC5aImms2 Hn9VPwJXoqfrvAZIdYLWTO3UuzG7hIRsLcOfxLgq6un7L+MJ704I+SZpwalBnE2hdKxS HuHEJMClhhAcjdquyIjpFhvqV3MF2rdXmSG3a6NM9Sm5qsvt9rSEBl1J2O7HmhqCLMuQ flaw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769584; x=1728374384; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=h1flmiq1CIb5dWvur8o1cuFYGIlZjiDxQSttLTSZj20=; b=KRn/7faw5ykM9YFxC73FHPeMHyPwEmSKZGG3IqBc9zIguojsF8jEeWxQ76OFDNHl3i qEbS1yKzke2EQrLn5r9DaqbnBwOnvS1v29g7zasySSCnZFyHwfSIS1Y8n9KzKpToIxPQ EV4sqMW63lf8bkMAOtK9iLjFXKvk+fsdwBG4+yWzfK3lhe8KPLnq68veEESIfvI4EwxM qmlpcBIp4+pAPSoKvmdthHmwgJXkhoArrUA+czr32I2X4l+5YHidATa06BlFgzRezJJs 9g9u1Zd+R5cMEDRfsIgejvUghgHe5508Z8rUZO+2Gg1PaHFskoiFXOhGV5UX1QP4hMaH ZkCQ== X-Forwarded-Encrypted: i=1; AJvYcCXP8CRX6bdSMUijy8mi+UG5ORYEsj2jChv5zdt71n6+u72u25SMr4lh3d8sQWpIr8xB/RzJYFoEW7qRakI=@vger.kernel.org X-Gm-Message-State: AOJu0Yyn9zrmbBglWF+xRF9hms8MSJTjQ0AxKyhYdZSQGbhFdH3Vm+KG cx0KXYFJ5zpntFv3Kb/p53x8eE47CJ8uIQyq5wdMfXzd2TjAUXt1rwZ/xnaCTxU= X-Google-Smtp-Source: AGHT+IGWWcq93SolMOcbPJboqSEg9Ubcs85ynCA4UMkBOerDIZugeKeyo4zjy4R1BEFlqXCJokgRZA== X-Received: by 2002:a17:90a:ac02:b0:2e0:8719:5f00 with SMTP id 98e67ed59e1d1-2e0b8b2261dmr17048516a91.22.1727769583943; Tue, 01 Oct 2024 00:59:43 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.00.59.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 00:59:43 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Andrew Morton , linux-mm@kvack.org Subject: [PATCH net-next v19 06/14] mm: page_frag: reuse existing space for 'size' and 'pfmemalloc' Date: Tue, 1 Oct 2024 15:58:49 +0800 Message-Id: <20241001075858.48936-7-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Currently there is one 'struct page_frag' for every 'struct sock' and 'struct task_struct', we are about to replace the 'struct page_frag' with 'struct page_frag_cache' for them. Before begin the replacing, we need to ensure the size of 'struct page_frag_cache' is not bigger than the size of 'struct page_frag', as there may be tens of thousands of 'struct sock' and 'struct task_struct' instances in the system. By or'ing the page order & pfmemalloc with lower bits of 'va' instead of using 'u16' or 'u32' for page size and 'u8' for pfmemalloc, we are able to avoid 3 or 5 bytes space waste. And page address & pfmemalloc & order is unchanged for the same page in the same 'page_frag_cache' instance, it makes sense to fit them together. After this patch, the size of 'struct page_frag_cache' should be the same as the size of 'struct page_frag'. CC: Alexander Duyck Signed-off-by: Yunsheng Lin --- include/linux/mm_types_task.h | 19 +++++---- include/linux/page_frag_cache.h | 26 +++++++++++- mm/page_frag_cache.c | 75 +++++++++++++++++++++++---------- 3 files changed, 88 insertions(+), 32 deletions(-) diff --git a/include/linux/mm_types_task.h b/include/linux/mm_types_task.h index 0ac6daebdd5c..a82aa80c0ba4 100644 --- a/include/linux/mm_types_task.h +++ b/include/linux/mm_types_task.h @@ -47,18 +47,21 @@ struct page_frag { #define PAGE_FRAG_CACHE_MAX_SIZE __ALIGN_MASK(32768, ~PAGE_MASK) #define PAGE_FRAG_CACHE_MAX_ORDER get_order(PAGE_FRAG_CACHE_MAX_SIZE) struct page_frag_cache { - void *va; -#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) + /* encoded_page consists of the virtual address, pfmemalloc bit and + * order of a page. + */ + unsigned long encoded_page; + + /* we maintain a pagecount bias, so that we dont dirty cache line + * containing page->_refcount every time we allocate a fragment. + */ +#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) && (BITS_PER_LONG <=3D 32) __u16 offset; - __u16 size; + __u16 pagecnt_bias; #else __u32 offset; + __u32 pagecnt_bias; #endif - /* we maintain a pagecount bias, so that we dont dirty cache line - * containing page->_refcount every time we allocate a fragment. - */ - unsigned int pagecnt_bias; - bool pfmemalloc; }; =20 /* Track pages that require TLB flushes */ diff --git a/include/linux/page_frag_cache.h b/include/linux/page_frag_cach= e.h index 0a52f7a179c8..75aaad6eaea2 100644 --- a/include/linux/page_frag_cache.h +++ b/include/linux/page_frag_cache.h @@ -3,18 +3,40 @@ #ifndef _LINUX_PAGE_FRAG_CACHE_H #define _LINUX_PAGE_FRAG_CACHE_H =20 +#include #include #include #include =20 +#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) +/* Use a full byte here to enable assembler optimization as the shift + * operation is usually expecting a byte. + */ +#define PAGE_FRAG_CACHE_ORDER_MASK GENMASK(7, 0) +#define PAGE_FRAG_CACHE_PFMEMALLOC_SHIFT 8 +#define PAGE_FRAG_CACHE_PFMEMALLOC_BIT BIT(PAGE_FRAG_CACHE_PFMEMALLOC_SHI= FT) +#else +/* Compiler should be able to figure out we don't read things as any value + * ANDed with 0 is 0. + */ +#define PAGE_FRAG_CACHE_ORDER_MASK 0 +#define PAGE_FRAG_CACHE_PFMEMALLOC_SHIFT 0 +#define PAGE_FRAG_CACHE_PFMEMALLOC_BIT BIT(PAGE_FRAG_CACHE_PFMEMALLOC_SHI= FT) +#endif + +static inline bool page_frag_encoded_page_pfmemalloc(unsigned long encoded= _page) +{ + return !!(encoded_page & PAGE_FRAG_CACHE_PFMEMALLOC_BIT); +} + static inline void page_frag_cache_init(struct page_frag_cache *nc) { - nc->va =3D NULL; + nc->encoded_page =3D 0; } =20 static inline bool page_frag_cache_is_pfmemalloc(struct page_frag_cache *n= c) { - return !!nc->pfmemalloc; + return page_frag_encoded_page_pfmemalloc(nc->encoded_page); } =20 void page_frag_cache_drain(struct page_frag_cache *nc); diff --git a/mm/page_frag_cache.c b/mm/page_frag_cache.c index 4c8e04379cb3..cf9375a81a64 100644 --- a/mm/page_frag_cache.c +++ b/mm/page_frag_cache.c @@ -12,6 +12,7 @@ * be used in the "frags" portion of skb_shared_info. */ =20 +#include #include #include #include @@ -19,9 +20,41 @@ #include #include "internal.h" =20 +static unsigned long page_frag_encode_page(struct page *page, unsigned int= order, + bool pfmemalloc) +{ + BUILD_BUG_ON(PAGE_FRAG_CACHE_MAX_ORDER > PAGE_FRAG_CACHE_ORDER_MASK); + BUILD_BUG_ON(PAGE_FRAG_CACHE_PFMEMALLOC_BIT >=3D PAGE_SIZE); + + return (unsigned long)page_address(page) | + (order & PAGE_FRAG_CACHE_ORDER_MASK) | + ((unsigned long)pfmemalloc << PAGE_FRAG_CACHE_PFMEMALLOC_SHIFT); +} + +static unsigned long page_frag_encoded_page_order(unsigned long encoded_pa= ge) +{ + return encoded_page & PAGE_FRAG_CACHE_ORDER_MASK; +} + +static void *page_frag_encoded_page_address(unsigned long encoded_page) +{ + return (void *)(encoded_page & PAGE_MASK); +} + +static struct page *page_frag_encoded_page_ptr(unsigned long encoded_page) +{ + return virt_to_page((void *)encoded_page); +} + +static unsigned int page_frag_cache_page_size(unsigned long encoded_page) +{ + return PAGE_SIZE << page_frag_encoded_page_order(encoded_page); +} + static struct page *__page_frag_cache_refill(struct page_frag_cache *nc, gfp_t gfp_mask) { + unsigned long order =3D PAGE_FRAG_CACHE_MAX_ORDER; struct page *page =3D NULL; gfp_t gfp =3D gfp_mask; =20 @@ -30,23 +63,26 @@ static struct page *__page_frag_cache_refill(struct pag= e_frag_cache *nc, __GFP_NOWARN | __GFP_NORETRY | __GFP_NOMEMALLOC; page =3D alloc_pages_node(NUMA_NO_NODE, gfp_mask, PAGE_FRAG_CACHE_MAX_ORDER); - nc->size =3D page ? PAGE_FRAG_CACHE_MAX_SIZE : PAGE_SIZE; #endif - if (unlikely(!page)) + if (unlikely(!page)) { page =3D alloc_pages_node(NUMA_NO_NODE, gfp, 0); + order =3D 0; + } =20 - nc->va =3D page ? page_address(page) : NULL; + nc->encoded_page =3D page ? + page_frag_encode_page(page, order, page_is_pfmemalloc(page)) : 0; =20 return page; } =20 void page_frag_cache_drain(struct page_frag_cache *nc) { - if (!nc->va) + if (!nc->encoded_page) return; =20 - __page_frag_cache_drain(virt_to_head_page(nc->va), nc->pagecnt_bias); - nc->va =3D NULL; + __page_frag_cache_drain(page_frag_encoded_page_ptr(nc->encoded_page), + nc->pagecnt_bias); + nc->encoded_page =3D 0; } EXPORT_SYMBOL(page_frag_cache_drain); =20 @@ -63,35 +99,29 @@ void *__page_frag_alloc_align(struct page_frag_cache *n= c, unsigned int fragsz, gfp_t gfp_mask, unsigned int align_mask) { -#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) - unsigned int size =3D nc->size; -#else - unsigned int size =3D PAGE_SIZE; -#endif - unsigned int offset; + unsigned long encoded_page =3D nc->encoded_page; + unsigned int size, offset; struct page *page; =20 - if (unlikely(!nc->va)) { + if (unlikely(!encoded_page)) { refill: page =3D __page_frag_cache_refill(nc, gfp_mask); if (!page) return NULL; =20 -#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) - /* if size can vary use size else just use PAGE_SIZE */ - size =3D nc->size; -#endif + encoded_page =3D nc->encoded_page; + /* Even if we own the page, we do not use atomic_set(). * This would break get_page_unless_zero() users. */ page_ref_add(page, PAGE_FRAG_CACHE_MAX_SIZE); =20 /* reset page count bias and offset to start of new frag */ - nc->pfmemalloc =3D page_is_pfmemalloc(page); nc->pagecnt_bias =3D PAGE_FRAG_CACHE_MAX_SIZE + 1; nc->offset =3D 0; } =20 + size =3D page_frag_cache_page_size(encoded_page); offset =3D __ALIGN_KERNEL_MASK(nc->offset, ~align_mask); if (unlikely(offset + fragsz > size)) { if (unlikely(fragsz > PAGE_SIZE)) { @@ -107,13 +137,14 @@ void *__page_frag_alloc_align(struct page_frag_cache = *nc, return NULL; } =20 - page =3D virt_to_page(nc->va); + page =3D page_frag_encoded_page_ptr(encoded_page); =20 if (!page_ref_sub_and_test(page, nc->pagecnt_bias)) goto refill; =20 - if (unlikely(nc->pfmemalloc)) { - free_unref_page(page, compound_order(page)); + if (unlikely(page_frag_encoded_page_pfmemalloc(encoded_page))) { + free_unref_page(page, + page_frag_encoded_page_order(encoded_page)); goto refill; } =20 @@ -128,7 +159,7 @@ void *__page_frag_alloc_align(struct page_frag_cache *n= c, nc->pagecnt_bias--; nc->offset =3D offset + fragsz; =20 - return nc->va + offset; + return page_frag_encoded_page_address(encoded_page) + offset; } EXPORT_SYMBOL(__page_frag_alloc_align); =20 --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pf1-f196.google.com (mail-pf1-f196.google.com [209.85.210.196]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A55921BFDE0; Tue, 1 Oct 2024 07:59:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.196 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769591; cv=none; b=FoGO3Kn3nuEs+D17kjtfOpMm93TKBMsIaNFUWNSw6bafEt2K+WOw1tpFGS68qvUrYoUmCXeZtZM3rmuyUQOWLKODBjlskNGiA9QQPEt8WUfg3kZky9cPWBvUGqAtkMrhpYf3WnU/nc3g3JKiq0Zwln3mX8EZGXq4WJkz0Hgfnac= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769591; c=relaxed/simple; bh=2VC8JX62znmzKZF7TGEoNh8u9WHkFhSDbG66czdPGPs=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=rysS+8vRMwv3ZIGXgDr5WMk4stFmXvGvaFOj1NhVJHqhFSQF9fBT9bCufriQUKvcM2rUGcTwCTMuBDR42FXzCm77WFmpRVxflg9QmRIbES+Fl9jtDHXtKC9VzQlFYxP+O/dWCCRne05b7jojZjWJcICCW3vQx0bEBXF6uPWhohI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=TSqvNqTz; arc=none smtp.client-ip=209.85.210.196 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="TSqvNqTz" Received: by mail-pf1-f196.google.com with SMTP id d2e1a72fcca58-718e6299191so2771874b3a.2; Tue, 01 Oct 2024 00:59:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769589; x=1728374389; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=gd1RgN1SUA8afyUXxZzVZIDkcTWdN6ZwdQZ6zZRg9I0=; b=TSqvNqTzUFm0OjK2zOVtQhSOR+qC+Vpq0J5pmKBuWUNK+BRHgNSFEPhyWckrGnRqp7 aF6V9D+ecoenqjEsxkC8tDsYuFIJDdvxYm7swe2SPQ4dRTW38fPPYRz/trWcixd7XC3k GWVUf+hXXB3XisHbCDNhHaDPkj3lDWNs7t/yT8l4TnOohVGOuK+r1Rt1pbHPBDErbLYL XQhnqn3q1YPECxJt+Pnt+FdTaX0KHBf+qQ0IHkkrDTvvKBUI2HEODxvKrGPt7CW2sNqP U6kMZy+LvvvH44uoHEWrowyZ5rNX5SpBIpt0HRSy+l8ngVLXOx9sNN1qy0Xpz6BcYwrO I/CA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769589; x=1728374389; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=gd1RgN1SUA8afyUXxZzVZIDkcTWdN6ZwdQZ6zZRg9I0=; b=LMbWyWYSkUGjtYICQsAOOF4Ij2fVRT4CNEtZ0w2lSf08Sr2nlN7kyDYhb5rXMh3VW/ Sd/z4EbJYispAEm3+ZK69DOmw+Z8szR/B1ctN9u65LGzQqC/xcxW9s1ny30iO8qfmiOa GLk1jwyoYigwKsXJIQxxi/SK6kcXlxiQmgsMfNbeFbNdTqeXoh/BFTK/GVbeQUA450OF vKbaZcaBPFPiQi9xtMHVQrELhBiTtpiU/TWtgz5hUboTcdzZzgDtZ6b7hdRUnhAhdqha iQGj455B2BxHlor/4u8zrUO5RC4hZKDbKs/kj+zQZo88+E2EpoFqvIZ9voSliVqibsKp xTFA== X-Forwarded-Encrypted: i=1; AJvYcCWXBqrbDaOcOdD3RlrllX1zWuvTPYnCShzkJ+62RSiHlzYSvvnqoJU5YpnLowXkKZXsnOsFthLuP7lJt6Y=@vger.kernel.org X-Gm-Message-State: AOJu0YwgeUdvOF54vOTkULUtfrweyB58GHxc1gRO/GG5thH2vlhBXgBt gxCbKmnxRucH9DRPqFj40pgRfMwO3CiZ9GO+Y/UHPVYHLAE0S/IX X-Google-Smtp-Source: AGHT+IFZp+Gi8vE0ox+pNEB55COsRo/wNQjqM5glSXrin4ALoGI9vxZDRJ2kDHOmSEGDlwKVj4MDzw== X-Received: by 2002:a05:6a20:6f0a:b0:1cf:2843:f798 with SMTP id adf61e73a8af0-1d4fa7ecda0mr22889063637.47.1727769588834; Tue, 01 Oct 2024 00:59:48 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.00.59.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 00:59:48 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Andrew Morton , linux-mm@kvack.org Subject: [PATCH net-next v19 07/14] mm: page_frag: some minor refactoring before adding new API Date: Tue, 1 Oct 2024 15:58:50 +0800 Message-Id: <20241001075858.48936-8-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Refactor common codes from __page_frag_alloc_va_align() to __page_frag_cache_prepare() and __page_frag_cache_commit(), so that the new API can make use of them. CC: Alexander Duyck Signed-off-by: Yunsheng Lin --- include/linux/page_frag_cache.h | 36 +++++++++++++++++++++++++++-- mm/page_frag_cache.c | 40 ++++++++++++++++++++++++++------- 2 files changed, 66 insertions(+), 10 deletions(-) diff --git a/include/linux/page_frag_cache.h b/include/linux/page_frag_cach= e.h index 75aaad6eaea2..b634e1338741 100644 --- a/include/linux/page_frag_cache.h +++ b/include/linux/page_frag_cache.h @@ -5,6 +5,7 @@ =20 #include #include +#include #include #include =20 @@ -41,8 +42,39 @@ static inline bool page_frag_cache_is_pfmemalloc(struct = page_frag_cache *nc) =20 void page_frag_cache_drain(struct page_frag_cache *nc); void __page_frag_cache_drain(struct page *page, unsigned int count); -void *__page_frag_alloc_align(struct page_frag_cache *nc, unsigned int fra= gsz, - gfp_t gfp_mask, unsigned int align_mask); +void *__page_frag_cache_prepare(struct page_frag_cache *nc, unsigned int f= ragsz, + struct page_frag *pfrag, gfp_t gfp_mask, + unsigned int align_mask); +unsigned int __page_frag_cache_commit_noref(struct page_frag_cache *nc, + struct page_frag *pfrag, + unsigned int used_sz); + +static inline unsigned int __page_frag_cache_commit(struct page_frag_cache= *nc, + struct page_frag *pfrag, + unsigned int used_sz) +{ + VM_BUG_ON(!nc->pagecnt_bias); + nc->pagecnt_bias--; + + return __page_frag_cache_commit_noref(nc, pfrag, used_sz); +} + +static inline void *__page_frag_alloc_align(struct page_frag_cache *nc, + unsigned int fragsz, gfp_t gfp_mask, + unsigned int align_mask) +{ + struct page_frag page_frag; + void *va; + + va =3D __page_frag_cache_prepare(nc, fragsz, &page_frag, gfp_mask, + align_mask); + if (unlikely(!va)) + return NULL; + + __page_frag_cache_commit(nc, &page_frag, fragsz); + + return va; +} =20 static inline void *page_frag_alloc_align(struct page_frag_cache *nc, unsigned int fragsz, gfp_t gfp_mask, diff --git a/mm/page_frag_cache.c b/mm/page_frag_cache.c index cf9375a81a64..6f6e47bbdc8d 100644 --- a/mm/page_frag_cache.c +++ b/mm/page_frag_cache.c @@ -95,9 +95,31 @@ void __page_frag_cache_drain(struct page *page, unsigned= int count) } EXPORT_SYMBOL(__page_frag_cache_drain); =20 -void *__page_frag_alloc_align(struct page_frag_cache *nc, - unsigned int fragsz, gfp_t gfp_mask, - unsigned int align_mask) +unsigned int __page_frag_cache_commit_noref(struct page_frag_cache *nc, + struct page_frag *pfrag, + unsigned int used_sz) +{ + unsigned int orig_offset; + + VM_BUG_ON(used_sz > pfrag->size); + VM_BUG_ON(pfrag->page !=3D page_frag_encoded_page_ptr(nc->encoded_page)); + VM_BUG_ON(pfrag->offset + pfrag->size > + page_frag_cache_page_size(nc->encoded_page)); + + /* pfrag->offset might be bigger than the nc->offset due to alignment */ + VM_BUG_ON(nc->offset > pfrag->offset); + + orig_offset =3D nc->offset; + nc->offset =3D pfrag->offset + used_sz; + + /* Return true size back to caller considering the offset alignment */ + return nc->offset - orig_offset; +} +EXPORT_SYMBOL(__page_frag_cache_commit_noref); + +void *__page_frag_cache_prepare(struct page_frag_cache *nc, unsigned int f= ragsz, + struct page_frag *pfrag, gfp_t gfp_mask, + unsigned int align_mask) { unsigned long encoded_page =3D nc->encoded_page; unsigned int size, offset; @@ -119,6 +141,8 @@ void *__page_frag_alloc_align(struct page_frag_cache *n= c, /* reset page count bias and offset to start of new frag */ nc->pagecnt_bias =3D PAGE_FRAG_CACHE_MAX_SIZE + 1; nc->offset =3D 0; + } else { + page =3D page_frag_encoded_page_ptr(encoded_page); } =20 size =3D page_frag_cache_page_size(encoded_page); @@ -137,8 +161,6 @@ void *__page_frag_alloc_align(struct page_frag_cache *n= c, return NULL; } =20 - page =3D page_frag_encoded_page_ptr(encoded_page); - if (!page_ref_sub_and_test(page, nc->pagecnt_bias)) goto refill; =20 @@ -153,15 +175,17 @@ void *__page_frag_alloc_align(struct page_frag_cache = *nc, =20 /* reset page count bias and offset to start of new frag */ nc->pagecnt_bias =3D PAGE_FRAG_CACHE_MAX_SIZE + 1; + nc->offset =3D 0; offset =3D 0; } =20 - nc->pagecnt_bias--; - nc->offset =3D offset + fragsz; + pfrag->page =3D page; + pfrag->offset =3D offset; + pfrag->size =3D size - offset; =20 return page_frag_encoded_page_address(encoded_page) + offset; } -EXPORT_SYMBOL(__page_frag_alloc_align); +EXPORT_SYMBOL(__page_frag_cache_prepare); =20 /* * Frees a page fragment allocated out of either a compound or order 0 pag= e. --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pg1-f194.google.com (mail-pg1-f194.google.com [209.85.215.194]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 21A3D1BE854; Tue, 1 Oct 2024 07:59:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.194 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769595; cv=none; b=e4nSFpbZxAL9Dwo84UZQTBxMyXjrk7ToJkefSwLldbh4UMLEnA3MoHQT/2PWbXl5sTyvyBD3q4bSe2ok836uDHPm5JZ2U+lT7p4/uwi4cXhUv1DwluOzYyhkgdnnHEWyFCLeJRUMP2kJdHqzTOmqwpguoejtj+ko+drwaqA63aI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769595; c=relaxed/simple; bh=0T9b0cXCJeMC0LrjWkbUmMV7IjhitTOlxdGgdVtqZqQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=VQ2M3eRc8U0A/UUx/C8oQd6+0RcJlHepETo0n8kOK4hGDf3T9/VBIYHs0UsDSjGz1ams8nMv18W5R9kfMY/WWUzCQ30PkDmc0b0VYjA4M21+YPh6DDXh/fF9YRkgOTqeHWI0runXrZFs6K7CZAhG/2Q4lZPVSTEySKYJi1yxK14= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=FWMqbYNl; arc=none smtp.client-ip=209.85.215.194 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="FWMqbYNl" Received: by mail-pg1-f194.google.com with SMTP id 41be03b00d2f7-7d916b6a73aso3330165a12.1; Tue, 01 Oct 2024 00:59:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769593; x=1728374393; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ADg4SjL/TdWbtGYAOROzU48mvQIzqBv73gL/8ReCbpM=; b=FWMqbYNlTO5TvZEXWGTB1Bpeaxq+CPZMFBFv3NsPg2iJ3LIv/gMptI1Fn7Nq8DcNpH dr4jUvf2zfoYLFONW+8gbdL5XB8ZW63+QQuevcfY9OSooc6vVGoBN7Q2VsjYpw8EiXwX dvHtnaN5qOFWrFTpRjHb6tZytnWbPRDjRjv2LjCaMkwR/LzM2TBBJk/JFH8JNlBF/Q28 5tvll3NO3MYMStpdrF6qF2BRT8fkXeoKq5CIG+T4Gdixs+QBNgwx+1k5ZxTRSdvFJnZQ +K/+TVyfrFfrvRhWJ5vr/frBn7qFU4II3E3G2FRq3g8jeAoAY+tFhob76PLMbX4jNcdy eNbQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769593; x=1728374393; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ADg4SjL/TdWbtGYAOROzU48mvQIzqBv73gL/8ReCbpM=; b=t3nmR+Gy95wtlphnR8NN/77JaPhoJYa/kVHqtyamPIDRotCwiN2JKVU01o6AP6o17X JAhq80Qvoi/fYALRJmsa8lnb0S1Y0FUCOxU82Rsy6BWH985mDv2MOBr01BY35Nxglpi2 6ZcAvxF1/0HJ9+LG7hOXCdgpdF0xZQ8RAF2KkiBsBwvj6XTr5bFBMUnWtMD7/148ORWD 1QHar49biOQ1GoYSZtedIGdT5wr5l5eAk2FchvxMNO4eAsBmZXMF2u9hiYm6/vgADrpq ywZL5gXaAuGuSS9rSsKJLz/Q1Bonsy3WrzefRB34VScs1SBniI0SkVub3K5AfAuL5M9O sv4A== X-Forwarded-Encrypted: i=1; AJvYcCW9xTl2sgOqGrRGo2ls3US2RnYE8wjV6P3zPaSN1VuUEa53MTan1qeqrw5kUm0OjVA0hYEYZ1jGMOkKJQA=@vger.kernel.org X-Gm-Message-State: AOJu0YyLK0Nrn0w/yf7335ednhTD3ozSiZ/Dlrdcg5Hlx/rzrg2x+n5p wUm6FjuVj2xiEmTqB0H9RDVJ5PIYxseEqRekETpOoYKPkzUSepcO X-Google-Smtp-Source: AGHT+IEMEMikIwAsGNCUaKklqicU3DUMXbKshUu12qfRtEdI3bF5DTyiGRaQfG0r7h/YT39HL2cwqg== X-Received: by 2002:a05:6a20:cf84:b0:1cf:49a6:9933 with SMTP id adf61e73a8af0-1d4fa6c2f99mr18322559637.20.1727769593548; Tue, 01 Oct 2024 00:59:53 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.00.59.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 00:59:53 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Andrew Morton , linux-mm@kvack.org Subject: [PATCH net-next v19 08/14] mm: page_frag: use __alloc_pages() to replace alloc_pages_node() Date: Tue, 1 Oct 2024 15:58:51 +0800 Message-Id: <20241001075858.48936-9-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" It seems there is about 24Bytes binary size increase for __page_frag_cache_refill() after refactoring in arm64 system with 64K PAGE_SIZE. By doing the gdb disassembling, It seems we can have more than 100Bytes decrease for the binary size by using __alloc_pages() to replace alloc_pages_node(), as there seems to be some unnecessary checking for nid being NUMA_NO_NODE, especially when page_frag is part of the mm system. CC: Alexander Duyck Signed-off-by: Yunsheng Lin Reviewed-by: Alexander Duyck --- mm/page_frag_cache.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mm/page_frag_cache.c b/mm/page_frag_cache.c index 6f6e47bbdc8d..a5448b44068a 100644 --- a/mm/page_frag_cache.c +++ b/mm/page_frag_cache.c @@ -61,11 +61,11 @@ static struct page *__page_frag_cache_refill(struct pag= e_frag_cache *nc, #if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE) gfp_mask =3D (gfp_mask & ~__GFP_DIRECT_RECLAIM) | __GFP_COMP | __GFP_NOWARN | __GFP_NORETRY | __GFP_NOMEMALLOC; - page =3D alloc_pages_node(NUMA_NO_NODE, gfp_mask, - PAGE_FRAG_CACHE_MAX_ORDER); + page =3D __alloc_pages(gfp_mask, PAGE_FRAG_CACHE_MAX_ORDER, + numa_mem_id(), NULL); #endif if (unlikely(!page)) { - page =3D alloc_pages_node(NUMA_NO_NODE, gfp, 0); + page =3D __alloc_pages(gfp, 0, numa_mem_id(), NULL); order =3D 0; } =20 --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pj1-f67.google.com (mail-pj1-f67.google.com [209.85.216.67]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 441301BE855; Tue, 1 Oct 2024 07:59:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.67 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769600; cv=none; b=hWsKDInPAR7NqlkFsAgre0CMJKt7Q+L2TYJxvzGEQg6GmtvQasPbMJXVzB/ZPjBuWRYWO8r1BG8IOhb3tRglXZmL5O5w9BsUw1DLtoId2/TQnZYP9TIsETOzm0fXCKAXvHCs5xjKQB4LlHqN5h3oc5tnHcJQbZtqYeM0689Z9F8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769600; c=relaxed/simple; bh=gYCPab+U6eyY6yRmHds8teTPnyl0gnPRVM7qnWkVd+E=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=RoUcYTdMqylwlo7qxJSdp3OC4h7QJeBTqQPBmhdnCRfw/I7qfkNGlXdSc9Hda3lDlAdBn3dI3e79i5zEp2RaWkvJxfNW8REMi1hHW5pG+2g/fTZg2ceJzyCS9F330wlutgSBgaqzSsqkDIZfxz1l3Dpg58DkECgDvLpvyXq0mVM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=fNC9EjOT; arc=none smtp.client-ip=209.85.216.67 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="fNC9EjOT" Received: by mail-pj1-f67.google.com with SMTP id 98e67ed59e1d1-2e077a4b8c0so3828753a91.1; Tue, 01 Oct 2024 00:59:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769598; x=1728374398; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=IpxkflJnYCzbT+jMhhi+6g6gN0FMQjEufujru1UkXhw=; b=fNC9EjOTc+v1MllejG+XZSWggpGMbi5rHDsctcdeJQ0iuGqxte92zTEiLt7MbGrETH cHDZhtqXDLBtT6v9QRhO5RwdxwONDFkPGXUMooiisHATas/LKBdBg85OIYweTeZz+AnV fGxRqVo0Whd6vSNJvxTNXzGz7p8Iy81miMTs0R3fyuaKqlthsYupYyTetwmcJqYs6DlN hYJInxuGgJo6qVMNwwwwHu/VWdLa4pri+m9hM3+t6aog9HbD181eYycIqdAUqt+EmTOM /tf94knsnF/HefS4ayME2cjSyT7hzEklixixeZAJrO6Y4iJXu8IAho1Whcw/ILtAyooD R7tA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769598; x=1728374398; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=IpxkflJnYCzbT+jMhhi+6g6gN0FMQjEufujru1UkXhw=; b=cT1/AGxoJLozTOTwSZqpK5BYtU8RjA7JjugSKGBpopnv6wicXbMy6FqKcri5bInSFy lgSGrvC2Da2CwsM6I0hYxNVUHsHLjUCwm2Z2vJMd1OW3Kjyd/cLohRqgcEr66okQNDQg /3ZcsyKggAPlAuniwSCIvs8fwIB8l3CAIrQIFcmE0yowdky6FZEg51lgfy145YY/e+JM GiwVaIdSdx45CkESSLHknBspAq4+stHV1RfoheLcEd+1DjB624FU24IbH9SuXK0a/pAE XoYIriaBPCJYxEIelCTYLgBDTE15r8fsrIjRdfue+M2Ue/QSb6Z3EopyYWbRwOFRYfK5 9LxA== X-Forwarded-Encrypted: i=1; AJvYcCU32y48pFYjhu3ZeWWB0gCO8OIYMDRtaW0jZwJbyzwpHucO9BTskCSYDzIvKW85wirB7GtRfUQKdkeEfNg=@vger.kernel.org X-Gm-Message-State: AOJu0YxeXT3PB90Lo0T+cNG3FioFuzTZmASSb+wV8GuRpoiA0q88rpnv j5eV5qPQuWzfqVJbERjRHqI1Y1e8gW9/WooMOm1aflu/9cKPZrD8 X-Google-Smtp-Source: AGHT+IFJ9foaS0kMGmUaZ3fPlXXoVou4TeZwiC2Mc9XXRJAck6Nm+vx1vfU25UCka/BYb3LslY1E1Q== X-Received: by 2002:a17:90a:d3c1:b0:2e1:1d4a:962b with SMTP id 98e67ed59e1d1-2e15a252c57mr3560683a91.9.1727769598489; Tue, 01 Oct 2024 00:59:58 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.00.59.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 00:59:58 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Eric Dumazet , David Ahern Subject: [PATCH net-next v19 09/14] net: rename skb_copy_to_page_nocache() helper Date: Tue, 1 Oct 2024 15:58:52 +0800 Message-Id: <20241001075858.48936-10-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Rename skb_copy_to_page_nocache() to skb_copy_to_va_nocache() to avoid calling virt_to_page() as we are about to pass virtual address directly. CC: Alexander Duyck Signed-off-by: Yunsheng Lin --- include/net/sock.h | 10 ++++------ net/ipv4/tcp.c | 7 +++---- net/kcm/kcmsock.c | 7 +++---- 3 files changed, 10 insertions(+), 14 deletions(-) diff --git a/include/net/sock.h b/include/net/sock.h index c58ca8dd561b..7d0b606d6251 100644 --- a/include/net/sock.h +++ b/include/net/sock.h @@ -2185,15 +2185,13 @@ static inline int skb_add_data_nocache(struct sock = *sk, struct sk_buff *skb, return err; } =20 -static inline int skb_copy_to_page_nocache(struct sock *sk, struct iov_ite= r *from, - struct sk_buff *skb, - struct page *page, - int off, int copy) +static inline int skb_copy_to_va_nocache(struct sock *sk, struct iov_iter = *from, + struct sk_buff *skb, char *va, + int copy) { int err; =20 - err =3D skb_do_copy_data_nocache(sk, skb, from, page_address(page) + off, - copy, skb->len); + err =3D skb_do_copy_data_nocache(sk, skb, from, va, copy, skb->len); if (err) return err; =20 diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c index 4f77bd862e95..8b03d8f48ac9 100644 --- a/net/ipv4/tcp.c +++ b/net/ipv4/tcp.c @@ -1218,10 +1218,9 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghd= r *msg, size_t size) if (!copy) goto wait_for_space; =20 - err =3D skb_copy_to_page_nocache(sk, &msg->msg_iter, skb, - pfrag->page, - pfrag->offset, - copy); + err =3D skb_copy_to_va_nocache(sk, &msg->msg_iter, skb, + page_address(pfrag->page) + + pfrag->offset, copy); if (err) goto do_error; =20 diff --git a/net/kcm/kcmsock.c b/net/kcm/kcmsock.c index d4118c796290..f4462cf88ed5 100644 --- a/net/kcm/kcmsock.c +++ b/net/kcm/kcmsock.c @@ -856,10 +856,9 @@ static int kcm_sendmsg(struct socket *sock, struct msg= hdr *msg, size_t len) if (!sk_wmem_schedule(sk, copy)) goto wait_for_memory; =20 - err =3D skb_copy_to_page_nocache(sk, &msg->msg_iter, skb, - pfrag->page, - pfrag->offset, - copy); + err =3D skb_copy_to_va_nocache(sk, &msg->msg_iter, skb, + page_address(pfrag->page) + + pfrag->offset, copy); if (err) goto out_error; =20 --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pj1-f68.google.com (mail-pj1-f68.google.com [209.85.216.68]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C06B81C1AA9; Tue, 1 Oct 2024 08:00:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.68 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769606; cv=none; b=XiRdjlaRXVmJ5yCNc+uI+1qqFvsG9Yl7ejPiYx4AL3kQeCwW3bBFWKR7ogVWktyDobI6UPEL/xJrzKjovQoEbSCLMraXJyUnqjg9s0hJT3/+dbaUQN0gHngt06iikJ8NXyThNuI4qFSpSkC6uV0hnXIlvn1vR+EsElIG/BOOwUw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769606; c=relaxed/simple; bh=WxENT/rypTbGvbnukSnyKm7DMpsKLUhPbsiqrGsTSjo=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=tIpyvLZvjWnEhfeIuCZezChbiA0BnURsFE2gCLryJTu41PWPtjCe/CkTL7Y5ejlh9dKc5LDD9cu/deehOF5ET4OFNrT672JPNbvYyfEP2JHP0tWnVOjOC87pqpEXBAdf/mNq414UiNvdQHCp2i+d3aUfZqcpcc4Nxmhj7MS0mA8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=XQrhc1jx; arc=none smtp.client-ip=209.85.216.68 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="XQrhc1jx" Received: by mail-pj1-f68.google.com with SMTP id 98e67ed59e1d1-2e0b0142bbfso3267678a91.1; Tue, 01 Oct 2024 01:00:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769604; x=1728374404; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=r1RucxwqQRpOPX6vOYgsd3mSR4ltbKTf5O9GaoA3/H0=; b=XQrhc1jxpCwoixZ9B9rGK+f5K+6zbK06f32K1+TRKNy+pINY8LeHn+ePo/JcY+XeeY e2OVNXpJhT2Mtc/KeWcoqNi0kY/jJSJ6/ZDDGMALQimzPbXKqAThB6+OlM6xsU6H8IPT IpXiDtBOo5bwRMMLIz4ysAMDYKcKPlnDWDo4oPrFJFkFJgZ7Kwr8D3LSB/TV+g6lrZsY 9Agu/eW6nY/oeXweJcG9xioxIw75bLfv1cBi7uz9ejqVb4szmT8rMto1NZuNGjzsnsW0 wjF3jcMtwlS0Ql8I7aiyoWfY/wntK6MCMIosjmCL6JtGYEsGFZfKKjiF8Y7NE0JfeUqd cKXA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769604; x=1728374404; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=r1RucxwqQRpOPX6vOYgsd3mSR4ltbKTf5O9GaoA3/H0=; b=PqbmnihdDIwqBhxAD4DmcFQ4Ea4gfPdUz+XMhXAqX2F5JhHW7f6q9VtXvhdKCkbPOB Uy3xOXnm/fewUoKL4wWLAqJhC+ku2nMmcKftYJYjqn1rx6O0JtJusnffbMrI3Fhjwb4e qMNixZrmHSyjPLP5TLnxHl6QoRIkH7HYsuo8qd75SvUzThCs3iW6U8NjY3uVM0S7GqGV BHsDS0j7H2P95QxobxrJCj1BPMdPt9+jpz/QB16t+PyRYMh3OrkxTwfYGkU3VeRVAsz+ NQewFCq8IIHoXNss5tzCVN/HIC9ug8UFP4e+HsnJ6qe2u/h1kCQUOAWsygScj8VcV4Em aG6A== X-Forwarded-Encrypted: i=1; AJvYcCUAZse+lLlAbTk0rdrtNSgzIkVMnwDOtlLoi94rdDjQ/2G1lrNIBgOIXCm1XKE5k2lBmLD5zQEzAPTCpYo=@vger.kernel.org X-Gm-Message-State: AOJu0YziD9cokzwHTNDsF7xXEtBhSbauLRknUR12uQU3bOCnX5z7vPFa RgWObLhosMRl+s/N+nlEsn8d/o8/kn4zpSytu1PVgC8KWB5nBPpL X-Google-Smtp-Source: AGHT+IFPxcxt0MFdf7tMGPm+w589CsajkXhlQaj5n+1Gi7AVAld6EP944pYZHk1LqVuIZirkwu8ymQ== X-Received: by 2002:a17:90a:e7d1:b0:2e0:728d:fb3b with SMTP id 98e67ed59e1d1-2e15a3431afmr3591602a91.18.1727769604111; Tue, 01 Oct 2024 01:00:04 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.01.00.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 01:00:03 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Andrew Morton , linux-mm@kvack.org Subject: [PATCH net-next v19 10/14] mm: page_frag: introduce prepare/probe/commit API Date: Tue, 1 Oct 2024 15:58:53 +0800 Message-Id: <20241001075858.48936-11-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" There are many use cases that need minimum memory in order for forward progress, but more performant if more memory is available or need to probe the cache info to use any memory available for frag caoleasing reason. Currently skb_page_frag_refill() API is used to solve the above use cases, but caller needs to know about the internal detail and access the data field of 'struct page_frag' to meet the requirement of the above use cases and its implementation is similar to the one in mm subsystem. To unify those two page_frag implementations, introduce a prepare API to ensure minimum memory is satisfied and return how much the actual memory is available to the caller and a probe API to report the current available memory to caller without doing cache refilling. The caller needs to either call the commit API to report how much memory it actually uses, or not do so if deciding to not use any memory. CC: Alexander Duyck Signed-off-by: Yunsheng Lin --- include/linux/page_frag_cache.h | 135 ++++++++++++++++++++++++++++++++ mm/page_frag_cache.c | 21 +++++ 2 files changed, 156 insertions(+) diff --git a/include/linux/page_frag_cache.h b/include/linux/page_frag_cach= e.h index b634e1338741..4e9018051956 100644 --- a/include/linux/page_frag_cache.h +++ b/include/linux/page_frag_cache.h @@ -40,6 +40,11 @@ static inline bool page_frag_cache_is_pfmemalloc(struct = page_frag_cache *nc) return page_frag_encoded_page_pfmemalloc(nc->encoded_page); } =20 +static inline unsigned int page_frag_cache_page_offset(const struct page_f= rag_cache *nc) +{ + return nc->offset; +} + void page_frag_cache_drain(struct page_frag_cache *nc); void __page_frag_cache_drain(struct page *page, unsigned int count); void *__page_frag_cache_prepare(struct page_frag_cache *nc, unsigned int f= ragsz, @@ -48,6 +53,10 @@ void *__page_frag_cache_prepare(struct page_frag_cache *= nc, unsigned int fragsz, unsigned int __page_frag_cache_commit_noref(struct page_frag_cache *nc, struct page_frag *pfrag, unsigned int used_sz); +void *__page_frag_alloc_refill_probe_align(struct page_frag_cache *nc, + unsigned int fragsz, + struct page_frag *pfrag, + unsigned int align_mask); =20 static inline unsigned int __page_frag_cache_commit(struct page_frag_cache= *nc, struct page_frag *pfrag, @@ -90,6 +99,132 @@ static inline void *page_frag_alloc(struct page_frag_ca= che *nc, return __page_frag_alloc_align(nc, fragsz, gfp_mask, ~0u); } =20 +static inline bool __page_frag_refill_align(struct page_frag_cache *nc, + unsigned int fragsz, + struct page_frag *pfrag, + gfp_t gfp_mask, + unsigned int align_mask) +{ + if (unlikely(!__page_frag_cache_prepare(nc, fragsz, pfrag, gfp_mask, + align_mask))) + return false; + + __page_frag_cache_commit(nc, pfrag, fragsz); + return true; +} + +static inline bool page_frag_refill_align(struct page_frag_cache *nc, + unsigned int fragsz, + struct page_frag *pfrag, + gfp_t gfp_mask, unsigned int align) +{ + WARN_ON_ONCE(!is_power_of_2(align)); + return __page_frag_refill_align(nc, fragsz, pfrag, gfp_mask, -align); +} + +static inline bool page_frag_refill(struct page_frag_cache *nc, + unsigned int fragsz, + struct page_frag *pfrag, gfp_t gfp_mask) +{ + return __page_frag_refill_align(nc, fragsz, pfrag, gfp_mask, ~0u); +} + +static inline bool __page_frag_refill_prepare_align(struct page_frag_cache= *nc, + unsigned int fragsz, + struct page_frag *pfrag, + gfp_t gfp_mask, + unsigned int align_mask) +{ + return !!__page_frag_cache_prepare(nc, fragsz, pfrag, gfp_mask, + align_mask); +} + +static inline bool page_frag_refill_prepare_align(struct page_frag_cache *= nc, + unsigned int fragsz, + struct page_frag *pfrag, + gfp_t gfp_mask, + unsigned int align) +{ + WARN_ON_ONCE(!is_power_of_2(align)); + return __page_frag_refill_prepare_align(nc, fragsz, pfrag, gfp_mask, + -align); +} + +static inline bool page_frag_refill_prepare(struct page_frag_cache *nc, + unsigned int fragsz, + struct page_frag *pfrag, + gfp_t gfp_mask) +{ + return __page_frag_refill_prepare_align(nc, fragsz, pfrag, gfp_mask, + ~0u); +} + +static inline void *__page_frag_alloc_refill_prepare_align(struct page_fra= g_cache *nc, + unsigned int fragsz, + struct page_frag *pfrag, + gfp_t gfp_mask, + unsigned int align_mask) +{ + return __page_frag_cache_prepare(nc, fragsz, pfrag, gfp_mask, align_mask); +} + +static inline void *page_frag_alloc_refill_prepare_align(struct page_frag_= cache *nc, + unsigned int fragsz, + struct page_frag *pfrag, + gfp_t gfp_mask, + unsigned int align) +{ + WARN_ON_ONCE(!is_power_of_2(align)); + return __page_frag_alloc_refill_prepare_align(nc, fragsz, pfrag, + gfp_mask, -align); +} + +static inline void *page_frag_alloc_refill_prepare(struct page_frag_cache = *nc, + unsigned int fragsz, + struct page_frag *pfrag, + gfp_t gfp_mask) +{ + return __page_frag_alloc_refill_prepare_align(nc, fragsz, pfrag, + gfp_mask, ~0u); +} + +static inline void *page_frag_alloc_refill_probe(struct page_frag_cache *n= c, + unsigned int fragsz, + struct page_frag *pfrag) +{ + return __page_frag_alloc_refill_probe_align(nc, fragsz, pfrag, ~0u); +} + +static inline bool page_frag_refill_probe(struct page_frag_cache *nc, + unsigned int fragsz, + struct page_frag *pfrag) +{ + return !!page_frag_alloc_refill_probe(nc, fragsz, pfrag); +} + +static inline void page_frag_commit(struct page_frag_cache *nc, + struct page_frag *pfrag, + unsigned int used_sz) +{ + __page_frag_cache_commit(nc, pfrag, used_sz); +} + +static inline void page_frag_commit_noref(struct page_frag_cache *nc, + struct page_frag *pfrag, + unsigned int used_sz) +{ + __page_frag_cache_commit_noref(nc, pfrag, used_sz); +} + +static inline void page_frag_alloc_abort(struct page_frag_cache *nc, + unsigned int fragsz) +{ + VM_BUG_ON(fragsz > nc->offset); + + nc->pagecnt_bias++; + nc->offset -=3D fragsz; +} + void page_frag_free(void *addr); =20 #endif diff --git a/mm/page_frag_cache.c b/mm/page_frag_cache.c index a5448b44068a..c052c77a96eb 100644 --- a/mm/page_frag_cache.c +++ b/mm/page_frag_cache.c @@ -117,6 +117,27 @@ unsigned int __page_frag_cache_commit_noref(struct pag= e_frag_cache *nc, } EXPORT_SYMBOL(__page_frag_cache_commit_noref); =20 +void *__page_frag_alloc_refill_probe_align(struct page_frag_cache *nc, + unsigned int fragsz, + struct page_frag *pfrag, + unsigned int align_mask) +{ + unsigned long encoded_page =3D nc->encoded_page; + unsigned int size, offset; + + size =3D page_frag_cache_page_size(encoded_page); + offset =3D __ALIGN_KERNEL_MASK(nc->offset, ~align_mask); + if (unlikely(!encoded_page || offset + fragsz > size)) + return NULL; + + pfrag->page =3D page_frag_encoded_page_ptr(encoded_page); + pfrag->size =3D size - offset; + pfrag->offset =3D offset; + + return page_frag_encoded_page_address(encoded_page) + offset; +} +EXPORT_SYMBOL(__page_frag_alloc_refill_probe_align); + void *__page_frag_cache_prepare(struct page_frag_cache *nc, unsigned int f= ragsz, struct page_frag *pfrag, gfp_t gfp_mask, unsigned int align_mask) --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pj1-f65.google.com (mail-pj1-f65.google.com [209.85.216.65]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 646BE1BF300; Tue, 1 Oct 2024 08:00:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.65 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769612; cv=none; b=mFmLu+dwkjp1uR6Hu6OmE+pshid27/YBXlhZDAbNnOE6lROHRst0571Qoz/5u75KEq0bijF3XRdCHvJ0Ro2ylQE5Oc9JsWfejNS3imktwRlBoqQO/r1KIRBxhJgWRBQxXwT780koHSSKzxA4cnnxWVykQg3xuDhEx4+ApIrA7vA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769612; c=relaxed/simple; bh=p4A2brn8pgGiYPzz8SV7EMrpoIMO7Qn7p4+2bG+sRb8=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=AwGup0bcmqCr2vwAlhCUKW7s/+bh2PdUH4KznGIYxE4EOEWbfir//Oi9qPmgcO+K6X6wA6xN+2DuyxRWqseyxtV83QzYN0M3IK/ADcWbTY3oSEGqlBYdNs05KyP5cBucj4IBZAltGlQjSa73Qaf7aeJWmqBfpT7nbPTadVerTfI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=UdA1azYD; arc=none smtp.client-ip=209.85.216.65 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="UdA1azYD" Received: by mail-pj1-f65.google.com with SMTP id 98e67ed59e1d1-2e0a060f6e8so3511684a91.1; Tue, 01 Oct 2024 01:00:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769610; x=1728374410; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=5ojxcdjNvn9tfBEJlcLOUTnmOt/qIyQL5omYnTHVVOo=; b=UdA1azYDfkwkCpCrsmNjGdi/rzm3DnhYe82+/SCCrZRq+Ej5k79bp2HoXzwu3+RHCy ynKU0x9V3HV1kRfzoZ4o/jmxjnLSj/x9szNGoGlRvMX61VYTf+yBPPEJL5ncRZHLN96A Z5idIR2AHgcFbZ5I/MQryiOgYFz+78ip4Dpl4+SqBnUh9Ii4ukh/BpdMcV1cp3YdrgD/ BukTZImpcjLQDqGnlTz+ls9Adr/5WXZaNNZnWuy2h2wY+vS7IERx9B1SktXs3DuRLUKg 3xY2jez0kBLh/TDFOu9nDRXGvAHRHB457g6UVRkZeq2k21AXX9gEMVYsQnujGQKmnd8n MkJA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769610; x=1728374410; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=5ojxcdjNvn9tfBEJlcLOUTnmOt/qIyQL5omYnTHVVOo=; b=QYoIQdYH6Y4TZ/GFfQS/0Aq0jitoxn7ws1Di3dHDfw7BdEvFLemU4NGmt7xPhkWZRA Ir8XqeBkV6mcUm1jxtiDOq0ZP/x9KkbkXOFpqxMI8a1OnzbtDt2E+oAt7nW2/m3L19jP hshFtbgIq5KcvcaD9bqcFK7JzszFkvG1KGapLIjVA2usbN8mEVm8hAbAjVBeUuYMCWGL gMjFyHmt+pSnmlnfUp4OPJWAcl5Thji0b0ve8afYfmzvdIlhFRL+LWE/xyeIawUkDo3d 8XSp0NNs3vd+G4+YQ2cZ/0gZH6QqlMCu5l/tS8Epr8mG8edopOZWGzxErDxlDWZaPI1P Q3JA== X-Forwarded-Encrypted: i=1; AJvYcCVjgDMJxBiukkPu8mOgZp4V0w5IWzxkVECOWA3zX8mMKG0t8lM9QCJcVz8sCPc2iGYcohmCUpTUXwwAHnVyDpeH@vger.kernel.org, AJvYcCW+hCh3xDGMbC7GPdrFdJlCFY/SHeV7RsnLS8/D8GBmVMEAx+K/oW1dJ88kbwuqG1WwC91lZERtU5SG6mg=@vger.kernel.org X-Gm-Message-State: AOJu0YyVSdO7bP0qgCCxumcoNnDwSSBHpQeZwL2TodJAnSWeY7vOQaWE 9vIZh5CLRwjlZvPFHjA3QIORp96QTlkOzW1clN5acI4nCLUrdpx9 X-Google-Smtp-Source: AGHT+IF3IG9U7cija4N7THOiO2nq96RB2NLJHQxqNLCpLLW60MhGNrffUUs5bLpndLyek42gdCV41A== X-Received: by 2002:a17:90a:f2cf:b0:2e0:b26c:9069 with SMTP id 98e67ed59e1d1-2e0b8ea648cmr15853457a91.25.1727769609750; Tue, 01 Oct 2024 01:00:09 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.01.00.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 01:00:09 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Andrew Morton , Shuah Khan , linux-mm@kvack.org, linux-kselftest@vger.kernel.org Subject: [PATCH net-next v19 11/14] mm: page_frag: add testing for the newly added prepare API Date: Tue, 1 Oct 2024 15:58:54 +0800 Message-Id: <20241001075858.48936-12-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add testing for the newly added prepare API, for both aligned and non-aligned API, also probe API is also tested along with prepare API. CC: Alexander Duyck Signed-off-by: Yunsheng Lin --- .../selftests/mm/page_frag/page_frag_test.c | 66 +++++++++++++++++-- tools/testing/selftests/mm/run_vmtests.sh | 4 ++ tools/testing/selftests/mm/test_page_frag.sh | 31 +++++++++ 3 files changed, 96 insertions(+), 5 deletions(-) diff --git a/tools/testing/selftests/mm/page_frag/page_frag_test.c b/tools/= testing/selftests/mm/page_frag/page_frag_test.c index 36543a129e40..567bcc6a181e 100644 --- a/tools/testing/selftests/mm/page_frag/page_frag_test.c +++ b/tools/testing/selftests/mm/page_frag/page_frag_test.c @@ -29,6 +29,10 @@ static bool test_align; module_param(test_align, bool, 0); MODULE_PARM_DESC(test_align, "use align API for testing"); =20 +static bool test_prepare; +module_param(test_prepare, bool, 0); +MODULE_PARM_DESC(test_prepare, "use prepare API for testing"); + static int test_alloc_len =3D 2048; module_param(test_alloc_len, int, 0); MODULE_PARM_DESC(test_alloc_len, "alloc len for testing"); @@ -68,6 +72,18 @@ static int page_frag_pop_thread(void *arg) return 0; } =20 +static void frag_frag_test_commit(struct page_frag_cache *nc, + struct page_frag *prepare_pfrag, + struct page_frag *probe_pfrag, + unsigned int used_sz) +{ + WARN_ON_ONCE(prepare_pfrag->page !=3D probe_pfrag->page || + prepare_pfrag->offset !=3D probe_pfrag->offset || + prepare_pfrag->size !=3D probe_pfrag->size); + + page_frag_commit(nc, prepare_pfrag, used_sz); +} + static int page_frag_push_thread(void *arg) { struct ptr_ring *ring =3D arg; @@ -80,13 +96,52 @@ static int page_frag_push_thread(void *arg) int ret; =20 if (test_align) { - va =3D page_frag_alloc_align(&test_nc, test_alloc_len, - GFP_KERNEL, SMP_CACHE_BYTES); + if (test_prepare) { + struct page_frag prepare_frag, probe_frag; + void *probe_va; + + va =3D page_frag_alloc_refill_prepare_align(&test_nc, + test_alloc_len, + &prepare_frag, + GFP_KERNEL, + SMP_CACHE_BYTES); + + probe_va =3D __page_frag_alloc_refill_probe_align(&test_nc, + test_alloc_len, + &probe_frag, + -SMP_CACHE_BYTES); + WARN_ON_ONCE(va !=3D probe_va); + + if (likely(va)) + frag_frag_test_commit(&test_nc, &prepare_frag, + &probe_frag, test_alloc_len); + } else { + va =3D page_frag_alloc_align(&test_nc, + test_alloc_len, + GFP_KERNEL, + SMP_CACHE_BYTES); + } =20 WARN_ONCE((unsigned long)va & (SMP_CACHE_BYTES - 1), "unaligned va returned\n"); } else { - va =3D page_frag_alloc(&test_nc, test_alloc_len, GFP_KERNEL); + if (test_prepare) { + struct page_frag prepare_frag, probe_frag; + void *probe_va; + + va =3D page_frag_alloc_refill_prepare(&test_nc, test_alloc_len, + &prepare_frag, GFP_KERNEL); + + probe_va =3D page_frag_alloc_refill_probe(&test_nc, test_alloc_len, + &probe_frag); + + WARN_ON_ONCE(va !=3D probe_va); + if (likely(va)) + frag_frag_test_commit(&test_nc, &prepare_frag, + &probe_frag, test_alloc_len); + } else { + va =3D page_frag_alloc(&test_nc, test_alloc_len, GFP_KERNEL); + } } =20 if (!va) @@ -152,8 +207,9 @@ static int __init page_frag_test_init(void) test_pushed, test_popped); =20 duration =3D (u64)ktime_us_delta(ktime_get(), start); - pr_info("%d of iterations for %s testing took: %lluus\n", nr_test, - test_align ? "aligned" : "non-aligned", duration); + pr_info("%d of iterations for %s %s API testing took: %lluus\n", nr_test, + test_align ? "aligned" : "non-aligned", + test_prepare ? "prepare" : "alloc", duration); =20 ptr_ring_cleanup(&ptr_ring, NULL); page_frag_cache_drain(&test_nc); diff --git a/tools/testing/selftests/mm/run_vmtests.sh b/tools/testing/self= tests/mm/run_vmtests.sh index 2c5394584af4..f6ff9080a6f2 100755 --- a/tools/testing/selftests/mm/run_vmtests.sh +++ b/tools/testing/selftests/mm/run_vmtests.sh @@ -464,6 +464,10 @@ CATEGORY=3D"page_frag" run_test ./test_page_frag.sh al= igned =20 CATEGORY=3D"page_frag" run_test ./test_page_frag.sh nonaligned =20 +CATEGORY=3D"page_frag" run_test ./test_page_frag.sh aligned_prepare + +CATEGORY=3D"page_frag" run_test ./test_page_frag.sh nonaligned_prepare + echo "SUMMARY: PASS=3D${count_pass} SKIP=3D${count_skip} FAIL=3D${count_fa= il}" | tap_prefix echo "1..${count_total}" | tap_output =20 diff --git a/tools/testing/selftests/mm/test_page_frag.sh b/tools/testing/s= elftests/mm/test_page_frag.sh index d750d910c899..71c3531fa38e 100755 --- a/tools/testing/selftests/mm/test_page_frag.sh +++ b/tools/testing/selftests/mm/test_page_frag.sh @@ -36,6 +36,8 @@ ksft_skip=3D4 SMOKE_PARAM=3D"test_push_cpu=3D$TEST_CPU_0 test_pop_cpu=3D$TEST_CPU_1" NONALIGNED_PARAM=3D"$SMOKE_PARAM test_alloc_len=3D75 nr_test=3D$NR_TEST" ALIGNED_PARAM=3D"$NONALIGNED_PARAM test_align=3D1" +NONALIGNED_PREPARE_PARAM=3D"$NONALIGNED_PARAM test_prepare=3D1" +ALIGNED_PREPARE_PARAM=3D"$ALIGNED_PARAM test_prepare=3D1" =20 check_test_requirements() { @@ -74,6 +76,24 @@ run_aligned_check() echo "Check the kernel ring buffer to see the summary." } =20 +run_nonaligned_prepare_check() +{ + echo "Run performance tests to evaluate how fast nonaligned prepare API i= s." + + insmod $DRIVER $NONALIGNED_PREPARE_PARAM > /dev/null 2>&1 + echo "Done." + echo "Ccheck the kernel ring buffer to see the summary." +} + +run_aligned_prepare_check() +{ + echo "Run performance tests to evaluate how fast aligned prepare API is." + + insmod $DRIVER $ALIGNED_PREPARE_PARAM > /dev/null 2>&1 + echo "Done." + echo "Check the kernel ring buffer to see the summary." +} + run_smoke_check() { echo "Run smoke test." @@ -86,6 +106,7 @@ run_smoke_check() usage() { echo -n "Usage: $0 [ aligned ] | [ nonaligned ] | | [ smoke ] | " + echo "[ aligned_prepare ] | [ nonaligned_prepare ] | " echo "manual parameters" echo echo "Valid tests and parameters:" @@ -106,6 +127,12 @@ usage() echo "# Performance testing for aligned alloc API" echo "$0 aligned" echo + echo "# Performance testing for nonaligned prepare API" + echo "$0 nonaligned_prepare" + echo + echo "# Performance testing for aligned prepare API" + echo "$0 aligned_prepare" + echo exit 0 } =20 @@ -159,6 +186,10 @@ function run_test() run_nonaligned_check elif [[ "$1" =3D "aligned" ]]; then run_aligned_check + elif [[ "$1" =3D "nonaligned_prepare" ]]; then + run_nonaligned_prepare_check + elif [[ "$1" =3D "aligned_prepare" ]]; then + run_aligned_prepare_check else run_manual_check $@ fi --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pf1-f196.google.com (mail-pf1-f196.google.com [209.85.210.196]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CADD91BDAA6 for ; Tue, 1 Oct 2024 08:00:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.196 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769625; cv=none; b=My1DhsC7QxflQF35/WgwbeqVNOYpozJ5cZZo0qyogXzU5nmNZt6ztudyeNRD2mm1bgffYE390U3hxvXmLfU4lyBkwDb5aoDFucKNI67YxyUocDtL/L9mDu7HUCTQY9ipE/Z0hchAHni5+8C/IfdNyDEAf4YwR1N2gwfsawGw2ko= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769625; c=relaxed/simple; bh=VupGmQFeT2ErxEmJAu3BHiLlVo96kTZl8m9rJO27tvI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=bXC92ChVEno05rHms1KOx2C9tSV7ZFy6IIkUK/6yK4Pue/ZYMQwIviNM6VB724r4QTdF/0F6q0266B9LlAFsaec+sYFrj3Zm25r36NJ8Ym3t1NPRQYturTHJIB0oybgtR+LlVh6rkJosj3IpxTZrTKRW0tuF3KZQAorbhGxHHdU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=cLDBUrN2; arc=none smtp.client-ip=209.85.210.196 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="cLDBUrN2" Received: by mail-pf1-f196.google.com with SMTP id d2e1a72fcca58-719b17b2da1so3758097b3a.0 for ; Tue, 01 Oct 2024 01:00:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769622; x=1728374422; darn=lists.linux.dev; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=nZGlThwdk/sDEuauh3d7YLjjdA5pAiJ/YWNeVfkcFEM=; b=cLDBUrN2cIwLP/YbpKhz+X4LGtmhwPqDv7P+ZGGYayZ0HedpvTWLn6bZnhseRGgC9a CNh6f4sG1VZOpU4J0OqZgPrJLH7guREpViUm5LqeSzXH0FonX2Izi5uRJQej5KFZLcib l0boblALIXO4EWw28ap0cAychsvLqC/Zao98O/YQgbOkfLkuzXjkwJld9UdAc1EYjkbT oLY7V6GR/l6NbaHU5BgOsTpElxBHfL4rouBAcduaLVV89P5shHXEkWHc5Nmz4CjBW+pH CuMB0ueRRgxFbCpE3pRnXBnwJvoN9yBfDrS3ewaaZFE9DmwbAWJSfPsraFjrDGCTvX0O I6pg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769622; x=1728374422; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=nZGlThwdk/sDEuauh3d7YLjjdA5pAiJ/YWNeVfkcFEM=; b=Ku15mb1Cyc/2Vh7lppthC4XvadNnj3A9MYPmMpbYF6hZaCHOTBhdkx2wEg76hafgcg 1xFbjARUUk7E4C/xrWQ5JS6sEEy/XqgRV8Yw3eIbAlxqxn/xKEAypVn8x6i6jzp+915k 7wGwF+0mQ2Sd0IYuaUfLshgfXxUs1EJiGpytkUFF6QRTEgESm2mHrVNTaLJSQGK/yrXP wIVm1V4AqMVRljE47oFqtzz9JqcOowSkPvqRnzftvy706ww3h46L0hqKKsuIrV+imp61 sDwILjMZbNJ6qL0kJjf4hcG55UNSoFPTXL20NOgUBePaZvZkKsHfay5N/xLM6X5GGUrL UIwg== X-Forwarded-Encrypted: i=1; AJvYcCWLnwTA2nkucGHBeiaYb+xxM0wPomu+zn+U+dVJC6sM/aC8uzgQ7nT2ID7Y/484m7gXp7yhaQ==@lists.linux.dev X-Gm-Message-State: AOJu0YwZ5bXS+qElEe+aYSly76iF1KpumZiNnDSih0PgywG9TMw+3cBK /1kyhyqDtvafM8x23AIoRADegeswg8tDVSgVh28VwCUGeac8mgIg X-Google-Smtp-Source: AGHT+IGhNb5RzdauleVykg18QDHnfRFBaf5hx+XfpJMB4fBDEcHSZGzH5Ngu/3sw91yk+jrBNiXrtg== X-Received: by 2002:a05:6a21:1813:b0:1ce:f6b2:d5a2 with SMTP id adf61e73a8af0-1d4fa806edemr20746936637.41.1727769621672; Tue, 01 Oct 2024 01:00:21 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.01.00.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 01:00:21 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Ayush Sawal , Eric Dumazet , Willem de Bruijn , Jason Wang , Ingo Molnar , Peter Zijlstra , Juri Lelli , Vincent Guittot , Dietmar Eggemann , Steven Rostedt , Ben Segall , Mel Gorman , Valentin Schneider , John Fastabend , Jakub Sitnicki , David Ahern , Matthieu Baerts , Mat Martineau , Geliang Tang , Jamal Hadi Salim , Cong Wang , Jiri Pirko , Boris Pismenny , bpf@vger.kernel.org, mptcp@lists.linux.dev Subject: [PATCH net-next v19 12/14] net: replace page_frag with page_frag_cache Date: Tue, 1 Oct 2024 15:58:55 +0800 Message-Id: <20241001075858.48936-13-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: mptcp@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use the newly introduced prepare/probe/commit API to replace page_frag with page_frag_cache for sk_page_frag(). CC: Alexander Duyck Signed-off-by: Yunsheng Lin --- .../chelsio/inline_crypto/chtls/chtls.h | 3 - .../chelsio/inline_crypto/chtls/chtls_io.c | 101 +++++------------- .../chelsio/inline_crypto/chtls/chtls_main.c | 3 - drivers/net/tun.c | 47 ++++---- include/linux/sched.h | 2 +- include/net/sock.h | 21 ++-- kernel/exit.c | 3 +- kernel/fork.c | 3 +- net/core/skbuff.c | 58 +++++----- net/core/skmsg.c | 12 ++- net/core/sock.c | 32 ++++-- net/ipv4/ip_output.c | 28 +++-- net/ipv4/tcp.c | 23 ++-- net/ipv4/tcp_output.c | 25 +++-- net/ipv6/ip6_output.c | 28 +++-- net/kcm/kcmsock.c | 18 ++-- net/mptcp/protocol.c | 47 ++++---- net/sched/em_meta.c | 2 +- net/tls/tls_device.c | 100 ++++++++++------- 19 files changed, 294 insertions(+), 262 deletions(-) diff --git a/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls.h b/dri= vers/net/ethernet/chelsio/inline_crypto/chtls/chtls.h index 7ff82b6778ba..fe2b6a8ef718 100644 --- a/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls.h +++ b/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls.h @@ -234,7 +234,6 @@ struct chtls_dev { struct list_head list_node; struct list_head rcu_node; struct list_head na_node; - unsigned int send_page_order; int max_host_sndbuf; u32 round_robin_cnt; struct key_map kmap; @@ -453,8 +452,6 @@ enum { =20 /* The ULP mode/submode of an skbuff */ #define skb_ulp_mode(skb) (ULP_SKB_CB(skb)->ulp_mode) -#define TCP_PAGE(sk) (sk->sk_frag.page) -#define TCP_OFF(sk) (sk->sk_frag.offset) =20 static inline struct chtls_dev *to_chtls_dev(struct tls_toe_device *tlsdev) { diff --git a/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c b/= drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c index d567e42e1760..48a61b1142a3 100644 --- a/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c +++ b/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c @@ -825,12 +825,6 @@ void skb_entail(struct sock *sk, struct sk_buff *skb, = int flags) ULP_SKB_CB(skb)->flags =3D flags; __skb_queue_tail(&csk->txq, skb); sk->sk_wmem_queued +=3D skb->truesize; - - if (TCP_PAGE(sk) && TCP_OFF(sk)) { - put_page(TCP_PAGE(sk)); - TCP_PAGE(sk) =3D NULL; - TCP_OFF(sk) =3D 0; - } } =20 static struct sk_buff *get_tx_skb(struct sock *sk, int size) @@ -882,16 +876,12 @@ static void push_frames_if_head(struct sock *sk) chtls_push_frames(csk, 1); } =20 -static int chtls_skb_copy_to_page_nocache(struct sock *sk, - struct iov_iter *from, - struct sk_buff *skb, - struct page *page, - int off, int copy) +static int chtls_skb_copy_to_va_nocache(struct sock *sk, struct iov_iter *= from, + struct sk_buff *skb, char *va, int copy) { int err; =20 - err =3D skb_do_copy_data_nocache(sk, skb, from, page_address(page) + - off, copy, skb->len); + err =3D skb_do_copy_data_nocache(sk, skb, from, va, copy, skb->len); if (err) return err; =20 @@ -1114,82 +1104,45 @@ int chtls_sendmsg(struct sock *sk, struct msghdr *m= sg, size_t size) if (err) goto do_fault; } else { + struct page_frag_cache *nc =3D &sk->sk_frag; + struct page_frag page_frag, *pfrag; int i =3D skb_shinfo(skb)->nr_frags; - struct page *page =3D TCP_PAGE(sk); - int pg_size =3D PAGE_SIZE; - int off =3D TCP_OFF(sk); - bool merge; - - if (page) - pg_size =3D page_size(page); - if (off < pg_size && - skb_can_coalesce(skb, i, page, off)) { + bool merge =3D false; + void *va; + + pfrag =3D &page_frag; + va =3D page_frag_alloc_refill_prepare(nc, 32U, pfrag, + sk->sk_allocation); + if (unlikely(!va)) + goto wait_for_memory; + + if (skb_can_coalesce(skb, i, pfrag->page, + pfrag->offset)) merge =3D true; - goto copy; - } - merge =3D false; - if (i =3D=3D (is_tls_tx(csk) ? (MAX_SKB_FRAGS - 1) : - MAX_SKB_FRAGS)) + else if (i =3D=3D (is_tls_tx(csk) ? (MAX_SKB_FRAGS - 1) : + MAX_SKB_FRAGS)) goto new_buf; =20 - if (page && off =3D=3D pg_size) { - put_page(page); - TCP_PAGE(sk) =3D page =3D NULL; - pg_size =3D PAGE_SIZE; - } - - if (!page) { - gfp_t gfp =3D sk->sk_allocation; - int order =3D cdev->send_page_order; - - if (order) { - page =3D alloc_pages(gfp | __GFP_COMP | - __GFP_NOWARN | - __GFP_NORETRY, - order); - if (page) - pg_size <<=3D order; - } - if (!page) { - page =3D alloc_page(gfp); - pg_size =3D PAGE_SIZE; - } - if (!page) - goto wait_for_memory; - off =3D 0; - } -copy: - if (copy > pg_size - off) - copy =3D pg_size - off; + copy =3D min_t(int, copy, pfrag->size); if (is_tls_tx(csk)) copy =3D min_t(int, copy, csk->tlshws.txleft); =20 - err =3D chtls_skb_copy_to_page_nocache(sk, &msg->msg_iter, - skb, page, - off, copy); - if (unlikely(err)) { - if (!TCP_PAGE(sk)) { - TCP_PAGE(sk) =3D page; - TCP_OFF(sk) =3D 0; - } + err =3D chtls_skb_copy_to_va_nocache(sk, &msg->msg_iter, + skb, va, copy); + if (unlikely(err)) goto do_fault; - } + /* Update the skb. */ if (merge) { skb_frag_size_add( &skb_shinfo(skb)->frags[i - 1], copy); + page_frag_commit_noref(nc, pfrag, copy); } else { - skb_fill_page_desc(skb, i, page, off, copy); - if (off + copy < pg_size) { - /* space left keep page */ - get_page(page); - TCP_PAGE(sk) =3D page; - } else { - TCP_PAGE(sk) =3D NULL; - } + skb_fill_page_desc(skb, i, pfrag->page, + pfrag->offset, copy); + page_frag_commit(nc, pfrag, copy); } - TCP_OFF(sk) =3D off + copy; } if (unlikely(skb->len =3D=3D mss)) tx_skb_finalize(skb); diff --git a/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_main.c = b/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_main.c index 455a54708be4..ba88b2fc7cd8 100644 --- a/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_main.c +++ b/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_main.c @@ -34,7 +34,6 @@ static DEFINE_MUTEX(notify_mutex); static RAW_NOTIFIER_HEAD(listen_notify_list); static struct proto chtls_cpl_prot, chtls_cpl_protv6; struct request_sock_ops chtls_rsk_ops, chtls_rsk_opsv6; -static uint send_page_order =3D (14 - PAGE_SHIFT < 0) ? 0 : 14 - PAGE_SHIF= T; =20 static void register_listen_notifier(struct notifier_block *nb) { @@ -273,8 +272,6 @@ static void *chtls_uld_add(const struct cxgb4_lld_info = *info) INIT_WORK(&cdev->deferq_task, process_deferq); spin_lock_init(&cdev->listen_lock); spin_lock_init(&cdev->idr_lock); - cdev->send_page_order =3D min_t(uint, get_order(32768), - send_page_order); cdev->max_host_sndbuf =3D 48 * 1024; =20 if (lldi->vr->key.size) diff --git a/drivers/net/tun.c b/drivers/net/tun.c index 5f77faef0ff1..ddf7d5aa372a 100644 --- a/drivers/net/tun.c +++ b/drivers/net/tun.c @@ -1599,21 +1599,19 @@ static bool tun_can_build_skb(struct tun_struct *tu= n, struct tun_file *tfile, } =20 static struct sk_buff *__tun_build_skb(struct tun_file *tfile, - struct page_frag *alloc_frag, char *buf, - int buflen, int len, int pad) + char *buf, int buflen, int len, int pad) { struct sk_buff *skb =3D build_skb(buf, buflen); =20 - if (!skb) + if (!skb) { + page_frag_free(buf); return ERR_PTR(-ENOMEM); + } =20 skb_reserve(skb, pad); skb_put(skb, len); skb_set_owner_w(skb, tfile->socket.sk); =20 - get_page(alloc_frag->page); - alloc_frag->offset +=3D buflen; - return skb; } =20 @@ -1661,8 +1659,8 @@ static struct sk_buff *tun_build_skb(struct tun_struc= t *tun, struct virtio_net_hdr *hdr, int len, int *skb_xdp) { - struct page_frag *alloc_frag =3D ¤t->task_frag; struct bpf_net_context __bpf_net_ctx, *bpf_net_ctx; + struct page_frag_cache *nc =3D ¤t->task_frag; struct bpf_prog *xdp_prog; int buflen =3D SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); char *buf; @@ -1677,16 +1675,16 @@ static struct sk_buff *tun_build_skb(struct tun_str= uct *tun, buflen +=3D SKB_DATA_ALIGN(len + pad); rcu_read_unlock(); =20 - alloc_frag->offset =3D ALIGN((u64)alloc_frag->offset, SMP_CACHE_BYTES); - if (unlikely(!skb_page_frag_refill(buflen, alloc_frag, GFP_KERNEL))) + buf =3D page_frag_alloc_align(nc, buflen, GFP_KERNEL, + SMP_CACHE_BYTES); + if (unlikely(!buf)) return ERR_PTR(-ENOMEM); =20 - buf =3D (char *)page_address(alloc_frag->page) + alloc_frag->offset; - copied =3D copy_page_from_iter(alloc_frag->page, - alloc_frag->offset + pad, - len, from); - if (copied !=3D len) + copied =3D copy_from_iter(buf + pad, len, from); + if (copied !=3D len) { + page_frag_alloc_abort(nc, buflen); return ERR_PTR(-EFAULT); + } =20 /* There's a small window that XDP may be set after the check * of xdp_prog above, this should be rare and for simplicity @@ -1694,8 +1692,7 @@ static struct sk_buff *tun_build_skb(struct tun_struc= t *tun, */ if (hdr->gso_type || !xdp_prog) { *skb_xdp =3D 1; - return __tun_build_skb(tfile, alloc_frag, buf, buflen, len, - pad); + return __tun_build_skb(tfile, buf, buflen, len, pad); } =20 *skb_xdp =3D 0; @@ -1712,21 +1709,23 @@ static struct sk_buff *tun_build_skb(struct tun_str= uct *tun, xdp_prepare_buff(&xdp, buf, pad, len, false); =20 act =3D bpf_prog_run_xdp(xdp_prog, &xdp); - if (act =3D=3D XDP_REDIRECT || act =3D=3D XDP_TX) { - get_page(alloc_frag->page); - alloc_frag->offset +=3D buflen; - } err =3D tun_xdp_act(tun, xdp_prog, &xdp, act); if (err < 0) { - if (act =3D=3D XDP_REDIRECT || act =3D=3D XDP_TX) - put_page(alloc_frag->page); + if (act =3D=3D XDP_REDIRECT || act =3D=3D XDP_TX) { + page_frag_alloc_abort(nc, 0); + goto out; + } + + page_frag_alloc_abort(nc, buflen); goto out; } =20 if (err =3D=3D XDP_REDIRECT) xdp_do_flush(); - if (err !=3D XDP_PASS) + if (err !=3D XDP_PASS) { + page_frag_alloc_abort(nc, buflen); goto out; + } =20 pad =3D xdp.data - xdp.data_hard_start; len =3D xdp.data_end - xdp.data; @@ -1735,7 +1734,7 @@ static struct sk_buff *tun_build_skb(struct tun_struc= t *tun, rcu_read_unlock(); local_bh_enable(); =20 - return __tun_build_skb(tfile, alloc_frag, buf, buflen, len, pad); + return __tun_build_skb(tfile, buf, buflen, len, pad); =20 out: bpf_net_ctx_clear(bpf_net_ctx); diff --git a/include/linux/sched.h b/include/linux/sched.h index e6ee4258169a..d4a4273d015e 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -1379,7 +1379,7 @@ struct task_struct { /* Cache last used pipe for splice(): */ struct pipe_inode_info *splice_pipe; =20 - struct page_frag task_frag; + struct page_frag_cache task_frag; =20 #ifdef CONFIG_TASK_DELAY_ACCT struct task_delay_info *delays; diff --git a/include/net/sock.h b/include/net/sock.h index 7d0b606d6251..6c41faef3879 100644 --- a/include/net/sock.h +++ b/include/net/sock.h @@ -303,7 +303,7 @@ struct sk_filter; * @sk_stamp: time stamp of last packet received * @sk_stamp_seq: lock for accessing sk_stamp on 32 bit architectures only * @sk_tsflags: SO_TIMESTAMPING flags - * @sk_use_task_frag: allow sk_page_frag() to use current->task_frag. + * @sk_use_task_frag: allow sk_page_frag_cache() to use current->task_fra= g. * Sockets that can be used under memory reclaim should * set this to false. * @sk_bind_phc: SO_TIMESTAMPING bind PHC index of PTP virtual clock @@ -462,7 +462,7 @@ struct sock { struct sk_buff_head sk_write_queue; u32 sk_dst_pending_confirm; u32 sk_pacing_status; /* see enum sk_pacing */ - struct page_frag sk_frag; + struct page_frag_cache sk_frag; struct timer_list sk_timer; =20 unsigned long sk_pacing_rate; /* bytes per second */ @@ -2472,22 +2472,22 @@ static inline void sk_stream_moderate_sndbuf(struct= sock *sk) } =20 /** - * sk_page_frag - return an appropriate page_frag + * sk_page_frag_cache - return an appropriate page_frag_cache * @sk: socket * - * Use the per task page_frag instead of the per socket one for + * Use the per task page_frag_cache instead of the per socket one for * optimization when we know that we're in process context and own * everything that's associated with %current. * * Both direct reclaim and page faults can nest inside other - * socket operations and end up recursing into sk_page_frag() - * while it's already in use: explicitly avoid task page_frag + * socket operations and end up recursing into sk_page_frag_cache() + * while it's already in use: explicitly avoid task page_frag_cache * when users disable sk_use_task_frag. * * Return: a per task page_frag if context allows that, * otherwise a per socket one. */ -static inline struct page_frag *sk_page_frag(struct sock *sk) +static inline struct page_frag_cache *sk_page_frag_cache(struct sock *sk) { if (sk->sk_use_task_frag) return ¤t->task_frag; @@ -2495,7 +2495,12 @@ static inline struct page_frag *sk_page_frag(struct = sock *sk) return &sk->sk_frag; } =20 -bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag); +bool sk_page_frag_refill_prepare(struct sock *sk, struct page_frag_cache *= nc, + struct page_frag *pfrag); + +void *sk_page_frag_alloc_refill_prepare(struct sock *sk, + struct page_frag_cache *nc, + struct page_frag *pfrag); =20 /* * Default write policy as shown to user space via poll/select/SIGIO diff --git a/kernel/exit.c b/kernel/exit.c index 619f0014c33b..5f9b7f58098d 100644 --- a/kernel/exit.c +++ b/kernel/exit.c @@ -974,8 +974,7 @@ void __noreturn do_exit(long code) if (tsk->splice_pipe) free_pipe_info(tsk->splice_pipe); =20 - if (tsk->task_frag.page) - put_page(tsk->task_frag.page); + page_frag_cache_drain(&tsk->task_frag); =20 exit_task_stack_account(tsk); =20 diff --git a/kernel/fork.c b/kernel/fork.c index 60c0b4868fd4..a197ccfac468 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -81,6 +81,7 @@ #include #include #include +#include #include #include #include @@ -1159,10 +1160,10 @@ static struct task_struct *dup_task_struct(struct t= ask_struct *orig, int node) tsk->btrace_seq =3D 0; #endif tsk->splice_pipe =3D NULL; - tsk->task_frag.page =3D NULL; tsk->wake_q.next =3D NULL; tsk->worker_private =3D NULL; =20 + page_frag_cache_init(&tsk->task_frag); kcov_task_init(tsk); kmsan_task_create(tsk); kmap_local_fork(tsk); diff --git a/net/core/skbuff.c b/net/core/skbuff.c index ca01880c7ad0..97e02892bed8 100644 --- a/net/core/skbuff.c +++ b/net/core/skbuff.c @@ -3062,25 +3062,6 @@ static void sock_spd_release(struct splice_pipe_desc= *spd, unsigned int i) put_page(spd->pages[i]); } =20 -static struct page *linear_to_page(struct page *page, unsigned int *len, - unsigned int *offset, - struct sock *sk) -{ - struct page_frag *pfrag =3D sk_page_frag(sk); - - if (!sk_page_frag_refill(sk, pfrag)) - return NULL; - - *len =3D min_t(unsigned int, *len, pfrag->size - pfrag->offset); - - memcpy(page_address(pfrag->page) + pfrag->offset, - page_address(page) + *offset, *len); - *offset =3D pfrag->offset; - pfrag->offset +=3D *len; - - return pfrag->page; -} - static bool spd_can_coalesce(const struct splice_pipe_desc *spd, struct page *page, unsigned int offset) @@ -3091,6 +3072,37 @@ static bool spd_can_coalesce(const struct splice_pip= e_desc *spd, spd->partial[spd->nr_pages - 1].len =3D=3D offset); } =20 +static bool spd_fill_linear_page(struct splice_pipe_desc *spd, + struct page *page, unsigned int offset, + unsigned int *len, struct sock *sk) +{ + struct page_frag_cache *nc =3D sk_page_frag_cache(sk); + struct page_frag page_frag, *pfrag; + void *va; + + pfrag =3D &page_frag; + va =3D sk_page_frag_alloc_refill_prepare(sk, nc, pfrag); + if (!va) + return true; + + *len =3D min_t(unsigned int, *len, pfrag->size); + memcpy(va, page_address(page) + offset, *len); + + if (spd_can_coalesce(spd, pfrag->page, pfrag->offset)) { + spd->partial[spd->nr_pages - 1].len +=3D *len; + page_frag_commit_noref(nc, pfrag, *len); + return false; + } + + page_frag_commit(nc, pfrag, *len); + spd->pages[spd->nr_pages] =3D pfrag->page; + spd->partial[spd->nr_pages].len =3D *len; + spd->partial[spd->nr_pages].offset =3D pfrag->offset; + spd->nr_pages++; + + return false; +} + /* * Fill page/offset/length into spd, if it can hold more pages. */ @@ -3103,11 +3115,9 @@ static bool spd_fill_page(struct splice_pipe_desc *s= pd, if (unlikely(spd->nr_pages =3D=3D MAX_SKB_FRAGS)) return true; =20 - if (linear) { - page =3D linear_to_page(page, len, &offset, sk); - if (!page) - return true; - } + if (linear) + return spd_fill_linear_page(spd, page, offset, len, sk); + if (spd_can_coalesce(spd, page, offset)) { spd->partial[spd->nr_pages - 1].len +=3D *len; return false; diff --git a/net/core/skmsg.c b/net/core/skmsg.c index b1dcbd3be89e..b19eafeeb8ac 100644 --- a/net/core/skmsg.c +++ b/net/core/skmsg.c @@ -27,23 +27,25 @@ static bool sk_msg_try_coalesce_ok(struct sk_msg *msg, = int elem_first_coalesce) int sk_msg_alloc(struct sock *sk, struct sk_msg *msg, int len, int elem_first_coalesce) { - struct page_frag *pfrag =3D sk_page_frag(sk); + struct page_frag_cache *nc =3D sk_page_frag_cache(sk); u32 osize =3D msg->sg.size; int ret =3D 0; =20 len -=3D msg->sg.size; while (len > 0) { + struct page_frag page_frag, *pfrag; struct scatterlist *sge; u32 orig_offset; int use, i; =20 - if (!sk_page_frag_refill(sk, pfrag)) { + pfrag =3D &page_frag; + if (!sk_page_frag_refill_prepare(sk, nc, pfrag)) { ret =3D -ENOMEM; goto msg_trim; } =20 orig_offset =3D pfrag->offset; - use =3D min_t(int, len, pfrag->size - orig_offset); + use =3D min_t(int, len, pfrag->size); if (!sk_wmem_schedule(sk, use)) { ret =3D -ENOMEM; goto msg_trim; @@ -57,6 +59,7 @@ int sk_msg_alloc(struct sock *sk, struct sk_msg *msg, int= len, sg_page(sge) =3D=3D pfrag->page && sge->offset + sge->length =3D=3D orig_offset) { sge->length +=3D use; + page_frag_commit_noref(nc, pfrag, use); } else { if (sk_msg_full(msg)) { ret =3D -ENOSPC; @@ -66,13 +69,12 @@ int sk_msg_alloc(struct sock *sk, struct sk_msg *msg, i= nt len, sge =3D &msg->sg.data[msg->sg.end]; sg_unmark_end(sge); sg_set_page(sge, pfrag->page, use, orig_offset); - get_page(pfrag->page); + page_frag_commit(nc, pfrag, use); sk_msg_iter_next(msg, end); } =20 sk_mem_charge(sk, use); msg->sg.size +=3D use; - pfrag->offset +=3D use; len -=3D use; } =20 diff --git a/net/core/sock.c b/net/core/sock.c index fe87f9bd8f16..e61a50aadc2e 100644 --- a/net/core/sock.c +++ b/net/core/sock.c @@ -2275,10 +2275,7 @@ static void __sk_destruct(struct rcu_head *head) pr_debug("%s: optmem leakage (%d bytes) detected\n", __func__, atomic_read(&sk->sk_omem_alloc)); =20 - if (sk->sk_frag.page) { - put_page(sk->sk_frag.page); - sk->sk_frag.page =3D NULL; - } + page_frag_cache_drain(&sk->sk_frag); =20 /* We do not need to acquire sk->sk_peer_lock, we are the last user. */ put_cred(sk->sk_peer_cred); @@ -3024,16 +3021,33 @@ bool skb_page_frag_refill(unsigned int sz, struct p= age_frag *pfrag, gfp_t gfp) } EXPORT_SYMBOL(skb_page_frag_refill); =20 -bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag) +bool sk_page_frag_refill_prepare(struct sock *sk, struct page_frag_cache *= nc, + struct page_frag *pfrag) { - if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation))) + if (likely(page_frag_refill_prepare(nc, 32U, pfrag, sk->sk_allocation))) return true; =20 sk_enter_memory_pressure(sk); sk_stream_moderate_sndbuf(sk); return false; } -EXPORT_SYMBOL(sk_page_frag_refill); +EXPORT_SYMBOL(sk_page_frag_refill_prepare); + +void *sk_page_frag_alloc_refill_prepare(struct sock *sk, + struct page_frag_cache *nc, + struct page_frag *pfrag) +{ + void *va; + + va =3D page_frag_alloc_refill_prepare(nc, 32U, pfrag, sk->sk_allocation); + if (likely(va)) + return va; + + sk_enter_memory_pressure(sk); + sk_stream_moderate_sndbuf(sk); + return NULL; +} +EXPORT_SYMBOL(sk_page_frag_alloc_refill_prepare); =20 void __lock_sock(struct sock *sk) __releases(&sk->sk_lock.slock) @@ -3555,8 +3569,8 @@ void sock_init_data_uid(struct socket *sock, struct s= ock *sk, kuid_t uid) sk->sk_error_report =3D sock_def_error_report; sk->sk_destruct =3D sock_def_destruct; =20 - sk->sk_frag.page =3D NULL; - sk->sk_frag.offset =3D 0; + page_frag_cache_init(&sk->sk_frag); + sk->sk_peek_off =3D -1; =20 sk->sk_peer_pid =3D NULL; diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c index 49811c9281d4..6190d9bfd618 100644 --- a/net/ipv4/ip_output.c +++ b/net/ipv4/ip_output.c @@ -953,7 +953,7 @@ static int __ip_append_data(struct sock *sk, struct flowi4 *fl4, struct sk_buff_head *queue, struct inet_cork *cork, - struct page_frag *pfrag, + struct page_frag_cache *nc, int getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb), void *from, int length, int transhdrlen, @@ -1228,13 +1228,19 @@ static int __ip_append_data(struct sock *sk, copy =3D err; wmem_alloc_delta +=3D copy; } else if (!zc) { + struct page_frag page_frag, *pfrag; int i =3D skb_shinfo(skb)->nr_frags; + void *va; =20 err =3D -ENOMEM; - if (!sk_page_frag_refill(sk, pfrag)) + pfrag =3D &page_frag; + va =3D sk_page_frag_alloc_refill_prepare(sk, nc, pfrag); + if (!va) goto error; =20 skb_zcopy_downgrade_managed(skb); + copy =3D min_t(int, copy, pfrag->size); + if (!skb_can_coalesce(skb, i, pfrag->page, pfrag->offset)) { err =3D -EMSGSIZE; @@ -1242,18 +1248,18 @@ static int __ip_append_data(struct sock *sk, goto error; =20 __skb_fill_page_desc(skb, i, pfrag->page, - pfrag->offset, 0); + pfrag->offset, copy); skb_shinfo(skb)->nr_frags =3D ++i; - get_page(pfrag->page); + page_frag_commit(nc, pfrag, copy); + } else { + skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], + copy); + page_frag_commit_noref(nc, pfrag, copy); } - copy =3D min_t(int, copy, pfrag->size - pfrag->offset); - if (getfrag(from, - page_address(pfrag->page) + pfrag->offset, - offset, copy, skb->len, skb) < 0) + + if (getfrag(from, va, offset, copy, skb->len, skb) < 0) goto error_efault; =20 - pfrag->offset +=3D copy; - skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy); skb_len_add(skb, copy); wmem_alloc_delta +=3D copy; } else { @@ -1364,7 +1370,7 @@ int ip_append_data(struct sock *sk, struct flowi4 *fl= 4, } =20 return __ip_append_data(sk, fl4, &sk->sk_write_queue, &inet->cork.base, - sk_page_frag(sk), getfrag, + sk_page_frag_cache(sk), getfrag, from, length, transhdrlen, flags); } =20 diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c index 8b03d8f48ac9..f93769242337 100644 --- a/net/ipv4/tcp.c +++ b/net/ipv4/tcp.c @@ -1192,9 +1192,13 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghd= r *msg, size_t size) if (zc =3D=3D 0) { bool merge =3D true; int i =3D skb_shinfo(skb)->nr_frags; - struct page_frag *pfrag =3D sk_page_frag(sk); + struct page_frag_cache *nc =3D sk_page_frag_cache(sk); + struct page_frag page_frag, *pfrag; + void *va; =20 - if (!sk_page_frag_refill(sk, pfrag)) + pfrag =3D &page_frag; + va =3D sk_page_frag_alloc_refill_prepare(sk, nc, pfrag); + if (!va) goto wait_for_space; =20 if (!skb_can_coalesce(skb, i, pfrag->page, @@ -1206,7 +1210,7 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr= *msg, size_t size) merge =3D false; } =20 - copy =3D min_t(int, copy, pfrag->size - pfrag->offset); + copy =3D min_t(int, copy, pfrag->size); =20 if (unlikely(skb_zcopy_pure(skb) || skb_zcopy_managed(skb))) { if (tcp_downgrade_zcopy_pure(sk, skb)) @@ -1219,20 +1223,19 @@ int tcp_sendmsg_locked(struct sock *sk, struct msgh= dr *msg, size_t size) goto wait_for_space; =20 err =3D skb_copy_to_va_nocache(sk, &msg->msg_iter, skb, - page_address(pfrag->page) + - pfrag->offset, copy); + va, copy); if (err) goto do_error; =20 /* Update the skb. */ if (merge) { skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy); + page_frag_commit_noref(nc, pfrag, copy); } else { skb_fill_page_desc(skb, i, pfrag->page, pfrag->offset, copy); - page_ref_inc(pfrag->page); + page_frag_commit(nc, pfrag, copy); } - pfrag->offset +=3D copy; } else if (zc =3D=3D MSG_ZEROCOPY) { /* First append to a fragless skb builds initial * pure zerocopy skb @@ -3392,11 +3395,7 @@ int tcp_disconnect(struct sock *sk, int flags) =20 WARN_ON(inet->inet_num && !icsk->icsk_bind_hash); =20 - if (sk->sk_frag.page) { - put_page(sk->sk_frag.page); - sk->sk_frag.page =3D NULL; - sk->sk_frag.offset =3D 0; - } + page_frag_cache_drain(&sk->sk_frag); sk_error_report(sk); return 0; } diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c index 4fd746bd4d54..3bb534315908 100644 --- a/net/ipv4/tcp_output.c +++ b/net/ipv4/tcp_output.c @@ -3973,9 +3973,11 @@ static int tcp_send_syn_data(struct sock *sk, struct= sk_buff *syn) struct inet_connection_sock *icsk =3D inet_csk(sk); struct tcp_sock *tp =3D tcp_sk(sk); struct tcp_fastopen_request *fo =3D tp->fastopen_req; - struct page_frag *pfrag =3D sk_page_frag(sk); + struct page_frag_cache *nc =3D sk_page_frag_cache(sk); + struct page_frag page_frag, *pfrag; struct sk_buff *syn_data; int space, err =3D 0; + void *va; =20 tp->rx_opt.mss_clamp =3D tp->advmss; /* If MSS is not cached */ if (!tcp_fastopen_cookie_check(sk, &tp->rx_opt.mss_clamp, &fo->cookie)) @@ -3994,21 +3996,25 @@ static int tcp_send_syn_data(struct sock *sk, struc= t sk_buff *syn) =20 space =3D min_t(size_t, space, fo->size); =20 - if (space && - !skb_page_frag_refill(min_t(size_t, space, PAGE_SIZE), - pfrag, sk->sk_allocation)) - goto fallback; + if (space) { + pfrag =3D &page_frag; + va =3D page_frag_alloc_refill_prepare(nc, + min_t(size_t, space, PAGE_SIZE), + pfrag, sk->sk_allocation); + if (!va) + goto fallback; + } + syn_data =3D tcp_stream_alloc_skb(sk, sk->sk_allocation, false); if (!syn_data) goto fallback; memcpy(syn_data->cb, syn->cb, sizeof(syn->cb)); if (space) { - space =3D min_t(size_t, space, pfrag->size - pfrag->offset); + space =3D min_t(size_t, space, pfrag->size); space =3D tcp_wmem_schedule(sk, space); } if (space) { - space =3D copy_page_from_iter(pfrag->page, pfrag->offset, - space, &fo->data->msg_iter); + space =3D _copy_from_iter(va, space, &fo->data->msg_iter); if (unlikely(!space)) { tcp_skb_tsorted_anchor_cleanup(syn_data); kfree_skb(syn_data); @@ -4016,8 +4022,7 @@ static int tcp_send_syn_data(struct sock *sk, struct = sk_buff *syn) } skb_fill_page_desc(syn_data, 0, pfrag->page, pfrag->offset, space); - page_ref_inc(pfrag->page); - pfrag->offset +=3D space; + page_frag_commit(nc, pfrag, space); skb_len_add(syn_data, space); skb_zcopy_set(syn_data, fo->uarg, NULL); } diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c index f26841f1490f..d30c59746b0f 100644 --- a/net/ipv6/ip6_output.c +++ b/net/ipv6/ip6_output.c @@ -1413,7 +1413,7 @@ static int __ip6_append_data(struct sock *sk, struct sk_buff_head *queue, struct inet_cork_full *cork_full, struct inet6_cork *v6_cork, - struct page_frag *pfrag, + struct page_frag_cache *nc, int getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb), void *from, size_t length, int transhdrlen, @@ -1754,13 +1754,19 @@ static int __ip6_append_data(struct sock *sk, copy =3D err; wmem_alloc_delta +=3D copy; } else if (!zc) { + struct page_frag page_frag, *pfrag; int i =3D skb_shinfo(skb)->nr_frags; + void *va; =20 err =3D -ENOMEM; - if (!sk_page_frag_refill(sk, pfrag)) + pfrag =3D &page_frag; + va =3D sk_page_frag_alloc_refill_prepare(sk, nc, pfrag); + if (!va) goto error; =20 skb_zcopy_downgrade_managed(skb); + copy =3D min_t(int, copy, pfrag->size); + if (!skb_can_coalesce(skb, i, pfrag->page, pfrag->offset)) { err =3D -EMSGSIZE; @@ -1768,18 +1774,18 @@ static int __ip6_append_data(struct sock *sk, goto error; =20 __skb_fill_page_desc(skb, i, pfrag->page, - pfrag->offset, 0); + pfrag->offset, copy); skb_shinfo(skb)->nr_frags =3D ++i; - get_page(pfrag->page); + page_frag_commit(nc, pfrag, copy); + } else { + skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], + copy); + page_frag_commit_noref(nc, pfrag, copy); } - copy =3D min_t(int, copy, pfrag->size - pfrag->offset); - if (getfrag(from, - page_address(pfrag->page) + pfrag->offset, - offset, copy, skb->len, skb) < 0) + + if (getfrag(from, va, offset, copy, skb->len, skb) < 0) goto error_efault; =20 - pfrag->offset +=3D copy; - skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy); skb->len +=3D copy; skb->data_len +=3D copy; skb->truesize +=3D copy; @@ -1842,7 +1848,7 @@ int ip6_append_data(struct sock *sk, } =20 return __ip6_append_data(sk, &sk->sk_write_queue, &inet->cork, - &np->cork, sk_page_frag(sk), getfrag, + &np->cork, sk_page_frag_cache(sk), getfrag, from, length, transhdrlen, flags, ipc6); } EXPORT_SYMBOL_GPL(ip6_append_data); diff --git a/net/kcm/kcmsock.c b/net/kcm/kcmsock.c index f4462cf88ed5..ab6ab1d102b2 100644 --- a/net/kcm/kcmsock.c +++ b/net/kcm/kcmsock.c @@ -804,9 +804,13 @@ static int kcm_sendmsg(struct socket *sock, struct msg= hdr *msg, size_t len) while (msg_data_left(msg)) { bool merge =3D true; int i =3D skb_shinfo(skb)->nr_frags; - struct page_frag *pfrag =3D sk_page_frag(sk); + struct page_frag_cache *nc =3D sk_page_frag_cache(sk); + struct page_frag page_frag, *pfrag; + void *va; =20 - if (!sk_page_frag_refill(sk, pfrag)) + pfrag =3D &page_frag; + va =3D sk_page_frag_alloc_refill_prepare(sk, nc, pfrag); + if (!va) goto wait_for_memory; =20 if (!skb_can_coalesce(skb, i, pfrag->page, @@ -851,14 +855,12 @@ static int kcm_sendmsg(struct socket *sock, struct ms= ghdr *msg, size_t len) if (head !=3D skb) head->truesize +=3D copy; } else { - copy =3D min_t(int, msg_data_left(msg), - pfrag->size - pfrag->offset); + copy =3D min_t(int, msg_data_left(msg), pfrag->size); if (!sk_wmem_schedule(sk, copy)) goto wait_for_memory; =20 err =3D skb_copy_to_va_nocache(sk, &msg->msg_iter, skb, - page_address(pfrag->page) + - pfrag->offset, copy); + va, copy); if (err) goto out_error; =20 @@ -866,13 +868,13 @@ static int kcm_sendmsg(struct socket *sock, struct ms= ghdr *msg, size_t len) if (merge) { skb_frag_size_add( &skb_shinfo(skb)->frags[i - 1], copy); + page_frag_commit_noref(nc, pfrag, copy); } else { skb_fill_page_desc(skb, i, pfrag->page, pfrag->offset, copy); - get_page(pfrag->page); + page_frag_commit(nc, pfrag, copy); } =20 - pfrag->offset +=3D copy; } =20 copied +=3D copy; diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c index c2317919fc14..3383000fe210 100644 --- a/net/mptcp/protocol.c +++ b/net/mptcp/protocol.c @@ -960,7 +960,6 @@ static bool mptcp_skb_can_collapse_to(u64 write_seq, } =20 /* we can append data to the given data frag if: - * - there is space available in the backing page_frag * - the data frag tail matches the current page_frag free offset * - the data frag end sequence number matches the current write seq */ @@ -969,7 +968,6 @@ static bool mptcp_frag_can_collapse_to(const struct mpt= cp_sock *msk, const struct mptcp_data_frag *df) { return df && pfrag->page =3D=3D df->page && - pfrag->size - pfrag->offset > 0 && pfrag->offset =3D=3D (df->offset + df->data_len) && df->data_seq + df->data_len =3D=3D msk->write_seq; } @@ -1085,14 +1083,20 @@ static void mptcp_enter_memory_pressure(struct sock= *sk) /* ensure we get enough memory for the frag hdr, beyond some minimal amoun= t of * data */ -static bool mptcp_page_frag_refill(struct sock *sk, struct page_frag *pfra= g) +static void *mptcp_page_frag_alloc_refill_prepare(struct sock *sk, + struct page_frag_cache *nc, + struct page_frag *pfrag) { - if (likely(skb_page_frag_refill(32U + sizeof(struct mptcp_data_frag), - pfrag, sk->sk_allocation))) - return true; + unsigned int fragsz =3D 32U + sizeof(struct mptcp_data_frag); + void *va; + + va =3D page_frag_alloc_refill_prepare(nc, fragsz, pfrag, + sk->sk_allocation); + if (likely(va)) + return va; =20 mptcp_enter_memory_pressure(sk); - return false; + return NULL; } =20 static struct mptcp_data_frag * @@ -1795,7 +1799,7 @@ static u32 mptcp_send_limit(const struct sock *sk) static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) { struct mptcp_sock *msk =3D mptcp_sk(sk); - struct page_frag *pfrag; + struct page_frag_cache *nc; size_t copied =3D 0; int ret =3D 0; long timeo; @@ -1829,14 +1833,16 @@ static int mptcp_sendmsg(struct sock *sk, struct ms= ghdr *msg, size_t len) if (unlikely(sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))) goto do_error; =20 - pfrag =3D sk_page_frag(sk); + nc =3D sk_page_frag_cache(sk); =20 while (msg_data_left(msg)) { + struct page_frag page_frag, *pfrag; int total_ts, frag_truesize =3D 0; struct mptcp_data_frag *dfrag; bool dfrag_collapsed; - size_t psize, offset; u32 copy_limit; + size_t psize; + void *va; =20 /* ensure fitting the notsent_lowat() constraint */ copy_limit =3D mptcp_send_limit(sk); @@ -1847,21 +1853,26 @@ static int mptcp_sendmsg(struct sock *sk, struct ms= ghdr *msg, size_t len) * page allocator */ dfrag =3D mptcp_pending_tail(sk); - dfrag_collapsed =3D mptcp_frag_can_collapse_to(msk, pfrag, dfrag); + pfrag =3D &page_frag; + va =3D page_frag_alloc_refill_probe(nc, 1, pfrag); + dfrag_collapsed =3D va && mptcp_frag_can_collapse_to(msk, pfrag, + dfrag); if (!dfrag_collapsed) { - if (!mptcp_page_frag_refill(sk, pfrag)) + va =3D mptcp_page_frag_alloc_refill_prepare(sk, nc, + pfrag); + if (!va) goto wait_for_memory; =20 dfrag =3D mptcp_carve_data_frag(msk, pfrag, pfrag->offset); frag_truesize =3D dfrag->overhead; + va +=3D dfrag->overhead; } =20 /* we do not bound vs wspace, to allow a single packet. * memory accounting will prevent execessive memory usage * anyway */ - offset =3D dfrag->offset + dfrag->data_len; - psize =3D pfrag->size - offset; + psize =3D pfrag->size - frag_truesize; psize =3D min_t(size_t, psize, msg_data_left(msg)); psize =3D min_t(size_t, psize, copy_limit); total_ts =3D psize + frag_truesize; @@ -1869,8 +1880,7 @@ static int mptcp_sendmsg(struct sock *sk, struct msgh= dr *msg, size_t len) if (!sk_wmem_schedule(sk, total_ts)) goto wait_for_memory; =20 - ret =3D do_copy_data_nocache(sk, psize, &msg->msg_iter, - page_address(dfrag->page) + offset); + ret =3D do_copy_data_nocache(sk, psize, &msg->msg_iter, va); if (ret) goto do_error; =20 @@ -1879,7 +1889,6 @@ static int mptcp_sendmsg(struct sock *sk, struct msgh= dr *msg, size_t len) copied +=3D psize; dfrag->data_len +=3D psize; frag_truesize +=3D psize; - pfrag->offset +=3D frag_truesize; WRITE_ONCE(msk->write_seq, msk->write_seq + psize); =20 /* charge data on mptcp pending queue to the msk socket @@ -1887,10 +1896,12 @@ static int mptcp_sendmsg(struct sock *sk, struct ms= ghdr *msg, size_t len) */ sk_wmem_queued_add(sk, frag_truesize); if (!dfrag_collapsed) { - get_page(dfrag->page); + page_frag_commit(nc, pfrag, frag_truesize); list_add_tail(&dfrag->list, &msk->rtx_queue); if (!msk->first_pending) WRITE_ONCE(msk->first_pending, dfrag); + } else { + page_frag_commit_noref(nc, pfrag, frag_truesize); } pr_debug("msk=3D%p dfrag at seq=3D%llu len=3D%u sent=3D%u new=3D%d\n", m= sk, dfrag->data_seq, dfrag->data_len, dfrag->already_sent, diff --git a/net/sched/em_meta.c b/net/sched/em_meta.c index 8996c73c9779..4da465af972f 100644 --- a/net/sched/em_meta.c +++ b/net/sched/em_meta.c @@ -590,7 +590,7 @@ META_COLLECTOR(int_sk_sendmsg_off) *err =3D -1; return; } - dst->value =3D sk->sk_frag.offset; + dst->value =3D page_frag_cache_page_offset(&sk->sk_frag); } =20 META_COLLECTOR(int_sk_write_pend) diff --git a/net/tls/tls_device.c b/net/tls/tls_device.c index dc063c2c7950..0ea2cee5dffe 100644 --- a/net/tls/tls_device.c +++ b/net/tls/tls_device.c @@ -253,8 +253,8 @@ static void tls_device_resync_tx(struct sock *sk, struc= t tls_context *tls_ctx, } =20 static void tls_append_frag(struct tls_record_info *record, - struct page_frag *pfrag, - int size) + struct page_frag_cache *nc, + struct page_frag *pfrag, int size) { skb_frag_t *frag; =20 @@ -262,15 +262,34 @@ static void tls_append_frag(struct tls_record_info *r= ecord, if (skb_frag_page(frag) =3D=3D pfrag->page && skb_frag_off(frag) + skb_frag_size(frag) =3D=3D pfrag->offset) { skb_frag_size_add(frag, size); + page_frag_commit_noref(nc, pfrag, size); } else { ++frag; skb_frag_fill_page_desc(frag, pfrag->page, pfrag->offset, size); ++record->num_frags; + page_frag_commit(nc, pfrag, size); + } + + record->len +=3D size; +} + +static void tls_append_dummy_frag(struct tls_record_info *record, + struct page_frag *pfrag, int size) +{ + skb_frag_t *frag; + + frag =3D &record->frags[record->num_frags - 1]; + if (skb_frag_page(frag) =3D=3D pfrag->page && + skb_frag_off(frag) + skb_frag_size(frag) =3D=3D pfrag->offset) { + skb_frag_size_add(frag, size); + } else { + ++frag; + skb_frag_fill_page_desc(frag, pfrag->page, pfrag->offset, size); + ++record->num_frags; get_page(pfrag->page); } =20 - pfrag->offset +=3D size; record->len +=3D size; } =20 @@ -311,11 +330,11 @@ static int tls_push_record(struct sock *sk, static void tls_device_record_close(struct sock *sk, struct tls_context *ctx, struct tls_record_info *record, - struct page_frag *pfrag, + struct page_frag_cache *nc, unsigned char record_type) { struct tls_prot_info *prot =3D &ctx->prot_info; - struct page_frag dummy_tag_frag; + struct page_frag dummy_tag_frag, *pfrag; =20 /* append tag * device will fill in the tag, we just need to append a placeholder @@ -323,13 +342,16 @@ static void tls_device_record_close(struct sock *sk, * increases frag count) * if we can't allocate memory now use the dummy page */ - if (unlikely(pfrag->size - pfrag->offset < prot->tag_size) && - !skb_page_frag_refill(prot->tag_size, pfrag, sk->sk_allocation)) { + pfrag =3D &dummy_tag_frag; + if (unlikely(!page_frag_refill_probe(nc, prot->tag_size, pfrag) && + !page_frag_refill_prepare(nc, prot->tag_size, pfrag, + sk->sk_allocation))) { dummy_tag_frag.page =3D dummy_page; dummy_tag_frag.offset =3D 0; - pfrag =3D &dummy_tag_frag; + tls_append_dummy_frag(record, pfrag, prot->tag_size); + } else { + tls_append_frag(record, nc, pfrag, prot->tag_size); } - tls_append_frag(record, pfrag, prot->tag_size); =20 /* fill prepend */ tls_fill_prepend(ctx, skb_frag_address(&record->frags[0]), @@ -338,6 +360,7 @@ static void tls_device_record_close(struct sock *sk, } =20 static int tls_create_new_record(struct tls_offload_context_tx *offload_ct= x, + struct page_frag_cache *nc, struct page_frag *pfrag, size_t prepend_size) { @@ -352,8 +375,7 @@ static int tls_create_new_record(struct tls_offload_con= text_tx *offload_ctx, skb_frag_fill_page_desc(frag, pfrag->page, pfrag->offset, prepend_size); =20 - get_page(pfrag->page); - pfrag->offset +=3D prepend_size; + page_frag_commit(nc, pfrag, prepend_size); =20 record->num_frags =3D 1; record->len =3D prepend_size; @@ -361,33 +383,34 @@ static int tls_create_new_record(struct tls_offload_c= ontext_tx *offload_ctx, return 0; } =20 -static int tls_do_allocation(struct sock *sk, - struct tls_offload_context_tx *offload_ctx, - struct page_frag *pfrag, - size_t prepend_size) +static void *tls_do_allocation(struct sock *sk, + struct tls_offload_context_tx *offload_ctx, + struct page_frag_cache *nc, + size_t prepend_size, struct page_frag *pfrag) { int ret; =20 if (!offload_ctx->open_record) { - if (unlikely(!skb_page_frag_refill(prepend_size, pfrag, - sk->sk_allocation))) { + void *va; + + if (unlikely(!page_frag_refill_prepare(nc, prepend_size, pfrag, + sk->sk_allocation))) { READ_ONCE(sk->sk_prot)->enter_memory_pressure(sk); sk_stream_moderate_sndbuf(sk); - return -ENOMEM; + return NULL; } =20 - ret =3D tls_create_new_record(offload_ctx, pfrag, prepend_size); + ret =3D tls_create_new_record(offload_ctx, nc, pfrag, + prepend_size); if (ret) - return ret; + return NULL; =20 - if (pfrag->size > pfrag->offset) - return 0; + va =3D page_frag_alloc_refill_probe(nc, 1, pfrag); + if (va) + return va; } =20 - if (!sk_page_frag_refill(sk, pfrag)) - return -ENOMEM; - - return 0; + return sk_page_frag_alloc_refill_prepare(sk, nc, pfrag); } =20 static int tls_device_copy_data(void *addr, size_t bytes, struct iov_iter = *i) @@ -424,8 +447,8 @@ static int tls_push_data(struct sock *sk, struct tls_prot_info *prot =3D &tls_ctx->prot_info; struct tls_offload_context_tx *ctx =3D tls_offload_ctx_tx(tls_ctx); struct tls_record_info *record; + struct page_frag_cache *nc; int tls_push_record_flags; - struct page_frag *pfrag; size_t orig_size =3D size; u32 max_open_record_len; bool more =3D false; @@ -454,7 +477,7 @@ static int tls_push_data(struct sock *sk, return rc; } =20 - pfrag =3D sk_page_frag(sk); + nc =3D sk_page_frag_cache(sk); =20 /* TLS_HEADER_SIZE is not counted as part of the TLS record, and * we need to leave room for an authentication tag. @@ -462,8 +485,12 @@ static int tls_push_data(struct sock *sk, max_open_record_len =3D TLS_MAX_PAYLOAD_SIZE + prot->prepend_size; do { - rc =3D tls_do_allocation(sk, ctx, pfrag, prot->prepend_size); - if (unlikely(rc)) { + struct page_frag page_frag, *pfrag; + void *va; + + pfrag =3D &page_frag; + va =3D tls_do_allocation(sk, ctx, nc, prot->prepend_size, pfrag); + if (unlikely(!va)) { rc =3D sk_stream_wait_memory(sk, &timeo); if (!rc) continue; @@ -512,16 +539,15 @@ static int tls_push_data(struct sock *sk, =20 zc_pfrag.offset =3D off; zc_pfrag.size =3D copy; - tls_append_frag(record, &zc_pfrag, copy); + tls_append_dummy_frag(record, &zc_pfrag, copy); } else if (copy) { - copy =3D min_t(size_t, copy, pfrag->size - pfrag->offset); + copy =3D min_t(size_t, copy, pfrag->size); =20 - rc =3D tls_device_copy_data(page_address(pfrag->page) + - pfrag->offset, copy, - iter); + rc =3D tls_device_copy_data(va, copy, iter); if (rc) goto handle_error; - tls_append_frag(record, pfrag, copy); + + tls_append_frag(record, nc, pfrag, copy); } =20 size -=3D copy; @@ -539,7 +565,7 @@ static int tls_push_data(struct sock *sk, if (done || record->len >=3D max_open_record_len || (record->num_frags >=3D MAX_SKB_FRAGS - 1)) { tls_device_record_close(sk, tls_ctx, record, - pfrag, record_type); + nc, record_type); =20 rc =3D tls_push_record(sk, tls_ctx, --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pj1-f65.google.com (mail-pj1-f65.google.com [209.85.216.65]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 106D21BF32C; Tue, 1 Oct 2024 08:00:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.65 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769634; cv=none; b=jfVGect/TK/cGWRcN2xDx/23/1GRFd+mKogpafSm8inh9ItH/geKQRGLgrFt3cmEo9Xj24/vPabFNa86rGSoGKUtsjTm6gptcN1Ue8rqUJE4sGed8nSxSRzgtlrkLXkJgk4PUevmmuAS++YcXt1KzxkKiAkHKdH6/WjbKEgI42k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769634; c=relaxed/simple; bh=ifZWxgWhOeOXskUmAg6H9udJwzsjxuqiy+z5btSOtDU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=eOP5Gqyd5NaxuoAwQr9LvpE8ji3RAfFo5P7n7VnDuVxW8klm5Gmzv/W3q85cbZ2BqWSy0+RCgTJLe4rZgAkXugTcOZA/Y+76wewnY7xO2I/lAq1g1ogGJ4fCaaGCS7xeojnifnEl8atiu8emJLVPpWgh2AdqDch0Yug+DCE1zfI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=lkSQP8HV; arc=none smtp.client-ip=209.85.216.65 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="lkSQP8HV" Received: by mail-pj1-f65.google.com with SMTP id 98e67ed59e1d1-2e078d28fe9so3803169a91.2; Tue, 01 Oct 2024 01:00:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769630; x=1728374430; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=8zjZyaQZU43G3B0nupuypiK3j9IrQpClbR8UP0D41RE=; b=lkSQP8HVtEFCba9spFeG77QHhcM82bog/KqfJQnh7O+eQPMhq2EUain81oEWGHvvhE p3ZaiTQjvs7oOUuF2XYgE1A8i6hTk84B5Eu/Dd2Zr8ve9/KMGL9ZVDw/LrzVOdK2Dxbv EcMX1jppDmuHGwXNJ1euD2l8z5W30yR+d/WwB+OFysiPTRVaHQiFaSnSku0ro0c1MyiB gTieaHX+T34HuAoqu6dlCoNd7AtzkO0IEUanEYoYHcQHpgFmrajfccJFS+zoUOrSEHVa uXzfygt2BSfMbQcbR8XilHgFBnt8NibbC77gE9/iOTIApi7AGr16yjnorJ2XCZdt1KUQ 8GYQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769630; x=1728374430; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8zjZyaQZU43G3B0nupuypiK3j9IrQpClbR8UP0D41RE=; b=O2ZL6MVBrBeof2r/S+UzScVmrygtAlYYO7ZckB/HX5WE19x2JnRPrYmiB5Dwhkw7jw 4CqkUxGzM5PudLCQvJF529KatZYSoLhfz/UDTrx+HZ4D8PrxPz9jQhO14kSDnmiR99hM aJ8iMoY5N10E9vNYxxPM45Krj7mAJrBK6WqJzPI37aVuPfOnH2Uzo3mrKfGQ50ommJ6q rx9YBiUIRNYyAmkyNFd8ScqQF53a6qEpX59iYi11zXsiN5OPsPAHsyLSeUQlF2Qr0rh6 2l00cV+CS7actKcN3ToEBQpfFe3DaY2DYTiNOps6BoNwBxSUIHPcMB/bsS8D5S4Z+5qa YCZQ== X-Forwarded-Encrypted: i=1; AJvYcCU5x+tuRjVxYYERL5Gx09ZIRTLf0nTY+JeV21Aixv6nNFVKxo8ZWuUEId/Ri8GIdML5dAepP02KPnuSRQdp@vger.kernel.org, AJvYcCWKl4YIPgs9RP109ZwNms105A5tgEhSD7TdNvZPUM6JlwQZDxjIm+SDgYplS0bvLbmZ/lLVeQ+u0tc=@vger.kernel.org X-Gm-Message-State: AOJu0Yyu3v2tJpbgXoRJsC5V2PjgetYbSe5vZw+oMlM3xbjVTagjezz4 HG1hxK1j01IMkj1AFrFL3VQyUd6n9tknB4YyV9zVu0geKyalu3TX X-Google-Smtp-Source: AGHT+IG7hNeIVWEP/rFCNow+T5F8c8AsizFC7gmGKcJLiut0GduVyog9R8rOe180NnXbFxlVRSj3qg== X-Received: by 2002:a17:90a:f2cd:b0:2c2:5f25:5490 with SMTP id 98e67ed59e1d1-2e0b8ee5bc1mr16207817a91.34.1727769629984; Tue, 01 Oct 2024 01:00:29 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.01.00.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 01:00:29 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck , Jonathan Corbet , Andrew Morton , linux-mm@kvack.org, linux-doc@vger.kernel.org Subject: [PATCH net-next v19 13/14] mm: page_frag: update documentation for page_frag Date: Tue, 1 Oct 2024 15:58:56 +0800 Message-Id: <20241001075858.48936-14-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Update documentation about design, implementation and API usages for page_frag. CC: Alexander Duyck Signed-off-by: Yunsheng Lin --- Documentation/mm/page_frags.rst | 177 +++++++++++++++++++++- include/linux/page_frag_cache.h | 259 +++++++++++++++++++++++++++++++- mm/page_frag_cache.c | 26 +++- 3 files changed, 451 insertions(+), 11 deletions(-) diff --git a/Documentation/mm/page_frags.rst b/Documentation/mm/page_frags.= rst index 503ca6cdb804..5eec04a3fe90 100644 --- a/Documentation/mm/page_frags.rst +++ b/Documentation/mm/page_frags.rst @@ -1,3 +1,5 @@ +.. SPDX-License-Identifier: GPL-2.0 + =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D Page fragments =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D @@ -40,4 +42,177 @@ page via a single call. The advantage to doing this is= that it allows for cleaning up the multiple references that were added to a page in order to avoid calling get_page per allocation. =20 -Alexander Duyck, Nov 29, 2016. + +Architecture overview +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +.. code-block:: none + + +----------------------+ + | page_frag API caller | + +----------------------+ + | + | + v + +------------------------------------------------------------------+ + | request page fragment | + +------------------------------------------------------------------+ + | | | + | | | + | Cache not enough | + | | | + | +-----------------+ | + | | reuse old cache |--Usable-->| + | +-----------------+ | + | | | + | Not usable | + | | | + | v | + Cache empty +-----------------+ | + | | drain old cache | | + | +-----------------+ | + | | | + v_________________________________v | + | | + | | + _________________v_______________ | + | | Cache is enou= gh + | | | + PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE | | + | | | + | PAGE_SIZE >=3D PAGE_FRAG_CACHE_MAX_SIZE | + v | | + +----------------------------------+ | | + | refill cache with order > 0 page | | | + +----------------------------------+ | | + | | | | + | | | | + | Refill failed | | + | | | | + | v v | + | +------------------------------------+ | + | | refill cache with order 0 page | | + | +----------------------------------=3D-+ | + | | | + Refill succeed | | + | Refill succeed | + | | | + v v v + +------------------------------------------------------------------+ + | allocate fragment from cache | + +------------------------------------------------------------------+ + +API interface +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +As the design and implementation of page_frag API implies, the allocation = side +does not allow concurrent calling. Instead it is assumed that the caller m= ust +ensure there is not concurrent alloc calling to the same page_frag_cache +instance by using its own lock or rely on some lockless guarantee like NAPI +softirq. + +Depending on different aligning requirement, the page_frag API caller may = call +page_frag_*_align*() to ensure the returned virtual address or offset of t= he +page is aligned according to the 'align/alignment' parameter. Note the siz= e of +the allocated fragment is not aligned, the caller needs to provide an alig= ned +fragsz if there is an alignment requirement for the size of the fragment. + +Depending on different use cases, callers expecting to deal with va, page = or +both va and page for them may call page_frag_alloc, page_frag_refill, or +page_frag_alloc_refill API accordingly. + +There is also a use case that needs minimum memory in order for forward pr= ogress, +but more performant if more memory is available. Using page_frag_*_prepare= () and +page_frag_commit*() related API, the caller requests the minimum memory it= needs +and the prepare API will return the maximum size of the fragment returned.= The +caller needs to either call the commit API to report how much memory it ac= tually +uses, or not do so if deciding to not use any memory. + +.. kernel-doc:: include/linux/page_frag_cache.h + :identifiers: page_frag_cache_init page_frag_cache_is_pfmemalloc + page_frag_cache_page_offset __page_frag_alloc_align + page_frag_alloc_align page_frag_alloc + __page_frag_refill_align page_frag_refill_align + page_frag_refill __page_frag_refill_prepare_align + page_frag_refill_prepare_align page_frag_refill_prepare + __page_frag_alloc_refill_prepare_align + page_frag_alloc_refill_prepare_align + page_frag_alloc_refill_prepare page_frag_alloc_refill_probe + page_frag_refill_probe page_frag_commit + page_frag_commit_noref page_frag_alloc_abort + +.. kernel-doc:: mm/page_frag_cache.c + :identifiers: page_frag_cache_drain page_frag_free + __page_frag_alloc_refill_probe_align + +Coding examples +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +Init & Drain API +---------------- + +.. code-block:: c + + page_frag_cache_init(nc); + ... + page_frag_cache_drain(nc); + + +Alloc & Free API +---------------- + +.. code-block:: c + + void *va; + + va =3D page_frag_alloc_align(nc, size, gfp, align); + if (!va) + goto do_error; + + err =3D do_something(va, size); + if (err) { + page_frag_abort(nc, size); + goto do_error; + } + + ... + + page_frag_free(va); + + +Prepare & Commit API +-------------------- + +.. code-block:: c + + struct page_frag page_frag, *pfrag; + bool merge =3D true; + void *va; + + pfrag =3D &page_frag; + va =3D page_frag_alloc_refill_prepare(nc, 32U, pfrag, GFP_KERNEL); + if (!va) + goto wait_for_space; + + copy =3D min_t(unsigned int, copy, pfrag->size); + if (!skb_can_coalesce(skb, i, pfrag->page, pfrag->offset)) { + if (i >=3D max_skb_frags) + goto new_segment; + + merge =3D false; + } + + copy =3D mem_schedule(copy); + if (!copy) + goto wait_for_space; + + err =3D copy_from_iter_full_nocache(va, copy, iter); + if (err) + goto do_error; + + if (merge) { + skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy); + page_frag_commit_noref(nc, pfrag, copy); + } else { + skb_fill_page_desc(skb, i, pfrag->page, pfrag->offset, copy); + page_frag_commit(nc, pfrag, copy); + } diff --git a/include/linux/page_frag_cache.h b/include/linux/page_frag_cach= e.h index 4e9018051956..dff68d8e0f30 100644 --- a/include/linux/page_frag_cache.h +++ b/include/linux/page_frag_cache.h @@ -30,16 +30,43 @@ static inline bool page_frag_encoded_page_pfmemalloc(un= signed long encoded_page) return !!(encoded_page & PAGE_FRAG_CACHE_PFMEMALLOC_BIT); } =20 +/** + * page_frag_cache_init() - Init page_frag cache. + * @nc: page_frag cache from which to init + * + * Inline helper to init the page_frag cache. + */ static inline void page_frag_cache_init(struct page_frag_cache *nc) { nc->encoded_page =3D 0; } =20 +/** + * page_frag_cache_is_pfmemalloc() - Check for pfmemalloc. + * @nc: page_frag cache from which to check + * + * Used to check if the current page in page_frag cache is pfmemalloc'ed. + * It has the same calling context expectation as the alloc API. + * + * Return: + * true if the current page in page_frag cache is pfmemalloc'ed, otherwise + * return false. + */ static inline bool page_frag_cache_is_pfmemalloc(struct page_frag_cache *n= c) { return page_frag_encoded_page_pfmemalloc(nc->encoded_page); } =20 +/** + * page_frag_cache_page_offset() - Return the current page fragment's offs= et. + * @nc: page_frag cache from which to check + * + * The API is only used in net/sched/em_meta.c for historical reason, do n= ot use + * it for new caller unless there is a strong reason. + * + * Return: + * the offset of the current page fragment in the page_frag cache. + */ static inline unsigned int page_frag_cache_page_offset(const struct page_f= rag_cache *nc) { return nc->offset; @@ -68,6 +95,19 @@ static inline unsigned int __page_frag_cache_commit(stru= ct page_frag_cache *nc, return __page_frag_cache_commit_noref(nc, pfrag, used_sz); } =20 +/** + * __page_frag_alloc_align() - Alloc a page fragment with aligning + * requirement. + * @nc: page_frag cache from which to allocate + * @fragsz: the requested fragment size + * @gfp_mask: the allocation gfp to use when cache need to be refilled + * @align_mask: the requested aligning requirement for the 'va' + * + * Alloc a page fragment from page_frag cache with aligning requirement. + * + * Return: + * Virtual address of the page fragment, otherwise return NULL. + */ static inline void *__page_frag_alloc_align(struct page_frag_cache *nc, unsigned int fragsz, gfp_t gfp_mask, unsigned int align_mask) @@ -85,6 +125,19 @@ static inline void *__page_frag_alloc_align(struct page= _frag_cache *nc, return va; } =20 +/** + * page_frag_alloc_align() - Alloc a page fragment with aligning requireme= nt. + * @nc: page_frag cache from which to allocate + * @fragsz: the requested fragment size + * @gfp_mask: the allocation gfp to use when cache needs to be refilled + * @align: the requested aligning requirement for the fragment + * + * WARN_ON_ONCE() checking for @align before allocing a page fragment from + * page_frag cache with aligning requirement. + * + * Return: + * virtual address of the page fragment, otherwise return NULL. + */ static inline void *page_frag_alloc_align(struct page_frag_cache *nc, unsigned int fragsz, gfp_t gfp_mask, unsigned int align) @@ -93,12 +146,36 @@ static inline void *page_frag_alloc_align(struct page_= frag_cache *nc, return __page_frag_alloc_align(nc, fragsz, gfp_mask, -align); } =20 +/** + * page_frag_alloc() - Alloc a page fragment. + * @nc: page_frag cache from which to allocate + * @fragsz: the requested fragment size + * @gfp_mask: the allocation gfp to use when cache need to be refilled + * + * Alloc a page fragment from page_frag cache. + * + * Return: + * virtual address of the page fragment, otherwise return NULL. + */ static inline void *page_frag_alloc(struct page_frag_cache *nc, unsigned int fragsz, gfp_t gfp_mask) { return __page_frag_alloc_align(nc, fragsz, gfp_mask, ~0u); } =20 +/** + * __page_frag_refill_align() - Refill a page_frag with aligning requireme= nt. + * @nc: page_frag cache from which to refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @gfp_mask: the allocation gfp to use when cache need to be refilled + * @align_mask: the requested aligning requirement for the fragment + * + * Refill a page_frag from page_frag cache with aligning requirement. + * + * Return: + * True if refill succeeds, otherwise return false. + */ static inline bool __page_frag_refill_align(struct page_frag_cache *nc, unsigned int fragsz, struct page_frag *pfrag, @@ -113,6 +190,20 @@ static inline bool __page_frag_refill_align(struct pag= e_frag_cache *nc, return true; } =20 +/** + * page_frag_refill_align() - Refill a page_frag with aligning requirement. + * @nc: page_frag cache from which to refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @gfp_mask: the allocation gfp to use when cache needs to be refilled + * @align: the requested aligning requirement for the fragment + * + * WARN_ON_ONCE() checking for @align before refilling a page_frag from + * page_frag cache with aligning requirement. + * + * Return: + * True if refill succeeds, otherwise return false. + */ static inline bool page_frag_refill_align(struct page_frag_cache *nc, unsigned int fragsz, struct page_frag *pfrag, @@ -122,6 +213,18 @@ static inline bool page_frag_refill_align(struct page_= frag_cache *nc, return __page_frag_refill_align(nc, fragsz, pfrag, gfp_mask, -align); } =20 +/** + * page_frag_refill() - Refill a page_frag. + * @nc: page_frag cache from which to refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @gfp_mask: the allocation gfp to use when cache need to be refilled + * + * Refill a page_frag from page_frag cache. + * + * Return: + * True if refill succeeds, otherwise return false. + */ static inline bool page_frag_refill(struct page_frag_cache *nc, unsigned int fragsz, struct page_frag *pfrag, gfp_t gfp_mask) @@ -129,6 +232,20 @@ static inline bool page_frag_refill(struct page_frag_c= ache *nc, return __page_frag_refill_align(nc, fragsz, pfrag, gfp_mask, ~0u); } =20 +/** + * __page_frag_refill_prepare_align() - Prepare refilling a page_frag with + * aligning requirement. + * @nc: page_frag cache from which to refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @gfp_mask: the allocation gfp to use when cache need to be refilled + * @align_mask: the requested aligning requirement for the fragment + * + * Prepare refill a page_frag from page_frag cache with aligning requireme= nt. + * + * Return: + * True if prepare refilling succeeds, otherwise return false. + */ static inline bool __page_frag_refill_prepare_align(struct page_frag_cache= *nc, unsigned int fragsz, struct page_frag *pfrag, @@ -139,6 +256,21 @@ static inline bool __page_frag_refill_prepare_align(st= ruct page_frag_cache *nc, align_mask); } =20 +/** + * page_frag_refill_prepare_align() - Prepare refilling a page_frag with + * aligning requirement. + * @nc: page_frag cache from which to refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @gfp_mask: the allocation gfp to use when cache needs to be refilled + * @align: the requested aligning requirement for the fragment + * + * WARN_ON_ONCE() checking for @align before prepare refilling a page_frag= from + * page_frag cache with aligning requirement. + * + * Return: + * True if prepare refilling succeeds, otherwise return false. + */ static inline bool page_frag_refill_prepare_align(struct page_frag_cache *= nc, unsigned int fragsz, struct page_frag *pfrag, @@ -150,6 +282,18 @@ static inline bool page_frag_refill_prepare_align(stru= ct page_frag_cache *nc, -align); } =20 +/** + * page_frag_refill_prepare() - Prepare refilling a page_frag. + * @nc: page_frag cache from which to refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @gfp_mask: the allocation gfp to use when cache need to be refilled + * + * Prepare refilling a page_frag from page_frag cache. + * + * Return: + * True if refill succeeds, otherwise return false. + */ static inline bool page_frag_refill_prepare(struct page_frag_cache *nc, unsigned int fragsz, struct page_frag *pfrag, @@ -159,6 +303,20 @@ static inline bool page_frag_refill_prepare(struct pag= e_frag_cache *nc, ~0u); } =20 +/** + * __page_frag_alloc_refill_prepare_align() - Prepare allocing a fragment = and + * refilling a page_frag with aligning requirement. + * @nc: page_frag cache from which to allocate and refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @gfp_mask: the allocation gfp to use when cache need to be refilled + * @align_mask: the requested aligning requirement for the fragment. + * + * Prepare allocing a fragment and refilling a page_frag from page_frag ca= che. + * + * Return: + * virtual address of the page fragment, otherwise return NULL. + */ static inline void *__page_frag_alloc_refill_prepare_align(struct page_fra= g_cache *nc, unsigned int fragsz, struct page_frag *pfrag, @@ -168,6 +326,21 @@ static inline void *__page_frag_alloc_refill_prepare_a= lign(struct page_frag_cach return __page_frag_cache_prepare(nc, fragsz, pfrag, gfp_mask, align_mask); } =20 +/** + * page_frag_alloc_refill_prepare_align() - Prepare allocing a fragment and + * refilling a page_frag with aligning requirement. + * @nc: page_frag cache from which to allocate and refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @gfp_mask: the allocation gfp to use when cache need to be refilled + * @align: the requested aligning requirement for the fragment. + * + * WARN_ON_ONCE() checking for @align before prepare allocing a fragment a= nd + * refilling a page_frag from page_frag cache. + * + * Return: + * virtual address of the page fragment, otherwise return NULL. + */ static inline void *page_frag_alloc_refill_prepare_align(struct page_frag_= cache *nc, unsigned int fragsz, struct page_frag *pfrag, @@ -179,6 +352,19 @@ static inline void *page_frag_alloc_refill_prepare_ali= gn(struct page_frag_cache gfp_mask, -align); } =20 +/** + * page_frag_alloc_refill_prepare() - Prepare allocing a fragment and refi= lling + * a page_frag. + * @nc: page_frag cache from which to allocate and refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @gfp_mask: the allocation gfp to use when cache need to be refilled + * + * Prepare allocing a fragment and refilling a page_frag from page_frag ca= che. + * + * Return: + * virtual address of the page fragment, otherwise return NULL. + */ static inline void *page_frag_alloc_refill_prepare(struct page_frag_cache = *nc, unsigned int fragsz, struct page_frag *pfrag, @@ -188,6 +374,18 @@ static inline void *page_frag_alloc_refill_prepare(str= uct page_frag_cache *nc, gfp_mask, ~0u); } =20 +/** + * page_frag_alloc_refill_probe() - Probe allocing a fragment and refilling + * a page_frag. + * @nc: page_frag cache from which to allocate and refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled + * + * Probe allocing a fragment and refilling a page_frag from page_frag cach= e. + * + * Return: + * virtual address of the page fragment, otherwise return NULL. + */ static inline void *page_frag_alloc_refill_probe(struct page_frag_cache *n= c, unsigned int fragsz, struct page_frag *pfrag) @@ -195,6 +393,17 @@ static inline void *page_frag_alloc_refill_probe(struc= t page_frag_cache *nc, return __page_frag_alloc_refill_probe_align(nc, fragsz, pfrag, ~0u); } =20 +/** + * page_frag_refill_probe() - Probe refilling a page_frag. + * @nc: page_frag cache from which to refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled + * + * Probe refilling a page_frag from page_frag cache. + * + * Return: + * True if refill succeeds, otherwise return false. + */ static inline bool page_frag_refill_probe(struct page_frag_cache *nc, unsigned int fragsz, struct page_frag *pfrag) @@ -202,20 +411,54 @@ static inline bool page_frag_refill_probe(struct page= _frag_cache *nc, return !!page_frag_alloc_refill_probe(nc, fragsz, pfrag); } =20 -static inline void page_frag_commit(struct page_frag_cache *nc, - struct page_frag *pfrag, - unsigned int used_sz) +/** + * page_frag_commit - Commit allocing a page fragment. + * @nc: page_frag cache from which to commit + * @pfrag: the page_frag to be committed + * @used_sz: size of the page fragment has been used + * + * Commit the actual used size for the allocation that was either prepared + * or probed. + * + * Return: + * The true size of the fragment considering the offset alignment. + */ +static inline unsigned int page_frag_commit(struct page_frag_cache *nc, + struct page_frag *pfrag, + unsigned int used_sz) { - __page_frag_cache_commit(nc, pfrag, used_sz); + return __page_frag_cache_commit(nc, pfrag, used_sz); } =20 -static inline void page_frag_commit_noref(struct page_frag_cache *nc, - struct page_frag *pfrag, - unsigned int used_sz) +/** + * page_frag_commit_noref - Commit allocing a page fragment without taking + * page refcount. + * @nc: page_frag cache from which to commit + * @pfrag: the page_frag to be committed + * @used_sz: size of the page fragment has been used + * + * Commit the alloc preparing or probing by passing the actual used size, = but + * not taking refcount. Mostly used for fragmemt coalescing case when the + * current fragment can share the same refcount with previous fragment. + * + * Return: + * The true size of the fragment considering the offset alignment. + */ +static inline unsigned int page_frag_commit_noref(struct page_frag_cache *= nc, + struct page_frag *pfrag, + unsigned int used_sz) { - __page_frag_cache_commit_noref(nc, pfrag, used_sz); + return __page_frag_cache_commit_noref(nc, pfrag, used_sz); } =20 +/** + * page_frag_alloc_abort - Abort the page fragment allocation. + * @nc: page_frag cache to which the page fragment is aborted back + * @fragsz: size of the page fragment to be aborted + * + * It is expected to be called from the same context as the alloc API. + * Mostly used for error handling cases where the fragment is no longer ne= eded. + */ static inline void page_frag_alloc_abort(struct page_frag_cache *nc, unsigned int fragsz) { diff --git a/mm/page_frag_cache.c b/mm/page_frag_cache.c index c052c77a96eb..209cc1e278ab 100644 --- a/mm/page_frag_cache.c +++ b/mm/page_frag_cache.c @@ -75,6 +75,10 @@ static struct page *__page_frag_cache_refill(struct page= _frag_cache *nc, return page; } =20 +/** + * page_frag_cache_drain - Drain the current page from page_frag cache. + * @nc: page_frag cache from which to drain + */ void page_frag_cache_drain(struct page_frag_cache *nc) { if (!nc->encoded_page) @@ -117,6 +121,20 @@ unsigned int __page_frag_cache_commit_noref(struct pag= e_frag_cache *nc, } EXPORT_SYMBOL(__page_frag_cache_commit_noref); =20 +/** + * __page_frag_alloc_refill_probe_align() - Probe allocing a fragment and + * refilling a page_frag with aligning requirement. + * @nc: page_frag cache from which to allocate and refill + * @fragsz: the requested fragment size + * @pfrag: the page_frag to be refilled. + * @align_mask: the requested aligning requirement for the fragment. + * + * Probe allocing a fragment and refilling a page_frag from page_frag cach= e with + * aligning requirement. + * + * Return: + * virtual address of the page fragment, otherwise return NULL. + */ void *__page_frag_alloc_refill_probe_align(struct page_frag_cache *nc, unsigned int fragsz, struct page_frag *pfrag, @@ -208,8 +226,12 @@ void *__page_frag_cache_prepare(struct page_frag_cache= *nc, unsigned int fragsz, } EXPORT_SYMBOL(__page_frag_cache_prepare); =20 -/* - * Frees a page fragment allocated out of either a compound or order 0 pag= e. +/** + * page_frag_free - Free a page fragment. + * @addr: va of page fragment to be freed + * + * Free a page fragment allocated out of either a compound or order 0 page= by + * virtual address. */ void page_frag_free(void *addr) { --=20 2.34.1 From nobody Thu Nov 28 13:33:59 2024 Received: from mail-pg1-f193.google.com (mail-pg1-f193.google.com [209.85.215.193]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A8EAD1BF33C; Tue, 1 Oct 2024 08:00:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.193 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769638; cv=none; b=pVudCHgQW21OT7z0imqU4Qv8TqGOuKjkTbjRh28qtxj+tcy2niQ/uAkxc04CR4aWtz08iHfn6iWS5NwF2tDq52T0wYGczcOX0qt3Kq8KVqYkIxMe4dzRKg3hXe9BYkDLhoyKmM8gUaQU1rIM0P/za6w4FhPxl84u2+B6klQqJWw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1727769638; c=relaxed/simple; bh=iLDhrZd6nqm8fibuYV3aF+o5WHXEJKdLMLwqzDI28AU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=qp9EmXuYWRCRY9+APquZkan7l8DnCXjIxq4QV7ZwQAZfBX7elb+9u8iBBYlpJDL0etDQB+Yc/yaD2CLkOtZ1mrzsDFYfWySVPixuwZG+PjNjgY8/yhHajHyoNQwGQFN3152+7yvfLJ0HggZAOH3sOoRK4Ob1gEON3W1MPrdRlhk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=TFIyGyQ5; arc=none smtp.client-ip=209.85.215.193 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="TFIyGyQ5" Received: by mail-pg1-f193.google.com with SMTP id 41be03b00d2f7-7db90a28cf6so4436626a12.0; Tue, 01 Oct 2024 01:00:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1727769636; x=1728374436; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=58g1IecKWl1H+iaQbjvUK7bF9Ui/htls5xzmgF1E8ZI=; b=TFIyGyQ5aK4UbFAYjE/IieN+ic4FG95jBQONHlD4MA6Yez7g/jjG0YEToDY20Jb+3T JKpfoYz3DnEuXnSmzw9hlMVgERRZzRdrx/AH8XzB374FFqMdSlnlrL3vLGYgHRHZHMQJ VaWILIcuFQXJOUQ5emr7qpNiBzMEkAj7Y2Gr94vPVs7GDN0b+8b+csdbY7OuRuhkEODi Ful7jZUNBfxbPtgC1icJyKDMIoAdv16T4vtCqjuzCGkmtFcxp/HnE2Uwgl98+6trhIwM Qu8NyYsPp8ueL43sHIPipOMtYs74AeHW4Oi7d4iaIiCJ3amx6qhCn20GEIN+aMeAmbQm 2mzQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727769636; x=1728374436; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=58g1IecKWl1H+iaQbjvUK7bF9Ui/htls5xzmgF1E8ZI=; b=KQKR4uSsfQ0XWfqGgWRhrvQ9m+aIWcWS0aHjsb3NzZk+UCk1pow7jjFQbPEJ5owkKD fUeYzbpH9x+kAsZY8ufWgEGsmWZ2YxFPFpDDb+/yzZJtkZdJBTFS0i3xzvlqEt/196rS OpFfViDiZrrGt7e4pUUPqgQJ0PsmvR187ITezCRk+wZWUNEYk92Z/wFRTF+dltzsOsD5 mSoSY04hZ/CcLmekujuF29OIm64ibqzT/nBaPyryQp+vqKHxEz41SpZYALTrWvCDg/tz 0jmzORXnPU3+nolQ0SDWDf+59o4FTuDkbWciVJNqbI8Xrx00xmUyXPbXziJZbTKcCFLg BK1w== X-Forwarded-Encrypted: i=1; AJvYcCXCTU7jWGUwTLcySuGOJ+tg7UJWhPDz9clywkRCfMkDM4pCdOnNVszUE+0BBwZDsJORVURsgZfvV7ReczI=@vger.kernel.org X-Gm-Message-State: AOJu0YwDnH+xQ90bX4VBU0O+E4VxTJ+52UHI3PluPdoOA6BJWNACBnnh ObDi7I+K2MvmuHsy2ST/LwS3T69LvDn8Eq/VTKfkzMHF1jXdUvuC X-Google-Smtp-Source: AGHT+IFkOrisr6bJa2UOCN3zarGX2rCOWIi7W7XMuVBjqkfitwZ6FuLO7hnxX6vN3kxpJR3e+Jpj5Q== X-Received: by 2002:a17:90a:6f82:b0:2e0:6c66:8aa0 with SMTP id 98e67ed59e1d1-2e15a3442c0mr3491904a91.17.1727769635957; Tue, 01 Oct 2024 01:00:35 -0700 (PDT) Received: from yunshenglin-MS-7549.. ([2409:8a55:301b:e120:88bd:a0fb:c6d6:c4a2]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2e06e16d6d2sm13168168a91.2.2024.10.01.01.00.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 01 Oct 2024 01:00:35 -0700 (PDT) From: Yunsheng Lin X-Google-Original-From: Yunsheng Lin To: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Yunsheng Lin , Alexander Duyck Subject: [PATCH net-next v19 14/14] mm: page_frag: add an entry in MAINTAINERS for page_frag Date: Tue, 1 Oct 2024 15:58:57 +0800 Message-Id: <20241001075858.48936-15-linyunsheng@huawei.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20241001075858.48936-1-linyunsheng@huawei.com> References: <20241001075858.48936-1-linyunsheng@huawei.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" After this patchset, page_frag is a small subsystem/library on its own, so add an entry in MAINTAINERS to indicate the new subsystem/library's maintainer, maillist, status and file lists of page_frag. Alexander is the original author of page_frag, add him in the MAINTAINERS too. CC: Alexander Duyck Signed-off-by: Yunsheng Lin --- MAINTAINERS | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index e71d066dc919..6d8e0c4c4780 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -17492,6 +17492,18 @@ F: mm/page-writeback.c F: mm/readahead.c F: mm/truncate.c =20 +PAGE FRAG +M: Alexander Duyck +M: Yunsheng Lin +L: linux-mm@kvack.org +L: netdev@vger.kernel.org +S: Supported +F: Documentation/mm/page_frags.rst +F: include/linux/page_frag_cache.h +F: mm/page_frag_cache.c +F: tools/testing/selftests/mm/page_frag/ +F: tools/testing/selftests/mm/test_page_frag.sh + PAGE POOL M: Jesper Dangaard Brouer M: Ilias Apalodimas --=20 2.34.1