From patchwork Fri Oct 29 18:28:07 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stefan Roesch X-Patchwork-Id: 12593245 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 00209C433FE for ; Fri, 29 Oct 2021 18:28:25 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D14BF610A0 for ; Fri, 29 Oct 2021 18:28:24 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230163AbhJ2Saw (ORCPT ); Fri, 29 Oct 2021 14:30:52 -0400 Received: from mx0a-00082601.pphosted.com ([67.231.145.42]:14004 "EHLO mx0a-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230160AbhJ2Sav (ORCPT ); Fri, 29 Oct 2021 14:30:51 -0400 Received: from pps.filterd (m0044010.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.1.2/8.16.1.2) with SMTP id 19THwMuD003711 for ; Fri, 29 Oct 2021 11:28:23 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=facebook; bh=vV/Ktz0HM3rsdk70/ELOJrCnVvBtZHRSFWorGgMYcL0=; b=kRoP2I9F9ywodLji+OVtWq0sq3LTuTQTMrQZ1IAYWyFJ3Z39g20VSQMbLy+N2u8c9UOH QSm4F6VBQ7PrW2qwg49yviTiB0qHrUQPOLhbHZnHnTdJK5SURDEoeUjbiqDhuyELD5S4 fGN8YFiTHi7xDIrEipaaq11ouHXIX61WdU4= Received: from maileast.thefacebook.com ([163.114.130.16]) by mx0a-00082601.pphosted.com with ESMTP id 3c0ee1m5xh-3 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Fri, 29 Oct 2021 11:28:20 -0700 Received: from intmgw001.05.ash7.facebook.com (2620:10d:c0a8:1b::d) by mail.thefacebook.com (2620:10d:c0a8:82::e) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2308.14; Fri, 29 Oct 2021 11:28:18 -0700 Received: by devvm225.atn0.facebook.com (Postfix, from userid 425415) id D9F175BCB638; Fri, 29 Oct 2021 11:28:15 -0700 (PDT) From: Stefan Roesch To: , CC: Subject: [PATCH v3 1/4] btrfs: store chunk size in space-info struct. Date: Fri, 29 Oct 2021 11:28:07 -0700 Message-ID: <20211029182812.3560677-2-shr@fb.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20211029182812.3560677-1-shr@fb.com> References: <20211029182812.3560677-1-shr@fb.com> MIME-Version: 1.0 X-FB-Internal: Safe X-FB-Source: Intern X-Proofpoint-GUID: pL_NjtY3W-tg_dmDFPdTFTYQfotKnatW X-Proofpoint-ORIG-GUID: pL_NjtY3W-tg_dmDFPdTFTYQfotKnatW X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.182.1,Aquarius:18.0.790,Hydra:6.0.425,FMLib:17.0.607.475 definitions=2021-10-29_04,2021-10-29_01,2020-04-07_01 X-Proofpoint-Spam-Details: rule=fb_default_notspam policy=fb_default score=0 mlxlogscore=999 lowpriorityscore=0 clxscore=1015 malwarescore=0 priorityscore=1501 spamscore=0 suspectscore=0 adultscore=0 phishscore=0 impostorscore=0 bulkscore=0 mlxscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2110150000 definitions=main-2110290100 X-FB-Internal: deliver Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org The chunk size is stored in the btrfs_space_info structure. It is initialized at the start and is then used. Two api's are added to get the current value and one to update the value. These api's will be used to be able to expose the chunk_size as a sysfs setting. Signed-off-by: Stefan Roesch --- fs/btrfs/space-info.c | 51 +++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 3 +++ fs/btrfs/volumes.c | 28 ++++++++---------------- 3 files changed, 63 insertions(+), 19 deletions(-) diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c index 48d77f360a24..7370c152ce8a 100644 --- a/fs/btrfs/space-info.c +++ b/fs/btrfs/space-info.c @@ -181,6 +181,56 @@ void btrfs_clear_space_info_full(struct btrfs_fs_info *info) found->full = 0; } +/* + * Compute chunk size depending on block type for regular volumes. + */ +static u64 compute_chunk_size_regular(struct btrfs_fs_info *info, u64 flags) +{ + ASSERT(flags & BTRFS_BLOCK_GROUP_TYPE_MASK); + + if (flags & BTRFS_BLOCK_GROUP_DATA) + return SZ_1G; + else if (flags & BTRFS_BLOCK_GROUP_SYSTEM) + return SZ_32M; + + /* Handle BTRFS_BLOCK_GROUP_METADATA */ + if (info->fs_devices->total_rw_bytes > 50ULL * SZ_1G) + return SZ_1G; + + return SZ_256M; +} + +/* + * Compute chunk size for zoned volumes. + */ +static u64 compute_chunk_size_zoned(struct btrfs_fs_info *info) +{ + return info->zone_size; +} + +/* + * Compute chunk size depending on volume type. + */ +static u64 compute_chunk_size(struct btrfs_fs_info *info, u64 flags) +{ + if (btrfs_is_zoned(info)) + return compute_chunk_size_zoned(info); + + return compute_chunk_size_regular(info, flags); +} + +/* + * Update default chunk size. + * + */ +void btrfs_update_space_info_chunk_size(struct btrfs_space_info *space_info, + u64 flags, u64 chunk_size) +{ + spin_lock(&space_info->lock); + space_info->default_chunk_size = chunk_size; + spin_unlock(&space_info->lock); +} + static int create_space_info(struct btrfs_fs_info *info, u64 flags) { @@ -202,6 +252,7 @@ static int create_space_info(struct btrfs_fs_info *info, u64 flags) INIT_LIST_HEAD(&space_info->tickets); INIT_LIST_HEAD(&space_info->priority_tickets); space_info->clamp = 1; + space_info->default_chunk_size = compute_chunk_size(info, flags); ret = btrfs_sysfs_add_space_info_type(info, space_info); if (ret) diff --git a/fs/btrfs/space-info.h b/fs/btrfs/space-info.h index cb5056472e79..aa8fc0f72ea6 100644 --- a/fs/btrfs/space-info.h +++ b/fs/btrfs/space-info.h @@ -23,6 +23,7 @@ struct btrfs_space_info { u64 max_extent_size; /* This will hold the maximum extent size of the space info if we had an ENOSPC in the allocator. */ + u64 default_chunk_size; /* default chunk size in bytes */ int clamp; /* Used to scale our threshold for preemptive flushing. The value is >> clamp, so turns @@ -115,6 +116,8 @@ void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags, u64 total_bytes, u64 bytes_used, u64 bytes_readonly, u64 bytes_zone_unusable, struct btrfs_space_info **space_info); +void btrfs_update_space_info_chunk_size(struct btrfs_space_info *space_info, + u64 flags, u64 chunk_size); struct btrfs_space_info *btrfs_find_space_info(struct btrfs_fs_info *info, u64 flags); u64 __pure btrfs_space_info_used(struct btrfs_space_info *s_info, diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c index 546bf1146b2d..563e5b30060d 100644 --- a/fs/btrfs/volumes.c +++ b/fs/btrfs/volumes.c @@ -5063,26 +5063,16 @@ static void init_alloc_chunk_ctl_policy_regular( struct btrfs_fs_devices *fs_devices, struct alloc_chunk_ctl *ctl) { - u64 type = ctl->type; + struct btrfs_space_info *space_info; - if (type & BTRFS_BLOCK_GROUP_DATA) { - ctl->max_stripe_size = SZ_1G; - ctl->max_chunk_size = BTRFS_MAX_DATA_CHUNK_SIZE; - } else if (type & BTRFS_BLOCK_GROUP_METADATA) { - /* For larger filesystems, use larger metadata chunks */ - if (fs_devices->total_rw_bytes > 50ULL * SZ_1G) - ctl->max_stripe_size = SZ_1G; - else - ctl->max_stripe_size = SZ_256M; - ctl->max_chunk_size = ctl->max_stripe_size; - } else if (type & BTRFS_BLOCK_GROUP_SYSTEM) { - ctl->max_stripe_size = SZ_32M; - ctl->max_chunk_size = 2 * ctl->max_stripe_size; - ctl->devs_max = min_t(int, ctl->devs_max, - BTRFS_MAX_DEVS_SYS_CHUNK); - } else { - BUG(); - } + space_info = btrfs_find_space_info(fs_devices->fs_info, ctl->type); + ASSERT(space_info); + + ctl->max_chunk_size = space_info->default_chunk_size; + ctl->max_stripe_size = space_info->default_chunk_size; + + if (ctl->type & BTRFS_BLOCK_GROUP_SYSTEM) + ctl->devs_max = min_t(int, ctl->devs_max, BTRFS_MAX_DEVS_SYS_CHUNK); /* We don't want a chunk larger than 10% of writable space */ ctl->max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),