From patchwork Tue Feb 22 22:26:11 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756006 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 783EAC433F5 for ; Tue, 22 Feb 2022 22:26:29 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234666AbiBVW0y (ORCPT ); Tue, 22 Feb 2022 17:26:54 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58860 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230318AbiBVW0x (ORCPT ); Tue, 22 Feb 2022 17:26:53 -0500 Received: from mail-qv1-xf2c.google.com (mail-qv1-xf2c.google.com [IPv6:2607:f8b0:4864:20::f2c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 27230B10B5 for ; Tue, 22 Feb 2022 14:26:27 -0800 (PST) Received: by mail-qv1-xf2c.google.com with SMTP id 8so3553844qvf.2 for ; Tue, 22 Feb 2022 14:26:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=suj/fvEAvRHPOZjBsYdOkYJ0wjw6CySP2/ziMVa4AGE=; b=nXRnAJ0BC93tRUns9i+4NiCeRuD3GoYsVANYbNYqmN3vMhFI26Sw1YpSjU7+AwaTLJ Q/6LPkhDOwjQFqgo+PL31XNOtDTkbrk3UkTIt5hmmtW5FzcbyW77udG5lL5azoDYwRJz pyeynNsGYvoSwjKocK0g5fdoLLty/yurnnBrkIuFtBIg+eLZsJ2WdsyHeb6sucBrL5VO vuzDMsmRbcG9Vgogiv7hVnW1IUvH+Y+TazPUlMUm7iQS/lnQei/pWG4r25gLqSF6WUYx t8YizPy/TEuQODR7hHPPj6RslBktJWRrKHIZxdojIwoGhRBexPyzE/qadSIiJBYLWFTV TyLg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=suj/fvEAvRHPOZjBsYdOkYJ0wjw6CySP2/ziMVa4AGE=; b=fRTPI+iPS++9lCyBK3FrwDtmPhm68Ut7hQ0Sqy3icirDCD1FuVikFOi48HbMzHMmTz pg1OEOUPsNekVv3FdlDCKoobkWdxbikM85hpKl/aF+nml6MEpII5e5y/UkE756AIA+nA CbEDIZ9/bBXHl3f8beUn69hJhH9eacfhI67OMgshFi3v7pGkz3I9sGB6sMnq4VHrWgXo TA3bu1c3Ib1hVSArfEbW+WoJ+K8Q15oQ9wm3EQCig697B4+/htyNXT7wFulqO4TNayXE 5ocfCmjuoW9KWI5u73wBBLSsfUqvRID5nnyoD7ctZtGrtdmWdp/0EAMB/8w1B5AhNQwC Kwew== X-Gm-Message-State: AOAM5316u4y7Oo9p86VzUUTSSD9hARxyfZ3Gg9YyN2z7MBo9qrLAF3iF JI5cku7xkXmRaio//lnr7iolgHPmvpfoXkfr X-Google-Smtp-Source: ABdhPJyHuyQCGiOwO4CJgz5iNTTnrUQ5MNAJknlkJC+/CfqQIYQ2GuS9vUw/6KAfXWty0xxNJid7XQ== X-Received: by 2002:a05:6214:5003:b0:42f:bc42:6ce4 with SMTP id jo3-20020a056214500300b0042fbc426ce4mr20979907qvb.63.1645568785961; Tue, 22 Feb 2022 14:26:25 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id t18sm746440qta.90.2022.02.22.14.26.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:25 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 01/13] btrfs-progs: turn on more compiler warnings and use -Wall Date: Tue, 22 Feb 2022 17:26:11 -0500 Message-Id: <2e052f1f853c09952ff44d250e78f64a3ba1471c.1645568701.git.josef@toxicpanda.com> X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org In converting some of our helpers to take new args I would miss some locations because we don't stop on any warning, and I would miss the warning in the scrollback. Fix this by stopping compiling on any error and turn on the fancy compiler checks. Signed-off-by: Josef Bacik --- Makefile | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Makefile b/Makefile index af4908f9..e0921ca3 100644 --- a/Makefile +++ b/Makefile @@ -93,6 +93,9 @@ CFLAGS = $(SUBST_CFLAGS) \ -D_XOPEN_SOURCE=700 \ -fno-strict-aliasing \ -fPIC \ + -Wall \ + -Wunused-but-set-parameter \ + -Werror \ -I$(TOPDIR) \ -I$(TOPDIR)/libbtrfsutil \ $(CRYPTO_CFLAGS) \ From patchwork Tue Feb 22 22:26:12 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756007 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 705C9C4332F for ; Tue, 22 Feb 2022 22:26:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234851AbiBVW0y (ORCPT ); Tue, 22 Feb 2022 17:26:54 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58874 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230318AbiBVW0y (ORCPT ); Tue, 22 Feb 2022 17:26:54 -0500 Received: from mail-qk1-x730.google.com (mail-qk1-x730.google.com [IPv6:2607:f8b0:4864:20::730]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 57BF3B10BC for ; Tue, 22 Feb 2022 14:26:28 -0800 (PST) Received: by mail-qk1-x730.google.com with SMTP id f21so1810461qke.13 for ; Tue, 22 Feb 2022 14:26:28 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=eebjVxdqAOalvSrcPJ6qj94x200V0G2iIgEVMzI3ork=; b=Pa2k/vL/aIk+dx1OkHxXIG3oTttVUotQw0oi+B1pzSWamNrq/GtOe7XgWziaWp6fva N0f7AU5XH4qShys6jpG+Pbu0UBsL7mQhXYmYQhfIe1K9+G1Gv0iaPwu9Dm3pGsw4rsJx r3P3IUYTs3crdN6tMsgM6DsLtOzGc7DZ4clO6CfHLdxgPtGdFx5dLCl4MidGNb/Qpugu 2+NuhUKkRz+mQ7lgZ5yyEx93ojhg8qg8SDP9v5g1eP8O2BBSX5WxmK7eRSw/e2oMs9HP KDhgwvJoEVE0xHWAb3L5DV70YcV59x50OIdaasgHr7lOhfQ+mOd7J2TKEFO0bUDu6lJP bl8Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=eebjVxdqAOalvSrcPJ6qj94x200V0G2iIgEVMzI3ork=; b=VO41Ptnr5UXXnKp+g8AxV9OMw77I6VVxD+nZAZRRNiBcCnMlMIAGxQ3jShMeDqt+WY eG6d4+X83CSee1erfnn41Qs0MDJ8iF9O5uE+AQ4UPxe9/5nkUGXJ8RDIEuj/7wn35S6h MFgapDkRq3EGPN5OGbCiPGatR6vJtuhxGqwOYYGgOqOH/GXiRw7l+LoiP/CdSPwWJH3J 62CGPW2uXP4mbJhhlKFf6xEe+zb5K+kH3fqwi1geXIi8EY+3IgjHCIfgN8EsNRyoJMJ0 9ljmweGfAOeVxtyDSKIOuczEF3ukny+idwBz/gwitFuG8fktfXIB0RrvF8+T+d8hgMki Zljg== X-Gm-Message-State: AOAM5313YSbS7RtbLfiiI6V7kKboKuEdhQbLG/wrkP5rsR51klnBhkIt 4f2n54ldGTWpWjGHWIUCJgG7XYpNUuCeHPcj X-Google-Smtp-Source: ABdhPJzMUETcopHJd8GzJ09mE9DI802AtCPWi8oAPU7A03DaCl0RrMApVKRJXfRhsSjs0Qk7vpMHXw== X-Received: by 2002:a37:a0c6:0:b0:60b:54ea:29dc with SMTP id j189-20020a37a0c6000000b0060b54ea29dcmr16691756qke.354.1645568787201; Tue, 22 Feb 2022 14:26:27 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id k5sm554291qkk.82.2022.02.22.14.26.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:26 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 02/13] btrfs-progs: store LEAF_DATA_SIZE in the mkfs_config Date: Tue, 22 Feb 2022 17:26:12 -0500 Message-Id: <3dfc516330a61f54ec9dbc2b59ad38d96992e59a.1645568701.git.josef@toxicpanda.com> X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org We use __BTRFS_LEAF_DATA_SIZE() in a few places for mkfs. With extent tree v2 we'll be increasing the size of btrfs_header, so it'll be kind of annoying to add flags to all callers of __BTRFS_LEAF_DATA_SIZE, so simply calculate it once and put it in the mkfs_config and use that. Signed-off-by: Josef Bacik --- mkfs/common.c | 9 ++++----- mkfs/common.h | 1 + mkfs/main.c | 1 + 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/mkfs/common.c b/mkfs/common.c index 9608d27f..aee4b9fb 100644 --- a/mkfs/common.c +++ b/mkfs/common.c @@ -93,7 +93,7 @@ static int btrfs_create_tree_root(int fd, struct btrfs_mkfs_config *cfg, btrfs_set_disk_key_type(&disk_key, BTRFS_ROOT_ITEM_KEY); btrfs_set_disk_key_offset(&disk_key, 0); - itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - sizeof(root_item); + itemoff = cfg->leaf_data_size - sizeof(root_item); for (i = 0; i < blocks_nr; i++) { blk = blocks[i]; @@ -148,7 +148,7 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg, { struct btrfs_free_space_info *info; struct btrfs_disk_key disk_key; - int itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize); + int itemoff = cfg->leaf_data_size; int nritems = 0; int ret; @@ -427,7 +427,7 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) cfg->nodesize - sizeof(struct btrfs_header)); nritems = 0; item_size = sizeof(*dev_item); - itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - item_size; + itemoff = cfg->leaf_data_size - item_size; /* first device 1 (there is no device 0) */ btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID); @@ -515,8 +515,7 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) memset(buf->data + sizeof(struct btrfs_header), 0, cfg->nodesize - sizeof(struct btrfs_header)); nritems = 0; - itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - - sizeof(struct btrfs_dev_extent); + itemoff = cfg->leaf_data_size - sizeof(struct btrfs_dev_extent); btrfs_set_disk_key_objectid(&disk_key, 1); btrfs_set_disk_key_offset(&disk_key, system_group_offset); diff --git a/mkfs/common.h b/mkfs/common.h index 66c9d9d0..428cd366 100644 --- a/mkfs/common.h +++ b/mkfs/common.h @@ -76,6 +76,7 @@ struct btrfs_mkfs_config { u32 nodesize; u32 sectorsize; u32 stripesize; + u32 leaf_data_size; /* Bitfield of incompat features, BTRFS_FEATURE_INCOMPAT_* */ u64 features; /* Bitfield of BTRFS_RUNTIME_FEATURE_* */ diff --git a/mkfs/main.c b/mkfs/main.c index f9e8be74..3dd06979 100644 --- a/mkfs/main.c +++ b/mkfs/main.c @@ -1413,6 +1413,7 @@ int BOX_MAIN(mkfs)(int argc, char **argv) mkfs_cfg.features = features; mkfs_cfg.runtime_features = runtime_features; mkfs_cfg.csum_type = csum_type; + mkfs_cfg.leaf_data_size = __BTRFS_LEAF_DATA_SIZE(nodesize); if (zoned) mkfs_cfg.zone_size = zone_size(file); else From patchwork Tue Feb 22 22:26:13 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756008 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5B887C433F5 for ; Tue, 22 Feb 2022 22:26:32 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235707AbiBVW04 (ORCPT ); Tue, 22 Feb 2022 17:26:56 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58880 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230318AbiBVW0z (ORCPT ); Tue, 22 Feb 2022 17:26:55 -0500 Received: from mail-qv1-xf2e.google.com (mail-qv1-xf2e.google.com [IPv6:2607:f8b0:4864:20::f2e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AFF1AB10B5 for ; Tue, 22 Feb 2022 14:26:29 -0800 (PST) Received: by mail-qv1-xf2e.google.com with SMTP id d3so3590113qvb.5 for ; Tue, 22 Feb 2022 14:26:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=611LCI5vySsFWRZuSkZ9BinIxusuA0FwgYLFYstxWmQ=; b=Z2DvIM5FppOhX7/ySROoCuWYZ59vsRkt9JLUq6DelrLPjwMzOgIgNmkzeGg7vwXgTG F+a7ZqapbH9qF/4pe1nnmAbX9bIY0nG9aKTu12fookW1tiw5072GI2+WlBbvrOFVDkHp joniNNtwU0XrJHC10MNBLdECY4luAK5pW2tbmKm3jK5AB5gI65J4D9isHSkkuK6+NdSf NTHo0bdq6rCVVddIwkBoFhKi0UDcrB9ITDqYrCCla1ZoxkoRijK8XJxLAoHgqtm+oqKy 98lst4/sa7sOY3HKVRYHReo8b07iSocNlR+ypcbrQjdVdI05MLOtJTvDi4aIydjhzi4d xQNQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=611LCI5vySsFWRZuSkZ9BinIxusuA0FwgYLFYstxWmQ=; b=ITimzYojhQLUY0SKBSqSlVEOIbNJZAfRRY5SxSCMnK0W6JXZ28bfl7sTpMVzCuCyFA bZfK5L4ea/5v3J3TY+8tiUppTqD1jPoKx8aoTtIcJU3X0b+0JfchfpylYRZMa8yPVeoB mM1hLUODmA9hZES1yxKHwnpJpzRE953HGwKzR6T+brBnsXhr+w36usUKTQS14jmIo4W7 AyXbzoazySx0GUnefFZtKuYQ2pxVhijyuk5ApgATZvoIgTdy4wM15ArjKVfkfaby/it1 yzVAM1rVxS3MVXlpYwF+GotqQeokN8xl7Hd/GnNpBLJ9UqXXjqybn3aCUS6GW5byudU6 YTjw== X-Gm-Message-State: AOAM530RYdNUGSvaT+VCKy7AE8mejdx5QtWBBqAys1BDpuJGXfTy01Sc UFJtQzlO2BJr37m49qF+KvH0REQi9Oy3rS15 X-Google-Smtp-Source: ABdhPJzJPDI3Fnpoec1jEPHWpxqf5nMgW8V5l+EPkGELw3GtRmZD6XyQBPKiIz5AnYQnE9n3GlXRgQ== X-Received: by 2002:ac8:5a0a:0:b0:2de:b81:24ca with SMTP id n10-20020ac85a0a000000b002de0b8124camr11719704qta.271.1645568788602; Tue, 22 Feb 2022 14:26:28 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id 18sm696283qtx.88.2022.02.22.14.26.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:28 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 03/13] btrfs-progs: store BTRFS_LEAF_DATA_SIZE in the fs_info Date: Tue, 22 Feb 2022 17:26:13 -0500 Message-Id: <94cb2a8f86edb5ecbe0874ccd7ca3d5514bdab6f.1645568701.git.josef@toxicpanda.com> X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org This is going to be a different value based on the incompat settings of the file system, just store this in the fs_info instead of calculating it every time. Signed-off-by: Josef Bacik --- kernel-shared/ctree.h | 4 ++-- kernel-shared/disk-io.c | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h index de5452f2..31169f33 100644 --- a/kernel-shared/ctree.h +++ b/kernel-shared/ctree.h @@ -363,8 +363,7 @@ static inline u32 __BTRFS_LEAF_DATA_SIZE(u32 nodesize) return nodesize - sizeof(struct btrfs_header); } -#define BTRFS_LEAF_DATA_SIZE(fs_info) \ - (__BTRFS_LEAF_DATA_SIZE(fs_info->nodesize)) +#define BTRFS_LEAF_DATA_SIZE(fs_info) (fs_info->leaf_data_size) /* * this is a very generous portion of the super block, giving us @@ -1271,6 +1270,7 @@ struct btrfs_fs_info { u32 nodesize; u32 sectorsize; u32 stripesize; + u32 leaf_data_size; u16 csum_type; u16 csum_size; diff --git a/kernel-shared/disk-io.c b/kernel-shared/disk-io.c index f83ba884..0434ed7d 100644 --- a/kernel-shared/disk-io.c +++ b/kernel-shared/disk-io.c @@ -1552,6 +1552,7 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, struct open_ctree_flags *oc fs_info->stripesize = btrfs_super_stripesize(disk_super); fs_info->csum_type = btrfs_super_csum_type(disk_super); fs_info->csum_size = btrfs_super_csum_size(disk_super); + fs_info->leaf_data_size = __BTRFS_LEAF_DATA_SIZE(fs_info->nodesize); ret = btrfs_check_fs_compatibility(fs_info->super_copy, flags); if (ret) From patchwork Tue Feb 22 22:26:14 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756009 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 07149C433EF for ; Tue, 22 Feb 2022 22:26:34 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236025AbiBVW06 (ORCPT ); Tue, 22 Feb 2022 17:26:58 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58936 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235962AbiBVW05 (ORCPT ); Tue, 22 Feb 2022 17:26:57 -0500 Received: from mail-qk1-x734.google.com (mail-qk1-x734.google.com [IPv6:2607:f8b0:4864:20::734]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E97D4B23 for ; Tue, 22 Feb 2022 14:26:30 -0800 (PST) Received: by mail-qk1-x734.google.com with SMTP id v5so1870931qkj.4 for ; Tue, 22 Feb 2022 14:26:30 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=ihXMTpnzi1FSNblBDeAIrCHeYX++xu+aaMtFvJzpH34=; b=jMyJia3/t7d9mHFix3c92wWoJP2DuVMvaMkkEDlRYxcVo/DuwVlJ340yeF3Zfv1mHr vSuc6b3elt9lHBpi29q08p1PoZc4BG2OxcOW5FygY0eTnfZjXORLfZ27ThQ5fLsQlrib htSLey5R4VGK83SzS8r/HyVImZMRUMuDiWHTJUcxTzky2HKF7OF5jmtwtAJjIHx2jAqj uTgN59TlbINlpuD2Kp5IoVq51k8l10SjLGfLUn8tQUZJBbcxRxKsPWIcvN/YKcvNS55B jSrH3nn75OSEGX2vVfvdZQ4WKsKaidot7WDc1v2LdqBE5whpXFntrgLaZvAvj/3GZi0W YBkg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ihXMTpnzi1FSNblBDeAIrCHeYX++xu+aaMtFvJzpH34=; b=NKJ04kqWTNYH9LR+KG7YJOTO4A2K6T3TWqw2sJR9DTK/FHms3p8GGFZaHu/DPXVKwU 5A2OK27jzM/N5DIgtuB+DYcD8tBKXwtJiB4+U2vGCiCU3V+CEUT4TCZH0xrYHi6Hm9ts /iJosWf3sQ8ODj8W5YNtVkW8vH6mbnv07wN5eQNIBHIisgjbtmcHt0uo9ItOhiwEbk9R 10RLlbWLDygDkeKdpYfee+d0K84ZSvDAjoNdjERroZG3RIGNsObUnkCMue1HlN44UWU7 pBCr/Nn4KLaILg676H9AMF1D7Ff3ibv9M35rURTMz4R8RmeCNZI3NGTuP1S4jdLgEpg+ dFHw== X-Gm-Message-State: AOAM533+/GSNvZdxvdwUOZGIyeHiJgYBomU2QgjZ2WzAl8oR4JV3sQ4K QZ93cbq+Mf3/LWJo1a4TIxLV0QI49jkelPIk X-Google-Smtp-Source: ABdhPJyvy+k6cYoyMJQ5WwOkOKon8ghZ30uY70YIRkDjGGsTiowkntRbGmSYU4o0v1RR8KVoKAykcA== X-Received: by 2002:ae9:e40e:0:b0:62c:ec14:9277 with SMTP id q14-20020ae9e40e000000b0062cec149277mr13283891qkc.432.1645568789777; Tue, 22 Feb 2022 14:26:29 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id z3sm556790qkl.13.2022.02.22.14.26.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:29 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 04/13] btrfs-progs: convert: use cfg->leaf_data_size Date: Tue, 22 Feb 2022 17:26:14 -0500 Message-Id: X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org The mkfs_config can hold the BTRFS_LEAF_DATA_SIZE, so calculate this at config creation time and then use that value throughout convert instead of calling __BTRFS_LEAF_DATA_SIZE. Signed-off-by: Josef Bacik --- convert/common.c | 8 ++++---- convert/main.c | 1 + 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/convert/common.c b/convert/common.c index 00a7e553..356c2b4c 100644 --- a/convert/common.c +++ b/convert/common.c @@ -238,7 +238,7 @@ static int setup_temp_root_tree(int fd, struct btrfs_mkfs_config *cfg, u64 dev_bytenr, u64 fs_bytenr, u64 csum_bytenr) { struct extent_buffer *buf = NULL; - u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize); + u32 itemoff = cfg->leaf_data_size; int slot = 0; int ret; @@ -419,7 +419,7 @@ static int setup_temp_chunk_tree(int fd, struct btrfs_mkfs_config *cfg, u64 chunk_bytenr) { struct extent_buffer *buf = NULL; - u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize); + u32 itemoff = cfg->leaf_data_size; int slot = 0; int ret; @@ -490,7 +490,7 @@ static int setup_temp_dev_tree(int fd, struct btrfs_mkfs_config *cfg, u64 dev_bytenr) { struct extent_buffer *buf = NULL; - u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize); + u32 itemoff = cfg->leaf_data_size; int slot = 0; int ret; @@ -688,7 +688,7 @@ static int setup_temp_extent_tree(int fd, struct btrfs_mkfs_config *cfg, u64 fs_bytenr, u64 csum_bytenr) { struct extent_buffer *buf = NULL; - u32 itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize); + u32 itemoff = cfg->leaf_data_size; int slot = 0; int ret; diff --git a/convert/main.c b/convert/main.c index 333d5be1..b72d1e51 100644 --- a/convert/main.c +++ b/convert/main.c @@ -1228,6 +1228,7 @@ static int do_convert(const char *devname, u32 convert_flags, u32 nodesize, mkfs_cfg.sectorsize = blocksize; mkfs_cfg.stripesize = blocksize; mkfs_cfg.features = features; + mkfs_cfg.leaf_data_size = __BTRFS_LEAF_DATA_SIZE(nodesize); printf("Create initial btrfs filesystem\n"); ret = make_convert_btrfs(fd, &mkfs_cfg, &cctx); From patchwork Tue Feb 22 22:26:15 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756010 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id EA0AAC433F5 for ; Tue, 22 Feb 2022 22:26:34 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236046AbiBVW07 (ORCPT ); Tue, 22 Feb 2022 17:26:59 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59004 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235962AbiBVW06 (ORCPT ); Tue, 22 Feb 2022 17:26:58 -0500 Received: from mail-qv1-xf35.google.com (mail-qv1-xf35.google.com [IPv6:2607:f8b0:4864:20::f35]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 149B6B23 for ; Tue, 22 Feb 2022 14:26:32 -0800 (PST) Received: by mail-qv1-xf35.google.com with SMTP id a1so3503085qvl.6 for ; Tue, 22 Feb 2022 14:26:32 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=5ncJGUm3CmUqE60m4mWQV2B5JlQzXDzME+OHPly9r7M=; b=SCFDxA8YQkDPErnmk11heDk5i6S6AkNfiMX3bu/dG5xHF7b+gLW2Fog8S+0Nk13d1C ZKB/XD6F3F7snxo9XOa3xEh/46tmfm1W+I5+qLfaSgJuSFcyuO4FTyDQ8foy8xzg+/lc ZUUjo2zhkwf92z77BsxD9lZut85d56JQNzcnAQTld1rUBmV/SXMb2wuEEoqZzIVkOG6p fTmNFvyOuq3QpBNkBSLzxTy5pmbTLOn/yZdEHktYWVGC2Kjy5v1MHO6xXQt6UEzlkBG3 LviHUs6lh8NP+uql12iDqV5jjrLeMQyp3R0x5ALQlg1jT0Xe5o2I7JyQ8js6Y5YEgcCz 3wzw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=5ncJGUm3CmUqE60m4mWQV2B5JlQzXDzME+OHPly9r7M=; b=p+qAWIyfK4ftMo6rv6aGL0lV9ZjPGvS4lYBX8VGfDJ5tBCdsoHvGxH6qWdOX6ydyxo XqnON01poXcXKiRmEm1WzjlQKrO8YC0swkr2Z1yOVxcRlRWYxUIatawjOSt+g90mCUbC R3cpemPS+vduiBrq/KXDy6rC7W464IsWKnJbp+BQCeka+7ulDGS1T4onS72NTIVKSZK1 E7eLfDhn/qE5JOvB/AMoOMrbJhPYhBHOsu/4puVw4FORDJRKYSBhzkfRwRVzuB+HjUbs Q9TFBIlVRvbjRbojcxrk6ldnWlXktC+VDFBWrpIQIeEWpZtf35mxmW8zXGcwOi3k/9/W 2TmQ== X-Gm-Message-State: AOAM532fhzLqel0A/aOEbQqoqaPUHkOO+N+sf8y/3nIeKcPUpZ9bOtUE /YPdwAFR1YSrfyvUi0R1qiIa/Z42+x7aG6Vn X-Google-Smtp-Source: ABdhPJyWOpmGk7dlNFZenmj/htWW3GVGonXjLVRb0Nzcm4LGk/Eeg0E/XwIr1j0fUXlrlSkGBR6laQ== X-Received: by 2002:ad4:53c5:0:b0:42d:7bb4:a8e8 with SMTP id k5-20020ad453c5000000b0042d7bb4a8e8mr20860599qvv.8.1645568791044; Tue, 22 Feb 2022 14:26:31 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id x12sm752419qtw.9.2022.02.22.14.26.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:30 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 05/13] btrfs-progs: reduce usage of __BTRFS_LEAF_DATA_SIZE Date: Tue, 22 Feb 2022 17:26:15 -0500 Message-Id: X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org This helper only takes the nodesize, but in the future it'll take a bool to indicate if we're extent tree v2. The remaining users are all where we only have extent_buffer, but we should always have a valid eb->fs_info in these cases, so add BUG_ON()'s for the !eb->fs_info case and then convert these callers to use BTRFS_LEAF_DATA_SIZE which takes the fs_info. Signed-off-by: Josef Bacik --- kernel-shared/ctree.c | 5 +++-- kernel-shared/ctree.h | 5 +++-- kernel-shared/print-tree.c | 2 +- mkfs/common.c | 2 +- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c index 950923d0..10b22b2c 100644 --- a/kernel-shared/ctree.c +++ b/kernel-shared/ctree.c @@ -1949,8 +1949,9 @@ int btrfs_leaf_free_space(struct extent_buffer *leaf) u32 leaf_data_size; int ret; - BUG_ON(leaf->fs_info && leaf->fs_info->nodesize != leaf->len); - leaf_data_size = __BTRFS_LEAF_DATA_SIZE(leaf->len); + BUG_ON(!leaf->fs_info); + BUG_ON(leaf->fs_info->nodesize != leaf->len); + leaf_data_size = BTRFS_LEAF_DATA_SIZE(leaf->fs_info); ret = leaf_data_size - leaf_space_used(leaf, 0 ,nritems); if (ret < 0) { printk("leaf free space ret %d, leaf data size %u, used %d nritems %d\n", diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h index 31169f33..d9677bce 100644 --- a/kernel-shared/ctree.h +++ b/kernel-shared/ctree.h @@ -1328,8 +1328,9 @@ static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info) static inline u32 BTRFS_NODEPTRS_PER_EXTENT_BUFFER(const struct extent_buffer *eb) { - BUG_ON(eb->fs_info && eb->fs_info->nodesize != eb->len); - return __BTRFS_LEAF_DATA_SIZE(eb->len) / sizeof(struct btrfs_key_ptr); + BUG_ON(!eb->fs_info); + BUG_ON(eb->fs_info->nodesize != eb->len); + return BTRFS_LEAF_DATA_SIZE(eb->fs_info) / sizeof(struct btrfs_key_ptr); } #define BTRFS_FILE_EXTENT_INLINE_DATA_START \ diff --git a/kernel-shared/print-tree.c b/kernel-shared/print-tree.c index bd75ae51..7308599f 100644 --- a/kernel-shared/print-tree.c +++ b/kernel-shared/print-tree.c @@ -1288,7 +1288,7 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode) { struct btrfs_item *item; struct btrfs_disk_key disk_key; - u32 leaf_data_size = __BTRFS_LEAF_DATA_SIZE(eb->len); + u32 leaf_data_size = BTRFS_LEAF_DATA_SIZE(eb->fs_info); u32 i; u32 nr; const bool print_csum_items = (mode & BTRFS_PRINT_TREE_CSUM_ITEMS); diff --git a/mkfs/common.c b/mkfs/common.c index aee4b9fb..f3e689cb 100644 --- a/mkfs/common.c +++ b/mkfs/common.c @@ -326,7 +326,7 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) memset(buf->data + sizeof(struct btrfs_header), 0, cfg->nodesize - sizeof(struct btrfs_header)); nritems = 0; - itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize); + itemoff = cfg->leaf_data_size; for (i = 0; i < blocks_nr; i++) { blk = blocks[i]; From patchwork Tue Feb 22 22:26:16 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756011 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id DF568C433EF for ; Tue, 22 Feb 2022 22:26:36 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236048AbiBVW1B (ORCPT ); Tue, 22 Feb 2022 17:27:01 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59170 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235962AbiBVW1A (ORCPT ); Tue, 22 Feb 2022 17:27:00 -0500 Received: from mail-qv1-xf29.google.com (mail-qv1-xf29.google.com [IPv6:2607:f8b0:4864:20::f29]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AB03BB23 for ; Tue, 22 Feb 2022 14:26:33 -0800 (PST) Received: by mail-qv1-xf29.google.com with SMTP id d3so3590605qvb.5 for ; Tue, 22 Feb 2022 14:26:33 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=KmF4M4hth6u1JTO3sX+FMnPfpHjjYKrQlsZhZPtRYzg=; b=726jzCpaOfSRimXcjdMVQBz9htM5szW+Gtu2NCUN34Sk9Tt0v9vyoz3Yqe6Mu8Y2hJ D4L7tGsA9a9lZNBgreWA/nFMDGTBiNUlJpSJVdje4c/dEzfQSw5Ljrs2W52cx1L07qtY 4lOFT4b5D41/oF7tNYDu0hQjZ1aZt2FBcqkcJxgFUkGjEG8XQexqAZbBfeHED5AWQQZv Iihzf1KYkLzz5eXAOy9KeMLsORSO5itAOSmIPqrbDybqZKNdAU1mCv8e5P9gTv0Qg9aX PZyuNvypGp18jlM9sdqNiGsfF13zvm/DAmstZv9NmvNaT4RthJNoJjDc0f+40XwLbCn5 mXYg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=KmF4M4hth6u1JTO3sX+FMnPfpHjjYKrQlsZhZPtRYzg=; b=6KVazefyS/eqF5eOlQgUUBv5ptKIltgmZMTa5J9cZVu+wyqPxNu/nGKiLydA75lBzA y6xRX0TOUM05MweQPw4hjFHqln6BaAfsX1nsjwNC1KbMiA4GV+MZQe5PWlkla+h+63AG jEgraxh7JDa7PhOidbiVNL40c2txOIvZuF5pODr2h0OeUOZAjW3E1u0eYjVnZl46YAU7 fj10UiB7JJYbK2di+ksUkrJ+v2fo5rHRuD6j0e0DrVRn2SBGFCWkZcQ5F2yAge6w7i6E 8qtdkM8OqaaKGDTK5o64TXskdcm+cPjZyfjWuC+oOMM3JXryqB1XxnGLOIQ7anI3odYV J91Q== X-Gm-Message-State: AOAM533Mah8kuLjXe2+SzDFzWVlRzV0YY6UgxMVXrfM0QhioNRjlws+A VKEXCK2BVNgHpY02cmK7i/fRZOWs+qh9Isb7 X-Google-Smtp-Source: ABdhPJxKUp5zLaZCXotn3Z1hMyYm4kkZXYSJIbdCSfBo23sGSTT+GnjL5B8c/G+xgZAV5n2/ZhJDsA== X-Received: by 2002:a0c:efcc:0:b0:432:42e6:e4ef with SMTP id a12-20020a0cefcc000000b0043242e6e4efmr3685516qvt.97.1645568792447; Tue, 22 Feb 2022 14:26:32 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id o6sm719021qtw.52.2022.02.22.14.26.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:32 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 06/13] btrfs-progs: btrfs_item_size_nr/btrfs_item_offset_nr everywhere Date: Tue, 22 Feb 2022 17:26:16 -0500 Message-Id: X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org We have this pattern in a lot of places item = btrfs_item_nr(slot); btrfs_item_size(leaf, item); btrfs_item_offset(leaf, item); when we could simply use btrfs_item_size_nr(leaf, slot); btrfs_item_offset_nr(leaf, slot); Fix all callers of btrfs_item_size() and btrfs_item_offset() to use the _nr variation of the helpers. Signed-off-by: Josef Bacik --- check/main.c | 8 ++++---- image/main.c | 2 +- kernel-shared/backref.c | 4 +--- kernel-shared/ctree.c | 24 ++++++++++++------------ kernel-shared/dir-item.c | 6 ++---- kernel-shared/inode-item.c | 4 +--- kernel-shared/print-tree.c | 6 +++--- 7 files changed, 24 insertions(+), 30 deletions(-) diff --git a/check/main.c b/check/main.c index e9ac94cc..76eb8d54 100644 --- a/check/main.c +++ b/check/main.c @@ -4222,10 +4222,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path, item2 = btrfs_item_nr(slot + 1); btrfs_item_key_to_cpu(buf, &k1, slot); btrfs_item_key_to_cpu(buf, &k2, slot + 1); - item1_offset = btrfs_item_offset(buf, item1); - item2_offset = btrfs_item_offset(buf, item2); - item1_size = btrfs_item_size(buf, item1); - item2_size = btrfs_item_size(buf, item2); + item1_offset = btrfs_item_offset_nr(buf, slot); + item2_offset = btrfs_item_offset_nr(buf, slot + 1); + item1_size = btrfs_item_size_nr(buf, slot); + item2_size = btrfs_item_size_nr(buf, slot + 1); item1_data = malloc(item1_size); if (!item1_data) diff --git a/image/main.c b/image/main.c index 3125163d..e953d981 100644 --- a/image/main.c +++ b/image/main.c @@ -1239,7 +1239,7 @@ static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size) for (i = slot; i < nritems; i++) { u32 ioff; item = btrfs_item_nr(i); - ioff = btrfs_item_offset(eb, item); + ioff = btrfs_item_offset_nr(eb, i); btrfs_set_item_offset(eb, item, ioff + size_diff); } diff --git a/kernel-shared/backref.c b/kernel-shared/backref.c index f1a638ed..327599b7 100644 --- a/kernel-shared/backref.c +++ b/kernel-shared/backref.c @@ -1417,7 +1417,6 @@ static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root, u64 parent = 0; int found = 0; struct extent_buffer *eb; - struct btrfs_item *item; struct btrfs_inode_ref *iref; struct btrfs_key found_key; @@ -1442,10 +1441,9 @@ static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root, extent_buffer_get(eb); btrfs_release_path(path); - item = btrfs_item_nr(slot); iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref); - for (cur = 0; cur < btrfs_item_size(eb, item); cur += len) { + for (cur = 0; cur < btrfs_item_size_nr(eb, slot); cur += len) { name_len = btrfs_inode_ref_name_len(eb, iref); /* path must be released before calling iterate()! */ pr_debug("following ref at offset %u for inode %llu in " diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c index 10b22b2c..fc661aeb 100644 --- a/kernel-shared/ctree.c +++ b/kernel-shared/ctree.c @@ -2041,7 +2041,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root if (path->slots[0] == i) push_space += data_size + sizeof(*item); - this_item_size = btrfs_item_size(left, item); + this_item_size = btrfs_item_size_nr(left, i); if (this_item_size + sizeof(*item) + push_space > free_space) break; push_items++; @@ -2092,7 +2092,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info); for (i = 0; i < right_nritems; i++) { item = btrfs_item_nr(i); - push_space -= btrfs_item_size(right, item); + push_space -= btrfs_item_size_nr(right, i); btrfs_set_item_offset(right, item, push_space); } @@ -2187,7 +2187,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root if (path->slots[0] == i) push_space += data_size + sizeof(*item); - this_item_size = btrfs_item_size(right, item); + this_item_size = btrfs_item_size_nr(right, i); if (this_item_size + sizeof(*item) + push_space > free_space) break; @@ -2224,7 +2224,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root u32 ioff; item = btrfs_item_nr(i); - ioff = btrfs_item_offset(left, item); + ioff = btrfs_item_offset_nr(left, i); btrfs_set_item_offset(left, item, ioff - (BTRFS_LEAF_DATA_SIZE(root->fs_info) - old_left_item_size)); @@ -2256,7 +2256,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info); for (i = 0; i < right_nritems; i++) { item = btrfs_item_nr(i); - push_space = push_space - btrfs_item_size(right, item); + push_space = push_space - btrfs_item_size_nr(right, i); btrfs_set_item_offset(right, item, push_space); } @@ -2319,7 +2319,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, for (i = 0; i < nritems; i++) { struct btrfs_item *item = btrfs_item_nr(i); - u32 ioff = btrfs_item_offset(right, item); + u32 ioff = btrfs_item_offset_nr(right, i); btrfs_set_item_offset(right, item, ioff + rt_data_off); } @@ -2574,8 +2574,8 @@ int btrfs_split_item(struct btrfs_trans_handle *trans, split: item = btrfs_item_nr(path->slots[0]); - orig_offset = btrfs_item_offset(leaf, item); - item_size = btrfs_item_size(leaf, item); + orig_offset = btrfs_item_offset_nr(leaf, path->slots[0]); + item_size = btrfs_item_size_nr(leaf, path->slots[0]); buf = kmalloc(item_size, GFP_NOFS); @@ -2666,7 +2666,7 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) for (i = slot; i < nritems; i++) { u32 ioff; item = btrfs_item_nr(i); - ioff = btrfs_item_offset(leaf, item); + ioff = btrfs_item_offset_nr(leaf, i); btrfs_set_item_offset(leaf, item, ioff + size_diff); } @@ -2762,7 +2762,7 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path, for (i = slot; i < nritems; i++) { u32 ioff; item = btrfs_item_nr(i); - ioff = btrfs_item_offset(leaf, item); + ioff = btrfs_item_offset_nr(leaf, i); btrfs_set_item_offset(leaf, item, ioff - data_size); } @@ -2854,7 +2854,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, u32 ioff; item = btrfs_item_nr(i); - ioff = btrfs_item_offset(leaf, item); + ioff = btrfs_item_offset_nr(leaf, i); btrfs_set_item_offset(leaf, item, ioff - total_data); } @@ -3029,7 +3029,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, u32 ioff; item = btrfs_item_nr(i); - ioff = btrfs_item_offset(leaf, item); + ioff = btrfs_item_offset_nr(leaf, i); btrfs_set_item_offset(leaf, item, ioff + dsize); } diff --git a/kernel-shared/dir-item.c b/kernel-shared/dir-item.c index 590b79a9..729d4308 100644 --- a/kernel-shared/dir-item.c +++ b/kernel-shared/dir-item.c @@ -32,7 +32,6 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle { int ret; char *ptr; - struct btrfs_item *item; struct extent_buffer *leaf; ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size); @@ -48,10 +47,9 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle return ERR_PTR(ret); WARN_ON(ret > 0); leaf = path->nodes[0]; - item = btrfs_item_nr(path->slots[0]); ptr = btrfs_item_ptr(leaf, path->slots[0], char); - BUG_ON(data_size > btrfs_item_size(leaf, item)); - ptr += btrfs_item_size(leaf, item) - data_size; + BUG_ON(data_size > btrfs_item_size_nr(leaf, path->slots[0])); + ptr += btrfs_item_size_nr(leaf, path->slots[0]) - data_size; return (struct btrfs_dir_item *)ptr; } diff --git a/kernel-shared/inode-item.c b/kernel-shared/inode-item.c index 67173eb1..7ca75f6d 100644 --- a/kernel-shared/inode-item.c +++ b/kernel-shared/inode-item.c @@ -336,7 +336,6 @@ int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans, struct btrfs_path *path; struct btrfs_key key; struct extent_buffer *leaf; - struct btrfs_item *item; key.objectid = inode_objectid; key.type = BTRFS_INODE_EXTREF_KEY; @@ -361,9 +360,8 @@ int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans, goto out; leaf = path->nodes[0]; - item = btrfs_item_nr(path->slots[0]); ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char); - ptr += btrfs_item_size(leaf, item) - ins_len; + ptr += btrfs_item_size_nr(leaf, path->slots[0]) - ins_len; extref = (struct btrfs_inode_extref *)ptr; btrfs_set_inode_extref_name_len(path->nodes[0], extref, name_len); diff --git a/kernel-shared/print-tree.c b/kernel-shared/print-tree.c index 7308599f..6e601779 100644 --- a/kernel-shared/print-tree.c +++ b/kernel-shared/print-tree.c @@ -1320,7 +1320,7 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode) break; } item = btrfs_item_nr(i); - item_size = btrfs_item_size(eb, item); + item_size = btrfs_item_size_nr(eb, i); /* Untyped extraction of slot from btrfs_item_ptr */ ptr = btrfs_item_ptr(eb, i, void*); @@ -1332,8 +1332,8 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode) printf("\titem %u ", i); btrfs_print_key(&disk_key); printf(" itemoff %u itemsize %u\n", - btrfs_item_offset(eb, item), - btrfs_item_size(eb, item)); + btrfs_item_offset_nr(eb, i), + btrfs_item_size_nr(eb, i)); if (type == 0 && objectid == BTRFS_FREE_SPACE_OBJECTID) print_free_space_header(eb, i); From patchwork Tue Feb 22 22:26:17 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756013 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 81AF6C433FE for ; Tue, 22 Feb 2022 22:26:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236051AbiBVW1E (ORCPT ); Tue, 22 Feb 2022 17:27:04 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59392 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235962AbiBVW1D (ORCPT ); Tue, 22 Feb 2022 17:27:03 -0500 Received: from mail-qv1-xf2b.google.com (mail-qv1-xf2b.google.com [IPv6:2607:f8b0:4864:20::f2b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 838DD6D95D for ; Tue, 22 Feb 2022 14:26:35 -0800 (PST) Received: by mail-qv1-xf2b.google.com with SMTP id ba20so3611567qvb.1 for ; Tue, 22 Feb 2022 14:26:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=3w66zh4vJIilxFZzefRnO4t8Hf8wUfSh1IA1bWAEFwk=; b=H18V5jumjIdQK1VozGMFBMec0iG1NmGCm/S35dOjRzkp3oK5H5Jj50xECX0Qa+c6Mb 5oGMag9PxhJuykMSpubk7lTXL1nw4fjoEuJlnfBANsfnc6JA6iJ9cFIa3Gb5Hp2r57/w HcFONqF9kzRMddHIFDWBsmFHn/nOV1KnRKsy2wuqeYZd2RJeb3G/85ghP1WXbK5w8nS7 96CuZuuOYt7WJiutqOduJI7/e0B+Dons8KRqz5RTJJNeUAjS7UnJIpMtQroAxilEcU5W 31T/pPSDIlckgBUxyGwFDb73hhxp5ONp8rYECiV24OXFahF72C/PXejQFPI9RH83bKUQ 49Nw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=3w66zh4vJIilxFZzefRnO4t8Hf8wUfSh1IA1bWAEFwk=; b=BYiIK0UMFUv0jlEf1SDG1bh7q281H6OBv+ABrXBJE/rTfFzQxKTH2idZGMdjuEsq9J lXxLhKFWnUMBxQLWNtCh0NGEswd85SVYkHM4+mqkPpDknW8LkS0wx24UaK7S+SdJb7+u KcFdybgIiaPb4AKeyaUHttIAmvo+i+d+nvLEw2idRbRLJAcuATjSpX2+syGOLOYAYiaA JyabMT5HbRkIwy1jZpsUdw85rJkyDE8l8O91uPVbwYWCCHXqK1EXLjw0ZWb0fuCfMML/ oa+6TjUnoV4F0nAco5HQ9NBP8jWxqPl+3gV8ZbIhjePKllPSsydb6tas7DVBsMiFCh2S VMeQ== X-Gm-Message-State: AOAM533yaFjk18BON+Qmj3mb4I6Vhr5cIK80ST7J/pJ5W6saLfE22Fj3 BmC2NPJ02ZoaP7nhBWD6frgzu0hMBJTNeulT X-Google-Smtp-Source: ABdhPJxOtcrUjc/0FnI/NRlvfF+tIL0iHi4JQxPlgwUdrxoLkn2EuisN57v4jBAGvCwNDC79+xO3fw== X-Received: by 2002:a05:6214:62e:b0:42c:4194:6ab4 with SMTP id a14-20020a056214062e00b0042c41946ab4mr20971617qvx.69.1645568794280; Tue, 22 Feb 2022 14:26:34 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id g11sm754589qtg.49.2022.02.22.14.26.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:33 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 07/13] btrfs-progs: add btrfs_set_item_*_nr() helpers Date: Tue, 22 Feb 2022 17:26:17 -0500 Message-Id: X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org We have a lot of the following patterns item = btrfs_item_nr(nr); btrfs_set_item_*(eb, item, val); btrfs_set_item_*(eb, btrfs_item_nr(nr), val); in a lot of places in our code. Instead add _nr variations of these helpers and convert all of the users to this new helper. Signed-off-by: Josef Bacik --- btrfs-corrupt-block.c | 5 ++- check/main.c | 14 +++------ convert/common.c | 25 ++++++++------- image/main.c | 7 ++--- kernel-shared/ctree.c | 72 ++++++++++++++----------------------------- kernel-shared/ctree.h | 12 ++++++++ mkfs/common.c | 41 +++++++++++------------- 7 files changed, 74 insertions(+), 102 deletions(-) diff --git a/btrfs-corrupt-block.c b/btrfs-corrupt-block.c index 866c863e..57a4e271 100644 --- a/btrfs-corrupt-block.c +++ b/btrfs-corrupt-block.c @@ -838,7 +838,7 @@ static void shift_items(struct btrfs_root *root, struct extent_buffer *eb) for (i = nritems - 1; i >= slot; i--) { u32 offset = btrfs_item_offset_nr(eb, i); offset -= shift_space; - btrfs_set_item_offset(eb, btrfs_item_nr(i), offset); + btrfs_set_item_offset_nr(eb, i, offset); } } @@ -980,8 +980,7 @@ static int corrupt_btrfs_item(struct btrfs_root *root, struct btrfs_key *key, case BTRFS_ITEM_OFFSET: orig = btrfs_item_offset_nr(path->nodes[0], path->slots[0]); bogus = generate_u32(orig); - btrfs_set_item_offset(path->nodes[0], - btrfs_item_nr(path->slots[0]), bogus); + btrfs_set_item_offset_nr(path->nodes[0], path->slots[0], bogus); break; default: ret = -EINVAL; diff --git a/check/main.c b/check/main.c index 76eb8d54..0bc42de7 100644 --- a/check/main.c +++ b/check/main.c @@ -4213,13 +4213,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path, btrfs_fixup_low_keys(path, &key, btrfs_header_level(buf) + 1); } } else { - struct btrfs_item *item1, *item2; struct btrfs_key k1, k2; char *item1_data, *item2_data; u32 item1_offset, item2_offset, item1_size, item2_size; - item1 = btrfs_item_nr(slot); - item2 = btrfs_item_nr(slot + 1); btrfs_item_key_to_cpu(buf, &k1, slot); btrfs_item_key_to_cpu(buf, &k2, slot + 1); item1_offset = btrfs_item_offset_nr(buf, slot); @@ -4244,10 +4241,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path, free(item1_data); free(item2_data); - btrfs_set_item_offset(buf, item1, item2_offset); - btrfs_set_item_offset(buf, item2, item1_offset); - btrfs_set_item_size(buf, item1, item2_size); - btrfs_set_item_size(buf, item2, item1_size); + btrfs_set_item_offset_nr(buf, slot, item2_offset); + btrfs_set_item_offset_nr(buf, slot + 1, item1_offset); + btrfs_set_item_size_nr(buf, slot, item2_size); + btrfs_set_item_size_nr(buf, slot + 1, item1_size); path->slots[0] = slot; btrfs_set_item_key_unsafe(root, path, &k2); @@ -4371,8 +4368,7 @@ again: btrfs_leaf_data(buf) + offset + shift, btrfs_leaf_data(buf) + offset, btrfs_item_size_nr(buf, i)); - btrfs_set_item_offset(buf, btrfs_item_nr(i), - offset + shift); + btrfs_set_item_offset_nr(buf, i, offset + shift); btrfs_mark_buffer_dirty(buf); } diff --git a/convert/common.c b/convert/common.c index 356c2b4c..38112084 100644 --- a/convert/common.c +++ b/convert/common.c @@ -204,8 +204,8 @@ static void insert_temp_root_item(struct extent_buffer *buf, btrfs_set_disk_key_offset(&disk_key, 0); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(root_item)); + btrfs_set_item_offset_nr(buf, *slot, *itemoff); + btrfs_set_item_size_nr(buf, *slot, sizeof(root_item)); write_extent_buffer(buf, &root_item, btrfs_item_ptr_offset(buf, *slot), sizeof(root_item)); @@ -311,8 +311,8 @@ static int insert_temp_dev_item(int fd, struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID); btrfs_set_disk_key_offset(&disk_key, 1); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(*dev_item)); + btrfs_set_item_offset_nr(buf, *slot, *itemoff); + btrfs_set_item_size_nr(buf, *slot, sizeof(*dev_item)); dev_item = btrfs_item_ptr(buf, *slot, struct btrfs_dev_item); /* Generate device uuid */ @@ -369,9 +369,8 @@ static int insert_temp_chunk_item(int fd, struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, BTRFS_FIRST_CHUNK_TREE_OBJECTID); btrfs_set_disk_key_offset(&disk_key, start); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(*slot), - btrfs_chunk_item_size(1)); + btrfs_set_item_offset_nr(buf, *slot, *itemoff); + btrfs_set_item_size_nr(buf, *slot, btrfs_chunk_item_size(1)); chunk = btrfs_item_ptr(buf, *slot, struct btrfs_chunk); btrfs_set_chunk_length(buf, chunk, len); @@ -472,8 +471,8 @@ static void insert_temp_dev_extent(struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, 1); btrfs_set_disk_key_offset(&disk_key, start); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(*dev_extent)); + btrfs_set_item_offset_nr(buf, *slot, *itemoff); + btrfs_set_item_size_nr(buf, *slot, sizeof(*dev_extent)); dev_extent = btrfs_item_ptr(buf, *slot, struct btrfs_dev_extent); btrfs_set_dev_extent_chunk_objectid(buf, dev_extent, @@ -604,8 +603,8 @@ static int insert_temp_extent_item(int fd, struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, bytenr); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(*slot), itemsize); + btrfs_set_item_offset_nr(buf, *slot, *itemoff); + btrfs_set_item_size_nr(buf, *slot, itemsize); ei = btrfs_item_ptr(buf, *slot, struct btrfs_extent_item); btrfs_set_extent_refs(buf, ei, 1); @@ -670,8 +669,8 @@ static void insert_temp_block_group(struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, bytenr); btrfs_set_disk_key_offset(&disk_key, len); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset(buf, btrfs_item_nr(*slot), *itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(*slot), sizeof(bgi)); + btrfs_set_item_offset_nr(buf, *slot, *itemoff); + btrfs_set_item_size_nr(buf, *slot, sizeof(bgi)); btrfs_set_stack_block_group_flags(&bgi, flag); btrfs_set_stack_block_group_used(&bgi, used); diff --git a/image/main.c b/image/main.c index e953d981..09f60e63 100644 --- a/image/main.c +++ b/image/main.c @@ -1218,7 +1218,6 @@ static struct extent_buffer *alloc_dummy_eb(u64 bytenr, u32 size) static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size) { - struct btrfs_item *item; u32 nritems; u32 old_size; u32 old_data_start; @@ -1238,16 +1237,14 @@ static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size) for (i = slot; i < nritems; i++) { u32 ioff; - item = btrfs_item_nr(i); ioff = btrfs_item_offset_nr(eb, i); - btrfs_set_item_offset(eb, item, ioff + size_diff); + btrfs_set_item_offset_nr(eb, i, ioff + size_diff); } memmove_extent_buffer(eb, btrfs_leaf_data(eb) + data_end + size_diff, btrfs_leaf_data(eb) + data_end, old_data_start + new_size - data_end); - item = btrfs_item_nr(slot); - btrfs_set_item_size(eb, item, new_size); + btrfs_set_item_size_nr(eb, slot, new_size); } static int fixup_chunk_tree_block(struct mdrestore_struct *mdres, diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c index fc661aeb..81a438c8 100644 --- a/kernel-shared/ctree.c +++ b/kernel-shared/ctree.c @@ -1982,7 +1982,6 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root int free_space; int push_space = 0; int push_items = 0; - struct btrfs_item *item; u32 left_nritems; u32 nr; u32 right_nritems; @@ -2036,16 +2035,14 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root i = left_nritems - 1; while (i >= nr) { - item = btrfs_item_nr(i); - if (path->slots[0] == i) - push_space += data_size + sizeof(*item); + push_space += data_size + sizeof(struct btrfs_item); this_item_size = btrfs_item_size_nr(left, i); - if (this_item_size + sizeof(*item) + push_space > free_space) + if (this_item_size + sizeof(struct btrfs_item) + push_space > free_space) break; push_items++; - push_space += this_item_size + sizeof(*item); + push_space += this_item_size + sizeof(struct btrfs_item); if (i == 0) break; i--; @@ -2091,9 +2088,8 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_set_header_nritems(right, right_nritems); push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info); for (i = 0; i < right_nritems; i++) { - item = btrfs_item_nr(i); push_space -= btrfs_item_size_nr(right, i); - btrfs_set_item_offset(right, item, push_space); + btrfs_set_item_offset_nr(right, i, push_space); } left_nritems -= push_items; @@ -2135,7 +2131,6 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root int free_space; int push_space = 0; int push_items = 0; - struct btrfs_item *item; u32 old_left_nritems; u32 right_nritems; u32 nr; @@ -2182,17 +2177,15 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root nr = right_nritems - 1; for (i = 0; i < nr; i++) { - item = btrfs_item_nr(i); - if (path->slots[0] == i) - push_space += data_size + sizeof(*item); + push_space += data_size + sizeof(struct btrfs_item); this_item_size = btrfs_item_size_nr(right, i); - if (this_item_size + sizeof(*item) + push_space > free_space) + if (this_item_size + sizeof(struct btrfs_item) + push_space > free_space) break; push_items++; - push_space += this_item_size + sizeof(*item); + push_space += this_item_size + sizeof(struct btrfs_item); } if (push_items == 0) { @@ -2223,9 +2216,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root for (i = old_left_nritems; i < old_left_nritems + push_items; i++) { u32 ioff; - item = btrfs_item_nr(i); ioff = btrfs_item_offset_nr(left, i); - btrfs_set_item_offset(left, item, + btrfs_set_item_offset_nr(left, i, ioff - (BTRFS_LEAF_DATA_SIZE(root->fs_info) - old_left_item_size)); } @@ -2255,9 +2247,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_set_header_nritems(right, right_nritems); push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info); for (i = 0; i < right_nritems; i++) { - item = btrfs_item_nr(i); push_space = push_space - btrfs_item_size_nr(right, i); - btrfs_set_item_offset(right, item, push_space); + btrfs_set_item_offset_nr(right, i, push_space); } btrfs_mark_buffer_dirty(left); @@ -2318,9 +2309,8 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, btrfs_item_end_nr(l, mid); for (i = 0; i < nritems; i++) { - struct btrfs_item *item = btrfs_item_nr(i); u32 ioff = btrfs_item_offset_nr(right, i); - btrfs_set_item_offset(right, item, ioff + rt_data_off); + btrfs_set_item_offset_nr(right, i, ioff + rt_data_off); } btrfs_set_header_nritems(l, mid); @@ -2537,8 +2527,6 @@ int btrfs_split_item(struct btrfs_trans_handle *trans, u32 item_size; struct extent_buffer *leaf; struct btrfs_key orig_key; - struct btrfs_item *item; - struct btrfs_item *new_item; int ret = 0; int slot; u32 nritems; @@ -2573,7 +2561,6 @@ int btrfs_split_item(struct btrfs_trans_handle *trans, leaf = path->nodes[0]; split: - item = btrfs_item_nr(path->slots[0]); orig_offset = btrfs_item_offset_nr(leaf, path->slots[0]); item_size = btrfs_item_size_nr(leaf, path->slots[0]); @@ -2598,14 +2585,12 @@ split: btrfs_cpu_key_to_disk(&disk_key, new_key); btrfs_set_item_key(leaf, &disk_key, slot); - new_item = btrfs_item_nr(slot); - - btrfs_set_item_offset(leaf, new_item, orig_offset); - btrfs_set_item_size(leaf, new_item, item_size - split_offset); + btrfs_set_item_offset_nr(leaf, slot, orig_offset); + btrfs_set_item_size_nr(leaf, slot, item_size - split_offset); - btrfs_set_item_offset(leaf, item, - orig_offset + item_size - split_offset); - btrfs_set_item_size(leaf, item, split_offset); + btrfs_set_item_offset_nr(leaf, path->slots[0], + orig_offset + item_size - split_offset); + btrfs_set_item_size_nr(leaf, path->slots[0], split_offset); btrfs_set_header_nritems(leaf, nritems + 1); @@ -2634,7 +2619,6 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) int ret = 0; int slot; struct extent_buffer *leaf; - struct btrfs_item *item; u32 nritems; unsigned int data_end; unsigned int old_data_start; @@ -2665,9 +2649,8 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) /* first correct the data pointers */ for (i = slot; i < nritems; i++) { u32 ioff; - item = btrfs_item_nr(i); ioff = btrfs_item_offset_nr(leaf, i); - btrfs_set_item_offset(leaf, item, ioff + size_diff); + btrfs_set_item_offset_nr(leaf, i, ioff + size_diff); } /* shift the data */ @@ -2711,8 +2694,7 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) btrfs_fixup_low_keys(path, &disk_key, 1); } - item = btrfs_item_nr(slot); - btrfs_set_item_size(leaf, item, new_size); + btrfs_set_item_size_nr(leaf, slot, new_size); btrfs_mark_buffer_dirty(leaf); ret = 0; @@ -2729,7 +2711,6 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path, int ret = 0; int slot; struct extent_buffer *leaf; - struct btrfs_item *item; u32 nritems; unsigned int data_end; unsigned int old_data; @@ -2761,9 +2742,8 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path, /* first correct the data pointers */ for (i = slot; i < nritems; i++) { u32 ioff; - item = btrfs_item_nr(i); ioff = btrfs_item_offset_nr(leaf, i); - btrfs_set_item_offset(leaf, item, ioff - data_size); + btrfs_set_item_offset_nr(leaf, i, ioff - data_size); } /* shift the data */ @@ -2773,8 +2753,7 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path, data_end = old_data; old_size = btrfs_item_size_nr(leaf, slot); - item = btrfs_item_nr(slot); - btrfs_set_item_size(leaf, item, old_size + data_size); + btrfs_set_item_size_nr(leaf, slot, old_size + data_size); btrfs_mark_buffer_dirty(leaf); ret = 0; @@ -2796,7 +2775,6 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, int nr) { struct extent_buffer *leaf; - struct btrfs_item *item; int ret = 0; int slot; int i; @@ -2853,9 +2831,8 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, for (i = slot; i < nritems; i++) { u32 ioff; - item = btrfs_item_nr(i); ioff = btrfs_item_offset_nr(leaf, i); - btrfs_set_item_offset(leaf, item, ioff - total_data); + btrfs_set_item_offset_nr(leaf, i, ioff - total_data); } /* shift the items */ @@ -2874,10 +2851,9 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, for (i = 0; i < nr; i++) { btrfs_cpu_key_to_disk(&disk_key, cpu_key + i); btrfs_set_item_key(leaf, &disk_key, slot + i); - item = btrfs_item_nr(slot + i); - btrfs_set_item_offset(leaf, item, data_end - data_size[i]); + btrfs_set_item_offset_nr(leaf, slot + i, data_end - data_size[i]); data_end -= data_size[i]; - btrfs_set_item_size(leaf, item, data_size[i]); + btrfs_set_item_size_nr(leaf, slot + i, data_size[i]); } btrfs_set_header_nritems(leaf, nritems + nr); btrfs_mark_buffer_dirty(leaf); @@ -3001,7 +2977,6 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct btrfs_path *path, int slot, int nr) { struct extent_buffer *leaf; - struct btrfs_item *item; int last_off; int dsize = 0; int ret = 0; @@ -3028,9 +3003,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, for (i = slot + nr; i < nritems; i++) { u32 ioff; - item = btrfs_item_nr(i); ioff = btrfs_item_offset_nr(leaf, i); - btrfs_set_item_offset(leaf, item, ioff + dsize); + btrfs_set_item_offset_nr(leaf, i, ioff + dsize); } memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot), diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h index d9677bce..cda05481 100644 --- a/kernel-shared/ctree.h +++ b/kernel-shared/ctree.h @@ -2005,6 +2005,18 @@ static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr) return btrfs_item_end(eb, btrfs_item_nr(nr)); } +static inline void btrfs_set_item_size_nr(struct extent_buffer *eb, int nr, + u32 size) +{ + btrfs_set_item_size(eb, btrfs_item_nr(nr), size); +} + +static inline void btrfs_set_item_offset_nr(struct extent_buffer *eb, int nr, + u32 offset) +{ + btrfs_set_item_offset(eb, btrfs_item_nr(nr), offset); +} + static inline u32 btrfs_item_offset_nr(const struct extent_buffer *eb, int nr) { return btrfs_item_offset(eb, btrfs_item_nr(nr)); diff --git a/mkfs/common.c b/mkfs/common.c index f3e689cb..0ea0d114 100644 --- a/mkfs/common.c +++ b/mkfs/common.c @@ -104,9 +104,8 @@ static int btrfs_create_tree_root(int fd, struct btrfs_mkfs_config *cfg, btrfs_set_disk_key_objectid(&disk_key, reference_root_table[blk]); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(nritems), - sizeof(root_item)); + btrfs_set_item_offset_nr(buf, nritems, itemoff); + btrfs_set_item_size_nr(buf, nritems, sizeof(root_item)); if (blk == MKFS_FS_TREE) { time_t now = time(NULL); @@ -160,8 +159,8 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg, btrfs_set_disk_key_offset(&disk_key, group_size); btrfs_set_disk_key_type(&disk_key, BTRFS_FREE_SPACE_INFO_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(nritems), sizeof(*info)); + btrfs_set_item_offset_nr(buf, nritems, itemoff); + btrfs_set_item_size_nr(buf, nritems, sizeof(*info)); info = btrfs_item_ptr(buf, nritems, struct btrfs_free_space_info); btrfs_set_free_space_extent_count(buf, info, 1); @@ -172,8 +171,8 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg, btrfs_set_disk_key_offset(&disk_key, group_start + group_size - free_start); btrfs_set_disk_key_type(&disk_key, BTRFS_FREE_SPACE_EXTENT_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(nritems), 0); + btrfs_set_item_offset_nr(buf, nritems, itemoff); + btrfs_set_item_size_nr(buf, nritems, 0); nritems++; btrfs_set_header_bytenr(buf, cfg->blocks[MKFS_FREE_SPACE_TREE]); @@ -341,8 +340,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, system_group_size); btrfs_set_disk_key_type(&disk_key, BTRFS_BLOCK_GROUP_ITEM_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(nritems), sizeof(*bg_item)); + btrfs_set_item_offset_nr(buf, nritems, itemoff); + btrfs_set_item_size_nr(buf, nritems, sizeof(*bg_item)); bg_item = btrfs_item_ptr(buf, nritems, struct btrfs_block_group_item); @@ -387,10 +386,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, cfg->nodesize); } btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset(buf, btrfs_item_nr(nritems), - itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(nritems), - item_size); + btrfs_set_item_offset_nr(buf, nritems, itemoff); + btrfs_set_item_size_nr(buf, nritems, item_size); extent_item = btrfs_item_ptr(buf, nritems, struct btrfs_extent_item); btrfs_set_extent_refs(buf, extent_item, 1); @@ -405,9 +402,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, ref_root); btrfs_set_disk_key_type(&disk_key, BTRFS_TREE_BLOCK_REF_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset(buf, btrfs_item_nr(nritems), - itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(nritems), 0); + btrfs_set_item_offset_nr(buf, nritems, itemoff); + btrfs_set_item_size_nr(buf, nritems, 0); nritems++; } btrfs_set_header_bytenr(buf, cfg->blocks[MKFS_EXTENT_TREE]); @@ -434,8 +430,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, 1); btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_ITEM_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(nritems), item_size); + btrfs_set_item_offset_nr(buf, nritems, itemoff); + btrfs_set_item_size_nr(buf, nritems, item_size); dev_item = btrfs_item_ptr(buf, nritems, struct btrfs_dev_item); btrfs_set_device_id(buf, dev_item, 1); @@ -465,8 +461,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, system_group_offset); btrfs_set_disk_key_type(&disk_key, BTRFS_CHUNK_ITEM_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(nritems), item_size); + btrfs_set_item_offset_nr(buf, nritems, itemoff); + btrfs_set_item_size_nr(buf, nritems, item_size); chunk = btrfs_item_ptr(buf, nritems, struct btrfs_chunk); btrfs_set_chunk_length(buf, chunk, system_group_size); @@ -521,9 +517,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, system_group_offset); btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_EXTENT_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); - btrfs_set_item_size(buf, btrfs_item_nr(nritems), - sizeof(struct btrfs_dev_extent)); + btrfs_set_item_offset_nr(buf, nritems, itemoff); + btrfs_set_item_size_nr(buf, nritems, sizeof(struct btrfs_dev_extent)); dev_extent = btrfs_item_ptr(buf, nritems, struct btrfs_dev_extent); btrfs_set_dev_extent_chunk_tree(buf, dev_extent, BTRFS_CHUNK_TREE_OBJECTID); From patchwork Tue Feb 22 22:26:18 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756012 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 60E1BC433EF for ; Tue, 22 Feb 2022 22:26:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236053AbiBVW1E (ORCPT ); Tue, 22 Feb 2022 17:27:04 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59412 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236049AbiBVW1D (ORCPT ); Tue, 22 Feb 2022 17:27:03 -0500 Received: from mail-qk1-x733.google.com (mail-qk1-x733.google.com [IPv6:2607:f8b0:4864:20::733]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D76B99F6F9 for ; Tue, 22 Feb 2022 14:26:36 -0800 (PST) Received: by mail-qk1-x733.google.com with SMTP id g24so1878747qkl.3 for ; Tue, 22 Feb 2022 14:26:36 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=0YKRtHH8N6yEXI9lrqTPwiddnLCX/xQgxf7Mq763d74=; b=BbI8eQo4IqV8iQqF3c/f5F+Seq23+3Os7oGWiNWUUJm6ki3MSY2psUSBLptjTX9yMG 4xM4GrOGtK86O0qEZRDF8i/IgEFX4b80NSSYD/Pm71Zvx/cr30DzuctXTrSaZ8kDX9ap mopI3Bv6KHoTrhOZU9UxkzpLNVVWLpx3dR10iRAAOFSl5Tn030G4SdLuG9BN7fmze+1b Tn1J+YylMeqtynCETvLpnP47Omy1B+y/OL4qpPXEqclTDbXj9C5v9CL6VD2AHOKrR1LU BRJjh5JzQ+ePPalNnKQUM7Ub8E9y7LV/AGTJi1b9HXls3eRzKK8gQ75GHgPW4fwn29qk jE6w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0YKRtHH8N6yEXI9lrqTPwiddnLCX/xQgxf7Mq763d74=; b=X6wb9AKZE2xUU+z1ofLUw6v8/4eqOv53zgvF9bEhSV6ARlNCTCSuMKOJXIzr/T4LEt 4oS5Pdj5iWuW8Ka5gn53JaGxg/CdrgemqX1vwT/zN8kItw9Z3SuBVQNBai7w+QTaP7Sx g8hv/hx8vor48bmc7zOyLDt3xcJIjyIFD5ON78zYlS5seBhLtRjF99sZU+fbqbcal/PN 2NHz0XWyS2sYeTxki5zbPeIe3UB398be/GNbszksnEmx1W9blc0or/+UHP+a1hjdfoKG GZC17PIwf80AMENzm6sgjVx7NSybcaT8Nb6unwXVWdx90bzCVRprB9hv3VPAfWcxIAI1 m7Gg== X-Gm-Message-State: AOAM531B/s7L88tSAdSa8PVg66yDU/Z91UziydIM2hZITKdvAx9MgvjM qpOT4bes4e5OKksOGNOlcW8KjISUcopz0WCw X-Google-Smtp-Source: ABdhPJwUbMoLqyvvOogps81Opm+yLDyQFv60bZUtGnjbw4Vjy9vyE0rrvysEuoqJrX1Y/pIyUBkZdw== X-Received: by 2002:a05:620a:4626:b0:63f:2610:a08e with SMTP id br38-20020a05620a462600b0063f2610a08emr12161189qkb.591.1645568795654; Tue, 22 Feb 2022 14:26:35 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id p16sm744081qtx.55.2022.02.22.14.26.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:35 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 08/13] btrfs-progs: change btrfs_file_extent_inline_item_len to take a slot Date: Tue, 22 Feb 2022 17:26:18 -0500 Message-Id: <7e947492d34fcde5e316e4e03ca39d6d1ea65da1.1645568701.git.josef@toxicpanda.com> X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org This matches how the kernel does it, simply pass in the slot and fix up btrfs_file_extent_inline_item_len to use the btrfs_item_nr() helper and the correct define. Fixup all the callers to use the slot now instead of passing in the btrfs_item. Signed-off-by: Josef Bacik --- check/main.c | 11 ++++------- check/mode-lowmem.c | 7 ++----- cmds/inspect-tree-stats.c | 3 +-- cmds/restore.c | 5 ++--- image/main.c | 4 +--- kernel-shared/ctree.h | 6 ++---- kernel-shared/print-tree.c | 7 ++----- 7 files changed, 14 insertions(+), 29 deletions(-) diff --git a/check/main.c b/check/main.c index 0bc42de7..fb0ef8cb 100644 --- a/check/main.c +++ b/check/main.c @@ -1604,20 +1604,18 @@ static int process_file_extent(struct btrfs_root *root, compression = btrfs_file_extent_compression(eb, fi); if (extent_type == BTRFS_FILE_EXTENT_INLINE) { - struct btrfs_item *item = btrfs_item_nr(slot); - num_bytes = btrfs_file_extent_ram_bytes(eb, fi); if (num_bytes == 0) rec->errors |= I_ERR_BAD_FILE_EXTENT; if (compression) { - if (btrfs_file_extent_inline_item_len(eb, item) > + if (btrfs_file_extent_inline_item_len(eb, slot) > max_inline_size || num_bytes > gfs_info->sectorsize) rec->errors |= I_ERR_FILE_EXTENT_TOO_LARGE; } else { if (num_bytes > max_inline_size) rec->errors |= I_ERR_FILE_EXTENT_TOO_LARGE; - if (btrfs_file_extent_inline_item_len(eb, item) != + if (btrfs_file_extent_inline_item_len(eb, slot) != num_bytes) rec->errors |= I_ERR_INLINE_RAM_BYTES_WRONG; } @@ -2625,7 +2623,6 @@ static int repair_inline_ram_bytes(struct btrfs_trans_handle *trans, { struct btrfs_key key; struct btrfs_file_extent_item *fi; - struct btrfs_item *i; u64 on_disk_item_len; int ret; @@ -2639,8 +2636,8 @@ static int repair_inline_ram_bytes(struct btrfs_trans_handle *trans, if (ret < 0) goto out; - i = btrfs_item_nr(path->slots[0]); - on_disk_item_len = btrfs_file_extent_inline_item_len(path->nodes[0], i); + on_disk_item_len = btrfs_file_extent_inline_item_len(path->nodes[0], + path->slots[0]); fi = btrfs_item_ptr(path->nodes[0], path->slots[0], struct btrfs_file_extent_item); btrfs_set_file_extent_ram_bytes(path->nodes[0], fi, on_disk_item_len); diff --git a/check/mode-lowmem.c b/check/mode-lowmem.c index 0cdf24cd..729c453a 100644 --- a/check/mode-lowmem.c +++ b/check/mode-lowmem.c @@ -1877,7 +1877,6 @@ static int repair_inline_ram_bytes(struct btrfs_root *root, struct btrfs_trans_handle *trans; struct btrfs_key key; struct btrfs_file_extent_item *fi; - struct btrfs_item *item; u32 on_disk_data_len; int ret; int recover_ret; @@ -1899,9 +1898,8 @@ static int repair_inline_ram_bytes(struct btrfs_root *root, if (ret < 0) goto recover; - item = btrfs_item_nr(path->slots[0]); on_disk_data_len = btrfs_file_extent_inline_item_len(path->nodes[0], - item); + path->slots[0]); fi = btrfs_item_ptr(path->nodes[0], path->slots[0], struct btrfs_file_extent_item); @@ -1943,7 +1941,6 @@ static int check_file_extent_inline(struct btrfs_root *root, u32 max_inline_extent_size = min_t(u32, gfs_info->sectorsize - 1, BTRFS_MAX_INLINE_DATA_SIZE(gfs_info)); struct extent_buffer *node = path->nodes[0]; - struct btrfs_item *e = btrfs_item_nr(path->slots[0]); struct btrfs_file_extent_item *fi; struct btrfs_key fkey; u64 extent_num_bytes; @@ -1953,7 +1950,7 @@ static int check_file_extent_inline(struct btrfs_root *root, int err = 0; fi = btrfs_item_ptr(node, path->slots[0], struct btrfs_file_extent_item); - item_inline_len = btrfs_file_extent_inline_item_len(node, e); + item_inline_len = btrfs_file_extent_inline_item_len(node, path->slots[0]); extent_num_bytes = btrfs_file_extent_ram_bytes(node, fi); compressed = btrfs_file_extent_compression(node, fi); btrfs_item_key_to_cpu(node, &fkey, path->slots[0]); diff --git a/cmds/inspect-tree-stats.c b/cmds/inspect-tree-stats.c index eeb57810..0731675c 100644 --- a/cmds/inspect-tree-stats.c +++ b/cmds/inspect-tree-stats.c @@ -121,8 +121,7 @@ static int walk_leaf(struct btrfs_root *root, struct btrfs_path *path, fi = btrfs_item_ptr(b, i, struct btrfs_file_extent_item); if (btrfs_file_extent_type(b, fi) == BTRFS_FILE_EXTENT_INLINE) stat->total_inline += - btrfs_file_extent_inline_item_len(b, - btrfs_item_nr(i)); + btrfs_file_extent_inline_item_len(b, i); } return 0; diff --git a/cmds/restore.c b/cmds/restore.c index 48300ae5..bc88af70 100644 --- a/cmds/restore.c +++ b/cmds/restore.c @@ -302,7 +302,7 @@ static int copy_one_inline(struct btrfs_root *root, int fd, struct btrfs_file_extent_item); ptr = btrfs_file_extent_inline_start(fi); len = btrfs_file_extent_ram_bytes(leaf, fi); - inline_item_len = btrfs_file_extent_inline_item_len(leaf, btrfs_item_nr(path->slots[0])); + inline_item_len = btrfs_file_extent_inline_item_len(leaf, path->slots[0]); read_extent_buffer(leaf, buf, ptr, inline_item_len); compress = btrfs_file_extent_compression(leaf, fi); @@ -834,8 +834,7 @@ static int copy_symlink(struct btrfs_root *root, struct btrfs_key *key, extent_item = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_file_extent_item); - len = btrfs_file_extent_inline_item_len(leaf, - btrfs_item_nr(path.slots[0])); + len = btrfs_file_extent_inline_item_len(leaf, path.slots[0]); if (len >= PATH_MAX) { error("symlink '%s' target length %d is longer than PATH_MAX", fs_name, len); diff --git a/image/main.c b/image/main.c index 09f60e63..5d67d282 100644 --- a/image/main.c +++ b/image/main.c @@ -302,7 +302,6 @@ static void zero_items(struct metadump_struct *md, u8 *dst, struct extent_buffer *src) { struct btrfs_file_extent_item *fi; - struct btrfs_item *item; struct btrfs_key key; u32 nritems = btrfs_header_nritems(src); size_t size; @@ -310,7 +309,6 @@ static void zero_items(struct metadump_struct *md, u8 *dst, int i, extent_type; for (i = 0; i < nritems; i++) { - item = btrfs_item_nr(i); btrfs_item_key_to_cpu(src, &key, i); if (key.type == BTRFS_CSUM_ITEM_KEY) { size = btrfs_item_size_nr(src, i); @@ -334,7 +332,7 @@ static void zero_items(struct metadump_struct *md, u8 *dst, continue; ptr = btrfs_file_extent_inline_start(fi); - size = btrfs_file_extent_inline_item_len(src, item); + size = btrfs_file_extent_inline_item_len(src, i); memset(dst + ptr, 0, size); } } diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h index cda05481..7fb66049 100644 --- a/kernel-shared/ctree.h +++ b/kernel-shared/ctree.h @@ -2564,11 +2564,9 @@ static inline u64 btrfs_dev_stats_value(const struct extent_buffer *eb, * the compressed size */ static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb, - struct btrfs_item *e) + int nr) { - unsigned long offset; - offset = offsetof(struct btrfs_file_extent_item, disk_bytenr); - return btrfs_item_size(eb, e) - offset; + return btrfs_item_size_nr(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START; } /* struct btrfs_ioctl_search_header */ diff --git a/kernel-shared/print-tree.c b/kernel-shared/print-tree.c index 6e601779..aff2ebc4 100644 --- a/kernel-shared/print-tree.c +++ b/kernel-shared/print-tree.c @@ -365,7 +365,6 @@ static const char* file_extent_type_to_str(u8 type) } static void print_file_extent_item(struct extent_buffer *eb, - struct btrfs_item *item, int slot, struct btrfs_file_extent_item *fi) { @@ -381,7 +380,7 @@ static void print_file_extent_item(struct extent_buffer *eb, if (extent_type == BTRFS_FILE_EXTENT_INLINE) { printf("\t\tinline extent data size %u ram_bytes %llu compression %hhu (%s)\n", - btrfs_file_extent_inline_item_len(eb, item), + btrfs_file_extent_inline_item_len(eb, slot), btrfs_file_extent_ram_bytes(eb, fi), btrfs_file_extent_compression(eb, fi), compress_str); @@ -1286,7 +1285,6 @@ static void print_header_info(struct extent_buffer *eb, unsigned int mode) void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode) { - struct btrfs_item *item; struct btrfs_disk_key disk_key; u32 leaf_data_size = BTRFS_LEAF_DATA_SIZE(eb->fs_info); u32 i; @@ -1319,7 +1317,6 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode) error("skip remaining slots"); break; } - item = btrfs_item_nr(i); item_size = btrfs_item_size_nr(eb, i); /* Untyped extraction of slot from btrfs_item_ptr */ ptr = btrfs_item_ptr(eb, i, void*); @@ -1402,7 +1399,7 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode) print_extent_csum(eb, item_size, offset, ptr, print_csum_items); break; case BTRFS_EXTENT_DATA_KEY: - print_file_extent_item(eb, item, i, ptr); + print_file_extent_item(eb, i, ptr); break; case BTRFS_BLOCK_GROUP_ITEM_KEY: print_block_group_item(eb, ptr); From patchwork Tue Feb 22 22:26:19 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756014 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1D5AAC4332F for ; Tue, 22 Feb 2022 22:26:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236054AbiBVW1F (ORCPT ); Tue, 22 Feb 2022 17:27:05 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59500 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236052AbiBVW1E (ORCPT ); Tue, 22 Feb 2022 17:27:04 -0500 Received: from mail-qk1-x729.google.com (mail-qk1-x729.google.com [IPv6:2607:f8b0:4864:20::729]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0C2B7B12C4 for ; Tue, 22 Feb 2022 14:26:38 -0800 (PST) Received: by mail-qk1-x729.google.com with SMTP id f21so1811211qke.13 for ; Tue, 22 Feb 2022 14:26:38 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=kZbMxv4vgwHhp3peCvKIqfSOQ0hBL08KPgI29O/3s/o=; b=303ihiWIpDhP69p4yyVVEQiQ4O4C7cmZ5d48mvuiviLX9DBO1N+rKdcooI8qBca1n0 Ee9LNjDgaf0upgdyx1fGBEWfaF5Bm/kkbPuHuDOPlJ50B+nxNCgK6v8/J/NQ+10x04vI bUSNeV6Pp/7FuJ51i350KA5MF6qFIZfrpM0nB6cyhM09/lxTfExCZio2zjxZjE2hUrof Giv+sRWRgnBmtGx0WPtXdVUu8PvaAunXLWLjcICgpdLCmwPCeO4bIzv/zOGIk+civVLM dan68LlYw6jd98IAQBrgLNoEmo6iYa9uq6jwbLVX/7cr8xa2u9CqQ8FFWCbAX7HLd5dc OEHA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=kZbMxv4vgwHhp3peCvKIqfSOQ0hBL08KPgI29O/3s/o=; b=bnVhG3K5rMMrUQJaleY5DJl8sraf+pwKvOYihasEp42fjKd61vEOYylfMKwV5YzB+u GOu9e7UhyEQ4zA+Nve2hxv/n+j4AAIlEyVDZlEi5sQbN+k8YVYvWaUMT6FitwbfHRI4q gKWLBYZcHvaGs5hGAE20aKzQTuA3f5fJR/w22zsQpXg9dR30z588MTAKhbmuGBzotmLF LHPOZgRQzHckouF20iTDinVH0yovtoWS9HErKNZMDDzhpXfWtNrpCENCUPnD4qa2gJxz b2ll3Ry7GD6Qz0MyjNji08IMxeyeDU/edN7IwnVD+DuXSmrkrl6FVMHFicPy3mvuMFbj A35w== X-Gm-Message-State: AOAM530W7POLt2zZh0/aXcRP5NiFvm8tL0sfQ3gxYz3mMAsDDnUVtSox ylTbXa77vSnE13BVRSfduKFZ/NkMbjB3Vxxe X-Google-Smtp-Source: ABdhPJz5vHwqV58aOmcq1mmjfhNM4uKlU5ijorlkmoHf52BtEug9dQN5VF5VwdWgW4Vc0OTv+38evg== X-Received: by 2002:a37:2f43:0:b0:648:acc2:d109 with SMTP id v64-20020a372f43000000b00648acc2d109mr10819588qkh.526.1645568796876; Tue, 22 Feb 2022 14:26:36 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id k205sm651623qke.31.2022.02.22.14.26.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:36 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 09/13] btrfs-progs: rename btrfs_item_end_nr to btrfs_item_end Date: Tue, 22 Feb 2022 17:26:19 -0500 Message-Id: X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org All callers use the btrfs_item_end_nr() variation, simply drop btrfs_item_end() and make btrfs_item_end_nr() use the _nr() variations of the item get helpers. Signed-off-by: Josef Bacik --- check/main.c | 12 ++++++------ kernel-shared/ctree.c | 20 ++++++++++---------- kernel-shared/ctree.h | 16 +++++----------- 3 files changed, 21 insertions(+), 27 deletions(-) diff --git a/check/main.c b/check/main.c index fb0ef8cb..92e1399f 100644 --- a/check/main.c +++ b/check/main.c @@ -4327,9 +4327,9 @@ again: for (i = 0; i < btrfs_header_nritems(buf); i++) { unsigned int shift = 0, offset; - if (i == 0 && btrfs_item_end_nr(buf, i) != + if (i == 0 && btrfs_item_end(buf, i) != BTRFS_LEAF_DATA_SIZE(gfs_info)) { - if (btrfs_item_end_nr(buf, i) > + if (btrfs_item_end(buf, i) > BTRFS_LEAF_DATA_SIZE(gfs_info)) { ret = delete_bogus_item(root, path, buf, i); if (!ret) @@ -4340,10 +4340,10 @@ again: break; } shift = BTRFS_LEAF_DATA_SIZE(gfs_info) - - btrfs_item_end_nr(buf, i); - } else if (i > 0 && btrfs_item_end_nr(buf, i) != + btrfs_item_end(buf, i); + } else if (i > 0 && btrfs_item_end(buf, i) != btrfs_item_offset_nr(buf, i - 1)) { - if (btrfs_item_end_nr(buf, i) > + if (btrfs_item_end(buf, i) > btrfs_item_offset_nr(buf, i - 1)) { ret = delete_bogus_item(root, path, buf, i); if (!ret) @@ -4353,7 +4353,7 @@ again: break; } shift = btrfs_item_offset_nr(buf, i - 1) - - btrfs_item_end_nr(buf, i); + btrfs_item_end(buf, i); } if (!shift) continue; diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c index 81a438c8..d18c91d1 100644 --- a/kernel-shared/ctree.c +++ b/kernel-shared/ctree.c @@ -730,10 +730,10 @@ btrfs_check_leaf(struct btrfs_fs_info *fs_info, else item_end_expected = btrfs_item_offset_nr(leaf, slot - 1); - if (btrfs_item_end_nr(leaf, slot) != item_end_expected) { + if (btrfs_item_end(leaf, slot) != item_end_expected) { generic_err(leaf, slot, "unexpected item end, have %u expect %u", - btrfs_item_end_nr(leaf, slot), + btrfs_item_end(leaf, slot), item_end_expected); ret = BTRFS_TREE_BLOCK_INVALID_OFFSETS; goto fail; @@ -744,11 +744,11 @@ btrfs_check_leaf(struct btrfs_fs_info *fs_info, * just in case all the items are consistent to each other, but * all point outside of the leaf. */ - if (btrfs_item_end_nr(leaf, slot) > + if (btrfs_item_end(leaf, slot) > BTRFS_LEAF_DATA_SIZE(fs_info)) { generic_err(leaf, slot, "slot end outside of leaf, have %u expect range [0, %u]", - btrfs_item_end_nr(leaf, slot), + btrfs_item_end(leaf, slot), BTRFS_LEAF_DATA_SIZE(fs_info)); ret = BTRFS_TREE_BLOCK_INVALID_OFFSETS; goto fail; @@ -1931,7 +1931,7 @@ static int leaf_space_used(struct extent_buffer *l, int start, int nr) if (!nr) return 0; - data_len = btrfs_item_end_nr(l, start); + data_len = btrfs_item_end(l, start); data_len = data_len - btrfs_item_offset_nr(l, end); data_len += sizeof(struct btrfs_item) * nr; WARN_ON(data_len < 0); @@ -2059,7 +2059,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root /* push left to right */ right_nritems = btrfs_header_nritems(right); - push_space = btrfs_item_end_nr(left, left_nritems - push_items); + push_space = btrfs_item_end(left, left_nritems - push_items); push_space -= leaf_data_end(left); /* make room in the right data area */ @@ -2294,7 +2294,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, nritems = nritems - mid; btrfs_set_header_nritems(right, nritems); - data_copy_size = btrfs_item_end_nr(l, mid) - leaf_data_end(l); + data_copy_size = btrfs_item_end(l, mid) - leaf_data_end(l); copy_extent_buffer(right, l, btrfs_item_nr_offset(0), btrfs_item_nr_offset(mid), @@ -2306,7 +2306,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, btrfs_leaf_data(l) + leaf_data_end(l), data_copy_size); rt_data_off = BTRFS_LEAF_DATA_SIZE(root->fs_info) - - btrfs_item_end_nr(l, mid); + btrfs_item_end(l, mid); for (i = 0; i < nritems; i++) { u32 ioff = btrfs_item_offset_nr(right, i); @@ -2727,7 +2727,7 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path, BUG(); } slot = path->slots[0]; - old_data = btrfs_item_end_nr(leaf, slot); + old_data = btrfs_item_end(leaf, slot); BUG_ON(slot < 0); if (slot >= nritems) { @@ -2816,7 +2816,7 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, BUG_ON(slot < 0); if (slot < nritems) { - unsigned int old_data = btrfs_item_end_nr(leaf, slot); + unsigned int old_data = btrfs_item_end(leaf, slot); if (old_data < data_end) { btrfs_print_leaf(leaf, BTRFS_PRINT_TREE_DEFAULT); diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h index 7fb66049..befa244f 100644 --- a/kernel-shared/ctree.h +++ b/kernel-shared/ctree.h @@ -1994,17 +1994,6 @@ static inline struct btrfs_item *btrfs_item_nr(int nr) return (struct btrfs_item *)btrfs_item_nr_offset(nr); } -static inline u32 btrfs_item_end(struct extent_buffer *eb, - struct btrfs_item *item) -{ - return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item); -} - -static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr) -{ - return btrfs_item_end(eb, btrfs_item_nr(nr)); -} - static inline void btrfs_set_item_size_nr(struct extent_buffer *eb, int nr, u32 size) { @@ -2027,6 +2016,11 @@ static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr) return btrfs_item_size(eb, btrfs_item_nr(nr)); } +static inline u32 btrfs_item_end(struct extent_buffer *eb, int nr) +{ + return btrfs_item_offset_nr(eb, nr) + btrfs_item_size_nr(eb, nr); +} + static inline void btrfs_item_key(struct extent_buffer *eb, struct btrfs_disk_key *disk_key, int nr) { From patchwork Tue Feb 22 22:26:20 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756018 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2AA72C433FE for ; Tue, 22 Feb 2022 22:26:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236059AbiBVW1L (ORCPT ); Tue, 22 Feb 2022 17:27:11 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59896 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236057AbiBVW1J (ORCPT ); Tue, 22 Feb 2022 17:27:09 -0500 Received: from mail-qv1-xf34.google.com (mail-qv1-xf34.google.com [IPv6:2607:f8b0:4864:20::f34]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4610CB12C4 for ; Tue, 22 Feb 2022 14:26:40 -0800 (PST) Received: by mail-qv1-xf34.google.com with SMTP id j5so3431997qvs.13 for ; Tue, 22 Feb 2022 14:26:40 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=SwOntcvzjumnY+pRayiV7cp4dQZJQxVSCCKQlTk6wl8=; b=G9TkuFZSlnItoMa2aCxP7MbFkvN2uhbBlbVomx5AoHvHhswqgFM03oVVFZrchjCiRK XnYIIlXqwCloU1nXoSwKJqL9tG4cTc7TvST/tobnL67vBc7QM3/6neBgK3ACgoCWR8RQ FzC4pvCfMuDQZpBPplSkNMQSOn1eIlVbZQ3em8Lk8/NTIXSjXx9xb9eM5pnbE1OLM8Z3 MWyq3UmdQttn2h0qqyNNyo5579Iyb8rs5jEY1UPsmuEb4+NTZD5Q7ojlFFIShwjO9sJ7 TvITY0XlXrRRNqkSBoi6vvsbZrFFYZgwONl8iBAZWgLQIdr7+8kJ0mfY6cJ+nsILrTdt 6SfQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=SwOntcvzjumnY+pRayiV7cp4dQZJQxVSCCKQlTk6wl8=; b=v8/sWcWiIFISCIN21kF67ZnA/syVbN651kJX03kHp4TH7nLLm0hGwsLSmtyBzH4Rbp YocVg2EpmE4QqHBsbqTbcY5S4jxH4TcqzE89t3AtaSm5n2QwYBPh/+eUlruuBZ65EX1z HQhFLkXp+ykB6clz/1Hwy6wIBvpL4YGXNY4nYnBlf1XM0p5MOka0BsVO0UOtv3QZ3WhB knjpZR8NDe2DeKioekddz7YTQ0dE+rGR1bRyWOn0Hr9WOogIpy8O38HvJcXyQ5/xisdk hZaPb/dvwgN2VW0fQqNY3sr8mU5UDRMxaIdrHD1hjVj8qKduNxzA+61rD8zJnbOvuKQm 0mmg== X-Gm-Message-State: AOAM532upk4Wm3NyFqiBozR14nJcEBfhEX7JBiMKnGC5PvwA3BNaiBi4 vWDqu/mM4YSB2YPex+XZkQ0JUBWM4l5Z713c X-Google-Smtp-Source: ABdhPJy3bNA8/VZPspiW8ZJ4wWcyJl55WTpiwEJ/de+iVttOK6naJZpWdcpY0HeJ1phQgeQEfmXrcg== X-Received: by 2002:a05:622a:40e:b0:2dc:eb59:4855 with SMTP id n14-20020a05622a040e00b002dceb594855mr24951396qtx.526.1645568798255; Tue, 22 Feb 2022 14:26:38 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id h19sm839194qtx.12.2022.02.22.14.26.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:37 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 10/13] btrfs-progs: remove the _nr from the item helpers Date: Tue, 22 Feb 2022 17:26:20 -0500 Message-Id: X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org Now that all callers are using the _nr variations we can simply rename these helpers to btrfs_item_##member/btrfs_set_item_##member and change the actual item SETGET funcs to raw_item_##member/set_raw_item_##member and then change all callers to drop the _nr part. Signed-off-by: Josef Bacik --- btrfs-corrupt-block.c | 16 +++---- check/main.c | 50 ++++++++++----------- check/mode-common.c | 12 ++--- check/mode-lowmem.c | 30 ++++++------- check/qgroup-verify.c | 2 +- cmds/rescue-chunk-recover.c | 4 +- cmds/restore.c | 2 +- convert/common.c | 24 +++++----- image/main.c | 20 ++++----- image/sanitize.c | 4 +- kernel-shared/backref.c | 8 ++-- kernel-shared/ctree.c | 90 ++++++++++++++++++------------------- kernel-shared/ctree.h | 42 +++++++---------- kernel-shared/dir-item.c | 8 ++-- kernel-shared/extent-tree.c | 12 ++--- kernel-shared/file-item.c | 12 ++--- kernel-shared/inode-item.c | 12 ++--- kernel-shared/print-tree.c | 20 ++++----- kernel-shared/root-tree.c | 2 +- kernel-shared/uuid-tree.c | 4 +- kernel-shared/volumes.c | 10 ++--- mkfs/common.c | 36 +++++++-------- 22 files changed, 206 insertions(+), 214 deletions(-) diff --git a/btrfs-corrupt-block.c b/btrfs-corrupt-block.c index 57a4e271..fb1f15f0 100644 --- a/btrfs-corrupt-block.c +++ b/btrfs-corrupt-block.c @@ -246,7 +246,7 @@ static int corrupt_extent(struct btrfs_trans_handle *trans, "corrupting extent record: key %llu %u %llu\n", key.objectid, key.type, key.offset); ptr = btrfs_item_ptr_offset(leaf, slot); - item_size = btrfs_item_size_nr(leaf, slot); + item_size = btrfs_item_size(leaf, slot); memset_extent_buffer(leaf, 0, ptr, item_size); btrfs_mark_buffer_dirty(leaf); } @@ -827,18 +827,18 @@ static void shift_items(struct btrfs_root *root, struct extent_buffer *eb) int shift_space = btrfs_leaf_free_space(eb) / 2; int slot = nritems / 2; int i = 0; - unsigned int data_end = btrfs_item_offset_nr(eb, nritems - 1); + unsigned int data_end = btrfs_item_offset(eb, nritems - 1); /* Shift the item data up to and including slot back by shift space */ memmove_extent_buffer(eb, btrfs_leaf_data(eb) + data_end - shift_space, btrfs_leaf_data(eb) + data_end, - btrfs_item_offset_nr(eb, slot - 1) - data_end); + btrfs_item_offset(eb, slot - 1) - data_end); /* Now update the item pointers. */ for (i = nritems - 1; i >= slot; i--) { - u32 offset = btrfs_item_offset_nr(eb, i); + u32 offset = btrfs_item_offset(eb, i); offset -= shift_space; - btrfs_set_item_offset_nr(eb, i, offset); + btrfs_set_item_offset(eb, i, offset); } } @@ -978,9 +978,9 @@ static int corrupt_btrfs_item(struct btrfs_root *root, struct btrfs_key *key, ret = 0; switch (corrupt_field) { case BTRFS_ITEM_OFFSET: - orig = btrfs_item_offset_nr(path->nodes[0], path->slots[0]); + orig = btrfs_item_offset(path->nodes[0], path->slots[0]); bogus = generate_u32(orig); - btrfs_set_item_offset_nr(path->nodes[0], path->slots[0], bogus); + btrfs_set_item_offset(path->nodes[0], path->slots[0], bogus); break; default: ret = -EINVAL; @@ -1082,7 +1082,7 @@ static int corrupt_item_nocow(struct btrfs_trans_handle *trans, fprintf(stdout, "Corrupting key and data [%llu, %u, %llu].\n", key.objectid, key.type, key.offset); ptr = btrfs_item_ptr_offset(leaf, slot); - item_size = btrfs_item_size_nr(leaf, slot); + item_size = btrfs_item_size(leaf, slot); memset_extent_buffer(leaf, 0, ptr, item_size); btrfs_mark_buffer_dirty(leaf); } diff --git a/check/main.c b/check/main.c index 92e1399f..ed3fde60 100644 --- a/check/main.c +++ b/check/main.c @@ -1408,7 +1408,7 @@ static int process_dir_item(struct extent_buffer *eb, return 0; di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item); - total = btrfs_item_size_nr(eb, slot); + total = btrfs_item_size(eb, slot); while (cur < total) { int ret; @@ -1490,7 +1490,7 @@ static int process_inode_ref(struct extent_buffer *eb, inode_cache = &active_node->inode_cache; ref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref); - total = btrfs_item_size_nr(eb, slot); + total = btrfs_item_size(eb, slot); while (cur < total) { name_len = btrfs_inode_ref_name_len(eb, ref); index = btrfs_inode_ref_index(eb, ref); @@ -1539,7 +1539,7 @@ static int process_inode_extref(struct extent_buffer *eb, inode_cache = &active_node->inode_cache; extref = btrfs_item_ptr(eb, slot, struct btrfs_inode_extref); - total = btrfs_item_size_nr(eb, slot); + total = btrfs_item_size(eb, slot); while (cur < total) { name_len = btrfs_inode_extref_name_len(eb, extref); index = btrfs_inode_extref_index(eb, extref); @@ -4216,10 +4216,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path, btrfs_item_key_to_cpu(buf, &k1, slot); btrfs_item_key_to_cpu(buf, &k2, slot + 1); - item1_offset = btrfs_item_offset_nr(buf, slot); - item2_offset = btrfs_item_offset_nr(buf, slot + 1); - item1_size = btrfs_item_size_nr(buf, slot); - item2_size = btrfs_item_size_nr(buf, slot + 1); + item1_offset = btrfs_item_offset(buf, slot); + item2_offset = btrfs_item_offset(buf, slot + 1); + item1_size = btrfs_item_size(buf, slot); + item2_size = btrfs_item_size(buf, slot + 1); item1_data = malloc(item1_size); if (!item1_data) @@ -4238,10 +4238,10 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path, free(item1_data); free(item2_data); - btrfs_set_item_offset_nr(buf, slot, item2_offset); - btrfs_set_item_offset_nr(buf, slot + 1, item1_offset); - btrfs_set_item_size_nr(buf, slot, item2_size); - btrfs_set_item_size_nr(buf, slot + 1, item1_size); + btrfs_set_item_offset(buf, slot, item2_offset); + btrfs_set_item_offset(buf, slot + 1, item1_offset); + btrfs_set_item_size(buf, slot, item2_size); + btrfs_set_item_size(buf, slot + 1, item1_size); path->slots[0] = slot; btrfs_set_item_key_unsafe(root, path, &k2); @@ -4342,9 +4342,9 @@ again: shift = BTRFS_LEAF_DATA_SIZE(gfs_info) - btrfs_item_end(buf, i); } else if (i > 0 && btrfs_item_end(buf, i) != - btrfs_item_offset_nr(buf, i - 1)) { + btrfs_item_offset(buf, i - 1)) { if (btrfs_item_end(buf, i) > - btrfs_item_offset_nr(buf, i - 1)) { + btrfs_item_offset(buf, i - 1)) { ret = delete_bogus_item(root, path, buf, i); if (!ret) goto again; @@ -4352,7 +4352,7 @@ again: ret = -EIO; break; } - shift = btrfs_item_offset_nr(buf, i - 1) - + shift = btrfs_item_offset(buf, i - 1) - btrfs_item_end(buf, i); } if (!shift) @@ -4360,12 +4360,12 @@ again: printf("Shifting item nr %d by %u bytes in block %llu\n", i, shift, (unsigned long long)buf->start); - offset = btrfs_item_offset_nr(buf, i); + offset = btrfs_item_offset(buf, i); memmove_extent_buffer(buf, btrfs_leaf_data(buf) + offset + shift, btrfs_leaf_data(buf) + offset, - btrfs_item_size_nr(buf, i)); - btrfs_set_item_offset_nr(buf, i, offset + shift); + btrfs_item_size(buf, i)); + btrfs_set_item_offset(buf, i, offset + shift); btrfs_mark_buffer_dirty(buf); } @@ -5403,7 +5403,7 @@ static int process_extent_item(struct btrfs_root *root, unsigned long ptr; int ret; int type; - u32 item_size = btrfs_item_size_nr(eb, slot); + u32 item_size = btrfs_item_size(eb, slot); u64 refs = 0; u64 offset; u64 num_bytes; @@ -6077,7 +6077,7 @@ static int check_csum_root(struct btrfs_root *root) path.slots[0]); errors++; } - num_entries = btrfs_item_size_nr(leaf, path.slots[0]) / csum_size; + num_entries = btrfs_item_size(leaf, path.slots[0]) / csum_size; data_len = num_entries * gfs_info->sectorsize; if (num_entries > max_entries) { @@ -6459,7 +6459,7 @@ static int run_next_block(struct btrfs_root *root, } if (key.type == BTRFS_EXTENT_CSUM_KEY) { total_csum_bytes += - btrfs_item_size_nr(buf, i); + btrfs_item_size(buf, i); continue; } if (key.type == BTRFS_CHUNK_ITEM_KEY) { @@ -6552,11 +6552,11 @@ static int run_next_block(struct btrfs_root *root, if (key.type != BTRFS_EXTENT_DATA_KEY) continue; /* Check itemsize before we continue */ - if (btrfs_item_size_nr(buf, i) < inline_offset) { + if (btrfs_item_size(buf, i) < inline_offset) { ret = -EUCLEAN; error( "invalid file extent item size, have %u expect (%lu, %u]", - btrfs_item_size_nr(buf, i), + btrfs_item_size(buf, i), inline_offset, BTRFS_LEAF_DATA_SIZE(gfs_info)); continue; @@ -6568,12 +6568,12 @@ static int run_next_block(struct btrfs_root *root, continue; /* Prealloc/regular extent must have fixed item size */ - if (btrfs_item_size_nr(buf, i) != + if (btrfs_item_size(buf, i) != sizeof(struct btrfs_file_extent_item)) { ret = -EUCLEAN; error( "invalid file extent item size, have %u expect %zu", - btrfs_item_size_nr(buf, i), + btrfs_item_size(buf, i), sizeof(struct btrfs_file_extent_item)); continue; } @@ -9661,7 +9661,7 @@ static int build_roots_info_cache(void) ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item); flags = btrfs_extent_flags(leaf, ei); - item_end = (unsigned long)ei + btrfs_item_size_nr(leaf, slot); + item_end = (unsigned long)ei + btrfs_item_size(leaf, slot); if (found_key.type == BTRFS_EXTENT_ITEM_KEY && !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)) diff --git a/check/mode-common.c b/check/mode-common.c index c3d8bb45..f05960ac 100644 --- a/check/mode-common.c +++ b/check/mode-common.c @@ -205,7 +205,7 @@ int check_prealloc_extent_written(u64 disk_bytenr, u64 num_bytes) /* First check all inline refs. */ ei = btrfs_item_ptr(path.nodes[0], path.slots[0], struct btrfs_extent_item); - item_size = btrfs_item_size_nr(path.nodes[0], path.slots[0]); + item_size = btrfs_item_size(path.nodes[0], path.slots[0]); ptr = (unsigned long)(ei + 1); end = (unsigned long)ei + item_size; while (ptr < end) { @@ -340,7 +340,7 @@ int count_csum_range(u64 start, u64 len, u64 *found) if (key.offset > start) start = key.offset; - size = btrfs_item_size_nr(leaf, path.slots[0]); + size = btrfs_item_size(leaf, path.slots[0]); csum_end = key.offset + (size / csum_size) * gfs_info->sectorsize; if (csum_end > start) { @@ -758,7 +758,7 @@ static int find_file_type_dir_index(struct btrfs_root *root, u64 ino, u64 dirid, if (filetype >= BTRFS_FT_MAX || filetype == BTRFS_FT_UNKNOWN) goto out; len = min_t(u32, BTRFS_NAME_LEN, - btrfs_item_size_nr(path.nodes[0], path.slots[0]) - sizeof(*di)); + btrfs_item_size(path.nodes[0], path.slots[0]) - sizeof(*di)); len = min_t(u32, len, btrfs_dir_name_len(path.nodes[0], di)); read_extent_buffer(path.nodes[0], namebuf, (unsigned long)(di + 1), len); if (name_len != len || memcmp(namebuf, name, len)) @@ -802,7 +802,7 @@ static int find_file_type_dir_item(struct btrfs_root *root, u64 ino, u64 dirid, goto out; cur = btrfs_item_ptr_offset(path.nodes[0], path.slots[0]); - end = cur + btrfs_item_size_nr(path.nodes[0], path.slots[0]); + end = cur + btrfs_item_size(path.nodes[0], path.slots[0]); while (cur < end) { di = (struct btrfs_dir_item *)cur; cur += btrfs_dir_name_len(path.nodes[0], di) + sizeof(*di); @@ -817,7 +817,7 @@ static int find_file_type_dir_item(struct btrfs_root *root, u64 ino, u64 dirid, if (filetype >= BTRFS_FT_MAX || filetype == BTRFS_FT_UNKNOWN) continue; len = min_t(u32, BTRFS_NAME_LEN, - btrfs_item_size_nr(path.nodes[0], path.slots[0]) - + btrfs_item_size(path.nodes[0], path.slots[0]) - sizeof(*di)); len = min_t(u32, len, btrfs_dir_name_len(path.nodes[0], di)); read_extent_buffer(path.nodes[0], namebuf, @@ -903,7 +903,7 @@ int detect_imode(struct btrfs_root *root, struct btrfs_path *path, case BTRFS_INODE_REF_KEY: /* The most accurate way to determine filetype */ cur = btrfs_item_ptr_offset(leaf, slot); - end = cur + btrfs_item_size_nr(leaf, slot); + end = cur + btrfs_item_size(leaf, slot); while (cur < end) { iref = (struct btrfs_inode_ref *)cur; namelen = min_t(u32, end - cur - sizeof(&iref), diff --git a/check/mode-lowmem.c b/check/mode-lowmem.c index 729c453a..99d04945 100644 --- a/check/mode-lowmem.c +++ b/check/mode-lowmem.c @@ -98,7 +98,7 @@ static int calc_extent_flag(struct btrfs_root *root, struct extent_buffer *eb, goto full_backref; ptr = (unsigned long)(ei + 1); - end = (unsigned long)ei + btrfs_item_size_nr(eb, slot); + end = (unsigned long)ei + btrfs_item_size(eb, slot); if (key.type == BTRFS_EXTENT_ITEM_KEY) ptr += sizeof(struct btrfs_tree_block_info); @@ -844,7 +844,7 @@ loop: node = path.nodes[0]; slot = path.slots[0]; di = btrfs_item_ptr(node, slot, struct btrfs_dir_item); - total = btrfs_item_size_nr(node, slot); + total = btrfs_item_size(node, slot); while (cur < total) { ret = -ENOENT; len = btrfs_dir_name_len(node, di); @@ -940,7 +940,7 @@ static int find_dir_item(struct btrfs_root *root, struct btrfs_key *key, node = path.nodes[0]; slot = path.slots[0]; di = btrfs_item_ptr(node, slot, struct btrfs_dir_item); - total = btrfs_item_size_nr(node, slot); + total = btrfs_item_size(node, slot); while (cur < total) { ret = key->type == BTRFS_DIR_ITEM_KEY ? DIR_ITEM_MISMATCH : DIR_INDEX_MISMATCH; @@ -1147,7 +1147,7 @@ begin: memset(namebuf, 0, sizeof(namebuf) / sizeof(*namebuf)); ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref); - total = btrfs_item_size_nr(node, slot); + total = btrfs_item_size(node, slot); next: /* Update inode ref count */ @@ -1256,7 +1256,7 @@ static int check_inode_extref(struct btrfs_root *root, location.offset = 0; extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref); - total = btrfs_item_size_nr(node, slot); + total = btrfs_item_size(node, slot); next: /* update inode ref count */ @@ -1352,7 +1352,7 @@ static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key, slot = path.slots[0]; ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref); - total = btrfs_item_size_nr(node, slot); + total = btrfs_item_size(node, slot); /* Iterate all entry of INODE_REF */ while (cur < total) { @@ -1418,7 +1418,7 @@ extref: extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref); cur = 0; - total = btrfs_item_size_nr(node, slot); + total = btrfs_item_size(node, slot); /* Iterate all entry of INODE_EXTREF */ while (cur < total) { @@ -1710,7 +1710,7 @@ begin: slot = path->slots[0]; di = btrfs_item_ptr(node, slot, struct btrfs_dir_item); - total = btrfs_item_size_nr(node, slot); + total = btrfs_item_size(node, slot); memset(namebuf, 0, sizeof(namebuf) / sizeof(*namebuf)); while (cur < total) { @@ -2206,7 +2206,7 @@ loop: special_case: di = btrfs_item_ptr(path.nodes[0], path.slots[0], struct btrfs_dir_item); cur = 0; - total = btrfs_item_size_nr(path.nodes[0], path.slots[0]); + total = btrfs_item_size(path.nodes[0], path.slots[0]); while (cur < total) { len = btrfs_dir_name_len(path.nodes[0], di); @@ -3106,7 +3106,7 @@ static int check_tree_block_ref(struct btrfs_root *root, /* * Iterate the extent/metadata item to find the exact backref */ - item_size = btrfs_item_size_nr(leaf, slot); + item_size = btrfs_item_size(leaf, slot); ptr = (unsigned long)iref; end = (unsigned long)ei + item_size; @@ -3448,7 +3448,7 @@ static int check_extent_data_item(struct btrfs_root *root, } /* Check data backref inside that extent item */ - item_size = btrfs_item_size_nr(leaf, path.slots[0]); + item_size = btrfs_item_size(leaf, path.slots[0]); iref = (struct btrfs_extent_inline_ref *)(ei + 1); ptr = (unsigned long)iref; end = (unsigned long)ei + item_size; @@ -4230,7 +4230,7 @@ static int check_extent_item(struct btrfs_path *path) int slot = path->slots[0]; int type; u32 nodesize = btrfs_super_nodesize(gfs_info->super_copy); - u32 item_size = btrfs_item_size_nr(eb, slot); + u32 item_size = btrfs_item_size(eb, slot); u64 flags; u64 offset; u64 parent; @@ -4391,7 +4391,7 @@ next: eb = path->nodes[0]; slot = path->slots[0]; ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item); - item_size = btrfs_item_size_nr(eb, slot); + item_size = btrfs_item_size(eb, slot); goto next; } } @@ -4408,7 +4408,7 @@ next: eb = path->nodes[0]; slot = path->slots[0]; ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item); - item_size = btrfs_item_size_nr(eb, slot); + item_size = btrfs_item_size(eb, slot); ptr_offset += btrfs_extent_inline_ref_size(type); goto next; } @@ -4846,7 +4846,7 @@ again: err |= ret; break; case BTRFS_EXTENT_CSUM_KEY: - total_csum_bytes += btrfs_item_size_nr(eb, slot); + total_csum_bytes += btrfs_item_size(eb, slot); err |= ret; break; case BTRFS_TREE_BLOCK_REF_KEY: diff --git a/check/qgroup-verify.c b/check/qgroup-verify.c index 0813b841..2c05f875 100644 --- a/check/qgroup-verify.c +++ b/check/qgroup-verify.c @@ -1041,7 +1041,7 @@ static int add_inline_refs(struct btrfs_fs_info *info, struct btrfs_extent_inline_ref *iref; struct btrfs_extent_data_ref *dref; u64 flags, root_obj, offset, parent; - u32 item_size = btrfs_item_size_nr(ei_leaf, slot); + u32 item_size = btrfs_item_size(ei_leaf, slot); int type; unsigned long end; unsigned long ptr; diff --git a/cmds/rescue-chunk-recover.c b/cmds/rescue-chunk-recover.c index da24df4c..ec5c206f 100644 --- a/cmds/rescue-chunk-recover.c +++ b/cmds/rescue-chunk-recover.c @@ -1812,7 +1812,7 @@ static int next_csum(struct btrfs_root *csum_root, struct btrfs_csum_item *csum_item; u32 blocksize = csum_root->fs_info->sectorsize; u16 csum_size = csum_root->fs_info->csum_size; - int csums_in_item = btrfs_item_size_nr(*leaf, *slot) / csum_size; + int csums_in_item = btrfs_item_size(*leaf, *slot) / csum_size; if (*csum_offset >= csums_in_item) { ++(*slot); @@ -1897,7 +1897,7 @@ static u64 item_end_offset(struct btrfs_root *root, struct btrfs_key *key, u32 blocksize = root->fs_info->sectorsize; u16 csum_size = root->fs_info->csum_size; - u64 offset = btrfs_item_size_nr(leaf, slot); + u64 offset = btrfs_item_size(leaf, slot); offset /= csum_size; offset *= blocksize; offset += key->offset; diff --git a/cmds/restore.c b/cmds/restore.c index bc88af70..81ca6cd5 100644 --- a/cmds/restore.c +++ b/cmds/restore.c @@ -512,7 +512,7 @@ static int set_file_xattrs(struct btrfs_root *root, u64 inode, if (key.type != BTRFS_XATTR_ITEM_KEY || key.objectid != inode) break; cur = 0; - total_len = btrfs_item_size_nr(leaf, path.slots[0]); + total_len = btrfs_item_size(leaf, path.slots[0]); di = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_dir_item); diff --git a/convert/common.c b/convert/common.c index 38112084..0fb7b6c5 100644 --- a/convert/common.c +++ b/convert/common.c @@ -204,8 +204,8 @@ static void insert_temp_root_item(struct extent_buffer *buf, btrfs_set_disk_key_offset(&disk_key, 0); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset_nr(buf, *slot, *itemoff); - btrfs_set_item_size_nr(buf, *slot, sizeof(root_item)); + btrfs_set_item_offset(buf, *slot, *itemoff); + btrfs_set_item_size(buf, *slot, sizeof(root_item)); write_extent_buffer(buf, &root_item, btrfs_item_ptr_offset(buf, *slot), sizeof(root_item)); @@ -311,8 +311,8 @@ static int insert_temp_dev_item(int fd, struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID); btrfs_set_disk_key_offset(&disk_key, 1); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset_nr(buf, *slot, *itemoff); - btrfs_set_item_size_nr(buf, *slot, sizeof(*dev_item)); + btrfs_set_item_offset(buf, *slot, *itemoff); + btrfs_set_item_size(buf, *slot, sizeof(*dev_item)); dev_item = btrfs_item_ptr(buf, *slot, struct btrfs_dev_item); /* Generate device uuid */ @@ -369,8 +369,8 @@ static int insert_temp_chunk_item(int fd, struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, BTRFS_FIRST_CHUNK_TREE_OBJECTID); btrfs_set_disk_key_offset(&disk_key, start); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset_nr(buf, *slot, *itemoff); - btrfs_set_item_size_nr(buf, *slot, btrfs_chunk_item_size(1)); + btrfs_set_item_offset(buf, *slot, *itemoff); + btrfs_set_item_size(buf, *slot, btrfs_chunk_item_size(1)); chunk = btrfs_item_ptr(buf, *slot, struct btrfs_chunk); btrfs_set_chunk_length(buf, chunk, len); @@ -471,8 +471,8 @@ static void insert_temp_dev_extent(struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, 1); btrfs_set_disk_key_offset(&disk_key, start); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset_nr(buf, *slot, *itemoff); - btrfs_set_item_size_nr(buf, *slot, sizeof(*dev_extent)); + btrfs_set_item_offset(buf, *slot, *itemoff); + btrfs_set_item_size(buf, *slot, sizeof(*dev_extent)); dev_extent = btrfs_item_ptr(buf, *slot, struct btrfs_dev_extent); btrfs_set_dev_extent_chunk_objectid(buf, dev_extent, @@ -603,8 +603,8 @@ static int insert_temp_extent_item(int fd, struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, bytenr); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset_nr(buf, *slot, *itemoff); - btrfs_set_item_size_nr(buf, *slot, itemsize); + btrfs_set_item_offset(buf, *slot, *itemoff); + btrfs_set_item_size(buf, *slot, itemsize); ei = btrfs_item_ptr(buf, *slot, struct btrfs_extent_item); btrfs_set_extent_refs(buf, ei, 1); @@ -669,8 +669,8 @@ static void insert_temp_block_group(struct extent_buffer *buf, btrfs_set_disk_key_objectid(&disk_key, bytenr); btrfs_set_disk_key_offset(&disk_key, len); btrfs_set_item_key(buf, &disk_key, *slot); - btrfs_set_item_offset_nr(buf, *slot, *itemoff); - btrfs_set_item_size_nr(buf, *slot, sizeof(bgi)); + btrfs_set_item_offset(buf, *slot, *itemoff); + btrfs_set_item_size(buf, *slot, sizeof(bgi)); btrfs_set_stack_block_group_flags(&bgi, flag); btrfs_set_stack_block_group_used(&bgi, used); diff --git a/image/main.c b/image/main.c index 5d67d282..ff121fca 100644 --- a/image/main.c +++ b/image/main.c @@ -311,9 +311,9 @@ static void zero_items(struct metadump_struct *md, u8 *dst, for (i = 0; i < nritems; i++) { btrfs_item_key_to_cpu(src, &key, i); if (key.type == BTRFS_CSUM_ITEM_KEY) { - size = btrfs_item_size_nr(src, i); + size = btrfs_item_size(src, i); memset(dst + btrfs_leaf_data(src) + - btrfs_item_offset_nr(src, i), 0, size); + btrfs_item_offset(src, i), 0, size); continue; } @@ -359,7 +359,7 @@ static void copy_buffer(struct metadump_struct *md, u8 *dst, memset(dst + size, 0, src->len - size); } else if (level == 0) { size = btrfs_leaf_data(src) + - btrfs_item_offset_nr(src, nritems - 1) - + btrfs_item_offset(src, nritems - 1) - btrfs_item_nr_offset(nritems); memset(dst + btrfs_item_nr_offset(nritems), 0, size); zero_items(md, dst, src); @@ -971,7 +971,7 @@ static int copy_from_extent_tree(struct metadump_struct *metadump, break; } - if (btrfs_item_size_nr(leaf, path->slots[0]) >= sizeof(*ei)) { + if (btrfs_item_size(leaf, path->slots[0]) >= sizeof(*ei)) { ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item); if (btrfs_extent_flags(leaf, ei) & @@ -1223,26 +1223,26 @@ static void truncate_item(struct extent_buffer *eb, int slot, u32 new_size) u32 data_end; int i; - old_size = btrfs_item_size_nr(eb, slot); + old_size = btrfs_item_size(eb, slot); if (old_size == new_size) return; nritems = btrfs_header_nritems(eb); - data_end = btrfs_item_offset_nr(eb, nritems - 1); + data_end = btrfs_item_offset(eb, nritems - 1); - old_data_start = btrfs_item_offset_nr(eb, slot); + old_data_start = btrfs_item_offset(eb, slot); size_diff = old_size - new_size; for (i = slot; i < nritems; i++) { u32 ioff; - ioff = btrfs_item_offset_nr(eb, i); - btrfs_set_item_offset_nr(eb, i, ioff + size_diff); + ioff = btrfs_item_offset(eb, i); + btrfs_set_item_offset(eb, i, ioff + size_diff); } memmove_extent_buffer(eb, btrfs_leaf_data(eb) + data_end + size_diff, btrfs_leaf_data(eb) + data_end, old_data_start + new_size - data_end); - btrfs_set_item_size_nr(eb, slot, new_size); + btrfs_set_item_size(eb, slot, new_size); } static int fixup_chunk_tree_block(struct mdrestore_struct *mdres, diff --git a/image/sanitize.c b/image/sanitize.c index e3ac1b84..c6970403 100644 --- a/image/sanitize.c +++ b/image/sanitize.c @@ -325,7 +325,7 @@ static void sanitize_dir_item(enum sanitize_mode sanitize, int free_garbage = (sanitize == SANITIZE_NAMES); dir_item = btrfs_item_ptr(eb, slot, struct btrfs_dir_item); - total_len = btrfs_item_size_nr(eb, slot); + total_len = btrfs_item_size(eb, slot); while (cur < total_len) { this_len = sizeof(*dir_item) + btrfs_dir_name_len(eb, dir_item) + @@ -371,7 +371,7 @@ static void sanitize_inode_ref(enum sanitize_mode sanitize, int len; int free_garbage = (sanitize == SANITIZE_NAMES); - item_size = btrfs_item_size_nr(eb, slot); + item_size = btrfs_item_size(eb, slot); ptr = btrfs_item_ptr_offset(eb, slot); while (cur_offset < item_size) { if (ext) { diff --git a/kernel-shared/backref.c b/kernel-shared/backref.c index 327599b7..9c5a3895 100644 --- a/kernel-shared/backref.c +++ b/kernel-shared/backref.c @@ -561,7 +561,7 @@ static int __add_inline_refs(struct btrfs_fs_info *fs_info, leaf = path->nodes[0]; slot = path->slots[0]; - item_size = btrfs_item_size_nr(leaf, slot); + item_size = btrfs_item_size(leaf, slot); BUG_ON(item_size < sizeof(*ei)); ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item); @@ -1182,7 +1182,7 @@ int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical, } eb = path->nodes[0]; - item_size = btrfs_item_size_nr(eb, path->slots[0]); + item_size = btrfs_item_size(eb, path->slots[0]); BUG_ON(item_size < sizeof(*ei)); ei = btrfs_item_ptr(eb, path->slots[0], struct btrfs_extent_item); @@ -1443,7 +1443,7 @@ static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root, iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref); - for (cur = 0; cur < btrfs_item_size_nr(eb, slot); cur += len) { + for (cur = 0; cur < btrfs_item_size(eb, slot); cur += len) { name_len = btrfs_inode_ref_name_len(eb, iref); /* path must be released before calling iterate()! */ pr_debug("following ref at offset %u for inode %llu in " @@ -1502,7 +1502,7 @@ static int iterate_inode_extrefs(u64 inum, struct btrfs_root *fs_root, btrfs_release_path(path); leaf = path->nodes[0]; - item_size = btrfs_item_size_nr(leaf, slot); + item_size = btrfs_item_size(leaf, slot); ptr = btrfs_item_ptr_offset(leaf, slot); cur_offset = 0; diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c index d18c91d1..04847cd5 100644 --- a/kernel-shared/ctree.c +++ b/kernel-shared/ctree.c @@ -582,7 +582,7 @@ static inline unsigned int leaf_data_end(const struct extent_buffer *leaf) u32 nr = btrfs_header_nritems(leaf); if (nr == 0) return BTRFS_LEAF_DATA_SIZE(leaf->fs_info); - return btrfs_item_offset_nr(leaf, nr - 1); + return btrfs_item_offset(leaf, nr - 1); } static void generic_err(const struct extent_buffer *buf, int slot, @@ -728,7 +728,7 @@ btrfs_check_leaf(struct btrfs_fs_info *fs_info, if (slot == 0) item_end_expected = BTRFS_LEAF_DATA_SIZE(fs_info); else - item_end_expected = btrfs_item_offset_nr(leaf, + item_end_expected = btrfs_item_offset(leaf, slot - 1); if (btrfs_item_end(leaf, slot) != item_end_expected) { generic_err(leaf, slot, @@ -1932,7 +1932,7 @@ static int leaf_space_used(struct extent_buffer *l, int start, int nr) if (!nr) return 0; data_len = btrfs_item_end(l, start); - data_len = data_len - btrfs_item_offset_nr(l, end); + data_len = data_len - btrfs_item_offset(l, end); data_len += sizeof(struct btrfs_item) * nr; WARN_ON(data_len < 0); return data_len; @@ -2038,7 +2038,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root if (path->slots[0] == i) push_space += data_size + sizeof(struct btrfs_item); - this_item_size = btrfs_item_size_nr(left, i); + this_item_size = btrfs_item_size(left, i); if (this_item_size + sizeof(struct btrfs_item) + push_space > free_space) break; push_items++; @@ -2088,8 +2088,8 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_set_header_nritems(right, right_nritems); push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info); for (i = 0; i < right_nritems; i++) { - push_space -= btrfs_item_size_nr(right, i); - btrfs_set_item_offset_nr(right, i, push_space); + push_space -= btrfs_item_size(right, i); + btrfs_set_item_offset(right, i, push_space); } left_nritems -= push_items; @@ -2180,7 +2180,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root if (path->slots[0] == i) push_space += data_size + sizeof(struct btrfs_item); - this_item_size = btrfs_item_size_nr(right, i); + this_item_size = btrfs_item_size(right, i); if (this_item_size + sizeof(struct btrfs_item) + push_space > free_space) break; @@ -2202,22 +2202,22 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root push_items * sizeof(struct btrfs_item)); push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info) - - btrfs_item_offset_nr(right, push_items -1); + btrfs_item_offset(right, push_items -1); copy_extent_buffer(left, right, btrfs_leaf_data(left) + leaf_data_end(left) - push_space, btrfs_leaf_data(right) + - btrfs_item_offset_nr(right, push_items - 1), + btrfs_item_offset(right, push_items - 1), push_space); old_left_nritems = btrfs_header_nritems(left); BUG_ON(old_left_nritems == 0); - old_left_item_size = btrfs_item_offset_nr(left, old_left_nritems - 1); + old_left_item_size = btrfs_item_offset(left, old_left_nritems - 1); for (i = old_left_nritems; i < old_left_nritems + push_items; i++) { u32 ioff; - ioff = btrfs_item_offset_nr(left, i); - btrfs_set_item_offset_nr(left, i, + ioff = btrfs_item_offset(left, i); + btrfs_set_item_offset(left, i, ioff - (BTRFS_LEAF_DATA_SIZE(root->fs_info) - old_left_item_size)); } @@ -2230,7 +2230,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root } if (push_items < right_nritems) { - push_space = btrfs_item_offset_nr(right, push_items - 1) - + push_space = btrfs_item_offset(right, push_items - 1) - leaf_data_end(right); memmove_extent_buffer(right, btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root->fs_info) - @@ -2247,8 +2247,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_set_header_nritems(right, right_nritems); push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info); for (i = 0; i < right_nritems; i++) { - push_space = push_space - btrfs_item_size_nr(right, i); - btrfs_set_item_offset_nr(right, i, push_space); + push_space = push_space - btrfs_item_size(right, i); + btrfs_set_item_offset(right, i, push_space); } btrfs_mark_buffer_dirty(left); @@ -2309,8 +2309,8 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, btrfs_item_end(l, mid); for (i = 0; i < nritems; i++) { - u32 ioff = btrfs_item_offset_nr(right, i); - btrfs_set_item_offset_nr(right, i, ioff + rt_data_off); + u32 ioff = btrfs_item_offset(right, i); + btrfs_set_item_offset(right, i, ioff + rt_data_off); } btrfs_set_header_nritems(l, mid); @@ -2364,7 +2364,7 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans, l = path->nodes[0]; slot = path->slots[0]; - if (extend && data_size + btrfs_item_size_nr(l, slot) + + if (extend && data_size + btrfs_item_size(l, slot) + sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root->fs_info)) return -EOVERFLOW; @@ -2540,7 +2540,7 @@ int btrfs_split_item(struct btrfs_trans_handle *trans, sizeof(struct btrfs_item)) goto split; - item_size = btrfs_item_size_nr(leaf, path->slots[0]); + item_size = btrfs_item_size(leaf, path->slots[0]); btrfs_release_path(path); path->search_for_split = 1; @@ -2549,7 +2549,7 @@ int btrfs_split_item(struct btrfs_trans_handle *trans, path->search_for_split = 0; /* if our item isn't there or got smaller, return now */ - if (ret != 0 || item_size != btrfs_item_size_nr(path->nodes[0], + if (ret != 0 || item_size != btrfs_item_size(path->nodes[0], path->slots[0])) { return -EAGAIN; } @@ -2561,8 +2561,8 @@ int btrfs_split_item(struct btrfs_trans_handle *trans, leaf = path->nodes[0]; split: - orig_offset = btrfs_item_offset_nr(leaf, path->slots[0]); - item_size = btrfs_item_size_nr(leaf, path->slots[0]); + orig_offset = btrfs_item_offset(leaf, path->slots[0]); + item_size = btrfs_item_size(leaf, path->slots[0]); buf = kmalloc(item_size, GFP_NOFS); @@ -2585,12 +2585,12 @@ split: btrfs_cpu_key_to_disk(&disk_key, new_key); btrfs_set_item_key(leaf, &disk_key, slot); - btrfs_set_item_offset_nr(leaf, slot, orig_offset); - btrfs_set_item_size_nr(leaf, slot, item_size - split_offset); + btrfs_set_item_offset(leaf, slot, orig_offset); + btrfs_set_item_size(leaf, slot, item_size - split_offset); - btrfs_set_item_offset_nr(leaf, path->slots[0], + btrfs_set_item_offset(leaf, path->slots[0], orig_offset + item_size - split_offset); - btrfs_set_item_size_nr(leaf, path->slots[0], split_offset); + btrfs_set_item_size(leaf, path->slots[0], split_offset); btrfs_set_header_nritems(leaf, nritems + 1); @@ -2629,14 +2629,14 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) leaf = path->nodes[0]; slot = path->slots[0]; - old_size = btrfs_item_size_nr(leaf, slot); + old_size = btrfs_item_size(leaf, slot); if (old_size == new_size) return 0; nritems = btrfs_header_nritems(leaf); data_end = leaf_data_end(leaf); - old_data_start = btrfs_item_offset_nr(leaf, slot); + old_data_start = btrfs_item_offset(leaf, slot); size_diff = old_size - new_size; @@ -2649,8 +2649,8 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) /* first correct the data pointers */ for (i = slot; i < nritems; i++) { u32 ioff; - ioff = btrfs_item_offset_nr(leaf, i); - btrfs_set_item_offset_nr(leaf, i, ioff + size_diff); + ioff = btrfs_item_offset(leaf, i); + btrfs_set_item_offset(leaf, i, ioff + size_diff); } /* shift the data */ @@ -2694,7 +2694,7 @@ int btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end) btrfs_fixup_low_keys(path, &disk_key, 1); } - btrfs_set_item_size_nr(leaf, slot, new_size); + btrfs_set_item_size(leaf, slot, new_size); btrfs_mark_buffer_dirty(leaf); ret = 0; @@ -2742,8 +2742,8 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path, /* first correct the data pointers */ for (i = slot; i < nritems; i++) { u32 ioff; - ioff = btrfs_item_offset_nr(leaf, i); - btrfs_set_item_offset_nr(leaf, i, ioff - data_size); + ioff = btrfs_item_offset(leaf, i); + btrfs_set_item_offset(leaf, i, ioff - data_size); } /* shift the data */ @@ -2752,8 +2752,8 @@ int btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path, data_end, old_data - data_end); data_end = old_data; - old_size = btrfs_item_size_nr(leaf, slot); - btrfs_set_item_size_nr(leaf, slot, old_size + data_size); + old_size = btrfs_item_size(leaf, slot); + btrfs_set_item_size(leaf, slot, old_size + data_size); btrfs_mark_buffer_dirty(leaf); ret = 0; @@ -2831,8 +2831,8 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, for (i = slot; i < nritems; i++) { u32 ioff; - ioff = btrfs_item_offset_nr(leaf, i); - btrfs_set_item_offset_nr(leaf, i, ioff - total_data); + ioff = btrfs_item_offset(leaf, i); + btrfs_set_item_offset(leaf, i, ioff - total_data); } /* shift the items */ @@ -2851,9 +2851,9 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, for (i = 0; i < nr; i++) { btrfs_cpu_key_to_disk(&disk_key, cpu_key + i); btrfs_set_item_key(leaf, &disk_key, slot + i); - btrfs_set_item_offset_nr(leaf, slot + i, data_end - data_size[i]); + btrfs_set_item_offset(leaf, slot + i, data_end - data_size[i]); data_end -= data_size[i]; - btrfs_set_item_size_nr(leaf, slot + i, data_size[i]); + btrfs_set_item_size(leaf, slot + i, data_size[i]); } btrfs_set_header_nritems(leaf, nritems + nr); btrfs_mark_buffer_dirty(leaf); @@ -2985,10 +2985,10 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, u32 nritems; leaf = path->nodes[0]; - last_off = btrfs_item_offset_nr(leaf, slot + nr - 1); + last_off = btrfs_item_offset(leaf, slot + nr - 1); for (i = 0; i < nr; i++) - dsize += btrfs_item_size_nr(leaf, slot + i); + dsize += btrfs_item_size(leaf, slot + i); nritems = btrfs_header_nritems(leaf); @@ -3003,8 +3003,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, for (i = slot + nr; i < nritems; i++) { u32 ioff; - ioff = btrfs_item_offset_nr(leaf, i); - btrfs_set_item_offset_nr(leaf, i, ioff + dsize); + ioff = btrfs_item_offset(leaf, i); + btrfs_set_item_offset(leaf, i, ioff + dsize); } memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot), @@ -3334,7 +3334,7 @@ static int btrfs_uuid_tree_lookup(struct btrfs_root *uuid_root, u8 *uuid, eb = path->nodes[0]; slot = path->slots[0]; - item_size = btrfs_item_size_nr(eb, slot); + item_size = btrfs_item_size(eb, slot); offset = btrfs_item_ptr_offset(eb, slot); ret = -ENOENT; @@ -3407,7 +3407,7 @@ int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans, u8 *uuid, u8 type, eb = path->nodes[0]; slot = path->slots[0]; offset = btrfs_item_ptr_offset(eb, slot); - offset += btrfs_item_size_nr(eb, slot) - sizeof(subvol_id_le); + offset += btrfs_item_size(eb, slot) - sizeof(subvol_id_le); } else if (ret < 0) { warning( "inserting uuid item failed (0x%016llx, 0x%016llx) type %u: %d", diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h index befa244f..8b654dde 100644 --- a/kernel-shared/ctree.h +++ b/kernel-shared/ctree.h @@ -1980,8 +1980,8 @@ static inline void btrfs_set_node_key(struct extent_buffer *eb, } /* struct btrfs_item */ -BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32); -BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32); +BTRFS_SETGET_FUNCS(raw_item_offset, struct btrfs_item, offset, 32); +BTRFS_SETGET_FUNCS(raw_item_size, struct btrfs_item, size, 32); static inline unsigned long btrfs_item_nr_offset(int nr) { @@ -1994,31 +1994,23 @@ static inline struct btrfs_item *btrfs_item_nr(int nr) return (struct btrfs_item *)btrfs_item_nr_offset(nr); } -static inline void btrfs_set_item_size_nr(struct extent_buffer *eb, int nr, - u32 size) -{ - btrfs_set_item_size(eb, btrfs_item_nr(nr), size); +#define BTRFS_ITEM_SETGET_FUNCS(member) \ +static inline u32 btrfs_item_##member(const struct extent_buffer *eb, int slot) \ +{ \ + return btrfs_raw_item_##member(eb, btrfs_item_nr(slot)); \ +} \ +static inline void btrfs_set_item_##member(struct extent_buffer *eb, \ + int slot, u32 val) \ +{ \ + btrfs_set_raw_item_##member(eb, btrfs_item_nr(slot), val); \ } -static inline void btrfs_set_item_offset_nr(struct extent_buffer *eb, int nr, - u32 offset) -{ - btrfs_set_item_offset(eb, btrfs_item_nr(nr), offset); -} - -static inline u32 btrfs_item_offset_nr(const struct extent_buffer *eb, int nr) -{ - return btrfs_item_offset(eb, btrfs_item_nr(nr)); -} - -static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr) -{ - return btrfs_item_size(eb, btrfs_item_nr(nr)); -} +BTRFS_ITEM_SETGET_FUNCS(size) +BTRFS_ITEM_SETGET_FUNCS(offset) static inline u32 btrfs_item_end(struct extent_buffer *eb, int nr) { - return btrfs_item_offset_nr(eb, nr) + btrfs_item_size_nr(eb, nr); + return btrfs_item_offset(eb, nr) + btrfs_item_size(eb, nr); } static inline void btrfs_item_key(struct extent_buffer *eb, @@ -2560,7 +2552,7 @@ static inline u64 btrfs_dev_stats_value(const struct extent_buffer *eb, static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb, int nr) { - return btrfs_item_size_nr(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START; + return btrfs_item_size(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START; } /* struct btrfs_ioctl_search_header */ @@ -2612,11 +2604,11 @@ static inline int __btrfs_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag) /* helper function to cast into the data area of the leaf. */ #define btrfs_item_ptr(leaf, slot, type) \ ((type *)(btrfs_leaf_data(leaf) + \ - btrfs_item_offset_nr(leaf, slot))) + btrfs_item_offset(leaf, slot))) #define btrfs_item_ptr_offset(leaf, slot) \ ((unsigned long)(btrfs_leaf_data(leaf) + \ - btrfs_item_offset_nr(leaf, slot))) + btrfs_item_offset(leaf, slot))) u64 btrfs_name_hash(const char *name, int len); u64 btrfs_extref_hash(u64 parent_objectid, const char *name, int len); diff --git a/kernel-shared/dir-item.c b/kernel-shared/dir-item.c index 729d4308..27dfb362 100644 --- a/kernel-shared/dir-item.c +++ b/kernel-shared/dir-item.c @@ -48,8 +48,8 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle WARN_ON(ret > 0); leaf = path->nodes[0]; ptr = btrfs_item_ptr(leaf, path->slots[0], char); - BUG_ON(data_size > btrfs_item_size_nr(leaf, path->slots[0])); - ptr += btrfs_item_size_nr(leaf, path->slots[0]) - data_size; + BUG_ON(data_size > btrfs_item_size(leaf, path->slots[0])); + ptr += btrfs_item_size(leaf, path->slots[0]) - data_size; return (struct btrfs_dir_item *)ptr; } @@ -264,7 +264,7 @@ int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, leaf = path->nodes[0]; sub_item_len = sizeof(*di) + btrfs_dir_name_len(leaf, di) + btrfs_dir_data_len(leaf, di); - item_len = btrfs_item_size_nr(leaf, path->slots[0]); + item_len = btrfs_item_size(leaf, path->slots[0]); /* * If @sub_item_len is longer than @item_len, then it means the @@ -329,7 +329,7 @@ struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root, leaf = path->nodes[0]; dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item); - total_len = btrfs_item_size_nr(leaf, path->slots[0]); + total_len = btrfs_item_size(leaf, path->slots[0]); if (verify_dir_item(root, leaf, dir_item)) return NULL; diff --git a/kernel-shared/extent-tree.c b/kernel-shared/extent-tree.c index 3713452b..e36745ca 100644 --- a/kernel-shared/extent-tree.c +++ b/kernel-shared/extent-tree.c @@ -929,7 +929,7 @@ again: BUG_ON(ret); leaf = path->nodes[0]; - item_size = btrfs_item_size_nr(leaf, path->slots[0]); + item_size = btrfs_item_size(leaf, path->slots[0]); if (item_size < sizeof(*ei)) { printf("Size is %u, needs to be %u, slot %d\n", (unsigned)item_size, @@ -1055,7 +1055,7 @@ static int setup_inline_extent_backref(struct btrfs_root *root, btrfs_set_extent_refs(leaf, ei, refs); ptr = (unsigned long)ei + item_offset; - end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]); + end = (unsigned long)ei + btrfs_item_size(leaf, path->slots[0]); if (ptr < end - size) memmove_extent_buffer(leaf, ptr + size, ptr, end - size - ptr); @@ -1159,7 +1159,7 @@ static int update_inline_extent_backref(struct btrfs_trans_handle *trans, btrfs_set_shared_data_ref_count(leaf, sref, refs); } else { size = btrfs_extent_inline_ref_size(type); - item_size = btrfs_item_size_nr(leaf, path->slots[0]); + item_size = btrfs_item_size(leaf, path->slots[0]); ptr = (unsigned long)iref; end = (unsigned long)ei + item_size; if (ptr + size < end) @@ -1353,7 +1353,7 @@ again: } l = path->nodes[0]; - item_size = btrfs_item_size_nr(l, path->slots[0]); + item_size = btrfs_item_size(l, path->slots[0]); if (item_size >= sizeof(*item)) { item = btrfs_item_ptr(l, path->slots[0], struct btrfs_extent_item); @@ -1429,7 +1429,7 @@ again: BUG(); } l = path->nodes[0]; - item_size = btrfs_item_size_nr(l, path->slots[0]); + item_size = btrfs_item_size(l, path->slots[0]); if (item_size < sizeof(*item)) { error( "unsupported or corrupted extent item, item size=%u expect minimal size=%zu", @@ -2035,7 +2035,7 @@ static int __free_extent(struct btrfs_trans_handle *trans, } leaf = path->nodes[0]; - item_size = btrfs_item_size_nr(leaf, extent_slot); + item_size = btrfs_item_size(leaf, extent_slot); if (item_size < sizeof(*ei)) { error( "unsupported or corrupted extent item, item size=%u expect minimal size=%zu", diff --git a/kernel-shared/file-item.c b/kernel-shared/file-item.c index 0d68ed52..b0fcd49d 100644 --- a/kernel-shared/file-item.c +++ b/kernel-shared/file-item.c @@ -170,7 +170,7 @@ btrfs_lookup_csum(struct btrfs_trans_handle *trans, csum_offset = (bytenr - found_key.offset) / root->fs_info->sectorsize; - csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]); + csums_in_item = btrfs_item_size(leaf, path->slots[0]); csums_in_item /= csum_size; if (csum_offset >= csums_in_item) { @@ -235,7 +235,7 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans, /* printf("item not big enough for bytenr %llu\n", bytenr); */ /* we found one, but it isn't big enough yet */ leaf = path->nodes[0]; - item_size = btrfs_item_size_nr(leaf, path->slots[0]); + item_size = btrfs_item_size(leaf, path->slots[0]); if ((item_size / csum_size) >= MAX_CSUM_ITEMS(root, csum_size)) { /* already at max size, make a new one */ goto insert; @@ -287,10 +287,10 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans, csum_offset >= MAX_CSUM_ITEMS(root, csum_size)) { goto insert; } - if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) / + if (csum_offset >= btrfs_item_size(leaf, path->slots[0]) / csum_size) { u32 diff = (csum_offset + 1) * csum_size; - diff = diff - btrfs_item_size_nr(leaf, path->slots[0]); + diff = diff - btrfs_item_size(leaf, path->slots[0]); if (diff != csum_size) goto insert; ret = btrfs_extend_item(root, path, diff); @@ -359,7 +359,7 @@ static noinline int truncate_one_csum(struct btrfs_root *root, int ret; leaf = path->nodes[0]; - csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; + csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size; csum_end *= root->fs_info->sectorsize; csum_end += key->offset; @@ -439,7 +439,7 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans, u64 bytenr, u64 len) if (key.offset >= end_byte) break; - csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; + csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size; csum_end *= blocksize; csum_end += key.offset; diff --git a/kernel-shared/inode-item.c b/kernel-shared/inode-item.c index 7ca75f6d..891ae40a 100644 --- a/kernel-shared/inode-item.c +++ b/kernel-shared/inode-item.c @@ -32,7 +32,7 @@ static int find_name_in_backref(struct btrfs_path *path, const char * name, int len; leaf = path->nodes[0]; - item_size = btrfs_item_size_nr(leaf, path->slots[0]); + item_size = btrfs_item_size(leaf, path->slots[0]); ptr = btrfs_item_ptr_offset(leaf, path->slots[0]); while (cur_offset < item_size) { ref = (struct btrfs_inode_ref *)(ptr + cur_offset); @@ -77,7 +77,7 @@ int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, if (find_name_in_backref(path, name, name_len, &ref)) goto out; - old_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]); + old_size = btrfs_item_size(path->nodes[0], path->slots[0]); ret = btrfs_extend_item(root, path, ins_len); BUG_ON(ret); ref = btrfs_item_ptr(path->nodes[0], path->slots[0], @@ -197,7 +197,7 @@ static int btrfs_find_name_in_ext_backref(struct btrfs_path *path, node = path->nodes[0]; slot = path->slots[0]; - item_size = btrfs_item_size_nr(node, slot); + item_size = btrfs_item_size(node, slot); ptr = btrfs_item_ptr_offset(node, slot); /* @@ -293,7 +293,7 @@ int btrfs_del_inode_extref(struct btrfs_trans_handle *trans, } leaf = path->nodes[0]; - item_size = btrfs_item_size_nr(leaf, path->slots[0]); + item_size = btrfs_item_size(leaf, path->slots[0]); if (index) *index = btrfs_inode_extref_index(leaf, extref); @@ -361,7 +361,7 @@ int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans, leaf = path->nodes[0]; ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char); - ptr += btrfs_item_size_nr(leaf, path->slots[0]) - ins_len; + ptr += btrfs_item_size(leaf, path->slots[0]) - ins_len; extref = (struct btrfs_inode_extref *)ptr; btrfs_set_inode_extref_name_len(path->nodes[0], extref, name_len); @@ -416,7 +416,7 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans, goto out; } leaf = path->nodes[0]; - item_size = btrfs_item_size_nr(leaf, path->slots[0]); + item_size = btrfs_item_size(leaf, path->slots[0]); if (index) *index = btrfs_inode_ref_index(leaf, ref); diff --git a/kernel-shared/print-tree.c b/kernel-shared/print-tree.c index aff2ebc4..717be5d5 100644 --- a/kernel-shared/print-tree.c +++ b/kernel-shared/print-tree.c @@ -440,7 +440,7 @@ void print_extent_item(struct extent_buffer *eb, int slot, int metadata) unsigned long end; unsigned long ptr; int type; - u32 item_size = btrfs_item_size_nr(eb, slot); + u32 item_size = btrfs_item_size(eb, slot); u64 flags; u64 offset; char flags_str[32] = {0}; @@ -571,7 +571,7 @@ static void print_root_item(struct extent_buffer *leaf, int slot) struct btrfs_key drop_key; ri = btrfs_item_ptr(leaf, slot, struct btrfs_root_item); - len = btrfs_item_size_nr(leaf, slot); + len = btrfs_item_size(leaf, slot); memset(&root_item, 0, sizeof(root_item)); read_extent_buffer(leaf, &root_item, (unsigned long)ri, len); @@ -1306,18 +1306,18 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode) * Only need to ensure all pointers are pointing range inside * the leaf, thus no segfault. */ - if (btrfs_item_offset_nr(eb, i) > leaf_data_size || - btrfs_item_size_nr(eb, i) + btrfs_item_offset_nr(eb, i) > + if (btrfs_item_offset(eb, i) > leaf_data_size || + btrfs_item_size(eb, i) + btrfs_item_offset(eb, i) > leaf_data_size) { error( "leaf %llu slot %u pointer invalid, offset %u size %u leaf data limit %u", btrfs_header_bytenr(eb), i, - btrfs_item_offset_nr(eb, i), - btrfs_item_size_nr(eb, i), leaf_data_size); + btrfs_item_offset(eb, i), + btrfs_item_size(eb, i), leaf_data_size); error("skip remaining slots"); break; } - item_size = btrfs_item_size_nr(eb, i); + item_size = btrfs_item_size(eb, i); /* Untyped extraction of slot from btrfs_item_ptr */ ptr = btrfs_item_ptr(eb, i, void*); @@ -1329,8 +1329,8 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode) printf("\titem %u ", i); btrfs_print_key(&disk_key); printf(" itemoff %u itemsize %u\n", - btrfs_item_offset_nr(eb, i), - btrfs_item_size_nr(eb, i)); + btrfs_item_offset(eb, i), + btrfs_item_size(eb, i)); if (type == 0 && objectid == BTRFS_FREE_SPACE_OBJECTID) print_free_space_header(eb, i); @@ -1436,7 +1436,7 @@ void btrfs_print_leaf(struct extent_buffer *eb, unsigned int mode) case BTRFS_UUID_KEY_SUBVOL: case BTRFS_UUID_KEY_RECEIVED_SUBVOL: print_uuid_item(eb, btrfs_item_ptr_offset(eb, i), - btrfs_item_size_nr(eb, i)); + btrfs_item_size(eb, i)); break; case BTRFS_STRING_ITEM_KEY: { const char *str = eb->data + btrfs_item_ptr_offset(eb, i); diff --git a/kernel-shared/root-tree.c b/kernel-shared/root-tree.c index bc410963..0f83f915 100644 --- a/kernel-shared/root-tree.c +++ b/kernel-shared/root-tree.c @@ -87,7 +87,7 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root l = path->nodes[0]; slot = path->slots[0]; ptr = btrfs_item_ptr_offset(l, slot); - old_len = btrfs_item_size_nr(l, slot); + old_len = btrfs_item_size(l, slot); /* * If this is the first time we update the root item which originated diff --git a/kernel-shared/uuid-tree.c b/kernel-shared/uuid-tree.c index c0b3406a..6de9a178 100644 --- a/kernel-shared/uuid-tree.c +++ b/kernel-shared/uuid-tree.c @@ -154,7 +154,7 @@ int btrfs_uuid_tree_remove(struct btrfs_trans_handle *trans, u8 *uuid, u8 type, eb = path->nodes[0]; slot = path->slots[0]; offset = btrfs_item_ptr_offset(eb, slot); - item_size = btrfs_item_size_nr(eb, slot); + item_size = btrfs_item_size(eb, slot); if (!IS_ALIGNED(item_size, sizeof(u64))) { warning("uuid item with illegal size %u!", item_size); ret = -ENOENT; @@ -175,7 +175,7 @@ int btrfs_uuid_tree_remove(struct btrfs_trans_handle *trans, u8 *uuid, u8 type, goto out; } - item_size = btrfs_item_size_nr(eb, slot); + item_size = btrfs_item_size(eb, slot); if (item_size == sizeof(subid)) { ret = btrfs_del_item(trans, uuid_root, path); goto out; diff --git a/kernel-shared/volumes.c b/kernel-shared/volumes.c index 4274c378..e24428db 100644 --- a/kernel-shared/volumes.c +++ b/kernel-shared/volumes.c @@ -2103,9 +2103,9 @@ int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info, * one stripe, so no "==" check. */ if (slot >= 0 && - btrfs_item_size_nr(leaf, slot) < sizeof(struct btrfs_chunk)) { + btrfs_item_size(leaf, slot) < sizeof(struct btrfs_chunk)) { error("invalid chunk item size, have %u expect [%zu, %u)", - btrfs_item_size_nr(leaf, slot), + btrfs_item_size(leaf, slot), sizeof(struct btrfs_chunk), BTRFS_LEAF_DATA_SIZE(fs_info)); return -EUCLEAN; @@ -2122,9 +2122,9 @@ int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info, return -EUCLEAN; } if (slot >= 0 && btrfs_chunk_item_size(num_stripes) != - btrfs_item_size_nr(leaf, slot)) { + btrfs_item_size(leaf, slot)) { error("invalid chunk item size, have %u expect %lu", - btrfs_item_size_nr(leaf, slot), + btrfs_item_size(leaf, slot), btrfs_chunk_item_size(num_stripes)); return -EUCLEAN; } @@ -2184,7 +2184,7 @@ int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info, */ if (num_stripes < 1 || (slot == -1 && chunk_ondisk_size > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) || - (slot >= 0 && chunk_ondisk_size > btrfs_item_size_nr(leaf, slot))) { + (slot >= 0 && chunk_ondisk_size > btrfs_item_size(leaf, slot))) { error("invalid num_stripes: %u", num_stripes); return -EIO; } diff --git a/mkfs/common.c b/mkfs/common.c index 0ea0d114..11d92c8b 100644 --- a/mkfs/common.c +++ b/mkfs/common.c @@ -104,8 +104,8 @@ static int btrfs_create_tree_root(int fd, struct btrfs_mkfs_config *cfg, btrfs_set_disk_key_objectid(&disk_key, reference_root_table[blk]); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset_nr(buf, nritems, itemoff); - btrfs_set_item_size_nr(buf, nritems, sizeof(root_item)); + btrfs_set_item_offset(buf, nritems, itemoff); + btrfs_set_item_size(buf, nritems, sizeof(root_item)); if (blk == MKFS_FS_TREE) { time_t now = time(NULL); @@ -159,8 +159,8 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg, btrfs_set_disk_key_offset(&disk_key, group_size); btrfs_set_disk_key_type(&disk_key, BTRFS_FREE_SPACE_INFO_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset_nr(buf, nritems, itemoff); - btrfs_set_item_size_nr(buf, nritems, sizeof(*info)); + btrfs_set_item_offset(buf, nritems, itemoff); + btrfs_set_item_size(buf, nritems, sizeof(*info)); info = btrfs_item_ptr(buf, nritems, struct btrfs_free_space_info); btrfs_set_free_space_extent_count(buf, info, 1); @@ -171,8 +171,8 @@ static int create_free_space_tree(int fd, struct btrfs_mkfs_config *cfg, btrfs_set_disk_key_offset(&disk_key, group_start + group_size - free_start); btrfs_set_disk_key_type(&disk_key, BTRFS_FREE_SPACE_EXTENT_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset_nr(buf, nritems, itemoff); - btrfs_set_item_size_nr(buf, nritems, 0); + btrfs_set_item_offset(buf, nritems, itemoff); + btrfs_set_item_size(buf, nritems, 0); nritems++; btrfs_set_header_bytenr(buf, cfg->blocks[MKFS_FREE_SPACE_TREE]); @@ -340,8 +340,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, system_group_size); btrfs_set_disk_key_type(&disk_key, BTRFS_BLOCK_GROUP_ITEM_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset_nr(buf, nritems, itemoff); - btrfs_set_item_size_nr(buf, nritems, sizeof(*bg_item)); + btrfs_set_item_offset(buf, nritems, itemoff); + btrfs_set_item_size(buf, nritems, sizeof(*bg_item)); bg_item = btrfs_item_ptr(buf, nritems, struct btrfs_block_group_item); @@ -386,8 +386,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, cfg->nodesize); } btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset_nr(buf, nritems, itemoff); - btrfs_set_item_size_nr(buf, nritems, item_size); + btrfs_set_item_offset(buf, nritems, itemoff); + btrfs_set_item_size(buf, nritems, item_size); extent_item = btrfs_item_ptr(buf, nritems, struct btrfs_extent_item); btrfs_set_extent_refs(buf, extent_item, 1); @@ -402,8 +402,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, ref_root); btrfs_set_disk_key_type(&disk_key, BTRFS_TREE_BLOCK_REF_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset_nr(buf, nritems, itemoff); - btrfs_set_item_size_nr(buf, nritems, 0); + btrfs_set_item_offset(buf, nritems, itemoff); + btrfs_set_item_size(buf, nritems, 0); nritems++; } btrfs_set_header_bytenr(buf, cfg->blocks[MKFS_EXTENT_TREE]); @@ -430,8 +430,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, 1); btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_ITEM_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset_nr(buf, nritems, itemoff); - btrfs_set_item_size_nr(buf, nritems, item_size); + btrfs_set_item_offset(buf, nritems, itemoff); + btrfs_set_item_size(buf, nritems, item_size); dev_item = btrfs_item_ptr(buf, nritems, struct btrfs_dev_item); btrfs_set_device_id(buf, dev_item, 1); @@ -461,8 +461,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, system_group_offset); btrfs_set_disk_key_type(&disk_key, BTRFS_CHUNK_ITEM_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset_nr(buf, nritems, itemoff); - btrfs_set_item_size_nr(buf, nritems, item_size); + btrfs_set_item_offset(buf, nritems, itemoff); + btrfs_set_item_size(buf, nritems, item_size); chunk = btrfs_item_ptr(buf, nritems, struct btrfs_chunk); btrfs_set_chunk_length(buf, chunk, system_group_size); @@ -517,8 +517,8 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg) btrfs_set_disk_key_offset(&disk_key, system_group_offset); btrfs_set_disk_key_type(&disk_key, BTRFS_DEV_EXTENT_KEY); btrfs_set_item_key(buf, &disk_key, nritems); - btrfs_set_item_offset_nr(buf, nritems, itemoff); - btrfs_set_item_size_nr(buf, nritems, sizeof(struct btrfs_dev_extent)); + btrfs_set_item_offset(buf, nritems, itemoff); + btrfs_set_item_size(buf, nritems, sizeof(struct btrfs_dev_extent)); dev_extent = btrfs_item_ptr(buf, nritems, struct btrfs_dev_extent); btrfs_set_dev_extent_chunk_tree(buf, dev_extent, BTRFS_CHUNK_TREE_OBJECTID); From patchwork Tue Feb 22 22:26:21 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756015 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id EA8B1C433EF for ; Tue, 22 Feb 2022 22:26:44 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236055AbiBVW1J (ORCPT ); Tue, 22 Feb 2022 17:27:09 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59772 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236052AbiBVW1I (ORCPT ); Tue, 22 Feb 2022 17:27:08 -0500 Received: from mail-qk1-x734.google.com (mail-qk1-x734.google.com [IPv6:2607:f8b0:4864:20::734]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 388ED9FF8 for ; Tue, 22 Feb 2022 14:26:41 -0800 (PST) Received: by mail-qk1-x734.google.com with SMTP id t21so1850935qkg.6 for ; Tue, 22 Feb 2022 14:26:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=bOB2lcEZb2eLTcchXz6BHds8aEvX5FQU89ADLRQpoQA=; b=XGcVdTI9BufRQYyaw8EH6ZhzimFv/vhdLMyFYkE7MD6BT2u+d+z8OxtCjPnMKhMBhb UwJPEvYgitqU7WDQts/Y4yQbVI93hdDDRA6NNBF9B3zK81r7e3oMtYarViJ1kb68dymv 7CNlMMKLjMaRT/GOST0a2VyRR7qN5CyKeZgPMZCDlFiumbTQ834qN7vjvPUlxDoTEX75 ur2TQCSZhEOX9OIR7kpWlZZlQBQ+iIz4I6290Mj18LnZ0kTvLba46qZEKZ3Lv5InOta4 hppu7JTeEMDHLL7euTuuDy4sHbTfljlYSKbOwMPXUeuTzSeUHj2RHh3qOmkIgpQOlV8m d6Fw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=bOB2lcEZb2eLTcchXz6BHds8aEvX5FQU89ADLRQpoQA=; b=5VCjgnxouOE/K6Pp8ulg2LUxokypptt0OWR+7yQs/IGfffKbQueE7ByPKUi38ROrPk AUzMvQsQTUAvJyEnJJMKElMKxRzRN94cBzRM+24hKLbJ4e2UubLZQ2kz7smhCsVsScd7 GGpoKPO1feZT9SKHbvRxkPJBjcXdgSpzPyWk2TVFrjwkDr/07WTPIyadj/xBFueixboG peauM8JUHKTSZpw94k3jPWhTMtpMYFcS76ja4yEr5345oQA0+TkH3xhMC8fcn5PsKsAb +IuCXb//1Qcqdpk+CTAODvlFWi9yJhFwShOa+o3pfzg3fT3RcONJYnbozgaUfUS7kxsI GvDA== X-Gm-Message-State: AOAM532YypcKrI/j0QGift1S8+MHgKuCHShd8zrknsJ8GItNntHuXZM3 rRAY5l+jbIXSO6HELrsrjt2VULVseYw/yyUO X-Google-Smtp-Source: ABdhPJyVEM0qP8MDM2EjjLMe3DqC2WZrf4HJ25LFcPM7j33GJ4amPN7JUXqODQSQqOLZxmK4zBRzBA== X-Received: by 2002:a37:404:0:b0:60d:29dd:b22f with SMTP id 4-20020a370404000000b0060d29ddb22fmr16479561qke.589.1645568800145; Tue, 22 Feb 2022 14:26:40 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id a20sm816423qtx.6.2022.02.22.14.26.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:39 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 11/13] btrfs-progs: replace btrfs_item_nr_offset(0) Date: Tue, 22 Feb 2022 17:26:21 -0500 Message-Id: X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org btrfs_item_nr_offset(0) is simply offsetof(struct btrfs_leaf, items), which is the same thing as btrfs_leaf_data(), so replace all calls of btrfs_item_nr_offset(0) with btrfs_leaf_data(). Signed-off-by: Josef Bacik --- kernel-shared/ctree.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c index 04847cd5..e164492b 100644 --- a/kernel-shared/ctree.c +++ b/kernel-shared/ctree.c @@ -2075,11 +2075,11 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_leaf_data(left) + leaf_data_end(left), push_space); memmove_extent_buffer(right, btrfs_item_nr_offset(push_items), - btrfs_item_nr_offset(0), + btrfs_leaf_data(right), right_nritems * sizeof(struct btrfs_item)); /* copy the items from left to right */ - copy_extent_buffer(right, left, btrfs_item_nr_offset(0), + copy_extent_buffer(right, left, btrfs_leaf_data(right), btrfs_item_nr_offset(left_nritems - push_items), push_items * sizeof(struct btrfs_item)); @@ -2198,7 +2198,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root /* push data from right to left */ copy_extent_buffer(left, right, btrfs_item_nr_offset(btrfs_header_nritems(left)), - btrfs_item_nr_offset(0), + btrfs_leaf_data(right), push_items * sizeof(struct btrfs_item)); push_space = BTRFS_LEAF_DATA_SIZE(root->fs_info) - @@ -2238,7 +2238,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root btrfs_leaf_data(right) + leaf_data_end(right), push_space); - memmove_extent_buffer(right, btrfs_item_nr_offset(0), + memmove_extent_buffer(right, btrfs_leaf_data(right), btrfs_item_nr_offset(push_items), (btrfs_header_nritems(right) - push_items) * sizeof(struct btrfs_item)); @@ -2296,7 +2296,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, btrfs_set_header_nritems(right, nritems); data_copy_size = btrfs_item_end(l, mid) - leaf_data_end(l); - copy_extent_buffer(right, l, btrfs_item_nr_offset(0), + copy_extent_buffer(right, l, btrfs_leaf_data(right), btrfs_item_nr_offset(mid), nritems * sizeof(struct btrfs_item)); From patchwork Tue Feb 22 22:26:22 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756016 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 68C95C433F5 for ; Tue, 22 Feb 2022 22:26:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236058AbiBVW1K (ORCPT ); Tue, 22 Feb 2022 17:27:10 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59902 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236059AbiBVW1J (ORCPT ); Tue, 22 Feb 2022 17:27:09 -0500 Received: from mail-qk1-x733.google.com (mail-qk1-x733.google.com [IPv6:2607:f8b0:4864:20::733]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2D4D42716B for ; Tue, 22 Feb 2022 14:26:43 -0800 (PST) Received: by mail-qk1-x733.google.com with SMTP id z66so1833886qke.10 for ; Tue, 22 Feb 2022 14:26:43 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=W5JgDZ47PpKoS6/RBeTTl9F5vSjrYJh0ABGY/tAhVo4=; b=T2paVEZ58A6UuSpF3DekoCC2AU2bs3b0Ch6zApipJPsgALyBiv73smbETxZ7Nyltfv Pd12IEShHkFbgnZlzEx9hQ9SfF+GG6/yAPoNXntCfEa19V8i0wMvIlKvvLl7LY2J22Nw f/R9N2OBKRCfYoCBD0eu4Uis8NJHJGLgV8cdjVdawkgknTyD5L3KRmSs4HNoohDPdLqV z9r03DtX9RSbr4weQHPif/DTuNCPj+TIlcETml8LQh4AbGfcqtzOF2jlcWrs4QQd6R4i JSaKFbrzLoh9XKn4mnP+ef+rtd+VkDaUCLOfNHvagqrNc7yAKGWXfNdDGg/LV/ELCp4X oZwg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=W5JgDZ47PpKoS6/RBeTTl9F5vSjrYJh0ABGY/tAhVo4=; b=4D4XOIM6MaLCDKHltsdncaFfPpMfQgGTIlJxz4rTw2kz7tkNadLxI4a5i9LRMx9xf0 Vc2+14LWSa4uYdKSoYkQd9/fguYwEHBfguvhkpp8YpvzR4sNtGW3tPeH9VkP90VFsXfD D/pENWzNZChlB8/2j1fZjZtY/ya/dxe5InafP6u3YGfiFSCcZFP8HtgWu94QoiGZolKN PFRWcQnLsV2HQePRm6LCENeW7DipyCVdWmsCG2yBWEknipr2eQis14AUnf51HuFP3uxu zrtAWpmxP/M4TZON085M1gmsMMB054IrOjrhErEjq+iejaXWeMJ5ZwE2KZSy03vCUSIz iF5A== X-Gm-Message-State: AOAM530BbVrFzSuA4ZWhbgp4uCPyGkvcWsqi3JiJXt4kuOYH7Go6XGLB T1aDGf3Cg+JoijFAAIBrxOSkgv20Z0/7skZ3 X-Google-Smtp-Source: ABdhPJzfboFo/WAafGhzcLKtVHmhp66B4kC8NOWG/IoD2Gb+eROeBSFGZYM+S+U3R+7viYNsbqo3IQ== X-Received: by 2002:a05:620a:1a08:b0:648:ac5c:37eb with SMTP id bk8-20020a05620a1a0800b00648ac5c37ebmr11275700qkb.49.1645568802032; Tue, 22 Feb 2022 14:26:42 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id t19sm816035qtx.68.2022.02.22.14.26.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:41 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 12/13] btrfs-progs: rework the btrfs_node accessors to match the item accessors Date: Tue, 22 Feb 2022 17:26:22 -0500 Message-Id: <0e2f3e99b79aa4502f5ef94e2b9c42f2c99cc20e.1645568701.git.josef@toxicpanda.com> X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org We are duplicating the offsetof(btrfs_node, key_ptr) logic everywhere, instead use the helper to do this work for us, and make all the node accessors use the helper. Signed-off-by: Josef Bacik --- kernel-shared/ctree.h | 49 +++++++++++++++++-------------------------- 1 file changed, 19 insertions(+), 30 deletions(-) diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h index 8b654dde..464a0f74 100644 --- a/kernel-shared/ctree.h +++ b/kernel-shared/ctree.h @@ -1921,62 +1921,51 @@ BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32); BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64); BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64); -static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr) +static inline unsigned long btrfs_node_key_ptr_offset(int nr) { - unsigned long ptr; - ptr = offsetof(struct btrfs_node, ptrs) + + return offsetof(struct btrfs_node, ptrs) + sizeof(struct btrfs_key_ptr) * nr; - return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr); +} + +static inline struct btrfs_key_ptr *btrfs_node_key_ptr(int nr) +{ + return (struct btrfs_key_ptr *)btrfs_node_key_ptr_offset(nr); +} + +static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr) +{ + return btrfs_key_blockptr(eb, btrfs_node_key_ptr(nr)); } static inline void btrfs_set_node_blockptr(struct extent_buffer *eb, int nr, u64 val) { - unsigned long ptr; - ptr = offsetof(struct btrfs_node, ptrs) + - sizeof(struct btrfs_key_ptr) * nr; - btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val); + btrfs_set_key_blockptr(eb, btrfs_node_key_ptr(nr), val); } static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr) { - unsigned long ptr; - ptr = offsetof(struct btrfs_node, ptrs) + - sizeof(struct btrfs_key_ptr) * nr; - return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr); + return btrfs_key_generation(eb, btrfs_node_key_ptr(nr)); } static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb, int nr, u64 val) { - unsigned long ptr; - ptr = offsetof(struct btrfs_node, ptrs) + - sizeof(struct btrfs_key_ptr) * nr; - btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val); -} - -static inline unsigned long btrfs_node_key_ptr_offset(int nr) -{ - return offsetof(struct btrfs_node, ptrs) + - sizeof(struct btrfs_key_ptr) * nr; + btrfs_set_key_generation(eb, btrfs_node_key_ptr(nr), val); } static inline void btrfs_node_key(struct extent_buffer *eb, struct btrfs_disk_key *disk_key, int nr) { - unsigned long ptr; - ptr = btrfs_node_key_ptr_offset(nr); - read_eb_member(eb, (struct btrfs_key_ptr *)ptr, - struct btrfs_key_ptr, key, disk_key); + read_eb_member(eb, btrfs_node_key_ptr(nr), struct btrfs_key_ptr, key, + disk_key); } static inline void btrfs_set_node_key(struct extent_buffer *eb, struct btrfs_disk_key *disk_key, int nr) { - unsigned long ptr; - ptr = btrfs_node_key_ptr_offset(nr); - write_eb_member(eb, (struct btrfs_key_ptr *)ptr, - struct btrfs_key_ptr, key, disk_key); + write_eb_member(eb, btrfs_node_key_ptr(nr), struct btrfs_key_ptr, key, + disk_key); } /* struct btrfs_item */ From patchwork Tue Feb 22 22:26:23 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12756017 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id DB59DC433EF for ; Tue, 22 Feb 2022 22:26:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236061AbiBVW1M (ORCPT ); Tue, 22 Feb 2022 17:27:12 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60022 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236060AbiBVW1L (ORCPT ); Tue, 22 Feb 2022 17:27:11 -0500 Received: from mail-qk1-x72f.google.com (mail-qk1-x72f.google.com [IPv6:2607:f8b0:4864:20::72f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 773C328E34 for ; Tue, 22 Feb 2022 14:26:44 -0800 (PST) Received: by mail-qk1-x72f.google.com with SMTP id f21so1811648qke.13 for ; Tue, 22 Feb 2022 14:26:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=4nTG3Ay0j0spW8TQ5AFMUYyjIXQWQqaI1siQeX8CDL4=; b=memKFjThRYOSTr2gzsiW+sntvYYlIZeR82xiWeP5CHC2oF+294wg+wo1zzr230ec0G 630M06RvH4eF8xLouBYXvhOemehatWdDjSnyZ4HSYXzwT0HG/tzMN9CRVsImgYpeNEWp K4Bl9wNHOAk7leKCpTJusPxE/cM316wzHoPqam7S2izzZJmkRl0DrnY8HB+W3YvwzpBK AeadzN1X29VM5T+1F8+5UmrZI0u3lKF8A9kCw5jtLyQVZc0RLdHBGKD8PY6pXvphGLsT 7n6fFDWJbgIdtz4lJ1l+kzWAVDcBlhV8DvofGukdR48icdaZdhwsQrRu0C8UPxuz5kUp bLFw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=4nTG3Ay0j0spW8TQ5AFMUYyjIXQWQqaI1siQeX8CDL4=; b=te3L1GdYLtjrzxV1kWF7x3pdNRW21v1PyavhehNHR2+MF9dFyRd1KTqgVtKkiqj3hR VLi6g8VMhf76hY9aL7xB+OOhS0nUtXYPT6A+rHSjaGZTZQq4B62vSADt4GNSlf/E0OHu fJ/Cebmhrhb4JGvRoUAC7oCer7PoRuSPQMi2QX8k18BZ76hkFLQ3fh0xySV0UXGfmIjq 6MyE7MqEJ9zXyZafq9ncAqSkVtW6AOu0Asx1nKr4M9ipDBw4A/1PcVxpt49dDzTYiwjL 9rZ4lWgzAhkMj4zbX8kBhQRJnPcHYOCoo4uE9gcysWL46FK4KUEebKa7IRQWz655RX1+ tFSA== X-Gm-Message-State: AOAM530bM7lU61STA5Dk8nYTO95Kvc0quHlUfvxVbXU5/i4v6lOiImPl JaOND6jscnW/c1yCyLQgB3yjKFK7LoGQRA37 X-Google-Smtp-Source: ABdhPJwUd2jbtr9YjdiFExH7rwuZLpymjGDAQqD/j7VrF2JoyjtsSkIyViXu0YF4xWHIDJdMb02EiA== X-Received: by 2002:a37:45d3:0:b0:47a:645e:137f with SMTP id s202-20020a3745d3000000b0047a645e137fmr16880335qka.535.1645568803285; Tue, 22 Feb 2022 14:26:43 -0800 (PST) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id f16sm799485qtk.8.2022.02.22.14.26.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Feb 2022 14:26:42 -0800 (PST) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH 13/13] btrfs-progs: make all of the item/key_ptr offset helpers take an eb Date: Tue, 22 Feb 2022 17:26:23 -0500 Message-Id: X-Mailer: git-send-email 2.26.3 In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-btrfs@vger.kernel.org When we change the size of the btrfs_header we're going to need to change how these helpers calculate where to find the start of items or block ptrs. To prepare for that make these helpers take the extent_buffer as an argument so we can do the appropriate math based on the version type. Signed-off-by: Josef Bacik --- check/main.c | 13 ++++++----- image/main.c | 4 ++-- kernel-shared/ctree.c | 54 +++++++++++++++++++++---------------------- kernel-shared/ctree.h | 36 ++++++++++++++--------------- 4 files changed, 54 insertions(+), 53 deletions(-) diff --git a/check/main.c b/check/main.c index ed3fde60..39cb1ce5 100644 --- a/check/main.c +++ b/check/main.c @@ -4192,16 +4192,17 @@ static int swap_values(struct btrfs_root *root, struct btrfs_path *path, if (btrfs_header_level(buf)) { struct btrfs_key_ptr ptr1, ptr2; - read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot), + read_extent_buffer(buf, &ptr1, + btrfs_node_key_ptr_offset(buf, slot), sizeof(struct btrfs_key_ptr)); read_extent_buffer(buf, &ptr2, - btrfs_node_key_ptr_offset(slot + 1), + btrfs_node_key_ptr_offset(buf, slot + 1), sizeof(struct btrfs_key_ptr)); write_extent_buffer(buf, &ptr1, - btrfs_node_key_ptr_offset(slot + 1), + btrfs_node_key_ptr_offset(buf, slot + 1), sizeof(struct btrfs_key_ptr)); write_extent_buffer(buf, &ptr2, - btrfs_node_key_ptr_offset(slot), + btrfs_node_key_ptr_offset(buf, slot), sizeof(struct btrfs_key_ptr)); if (slot == 0) { struct btrfs_disk_key key; @@ -4299,8 +4300,8 @@ static int delete_bogus_item(struct btrfs_root *root, printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n", (unsigned long long)key.objectid, key.type, (unsigned long long)key.offset, slot, buf->start); - memmove_extent_buffer(buf, btrfs_item_nr_offset(slot), - btrfs_item_nr_offset(slot + 1), + memmove_extent_buffer(buf, btrfs_item_nr_offset(buf, slot), + btrfs_item_nr_offset(buf, slot + 1), sizeof(struct btrfs_item) * (nritems - slot - 1)); btrfs_set_header_nritems(buf, nritems - 1); diff --git a/image/main.c b/image/main.c index ff121fca..c6af0cc2 100644 --- a/image/main.c +++ b/image/main.c @@ -360,8 +360,8 @@ static void copy_buffer(struct metadump_struct *md, u8 *dst, } else if (level == 0) { size = btrfs_leaf_data(src) + btrfs_item_offset(src, nritems - 1) - - btrfs_item_nr_offset(nritems); - memset(dst + btrfs_item_nr_offset(nritems), 0, size); + btrfs_item_nr_offset(src, nritems); + memset(dst + btrfs_item_nr_offset(src, nritems), 0, size); zero_items(md, dst, src); } else { size = offsetof(struct btrfs_node, ptrs) + diff --git a/kernel-shared/ctree.c b/kernel-shared/ctree.c index e164492b..758a3882 100644 --- a/kernel-shared/ctree.c +++ b/kernel-shared/ctree.c @@ -756,10 +756,10 @@ btrfs_check_leaf(struct btrfs_fs_info *fs_info, /* Also check if the item pointer overlaps with btrfs item. */ if (btrfs_item_ptr_offset(leaf, slot) < - btrfs_item_nr_offset(slot) + sizeof(struct btrfs_item)) { + btrfs_item_nr_offset(leaf, slot) + sizeof(struct btrfs_item)) { generic_err(leaf, slot, "slot overlaps with its data, item end %lu data start %lu", - btrfs_item_nr_offset(slot) + + btrfs_item_nr_offset(leaf, slot) + sizeof(struct btrfs_item), btrfs_item_ptr_offset(leaf, slot)); ret = BTRFS_TREE_BLOCK_INVALID_OFFSETS; @@ -1638,13 +1638,13 @@ static int push_node_left(struct btrfs_trans_handle *trans, push_items = min(src_nritems - 8, push_items); copy_extent_buffer(dst, src, - btrfs_node_key_ptr_offset(dst_nritems), - btrfs_node_key_ptr_offset(0), + btrfs_node_key_ptr_offset(dst, dst_nritems), + btrfs_node_key_ptr_offset(src, 0), push_items * sizeof(struct btrfs_key_ptr)); if (push_items < src_nritems) { - memmove_extent_buffer(src, btrfs_node_key_ptr_offset(0), - btrfs_node_key_ptr_offset(push_items), + memmove_extent_buffer(src, btrfs_node_key_ptr_offset(src, 0), + btrfs_node_key_ptr_offset(src, push_items), (src_nritems - push_items) * sizeof(struct btrfs_key_ptr)); } @@ -1699,14 +1699,14 @@ static int balance_node_right(struct btrfs_trans_handle *trans, if (max_push < push_items) push_items = max_push; - memmove_extent_buffer(dst, btrfs_node_key_ptr_offset(push_items), - btrfs_node_key_ptr_offset(0), + memmove_extent_buffer(dst, btrfs_node_key_ptr_offset(dst, push_items), + btrfs_node_key_ptr_offset(dst, 0), (dst_nritems) * sizeof(struct btrfs_key_ptr)); copy_extent_buffer(dst, src, - btrfs_node_key_ptr_offset(0), - btrfs_node_key_ptr_offset(src_nritems - push_items), + btrfs_node_key_ptr_offset(dst, 0), + btrfs_node_key_ptr_offset(src, src_nritems - push_items), push_items * sizeof(struct btrfs_key_ptr)); btrfs_set_header_nritems(src, src_nritems - push_items); @@ -1816,8 +1816,8 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root if (slot < nritems) { /* shift the items */ memmove_extent_buffer(lower, - btrfs_node_key_ptr_offset(slot + 1), - btrfs_node_key_ptr_offset(slot), + btrfs_node_key_ptr_offset(lower, slot + 1), + btrfs_node_key_ptr_offset(lower, slot), (nritems - slot) * sizeof(struct btrfs_key_ptr)); } btrfs_set_node_key(lower, key, slot); @@ -1891,8 +1891,8 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root root_add_used(root, root->fs_info->nodesize); copy_extent_buffer(split, c, - btrfs_node_key_ptr_offset(0), - btrfs_node_key_ptr_offset(mid), + btrfs_node_key_ptr_offset(split, 0), + btrfs_node_key_ptr_offset(c, mid), (c_nritems - mid) * sizeof(struct btrfs_key_ptr)); btrfs_set_header_nritems(split, c_nritems - mid); btrfs_set_header_nritems(c, mid); @@ -2074,13 +2074,13 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root BTRFS_LEAF_DATA_SIZE(root->fs_info) - push_space, btrfs_leaf_data(left) + leaf_data_end(left), push_space); - memmove_extent_buffer(right, btrfs_item_nr_offset(push_items), + memmove_extent_buffer(right, btrfs_item_nr_offset(right, push_items), btrfs_leaf_data(right), right_nritems * sizeof(struct btrfs_item)); /* copy the items from left to right */ copy_extent_buffer(right, left, btrfs_leaf_data(right), - btrfs_item_nr_offset(left_nritems - push_items), + btrfs_item_nr_offset(left, left_nritems - push_items), push_items * sizeof(struct btrfs_item)); /* update the item pointers */ @@ -2197,7 +2197,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root /* push data from right to left */ copy_extent_buffer(left, right, - btrfs_item_nr_offset(btrfs_header_nritems(left)), + btrfs_item_nr_offset(left, btrfs_header_nritems(left)), btrfs_leaf_data(right), push_items * sizeof(struct btrfs_item)); @@ -2239,7 +2239,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root leaf_data_end(right), push_space); memmove_extent_buffer(right, btrfs_leaf_data(right), - btrfs_item_nr_offset(push_items), + btrfs_item_nr_offset(right, push_items), (btrfs_header_nritems(right) - push_items) * sizeof(struct btrfs_item)); } @@ -2297,7 +2297,7 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, data_copy_size = btrfs_item_end(l, mid) - leaf_data_end(l); copy_extent_buffer(right, l, btrfs_leaf_data(right), - btrfs_item_nr_offset(mid), + btrfs_item_nr_offset(l, mid), nritems * sizeof(struct btrfs_item)); copy_extent_buffer(right, l, @@ -2576,8 +2576,8 @@ split: if (slot < nritems) { /* shift the items */ - memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + 1), - btrfs_item_nr_offset(slot), + memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, slot + 1), + btrfs_item_nr_offset(leaf, slot), (nritems - slot) * sizeof(struct btrfs_item)); } @@ -2836,8 +2836,8 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, } /* shift the items */ - memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr), - btrfs_item_nr_offset(slot), + memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, slot + nr), + btrfs_item_nr_offset(leaf, slot), (nritems - slot) * sizeof(struct btrfs_item)); /* shift the data */ @@ -2919,8 +2919,8 @@ int btrfs_del_ptr(struct btrfs_root *root, struct btrfs_path *path, if (slot < nritems - 1) { /* shift the items */ memmove_extent_buffer(parent, - btrfs_node_key_ptr_offset(slot), - btrfs_node_key_ptr_offset(slot + 1), + btrfs_node_key_ptr_offset(parent, slot), + btrfs_node_key_ptr_offset(parent, slot + 1), sizeof(struct btrfs_key_ptr) * (nritems - slot - 1)); } @@ -3007,8 +3007,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, btrfs_set_item_offset(leaf, i, ioff + dsize); } - memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot), - btrfs_item_nr_offset(slot + nr), + memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, slot), + btrfs_item_nr_offset(leaf, slot + nr), sizeof(struct btrfs_item) * (nritems - slot - nr)); } diff --git a/kernel-shared/ctree.h b/kernel-shared/ctree.h index 464a0f74..addfafc7 100644 --- a/kernel-shared/ctree.h +++ b/kernel-shared/ctree.h @@ -1921,77 +1921,77 @@ BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32); BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64); BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64); -static inline unsigned long btrfs_node_key_ptr_offset(int nr) +static inline unsigned long btrfs_node_key_ptr_offset(const struct extent_buffer *eb, int nr) { return offsetof(struct btrfs_node, ptrs) + sizeof(struct btrfs_key_ptr) * nr; } -static inline struct btrfs_key_ptr *btrfs_node_key_ptr(int nr) +static inline struct btrfs_key_ptr *btrfs_node_key_ptr(const struct extent_buffer *eb, int nr) { - return (struct btrfs_key_ptr *)btrfs_node_key_ptr_offset(nr); + return (struct btrfs_key_ptr *)btrfs_node_key_ptr_offset(eb, nr); } static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr) { - return btrfs_key_blockptr(eb, btrfs_node_key_ptr(nr)); + return btrfs_key_blockptr(eb, btrfs_node_key_ptr(eb, nr)); } static inline void btrfs_set_node_blockptr(struct extent_buffer *eb, int nr, u64 val) { - btrfs_set_key_blockptr(eb, btrfs_node_key_ptr(nr), val); + btrfs_set_key_blockptr(eb, btrfs_node_key_ptr(eb, nr), val); } static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr) { - return btrfs_key_generation(eb, btrfs_node_key_ptr(nr)); + return btrfs_key_generation(eb, btrfs_node_key_ptr(eb, nr)); } static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb, int nr, u64 val) { - btrfs_set_key_generation(eb, btrfs_node_key_ptr(nr), val); + btrfs_set_key_generation(eb, btrfs_node_key_ptr(eb, nr), val); } static inline void btrfs_node_key(struct extent_buffer *eb, struct btrfs_disk_key *disk_key, int nr) { - read_eb_member(eb, btrfs_node_key_ptr(nr), struct btrfs_key_ptr, key, - disk_key); + read_eb_member(eb, btrfs_node_key_ptr(eb, nr), struct btrfs_key_ptr, + key, disk_key); } static inline void btrfs_set_node_key(struct extent_buffer *eb, struct btrfs_disk_key *disk_key, int nr) { - write_eb_member(eb, btrfs_node_key_ptr(nr), struct btrfs_key_ptr, key, - disk_key); + write_eb_member(eb, btrfs_node_key_ptr(eb, nr), struct btrfs_key_ptr, + key, disk_key); } /* struct btrfs_item */ BTRFS_SETGET_FUNCS(raw_item_offset, struct btrfs_item, offset, 32); BTRFS_SETGET_FUNCS(raw_item_size, struct btrfs_item, size, 32); -static inline unsigned long btrfs_item_nr_offset(int nr) +static inline unsigned long btrfs_item_nr_offset(const struct extent_buffer *eb, int nr) { return offsetof(struct btrfs_leaf, items) + sizeof(struct btrfs_item) * nr; } -static inline struct btrfs_item *btrfs_item_nr(int nr) +static inline struct btrfs_item *btrfs_item_nr(const struct extent_buffer *eb, int nr) { - return (struct btrfs_item *)btrfs_item_nr_offset(nr); + return (struct btrfs_item *)btrfs_item_nr_offset(eb, nr); } #define BTRFS_ITEM_SETGET_FUNCS(member) \ static inline u32 btrfs_item_##member(const struct extent_buffer *eb, int slot) \ { \ - return btrfs_raw_item_##member(eb, btrfs_item_nr(slot)); \ + return btrfs_raw_item_##member(eb, btrfs_item_nr(eb, slot)); \ } \ static inline void btrfs_set_item_##member(struct extent_buffer *eb, \ int slot, u32 val) \ { \ - btrfs_set_raw_item_##member(eb, btrfs_item_nr(slot), val); \ + btrfs_set_raw_item_##member(eb, btrfs_item_nr(eb, slot), val); \ } BTRFS_ITEM_SETGET_FUNCS(size) @@ -2005,14 +2005,14 @@ static inline u32 btrfs_item_end(struct extent_buffer *eb, int nr) static inline void btrfs_item_key(struct extent_buffer *eb, struct btrfs_disk_key *disk_key, int nr) { - struct btrfs_item *item = btrfs_item_nr(nr); + struct btrfs_item *item = btrfs_item_nr(eb, nr); read_eb_member(eb, item, struct btrfs_item, key, disk_key); } static inline void btrfs_set_item_key(struct extent_buffer *eb, struct btrfs_disk_key *disk_key, int nr) { - struct btrfs_item *item = btrfs_item_nr(nr); + struct btrfs_item *item = btrfs_item_nr(eb, nr); write_eb_member(eb, item, struct btrfs_item, key, disk_key); }