From patchwork Fri Sep 9 21:53: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: 12972188 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 73E2FECAAD3 for ; Fri, 9 Sep 2022 21:53:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231742AbiIIVx4 (ORCPT ); Fri, 9 Sep 2022 17:53:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57926 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229690AbiIIVxz (ORCPT ); Fri, 9 Sep 2022 17:53:55 -0400 Received: from mail-qt1-x832.google.com (mail-qt1-x832.google.com [IPv6:2607:f8b0:4864:20::832]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2DEB7F913B for ; Fri, 9 Sep 2022 14:53:54 -0700 (PDT) Received: by mail-qt1-x832.google.com with SMTP id r20so1644967qtn.12 for ; Fri, 09 Sep 2022 14:53:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=9lhOBWAtwRXXN1xkbQc+GDl6n3yAIaM6dUgf7ugdbx0=; b=LJ9pRJ4U2tRqY0EESS/x2oNRwxKpafD3Xl50cREVynHp5Z7uYl3lonJm2Xg0JvfYH2 bTjyi9eYIlEKmXUJn4sqgyGhUAjNpn9hg+Mzt8/eum7kEhShw2NnqcOaa4IzAtDNeuE/ PD1IuXyftBypoGT3nPbVY16Firf1rUxE20RPDOupxDmO+2cqpN3B5STiSiRgnbd+gqJp KAHFv00qDEx86B08C9jlX/bK/e4MZjCRDwXfiQdBTUGkdy7LporfmgV4Pg3oqL1oWprr 3Dzk35oXxgkSgufuC5ARqpOMf31gfu9jvpV2ygSBgym0A1etp0ur67KitVACrj+46IoK F6pA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=9lhOBWAtwRXXN1xkbQc+GDl6n3yAIaM6dUgf7ugdbx0=; b=Kb8DlOtB5t4O9Ybe+jD9fObEIO9GFTiCLh6cy6G9nY63uYWwZa5gzoWoYptVnNbnKI EFJiOSSgQGe5LMdKW5O1UOUd5jxfkTqglFwjHAWvZF6fKqAhiaInvGe7Fh1O0PEptRGb roI/s/x21il8qZDFqa96bPxoVnhvqagOD8pgvSpG8pUjqtphnFsGfHGiJD6dYl+YTuAo Fr9+zLeFH8Du1+TlHHKllUlRsH+IA3GFtNX0d5rnb/2EJ3Q3v8bjRhm/TFyuqSeJnntb jvimufMY470gOwOpk0JhIkJnNe7mF5Mo0ktSrWc8PHB7MgWCo0ZrNorRydWXpM2KSD71 xWAg== X-Gm-Message-State: ACgBeo3aMPlhZQNZIzY/lpuH1oLp6P+gH3iL9DRBPKYNhaKap3huNFqF FwtGE30JCd9kZWxyjgvqB5aOOpEb86JRgA== X-Google-Smtp-Source: AA6agR5YwVthWKwtgyz17nmmiHTseKARliS+J0YiTKHV0aDaXH5tJodLVcQCE9mTfc/+kD/Pmcud8Q== X-Received: by 2002:a05:622a:13cd:b0:344:7bcd:4411 with SMTP id p13-20020a05622a13cd00b003447bcd4411mr14141351qtk.644.1662760432969; Fri, 09 Sep 2022 14:53:52 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id fe10-20020a05622a4d4a00b0035ba2f6d081sm1126888qtb.88.2022.09.09.14.53.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:53:52 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 01/36] btrfs: rename clean_io_failure and remove extraneous args Date: Fri, 9 Sep 2022 17:53:14 -0400 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 is exported, so rename it to btrfs_clean_io_failure. Additionally we are passing in the io tree's and such from the inode, so instead of doing all that simply pass in the inode itself and get all the components we need directly inside of btrfs_clean_io_failure. Signed-off-by: Josef Bacik Reviewed-by: Johannes Thumshirn --- fs/btrfs/compression.c | 5 ++--- fs/btrfs/extent-io-tree.h | 6 ++---- fs/btrfs/extent_io.c | 17 +++++++---------- fs/btrfs/inode.c | 7 ++----- 4 files changed, 13 insertions(+), 22 deletions(-) diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c index 1c77de3239bc..cac0eeceb815 100644 --- a/fs/btrfs/compression.c +++ b/fs/btrfs/compression.c @@ -183,9 +183,8 @@ static void end_compressed_bio_read(struct btrfs_bio *bbio) if (!status && (!csum || !btrfs_check_data_csum(inode, bbio, offset, bv.bv_page, bv.bv_offset))) { - clean_io_failure(fs_info, &bi->io_failure_tree, - &bi->io_tree, start, bv.bv_page, - btrfs_ino(bi), bv.bv_offset); + btrfs_clean_io_failure(bi, start, bv.bv_page, + bv.bv_offset); } else { int ret; diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index ec2f8b8e6faa..bb71b4a69022 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -256,9 +256,7 @@ void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start, int free_io_failure(struct extent_io_tree *failure_tree, struct extent_io_tree *io_tree, struct io_failure_record *rec); -int clean_io_failure(struct btrfs_fs_info *fs_info, - struct extent_io_tree *failure_tree, - struct extent_io_tree *io_tree, u64 start, - struct page *page, u64 ino, unsigned int pg_offset); +int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, + struct page *page, unsigned int pg_offset); #endif /* BTRFS_EXTENT_IO_TREE_H */ diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index cea7d09c2dc1..5ee8b5be636d 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -2431,11 +2431,13 @@ static int prev_mirror(const struct io_failure_record *failrec, int cur_mirror) * each time an IO finishes, we do a fast check in the IO failure tree * to see if we need to process or clean up an io_failure_record */ -int clean_io_failure(struct btrfs_fs_info *fs_info, - struct extent_io_tree *failure_tree, - struct extent_io_tree *io_tree, u64 start, - struct page *page, u64 ino, unsigned int pg_offset) +int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, + struct page *page, unsigned int pg_offset) { + struct btrfs_fs_info *fs_info = inode->root->fs_info; + struct extent_io_tree *failure_tree = &inode->io_failure_tree; + struct extent_io_tree *io_tree = &inode->io_tree; + u64 ino = btrfs_ino(inode); u64 private; struct io_failure_record *failrec; struct extent_state *state; @@ -2963,7 +2965,6 @@ static void end_bio_extent_readpage(struct btrfs_bio *bbio) { struct bio *bio = &bbio->bio; struct bio_vec *bvec; - struct extent_io_tree *tree, *failure_tree; struct processed_extent processed = { 0 }; /* * The offset to the beginning of a bio, since one bio can never be @@ -2990,8 +2991,6 @@ static void end_bio_extent_readpage(struct btrfs_bio *bbio) "end_bio_extent_readpage: bi_sector=%llu, err=%d, mirror=%u", bio->bi_iter.bi_sector, bio->bi_status, bbio->mirror_num); - tree = &BTRFS_I(inode)->io_tree; - failure_tree = &BTRFS_I(inode)->io_failure_tree; /* * We always issue full-sector reads, but if some block in a @@ -3032,9 +3031,7 @@ static void end_bio_extent_readpage(struct btrfs_bio *bbio) loff_t i_size = i_size_read(inode); pgoff_t end_index = i_size >> PAGE_SHIFT; - clean_io_failure(BTRFS_I(inode)->root->fs_info, - failure_tree, tree, start, page, - btrfs_ino(BTRFS_I(inode)), 0); + btrfs_clean_io_failure(BTRFS_I(inode), start, page, 0); /* * Zero out the remaining part if this range straddles diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 10849db7f3a5..548665299e57 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -7869,8 +7869,6 @@ static blk_status_t btrfs_check_read_dio_bio(struct btrfs_dio_private *dip, { struct inode *inode = dip->inode; struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; - struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree; - struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM); blk_status_t err = BLK_STS_OK; struct bvec_iter iter; @@ -7883,9 +7881,8 @@ static blk_status_t btrfs_check_read_dio_bio(struct btrfs_dio_private *dip, if (uptodate && (!csum || !btrfs_check_data_csum(inode, bbio, offset, bv.bv_page, bv.bv_offset))) { - clean_io_failure(fs_info, failure_tree, io_tree, start, - bv.bv_page, btrfs_ino(BTRFS_I(inode)), - bv.bv_offset); + btrfs_clean_io_failure(BTRFS_I(inode), start, + bv.bv_page, bv.bv_offset); } else { int ret; From patchwork Fri Sep 9 21:53: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: 12972189 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 827A1ECAAD5 for ; Fri, 9 Sep 2022 21:53:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231754AbiIIVx5 (ORCPT ); Fri, 9 Sep 2022 17:53:57 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57944 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231752AbiIIVx4 (ORCPT ); Fri, 9 Sep 2022 17:53:56 -0400 Received: from mail-qt1-x832.google.com (mail-qt1-x832.google.com [IPv6:2607:f8b0:4864:20::832]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A1A4AF651D for ; Fri, 9 Sep 2022 14:53:55 -0700 (PDT) Received: by mail-qt1-x832.google.com with SMTP id r6so2344273qtx.6 for ; Fri, 09 Sep 2022 14:53:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=7jGBXCtrgUnh5/1FxVC7N8Uh5dkFu9GRNKiXChcgn94=; b=ImCnNIBpYj0YjelRLe1AmDmeuT4OZfQMR5+Wdl0AWhbWH5OSVGg1Uo6QehFnNhDSDw uwIt8F2rFWRuCueyl1B04yCWVangk6wCazR4VdxKfBnKxacIj+aHK1dD/FC6ir8+7Irf q5L+kl0yb5SmFnE+jS7DwyVdbTI5Sc4nyiAFyBZF1SFUsF9gt2kH6pk5igSxZUyZ5fwy ulzsHV+0gjIbIko9bEUBrmn8HJBQAYCuRtptzxcugneqnzFS0sXLJFWPNpxl0NPmg/1E uYVl4mNrpwIkKbs3Bc3ecb5wU7q/b0buw/hz2F4RZDdEuA3DiTUH1WOmghnKobNvwvkj D/xA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=7jGBXCtrgUnh5/1FxVC7N8Uh5dkFu9GRNKiXChcgn94=; b=yhmwOJlW47rwjLEryUhawYOSmVyv/9wMMF5+GKyrrlqyPEeSeYfQVPkiV4/U8We6nc /k2WL5l4dndPofTawK0juloyRoapBLPRmSNRcgVNf7vF9CGaPH28/1G2HJdhYmRBbrvf aKPljlTJTaBAAW3bS5GMPsgCPI8KP39C8+KPL410yaHsbC53PPLSpjFVSkfaYINqkoa7 JcGDCiSo3gCSAsyxdx1jv3ScBDDTIIpis6vXbLbiPiT6yhKCkmb3I/wOdaOc5J0W2ZlO Utu70CrgUKinV4VLShJWcqWjvRwvBNB1raxD39tlmndyTgYzu28uDz4OTI9EbI+lSL44 alWQ== X-Gm-Message-State: ACgBeo1YMOK8puKyIT0oarnR9r4pUwxnVJ30xD42b4qjDw3U7kYu3bAs rD4DeonkliRAyWvzJMCZparP1rzW9Sp8AQ== X-Google-Smtp-Source: AA6agR7xl253ROUghBq852arcpTec+SpFbcjKdtEc77BAFx9JKtj1VW5ZlnuGougFt56BUeIg98L9g== X-Received: by 2002:ac8:7f43:0:b0:35b:a52f:1c14 with SMTP id g3-20020ac87f43000000b0035ba52f1c14mr2307025qtk.138.1662760434449; Fri, 09 Sep 2022 14:53:54 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id gd25-20020a05622a5c1900b0035ba3cae6basm1218710qtb.34.2022.09.09.14.53.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:53:53 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 02/36] btrfs: unexport internal failrec functions Date: Fri, 9 Sep 2022 17:53:15 -0400 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 These are internally used functions and are not used outside of extent_io.c. Signed-off-by: Josef Bacik Reviewed-by: Johannes Thumshirn --- fs/btrfs/extent-io-tree.h | 6 ------ fs/btrfs/extent_io.c | 13 +++++++------ 2 files changed, 7 insertions(+), 12 deletions(-) diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index bb71b4a69022..5584968643eb 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -248,14 +248,8 @@ bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, struct extent_state **cached_state); /* This should be reworked in the future and put elsewhere. */ -struct io_failure_record *get_state_failrec(struct extent_io_tree *tree, u64 start); -int set_state_failrec(struct extent_io_tree *tree, u64 start, - struct io_failure_record *failrec); void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start, u64 end); -int free_io_failure(struct extent_io_tree *failure_tree, - struct extent_io_tree *io_tree, - struct io_failure_record *rec); int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, struct page *page, unsigned int pg_offset); diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 5ee8b5be636d..589a82d68994 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -2163,8 +2163,8 @@ u64 count_range_bits(struct extent_io_tree *tree, * set the private field for a given byte offset in the tree. If there isn't * an extent_state there already, this does nothing. */ -int set_state_failrec(struct extent_io_tree *tree, u64 start, - struct io_failure_record *failrec) +static int set_state_failrec(struct extent_io_tree *tree, u64 start, + struct io_failure_record *failrec) { struct rb_node *node; struct extent_state *state; @@ -2191,7 +2191,8 @@ int set_state_failrec(struct extent_io_tree *tree, u64 start, return ret; } -struct io_failure_record *get_state_failrec(struct extent_io_tree *tree, u64 start) +static struct io_failure_record *get_state_failrec(struct extent_io_tree *tree, + u64 start) { struct rb_node *node; struct extent_state *state; @@ -2275,9 +2276,9 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, return bitset; } -int free_io_failure(struct extent_io_tree *failure_tree, - struct extent_io_tree *io_tree, - struct io_failure_record *rec) +static int free_io_failure(struct extent_io_tree *failure_tree, + struct extent_io_tree *io_tree, + struct io_failure_record *rec) { int ret; int err = 0; From patchwork Fri Sep 9 21:53: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: 12972191 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 499DBECAAA1 for ; Fri, 9 Sep 2022 21:54:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231770AbiIIVx7 (ORCPT ); Fri, 9 Sep 2022 17:53:59 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57974 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229690AbiIIVx6 (ORCPT ); Fri, 9 Sep 2022 17:53:58 -0400 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 33877F651D for ; Fri, 9 Sep 2022 14:53:57 -0700 (PDT) Received: by mail-qk1-x730.google.com with SMTP id h28so2243608qka.0 for ; Fri, 09 Sep 2022 14:53:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=sXyE3baxwFq2MvWbZkejxVQkgNlK2plsrhRH6X5R4uU=; b=NoM5/ee9OkeKitUXrElXrLLsQsmoGlHE1WlW9lU/1p083LodWTqse6tF8ShZYhCAj5 m8oSm2GuFEZ+TRjiwzz0FnOfSLhM/O5wvWyYod4gm3tfjcdJ3XxrolLtSH1B2m4bNu3Z EZn8+qVOsvkFq69TSX36zWZHPV8bGioen/AsRRff9jyXUaj1IHJ3t5SCbDJh048Nz7Yz 8EorsfPzwgy7kjlovelOeDQ/uW9BRFibJiDlvJXDN/EDjaAPtKMdnP3AMtKwsvHPXf7V 2mofgVZnVKX6qOGtEdSxdbZj8x2Z+3qHI4cj3n//p6oW4FP5LpiAZ/m77wJMWkJl64Vd 5fWQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=sXyE3baxwFq2MvWbZkejxVQkgNlK2plsrhRH6X5R4uU=; b=dUOxg2DXH5EL2TjMPR4fv3HvIwEu67csdYk5ApmLIrspO2Qw2++BNmuaefQ5yfAslL Th56D0vBIZaPBRbLLbvXBx+CGkITQkXUMUglQEq87zOwkP1WOPEalPIEGyBq/ftXrjVg k1Smg0QxjfRrb+hULQAS0ZJs4g2wuEVxg2UiK+PSjE5OKWPVf/Cmqh4nIejGWAcsuNU1 siYmV/UcZbjQsvh7fmkftFTudPr7WE7q7ok5jrbbDnRPIjLz7HAcjk94Qn//S/en2nwy /XTqhqBpmEw8OUvpW+iXO6wxEI2Jd6Uwt8lHxEjckBTyjHJCtiXER4F9CecYCMEnbGqa j0uw== X-Gm-Message-State: ACgBeo0SkTGY+SFM778u87BDo5W9DEly36sQrhgoCQmQ/1bxj/vwTnAQ gACAHuOmwTw+lfOENIEMXnBzk4X8xbJoxQ== X-Google-Smtp-Source: AA6agR76O/oo5Qis4jueIwfAITPnJB4NvgYfVaG8xoL8K5U+KfgJ6Q21gLpUHJbVvH5YlU09oQue/Q== X-Received: by 2002:a05:620a:2987:b0:6ba:dc04:11ae with SMTP id r7-20020a05620a298700b006badc0411aemr11767869qkp.748.1662760435847; Fri, 09 Sep 2022 14:53:55 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id y25-20020a37f619000000b006cdd0939ffbsm1255902qkj.86.2022.09.09.14.53.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:53:55 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 03/36] btrfs: convert the io_failure_tree to a plain rb_tree Date: Fri, 9 Sep 2022 17:53:16 -0400 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 still have this oddity of stashing the io_failure_record in the extent state for the io_failure_tree, which is leftover from when we used to stuff private pointers in extent_io_trees. However this doesn't make a lot of sense for the io failure records, we can simply use a normal rb_tree for this. This will allow us to further simplify the extent_io_tree code by removing the io_failure_rec pointer from the extent state. Convert the io_failure_tree to an rb tree + spinlock in the inode, and then use our rb tree simple helpers to insert and find failed records. This greatly cleans up this code and makes it easier to separate out the extent_io_tree code. Signed-off-by: Josef Bacik --- fs/btrfs/btrfs_inode.h | 3 +- fs/btrfs/extent-io-tree.h | 3 - fs/btrfs/extent_io.c | 164 +++++++++++------------------------ fs/btrfs/extent_io.h | 5 +- fs/btrfs/inode.c | 5 +- fs/btrfs/misc.h | 35 ++++++++ include/trace/events/btrfs.h | 1 - 7 files changed, 96 insertions(+), 120 deletions(-) diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h index b160b8e124e0..108af52ba870 100644 --- a/fs/btrfs/btrfs_inode.h +++ b/fs/btrfs/btrfs_inode.h @@ -94,7 +94,8 @@ struct btrfs_inode { /* special utility tree used to record which mirrors have already been * tried when checksums fail for a given block */ - struct extent_io_tree io_failure_tree; + struct rb_root io_failure_tree; + spinlock_t io_failure_lock; /* * Keep track of where the inode has extent items mapped in order to diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 5584968643eb..ee2ba4b6e4a1 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -56,7 +56,6 @@ enum { IO_TREE_FS_EXCLUDED_EXTENTS, IO_TREE_BTREE_INODE_IO, IO_TREE_INODE_IO, - IO_TREE_INODE_IO_FAILURE, IO_TREE_RELOC_BLOCKS, IO_TREE_TRANS_DIRTY_PAGES, IO_TREE_ROOT_DIRTY_LOG_PAGES, @@ -89,8 +88,6 @@ struct extent_state { refcount_t refs; u32 state; - struct io_failure_record *failrec; - #ifdef CONFIG_BTRFS_DEBUG struct list_head leak_list; #endif diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 589a82d68994..972181451561 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -326,7 +326,6 @@ static struct extent_state *alloc_extent_state(gfp_t mask) if (!state) return state; state->state = 0; - state->failrec = NULL; RB_CLEAR_NODE(&state->rb_node); btrfs_leak_debug_add(&leak_lock, &state->leak_list, &states); refcount_set(&state->refs, 1); @@ -2159,64 +2158,30 @@ u64 count_range_bits(struct extent_io_tree *tree, return total_bytes; } -/* - * set the private field for a given byte offset in the tree. If there isn't - * an extent_state there already, this does nothing. - */ -static int set_state_failrec(struct extent_io_tree *tree, u64 start, - struct io_failure_record *failrec) +static int insert_failrec(struct btrfs_inode *inode, + struct io_failure_record *failrec) { - struct rb_node *node; - struct extent_state *state; - int ret = 0; + struct rb_node *exist; - spin_lock(&tree->lock); - /* - * this search will find all the extents that end after - * our range starts. - */ - node = tree_search(tree, start); - if (!node) { - ret = -ENOENT; - goto out; - } - state = rb_entry(node, struct extent_state, rb_node); - if (state->start != start) { - ret = -ENOENT; - goto out; - } - state->failrec = failrec; -out: - spin_unlock(&tree->lock); - return ret; + spin_lock(&inode->io_failure_lock); + exist = rb_simple_insert(&inode->io_failure_tree, failrec->bytenr, + &failrec->rb_node); + spin_unlock(&inode->io_failure_lock); + + return (exist == NULL) ? 0 : -EEXIST; } -static struct io_failure_record *get_state_failrec(struct extent_io_tree *tree, - u64 start) +static struct io_failure_record *get_failrec(struct btrfs_inode *inode, + u64 start) { struct rb_node *node; - struct extent_state *state; - struct io_failure_record *failrec; + struct io_failure_record *failrec = ERR_PTR(-ENOENT); - spin_lock(&tree->lock); - /* - * this search will find all the extents that end after - * our range starts. - */ - node = tree_search(tree, start); - if (!node) { - failrec = ERR_PTR(-ENOENT); - goto out; - } - state = rb_entry(node, struct extent_state, rb_node); - if (state->start != start) { - failrec = ERR_PTR(-ENOENT); - goto out; - } - - failrec = state->failrec; -out: - spin_unlock(&tree->lock); + spin_lock(&inode->io_failure_lock); + node = rb_simple_search(&inode->io_failure_tree, start); + if (node) + failrec = rb_entry(node, struct io_failure_record, rb_node); + spin_unlock(&inode->io_failure_lock); return failrec; } @@ -2276,28 +2241,20 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, return bitset; } -static int free_io_failure(struct extent_io_tree *failure_tree, - struct extent_io_tree *io_tree, +static int free_io_failure(struct btrfs_inode *inode, struct io_failure_record *rec) { int ret; - int err = 0; - set_state_failrec(failure_tree, rec->start, NULL); - ret = clear_extent_bits(failure_tree, rec->start, - rec->start + rec->len - 1, - EXTENT_LOCKED | EXTENT_DIRTY); - if (ret) - err = ret; + spin_lock(&inode->io_failure_lock); + rb_erase(&rec->rb_node, &inode->io_failure_tree); + spin_unlock(&inode->io_failure_lock); - ret = clear_extent_bits(io_tree, rec->start, - rec->start + rec->len - 1, + ret = clear_extent_bits(&inode->io_tree, rec->bytenr, + rec->bytenr + rec->len - 1, EXTENT_DAMAGED); - if (ret && !err) - err = ret; - kfree(rec); - return err; + return ret; } /* @@ -2436,22 +2393,13 @@ int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, struct page *page, unsigned int pg_offset) { struct btrfs_fs_info *fs_info = inode->root->fs_info; - struct extent_io_tree *failure_tree = &inode->io_failure_tree; struct extent_io_tree *io_tree = &inode->io_tree; u64 ino = btrfs_ino(inode); - u64 private; struct io_failure_record *failrec; struct extent_state *state; int mirror; - int ret; - - private = 0; - ret = count_range_bits(failure_tree, &private, (u64)-1, 1, - EXTENT_DIRTY, 0); - if (!ret) - return 0; - failrec = get_state_failrec(failure_tree, start); + failrec = get_failrec(inode, start); if (IS_ERR(failrec)) return 0; @@ -2462,12 +2410,12 @@ int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, spin_lock(&io_tree->lock); state = find_first_extent_bit_state(io_tree, - failrec->start, + failrec->bytenr, EXTENT_LOCKED); spin_unlock(&io_tree->lock); - if (!state || state->start > failrec->start || - state->end < failrec->start + failrec->len - 1) + if (!state || state->start > failrec->bytenr || + state->end < failrec->bytenr + failrec->len - 1) goto out; mirror = failrec->this_mirror; @@ -2478,7 +2426,7 @@ int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, } while (mirror != failrec->failed_mirror); out: - free_io_failure(failure_tree, io_tree, failrec); + free_io_failure(inode, failrec); return 0; } @@ -2490,30 +2438,26 @@ int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, */ void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start, u64 end) { - struct extent_io_tree *failure_tree = &inode->io_failure_tree; struct io_failure_record *failrec; - struct extent_state *state, *next; + struct rb_node *n, *next; - if (RB_EMPTY_ROOT(&failure_tree->state)) + if (RB_EMPTY_ROOT(&inode->io_failure_tree)) return; - spin_lock(&failure_tree->lock); - state = find_first_extent_bit_state(failure_tree, start, EXTENT_DIRTY); - while (state) { - if (state->start > end) + spin_lock(&inode->io_failure_lock); + n = rb_simple_search_first(&inode->io_failure_tree, start); + while (n) { + failrec = rb_entry(n, struct io_failure_record, rb_node); + if (failrec->bytenr > end) break; - ASSERT(state->end <= end); - - next = next_state(state); - - failrec = state->failrec; - free_extent_state(state); + next = rb_next(n); + rb_erase(&failrec->rb_node, &inode->io_failure_tree); kfree(failrec); - state = next; + n = next; } - spin_unlock(&failure_tree->lock); + spin_unlock(&inode->io_failure_lock); } static struct io_failure_record *btrfs_get_io_failure_record(struct inode *inode, @@ -2523,16 +2467,15 @@ static struct io_failure_record *btrfs_get_io_failure_record(struct inode *inode struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); u64 start = bbio->file_offset + bio_offset; struct io_failure_record *failrec; - struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree; struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree; const u32 sectorsize = fs_info->sectorsize; int ret; - failrec = get_state_failrec(failure_tree, start); + failrec = get_failrec(BTRFS_I(inode), start); if (!IS_ERR(failrec)) { btrfs_debug(fs_info, "Get IO Failure Record: (found) logical=%llu, start=%llu, len=%llu", - failrec->logical, failrec->start, failrec->len); + failrec->logical, failrec->bytenr, failrec->len); /* * when data can be on disk more than twice, add to failrec here * (e.g. with a list for failed_mirror) to make @@ -2547,7 +2490,8 @@ static struct io_failure_record *btrfs_get_io_failure_record(struct inode *inode if (!failrec) return ERR_PTR(-ENOMEM); - failrec->start = start; + RB_CLEAR_NODE(&failrec->rb_node); + failrec->bytenr = start; failrec->len = sectorsize; failrec->failed_mirror = bbio->mirror_num; failrec->this_mirror = bbio->mirror_num; @@ -2572,17 +2516,17 @@ static struct io_failure_record *btrfs_get_io_failure_record(struct inode *inode } /* Set the bits in the private failure tree */ - ret = set_extent_bits(failure_tree, start, start + sectorsize - 1, - EXTENT_LOCKED | EXTENT_DIRTY); - if (ret >= 0) { - ret = set_state_failrec(failure_tree, start, failrec); - /* Set the bits in the inode's tree */ - ret = set_extent_bits(tree, start, start + sectorsize - 1, - EXTENT_DAMAGED); - } else if (ret < 0) { + ret = insert_failrec(BTRFS_I(inode), failrec); + if (ret) { kfree(failrec); return ERR_PTR(ret); } + ret = set_extent_bits(tree, start, start + sectorsize - 1, + EXTENT_DAMAGED); + if (ret) { + free_io_failure(BTRFS_I(inode), failrec); + return ERR_PTR(ret); + } return failrec; } @@ -2594,8 +2538,6 @@ int btrfs_repair_one_sector(struct inode *inode, struct btrfs_bio *failed_bbio, u64 start = failed_bbio->file_offset + bio_offset; struct io_failure_record *failrec; struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); - struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree; - struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree; struct bio *failed_bio = &failed_bbio->bio; const int icsum = bio_offset >> fs_info->sectorsize_bits; struct bio *repair_bio; @@ -2624,7 +2566,7 @@ int btrfs_repair_one_sector(struct inode *inode, struct btrfs_bio *failed_bbio, btrfs_debug(fs_info, "failed to repair num_copies %d this_mirror %d failed_mirror %d", failrec->num_copies, failrec->this_mirror, failrec->failed_mirror); - free_io_failure(failure_tree, tree, failrec); + free_io_failure(BTRFS_I(inode), failrec); return -EIO; } diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h index 69a86ae6fd50..879f8a60cd6f 100644 --- a/fs/btrfs/extent_io.h +++ b/fs/btrfs/extent_io.h @@ -254,8 +254,11 @@ int btrfs_repair_eb_io_failure(const struct extent_buffer *eb, int mirror_num); * bio end_io callback is called to indicate things have failed. */ struct io_failure_record { + struct { + struct rb_node rb_node; + u64 bytenr; + }; /* Use rb_simple_node for search/insert */ struct page *page; - u64 start; u64 len; u64 logical; int this_mirror; diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 548665299e57..8def3a67adb7 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -8790,6 +8790,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb) ei->last_log_commit = 0; spin_lock_init(&ei->lock); + spin_lock_init(&ei->io_failure_lock); ei->outstanding_extents = 0; if (sb->s_magic != BTRFS_TEST_MAGIC) btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv, @@ -8806,12 +8807,10 @@ struct inode *btrfs_alloc_inode(struct super_block *sb) inode = &ei->vfs_inode; extent_map_tree_init(&ei->extent_tree); extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO, inode); - extent_io_tree_init(fs_info, &ei->io_failure_tree, - IO_TREE_INODE_IO_FAILURE, inode); extent_io_tree_init(fs_info, &ei->file_extent_tree, IO_TREE_INODE_FILE_EXTENT, inode); + ei->io_failure_tree = RB_ROOT; ei->io_tree.track_uptodate = true; - ei->io_failure_tree.track_uptodate = true; atomic_set(&ei->sync_writers, 0); mutex_init(&ei->log_mutex); btrfs_ordered_inode_tree_init(&ei->ordered_tree); diff --git a/fs/btrfs/misc.h b/fs/btrfs/misc.h index 340f995652f2..4ffd603d19cb 100644 --- a/fs/btrfs/misc.h +++ b/fs/btrfs/misc.h @@ -88,6 +88,41 @@ static inline struct rb_node *rb_simple_search(struct rb_root *root, u64 bytenr) return NULL; } +/** + * Search @root from an entry that starts or comes after @bytenr. + * + * @root: the root to search. + * @bytenr: bytenr to search from. + * + * Return the rb_node that start at or after @bytenr. If there is no entry at + * or after @bytner return NULL. + */ +static inline struct rb_node *rb_simple_search_first(struct rb_root *root, + u64 bytenr) +{ + struct rb_node *node = root->rb_node, *ret = NULL; + struct rb_simple_node *entry, *ret_entry = NULL; + + while (node) { + entry = rb_entry(node, struct rb_simple_node, rb_node); + + if (bytenr < entry->bytenr) { + if (!ret || entry->bytenr < ret_entry->bytenr) { + ret = node; + ret_entry = entry; + } + + node = node->rb_left; + } else if (bytenr > entry->bytenr) { + node = node->rb_right; + } else { + return node; + } + } + + return ret; +} + static inline struct rb_node *rb_simple_insert(struct rb_root *root, u64 bytenr, struct rb_node *node) { diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h index 73df80d462dc..4db905311d67 100644 --- a/include/trace/events/btrfs.h +++ b/include/trace/events/btrfs.h @@ -84,7 +84,6 @@ struct raid56_bio_trace_info; EM( IO_TREE_FS_EXCLUDED_EXTENTS, "EXCLUDED_EXTENTS") \ EM( IO_TREE_BTREE_INODE_IO, "BTREE_INODE_IO") \ EM( IO_TREE_INODE_IO, "INODE_IO") \ - EM( IO_TREE_INODE_IO_FAILURE, "INODE_IO_FAILURE") \ EM( IO_TREE_RELOC_BLOCKS, "RELOC_BLOCKS") \ EM( IO_TREE_TRANS_DIRTY_PAGES, "TRANS_DIRTY_PAGES") \ EM( IO_TREE_ROOT_DIRTY_LOG_PAGES, "ROOT_DIRTY_LOG_PAGES") \ From patchwork Fri Sep 9 21:53: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: 12972190 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 1FF44ECAAD3 for ; Fri, 9 Sep 2022 21:54:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231784AbiIIVyA (ORCPT ); Fri, 9 Sep 2022 17:54:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57982 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231755AbiIIVx7 (ORCPT ); Fri, 9 Sep 2022 17:53:59 -0400 Received: from mail-qk1-x72a.google.com (mail-qk1-x72a.google.com [IPv6:2607:f8b0:4864:20::72a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 74C21CEB26 for ; Fri, 9 Sep 2022 14:53:58 -0700 (PDT) Received: by mail-qk1-x72a.google.com with SMTP id s22so2222580qkj.3 for ; Fri, 09 Sep 2022 14:53:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=HHuriAKnGvqRraw4EjngMZzAEBRl513RxLJo1fLnj8U=; b=mOW7zp91pdKBzlL4gtJ6P4R4cFi9hfeV8DEChfCQLRr95uwdu6jT5TisHsFOinnMcN +5G578l8IOBUeq51oQcZKerzHe5DYIVPPDpdyGH8Z0ZyAiCl50MxocXzFb/bL7vbMtxy BYl8Y3Tpr5Pb4vajMsKzS49xv1wgw+Ngfzqfp+mXdN7+a0yqvOOBg3Nk/Qy1bgC71mGU BuR+QR1AaGEZ9Uh8aO+Sc2KO0y6cC41dCAJsbgTyusns265zwfg28Top+S+gw1DDV5rF sUvPYe5V7JCJp7yGaM5X7j9YpXiJa7VSjU00vtB/zl9vCPBbpGQa/B9B3ZaMur+0LV+0 I+0g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=HHuriAKnGvqRraw4EjngMZzAEBRl513RxLJo1fLnj8U=; b=LvMgpUCgk1SoJa+gbl2sge3spCthOClG/nSKA9h1VK0mD5Rtrq0qQ+YvR/CtEp+u6t PdJMYMwIfTg0vqk48Z1pHhcnChYJe2Qm27NhhL/r1PaS1whBYcizGFPXcSeVUY28iple +MarlBwty9BYV5GefQ1xP+Xwu+VrdVOlo6NKJ3OVssD9XjDXDZK4klOKmTEjnGpX7ENk SNLVSZLn50dzjJam6BLyry+NMIZEIlqT948UnC2t5gzUDe0rkmUCBpRgiy+sxfJPcxKA he4NO31NRu6RjCr4hVUYmtW3ia+6/Ry6etWtN+Zn7xCYQ1O2N0tWsiGhyD1GJhBwIgIx V1aw== X-Gm-Message-State: ACgBeo1Yc5kClbXoSLxciIUN/m2uDIVKp5ZUGMAFzXb4Bl8lZ/8H2b9r we52OtQOUzaVuuBLCF8l28/9oydFKNviMg== X-Google-Smtp-Source: AA6agR5SME4jJV0E6hiosmeCwYvPl0MM69kON7siIl7tqJXQLdv+r3eWWwqMEenBoXUNbSU8lHHveQ== X-Received: by 2002:a05:620a:14a6:b0:6cd:df30:3ae6 with SMTP id x6-20020a05620a14a600b006cddf303ae6mr2697968qkj.556.1662760437261; Fri, 09 Sep 2022 14:53:57 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id m16-20020ac84450000000b0034361fb2f75sm1069821qtn.22.2022.09.09.14.53.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:53:56 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 04/36] btrfs: use find_first_extent_bit in btrfs_clean_io_failure Date: Fri, 9 Sep 2022 17:53:17 -0400 Message-Id: <52eddebdf9d7f5d9605a469c0dd56d7421be61bb.1662760286.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 Currently we're using find_first_extent_bit_state to check if our state contains the given failrec range, however this is more of an internal extent_io_tree helper, and is technically unsafe to use because we're accessing the state outside of the extent_io_tree lock. Instead use the normal helper find_first_extent_bit which returns the range of the extent state we find in find_first_extent_bit_state and use that to do our sanity checking. Signed-off-by: Josef Bacik --- fs/btrfs/extent_io.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 972181451561..0f087ab1b175 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -2395,9 +2395,10 @@ int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, struct btrfs_fs_info *fs_info = inode->root->fs_info; struct extent_io_tree *io_tree = &inode->io_tree; u64 ino = btrfs_ino(inode); + u64 locked_start, locked_end; struct io_failure_record *failrec; - struct extent_state *state; int mirror; + int ret; failrec = get_failrec(inode, start); if (IS_ERR(failrec)) @@ -2408,14 +2409,10 @@ int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, if (sb_rdonly(fs_info->sb)) goto out; - spin_lock(&io_tree->lock); - state = find_first_extent_bit_state(io_tree, - failrec->bytenr, - EXTENT_LOCKED); - spin_unlock(&io_tree->lock); - - if (!state || state->start > failrec->bytenr || - state->end < failrec->bytenr + failrec->len - 1) + ret = find_first_extent_bit(io_tree, failrec->bytenr, &locked_start, + &locked_end, EXTENT_LOCKED, NULL); + if (ret || locked_start > failrec->bytenr || + locked_end < failrec->bytenr + failrec->len - 1) goto out; mirror = failrec->this_mirror; From patchwork Fri Sep 9 21:53: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: 12972193 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 ED58DECAAD5 for ; Fri, 9 Sep 2022 21:54:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231787AbiIIVyC (ORCPT ); Fri, 9 Sep 2022 17:54:02 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58000 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231773AbiIIVyA (ORCPT ); Fri, 9 Sep 2022 17:54:00 -0400 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 E4593CEB26 for ; Fri, 9 Sep 2022 14:53:59 -0700 (PDT) Received: by mail-qk1-x734.google.com with SMTP id j6so2203940qkl.10 for ; Fri, 09 Sep 2022 14:53:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=752VRjdEIKUyzdIAZx69Lfw1LXg03xV1xqhBLDgwr3g=; b=nOy+ye8iau0CPVm10l0B3SAkNVJiSWgg1yjr8SNPGLEe6x+ObDOF7f/+zi/qzkpITq 8IMhuz9HoTogyV3ohtOxis9rrVlck6uQZ/y3TY685AJTvw6QQncrM3hETOTD3ZFMATDK oH+KBwUjcviEt+PkMMBknshuA9MzqU3mqa3bRpxE1ospjkVNwlckAG0ngwT5aln2MF9z 2LWdefzcnvOdRpBC073HL4kdFXefUEU6LnZkTunnNnLxo2Uo51UqFgCUOpJ1GTsG1F9x tvT2WWESA4YIFyxnUZNhutJ7XUbe8XskQRSfwa1D5ohCB130J2aOFLLDIWu6lp86wMYE +nZw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=752VRjdEIKUyzdIAZx69Lfw1LXg03xV1xqhBLDgwr3g=; b=6hITcC+40DUdJuIdDO09FnBpbTUB4Q0cG0Xt8v7JX3W5lePZgT8BHXKdjM8OQfm6pl RiuX4Bvng2hXnUb0xQj1yABS53VyClc/AZmHrJbWmIek5cMGTfoLf/7ZMzLStD9oTlxG tD0r6vUwvAekOsynoxwS1OI4NGMKBT/k0O+OqYHX4LS3l4ic0knpQSVvdCisaSxZld56 BTcfjPL3PvTCABlrMbRU+SZHodvbsTYBBclzKMcT6HE342trJc40/fKs/xyz3OzHM+gX U7hjBQwbpuF2Mgtnmuh5VF78Hyk4SsmnpS8SPE+7w9v64ag+PXGOlsWLkgQsyX/j79Eq Meww== X-Gm-Message-State: ACgBeo1h6U29KdSexrMJKGCRASTNUtfj3H1RnPEWP/8ycv763fj+K31m brySqX4SEFTR7NHJW9zc9k9PYUL9cVlf8g== X-Google-Smtp-Source: AA6agR51E96eAaKmDO29EdrGgM/N1khWR4koc/9YnOxt2Jo3vHz7uWc2wpZrOqFlp+mhPhdePgL9Bg== X-Received: by 2002:a05:620a:470a:b0:6bb:6dc1:67ce with SMTP id bs10-20020a05620a470a00b006bb6dc167cemr11908634qkb.589.1662760438685; Fri, 09 Sep 2022 14:53:58 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id c6-20020a05620a268600b006b93b61bc74sm1555586qkp.9.2022.09.09.14.53.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:53:58 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 05/36] btrfs: separate out the extent state and extent buffer init code Date: Fri, 9 Sep 2022 17:53:18 -0400 Message-Id: <16e57635b3262ea0ce9c1fb391665e34a8ccc804.1662760286.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 order to help separate the extent buffer from the extent io tree code we need to break up the init functions. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.h | 4 ++-- fs/btrfs/extent_io.c | 21 ++++++++++++++------- fs/btrfs/extent_io.h | 3 +++ fs/btrfs/super.c | 17 ++++++++++++----- 4 files changed, 31 insertions(+), 14 deletions(-) diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index ee2ba4b6e4a1..6c2016db304b 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -108,8 +108,8 @@ static inline int lock_extent(struct extent_io_tree *tree, u64 start, u64 end) int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end); -int __init extent_io_init(void); -void __cold extent_io_exit(void); +int __init extent_state_init_cachep(void); +void __cold extent_state_free_cachep(void); u64 count_range_bits(struct extent_io_tree *tree, u64 *start, u64 search_end, diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 0f087ab1b175..34b03bd2352e 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -230,7 +230,7 @@ static void submit_write_bio(struct extent_page_data *epd, int ret) } } -int __init extent_io_init(void) +int __init extent_state_init_cachep(void) { extent_state_cache = kmem_cache_create("btrfs_extent_state", sizeof(struct extent_state), 0, @@ -238,18 +238,27 @@ int __init extent_io_init(void) if (!extent_state_cache) return -ENOMEM; + return 0; +} + +int __init extent_buffer_init_cachep(void) +{ extent_buffer_cache = kmem_cache_create("btrfs_extent_buffer", sizeof(struct extent_buffer), 0, SLAB_MEM_SPREAD, NULL); - if (!extent_buffer_cache) { - kmem_cache_destroy(extent_state_cache); + if (!extent_buffer_cache) return -ENOMEM; - } return 0; } -void __cold extent_io_exit(void) +void __cold extent_state_free_cachep(void) +{ + btrfs_extent_state_leak_debug_check(); + kmem_cache_destroy(extent_state_cache); +} + +void __cold extent_buffer_free_cachep(void) { /* * Make sure all delayed rcu free are flushed before we @@ -257,8 +266,6 @@ void __cold extent_io_exit(void) */ rcu_barrier(); kmem_cache_destroy(extent_buffer_cache); - btrfs_extent_state_leak_debug_check(); - kmem_cache_destroy(extent_state_cache); } /* diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h index 879f8a60cd6f..52e4dfea2164 100644 --- a/fs/btrfs/extent_io.h +++ b/fs/btrfs/extent_io.h @@ -64,6 +64,9 @@ struct btrfs_fs_info; struct io_failure_record; struct extent_io_tree; +int __init extent_buffer_init_cachep(void); +void __cold extent_buffer_free_cachep(void); + typedef void (submit_bio_hook_t)(struct inode *inode, struct bio *bio, int mirror_num, enum btrfs_compression_type compress_type); diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c index eb0ae7e396ef..be7df8d1d5b8 100644 --- a/fs/btrfs/super.c +++ b/fs/btrfs/super.c @@ -2736,13 +2736,17 @@ static int __init init_btrfs_fs(void) if (err) goto free_compress; - err = extent_io_init(); + err = extent_state_init_cachep(); if (err) goto free_cachep; + err = extent_buffer_init_cachep(); + if (err) + goto free_extent_cachep; + err = btrfs_bioset_init(); if (err) - goto free_extent_io; + goto free_eb_cachep; err = extent_map_init(); if (err) @@ -2800,8 +2804,10 @@ static int __init init_btrfs_fs(void) extent_map_exit(); free_bioset: btrfs_bioset_exit(); -free_extent_io: - extent_io_exit(); +free_eb_cachep: + extent_buffer_free_cachep(); +free_extent_cachep: + extent_state_free_cachep(); free_cachep: btrfs_destroy_cachep(); free_compress: @@ -2821,7 +2827,8 @@ static void __exit exit_btrfs_fs(void) ordered_data_exit(); extent_map_exit(); btrfs_bioset_exit(); - extent_io_exit(); + extent_state_free_cachep(); + extent_buffer_free_cachep(); btrfs_interface_exit(); unregister_filesystem(&btrfs_fs_type); btrfs_exit_sysfs(); From patchwork Fri Sep 9 21:53: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: 12972192 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 19EFDC6FA89 for ; Fri, 9 Sep 2022 21:54:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231788AbiIIVyC (ORCPT ); Fri, 9 Sep 2022 17:54:02 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58018 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231755AbiIIVyB (ORCPT ); Fri, 9 Sep 2022 17:54:01 -0400 Received: from mail-qt1-x832.google.com (mail-qt1-x832.google.com [IPv6:2607:f8b0:4864:20::832]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A6C76F651D for ; Fri, 9 Sep 2022 14:54:00 -0700 (PDT) Received: by mail-qt1-x832.google.com with SMTP id r6so2344396qtx.6 for ; Fri, 09 Sep 2022 14:54:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=uPVd2o0gf3rx81vKXT46VZaevTKGQr8nLf5qget5uVE=; b=I8CAiCVl6PhcgG3JtyfFMfUBNsZbLTFJzz+qL1tTuxJYyUWbXYwjcT6p2cy/pE5qtv mfR6+mJpgQ2wIBweOzXwXVuTKBAqqBQqIjYDQtkAvA8yg3lZYa+rNH/4GglB7l3W0euf vsKk2dgnD6ao3QKx4EZygH4A0H0HQxzV4OW78n2C7ZBawTW2JRo/uaK6oTBDLSdM6tVO 2zegXn4MAchT4u6f1hr0XL39JXbC0jGSfYnbG3o9lfPOEHVe5OswRVhxYV2MDipL2+4c s8eCFpfQZX/0zWTZaYvEkohbTzJ9J/nuYvOUM/PY8w6cyaPOMWuglgJZLAfQ+U4X0bUC /QzA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=uPVd2o0gf3rx81vKXT46VZaevTKGQr8nLf5qget5uVE=; b=MjzlExZBTmfY6a52iRo8IvHwBZ/VWe+P79L3b98FnpRFRcokqq/hN5hEKtjZpio83H rU9LtSZFhinEk55mGAQRaemuMMHTlmPxPrNSsNPPQJzrxGPonilUeMAHoob99PAbkbWM o3yVCIv9/OXyq9aEUwmjKFS5WJZGLz2thsdkUjt64XRLfxjWVr2mJD+H01ISFxW9noW5 UAD6qV4vaRBQX0W2h5c5EFQUDBZE+GFGy7Sfz3e1znojznZSwYX6LOooB8SWL99TgVbP dFrBROBlb0lEtUHi/WuS2V2yuWhlOODWuTnMMZF8ihNpirVIkC3PACqCxlWoON7nklz1 IDXQ== X-Gm-Message-State: ACgBeo2ROZ63tfasJn1yTK1I22HIBQ5LBw/x1gKxrIIl49tc/TJOmpHT pRBUb0LDImUI2PETVtXVnjaot/WSOpkYGA== X-Google-Smtp-Source: AA6agR7KQ+b7AM5Gm2dF92LllSD7QHtOtf+YadYEsMRYdikp9CywaNUk9Hm9XuYj++JEQmLUKOWl/g== X-Received: by 2002:ac8:5ac5:0:b0:343:6d5a:43d9 with SMTP id d5-20020ac85ac5000000b003436d5a43d9mr14494796qtd.10.1662760440016; Fri, 09 Sep 2022 14:54:00 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id l18-20020ac848d2000000b00344f936bfc0sm1169934qtr.33.2022.09.09.14.53.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:53:59 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 06/36] btrfs: separate out the eb and extent state leak helpers Date: Fri, 9 Sep 2022 17:53:19 -0400 Message-Id: <7b6a38c92a390bf480e5718666608e4338e50ee9.1662760286.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 Currently we have the add/del functions generic so that we can use them for both extent buffers and extent states. We want to separate this code however, so separate these helpers into per-object helpers in anticipation of the split. Signed-off-by: Josef Bacik --- fs/btrfs/extent_io.c | 58 +++++++++++++++++++++++++++++--------------- 1 file changed, 38 insertions(+), 20 deletions(-) diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 34b03bd2352e..35811d40e2f1 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -43,25 +43,42 @@ static inline bool extent_state_in_tree(const struct extent_state *state) static LIST_HEAD(states); static DEFINE_SPINLOCK(leak_lock); -static inline void btrfs_leak_debug_add(spinlock_t *lock, - struct list_head *new, - struct list_head *head) +static inline void btrfs_leak_debug_add_eb(struct extent_buffer *eb) +{ + struct btrfs_fs_info *fs_info = eb->fs_info; + unsigned long flags; + + spin_lock_irqsave(&fs_info->eb_leak_lock, flags); + list_add(&eb->leak_list, &fs_info->allocated_ebs); + spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags); +} + +static inline void btrfs_leak_debug_add_state(struct extent_state *state) { unsigned long flags; - spin_lock_irqsave(lock, flags); - list_add(new, head); - spin_unlock_irqrestore(lock, flags); + spin_lock_irqsave(&leak_lock, flags); + list_add(&state->leak_list, &states); + spin_unlock_irqrestore(&leak_lock, flags); +} + +static inline void btrfs_leak_debug_del_eb(struct extent_buffer *eb) +{ + struct btrfs_fs_info *fs_info = eb->fs_info; + unsigned long flags; + + spin_lock_irqsave(&fs_info->eb_leak_lock, flags); + list_del(&eb->leak_list); + spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags); } -static inline void btrfs_leak_debug_del(spinlock_t *lock, - struct list_head *entry) +static inline void btrfs_leak_debug_del_state(struct extent_state *state) { unsigned long flags; - spin_lock_irqsave(lock, flags); - list_del(entry); - spin_unlock_irqrestore(lock, flags); + spin_lock_irqsave(&leak_lock, flags); + list_del(&state->leak_list); + spin_unlock_irqrestore(&leak_lock, flags); } void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info) @@ -125,9 +142,11 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller, } } #else -#define btrfs_leak_debug_add(lock, new, head) do {} while (0) -#define btrfs_leak_debug_del(lock, entry) do {} while (0) -#define btrfs_extent_state_leak_debug_check() do {} while (0) +#define btrfs_leak_debug_add_eb(eb) do {} while (0) +#define btrfs_leak_debug_add_state(state) do {} while (0) +#define btrfs_leak_debug_del_eb(eb) do {} while (0) +#define btrfs_leak_debug_del_state(state) do {} while (0) +#define btrfs_extent_state_leak_debug_check() do {} while (0) #define btrfs_debug_check_extent_io_range(c, s, e) do {} while (0) #endif @@ -334,7 +353,7 @@ static struct extent_state *alloc_extent_state(gfp_t mask) return state; state->state = 0; RB_CLEAR_NODE(&state->rb_node); - btrfs_leak_debug_add(&leak_lock, &state->leak_list, &states); + btrfs_leak_debug_add_state(state); refcount_set(&state->refs, 1); init_waitqueue_head(&state->wq); trace_alloc_extent_state(state, mask, _RET_IP_); @@ -347,7 +366,7 @@ void free_extent_state(struct extent_state *state) return; if (refcount_dec_and_test(&state->refs)) { WARN_ON(extent_state_in_tree(state)); - btrfs_leak_debug_del(&leak_lock, &state->leak_list); + btrfs_leak_debug_del_state(state); trace_free_extent_state(state, _RET_IP_); kmem_cache_free(extent_state_cache, state); } @@ -5993,7 +6012,7 @@ static void btrfs_release_extent_buffer_pages(struct extent_buffer *eb) static inline void btrfs_release_extent_buffer(struct extent_buffer *eb) { btrfs_release_extent_buffer_pages(eb); - btrfs_leak_debug_del(&eb->fs_info->eb_leak_lock, &eb->leak_list); + btrfs_leak_debug_del_eb(eb); __free_extent_buffer(eb); } @@ -6010,8 +6029,7 @@ __alloc_extent_buffer(struct btrfs_fs_info *fs_info, u64 start, eb->bflags = 0; init_rwsem(&eb->lock); - btrfs_leak_debug_add(&fs_info->eb_leak_lock, &eb->leak_list, - &fs_info->allocated_ebs); + btrfs_leak_debug_add_eb(eb); INIT_LIST_HEAD(&eb->release_list); spin_lock_init(&eb->refs_lock); @@ -6479,7 +6497,7 @@ static int release_extent_buffer(struct extent_buffer *eb) spin_unlock(&eb->refs_lock); } - btrfs_leak_debug_del(&eb->fs_info->eb_leak_lock, &eb->leak_list); + btrfs_leak_debug_del_eb(eb); /* Should be safe to release our pages at this point */ btrfs_release_extent_buffer_pages(eb); #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS From patchwork Fri Sep 9 21:53: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: 12972194 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 1E325ECAAA1 for ; Fri, 9 Sep 2022 21:54:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231791AbiIIVyF (ORCPT ); Fri, 9 Sep 2022 17:54:05 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58070 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231755AbiIIVyD (ORCPT ); Fri, 9 Sep 2022 17:54:03 -0400 Received: from mail-qk1-x72d.google.com (mail-qk1-x72d.google.com [IPv6:2607:f8b0:4864:20::72d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CBAB310300F for ; Fri, 9 Sep 2022 14:54:02 -0700 (PDT) Received: by mail-qk1-x72d.google.com with SMTP id 3so1822255qka.5 for ; Fri, 09 Sep 2022 14:54:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=pP3dhZ+ZmPQsVzNojbnTAghRS+VVB3ge1tStzWbVoNU=; b=03oWBACHNozXHNsspaWwOsvSfbINB5jVFL1Nf4stxFGozIk4cg6bmaO4vheKS0RQ/s 3VmHHIQCj1PntcF7pPek2IX3IDviiZk5mAfzKquB+MSEM6gdBQZDp+EHOHoFXw+xM4k5 2zXncNe0vJGA7kBddQq7lwJrNI9+jG+Prtc9ePz0Ezv5zYuQkZt6Jb/49eOcpVPfxM6r Qdl8eSev6LwxRpT1Jg2dtG/x+E5FIyAuswkRanozbTARLjZxJlZHD3krN63oRCALXDk+ APqrIWHAaFiRLXt3wdEloMKYmRncmUEAObIic7yuoDdRk4vaMDWzyZvQOEerax3wy7/w KX2w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=pP3dhZ+ZmPQsVzNojbnTAghRS+VVB3ge1tStzWbVoNU=; b=C+tI6J1zN5uYOrQNb68xPGLj2pnlgLBfxF1kRAtE6mYW01I/zyOhWDXKh4z+4x9g9G 33/SnB2LfjPIFpb7p+mZdDIIVfr28wxu3/IMlBh5+O27Qp9WbfU62IWtJACeFQEVs6Ib rrvQNql6M2B6CTmK0Yn7wFCr5JbYdxg9SHwWgKVvVMw9Efp9NL0dgu8/VRohhZzEagQZ 9t8KdqD8vkpcZ6B72B4JoEs1cDXui5m1/jNhxcE6hb7fWy/DHwvzwHd+pm7c0rtAU0Hm iOcE9Mre44OT7sS9Ao2cR7rUTgvdpF2nv1nqeYLaauw25JBFTsiKIIFhqqYfQcVluxXa pOXA== X-Gm-Message-State: ACgBeo2ghmOpsDsP7UXiucTTqP3xMq8wNYM1G60adW90NW4iH25D0QCH vsO85uhsx/or+1FpMy1xwNIopNefz9bYKQ== X-Google-Smtp-Source: AA6agR74Q+uc6mKMHfTPvwV2XNh93wtfFPkJQwq6Bq6L7CqxCHAHSLip5wGBeoHtWMhYL2tELX70BQ== X-Received: by 2002:a05:620a:122c:b0:6c9:cefa:f6d2 with SMTP id v12-20020a05620a122c00b006c9cefaf6d2mr11600107qkj.313.1662760441440; Fri, 09 Sep 2022 14:54:01 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id 4-20020ac85744000000b00342f8984348sm1295926qtx.87.2022.09.09.14.54.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:00 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 07/36] btrfs: temporarily export alloc_extent_state helpers Date: Fri, 9 Sep 2022 17:53:20 -0400 Message-Id: <0a21adef99bb0f2bb90d0c7032c007fdcba2bd77.1662760286.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're going to move this code in stages, but while we're doing that we need to export these helpers so we can more easily move the code into the new file. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.h | 3 +++ fs/btrfs/extent_io.c | 5 ++--- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 6c2016db304b..8e7a548b88e9 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -250,4 +250,7 @@ void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start, int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, struct page *page, unsigned int pg_offset); +struct extent_state *alloc_extent_state_atomic(struct extent_state *prealloc); +struct extent_state *alloc_extent_state(gfp_t mask); + #endif /* BTRFS_EXTENT_IO_TREE_H */ diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 35811d40e2f1..412dabccb1f4 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -339,7 +339,7 @@ void extent_io_tree_release(struct extent_io_tree *tree) spin_unlock(&tree->lock); } -static struct extent_state *alloc_extent_state(gfp_t mask) +struct extent_state *alloc_extent_state(gfp_t mask) { struct extent_state *state; @@ -710,8 +710,7 @@ static struct extent_state *clear_state_bit(struct extent_io_tree *tree, return next; } -static struct extent_state * -alloc_extent_state_atomic(struct extent_state *prealloc) +struct extent_state *alloc_extent_state_atomic(struct extent_state *prealloc) { if (!prealloc) prealloc = alloc_extent_state(GFP_ATOMIC); From patchwork Fri Sep 9 21:53: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: 12972196 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 D2EC2ECAAD3 for ; Fri, 9 Sep 2022 21:54:07 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231807AbiIIVyG (ORCPT ); Fri, 9 Sep 2022 17:54:06 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58132 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231795AbiIIVyF (ORCPT ); Fri, 9 Sep 2022 17:54:05 -0400 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 4288C10B009 for ; Fri, 9 Sep 2022 14:54:04 -0700 (PDT) Received: by mail-qv1-xf2b.google.com with SMTP id w4so2291232qvp.2 for ; Fri, 09 Sep 2022 14:54:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=k83Y1tpedwsgPm+X+YCt+4idZsENLEvibTy18VT8XJ0=; b=kzKDs8/aD3mpwVTJGbiIylR65vh29ssc2/scXs5aSD4b9/dhYngL1Tj1Jnk4/2f79D O7lx6fv7IxYnAYy/cTv5LELKfs4RaHpH/66KGdKqmxX8TU9/qKSsDMaYL2lFHVuwSiXX YMjKujOpn3BZzzC7QaudsDfoMCzXEPVt/FzncWRdM7n3TF7fK36i2pg8t1Lkpipy55en qXQ99JoGLSYRTmz3SKcK3eUfCC3MG96WCzTJ0PpkOiDEp21D3w4jmicGtAbeFvoZPrV9 6oob6tyQqSV0T5g2AtqSVZR5Pmgln34fwgnWN8uxCorD6esiEOBF9ldkwMcVoE0dz1D6 eeZw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=k83Y1tpedwsgPm+X+YCt+4idZsENLEvibTy18VT8XJ0=; b=aEJYOjtdcEFlAxJfbxOwrdN0FfEB7zAjf4Tx6zTJnp9le/mNAhfWVmtBAO8QOC5ASt UwjFDTaXwDdFhUCTg338Q/UNR3sr5EV/JIAybapMetvFiqdcgKH9p7oZgHu1xmo5nL6S yKdJjst4FtbeKUwApbbnaRJMmsvZ7lEw2c12+bKJ9sox1emhbFmZfdtaAexxW7krTinV yxrR7nYa/jC81lYWyd1i325O1/w4hH0AMAQS8SfFwm8Be2wuGkvHJjAnoGUW7/FJSLy7 nzX45LYFr2HbpisUB7lFeaVwmrUTxa/CEcAAwo1YxVaSwnD7L7wQOxaPT2OCNQLG9yut t6Fg== X-Gm-Message-State: ACgBeo1GG/iwdNArlVLQ1+8DqmcI/uC9ri7MJcDBHP6cQDAF9KfUtzpl 3x/PLCi2lCUxVaZsPOsHjtwSMYsKhGFfgw== X-Google-Smtp-Source: AA6agR66tLjrNkkGL7anQgD/C/NskMLP0ywJXD+/5alTscUs6BUDB5MEPmCfk/pdambqdAbRdFSF5g== X-Received: by 2002:ad4:5f4b:0:b0:49e:61df:c46b with SMTP id p11-20020ad45f4b000000b0049e61dfc46bmr14099381qvg.30.1662760442844; Fri, 09 Sep 2022 14:54:02 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id 16-20020a370a10000000b006b949afa980sm1192357qkk.56.2022.09.09.14.54.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:02 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 08/36] btrfs: move extent state init and alloc functions to their own file Date: Fri, 9 Sep 2022 17:53:21 -0400 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 Start cleaning up extent_io.c by moving the extent state code out of it. This patch starts with the extent state allocation code and the extent_io_tree init code. Signed-off-by: Josef Bacik --- fs/btrfs/Makefile | 2 +- fs/btrfs/extent-io-tree.c | 160 ++++++++++++++++++++++++++++++++++++++ fs/btrfs/extent-io-tree.h | 5 ++ fs/btrfs/extent_io.c | 155 ------------------------------------ 4 files changed, 166 insertions(+), 156 deletions(-) create mode 100644 fs/btrfs/extent-io-tree.c diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile index 99f9995670ea..fa9ddcc9eb0b 100644 --- a/fs/btrfs/Makefile +++ b/fs/btrfs/Makefile @@ -31,7 +31,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \ uuid-tree.o props.o free-space-tree.o tree-checker.o space-info.o \ block-rsv.o delalloc-space.o block-group.o discard.o reflink.o \ - subpage.o tree-mod-log.o + subpage.o tree-mod-log.o extent-io-tree.o btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c new file mode 100644 index 000000000000..2aedac452636 --- /dev/null +++ b/fs/btrfs/extent-io-tree.c @@ -0,0 +1,160 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include +#include "ctree.h" +#include "extent-io-tree.h" + +static struct kmem_cache *extent_state_cache; + +#ifdef CONFIG_BTRFS_DEBUG +static LIST_HEAD(states); +static DEFINE_SPINLOCK(leak_lock); + +static inline void btrfs_leak_debug_add_state(struct extent_state *state) +{ + unsigned long flags; + + spin_lock_irqsave(&leak_lock, flags); + list_add(&state->leak_list, &states); + spin_unlock_irqrestore(&leak_lock, flags); +} + +static inline void btrfs_leak_debug_del_state(struct extent_state *state) +{ + unsigned long flags; + + spin_lock_irqsave(&leak_lock, flags); + list_del(&state->leak_list); + spin_unlock_irqrestore(&leak_lock, flags); +} + +static inline void btrfs_extent_state_leak_debug_check(void) +{ + struct extent_state *state; + + while (!list_empty(&states)) { + state = list_entry(states.next, struct extent_state, leak_list); + pr_err("BTRFS: state leak: start %llu end %llu state %u in tree %d refs %d\n", + state->start, state->end, state->state, + extent_state_in_tree(state), + refcount_read(&state->refs)); + list_del(&state->leak_list); + kmem_cache_free(extent_state_cache, state); + } +} +#else +#define btrfs_leak_debug_add_state(state) do {} while (0) +#define btrfs_leak_debug_del_state(state) do {} while (0) +#define btrfs_extent_state_leak_debug_check() do {} while (0) +#endif + +/* + * For the file_extent_tree, we want to hold the inode lock when we lookup and + * update the disk_i_size, but lockdep will complain because our io_tree we hold + * the tree lock and get the inode lock when setting delalloc. These two things + * are unrelated, so make a class for the file_extent_tree so we don't get the + * two locking patterns mixed up. + */ +static struct lock_class_key file_extent_tree_class; + +void extent_io_tree_init(struct btrfs_fs_info *fs_info, + struct extent_io_tree *tree, unsigned int owner, + void *private_data) +{ + tree->fs_info = fs_info; + tree->state = RB_ROOT; + tree->dirty_bytes = 0; + spin_lock_init(&tree->lock); + tree->private_data = private_data; + tree->owner = owner; + if (owner == IO_TREE_INODE_FILE_EXTENT) + lockdep_set_class(&tree->lock, &file_extent_tree_class); +} + +void extent_io_tree_release(struct extent_io_tree *tree) +{ + spin_lock(&tree->lock); + /* + * Do a single barrier for the waitqueue_active check here, the state + * of the waitqueue should not change once extent_io_tree_release is + * called. + */ + smp_mb(); + while (!RB_EMPTY_ROOT(&tree->state)) { + struct rb_node *node; + struct extent_state *state; + + node = rb_first(&tree->state); + state = rb_entry(node, struct extent_state, rb_node); + rb_erase(&state->rb_node, &tree->state); + RB_CLEAR_NODE(&state->rb_node); + /* + * btree io trees aren't supposed to have tasks waiting for + * changes in the flags of extent states ever. + */ + ASSERT(!waitqueue_active(&state->wq)); + free_extent_state(state); + + cond_resched_lock(&tree->lock); + } + spin_unlock(&tree->lock); +} + +struct extent_state *alloc_extent_state(gfp_t mask) +{ + struct extent_state *state; + + /* + * The given mask might be not appropriate for the slab allocator, + * drop the unsupported bits + */ + mask &= ~(__GFP_DMA32|__GFP_HIGHMEM); + state = kmem_cache_alloc(extent_state_cache, mask); + if (!state) + return state; + state->state = 0; + RB_CLEAR_NODE(&state->rb_node); + btrfs_leak_debug_add_state(state); + refcount_set(&state->refs, 1); + init_waitqueue_head(&state->wq); + trace_alloc_extent_state(state, mask, _RET_IP_); + return state; +} + +struct extent_state *alloc_extent_state_atomic(struct extent_state *prealloc) +{ + if (!prealloc) + prealloc = alloc_extent_state(GFP_ATOMIC); + + return prealloc; +} + +void free_extent_state(struct extent_state *state) +{ + if (!state) + return; + if (refcount_dec_and_test(&state->refs)) { + WARN_ON(extent_state_in_tree(state)); + btrfs_leak_debug_del_state(state); + trace_free_extent_state(state, _RET_IP_); + kmem_cache_free(extent_state_cache, state); + } +} + +void __cold extent_state_free_cachep(void) +{ + btrfs_extent_state_leak_debug_check(); + kmem_cache_destroy(extent_state_cache); +} + +int __init extent_state_init_cachep(void) +{ + extent_state_cache = kmem_cache_create("btrfs_extent_state", + sizeof(struct extent_state), 0, + SLAB_MEM_SPREAD, NULL); + if (!extent_state_cache) + return -ENOMEM; + + return 0; +} diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 8e7a548b88e9..56266e75b4fe 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -253,4 +253,9 @@ int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, struct extent_state *alloc_extent_state_atomic(struct extent_state *prealloc); struct extent_state *alloc_extent_state(gfp_t mask); +static inline bool extent_state_in_tree(const struct extent_state *state) +{ + return !RB_EMPTY_NODE(&state->rb_node); +} + #endif /* BTRFS_EXTENT_IO_TREE_H */ diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 412dabccb1f4..ae746857dd6c 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -31,18 +31,9 @@ #include "block-group.h" #include "compression.h" -static struct kmem_cache *extent_state_cache; static struct kmem_cache *extent_buffer_cache; -static inline bool extent_state_in_tree(const struct extent_state *state) -{ - return !RB_EMPTY_NODE(&state->rb_node); -} - #ifdef CONFIG_BTRFS_DEBUG -static LIST_HEAD(states); -static DEFINE_SPINLOCK(leak_lock); - static inline void btrfs_leak_debug_add_eb(struct extent_buffer *eb) { struct btrfs_fs_info *fs_info = eb->fs_info; @@ -53,15 +44,6 @@ static inline void btrfs_leak_debug_add_eb(struct extent_buffer *eb) spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags); } -static inline void btrfs_leak_debug_add_state(struct extent_state *state) -{ - unsigned long flags; - - spin_lock_irqsave(&leak_lock, flags); - list_add(&state->leak_list, &states); - spin_unlock_irqrestore(&leak_lock, flags); -} - static inline void btrfs_leak_debug_del_eb(struct extent_buffer *eb) { struct btrfs_fs_info *fs_info = eb->fs_info; @@ -72,15 +54,6 @@ static inline void btrfs_leak_debug_del_eb(struct extent_buffer *eb) spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags); } -static inline void btrfs_leak_debug_del_state(struct extent_state *state) -{ - unsigned long flags; - - spin_lock_irqsave(&leak_lock, flags); - list_del(&state->leak_list); - spin_unlock_irqrestore(&leak_lock, flags); -} - void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info) { struct extent_buffer *eb; @@ -108,21 +81,6 @@ void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info) spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags); } -static inline void btrfs_extent_state_leak_debug_check(void) -{ - struct extent_state *state; - - while (!list_empty(&states)) { - state = list_entry(states.next, struct extent_state, leak_list); - pr_err("BTRFS: state leak: start %llu end %llu state %u in tree %d refs %d\n", - state->start, state->end, state->state, - extent_state_in_tree(state), - refcount_read(&state->refs)); - list_del(&state->leak_list); - kmem_cache_free(extent_state_cache, state); - } -} - #define btrfs_debug_check_extent_io_range(tree, start, end) \ __btrfs_debug_check_extent_io_range(__func__, (tree), (start), (end)) static inline void __btrfs_debug_check_extent_io_range(const char *caller, @@ -143,10 +101,7 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller, } #else #define btrfs_leak_debug_add_eb(eb) do {} while (0) -#define btrfs_leak_debug_add_state(state) do {} while (0) #define btrfs_leak_debug_del_eb(eb) do {} while (0) -#define btrfs_leak_debug_del_state(state) do {} while (0) -#define btrfs_extent_state_leak_debug_check() do {} while (0) #define btrfs_debug_check_extent_io_range(c, s, e) do {} while (0) #endif @@ -249,17 +204,6 @@ static void submit_write_bio(struct extent_page_data *epd, int ret) } } -int __init extent_state_init_cachep(void) -{ - extent_state_cache = kmem_cache_create("btrfs_extent_state", - sizeof(struct extent_state), 0, - SLAB_MEM_SPREAD, NULL); - if (!extent_state_cache) - return -ENOMEM; - - return 0; -} - int __init extent_buffer_init_cachep(void) { extent_buffer_cache = kmem_cache_create("btrfs_extent_buffer", @@ -271,12 +215,6 @@ int __init extent_buffer_init_cachep(void) return 0; } -void __cold extent_state_free_cachep(void) -{ - btrfs_extent_state_leak_debug_check(); - kmem_cache_destroy(extent_state_cache); -} - void __cold extent_buffer_free_cachep(void) { /* @@ -287,91 +225,6 @@ void __cold extent_buffer_free_cachep(void) kmem_cache_destroy(extent_buffer_cache); } -/* - * For the file_extent_tree, we want to hold the inode lock when we lookup and - * update the disk_i_size, but lockdep will complain because our io_tree we hold - * the tree lock and get the inode lock when setting delalloc. These two things - * are unrelated, so make a class for the file_extent_tree so we don't get the - * two locking patterns mixed up. - */ -static struct lock_class_key file_extent_tree_class; - -void extent_io_tree_init(struct btrfs_fs_info *fs_info, - struct extent_io_tree *tree, unsigned int owner, - void *private_data) -{ - tree->fs_info = fs_info; - tree->state = RB_ROOT; - tree->dirty_bytes = 0; - spin_lock_init(&tree->lock); - tree->private_data = private_data; - tree->owner = owner; - if (owner == IO_TREE_INODE_FILE_EXTENT) - lockdep_set_class(&tree->lock, &file_extent_tree_class); -} - -void extent_io_tree_release(struct extent_io_tree *tree) -{ - spin_lock(&tree->lock); - /* - * Do a single barrier for the waitqueue_active check here, the state - * of the waitqueue should not change once extent_io_tree_release is - * called. - */ - smp_mb(); - while (!RB_EMPTY_ROOT(&tree->state)) { - struct rb_node *node; - struct extent_state *state; - - node = rb_first(&tree->state); - state = rb_entry(node, struct extent_state, rb_node); - rb_erase(&state->rb_node, &tree->state); - RB_CLEAR_NODE(&state->rb_node); - /* - * btree io trees aren't supposed to have tasks waiting for - * changes in the flags of extent states ever. - */ - ASSERT(!waitqueue_active(&state->wq)); - free_extent_state(state); - - cond_resched_lock(&tree->lock); - } - spin_unlock(&tree->lock); -} - -struct extent_state *alloc_extent_state(gfp_t mask) -{ - struct extent_state *state; - - /* - * The given mask might be not appropriate for the slab allocator, - * drop the unsupported bits - */ - mask &= ~(__GFP_DMA32|__GFP_HIGHMEM); - state = kmem_cache_alloc(extent_state_cache, mask); - if (!state) - return state; - state->state = 0; - RB_CLEAR_NODE(&state->rb_node); - btrfs_leak_debug_add_state(state); - refcount_set(&state->refs, 1); - init_waitqueue_head(&state->wq); - trace_alloc_extent_state(state, mask, _RET_IP_); - return state; -} - -void free_extent_state(struct extent_state *state) -{ - if (!state) - return; - if (refcount_dec_and_test(&state->refs)) { - WARN_ON(extent_state_in_tree(state)); - btrfs_leak_debug_del_state(state); - trace_free_extent_state(state, _RET_IP_); - kmem_cache_free(extent_state_cache, state); - } -} - /** * Search @tree for an entry that contains @offset. Such entry would have * entry->start <= offset && entry->end >= offset. @@ -710,14 +563,6 @@ static struct extent_state *clear_state_bit(struct extent_io_tree *tree, return next; } -struct extent_state *alloc_extent_state_atomic(struct extent_state *prealloc) -{ - if (!prealloc) - prealloc = alloc_extent_state(GFP_ATOMIC); - - return prealloc; -} - static void extent_io_tree_panic(struct extent_io_tree *tree, int err) { btrfs_panic(tree->fs_info, err, From patchwork Fri Sep 9 21:53: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: 12972195 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 23909ECAAD5 for ; Fri, 9 Sep 2022 21:54:07 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231799AbiIIVyG (ORCPT ); Fri, 9 Sep 2022 17:54:06 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58124 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231755AbiIIVyF (ORCPT ); Fri, 9 Sep 2022 17:54:05 -0400 Received: from mail-qt1-x832.google.com (mail-qt1-x832.google.com [IPv6:2607:f8b0:4864:20::832]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E42CFF6BA2 for ; Fri, 9 Sep 2022 14:54:04 -0700 (PDT) Received: by mail-qt1-x832.google.com with SMTP id r20so1645226qtn.12 for ; Fri, 09 Sep 2022 14:54:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=8wPG5OFv/+Cm5y2CedtG1fVh2+JfzN3tKiGya+HyIbQ=; b=7kgtLUKDLzHNhyZj3iQ4bDl0cm3/hHatwBNVZpYHzGQ0Ri9jMYfUyQumBCuBSIg1uF 0efwRGZjvlmKuv2yoZ12wChis42QZHdlEiUu2F2jz42+RnQaB7IoTtxXvRGBAKkM3LE/ gf/EOttoxK1j4zc1X/2hen/cUnsPwkELz8kBS3lziSZrw9u9zrcDU9Lvck0HJmZ+6YLn CniPJ10MUtaEHSrzc9fpJcjJ89e+LwWLSMJpXDe1DX/1NhBR61Dj+iyX3vP3uEHvKRfo axBPRU2ftTEt7A6WWKw0l3g3HrCAYmEpxKebP2n40/OFB1clI3ytLYcTuuvR67rPTtI7 0BdA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=8wPG5OFv/+Cm5y2CedtG1fVh2+JfzN3tKiGya+HyIbQ=; b=K3Aj17VqeNMA9hBh9/8/DVpAJbUGJOzrzMkoiR9l5wHlpyiWP6Sqs0htFivDXXhBHF Uqg2hARZqCbZTBW1wIZKCw/+H3GRqC7Cvkg6IkjKeZYKuCb7pX8QzJ4QSDzexL7MdUQ0 jjshtwdeGkEuHasVJmRqUVXCPGfu7So1egNrqPjSvWH4UDIguMiliGFtWvMxycVPGf6y wt5WxUjE0curRtpYoi7DFUM5xmlG4HnxUFdIYTEh2ZpprEUmDmqVkBRCLlMfvcZ4tgBX ki9MXwxg3TCF+qb2oKJrbiBiH7F4jFUxEwdVbI48qnfYtvjd15/Xk9v3ri6rDMT/Vkth iKEw== X-Gm-Message-State: ACgBeo0+I5PJmMUgEvomwUeseTR/Mh/NXVy3O4OWA02Zg+YvME6EZeEw tJVgtpv+v1Uie69M2CpfZcqw5BKPgkeHsQ== X-Google-Smtp-Source: AA6agR4BiR2PtLe10uJKdwivKl19XpJ7tcMNTJytGzboM2K9YrxYklWdDdXyfDZIgr/w41yFz+ewrw== X-Received: by 2002:a05:622a:613:b0:342:f81f:4f7e with SMTP id z19-20020a05622a061300b00342f81f4f7emr14251758qta.198.1662760444296; Fri, 09 Sep 2022 14:54:04 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id x8-20020a05620a258800b006b919c6749esm1324815qko.91.2022.09.09.14.54.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:03 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 09/36] btrfs: convert BUG_ON(EXTENT_BIT_LOCKED) checks to ASSERT's Date: Fri, 9 Sep 2022 17:53:22 -0400 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 only call these functions from the qgroup code which doesn't call with EXTENT_BIT_LOCKED. These are BUG_ON()'s that exist to keep us developers from using these functions with EXTENT_BIT_LOCKED, so convert them to ASSERT()'s. Signed-off-by: Josef Bacik --- fs/btrfs/extent_io.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index ae746857dd6c..5ad22bc27951 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -1293,7 +1293,7 @@ int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, * either fail with -EEXIST or changeset will record the whole * range. */ - BUG_ON(bits & EXTENT_LOCKED); + ASSERT(!(bits & EXTENT_LOCKED)); return set_extent_bit(tree, start, end, bits, 0, NULL, NULL, GFP_NOFS, changeset); @@ -1321,7 +1321,7 @@ int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, * Don't support EXTENT_LOCKED case, same reason as * set_record_extent_bits(). */ - BUG_ON(bits & EXTENT_LOCKED); + ASSERT(!(bits & EXTENT_LOCKED)); return __clear_extent_bit(tree, start, end, bits, 0, 0, NULL, GFP_NOFS, changeset); From patchwork Fri Sep 9 21:53: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: 12972197 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 9CC09ECAAD3 for ; Fri, 9 Sep 2022 21:54:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231810AbiIIVyJ (ORCPT ); Fri, 9 Sep 2022 17:54:09 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58218 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231755AbiIIVyI (ORCPT ); Fri, 9 Sep 2022 17:54:08 -0400 Received: from mail-qt1-x82f.google.com (mail-qt1-x82f.google.com [IPv6:2607:f8b0:4864:20::82f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E8DD9CEB26 for ; Fri, 9 Sep 2022 14:54:06 -0700 (PDT) Received: by mail-qt1-x82f.google.com with SMTP id a3so808544qto.10 for ; Fri, 09 Sep 2022 14:54:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=swOTGocfH0e7AV6mvXQoxorMuqm1m/bwAmQIkZhRl34=; b=oroqkaioo/nwHnYGfsFBy0KLvMLY7ICU2ZyocvhAgAcCAlennkyR9/T9QTSDMClUvV OFTFQBEvKaghyuCRBYfJh1Zrl0tuJ/HgdK4Ug164YioDypjoTJ4F7UU9TeN+P2KSX55a agqmTLQFMeMHX7050LJwjpIVzYWPW9EL1KUM1wNnu+9aDv0hD6apnnBGiKUpYNcbGen9 OzoVyXVCtHC1MZ4x1vQxPDDqCtRvoK7KGnacAAgCOdxFzsv3RisFU6d8tsk9a98igQAl qb4DdRnin3njz5w1Y4qfeU5UIJc7YYlwKbnsWycbFriM4J48DPgisiXqSNm3QCNh0DQF Bcgw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=swOTGocfH0e7AV6mvXQoxorMuqm1m/bwAmQIkZhRl34=; b=ynIAg/H5eNYa8QSOpW0AEgHVrtjB3YeeMV1LDw1E52cCFSSbSwrdFhrXY8vuk6aiaN 6Uhn/dSj8RRqdatT+sBG1SLQoOfAV+x0KTNbzuFlTY+Uu7GgcAeMOyGuzhg0R6KX2+3r OHagrm1J9wPzOedRB79KV3zb9RriiFb8Rq86tlJqANprINlqh9/mEd/telLPKjGrT+Cv se60mqOOj/8AIXsFuXN+dlgaXzWgrClEYU+CRzKNuNwh8fDlVPLfzGrM3rYUzynoOI7l FPXoKO2+UwnIxcF+1w8dLgjcOiy1zkOGazMGgjeYHWt5PJwXjzk8eZ0BnB5HrH0BXixD dPgQ== X-Gm-Message-State: ACgBeo20Dm64wYK3O5lxExD8TUh+gF6kysGNHs69xDpnX1ese4CUcNJP jiA425V5zAuw+7GFeFKENSprLXWnT8qXLw== X-Google-Smtp-Source: AA6agR4MIpJKH7nOfroq5li/yXyRHsLc2/td28cXyS1k/BsfnwD4/Bdbb5wK4oWRqIS6+btM0O4EIQ== X-Received: by 2002:ac8:5c89:0:b0:343:4e44:3dbe with SMTP id r9-20020ac85c89000000b003434e443dbemr13908135qta.531.1662760445623; Fri, 09 Sep 2022 14:54:05 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id y25-20020a37f619000000b006cdd0939ffbsm1256204qkj.86.2022.09.09.14.54.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:05 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 10/36] btrfs: move simple extent bit helpers out of extent_io.c Date: Fri, 9 Sep 2022 17:53:23 -0400 Message-Id: <4814804ab1d42e492f1c181259004b91f7129e85.1662760286.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 These are just variants and wrappers around the actual work horses of the extent state. Extract these out of extent_io.c. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 45 +++++++++++++++++++++++++++++ fs/btrfs/extent-io-tree.h | 20 +++++++++---- fs/btrfs/extent_io.c | 60 --------------------------------------- 3 files changed, 60 insertions(+), 65 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 2aedac452636..7b8ac9b3bc55 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -142,6 +142,51 @@ void free_extent_state(struct extent_state *state) } } +/* wrappers around set/clear extent bit */ +int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, + u32 bits, struct extent_changeset *changeset) +{ + /* + * We don't support EXTENT_LOCKED yet, as current changeset will + * record any bits changed, so for EXTENT_LOCKED case, it will + * either fail with -EEXIST or changeset will record the whole + * range. + */ + ASSERT(!(bits & EXTENT_LOCKED)); + + return set_extent_bit(tree, start, end, bits, 0, NULL, NULL, GFP_NOFS, + changeset); +} + +int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, + u32 bits, struct extent_changeset *changeset) +{ + /* + * Don't support EXTENT_LOCKED case, same reason as + * set_record_extent_bits(). + */ + ASSERT(!(bits & EXTENT_LOCKED)); + + return __clear_extent_bit(tree, start, end, bits, 0, 0, NULL, GFP_NOFS, + changeset); +} + +int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) +{ + int err; + u64 failed_start; + + err = set_extent_bit(tree, start, end, EXTENT_LOCKED, EXTENT_LOCKED, + &failed_start, NULL, GFP_NOFS, NULL); + if (err == -EEXIST) { + if (failed_start > start) + clear_extent_bit(tree, start, failed_start - 1, + EXTENT_LOCKED, 1, 0, NULL); + return 0; + } + return 1; +} + void __cold extent_state_free_cachep(void) { btrfs_extent_state_leak_debug_check(); diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 56266e75b4fe..16a9da4149f3 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -120,14 +120,19 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, int filled, struct extent_state *cached_state); int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset); -int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, int wake, int delete, - struct extent_state **cached); int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, int wake, int delete, struct extent_state **cached, gfp_t mask, struct extent_changeset *changeset); +static inline int clear_extent_bit(struct extent_io_tree *tree, u64 start, + u64 end, u32 bits, int wake, int delete, + struct extent_state **cached) +{ + return __clear_extent_bit(tree, start, end, bits, wake, delete, + cached, GFP_NOFS, NULL); +} + static inline int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end) { return clear_extent_bit(tree, start, end, EXTENT_LOCKED, 1, 0, NULL); @@ -164,8 +169,13 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, unsigned exclusive_bits, u64 *failed_start, struct extent_state **cached_state, gfp_t mask, struct extent_changeset *changeset); -int set_extent_bits_nowait(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits); + +static inline int set_extent_bits_nowait(struct extent_io_tree *tree, u64 start, + u64 end, u32 bits) +{ + return set_extent_bit(tree, start, end, bits, 0, NULL, NULL, + GFP_NOWAIT, NULL); +} static inline int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 5ad22bc27951..eb4abca913f4 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -1283,50 +1283,6 @@ int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, return err; } -/* wrappers around set/clear extent bit */ -int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, struct extent_changeset *changeset) -{ - /* - * We don't support EXTENT_LOCKED yet, as current changeset will - * record any bits changed, so for EXTENT_LOCKED case, it will - * either fail with -EEXIST or changeset will record the whole - * range. - */ - ASSERT(!(bits & EXTENT_LOCKED)); - - return set_extent_bit(tree, start, end, bits, 0, NULL, NULL, GFP_NOFS, - changeset); -} - -int set_extent_bits_nowait(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits) -{ - return set_extent_bit(tree, start, end, bits, 0, NULL, NULL, - GFP_NOWAIT, NULL); -} - -int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, int wake, int delete, - struct extent_state **cached) -{ - return __clear_extent_bit(tree, start, end, bits, wake, delete, - cached, GFP_NOFS, NULL); -} - -int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, struct extent_changeset *changeset) -{ - /* - * Don't support EXTENT_LOCKED case, same reason as - * set_record_extent_bits(). - */ - ASSERT(!(bits & EXTENT_LOCKED)); - - return __clear_extent_bit(tree, start, end, bits, 0, 0, NULL, GFP_NOFS, - changeset); -} - /* * either insert or lock state struct between start and end use mask to tell * us if waiting is desired. @@ -1351,22 +1307,6 @@ int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, return err; } -int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) -{ - int err; - u64 failed_start; - - err = set_extent_bit(tree, start, end, EXTENT_LOCKED, EXTENT_LOCKED, - &failed_start, NULL, GFP_NOFS, NULL); - if (err == -EEXIST) { - if (failed_start > start) - clear_extent_bit(tree, start, failed_start - 1, - EXTENT_LOCKED, 1, 0, NULL); - return 0; - } - return 1; -} - void extent_range_clear_dirty_for_io(struct inode *inode, u64 start, u64 end) { unsigned long index = start >> PAGE_SHIFT; From patchwork Fri Sep 9 21:53:24 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972198 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 6EBF5ECAAA1 for ; Fri, 9 Sep 2022 21:54:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231811AbiIIVyK (ORCPT ); Fri, 9 Sep 2022 17:54:10 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58228 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231795AbiIIVyI (ORCPT ); Fri, 9 Sep 2022 17:54:08 -0400 Received: from mail-qk1-x72e.google.com (mail-qk1-x72e.google.com [IPv6:2607:f8b0:4864:20::72e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C3D12100427 for ; Fri, 9 Sep 2022 14:54:07 -0700 (PDT) Received: by mail-qk1-x72e.google.com with SMTP id d17so1442918qko.13 for ; Fri, 09 Sep 2022 14:54:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=BZNzRO0bHGDbnRpPEkZRyj4nlvwiHnduw36Zc83fb6o=; b=n/7uzKbQTi77VmeAXCl5iJvIPbsmbpT79eywahflig+O7tnbZHZ+TzImMlte+T00RT IoKmH5mKxmxACvB+mPByXnQ1YkslO1tCUX7WCfMc8rZAkgwITqZAwbqTPgzCY2YpqAx/ bDiJE/zQrMSJKrVk9dypCLlxkHnEpIvqBb5d00Zti9EjbP4Mf0/iZ++pXNT7ziUiQBPG jlUg1vd4T8z6lKoHpQvWM+VLQ7D3BBHIwrvEghszY2YgyLgS9MkPiTba8axQ6fjWoE/o uUOCyUEMEKew6N3rexI+pFsYgpkzGbfy78hhRHxX8cDJ+x4IABoir5pbOnn4QhBrxrA1 ob8g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=BZNzRO0bHGDbnRpPEkZRyj4nlvwiHnduw36Zc83fb6o=; b=MluNL/TAww7ZNW5s0eLURIWI0yIAwqnke1eeTtqpt0InXliWKIp+iZoSD/KXv2TyFi SUk9V4XXoun0I4wm9LYzMpbORKhJjeXMPZieoWtJD1BFwBxWy62SC47IlEJADLmNZNK+ ysqzQjlc4oSZyIbJXs8Lu1yHAzbhG6wYIyJjXm6P8b+T5MRJ6MmarhKEa/yvHbjkvXlY qskfQARJgKk8xebmElpzDTsA7AKowbV+mK5uCWd2ipqiW4Y4G8VcTEn97a9rNtOBdhes LcyhBslELgJ8Ll6fi5DFNUIAQepPJ3rcjkrEIyvOnpSdfzJOEHW/sBr7wQplgQtKAkz1 Ck8Q== X-Gm-Message-State: ACgBeo3oBd2gA2+YiPG7o+SZorTYCkiaivDsIDYK7yWpwOo2YpCC8g/u P9YHwsPXnLaswXcng9LAP3uJomn/HdSuPg== X-Google-Smtp-Source: AA6agR5kS8eZqGLP4IaiN/TrM+yCIufTwKDSMuiO5KpwtK/VV4bEEH3syOqJyE4HUs2ZQrTPVbNpHA== X-Received: by 2002:a05:620a:9d9:b0:6cd:d438:8b8a with SMTP id y25-20020a05620a09d900b006cdd4388b8amr2853186qky.300.1662760447030; Fri, 09 Sep 2022 14:54:07 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id j10-20020a05620a410a00b006bb83e2e65fsm1621019qko.42.2022.09.09.14.54.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:06 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 11/36] btrfs: export wait_extent_bit Date: Fri, 9 Sep 2022 17:53:24 -0400 Message-Id: <510e884aacf27cf2c4dabd53797670c1b7bfb783.1662760286.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 used by the subpage code in addition to lock_extent_bits, so export it so we can move it out of extent_io.c Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.h | 1 + fs/btrfs/extent_io.c | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 16a9da4149f3..3b63aeca941a 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -253,6 +253,7 @@ int extent_invalidate_folio(struct extent_io_tree *tree, bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, u64 *end, u64 max_bytes, struct extent_state **cached_state); +void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits); /* This should be reworked in the future and put elsewhere. */ void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start, diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index eb4abca913f4..ebe36ad40add 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -753,8 +753,7 @@ static void wait_on_state(struct extent_io_tree *tree, * The range [start, end] is inclusive. * The tree lock is taken by this function */ -static void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits) +void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { struct extent_state *state; struct rb_node *node; From patchwork Fri Sep 9 21:53:25 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972199 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 F3D29ECAAD5 for ; Fri, 9 Sep 2022 21:54:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231821AbiIIVyL (ORCPT ); Fri, 9 Sep 2022 17:54:11 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58258 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231820AbiIIVyK (ORCPT ); Fri, 9 Sep 2022 17:54:10 -0400 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 91171F913B for ; Fri, 9 Sep 2022 14:54:09 -0700 (PDT) Received: by mail-qk1-x733.google.com with SMTP id c9so2212484qkk.6 for ; Fri, 09 Sep 2022 14:54:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=ygj/Ssd7esiZwgLTADlJlAelouUW01J649zBXS25LX4=; b=Sg/OQoLLNqA1KRbDFfqTpwOknTN1uAjqGBw657TrOjxbiQCXyi+9rIjGAS7YaIVDz3 QpIKK7g2w0e+k69HOeRWHWPK0BnVsdwAzDZVFFcmwhNQIIVzMHW46pXxwhYmJITIW9+S 5Z47tx0ek2aQEEguJc0xCUndgEHqBEN31LaXGTmp6ac50dYSA5UsNNN692pp0oGjm6Gp 0SvBfpTEt3OpoLIG7EzLMyAPvccutIqJVLPmGQeGzw8l3pLZN/rDW/w6yy/mUu8M/7s6 QIWaaBplzX8rFP0oZUPaUWYOYgHE+ubpLl+6ZqaKBHbi4WImooG6shalEKF7wWlqiRc+ 0R1A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=ygj/Ssd7esiZwgLTADlJlAelouUW01J649zBXS25LX4=; b=Yr50bsNeC46KnHABqxK4YpUixhpGDjVJTPOdtDAYIIf326KnQeV47yJ4hBoQ9fHKhB waEJyNTkTDBTD9B3aF/f6fElC9RKr6ABWlQWxFkBwZ9VWapvFst3fOgjmKkCI0xbKE+M R5wRC9f5rZariDTQdlCIyy+dXbzQ2LL480NHfFa9qB86GboJGzFQ42cQg8CH8BNSkZaZ hGC8ylN6/FRQ4M++iPH6ZSUS6XTnslae3AbW3mzMQ6eBhTb/m2oo9jh8NKer8wcVoEY+ eEgQMPHeU5h41mpqlrkvKf16d2T2WEFMgCooT5PGYpAifR/0hVBX2nU5TsSqVufOcSzT nO5g== X-Gm-Message-State: ACgBeo3G5fZzYmH6boWLia2LGeY/D7kxqtjLhJheY1f54469kTb5G+Qi +xUigRbIPJxsa3do1t9EqJOVjxixlXmCaA== X-Google-Smtp-Source: AA6agR4lLrqbnDzQbZXbJZ3d6Ige+pg3dzwcXT+9QsD+8JrFNkkg57HziWkmU8H3BztF30xQefV8ug== X-Received: by 2002:a37:9d7:0:b0:6cd:6ccb:a8fc with SMTP id 206-20020a3709d7000000b006cd6ccba8fcmr3491132qkj.92.1662760448380; Fri, 09 Sep 2022 14:54:08 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id n21-20020a05620a295500b006bb49cfe147sm1751865qkp.84.2022.09.09.14.54.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:08 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 12/36] btrfs: move btrfs_debug_check_extent_io_range into extent-io-tree.c Date: Fri, 9 Sep 2022 17:53:25 -0400 Message-Id: <6d50ac3c839be3f77c14eede420352c99f1095bb.1662760286.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 helper is used by a lot of the core extent_io_tree helpers, so temporarily export it and move it into extent-io-tree.c in order to make it straightforward to migrate the helpers in batches. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 19 +++++++++++++++++++ fs/btrfs/extent-io-tree.h | 10 ++++++++++ fs/btrfs/extent_io.c | 20 -------------------- 3 files changed, 29 insertions(+), 20 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 7b8ac9b3bc55..b38aa46c86a1 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -4,6 +4,7 @@ #include #include "ctree.h" #include "extent-io-tree.h" +#include "btrfs_inode.h" static struct kmem_cache *extent_state_cache; @@ -43,6 +44,24 @@ static inline void btrfs_extent_state_leak_debug_check(void) kmem_cache_free(extent_state_cache, state); } } + +void __btrfs_debug_check_extent_io_range(const char *caller, + struct extent_io_tree *tree, u64 start, + u64 end) +{ + struct inode *inode = tree->private_data; + u64 isize; + + if (!inode || !is_data_inode(inode)) + return; + + isize = i_size_read(inode); + if (end >= PAGE_SIZE && (end % 2) == 0 && end != isize - 1) { + btrfs_debug_rl(BTRFS_I(inode)->root->fs_info, + "%s: ino %llu isize %llu odd range [%llu,%llu]", + caller, btrfs_ino(BTRFS_I(inode)), isize, start, end); + } +} #else #define btrfs_leak_debug_add_state(state) do {} while (0) #define btrfs_leak_debug_del_state(state) do {} while (0) diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 3b63aeca941a..d9c1bb70d76b 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -269,4 +269,14 @@ static inline bool extent_state_in_tree(const struct extent_state *state) return !RB_EMPTY_NODE(&state->rb_node); } +#ifdef CONFIG_BTRFS_DEBUG +void __btrfs_debug_check_extent_io_range(const char *caller, + struct extent_io_tree *tree, u64 start, + u64 end); +#define btrfs_debug_check_extent_io_range(tree, start, end) \ + __btrfs_debug_check_extent_io_range(__func__, (tree), (start), (end)) +#else +#define btrfs_debug_check_extent_io_range(c, s, e) do {} while (0) +#endif + #endif /* BTRFS_EXTENT_IO_TREE_H */ diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index ebe36ad40add..8d8a2cf177ac 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -80,29 +80,9 @@ void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info) } spin_unlock_irqrestore(&fs_info->eb_leak_lock, flags); } - -#define btrfs_debug_check_extent_io_range(tree, start, end) \ - __btrfs_debug_check_extent_io_range(__func__, (tree), (start), (end)) -static inline void __btrfs_debug_check_extent_io_range(const char *caller, - struct extent_io_tree *tree, u64 start, u64 end) -{ - struct inode *inode = tree->private_data; - u64 isize; - - if (!inode || !is_data_inode(inode)) - return; - - isize = i_size_read(inode); - if (end >= PAGE_SIZE && (end % 2) == 0 && end != isize - 1) { - btrfs_debug_rl(BTRFS_I(inode)->root->fs_info, - "%s: ino %llu isize %llu odd range [%llu,%llu]", - caller, btrfs_ino(BTRFS_I(inode)), isize, start, end); - } -} #else #define btrfs_leak_debug_add_eb(eb) do {} while (0) #define btrfs_leak_debug_del_eb(eb) do {} while (0) -#define btrfs_debug_check_extent_io_range(c, s, e) do {} while (0) #endif struct tree_entry { From patchwork Fri Sep 9 21:53:26 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972200 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 DA19CECAAD3 for ; Fri, 9 Sep 2022 21:54:14 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231836AbiIIVyN (ORCPT ); Fri, 9 Sep 2022 17:54:13 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58296 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231820AbiIIVyM (ORCPT ); Fri, 9 Sep 2022 17:54:12 -0400 Received: from mail-qt1-x82f.google.com (mail-qt1-x82f.google.com [IPv6:2607:f8b0:4864:20::82f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 790A3F651D for ; Fri, 9 Sep 2022 14:54:10 -0700 (PDT) Received: by mail-qt1-x82f.google.com with SMTP id a3so808645qto.10 for ; Fri, 09 Sep 2022 14:54:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=8fmQiplXoeNhOXIFMnUk7aC0hhtIIS6l4LnW+GM2Rsg=; b=nFH3THRq4NqmA5pUShqc0kYd6S8pqkA0/Opf89k+3Szrov6NytMyEHgfocUiTMv5cG DDEnxO9viB9atNHtpMVggwmkv3IrtPOtF1ARrx9P8GVCaIjV8bpYQwfSwbsLkZis1eR/ nzLdrzfwFTEMCZRYf9hb/6jY23D7JrrErKraB7aeqSkh12vWBQ1q1BZbZM0U/rxiT8Un 9YRemBVWfhw8c6fZJ2aRnnL/mkhdi/nTxekfPV4pALXl4kz62atepkGWHpoFG6dkl8DL PS7lUXeFF6tgaM9EW1sen9pIXji627hXY463Wg3nlOjP7NT7AgPnG6+l+Pf9SDdjAMK1 M0tg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=8fmQiplXoeNhOXIFMnUk7aC0hhtIIS6l4LnW+GM2Rsg=; b=UIAAF2tni5HCyr1OP4Nndxkz/bJizChxs91JGd/REwDVo0/4CDV/7bJfQ1R9Nz/ot2 hWImeoden6OSFHIxd0ULEdr5CMIdBrw7V1Mjc1Oh3qD3SZT9+uQM8y7CVZSwwbnp4l2d ESrwkGAPT9nPkvVg+xqK1YjVcWopmmU+omGwPYqdlWjTF41VSUMaV3wTLKza9N2BQZ7H MxNb8j4CQjEcjmkxrJk0E52u6da5cxwZnJRxk305me4VutY2WKBnz2hQ0MZ2FbLk1oPp kG8C1kDNRGm35j9xLKTfDxsgH6MpDq0KHSd43ZG8mCfbvBWVzCiRsnRW0cgEdy6+nLJF qHXg== X-Gm-Message-State: ACgBeo3HasLFY9N7zAFK/2QO12H1omrLzmYCiaLXCS1LZvDJUfSnVRNF +iwPmLIGwy9lWhuWs7pHnb00nfzJXf0XOA== X-Google-Smtp-Source: AA6agR4jiR2MmdQhelxvyoCTImWgEFLdrweBAhnRfJWLF3BN/WTf1DW04bOCmTv1D1OFimM4vSxL/g== X-Received: by 2002:ac8:5808:0:b0:35a:7219:f31d with SMTP id g8-20020ac85808000000b0035a7219f31dmr6388671qtg.221.1662760449718; Fri, 09 Sep 2022 14:54:09 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id i8-20020ac860c8000000b00304fe5247bfsm1239052qtm.36.2022.09.09.14.54.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:09 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 13/36] btrfs: temporarily export and move core extent_io_tree tree functions Date: Fri, 9 Sep 2022 17:53:26 -0400 Message-Id: <433b8c2e4971e0cf26c96cb62fe83485a3bfc855.1662760286.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 A lot of the various internals of extent_io_tree call these two functions for insert or searching the rb tree for entries, so temporarily export them and then move them to extent-io-tree.c. We can't move tree_search() without renaming it, and I don't want to introduce a bunch of churn just to do that, so move these functions first and then we can move a few big functions and then the remaining users of tree_search(). Signed-off-by: Josef Bacik Reported-by: kernel test robot --- fs/btrfs/extent-io-tree.c | 107 +++++++++++++++++++++++++++++++++++ fs/btrfs/extent-io-tree.h | 13 +++++ fs/btrfs/extent_io.c | 115 -------------------------------------- 3 files changed, 120 insertions(+), 115 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index b38aa46c86a1..d3d5c24ed820 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -161,6 +161,113 @@ void free_extent_state(struct extent_state *state) } } +/** + * Search @tree for an entry that contains @offset. Such entry would have + * entry->start <= offset && entry->end >= offset. + * + * @tree: the tree to search + * @offset: offset that should fall within an entry in @tree + * @node_ret: pointer where new node should be anchored (used when inserting an + * entry in the tree) + * @parent_ret: points to entry which would have been the parent of the entry, + * containing @offset + * + * Return a pointer to the entry that contains @offset byte address and don't change + * @node_ret and @parent_ret. + * + * If no such entry exists, return pointer to entry that ends before @offset + * and fill parameters @node_ret and @parent_ret, ie. does not return NULL. + */ +struct rb_node *tree_search_for_insert(struct extent_io_tree *tree, u64 offset, + struct rb_node ***node_ret, + struct rb_node **parent_ret) +{ + struct rb_root *root = &tree->state; + struct rb_node **node = &root->rb_node; + struct rb_node *prev = NULL; + struct tree_entry *entry; + + while (*node) { + prev = *node; + entry = rb_entry(prev, struct tree_entry, rb_node); + + if (offset < entry->start) + node = &(*node)->rb_left; + else if (offset > entry->end) + node = &(*node)->rb_right; + else + return *node; + } + + if (node_ret) + *node_ret = node; + if (parent_ret) + *parent_ret = prev; + + /* Search neighbors until we find the first one past the end */ + while (prev && offset > entry->end) { + prev = rb_next(prev); + entry = rb_entry(prev, struct tree_entry, rb_node); + } + + return prev; +} + +/** + * Search offset in the tree or fill neighbor rbtree node pointers. + * + * @tree: the tree to search + * @offset: offset that should fall within an entry in @tree + * @next_ret: pointer to the first entry whose range ends after @offset + * @prev_ret: pointer to the first entry whose range begins before @offset + * + * Return a pointer to the entry that contains @offset byte address. If no + * such entry exists, then return NULL and fill @prev_ret and @next_ret. + * Otherwise return the found entry and other pointers are left untouched. + */ +struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, u64 offset, + struct rb_node **prev_ret, + struct rb_node **next_ret) +{ + struct rb_root *root = &tree->state; + struct rb_node **node = &root->rb_node; + struct rb_node *prev = NULL; + struct rb_node *orig_prev = NULL; + struct tree_entry *entry; + + ASSERT(prev_ret); + ASSERT(next_ret); + + while (*node) { + prev = *node; + entry = rb_entry(prev, struct tree_entry, rb_node); + + if (offset < entry->start) + node = &(*node)->rb_left; + else if (offset > entry->end) + node = &(*node)->rb_right; + else + return *node; + } + + orig_prev = prev; + while (prev && offset > entry->end) { + prev = rb_next(prev); + entry = rb_entry(prev, struct tree_entry, rb_node); + } + *next_ret = prev; + prev = orig_prev; + + entry = rb_entry(prev, struct tree_entry, rb_node); + while (prev && offset < entry->start) { + prev = rb_prev(prev); + entry = rb_entry(prev, struct tree_entry, rb_node); + } + *prev_ret = prev; + + return NULL; +} + /* wrappers around set/clear extent bit */ int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset) diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index d9c1bb70d76b..ce07432954b4 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -279,4 +279,17 @@ void __btrfs_debug_check_extent_io_range(const char *caller, #define btrfs_debug_check_extent_io_range(c, s, e) do {} while (0) #endif +struct tree_entry { + u64 start; + u64 end; + struct rb_node rb_node; +}; + +struct rb_node *tree_search_for_insert(struct extent_io_tree *tree, u64 offset, + struct rb_node ***node_ret, + struct rb_node **parent_ret); +struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, u64 offset, + struct rb_node **prev_ret, + struct rb_node **next_ret); + #endif /* BTRFS_EXTENT_IO_TREE_H */ diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 8d8a2cf177ac..852f29ea00ce 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -85,12 +85,6 @@ void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info) #define btrfs_leak_debug_del_eb(eb) do {} while (0) #endif -struct tree_entry { - u64 start; - u64 end; - struct rb_node rb_node; -}; - /* * Structure to record info about the bio being assembled, and other info like * how many bytes are there before stripe/ordered extent boundary. @@ -205,59 +199,6 @@ void __cold extent_buffer_free_cachep(void) kmem_cache_destroy(extent_buffer_cache); } -/** - * Search @tree for an entry that contains @offset. Such entry would have - * entry->start <= offset && entry->end >= offset. - * - * @tree: the tree to search - * @offset: offset that should fall within an entry in @tree - * @node_ret: pointer where new node should be anchored (used when inserting an - * entry in the tree) - * @parent_ret: points to entry which would have been the parent of the entry, - * containing @offset - * - * Return a pointer to the entry that contains @offset byte address and don't change - * @node_ret and @parent_ret. - * - * If no such entry exists, return pointer to entry that ends before @offset - * and fill parameters @node_ret and @parent_ret, ie. does not return NULL. - */ -static inline struct rb_node *tree_search_for_insert(struct extent_io_tree *tree, - u64 offset, - struct rb_node ***node_ret, - struct rb_node **parent_ret) -{ - struct rb_root *root = &tree->state; - struct rb_node **node = &root->rb_node; - struct rb_node *prev = NULL; - struct tree_entry *entry; - - while (*node) { - prev = *node; - entry = rb_entry(prev, struct tree_entry, rb_node); - - if (offset < entry->start) - node = &(*node)->rb_left; - else if (offset > entry->end) - node = &(*node)->rb_right; - else - return *node; - } - - if (node_ret) - *node_ret = node; - if (parent_ret) - *parent_ret = prev; - - /* Search neighbors until we find the first one past the end */ - while (prev && offset > entry->end) { - prev = rb_next(prev); - entry = rb_entry(prev, struct tree_entry, rb_node); - } - - return prev; -} - /* * Inexact rb-tree search, return the next entry if @offset is not found */ @@ -266,62 +207,6 @@ static inline struct rb_node *tree_search(struct extent_io_tree *tree, u64 offse return tree_search_for_insert(tree, offset, NULL, NULL); } -/** - * Search offset in the tree or fill neighbor rbtree node pointers. - * - * @tree: the tree to search - * @offset: offset that should fall within an entry in @tree - * @next_ret: pointer to the first entry whose range ends after @offset - * @prev_ret: pointer to the first entry whose range begins before @offset - * - * Return a pointer to the entry that contains @offset byte address. If no - * such entry exists, then return NULL and fill @prev_ret and @next_ret. - * Otherwise return the found entry and other pointers are left untouched. - */ -static struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, - u64 offset, - struct rb_node **prev_ret, - struct rb_node **next_ret) -{ - struct rb_root *root = &tree->state; - struct rb_node **node = &root->rb_node; - struct rb_node *prev = NULL; - struct rb_node *orig_prev = NULL; - struct tree_entry *entry; - - ASSERT(prev_ret); - ASSERT(next_ret); - - while (*node) { - prev = *node; - entry = rb_entry(prev, struct tree_entry, rb_node); - - if (offset < entry->start) - node = &(*node)->rb_left; - else if (offset > entry->end) - node = &(*node)->rb_right; - else - return *node; - } - - orig_prev = prev; - while (prev && offset > entry->end) { - prev = rb_next(prev); - entry = rb_entry(prev, struct tree_entry, rb_node); - } - *next_ret = prev; - prev = orig_prev; - - entry = rb_entry(prev, struct tree_entry, rb_node); - while (prev && offset < entry->start) { - prev = rb_prev(prev); - entry = rb_entry(prev, struct tree_entry, rb_node); - } - *prev_ret = prev; - - return NULL; -} - /* * utility function to look for merge candidates inside a given range. * Any extents with matching state are merged together into a single From patchwork Fri Sep 9 21:53:27 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972201 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 405A5ECAAA1 for ; Fri, 9 Sep 2022 21:54:16 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230012AbiIIVyO (ORCPT ); Fri, 9 Sep 2022 17:54:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58312 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231829AbiIIVyN (ORCPT ); Fri, 9 Sep 2022 17:54:13 -0400 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 EB81910B573 for ; Fri, 9 Sep 2022 14:54:11 -0700 (PDT) Received: by mail-qk1-x734.google.com with SMTP id j6so2204218qkl.10 for ; Fri, 09 Sep 2022 14:54:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=TzrpwW8Bygt4v46Ij11RFpHynq8d67Wsk5QDfEVEdjc=; b=Qnj8N+MZVrAw82j4IYkd7ynHztUVOcj8DeV1+O2hWGmV1SnuP5KGiVOc4Z58DR0Ud5 +tFWHycG5uo3nwy0/Y8wYFqwGJTRzaCN6mOWbCBq3AT8dykpNAy/LLL4zqfoFVn+lTDc y5Jaj3f1cQq2upcWZWWaxv+/HdFArGghcpj/JdZ1+cAnLxVgzt0sJ+Esyo4qOXQlca3Y 4VmaijN6UU/9HA80HIedQgIGcvxDrekSUwHecP3050OJCAxAf1ecI/fMuqdFznZJ8eWR lDkcZIvJq2yQPkXLefCCLDAFRSge77yWKkcWvTncWGz0ctrLa5XauAinlf/BeA2Pf37V O8fw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=TzrpwW8Bygt4v46Ij11RFpHynq8d67Wsk5QDfEVEdjc=; b=z00nbMHZjwkOGVbyPvPXQAQVIt/0ZtyvfZxmx2io4NpJmiRs5lqgNPYqSXVkph1Xju Ecf6amtwwBnNkDZ6ZxkGDwz5JaFZaHl5D95LZlg9jC0IOY8VbkUS7jTXbBS4YxVBNyw9 5nvusbJ+i5vtVbJR2Nz+YDkv1h2PFNotFiUeepL3rfjDurq0RDZf7/M0cADIEZSezCK5 PRtAQwLes0XxKXIKkT5hTGKEfGsg7TRdakh/9YAQ5ZzRmUnNahcS+eG6CVAM3E6b5t3U KmG69WMOf/7xNN83Ts2jdrG+gliGuJ61LNQowGyuY2yF9/K0+QEYwMYObfAqBDLXWUNc JKDQ== X-Gm-Message-State: ACgBeo3K05ObU5aSdAPLqAOG1SwGcNhpVE8NFqI2g4DBWPY5dM9eH9pF B7E0fMyO3ALN8hmJf/V3ndetjfqHgb3jzA== X-Google-Smtp-Source: AA6agR7zCeRjZPZUqUmR748BMYoTB7nyzRAx7OOhQmegnrvn+gU27qNSK6ugwdXGGBZPuh/ptFtQPQ== X-Received: by 2002:a05:620a:254e:b0:6c9:cc85:c41a with SMTP id s14-20020a05620a254e00b006c9cc85c41amr11909765qko.260.1662760451142; Fri, 09 Sep 2022 14:54:11 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id d10-20020a05622a05ca00b003430589dd34sm1426973qtb.57.2022.09.09.14.54.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:10 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 14/36] btrfs: temporarily export and then move extent state helpers Date: Fri, 9 Sep 2022 17:53:27 -0400 Message-Id: <51721f4bfbba615dcf597116046ad0d11499b0d9.1662760286.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 order to avoid moving all of the related code at once temporarily export all of the extent state related helpers. Then move these helpers into extent-io-tree.c. We will clean up the exports and make them static in followup patches. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 242 +++++++++++++++++++++++++++++++++++ fs/btrfs/extent-io-tree.h | 25 ++++ fs/btrfs/extent_io.c | 258 -------------------------------------- 3 files changed, 267 insertions(+), 258 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index d3d5c24ed820..882f9a609d11 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -161,6 +161,24 @@ void free_extent_state(struct extent_state *state) } } +static int add_extent_changeset(struct extent_state *state, u32 bits, + struct extent_changeset *changeset, + int set) +{ + int ret; + + if (!changeset) + return 0; + if (set && (state->state & bits) == bits) + return 0; + if (!set && (state->state & bits) == 0) + return 0; + changeset->bytes_changed += state->end - state->start + 1; + ret = ulist_add(&changeset->range_changed, state->start, state->end, + GFP_ATOMIC); + return ret; +} + /** * Search @tree for an entry that contains @offset. Such entry would have * entry->start <= offset && entry->end >= offset. @@ -268,6 +286,230 @@ struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, u64 offset, return NULL; } +/* + * utility function to look for merge candidates inside a given range. + * Any extents with matching state are merged together into a single + * extent in the tree. Extents with EXTENT_IO in their state field + * are not merged because the end_io handlers need to be able to do + * operations on them without sleeping (or doing allocations/splits). + * + * This should be called with the tree lock held. + */ +void merge_state(struct extent_io_tree *tree, struct extent_state *state) +{ + struct extent_state *other; + struct rb_node *other_node; + + if (state->state & (EXTENT_LOCKED | EXTENT_BOUNDARY)) + return; + + other_node = rb_prev(&state->rb_node); + if (other_node) { + other = rb_entry(other_node, struct extent_state, rb_node); + if (other->end == state->start - 1 && + other->state == state->state) { + if (tree->private_data && + is_data_inode(tree->private_data)) + btrfs_merge_delalloc_extent(tree->private_data, + state, other); + state->start = other->start; + rb_erase(&other->rb_node, &tree->state); + RB_CLEAR_NODE(&other->rb_node); + free_extent_state(other); + } + } + other_node = rb_next(&state->rb_node); + if (other_node) { + other = rb_entry(other_node, struct extent_state, rb_node); + if (other->start == state->end + 1 && + other->state == state->state) { + if (tree->private_data && + is_data_inode(tree->private_data)) + btrfs_merge_delalloc_extent(tree->private_data, + state, other); + state->end = other->end; + rb_erase(&other->rb_node, &tree->state); + RB_CLEAR_NODE(&other->rb_node); + free_extent_state(other); + } + } +} + +void set_state_bits(struct extent_io_tree *tree, struct extent_state *state, + u32 bits, struct extent_changeset *changeset) +{ + u32 bits_to_set = bits & ~EXTENT_CTLBITS; + int ret; + + if (tree->private_data && is_data_inode(tree->private_data)) + btrfs_set_delalloc_extent(tree->private_data, state, bits); + + if ((bits_to_set & EXTENT_DIRTY) && !(state->state & EXTENT_DIRTY)) { + u64 range = state->end - state->start + 1; + tree->dirty_bytes += range; + } + ret = add_extent_changeset(state, bits_to_set, changeset, 1); + BUG_ON(ret < 0); + state->state |= bits_to_set; +} + +/* + * insert an extent_state struct into the tree. 'bits' are set on the + * struct before it is inserted. + * + * This may return -EEXIST if the extent is already there, in which case the + * state struct is freed. + * + * The tree lock is not taken internally. This is a utility function and + * probably isn't what you want to call (see set/clear_extent_bit). + */ +int insert_state(struct extent_io_tree *tree, struct extent_state *state, + u32 bits, struct extent_changeset *changeset) +{ + struct rb_node **node; + struct rb_node *parent; + const u64 end = state->end; + + set_state_bits(tree, state, bits, changeset); + + node = &tree->state.rb_node; + while (*node) { + struct tree_entry *entry; + + parent = *node; + entry = rb_entry(parent, struct tree_entry, rb_node); + + if (end < entry->start) { + node = &(*node)->rb_left; + } else if (end > entry->end) { + node = &(*node)->rb_right; + } else { + btrfs_err(tree->fs_info, + "found node %llu %llu on insert of %llu %llu", + entry->start, entry->end, state->start, end); + return -EEXIST; + } + } + + rb_link_node(&state->rb_node, parent, node); + rb_insert_color(&state->rb_node, &tree->state); + + merge_state(tree, state); + return 0; +} + +/* + * Insert state to @tree to the location given by @node and @parent. + */ +void insert_state_fast(struct extent_io_tree *tree, struct extent_state *state, + struct rb_node **node, struct rb_node *parent, + unsigned bits, struct extent_changeset *changeset) +{ + set_state_bits(tree, state, bits, changeset); + rb_link_node(&state->rb_node, parent, node); + rb_insert_color(&state->rb_node, &tree->state); + merge_state(tree, state); +} + +/* + * split a given extent state struct in two, inserting the preallocated + * struct 'prealloc' as the newly created second half. 'split' indicates an + * offset inside 'orig' where it should be split. + * + * Before calling, + * the tree has 'orig' at [orig->start, orig->end]. After calling, there + * are two extent state structs in the tree: + * prealloc: [orig->start, split - 1] + * orig: [ split, orig->end ] + * + * The tree locks are not taken by this function. They need to be held + * by the caller. + */ +int split_state(struct extent_io_tree *tree, struct extent_state *orig, + struct extent_state *prealloc, u64 split) +{ + struct rb_node *parent = NULL; + struct rb_node **node; + + if (tree->private_data && is_data_inode(tree->private_data)) + btrfs_split_delalloc_extent(tree->private_data, orig, split); + + prealloc->start = orig->start; + prealloc->end = split - 1; + prealloc->state = orig->state; + orig->start = split; + + parent = &orig->rb_node; + node = &parent; + while (*node) { + struct tree_entry *entry; + + parent = *node; + entry = rb_entry(parent, struct tree_entry, rb_node); + + if (prealloc->end < entry->start) { + node = &(*node)->rb_left; + } else if (prealloc->end > entry->end) { + node = &(*node)->rb_right; + } else { + free_extent_state(prealloc); + return -EEXIST; + } + } + + rb_link_node(&prealloc->rb_node, parent, node); + rb_insert_color(&prealloc->rb_node, &tree->state); + + return 0; +} + + +/* + * utility function to clear some bits in an extent state struct. + * it will optionally wake up anyone waiting on this state (wake == 1). + * + * If no bits are set on the state struct after clearing things, the + * struct is freed and removed from the tree + */ +struct extent_state *clear_state_bit(struct extent_io_tree *tree, + struct extent_state *state, u32 bits, + int wake, + struct extent_changeset *changeset) +{ + struct extent_state *next; + u32 bits_to_clear = bits & ~EXTENT_CTLBITS; + int ret; + + if ((bits_to_clear & EXTENT_DIRTY) && (state->state & EXTENT_DIRTY)) { + u64 range = state->end - state->start + 1; + WARN_ON(range > tree->dirty_bytes); + tree->dirty_bytes -= range; + } + + if (tree->private_data && is_data_inode(tree->private_data)) + btrfs_clear_delalloc_extent(tree->private_data, state, bits); + + ret = add_extent_changeset(state, bits_to_clear, changeset, 0); + BUG_ON(ret < 0); + state->state &= ~bits_to_clear; + if (wake) + wake_up(&state->wq); + if (state->state == 0) { + next = next_state(state); + if (extent_state_in_tree(state)) { + rb_erase(&state->rb_node, &tree->state); + RB_CLEAR_NODE(&state->rb_node); + free_extent_state(state); + } else { + WARN_ON(1); + } + } else { + merge_state(tree, state); + next = next_state(state); + } + return next; +} + /* wrappers around set/clear extent bit */ int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset) diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index ce07432954b4..251f1fc9a5b7 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -291,5 +291,30 @@ struct rb_node *tree_search_for_insert(struct extent_io_tree *tree, u64 offset, struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, u64 offset, struct rb_node **prev_ret, struct rb_node **next_ret); +void merge_state(struct extent_io_tree *tree, struct extent_state *state); + +static inline struct extent_state *next_state(struct extent_state *state) +{ + struct rb_node *next = rb_next(&state->rb_node); + if (next) + return rb_entry(next, struct extent_state, rb_node); + else + return NULL; +} +struct extent_state *clear_state_bit(struct extent_io_tree *tree, + struct extent_state *state, u32 bits, + int wake, + struct extent_changeset *changeset); +int insert_state(struct extent_io_tree *tree, struct extent_state *state, + u32 bits, struct extent_changeset *changeset); +int split_state(struct extent_io_tree *tree, struct extent_state *orig, + struct extent_state *prealloc, u64 split); +int insert_state(struct extent_io_tree *tree, struct extent_state *state, + u32 bits, struct extent_changeset *changeset); +void insert_state_fast(struct extent_io_tree *tree, struct extent_state *state, + struct rb_node **node, struct rb_node *parent, + unsigned bits, struct extent_changeset *changeset); +void set_state_bits(struct extent_io_tree *tree, struct extent_state *state, + u32 bits, struct extent_changeset *changeset); #endif /* BTRFS_EXTENT_IO_TREE_H */ diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 852f29ea00ce..65e239ab3dc0 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -108,24 +108,6 @@ struct extent_page_data { unsigned int sync_io:1; }; -static int add_extent_changeset(struct extent_state *state, u32 bits, - struct extent_changeset *changeset, - int set) -{ - int ret; - - if (!changeset) - return 0; - if (set && (state->state & bits) == bits) - return 0; - if (!set && (state->state & bits) == 0) - return 0; - changeset->bytes_changed += state->end - state->start + 1; - ret = ulist_add(&changeset->range_changed, state->start, state->end, - GFP_ATOMIC); - return ret; -} - static void submit_one_bio(struct btrfs_bio_ctrl *bio_ctrl) { struct bio *bio; @@ -207,227 +189,6 @@ static inline struct rb_node *tree_search(struct extent_io_tree *tree, u64 offse return tree_search_for_insert(tree, offset, NULL, NULL); } -/* - * utility function to look for merge candidates inside a given range. - * Any extents with matching state are merged together into a single - * extent in the tree. Extents with EXTENT_IO in their state field - * are not merged because the end_io handlers need to be able to do - * operations on them without sleeping (or doing allocations/splits). - * - * This should be called with the tree lock held. - */ -static void merge_state(struct extent_io_tree *tree, - struct extent_state *state) -{ - struct extent_state *other; - struct rb_node *other_node; - - if (state->state & (EXTENT_LOCKED | EXTENT_BOUNDARY)) - return; - - other_node = rb_prev(&state->rb_node); - if (other_node) { - other = rb_entry(other_node, struct extent_state, rb_node); - if (other->end == state->start - 1 && - other->state == state->state) { - if (tree->private_data && - is_data_inode(tree->private_data)) - btrfs_merge_delalloc_extent(tree->private_data, - state, other); - state->start = other->start; - rb_erase(&other->rb_node, &tree->state); - RB_CLEAR_NODE(&other->rb_node); - free_extent_state(other); - } - } - other_node = rb_next(&state->rb_node); - if (other_node) { - other = rb_entry(other_node, struct extent_state, rb_node); - if (other->start == state->end + 1 && - other->state == state->state) { - if (tree->private_data && - is_data_inode(tree->private_data)) - btrfs_merge_delalloc_extent(tree->private_data, - state, other); - state->end = other->end; - rb_erase(&other->rb_node, &tree->state); - RB_CLEAR_NODE(&other->rb_node); - free_extent_state(other); - } - } -} - -static void set_state_bits(struct extent_io_tree *tree, - struct extent_state *state, u32 bits, - struct extent_changeset *changeset); - -/* - * insert an extent_state struct into the tree. 'bits' are set on the - * struct before it is inserted. - * - * This may return -EEXIST if the extent is already there, in which case the - * state struct is freed. - * - * The tree lock is not taken internally. This is a utility function and - * probably isn't what you want to call (see set/clear_extent_bit). - */ -static int insert_state(struct extent_io_tree *tree, - struct extent_state *state, - u32 bits, struct extent_changeset *changeset) -{ - struct rb_node **node; - struct rb_node *parent; - const u64 end = state->end; - - set_state_bits(tree, state, bits, changeset); - - node = &tree->state.rb_node; - while (*node) { - struct tree_entry *entry; - - parent = *node; - entry = rb_entry(parent, struct tree_entry, rb_node); - - if (end < entry->start) { - node = &(*node)->rb_left; - } else if (end > entry->end) { - node = &(*node)->rb_right; - } else { - btrfs_err(tree->fs_info, - "found node %llu %llu on insert of %llu %llu", - entry->start, entry->end, state->start, end); - return -EEXIST; - } - } - - rb_link_node(&state->rb_node, parent, node); - rb_insert_color(&state->rb_node, &tree->state); - - merge_state(tree, state); - return 0; -} - -/* - * Insert state to @tree to the location given by @node and @parent. - */ -static void insert_state_fast(struct extent_io_tree *tree, - struct extent_state *state, struct rb_node **node, - struct rb_node *parent, unsigned bits, - struct extent_changeset *changeset) -{ - set_state_bits(tree, state, bits, changeset); - rb_link_node(&state->rb_node, parent, node); - rb_insert_color(&state->rb_node, &tree->state); - merge_state(tree, state); -} - -/* - * split a given extent state struct in two, inserting the preallocated - * struct 'prealloc' as the newly created second half. 'split' indicates an - * offset inside 'orig' where it should be split. - * - * Before calling, - * the tree has 'orig' at [orig->start, orig->end]. After calling, there - * are two extent state structs in the tree: - * prealloc: [orig->start, split - 1] - * orig: [ split, orig->end ] - * - * The tree locks are not taken by this function. They need to be held - * by the caller. - */ -static int split_state(struct extent_io_tree *tree, struct extent_state *orig, - struct extent_state *prealloc, u64 split) -{ - struct rb_node *parent = NULL; - struct rb_node **node; - - if (tree->private_data && is_data_inode(tree->private_data)) - btrfs_split_delalloc_extent(tree->private_data, orig, split); - - prealloc->start = orig->start; - prealloc->end = split - 1; - prealloc->state = orig->state; - orig->start = split; - - parent = &orig->rb_node; - node = &parent; - while (*node) { - struct tree_entry *entry; - - parent = *node; - entry = rb_entry(parent, struct tree_entry, rb_node); - - if (prealloc->end < entry->start) { - node = &(*node)->rb_left; - } else if (prealloc->end > entry->end) { - node = &(*node)->rb_right; - } else { - free_extent_state(prealloc); - return -EEXIST; - } - } - - rb_link_node(&prealloc->rb_node, parent, node); - rb_insert_color(&prealloc->rb_node, &tree->state); - - return 0; -} - -static struct extent_state *next_state(struct extent_state *state) -{ - struct rb_node *next = rb_next(&state->rb_node); - if (next) - return rb_entry(next, struct extent_state, rb_node); - else - return NULL; -} - -/* - * utility function to clear some bits in an extent state struct. - * it will optionally wake up anyone waiting on this state (wake == 1). - * - * If no bits are set on the state struct after clearing things, the - * struct is freed and removed from the tree - */ -static struct extent_state *clear_state_bit(struct extent_io_tree *tree, - struct extent_state *state, - u32 bits, int wake, - struct extent_changeset *changeset) -{ - struct extent_state *next; - u32 bits_to_clear = bits & ~EXTENT_CTLBITS; - int ret; - - if ((bits_to_clear & EXTENT_DIRTY) && (state->state & EXTENT_DIRTY)) { - u64 range = state->end - state->start + 1; - WARN_ON(range > tree->dirty_bytes); - tree->dirty_bytes -= range; - } - - if (tree->private_data && is_data_inode(tree->private_data)) - btrfs_clear_delalloc_extent(tree->private_data, state, bits); - - ret = add_extent_changeset(state, bits_to_clear, changeset, 0); - BUG_ON(ret < 0); - state->state &= ~bits_to_clear; - if (wake) - wake_up(&state->wq); - if (state->state == 0) { - next = next_state(state); - if (extent_state_in_tree(state)) { - rb_erase(&state->rb_node, &tree->state); - RB_CLEAR_NODE(&state->rb_node); - free_extent_state(state); - } else { - WARN_ON(1); - } - } else { - merge_state(tree, state); - next = next_state(state); - } - return next; -} - static void extent_io_tree_panic(struct extent_io_tree *tree, int err) { btrfs_panic(tree->fs_info, err, @@ -663,25 +424,6 @@ void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) spin_unlock(&tree->lock); } -static void set_state_bits(struct extent_io_tree *tree, - struct extent_state *state, - u32 bits, struct extent_changeset *changeset) -{ - u32 bits_to_set = bits & ~EXTENT_CTLBITS; - int ret; - - if (tree->private_data && is_data_inode(tree->private_data)) - btrfs_set_delalloc_extent(tree->private_data, state, bits); - - if ((bits_to_set & EXTENT_DIRTY) && !(state->state & EXTENT_DIRTY)) { - u64 range = state->end - state->start + 1; - tree->dirty_bytes += range; - } - ret = add_extent_changeset(state, bits_to_set, changeset, 1); - BUG_ON(ret < 0); - state->state |= bits_to_set; -} - static void cache_state_if_flags(struct extent_state *state, struct extent_state **cached_ptr, unsigned flags) From patchwork Fri Sep 9 21:53:28 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972202 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 16893ECAAD3 for ; Fri, 9 Sep 2022 21:54:18 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229806AbiIIVyQ (ORCPT ); Fri, 9 Sep 2022 17:54:16 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58368 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231829AbiIIVyP (ORCPT ); Fri, 9 Sep 2022 17:54:15 -0400 Received: from mail-qt1-x82d.google.com (mail-qt1-x82d.google.com [IPv6:2607:f8b0:4864:20::82d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DD7AF10D72D for ; Fri, 9 Sep 2022 14:54:13 -0700 (PDT) Received: by mail-qt1-x82d.google.com with SMTP id z18so2335817qts.7 for ; Fri, 09 Sep 2022 14:54:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=gEVI1BkzSeksrm2FHW6+BRs3zBNNFKw3QpM0DAwdrLc=; b=ZISD8szcBbG2V+JVdiQONe2I5LPFN2NDCEEbYN7kdBrZ0m7qDTaVIZZRVHj5ynGVx1 CkHYbRYHZvKlosd2cmEJD67l0STouRgwietaSqxvr/Vo1n0KfWyUb7ASrlUA/Vb6ImE4 E5LbV35B3rJ1r3d2ziM6XOTAvGc1/HKVrWEvo9odojsuOTIkktste3lbgM7gDs16LO5H teZVWXbhOq+jH97wF4PlUDpyslXQ5MFyw3DrhXDPjLPFLXt9MCD+fd0MociQrl59KQCi PVKDDgLyB+YNy2+m8/jkBVfqdAFL5pJHUreY7XbcpYEo1GoVhsxO/bUBm898IAJNHAiS zRfg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=gEVI1BkzSeksrm2FHW6+BRs3zBNNFKw3QpM0DAwdrLc=; b=KZX93GwxL8uxDeD4+RGOb/ll/1QVluqPGgHsddwZYa7yVmMmlQwYVQ7qd7FwVOerGS 2pLP1PLx5jHnItYAq329HsPlC4BFbPuRtu54btv84iG+xpGUFB+61rKxrRVq8V2t/Hw4 q3Dto0yi4gCp3OdJB6QBqv2xI/Rd3GCJuWPARx2N1Pc33wos8IJDV/sXHqi7BggASyI0 hJ3u+ExB2CdeQcFhYPw+AcW6CdMt5bBuM/sfVFAyfnlL7n2IFvA5JvQlFCMsgDAJQxd7 srQpisnx4jDRufsuuLGBnPCIOby8q7Mzp4NJX2sQqYI0yGXFNT4uGQ1JBRvU141+gQ05 gD2Q== X-Gm-Message-State: ACgBeo3g/DuJAPQ1w3CFY3B7uOg23lddb/PlsGzTWeSxi90zIAPCFf7m 8+Z4ELYcOCdWBQ8LFdeZyGFCFTB4r1v7wA== X-Google-Smtp-Source: AA6agR7EptkH45QixeN6bUdwePkm8NgXb2LNN2BL88b5vuAjQhawWqVpEnbObfGGHfZ6D8tOYQwwTA== X-Received: by 2002:a05:622a:291:b0:343:7e97:db08 with SMTP id z17-20020a05622a029100b003437e97db08mr14073302qtw.58.1662760452559; Fri, 09 Sep 2022 14:54:12 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id n21-20020a05620a295500b006bb49cfe147sm1752026qkp.84.2022.09.09.14.54.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:12 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 15/36] btrfs: move a few exported extent_io_tree helpers to extent-io-tree.c Date: Fri, 9 Sep 2022 17:53:28 -0400 Message-Id: <006710f3346c24464aee913dec7d5066938a6047.1662760286.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 These are the last few helpers that do not rely on tree_search() and who's other helpers are exported and in extent-io-tree.c already. Move these across now in order to make the core move smaller. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 142 ++++++++++++++++++++++++++++++++++++++ fs/btrfs/extent_io.c | 141 ------------------------------------- 2 files changed, 142 insertions(+), 141 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 882f9a609d11..468b373c4359 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -5,6 +5,7 @@ #include "ctree.h" #include "extent-io-tree.h" #include "btrfs_inode.h" +#include "misc.h" static struct kmem_cache *extent_state_cache; @@ -510,6 +511,123 @@ struct extent_state *clear_state_bit(struct extent_io_tree *tree, return next; } +/** + * Find the first range that has @bits not set. This range could start before + * @start. + * + * @tree: the tree to search + * @start: offset at/after which the found extent should start + * @start_ret: records the beginning of the range + * @end_ret: records the end of the range (inclusive) + * @bits: the set of bits which must be unset + * + * Since unallocated range is also considered one which doesn't have the bits + * set it's possible that @end_ret contains -1, this happens in case the range + * spans (last_range_end, end of device]. In this case it's up to the caller to + * trim @end_ret to the appropriate size. + */ +void find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start, + u64 *start_ret, u64 *end_ret, u32 bits) +{ + struct extent_state *state; + struct rb_node *node, *prev = NULL, *next; + + spin_lock(&tree->lock); + + /* Find first extent with bits cleared */ + while (1) { + node = tree_search_prev_next(tree, start, &prev, &next); + if (!node && !next && !prev) { + /* + * Tree is completely empty, send full range and let + * caller deal with it + */ + *start_ret = 0; + *end_ret = -1; + goto out; + } else if (!node && !next) { + /* + * We are past the last allocated chunk, set start at + * the end of the last extent. + */ + state = rb_entry(prev, struct extent_state, rb_node); + *start_ret = state->end + 1; + *end_ret = -1; + goto out; + } else if (!node) { + node = next; + } + /* + * At this point 'node' either contains 'start' or start is + * before 'node' + */ + state = rb_entry(node, struct extent_state, rb_node); + + if (in_range(start, state->start, state->end - state->start + 1)) { + if (state->state & bits) { + /* + * |--range with bits sets--| + * | + * start + */ + start = state->end + 1; + } else { + /* + * 'start' falls within a range that doesn't + * have the bits set, so take its start as + * the beginning of the desired range + * + * |--range with bits cleared----| + * | + * start + */ + *start_ret = state->start; + break; + } + } else { + /* + * |---prev range---|---hole/unset---|---node range---| + * | + * start + * + * or + * + * |---hole/unset--||--first node--| + * 0 | + * start + */ + if (prev) { + state = rb_entry(prev, struct extent_state, + rb_node); + *start_ret = state->end + 1; + } else { + *start_ret = 0; + } + break; + } + } + + /* + * Find the longest stretch from start until an entry which has the + * bits set + */ + while (1) { + state = rb_entry(node, struct extent_state, rb_node); + if (state->end >= start && !(state->state & bits)) { + *end_ret = state->end; + } else { + *end_ret = state->start - 1; + break; + } + + node = rb_next(node); + if (!node) + break; + } +out: + spin_unlock(&tree->lock); +} + /* wrappers around set/clear extent bit */ int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset) @@ -555,6 +673,30 @@ int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) return 1; } +/* + * either insert or lock state struct between start and end use mask to tell + * us if waiting is desired. + */ +int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, + struct extent_state **cached_state) +{ + int err; + u64 failed_start; + + while (1) { + err = set_extent_bit(tree, start, end, EXTENT_LOCKED, + EXTENT_LOCKED, &failed_start, + cached_state, GFP_NOFS, NULL); + if (err == -EEXIST) { + wait_extent_bit(tree, failed_start, end, EXTENT_LOCKED); + start = failed_start; + } else + break; + WARN_ON(start > end); + } + return err; +} + void __cold extent_state_free_cachep(void) { btrfs_extent_state_leak_debug_check(); diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 65e239ab3dc0..fd2506c9be03 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -889,30 +889,6 @@ int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, return err; } -/* - * either insert or lock state struct between start and end use mask to tell - * us if waiting is desired. - */ -int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, - struct extent_state **cached_state) -{ - int err; - u64 failed_start; - - while (1) { - err = set_extent_bit(tree, start, end, EXTENT_LOCKED, - EXTENT_LOCKED, &failed_start, - cached_state, GFP_NOFS, NULL); - if (err == -EEXIST) { - wait_extent_bit(tree, failed_start, end, EXTENT_LOCKED); - start = failed_start; - } else - break; - WARN_ON(start > end); - } - return err; -} - void extent_range_clear_dirty_for_io(struct inode *inode, u64 start, u64 end) { unsigned long index = start >> PAGE_SHIFT; @@ -1057,123 +1033,6 @@ int find_contiguous_extent_bit(struct extent_io_tree *tree, u64 start, return ret; } -/** - * Find the first range that has @bits not set. This range could start before - * @start. - * - * @tree: the tree to search - * @start: offset at/after which the found extent should start - * @start_ret: records the beginning of the range - * @end_ret: records the end of the range (inclusive) - * @bits: the set of bits which must be unset - * - * Since unallocated range is also considered one which doesn't have the bits - * set it's possible that @end_ret contains -1, this happens in case the range - * spans (last_range_end, end of device]. In this case it's up to the caller to - * trim @end_ret to the appropriate size. - */ -void find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start, - u64 *start_ret, u64 *end_ret, u32 bits) -{ - struct extent_state *state; - struct rb_node *node, *prev = NULL, *next; - - spin_lock(&tree->lock); - - /* Find first extent with bits cleared */ - while (1) { - node = tree_search_prev_next(tree, start, &prev, &next); - if (!node && !next && !prev) { - /* - * Tree is completely empty, send full range and let - * caller deal with it - */ - *start_ret = 0; - *end_ret = -1; - goto out; - } else if (!node && !next) { - /* - * We are past the last allocated chunk, set start at - * the end of the last extent. - */ - state = rb_entry(prev, struct extent_state, rb_node); - *start_ret = state->end + 1; - *end_ret = -1; - goto out; - } else if (!node) { - node = next; - } - /* - * At this point 'node' either contains 'start' or start is - * before 'node' - */ - state = rb_entry(node, struct extent_state, rb_node); - - if (in_range(start, state->start, state->end - state->start + 1)) { - if (state->state & bits) { - /* - * |--range with bits sets--| - * | - * start - */ - start = state->end + 1; - } else { - /* - * 'start' falls within a range that doesn't - * have the bits set, so take its start as - * the beginning of the desired range - * - * |--range with bits cleared----| - * | - * start - */ - *start_ret = state->start; - break; - } - } else { - /* - * |---prev range---|---hole/unset---|---node range---| - * | - * start - * - * or - * - * |---hole/unset--||--first node--| - * 0 | - * start - */ - if (prev) { - state = rb_entry(prev, struct extent_state, - rb_node); - *start_ret = state->end + 1; - } else { - *start_ret = 0; - } - break; - } - } - - /* - * Find the longest stretch from start until an entry which has the - * bits set - */ - while (1) { - state = rb_entry(node, struct extent_state, rb_node); - if (state->end >= start && !(state->state & bits)) { - *end_ret = state->end; - } else { - *end_ret = state->start - 1; - break; - } - - node = rb_next(node); - if (!node) - break; - } -out: - spin_unlock(&tree->lock); -} - /* * find a contiguous range of bytes in the file marked as delalloc, not * more than 'max_bytes'. start and end are used to return the range, From patchwork Fri Sep 9 21:53:29 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972206 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 68472ECAAD3 for ; Fri, 9 Sep 2022 21:54:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231863AbiIIVyW (ORCPT ); Fri, 9 Sep 2022 17:54:22 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58502 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231851AbiIIVyU (ORCPT ); Fri, 9 Sep 2022 17:54:20 -0400 Received: from mail-qk1-x732.google.com (mail-qk1-x732.google.com [IPv6:2607:f8b0:4864:20::732]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E6D9F1079C8 for ; Fri, 9 Sep 2022 14:54:15 -0700 (PDT) Received: by mail-qk1-x732.google.com with SMTP id g16so2200864qkl.11 for ; Fri, 09 Sep 2022 14:54:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=FSrH+5w2vszyBc1JEauTslffrT2IF61FPhSKZKyeJFo=; b=aj3whDJ5AFt2Djaqv0pjXBdnEE5KWDsFu7uUMOnMmVwd7jjq0y7fYhErG3iUmzUSNy 87ZW5ZR8TgJNdEbsPemEt2/8uXv1kSmoul3Bmaf2eYFdhWFp3gp11NjtrfEPjtjiYto5 xQ8OLOWbtShbO9Q+7rCdcpV+qsdNlq3V1G/7/oHSD77Px4MZF61tw0VsHnPwtrqbCNZD h4y66gII9elxW4JtdHLVl36pB6UnAKcJ+ewMOVWOSdHHL4BK2gjgZh/WMuy8w+VzHqGA cevTbSfUEEM484ZKd0+qe9m/DnAVVpZd4H9ajZKYOoTlb/wgxe1C+kc/yv8WLEgvShp3 S93Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=FSrH+5w2vszyBc1JEauTslffrT2IF61FPhSKZKyeJFo=; b=hj02mw8QvwhNdnpROAZf5iED0EAGFEi6sSkUZ73GRgxZE7XakVPPZNFRjykW3ByGAO z2qvl4hNe6XlGF0sKM97kzrK+OYNhFLJsA/zBQnzqd3WzbsdcV0SXZQiEuQ1wkUD8MwN B6LU18JWDbYa1z2KTGlNV74MqviQi3nuNjmUymQnX+GNWGlMOfw44pllziwMT5VpMll4 TCUV/GIy5TgQga+EmdDVLJoVTknOqZmDTckwygEs+YALw9WI+gRVQjAurISEPXzciSnm If++TFoICITDvo9xjMSju4JkcmgsDXx4eCFpeLxZc294uvfQ32TfH/rTlz5F3j54Exjt FupA== X-Gm-Message-State: ACgBeo1ThW/kVXQXr8GNVPaEvbVandM16CUw/MCXFnbEQOqsFmEjGFHi rqRlLZ7MNYxcUliAAkSnD4XYQr42siC5Qw== X-Google-Smtp-Source: AA6agR4ZKg1X0q0OBa4c18C6mD23sRv3U5WxFw+WmEeWsyBgjcdEtX3HdPWMu2bJ+G7/fwW7TaCUOA== X-Received: by 2002:a05:620a:919:b0:6bc:6a30:2e22 with SMTP id v25-20020a05620a091900b006bc6a302e22mr12071554qkv.702.1662760454034; Fri, 09 Sep 2022 14:54:14 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id r18-20020a05620a299200b006bbda80595asm1547473qkp.5.2022.09.09.14.54.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:13 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 16/36] btrfs: move core extent_io_tree functions to extent-io-tree.c Date: Fri, 9 Sep 2022 17:53:29 -0400 Message-Id: <3efcedc29cb34257fecff32bd1bce297a6c02358.1662760286.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 still huge, but unfortunately I cannot make it smaller without renaming tree_search() and changing all the callers to use the new name, then moving those chunks and then changing the name back. This feels like too much churn for code movement, so I've limited this to only things that called tree_search(). With this patch all of the extent_io_tree code is now in extent-io-tree.c. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 996 ++++++++++++++++++++++++++++++++++++++ fs/btrfs/extent_io.c | 996 -------------------------------------- 2 files changed, 996 insertions(+), 996 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 468b373c4359..322909cf3040 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -287,6 +287,20 @@ struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, u64 offset, return NULL; } +/* + * Inexact rb-tree search, return the next entry if @offset is not found + */ +static inline struct rb_node *tree_search(struct extent_io_tree *tree, u64 offset) +{ + return tree_search_for_insert(tree, offset, NULL, NULL); +} + +static void extent_io_tree_panic(struct extent_io_tree *tree, int err) +{ + btrfs_panic(tree->fs_info, err, + "locking error: extent tree was modified by another thread while locked"); +} + /* * utility function to look for merge candidates inside a given range. * Any extents with matching state are merged together into a single @@ -511,6 +525,872 @@ struct extent_state *clear_state_bit(struct extent_io_tree *tree, return next; } +/* + * clear some bits on a range in the tree. This may require splitting + * or inserting elements in the tree, so the gfp mask is used to + * indicate which allocations or sleeping are allowed. + * + * pass 'wake' == 1 to kick any sleepers, and 'delete' == 1 to remove + * the given range from the tree regardless of state (ie for truncate). + * + * the range [start, end] is inclusive. + * + * This takes the tree lock, and returns 0 on success and < 0 on error. + */ +int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, + u32 bits, int wake, int delete, + struct extent_state **cached_state, + gfp_t mask, struct extent_changeset *changeset) +{ + struct extent_state *state; + struct extent_state *cached; + struct extent_state *prealloc = NULL; + struct rb_node *node; + u64 last_end; + int err; + int clear = 0; + + btrfs_debug_check_extent_io_range(tree, start, end); + trace_btrfs_clear_extent_bit(tree, start, end - start + 1, bits); + + if (bits & EXTENT_DELALLOC) + bits |= EXTENT_NORESERVE; + + if (delete) + bits |= ~EXTENT_CTLBITS; + + if (bits & (EXTENT_LOCKED | EXTENT_BOUNDARY)) + clear = 1; +again: + if (!prealloc && gfpflags_allow_blocking(mask)) { + /* + * Don't care for allocation failure here because we might end + * up not needing the pre-allocated extent state at all, which + * is the case if we only have in the tree extent states that + * cover our input range and don't cover too any other range. + * If we end up needing a new extent state we allocate it later. + */ + prealloc = alloc_extent_state(mask); + } + + spin_lock(&tree->lock); + if (cached_state) { + cached = *cached_state; + + if (clear) { + *cached_state = NULL; + cached_state = NULL; + } + + if (cached && extent_state_in_tree(cached) && + cached->start <= start && cached->end > start) { + if (clear) + refcount_dec(&cached->refs); + state = cached; + goto hit_next; + } + if (clear) + free_extent_state(cached); + } + /* + * this search will find the extents that end after + * our range starts + */ + node = tree_search(tree, start); + if (!node) + goto out; + state = rb_entry(node, struct extent_state, rb_node); +hit_next: + if (state->start > end) + goto out; + WARN_ON(state->end < start); + last_end = state->end; + + /* the state doesn't have the wanted bits, go ahead */ + if (!(state->state & bits)) { + state = next_state(state); + goto next; + } + + /* + * | ---- desired range ---- | + * | state | or + * | ------------- state -------------- | + * + * We need to split the extent we found, and may flip + * bits on second half. + * + * If the extent we found extends past our range, we + * just split and search again. It'll get split again + * the next time though. + * + * If the extent we found is inside our range, we clear + * the desired bit on it. + */ + + if (state->start < start) { + prealloc = alloc_extent_state_atomic(prealloc); + BUG_ON(!prealloc); + err = split_state(tree, state, prealloc, start); + if (err) + extent_io_tree_panic(tree, err); + + prealloc = NULL; + if (err) + goto out; + if (state->end <= end) { + state = clear_state_bit(tree, state, bits, wake, changeset); + goto next; + } + goto search_again; + } + /* + * | ---- desired range ---- | + * | state | + * We need to split the extent, and clear the bit + * on the first half + */ + if (state->start <= end && state->end > end) { + prealloc = alloc_extent_state_atomic(prealloc); + BUG_ON(!prealloc); + err = split_state(tree, state, prealloc, end + 1); + if (err) + extent_io_tree_panic(tree, err); + + if (wake) + wake_up(&state->wq); + + clear_state_bit(tree, prealloc, bits, wake, changeset); + + prealloc = NULL; + goto out; + } + + state = clear_state_bit(tree, state, bits, wake, changeset); +next: + if (last_end == (u64)-1) + goto out; + start = last_end + 1; + if (start <= end && state && !need_resched()) + goto hit_next; + +search_again: + if (start > end) + goto out; + spin_unlock(&tree->lock); + if (gfpflags_allow_blocking(mask)) + cond_resched(); + goto again; + +out: + spin_unlock(&tree->lock); + if (prealloc) + free_extent_state(prealloc); + + return 0; + +} + +static void wait_on_state(struct extent_io_tree *tree, + struct extent_state *state) + __releases(tree->lock) + __acquires(tree->lock) +{ + DEFINE_WAIT(wait); + prepare_to_wait(&state->wq, &wait, TASK_UNINTERRUPTIBLE); + spin_unlock(&tree->lock); + schedule(); + spin_lock(&tree->lock); + finish_wait(&state->wq, &wait); +} + +/* + * waits for one or more bits to clear on a range in the state tree. + * The range [start, end] is inclusive. + * The tree lock is taken by this function + */ +void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) +{ + struct extent_state *state; + struct rb_node *node; + + btrfs_debug_check_extent_io_range(tree, start, end); + + spin_lock(&tree->lock); +again: + while (1) { + /* + * this search will find all the extents that end after + * our range starts + */ + node = tree_search(tree, start); +process_node: + if (!node) + break; + + state = rb_entry(node, struct extent_state, rb_node); + + if (state->start > end) + goto out; + + if (state->state & bits) { + start = state->start; + refcount_inc(&state->refs); + wait_on_state(tree, state); + free_extent_state(state); + goto again; + } + start = state->end + 1; + + if (start > end) + break; + + if (!cond_resched_lock(&tree->lock)) { + node = rb_next(node); + goto process_node; + } + } +out: + spin_unlock(&tree->lock); +} + +static void cache_state_if_flags(struct extent_state *state, + struct extent_state **cached_ptr, + unsigned flags) +{ + if (cached_ptr && !(*cached_ptr)) { + if (!flags || (state->state & flags)) { + *cached_ptr = state; + refcount_inc(&state->refs); + } + } +} + +static void cache_state(struct extent_state *state, + struct extent_state **cached_ptr) +{ + return cache_state_if_flags(state, cached_ptr, + EXTENT_LOCKED | EXTENT_BOUNDARY); +} + +/* find the first state struct with 'bits' set after 'start', and + * return it. tree->lock must be held. NULL will returned if + * nothing was found after 'start' + */ +static struct extent_state * +find_first_extent_bit_state(struct extent_io_tree *tree, u64 start, u32 bits) +{ + struct rb_node *node; + struct extent_state *state; + + /* + * this search will find all the extents that end after + * our range starts. + */ + node = tree_search(tree, start); + if (!node) + goto out; + + while (1) { + state = rb_entry(node, struct extent_state, rb_node); + if (state->end >= start && (state->state & bits)) + return state; + + node = rb_next(node); + if (!node) + break; + } +out: + return NULL; +} + +/* + * Find the first offset in the io tree with one or more @bits set. + * + * Note: If there are multiple bits set in @bits, any of them will match. + * + * Return 0 if we find something, and update @start_ret and @end_ret. + * Return 1 if we found nothing. + */ +int find_first_extent_bit(struct extent_io_tree *tree, u64 start, + u64 *start_ret, u64 *end_ret, u32 bits, + struct extent_state **cached_state) +{ + struct extent_state *state; + int ret = 1; + + spin_lock(&tree->lock); + if (cached_state && *cached_state) { + state = *cached_state; + if (state->end == start - 1 && extent_state_in_tree(state)) { + while ((state = next_state(state)) != NULL) { + if (state->state & bits) + goto got_it; + } + free_extent_state(*cached_state); + *cached_state = NULL; + goto out; + } + free_extent_state(*cached_state); + *cached_state = NULL; + } + + state = find_first_extent_bit_state(tree, start, bits); +got_it: + if (state) { + cache_state_if_flags(state, cached_state, 0); + *start_ret = state->start; + *end_ret = state->end; + ret = 0; + } +out: + spin_unlock(&tree->lock); + return ret; +} + +/** + * Find a contiguous area of bits + * + * @tree: io tree to check + * @start: offset to start the search from + * @start_ret: the first offset we found with the bits set + * @end_ret: the final contiguous range of the bits that were set + * @bits: bits to look for + * + * set_extent_bit and clear_extent_bit can temporarily split contiguous ranges + * to set bits appropriately, and then merge them again. During this time it + * will drop the tree->lock, so use this helper if you want to find the actual + * contiguous area for given bits. We will search to the first bit we find, and + * then walk down the tree until we find a non-contiguous area. The area + * returned will be the full contiguous area with the bits set. + */ +int find_contiguous_extent_bit(struct extent_io_tree *tree, u64 start, + u64 *start_ret, u64 *end_ret, u32 bits) +{ + struct extent_state *state; + int ret = 1; + + spin_lock(&tree->lock); + state = find_first_extent_bit_state(tree, start, bits); + if (state) { + *start_ret = state->start; + *end_ret = state->end; + while ((state = next_state(state)) != NULL) { + if (state->start > (*end_ret + 1)) + break; + *end_ret = state->end; + } + ret = 0; + } + spin_unlock(&tree->lock); + return ret; +} + +/* + * find a contiguous range of bytes in the file marked as delalloc, not + * more than 'max_bytes'. start and end are used to return the range, + * + * true is returned if we find something, false if nothing was in the tree + */ +bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, + u64 *end, u64 max_bytes, + struct extent_state **cached_state) +{ + struct rb_node *node; + struct extent_state *state; + u64 cur_start = *start; + bool found = false; + u64 total_bytes = 0; + + spin_lock(&tree->lock); + + /* + * this search will find all the extents that end after + * our range starts. + */ + node = tree_search(tree, cur_start); + if (!node) { + *end = (u64)-1; + goto out; + } + + while (1) { + state = rb_entry(node, struct extent_state, rb_node); + if (found && (state->start != cur_start || + (state->state & EXTENT_BOUNDARY))) { + goto out; + } + if (!(state->state & EXTENT_DELALLOC)) { + if (!found) + *end = state->end; + goto out; + } + if (!found) { + *start = state->start; + *cached_state = state; + refcount_inc(&state->refs); + } + found = true; + *end = state->end; + cur_start = state->end + 1; + node = rb_next(node); + total_bytes += state->end - state->start + 1; + if (total_bytes >= max_bytes) + break; + if (!node) + break; + } +out: + spin_unlock(&tree->lock); + return found; +} + +/* + * set some bits on a range in the tree. This may require allocations or + * sleeping, so the gfp mask is used to indicate what is allowed. + * + * If any of the exclusive bits are set, this will fail with -EEXIST if some + * part of the range already has the desired bits set. The start of the + * existing range is returned in failed_start in this case. + * + * [start, end] is inclusive This takes the tree lock. + */ +int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, + u32 exclusive_bits, u64 *failed_start, + struct extent_state **cached_state, gfp_t mask, + struct extent_changeset *changeset) +{ + struct extent_state *state; + struct extent_state *prealloc = NULL; + struct rb_node *node; + struct rb_node **p; + struct rb_node *parent; + int err = 0; + u64 last_start; + u64 last_end; + + btrfs_debug_check_extent_io_range(tree, start, end); + trace_btrfs_set_extent_bit(tree, start, end - start + 1, bits); + + if (exclusive_bits) + ASSERT(failed_start); + else + ASSERT(failed_start == NULL); +again: + if (!prealloc && gfpflags_allow_blocking(mask)) { + /* + * Don't care for allocation failure here because we might end + * up not needing the pre-allocated extent state at all, which + * is the case if we only have in the tree extent states that + * cover our input range and don't cover too any other range. + * If we end up needing a new extent state we allocate it later. + */ + prealloc = alloc_extent_state(mask); + } + + spin_lock(&tree->lock); + if (cached_state && *cached_state) { + state = *cached_state; + if (state->start <= start && state->end > start && + extent_state_in_tree(state)) { + node = &state->rb_node; + goto hit_next; + } + } + /* + * this search will find all the extents that end after + * our range starts. + */ + node = tree_search_for_insert(tree, start, &p, &parent); + if (!node) { + prealloc = alloc_extent_state_atomic(prealloc); + BUG_ON(!prealloc); + prealloc->start = start; + prealloc->end = end; + insert_state_fast(tree, prealloc, p, parent, bits, changeset); + cache_state(prealloc, cached_state); + prealloc = NULL; + goto out; + } + state = rb_entry(node, struct extent_state, rb_node); +hit_next: + last_start = state->start; + last_end = state->end; + + /* + * | ---- desired range ---- | + * | state | + * + * Just lock what we found and keep going + */ + if (state->start == start && state->end <= end) { + if (state->state & exclusive_bits) { + *failed_start = state->start; + err = -EEXIST; + goto out; + } + + set_state_bits(tree, state, bits, changeset); + cache_state(state, cached_state); + merge_state(tree, state); + if (last_end == (u64)-1) + goto out; + start = last_end + 1; + state = next_state(state); + if (start < end && state && state->start == start && + !need_resched()) + goto hit_next; + goto search_again; + } + + /* + * | ---- desired range ---- | + * | state | + * or + * | ------------- state -------------- | + * + * We need to split the extent we found, and may flip bits on + * second half. + * + * If the extent we found extends past our + * range, we just split and search again. It'll get split + * again the next time though. + * + * If the extent we found is inside our range, we set the + * desired bit on it. + */ + if (state->start < start) { + if (state->state & exclusive_bits) { + *failed_start = start; + err = -EEXIST; + goto out; + } + + /* + * If this extent already has all the bits we want set, then + * skip it, not necessary to split it or do anything with it. + */ + if ((state->state & bits) == bits) { + start = state->end + 1; + cache_state(state, cached_state); + goto search_again; + } + + prealloc = alloc_extent_state_atomic(prealloc); + BUG_ON(!prealloc); + err = split_state(tree, state, prealloc, start); + if (err) + extent_io_tree_panic(tree, err); + + prealloc = NULL; + if (err) + goto out; + if (state->end <= end) { + set_state_bits(tree, state, bits, changeset); + cache_state(state, cached_state); + merge_state(tree, state); + if (last_end == (u64)-1) + goto out; + start = last_end + 1; + state = next_state(state); + if (start < end && state && state->start == start && + !need_resched()) + goto hit_next; + } + goto search_again; + } + /* + * | ---- desired range ---- | + * | state | or | state | + * + * There's a hole, we need to insert something in it and + * ignore the extent we found. + */ + if (state->start > start) { + u64 this_end; + if (end < last_start) + this_end = end; + else + this_end = last_start - 1; + + prealloc = alloc_extent_state_atomic(prealloc); + BUG_ON(!prealloc); + + /* + * Avoid to free 'prealloc' if it can be merged with + * the later extent. + */ + prealloc->start = start; + prealloc->end = this_end; + err = insert_state(tree, prealloc, bits, changeset); + if (err) + extent_io_tree_panic(tree, err); + + cache_state(prealloc, cached_state); + prealloc = NULL; + start = this_end + 1; + goto search_again; + } + /* + * | ---- desired range ---- | + * | state | + * We need to split the extent, and set the bit + * on the first half + */ + if (state->start <= end && state->end > end) { + if (state->state & exclusive_bits) { + *failed_start = start; + err = -EEXIST; + goto out; + } + + prealloc = alloc_extent_state_atomic(prealloc); + BUG_ON(!prealloc); + err = split_state(tree, state, prealloc, end + 1); + if (err) + extent_io_tree_panic(tree, err); + + set_state_bits(tree, prealloc, bits, changeset); + cache_state(prealloc, cached_state); + merge_state(tree, prealloc); + prealloc = NULL; + goto out; + } + +search_again: + if (start > end) + goto out; + spin_unlock(&tree->lock); + if (gfpflags_allow_blocking(mask)) + cond_resched(); + goto again; + +out: + spin_unlock(&tree->lock); + if (prealloc) + free_extent_state(prealloc); + + return err; + +} + +/** + * convert_extent_bit - convert all bits in a given range from one bit to + * another + * @tree: the io tree to search + * @start: the start offset in bytes + * @end: the end offset in bytes (inclusive) + * @bits: the bits to set in this range + * @clear_bits: the bits to clear in this range + * @cached_state: state that we're going to cache + * + * This will go through and set bits for the given range. If any states exist + * already in this range they are set with the given bit and cleared of the + * clear_bits. This is only meant to be used by things that are mergeable, ie + * converting from say DELALLOC to DIRTY. This is not meant to be used with + * boundary bits like LOCK. + * + * All allocations are done with GFP_NOFS. + */ +int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, + u32 bits, u32 clear_bits, + struct extent_state **cached_state) +{ + struct extent_state *state; + struct extent_state *prealloc = NULL; + struct rb_node *node; + struct rb_node **p; + struct rb_node *parent; + int err = 0; + u64 last_start; + u64 last_end; + bool first_iteration = true; + + btrfs_debug_check_extent_io_range(tree, start, end); + trace_btrfs_convert_extent_bit(tree, start, end - start + 1, bits, + clear_bits); + +again: + if (!prealloc) { + /* + * Best effort, don't worry if extent state allocation fails + * here for the first iteration. We might have a cached state + * that matches exactly the target range, in which case no + * extent state allocations are needed. We'll only know this + * after locking the tree. + */ + prealloc = alloc_extent_state(GFP_NOFS); + if (!prealloc && !first_iteration) + return -ENOMEM; + } + + spin_lock(&tree->lock); + if (cached_state && *cached_state) { + state = *cached_state; + if (state->start <= start && state->end > start && + extent_state_in_tree(state)) { + node = &state->rb_node; + goto hit_next; + } + } + + /* + * this search will find all the extents that end after + * our range starts. + */ + node = tree_search_for_insert(tree, start, &p, &parent); + if (!node) { + prealloc = alloc_extent_state_atomic(prealloc); + if (!prealloc) { + err = -ENOMEM; + goto out; + } + prealloc->start = start; + prealloc->end = end; + insert_state_fast(tree, prealloc, p, parent, bits, NULL); + cache_state(prealloc, cached_state); + prealloc = NULL; + goto out; + } + state = rb_entry(node, struct extent_state, rb_node); +hit_next: + last_start = state->start; + last_end = state->end; + + /* + * | ---- desired range ---- | + * | state | + * + * Just lock what we found and keep going + */ + if (state->start == start && state->end <= end) { + set_state_bits(tree, state, bits, NULL); + cache_state(state, cached_state); + state = clear_state_bit(tree, state, clear_bits, 0, NULL); + if (last_end == (u64)-1) + goto out; + start = last_end + 1; + if (start < end && state && state->start == start && + !need_resched()) + goto hit_next; + goto search_again; + } + + /* + * | ---- desired range ---- | + * | state | + * or + * | ------------- state -------------- | + * + * We need to split the extent we found, and may flip bits on + * second half. + * + * If the extent we found extends past our + * range, we just split and search again. It'll get split + * again the next time though. + * + * If the extent we found is inside our range, we set the + * desired bit on it. + */ + if (state->start < start) { + prealloc = alloc_extent_state_atomic(prealloc); + if (!prealloc) { + err = -ENOMEM; + goto out; + } + err = split_state(tree, state, prealloc, start); + if (err) + extent_io_tree_panic(tree, err); + prealloc = NULL; + if (err) + goto out; + if (state->end <= end) { + set_state_bits(tree, state, bits, NULL); + cache_state(state, cached_state); + state = clear_state_bit(tree, state, clear_bits, 0, NULL); + if (last_end == (u64)-1) + goto out; + start = last_end + 1; + if (start < end && state && state->start == start && + !need_resched()) + goto hit_next; + } + goto search_again; + } + /* + * | ---- desired range ---- | + * | state | or | state | + * + * There's a hole, we need to insert something in it and + * ignore the extent we found. + */ + if (state->start > start) { + u64 this_end; + if (end < last_start) + this_end = end; + else + this_end = last_start - 1; + + prealloc = alloc_extent_state_atomic(prealloc); + if (!prealloc) { + err = -ENOMEM; + goto out; + } + + /* + * Avoid to free 'prealloc' if it can be merged with + * the later extent. + */ + prealloc->start = start; + prealloc->end = this_end; + err = insert_state(tree, prealloc, bits, NULL); + if (err) + extent_io_tree_panic(tree, err); + cache_state(prealloc, cached_state); + prealloc = NULL; + start = this_end + 1; + goto search_again; + } + /* + * | ---- desired range ---- | + * | state | + * We need to split the extent, and set the bit + * on the first half + */ + if (state->start <= end && state->end > end) { + prealloc = alloc_extent_state_atomic(prealloc); + if (!prealloc) { + err = -ENOMEM; + goto out; + } + + err = split_state(tree, state, prealloc, end + 1); + if (err) + extent_io_tree_panic(tree, err); + + set_state_bits(tree, prealloc, bits, NULL); + cache_state(prealloc, cached_state); + clear_state_bit(tree, prealloc, clear_bits, 0, NULL); + prealloc = NULL; + goto out; + } + +search_again: + if (start > end) + goto out; + spin_unlock(&tree->lock); + cond_resched(); + first_iteration = false; + goto again; + +out: + spin_unlock(&tree->lock); + if (prealloc) + free_extent_state(prealloc); + + return err; +} + /** * Find the first range that has @bits not set. This range could start before * @start. @@ -628,6 +1508,122 @@ void find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start, spin_unlock(&tree->lock); } +/* + * count the number of bytes in the tree that have a given bit(s) + * set. This can be fairly slow, except for EXTENT_DIRTY which is + * cached. The total number found is returned. + */ +u64 count_range_bits(struct extent_io_tree *tree, + u64 *start, u64 search_end, u64 max_bytes, + u32 bits, int contig) +{ + struct rb_node *node; + struct extent_state *state; + u64 cur_start = *start; + u64 total_bytes = 0; + u64 last = 0; + int found = 0; + + if (WARN_ON(search_end <= cur_start)) + return 0; + + spin_lock(&tree->lock); + if (cur_start == 0 && bits == EXTENT_DIRTY) { + total_bytes = tree->dirty_bytes; + goto out; + } + /* + * this search will find all the extents that end after + * our range starts. + */ + node = tree_search(tree, cur_start); + if (!node) + goto out; + + while (1) { + state = rb_entry(node, struct extent_state, rb_node); + if (state->start > search_end) + break; + if (contig && found && state->start > last + 1) + break; + if (state->end >= cur_start && (state->state & bits) == bits) { + total_bytes += min(search_end, state->end) + 1 - + max(cur_start, state->start); + if (total_bytes >= max_bytes) + break; + if (!found) { + *start = max(cur_start, state->start); + found = 1; + } + last = state->end; + } else if (contig && found) { + break; + } + node = rb_next(node); + if (!node) + break; + } +out: + spin_unlock(&tree->lock); + return total_bytes; +} + +/* + * searches a range in the state tree for a given mask. + * If 'filled' == 1, this returns 1 only if every extent in the tree + * has the bits set. Otherwise, 1 is returned if any bit in the + * range is found set. + */ +int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, + u32 bits, int filled, struct extent_state *cached) +{ + struct extent_state *state = NULL; + struct rb_node *node; + int bitset = 0; + + spin_lock(&tree->lock); + if (cached && extent_state_in_tree(cached) && cached->start <= start && + cached->end > start) + node = &cached->rb_node; + else + node = tree_search(tree, start); + while (node && start <= end) { + state = rb_entry(node, struct extent_state, rb_node); + + if (filled && state->start > start) { + bitset = 0; + break; + } + + if (state->start > end) + break; + + if (state->state & bits) { + bitset = 1; + if (!filled) + break; + } else if (filled) { + bitset = 0; + break; + } + + if (state->end == (u64)-1) + break; + + start = state->end + 1; + if (start > end) + break; + node = rb_next(node); + if (!node) { + if (filled) + bitset = 0; + break; + } + } + spin_unlock(&tree->lock); + return bitset; +} + /* wrappers around set/clear extent bit */ int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset) diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index fd2506c9be03..8644072303df 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -181,714 +181,6 @@ void __cold extent_buffer_free_cachep(void) kmem_cache_destroy(extent_buffer_cache); } -/* - * Inexact rb-tree search, return the next entry if @offset is not found - */ -static inline struct rb_node *tree_search(struct extent_io_tree *tree, u64 offset) -{ - return tree_search_for_insert(tree, offset, NULL, NULL); -} - -static void extent_io_tree_panic(struct extent_io_tree *tree, int err) -{ - btrfs_panic(tree->fs_info, err, - "locking error: extent tree was modified by another thread while locked"); -} - -/* - * clear some bits on a range in the tree. This may require splitting - * or inserting elements in the tree, so the gfp mask is used to - * indicate which allocations or sleeping are allowed. - * - * pass 'wake' == 1 to kick any sleepers, and 'delete' == 1 to remove - * the given range from the tree regardless of state (ie for truncate). - * - * the range [start, end] is inclusive. - * - * This takes the tree lock, and returns 0 on success and < 0 on error. - */ -int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, int wake, int delete, - struct extent_state **cached_state, - gfp_t mask, struct extent_changeset *changeset) -{ - struct extent_state *state; - struct extent_state *cached; - struct extent_state *prealloc = NULL; - struct rb_node *node; - u64 last_end; - int err; - int clear = 0; - - btrfs_debug_check_extent_io_range(tree, start, end); - trace_btrfs_clear_extent_bit(tree, start, end - start + 1, bits); - - if (bits & EXTENT_DELALLOC) - bits |= EXTENT_NORESERVE; - - if (delete) - bits |= ~EXTENT_CTLBITS; - - if (bits & (EXTENT_LOCKED | EXTENT_BOUNDARY)) - clear = 1; -again: - if (!prealloc && gfpflags_allow_blocking(mask)) { - /* - * Don't care for allocation failure here because we might end - * up not needing the pre-allocated extent state at all, which - * is the case if we only have in the tree extent states that - * cover our input range and don't cover too any other range. - * If we end up needing a new extent state we allocate it later. - */ - prealloc = alloc_extent_state(mask); - } - - spin_lock(&tree->lock); - if (cached_state) { - cached = *cached_state; - - if (clear) { - *cached_state = NULL; - cached_state = NULL; - } - - if (cached && extent_state_in_tree(cached) && - cached->start <= start && cached->end > start) { - if (clear) - refcount_dec(&cached->refs); - state = cached; - goto hit_next; - } - if (clear) - free_extent_state(cached); - } - /* - * this search will find the extents that end after - * our range starts - */ - node = tree_search(tree, start); - if (!node) - goto out; - state = rb_entry(node, struct extent_state, rb_node); -hit_next: - if (state->start > end) - goto out; - WARN_ON(state->end < start); - last_end = state->end; - - /* the state doesn't have the wanted bits, go ahead */ - if (!(state->state & bits)) { - state = next_state(state); - goto next; - } - - /* - * | ---- desired range ---- | - * | state | or - * | ------------- state -------------- | - * - * We need to split the extent we found, and may flip - * bits on second half. - * - * If the extent we found extends past our range, we - * just split and search again. It'll get split again - * the next time though. - * - * If the extent we found is inside our range, we clear - * the desired bit on it. - */ - - if (state->start < start) { - prealloc = alloc_extent_state_atomic(prealloc); - BUG_ON(!prealloc); - err = split_state(tree, state, prealloc, start); - if (err) - extent_io_tree_panic(tree, err); - - prealloc = NULL; - if (err) - goto out; - if (state->end <= end) { - state = clear_state_bit(tree, state, bits, wake, changeset); - goto next; - } - goto search_again; - } - /* - * | ---- desired range ---- | - * | state | - * We need to split the extent, and clear the bit - * on the first half - */ - if (state->start <= end && state->end > end) { - prealloc = alloc_extent_state_atomic(prealloc); - BUG_ON(!prealloc); - err = split_state(tree, state, prealloc, end + 1); - if (err) - extent_io_tree_panic(tree, err); - - if (wake) - wake_up(&state->wq); - - clear_state_bit(tree, prealloc, bits, wake, changeset); - - prealloc = NULL; - goto out; - } - - state = clear_state_bit(tree, state, bits, wake, changeset); -next: - if (last_end == (u64)-1) - goto out; - start = last_end + 1; - if (start <= end && state && !need_resched()) - goto hit_next; - -search_again: - if (start > end) - goto out; - spin_unlock(&tree->lock); - if (gfpflags_allow_blocking(mask)) - cond_resched(); - goto again; - -out: - spin_unlock(&tree->lock); - if (prealloc) - free_extent_state(prealloc); - - return 0; - -} - -static void wait_on_state(struct extent_io_tree *tree, - struct extent_state *state) - __releases(tree->lock) - __acquires(tree->lock) -{ - DEFINE_WAIT(wait); - prepare_to_wait(&state->wq, &wait, TASK_UNINTERRUPTIBLE); - spin_unlock(&tree->lock); - schedule(); - spin_lock(&tree->lock); - finish_wait(&state->wq, &wait); -} - -/* - * waits for one or more bits to clear on a range in the state tree. - * The range [start, end] is inclusive. - * The tree lock is taken by this function - */ -void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) -{ - struct extent_state *state; - struct rb_node *node; - - btrfs_debug_check_extent_io_range(tree, start, end); - - spin_lock(&tree->lock); -again: - while (1) { - /* - * this search will find all the extents that end after - * our range starts - */ - node = tree_search(tree, start); -process_node: - if (!node) - break; - - state = rb_entry(node, struct extent_state, rb_node); - - if (state->start > end) - goto out; - - if (state->state & bits) { - start = state->start; - refcount_inc(&state->refs); - wait_on_state(tree, state); - free_extent_state(state); - goto again; - } - start = state->end + 1; - - if (start > end) - break; - - if (!cond_resched_lock(&tree->lock)) { - node = rb_next(node); - goto process_node; - } - } -out: - spin_unlock(&tree->lock); -} - -static void cache_state_if_flags(struct extent_state *state, - struct extent_state **cached_ptr, - unsigned flags) -{ - if (cached_ptr && !(*cached_ptr)) { - if (!flags || (state->state & flags)) { - *cached_ptr = state; - refcount_inc(&state->refs); - } - } -} - -static void cache_state(struct extent_state *state, - struct extent_state **cached_ptr) -{ - return cache_state_if_flags(state, cached_ptr, - EXTENT_LOCKED | EXTENT_BOUNDARY); -} - -/* - * set some bits on a range in the tree. This may require allocations or - * sleeping, so the gfp mask is used to indicate what is allowed. - * - * If any of the exclusive bits are set, this will fail with -EEXIST if some - * part of the range already has the desired bits set. The start of the - * existing range is returned in failed_start in this case. - * - * [start, end] is inclusive This takes the tree lock. - */ -int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, - u32 exclusive_bits, u64 *failed_start, - struct extent_state **cached_state, gfp_t mask, - struct extent_changeset *changeset) -{ - struct extent_state *state; - struct extent_state *prealloc = NULL; - struct rb_node *node; - struct rb_node **p; - struct rb_node *parent; - int err = 0; - u64 last_start; - u64 last_end; - - btrfs_debug_check_extent_io_range(tree, start, end); - trace_btrfs_set_extent_bit(tree, start, end - start + 1, bits); - - if (exclusive_bits) - ASSERT(failed_start); - else - ASSERT(failed_start == NULL); -again: - if (!prealloc && gfpflags_allow_blocking(mask)) { - /* - * Don't care for allocation failure here because we might end - * up not needing the pre-allocated extent state at all, which - * is the case if we only have in the tree extent states that - * cover our input range and don't cover too any other range. - * If we end up needing a new extent state we allocate it later. - */ - prealloc = alloc_extent_state(mask); - } - - spin_lock(&tree->lock); - if (cached_state && *cached_state) { - state = *cached_state; - if (state->start <= start && state->end > start && - extent_state_in_tree(state)) { - node = &state->rb_node; - goto hit_next; - } - } - /* - * this search will find all the extents that end after - * our range starts. - */ - node = tree_search_for_insert(tree, start, &p, &parent); - if (!node) { - prealloc = alloc_extent_state_atomic(prealloc); - BUG_ON(!prealloc); - prealloc->start = start; - prealloc->end = end; - insert_state_fast(tree, prealloc, p, parent, bits, changeset); - cache_state(prealloc, cached_state); - prealloc = NULL; - goto out; - } - state = rb_entry(node, struct extent_state, rb_node); -hit_next: - last_start = state->start; - last_end = state->end; - - /* - * | ---- desired range ---- | - * | state | - * - * Just lock what we found and keep going - */ - if (state->start == start && state->end <= end) { - if (state->state & exclusive_bits) { - *failed_start = state->start; - err = -EEXIST; - goto out; - } - - set_state_bits(tree, state, bits, changeset); - cache_state(state, cached_state); - merge_state(tree, state); - if (last_end == (u64)-1) - goto out; - start = last_end + 1; - state = next_state(state); - if (start < end && state && state->start == start && - !need_resched()) - goto hit_next; - goto search_again; - } - - /* - * | ---- desired range ---- | - * | state | - * or - * | ------------- state -------------- | - * - * We need to split the extent we found, and may flip bits on - * second half. - * - * If the extent we found extends past our - * range, we just split and search again. It'll get split - * again the next time though. - * - * If the extent we found is inside our range, we set the - * desired bit on it. - */ - if (state->start < start) { - if (state->state & exclusive_bits) { - *failed_start = start; - err = -EEXIST; - goto out; - } - - /* - * If this extent already has all the bits we want set, then - * skip it, not necessary to split it or do anything with it. - */ - if ((state->state & bits) == bits) { - start = state->end + 1; - cache_state(state, cached_state); - goto search_again; - } - - prealloc = alloc_extent_state_atomic(prealloc); - BUG_ON(!prealloc); - err = split_state(tree, state, prealloc, start); - if (err) - extent_io_tree_panic(tree, err); - - prealloc = NULL; - if (err) - goto out; - if (state->end <= end) { - set_state_bits(tree, state, bits, changeset); - cache_state(state, cached_state); - merge_state(tree, state); - if (last_end == (u64)-1) - goto out; - start = last_end + 1; - state = next_state(state); - if (start < end && state && state->start == start && - !need_resched()) - goto hit_next; - } - goto search_again; - } - /* - * | ---- desired range ---- | - * | state | or | state | - * - * There's a hole, we need to insert something in it and - * ignore the extent we found. - */ - if (state->start > start) { - u64 this_end; - if (end < last_start) - this_end = end; - else - this_end = last_start - 1; - - prealloc = alloc_extent_state_atomic(prealloc); - BUG_ON(!prealloc); - - /* - * Avoid to free 'prealloc' if it can be merged with - * the later extent. - */ - prealloc->start = start; - prealloc->end = this_end; - err = insert_state(tree, prealloc, bits, changeset); - if (err) - extent_io_tree_panic(tree, err); - - cache_state(prealloc, cached_state); - prealloc = NULL; - start = this_end + 1; - goto search_again; - } - /* - * | ---- desired range ---- | - * | state | - * We need to split the extent, and set the bit - * on the first half - */ - if (state->start <= end && state->end > end) { - if (state->state & exclusive_bits) { - *failed_start = start; - err = -EEXIST; - goto out; - } - - prealloc = alloc_extent_state_atomic(prealloc); - BUG_ON(!prealloc); - err = split_state(tree, state, prealloc, end + 1); - if (err) - extent_io_tree_panic(tree, err); - - set_state_bits(tree, prealloc, bits, changeset); - cache_state(prealloc, cached_state); - merge_state(tree, prealloc); - prealloc = NULL; - goto out; - } - -search_again: - if (start > end) - goto out; - spin_unlock(&tree->lock); - if (gfpflags_allow_blocking(mask)) - cond_resched(); - goto again; - -out: - spin_unlock(&tree->lock); - if (prealloc) - free_extent_state(prealloc); - - return err; - -} - -/** - * convert_extent_bit - convert all bits in a given range from one bit to - * another - * @tree: the io tree to search - * @start: the start offset in bytes - * @end: the end offset in bytes (inclusive) - * @bits: the bits to set in this range - * @clear_bits: the bits to clear in this range - * @cached_state: state that we're going to cache - * - * This will go through and set bits for the given range. If any states exist - * already in this range they are set with the given bit and cleared of the - * clear_bits. This is only meant to be used by things that are mergeable, ie - * converting from say DELALLOC to DIRTY. This is not meant to be used with - * boundary bits like LOCK. - * - * All allocations are done with GFP_NOFS. - */ -int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, u32 clear_bits, - struct extent_state **cached_state) -{ - struct extent_state *state; - struct extent_state *prealloc = NULL; - struct rb_node *node; - struct rb_node **p; - struct rb_node *parent; - int err = 0; - u64 last_start; - u64 last_end; - bool first_iteration = true; - - btrfs_debug_check_extent_io_range(tree, start, end); - trace_btrfs_convert_extent_bit(tree, start, end - start + 1, bits, - clear_bits); - -again: - if (!prealloc) { - /* - * Best effort, don't worry if extent state allocation fails - * here for the first iteration. We might have a cached state - * that matches exactly the target range, in which case no - * extent state allocations are needed. We'll only know this - * after locking the tree. - */ - prealloc = alloc_extent_state(GFP_NOFS); - if (!prealloc && !first_iteration) - return -ENOMEM; - } - - spin_lock(&tree->lock); - if (cached_state && *cached_state) { - state = *cached_state; - if (state->start <= start && state->end > start && - extent_state_in_tree(state)) { - node = &state->rb_node; - goto hit_next; - } - } - - /* - * this search will find all the extents that end after - * our range starts. - */ - node = tree_search_for_insert(tree, start, &p, &parent); - if (!node) { - prealloc = alloc_extent_state_atomic(prealloc); - if (!prealloc) { - err = -ENOMEM; - goto out; - } - prealloc->start = start; - prealloc->end = end; - insert_state_fast(tree, prealloc, p, parent, bits, NULL); - cache_state(prealloc, cached_state); - prealloc = NULL; - goto out; - } - state = rb_entry(node, struct extent_state, rb_node); -hit_next: - last_start = state->start; - last_end = state->end; - - /* - * | ---- desired range ---- | - * | state | - * - * Just lock what we found and keep going - */ - if (state->start == start && state->end <= end) { - set_state_bits(tree, state, bits, NULL); - cache_state(state, cached_state); - state = clear_state_bit(tree, state, clear_bits, 0, NULL); - if (last_end == (u64)-1) - goto out; - start = last_end + 1; - if (start < end && state && state->start == start && - !need_resched()) - goto hit_next; - goto search_again; - } - - /* - * | ---- desired range ---- | - * | state | - * or - * | ------------- state -------------- | - * - * We need to split the extent we found, and may flip bits on - * second half. - * - * If the extent we found extends past our - * range, we just split and search again. It'll get split - * again the next time though. - * - * If the extent we found is inside our range, we set the - * desired bit on it. - */ - if (state->start < start) { - prealloc = alloc_extent_state_atomic(prealloc); - if (!prealloc) { - err = -ENOMEM; - goto out; - } - err = split_state(tree, state, prealloc, start); - if (err) - extent_io_tree_panic(tree, err); - prealloc = NULL; - if (err) - goto out; - if (state->end <= end) { - set_state_bits(tree, state, bits, NULL); - cache_state(state, cached_state); - state = clear_state_bit(tree, state, clear_bits, 0, NULL); - if (last_end == (u64)-1) - goto out; - start = last_end + 1; - if (start < end && state && state->start == start && - !need_resched()) - goto hit_next; - } - goto search_again; - } - /* - * | ---- desired range ---- | - * | state | or | state | - * - * There's a hole, we need to insert something in it and - * ignore the extent we found. - */ - if (state->start > start) { - u64 this_end; - if (end < last_start) - this_end = end; - else - this_end = last_start - 1; - - prealloc = alloc_extent_state_atomic(prealloc); - if (!prealloc) { - err = -ENOMEM; - goto out; - } - - /* - * Avoid to free 'prealloc' if it can be merged with - * the later extent. - */ - prealloc->start = start; - prealloc->end = this_end; - err = insert_state(tree, prealloc, bits, NULL); - if (err) - extent_io_tree_panic(tree, err); - cache_state(prealloc, cached_state); - prealloc = NULL; - start = this_end + 1; - goto search_again; - } - /* - * | ---- desired range ---- | - * | state | - * We need to split the extent, and set the bit - * on the first half - */ - if (state->start <= end && state->end > end) { - prealloc = alloc_extent_state_atomic(prealloc); - if (!prealloc) { - err = -ENOMEM; - goto out; - } - - err = split_state(tree, state, prealloc, end + 1); - if (err) - extent_io_tree_panic(tree, err); - - set_state_bits(tree, prealloc, bits, NULL); - cache_state(prealloc, cached_state); - clear_state_bit(tree, prealloc, clear_bits, 0, NULL); - prealloc = NULL; - goto out; - } - -search_again: - if (start > end) - goto out; - spin_unlock(&tree->lock); - cond_resched(); - first_iteration = false; - goto again; - -out: - spin_unlock(&tree->lock); - if (prealloc) - free_extent_state(prealloc); - - return err; -} - void extent_range_clear_dirty_for_io(struct inode *inode, u64 start, u64 end) { unsigned long index = start >> PAGE_SHIFT; @@ -920,178 +212,6 @@ void extent_range_redirty_for_io(struct inode *inode, u64 start, u64 end) } } -/* find the first state struct with 'bits' set after 'start', and - * return it. tree->lock must be held. NULL will returned if - * nothing was found after 'start' - */ -static struct extent_state * -find_first_extent_bit_state(struct extent_io_tree *tree, u64 start, u32 bits) -{ - struct rb_node *node; - struct extent_state *state; - - /* - * this search will find all the extents that end after - * our range starts. - */ - node = tree_search(tree, start); - if (!node) - goto out; - - while (1) { - state = rb_entry(node, struct extent_state, rb_node); - if (state->end >= start && (state->state & bits)) - return state; - - node = rb_next(node); - if (!node) - break; - } -out: - return NULL; -} - -/* - * Find the first offset in the io tree with one or more @bits set. - * - * Note: If there are multiple bits set in @bits, any of them will match. - * - * Return 0 if we find something, and update @start_ret and @end_ret. - * Return 1 if we found nothing. - */ -int find_first_extent_bit(struct extent_io_tree *tree, u64 start, - u64 *start_ret, u64 *end_ret, u32 bits, - struct extent_state **cached_state) -{ - struct extent_state *state; - int ret = 1; - - spin_lock(&tree->lock); - if (cached_state && *cached_state) { - state = *cached_state; - if (state->end == start - 1 && extent_state_in_tree(state)) { - while ((state = next_state(state)) != NULL) { - if (state->state & bits) - goto got_it; - } - free_extent_state(*cached_state); - *cached_state = NULL; - goto out; - } - free_extent_state(*cached_state); - *cached_state = NULL; - } - - state = find_first_extent_bit_state(tree, start, bits); -got_it: - if (state) { - cache_state_if_flags(state, cached_state, 0); - *start_ret = state->start; - *end_ret = state->end; - ret = 0; - } -out: - spin_unlock(&tree->lock); - return ret; -} - -/** - * Find a contiguous area of bits - * - * @tree: io tree to check - * @start: offset to start the search from - * @start_ret: the first offset we found with the bits set - * @end_ret: the final contiguous range of the bits that were set - * @bits: bits to look for - * - * set_extent_bit and clear_extent_bit can temporarily split contiguous ranges - * to set bits appropriately, and then merge them again. During this time it - * will drop the tree->lock, so use this helper if you want to find the actual - * contiguous area for given bits. We will search to the first bit we find, and - * then walk down the tree until we find a non-contiguous area. The area - * returned will be the full contiguous area with the bits set. - */ -int find_contiguous_extent_bit(struct extent_io_tree *tree, u64 start, - u64 *start_ret, u64 *end_ret, u32 bits) -{ - struct extent_state *state; - int ret = 1; - - spin_lock(&tree->lock); - state = find_first_extent_bit_state(tree, start, bits); - if (state) { - *start_ret = state->start; - *end_ret = state->end; - while ((state = next_state(state)) != NULL) { - if (state->start > (*end_ret + 1)) - break; - *end_ret = state->end; - } - ret = 0; - } - spin_unlock(&tree->lock); - return ret; -} - -/* - * find a contiguous range of bytes in the file marked as delalloc, not - * more than 'max_bytes'. start and end are used to return the range, - * - * true is returned if we find something, false if nothing was in the tree - */ -bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, - u64 *end, u64 max_bytes, - struct extent_state **cached_state) -{ - struct rb_node *node; - struct extent_state *state; - u64 cur_start = *start; - bool found = false; - u64 total_bytes = 0; - - spin_lock(&tree->lock); - - /* - * this search will find all the extents that end after - * our range starts. - */ - node = tree_search(tree, cur_start); - if (!node) { - *end = (u64)-1; - goto out; - } - - while (1) { - state = rb_entry(node, struct extent_state, rb_node); - if (found && (state->start != cur_start || - (state->state & EXTENT_BOUNDARY))) { - goto out; - } - if (!(state->state & EXTENT_DELALLOC)) { - if (!found) - *end = state->end; - goto out; - } - if (!found) { - *start = state->start; - *cached_state = state; - refcount_inc(&state->refs); - } - found = true; - *end = state->end; - cur_start = state->end + 1; - node = rb_next(node); - total_bytes += state->end - state->start + 1; - if (total_bytes >= max_bytes) - break; - if (!node) - break; - } -out: - spin_unlock(&tree->lock); - return found; -} - /* * Process one page for __process_pages_contig(). * @@ -1373,66 +493,6 @@ void extent_clear_unlock_delalloc(struct btrfs_inode *inode, u64 start, u64 end, start, end, page_ops, NULL); } -/* - * count the number of bytes in the tree that have a given bit(s) - * set. This can be fairly slow, except for EXTENT_DIRTY which is - * cached. The total number found is returned. - */ -u64 count_range_bits(struct extent_io_tree *tree, - u64 *start, u64 search_end, u64 max_bytes, - u32 bits, int contig) -{ - struct rb_node *node; - struct extent_state *state; - u64 cur_start = *start; - u64 total_bytes = 0; - u64 last = 0; - int found = 0; - - if (WARN_ON(search_end <= cur_start)) - return 0; - - spin_lock(&tree->lock); - if (cur_start == 0 && bits == EXTENT_DIRTY) { - total_bytes = tree->dirty_bytes; - goto out; - } - /* - * this search will find all the extents that end after - * our range starts. - */ - node = tree_search(tree, cur_start); - if (!node) - goto out; - - while (1) { - state = rb_entry(node, struct extent_state, rb_node); - if (state->start > search_end) - break; - if (contig && found && state->start > last + 1) - break; - if (state->end >= cur_start && (state->state & bits) == bits) { - total_bytes += min(search_end, state->end) + 1 - - max(cur_start, state->start); - if (total_bytes >= max_bytes) - break; - if (!found) { - *start = max(cur_start, state->start); - found = 1; - } - last = state->end; - } else if (contig && found) { - break; - } - node = rb_next(node); - if (!node) - break; - } -out: - spin_unlock(&tree->lock); - return total_bytes; -} - static int insert_failrec(struct btrfs_inode *inode, struct io_failure_record *failrec) { @@ -1460,62 +520,6 @@ static struct io_failure_record *get_failrec(struct btrfs_inode *inode, return failrec; } -/* - * searches a range in the state tree for a given mask. - * If 'filled' == 1, this returns 1 only if every extent in the tree - * has the bits set. Otherwise, 1 is returned if any bit in the - * range is found set. - */ -int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, int filled, struct extent_state *cached) -{ - struct extent_state *state = NULL; - struct rb_node *node; - int bitset = 0; - - spin_lock(&tree->lock); - if (cached && extent_state_in_tree(cached) && cached->start <= start && - cached->end > start) - node = &cached->rb_node; - else - node = tree_search(tree, start); - while (node && start <= end) { - state = rb_entry(node, struct extent_state, rb_node); - - if (filled && state->start > start) { - bitset = 0; - break; - } - - if (state->start > end) - break; - - if (state->state & bits) { - bitset = 1; - if (!filled) - break; - } else if (filled) { - bitset = 0; - break; - } - - if (state->end == (u64)-1) - break; - - start = state->end + 1; - if (start > end) - break; - node = rb_next(node); - if (!node) { - if (filled) - bitset = 0; - break; - } - } - spin_unlock(&tree->lock); - return bitset; -} - static int free_io_failure(struct btrfs_inode *inode, struct io_failure_record *rec) { From patchwork Fri Sep 9 21:53:30 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972203 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 32521ECAAD3 for ; Fri, 9 Sep 2022 21:54:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231846AbiIIVyT (ORCPT ); Fri, 9 Sep 2022 17:54:19 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58448 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231829AbiIIVyS (ORCPT ); Fri, 9 Sep 2022 17:54:18 -0400 Received: from mail-qv1-xf30.google.com (mail-qv1-xf30.google.com [IPv6:2607:f8b0:4864:20::f30]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 342BF10B009 for ; Fri, 9 Sep 2022 14:54:17 -0700 (PDT) Received: by mail-qv1-xf30.google.com with SMTP id m9so2282977qvv.7 for ; Fri, 09 Sep 2022 14:54:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=2UMxDY5tG/hRohwsBIr2XSsC2j+BTvTFcC+qsCsUO8M=; b=ZuECmMlvkBFrlaf6zjW2SzhltTr/MB7Y3a3352hXKIYj7OUaJbRMvgorI2rLuA9Efc upjAsA6c7Dw5a7X5FuokdWe07DNfnv1axLpcyTn/ebXKhfO/Z9TCrt3SLBCklAUGd1zt fxE17iNeAKdyhO+vH8WrGsINa/a87P9uc8biXiuoMPmSs79zmIUeNmttelQA1HIxX9gB cgvCp6VgrXlHYjkTMo2urR0Gp9I6WnM7EtVKQn2MPeCF4omGgfUV5KM8a+Gz7WOF0TNX iDsxdKZr379c93Kb/+SFXqIGIO04k5RUntXdhnfQHNdrqtF8dv8/zLNdIUHXZofEEirP Q9ig== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=2UMxDY5tG/hRohwsBIr2XSsC2j+BTvTFcC+qsCsUO8M=; b=gj/7pX+ChJABoqYfLrHVdFwS/7Ze+IhJ39xiWbwSHmU0oNlwXYbNo8fj85M+WaSCiw 8Y8cHRGgLjgAWk6jxw4dNtVRTOVlsdssUc6+bmLnacnJ+xinnLkmq1EQ6kh7dzB3CBVM 6duzFxQn6gMzgJ+xMs/ZdHBLLH4B3KDV1NH6+Ph/TaXzeJ2yuZGi179O3uped558F7Dl huP11HgoWxo+o2KU7T3zSlnbmVT0bet2usV4YXIuAjFvEH4Y5h+FS1JAwfn5ck1Ae4Za ypJcXfrt5o5IuJscxEXcKEY4LzZ6jNMGJbatufhPeNIll5LmCwuHXifcVKS8xvKvpFen K8Dw== X-Gm-Message-State: ACgBeo0HV1FLaqJ0eTQ1gPSFUwyp9bI18YizEcFbCDlzTmsiTaLXxQd6 EBekdxLdFn951I/FjyRTD5dsPuKmo+sM0w== X-Google-Smtp-Source: AA6agR5wN5CEH3ezYIdwv57/51zae/00tCxpTfQAmqZM27Yy1BIJZ/QCyztfvi2x6Qa+xwSFhzjFgw== X-Received: by 2002:ad4:5ce9:0:b0:49f:ee02:50c7 with SMTP id iv9-20020ad45ce9000000b0049fee0250c7mr13851759qvb.105.1662760455804; Fri, 09 Sep 2022 14:54:15 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id a9-20020a05622a02c900b00344fbd8270bsm1262617qtx.42.2022.09.09.14.54.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:15 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 17/36] btrfs: unexport btrfs_debug_check_extent_io_range Date: Fri, 9 Sep 2022 17:53:30 -0400 Message-Id: <889cfbc7e78e7cb4c0919ddd65caa101c2b91963.1662760286.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 no longer need to export this as all users are in extent-io-tree.c, remove it from the header and put it into extent-io-tree.c. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 9 ++++++--- fs/btrfs/extent-io-tree.h | 10 ---------- 2 files changed, 6 insertions(+), 13 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 322909cf3040..6e1945fef01f 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -46,9 +46,11 @@ static inline void btrfs_extent_state_leak_debug_check(void) } } -void __btrfs_debug_check_extent_io_range(const char *caller, - struct extent_io_tree *tree, u64 start, - u64 end) +#define btrfs_debug_check_extent_io_range(tree, start, end) \ + __btrfs_debug_check_extent_io_range(__func__, (tree), (start), (end)) +static inline void __btrfs_debug_check_extent_io_range(const char *caller, + struct extent_io_tree *tree, + u64 start, u64 end) { struct inode *inode = tree->private_data; u64 isize; @@ -67,6 +69,7 @@ void __btrfs_debug_check_extent_io_range(const char *caller, #define btrfs_leak_debug_add_state(state) do {} while (0) #define btrfs_leak_debug_del_state(state) do {} while (0) #define btrfs_extent_state_leak_debug_check() do {} while (0) +#define btrfs_debug_check_extent_io_range(c, s, e) do {} while (0) #endif /* diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 251f1fc9a5b7..d01aba02ae2f 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -269,16 +269,6 @@ static inline bool extent_state_in_tree(const struct extent_state *state) return !RB_EMPTY_NODE(&state->rb_node); } -#ifdef CONFIG_BTRFS_DEBUG -void __btrfs_debug_check_extent_io_range(const char *caller, - struct extent_io_tree *tree, u64 start, - u64 end); -#define btrfs_debug_check_extent_io_range(tree, start, end) \ - __btrfs_debug_check_extent_io_range(__func__, (tree), (start), (end)) -#else -#define btrfs_debug_check_extent_io_range(c, s, e) do {} while (0) -#endif - struct tree_entry { u64 start; u64 end; From patchwork Fri Sep 9 21:53:31 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972204 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 2C1C2ECAAA1 for ; Fri, 9 Sep 2022 21:54:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231853AbiIIVyU (ORCPT ); Fri, 9 Sep 2022 17:54:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58474 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231843AbiIIVyT (ORCPT ); Fri, 9 Sep 2022 17:54:19 -0400 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 059681269D9 for ; Fri, 9 Sep 2022 14:54:18 -0700 (PDT) Received: by mail-qk1-x730.google.com with SMTP id h28so2244080qka.0 for ; Fri, 09 Sep 2022 14:54:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=smhc6y9qajeggr9zFcF+804yjK+8Bf2zTQtZmMWXTm0=; b=WErKrXnlP27kS49hnVaGwPDXPZvXjXb1k2IrmF62ILBOBKjlQMhivwXX5+MOi9ei7l Uep30ta2S753oiq6FdijSbsTP80rb407hyWWdLgLwYUwK1ilkgyBlj91148ZGWxuE4wE FZ29eZfbWXtI/ezaZiBN6N+Vb/5/+WyTq/XFt59HsmSK+mO/k+30KrYxHgrf4q1elr1j QliRGqalPk0c4noPjyhY26bUUVVgIft6Ho4ileAoimnnUoxO+31cUnzCTmGHJ0AlEwIZ Do521raomf/QJxiTU4j+ojJr8flp4Tyxqv/h8aq216ano15BHuMQqlWVKPR9oBKnc1hG CqEA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=smhc6y9qajeggr9zFcF+804yjK+8Bf2zTQtZmMWXTm0=; b=lFwG/u+x0yA01nh4/R0boNbvlYvlHb17wRClyQfwKenvrLMfasXmsdLjFwPsEToLuJ lBboqkSiQgkctLOX2xGK+13ZdNRMY10ygMIFZetaISqOju9+EKGyN4ddWRzeTMTKHb5S og7lxa3cNi/D+DZlaTrq+mQUK1LkahKtRObsNkURwv6eDU6PTKHpwTy0RDXVsOkNetXo ryUqXJWwh8eztxmtWDjCGDRkIYUX9QwvTxUV2eKevd6ZE0b3I9h6dhgAltei5Jg+GxJC d9EbdV+DooxYw0dycibBXv8HupA2qIVbOi1CMhE1hY5rpfgyN8xZdqeNMdWiMWXAsUhW nC7w== X-Gm-Message-State: ACgBeo1GWzMVpB6FQFniqZPLIKrSX5z9e29KHRsKyaflPRHjVmsTPmH5 r9CviYtU82VQKzJCUNlltv0AuXX71+DIjQ== X-Google-Smtp-Source: AA6agR5kWTyLi4Dus03sxm1BrNO4yXUAH5PhLwR5deE/TTXSyCw51OBUuq6axxR7dOHNK+wMQknpew== X-Received: by 2002:a05:620a:4384:b0:6bb:268c:1c3c with SMTP id a4-20020a05620a438400b006bb268c1c3cmr11876959qkp.16.1662760457319; Fri, 09 Sep 2022 14:54:17 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id m13-20020a05620a290d00b006b9815a05easm1336999qkp.26.2022.09.09.14.54.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:16 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 18/36] btrfs: unexport all the temporary exports for extent-io-tree.c Date: Fri, 9 Sep 2022 17:53:31 -0400 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 we've moved everything we can unexport all the temporary exports, move the random helpers, and mark everything as static again. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 69 ++++++++++++++++++++++++++------------- fs/btrfs/extent-io-tree.h | 47 -------------------------- 2 files changed, 47 insertions(+), 69 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 6e1945fef01f..e462b81a8d3e 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -9,6 +9,11 @@ static struct kmem_cache *extent_state_cache; +static inline bool extent_state_in_tree(const struct extent_state *state) +{ + return !RB_EMPTY_NODE(&state->rb_node); +} + #ifdef CONFIG_BTRFS_DEBUG static LIST_HEAD(states); static DEFINE_SPINLOCK(leak_lock); @@ -81,6 +86,12 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller, */ static struct lock_class_key file_extent_tree_class; +struct tree_entry { + u64 start; + u64 end; + struct rb_node rb_node; +}; + void extent_io_tree_init(struct btrfs_fs_info *fs_info, struct extent_io_tree *tree, unsigned int owner, void *private_data) @@ -124,7 +135,7 @@ void extent_io_tree_release(struct extent_io_tree *tree) spin_unlock(&tree->lock); } -struct extent_state *alloc_extent_state(gfp_t mask) +static struct extent_state *alloc_extent_state(gfp_t mask) { struct extent_state *state; @@ -145,7 +156,7 @@ struct extent_state *alloc_extent_state(gfp_t mask) return state; } -struct extent_state *alloc_extent_state_atomic(struct extent_state *prealloc) +static struct extent_state *alloc_extent_state_atomic(struct extent_state *prealloc) { if (!prealloc) prealloc = alloc_extent_state(GFP_ATOMIC); @@ -183,6 +194,15 @@ static int add_extent_changeset(struct extent_state *state, u32 bits, return ret; } +static inline struct extent_state *next_state(struct extent_state *state) +{ + struct rb_node *next = rb_next(&state->rb_node); + if (next) + return rb_entry(next, struct extent_state, rb_node); + else + return NULL; +} + /** * Search @tree for an entry that contains @offset. Such entry would have * entry->start <= offset && entry->end >= offset. @@ -200,9 +220,10 @@ static int add_extent_changeset(struct extent_state *state, u32 bits, * If no such entry exists, return pointer to entry that ends before @offset * and fill parameters @node_ret and @parent_ret, ie. does not return NULL. */ -struct rb_node *tree_search_for_insert(struct extent_io_tree *tree, u64 offset, - struct rb_node ***node_ret, - struct rb_node **parent_ret) +static inline struct rb_node *tree_search_for_insert(struct extent_io_tree *tree, + u64 offset, + struct rb_node ***node_ret, + struct rb_node **parent_ret) { struct rb_root *root = &tree->state; struct rb_node **node = &root->rb_node; @@ -247,9 +268,10 @@ struct rb_node *tree_search_for_insert(struct extent_io_tree *tree, u64 offset, * such entry exists, then return NULL and fill @prev_ret and @next_ret. * Otherwise return the found entry and other pointers are left untouched. */ -struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, u64 offset, - struct rb_node **prev_ret, - struct rb_node **next_ret) +static inline struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, + u64 offset, + struct rb_node **prev_ret, + struct rb_node **next_ret) { struct rb_root *root = &tree->state; struct rb_node **node = &root->rb_node; @@ -313,7 +335,7 @@ static void extent_io_tree_panic(struct extent_io_tree *tree, int err) * * This should be called with the tree lock held. */ -void merge_state(struct extent_io_tree *tree, struct extent_state *state) +static void merge_state(struct extent_io_tree *tree, struct extent_state *state) { struct extent_state *other; struct rb_node *other_node; @@ -353,8 +375,9 @@ void merge_state(struct extent_io_tree *tree, struct extent_state *state) } } -void set_state_bits(struct extent_io_tree *tree, struct extent_state *state, - u32 bits, struct extent_changeset *changeset) +static void set_state_bits(struct extent_io_tree *tree, + struct extent_state *state, + u32 bits, struct extent_changeset *changeset) { u32 bits_to_set = bits & ~EXTENT_CTLBITS; int ret; @@ -381,8 +404,9 @@ void set_state_bits(struct extent_io_tree *tree, struct extent_state *state, * The tree lock is not taken internally. This is a utility function and * probably isn't what you want to call (see set/clear_extent_bit). */ -int insert_state(struct extent_io_tree *tree, struct extent_state *state, - u32 bits, struct extent_changeset *changeset) +static int insert_state(struct extent_io_tree *tree, + struct extent_state *state, + u32 bits, struct extent_changeset *changeset) { struct rb_node **node; struct rb_node *parent; @@ -419,9 +443,10 @@ int insert_state(struct extent_io_tree *tree, struct extent_state *state, /* * Insert state to @tree to the location given by @node and @parent. */ -void insert_state_fast(struct extent_io_tree *tree, struct extent_state *state, - struct rb_node **node, struct rb_node *parent, - unsigned bits, struct extent_changeset *changeset) +static void insert_state_fast(struct extent_io_tree *tree, + struct extent_state *state, struct rb_node **node, + struct rb_node *parent, unsigned bits, + struct extent_changeset *changeset) { set_state_bits(tree, state, bits, changeset); rb_link_node(&state->rb_node, parent, node); @@ -443,8 +468,8 @@ void insert_state_fast(struct extent_io_tree *tree, struct extent_state *state, * The tree locks are not taken by this function. They need to be held * by the caller. */ -int split_state(struct extent_io_tree *tree, struct extent_state *orig, - struct extent_state *prealloc, u64 split) +static int split_state(struct extent_io_tree *tree, struct extent_state *orig, + struct extent_state *prealloc, u64 split) { struct rb_node *parent = NULL; struct rb_node **node; @@ -489,10 +514,10 @@ int split_state(struct extent_io_tree *tree, struct extent_state *orig, * If no bits are set on the state struct after clearing things, the * struct is freed and removed from the tree */ -struct extent_state *clear_state_bit(struct extent_io_tree *tree, - struct extent_state *state, u32 bits, - int wake, - struct extent_changeset *changeset) +static struct extent_state *clear_state_bit(struct extent_io_tree *tree, + struct extent_state *state, + u32 bits, int wake, + struct extent_changeset *changeset) { struct extent_state *next; u32 bits_to_clear = bits & ~EXTENT_CTLBITS; diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index d01aba02ae2f..3b17cc33bcec 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -260,51 +260,4 @@ void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start, u64 end); int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, struct page *page, unsigned int pg_offset); - -struct extent_state *alloc_extent_state_atomic(struct extent_state *prealloc); -struct extent_state *alloc_extent_state(gfp_t mask); - -static inline bool extent_state_in_tree(const struct extent_state *state) -{ - return !RB_EMPTY_NODE(&state->rb_node); -} - -struct tree_entry { - u64 start; - u64 end; - struct rb_node rb_node; -}; - -struct rb_node *tree_search_for_insert(struct extent_io_tree *tree, u64 offset, - struct rb_node ***node_ret, - struct rb_node **parent_ret); -struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, u64 offset, - struct rb_node **prev_ret, - struct rb_node **next_ret); -void merge_state(struct extent_io_tree *tree, struct extent_state *state); - -static inline struct extent_state *next_state(struct extent_state *state) -{ - struct rb_node *next = rb_next(&state->rb_node); - if (next) - return rb_entry(next, struct extent_state, rb_node); - else - return NULL; -} -struct extent_state *clear_state_bit(struct extent_io_tree *tree, - struct extent_state *state, u32 bits, - int wake, - struct extent_changeset *changeset); -int insert_state(struct extent_io_tree *tree, struct extent_state *state, - u32 bits, struct extent_changeset *changeset); -int split_state(struct extent_io_tree *tree, struct extent_state *orig, - struct extent_state *prealloc, u64 split); -int insert_state(struct extent_io_tree *tree, struct extent_state *state, - u32 bits, struct extent_changeset *changeset); -void insert_state_fast(struct extent_io_tree *tree, struct extent_state *state, - struct rb_node **node, struct rb_node *parent, - unsigned bits, struct extent_changeset *changeset); -void set_state_bits(struct extent_io_tree *tree, struct extent_state *state, - u32 bits, struct extent_changeset *changeset); - #endif /* BTRFS_EXTENT_IO_TREE_H */ From patchwork Fri Sep 9 21:53:32 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972205 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 4FB35C6FA89 for ; Fri, 9 Sep 2022 21:54:24 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231866AbiIIVyW (ORCPT ); Fri, 9 Sep 2022 17:54:22 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58504 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231829AbiIIVyU (ORCPT ); Fri, 9 Sep 2022 17:54:20 -0400 Received: from mail-qt1-x832.google.com (mail-qt1-x832.google.com [IPv6:2607:f8b0:4864:20::832]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4450F113C5E for ; Fri, 9 Sep 2022 14:54:19 -0700 (PDT) Received: by mail-qt1-x832.google.com with SMTP id r6so2344797qtx.6 for ; Fri, 09 Sep 2022 14:54:19 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=qUFMHuXycz7rmHA0hI3ZRo8x5SOXZYVbmwk1Z+HWHWk=; b=okqdrzNxeKXDSUZMiTISY3yxpdtNV+gV8f/qpw2+d64sG36oCqTQj4CeNgcXyDLIVg 5FXNvxdhTjXWAA3Kg7L5CIqbinp9hO19NR+vqsiCJ4Pj/nlcmxAP0Sd9qgAkZeK9Z5pz l6QZPOfe4QYSxPGMo5HC1Usw8Y6AsAb1GGgM6iwp5ZGdGbouUOQxBmpUg+maYa4ITCLe b0Poy7fRw7gG7NAOK+7h9CQBCne8NXauCtkdNHsFcGCJPsob+iAWigdtpSAUtQ/BVhuE tzi3E3xdmMjNXUPBmVE6FEZ62fptDcYv0uEkSPgNjdNEeUr+GLllFOIss6GFVr3QoPwJ Kjkg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=qUFMHuXycz7rmHA0hI3ZRo8x5SOXZYVbmwk1Z+HWHWk=; b=D3hHuGz6nrQSkv1B0CbAtK1dqyWBWjT+BZbrmPKF8gpJIk95zJBYm1q/aXw/2nVVIs KEMlQxbHw4NCjlENi8o7aed/OQB70P1nUrDcJ4fG2n70SUGUY9scgypzVGSFu21PXPyc V1rV4rVcDxkkVT3rU8e0s/lcO4H87jDvBFM3ESylqPUNVyYc8c0o9ndpDwxfHFV2gTN5 shdElS2njQXpbOClKl+/h4mhkxAHNV1m/o46BgGmNqZ5QvS/vGsFfNOSdwMR6KnL3pzv 35ksbPJPOU8zqU9gC1ECQGmKo1fQ16kGEkVszpEyCigw4d206NRdXoyj5LB5nSpwK8Cd oY0w== X-Gm-Message-State: ACgBeo2JDS8fggsn/eFZ2ak8uIsfO47slChpijOyXkOztY3qZ552O5aD 0RWNqYioovYuAkgtiQcNs2gTYTxMfvQr8Q== X-Google-Smtp-Source: AA6agR4AtzNg2UeKBAa9PtrQkBmV8F1Q8wyHqmsepcYOnFopW5YXzzrytwEDlc7C5nRJgSP9yU5GJQ== X-Received: by 2002:ac8:7f03:0:b0:344:6f5c:6aee with SMTP id f3-20020ac87f03000000b003446f5c6aeemr14661672qtk.558.1662760458623; Fri, 09 Sep 2022 14:54:18 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id l3-20020a37f903000000b006af0ce13499sm1321029qkj.115.2022.09.09.14.54.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:18 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 19/36] btrfs: remove struct tree_entry Date: Fri, 9 Sep 2022 17:53:32 -0400 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 existed when we overloaded the tree manipulation functions for both the extent_io_tree and the extent buffer tree. However the extent buffers are now stored in a radix tree, so we no longer need this abstraction. Remove struct tree_entry and use extent_state directly instead. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index e462b81a8d3e..4855fa5ab29e 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -228,11 +228,11 @@ static inline struct rb_node *tree_search_for_insert(struct extent_io_tree *tree struct rb_root *root = &tree->state; struct rb_node **node = &root->rb_node; struct rb_node *prev = NULL; - struct tree_entry *entry; + struct extent_state *entry; while (*node) { prev = *node; - entry = rb_entry(prev, struct tree_entry, rb_node); + entry = rb_entry(prev, struct extent_state, rb_node); if (offset < entry->start) node = &(*node)->rb_left; @@ -250,7 +250,7 @@ static inline struct rb_node *tree_search_for_insert(struct extent_io_tree *tree /* Search neighbors until we find the first one past the end */ while (prev && offset > entry->end) { prev = rb_next(prev); - entry = rb_entry(prev, struct tree_entry, rb_node); + entry = rb_entry(prev, struct extent_state, rb_node); } return prev; @@ -277,14 +277,14 @@ static inline struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, struct rb_node **node = &root->rb_node; struct rb_node *prev = NULL; struct rb_node *orig_prev = NULL; - struct tree_entry *entry; + struct extent_state *entry; ASSERT(prev_ret); ASSERT(next_ret); while (*node) { prev = *node; - entry = rb_entry(prev, struct tree_entry, rb_node); + entry = rb_entry(prev, struct extent_state, rb_node); if (offset < entry->start) node = &(*node)->rb_left; @@ -297,15 +297,15 @@ static inline struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, orig_prev = prev; while (prev && offset > entry->end) { prev = rb_next(prev); - entry = rb_entry(prev, struct tree_entry, rb_node); + entry = rb_entry(prev, struct extent_state, rb_node); } *next_ret = prev; prev = orig_prev; - entry = rb_entry(prev, struct tree_entry, rb_node); + entry = rb_entry(prev, struct extent_state, rb_node); while (prev && offset < entry->start) { prev = rb_prev(prev); - entry = rb_entry(prev, struct tree_entry, rb_node); + entry = rb_entry(prev, struct extent_state, rb_node); } *prev_ret = prev; @@ -416,10 +416,10 @@ static int insert_state(struct extent_io_tree *tree, node = &tree->state.rb_node; while (*node) { - struct tree_entry *entry; + struct extent_state *entry; parent = *node; - entry = rb_entry(parent, struct tree_entry, rb_node); + entry = rb_entry(parent, struct extent_state, rb_node); if (end < entry->start) { node = &(*node)->rb_left; @@ -485,10 +485,10 @@ static int split_state(struct extent_io_tree *tree, struct extent_state *orig, parent = &orig->rb_node; node = &parent; while (*node) { - struct tree_entry *entry; + struct extent_state *entry; parent = *node; - entry = rb_entry(parent, struct tree_entry, rb_node); + entry = rb_entry(parent, struct extent_state, rb_node); if (prealloc->end < entry->start) { node = &(*node)->rb_left; From patchwork Fri Sep 9 21:53:33 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972207 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 3D623ECAAD5 for ; Fri, 9 Sep 2022 21:54:25 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231868AbiIIVyX (ORCPT ); Fri, 9 Sep 2022 17:54:23 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58534 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231859AbiIIVyV (ORCPT ); Fri, 9 Sep 2022 17:54:21 -0400 Received: from mail-qk1-x72a.google.com (mail-qk1-x72a.google.com [IPv6:2607:f8b0:4864:20::72a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D39151079C8 for ; Fri, 9 Sep 2022 14:54:20 -0700 (PDT) Received: by mail-qk1-x72a.google.com with SMTP id s22so2223103qkj.3 for ; Fri, 09 Sep 2022 14:54:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=AK3479ESINHUUJLmgSIWNutZHl95zZZl3FXkX49uOvQ=; b=cZZK6lDBnjJpylNTMN3PvjatxG6lIO7PxGsqa/TQb49c5OYRCkuPnR26KFVIlqmTE7 wGP98mHSJnrlX3SJxwqFG5DjOs6ZIjBJyP3/Ze6owfO/PySu4XDY3PtSV9oSFsVmbslJ 9Vdl4RTurwhZMzrR1JHuCUdsMQq2yfSB9heB7hdkXwEPQ7yuPOwWThYfeiP5dFh2TEu4 G/uDX+LDyqZVr3jm0d1HGuuiLaY6OGPYNCTFJiqiLVe0b0c4WCn+wRpnaC0Dp8xGOafv VRMRbpjQp1dAkMgWTqZ0URy0pPiHEg3JQbXDfVeESB7k8TSrLKftzJ6mTaPrAZTyAzwb VWog== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=AK3479ESINHUUJLmgSIWNutZHl95zZZl3FXkX49uOvQ=; b=w1kFgJb+ErV8EToYCV7fhoJS+yl1UPk0uBy+d8tGdetE9wTqAdB2Efs0jNah/HXEk6 GpedaujneweEaIMTeJyMVUREk2QxbwGaEe4+6zJ+kEpCnLRmxEU8YiGs9pyMvRHOz93I N9WhFxRkFTKLykLj4mIrdfMzTSJqJz1PdkjofcQ7OvorfcHM5eNOCtfgF/rVOoVHFk1O +/bH7lTbpJ9oUNzyFoLlmyoGngFuefGEU2brMO8Vlk4wGu2ibShRQ8fjZSo4T/dGO6OS zXVcK8Mu2dpMPjIEkFavVVRu+WmNopajCezEynCAPXv7KExsdRTl5L1Ci5zJMcRgvqQD tV+Q== X-Gm-Message-State: ACgBeo3GC4n5QMmq2vmH9L2mu80V8rXZUGwMZl9xggd2JRmlKNT628fI r1NGs7eLBmxcWFkHY0NIeuVdcpozMzGKXQ== X-Google-Smtp-Source: AA6agR7VNf8z2HYdndNqifM69Vw3L0+YJwms8bPX+vto17vbPnsCpWJ153uY/i7dKjXy7Um2UPt6Eg== X-Received: by 2002:a05:620a:8001:b0:6ba:be07:7187 with SMTP id ee1-20020a05620a800100b006babe077187mr11884429qkb.153.1662760460177; Fri, 09 Sep 2022 14:54:20 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id 126-20020a370684000000b006be8713f742sm1422630qkg.38.2022.09.09.14.54.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:19 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 20/36] btrfs: use next_state instead of rb_next where we can Date: Fri, 9 Sep 2022 17:53:33 -0400 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 can simplify a lot of these functions where we have to cycle through extent_state's by simply using next_state() instead of rb_next(). In many spots this allows us to do things like while (state) { /* whatever */ state = next_state(state); } instead of while (1) { state = rb_entry(n, struct extent_state, rb_node); n = rb_next(n); if (!n) break; } Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 57 +++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 33 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 4855fa5ab29e..f3034524acdf 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -752,12 +752,10 @@ void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) * our range starts */ node = tree_search(tree, start); -process_node: if (!node) break; - state = rb_entry(node, struct extent_state, rb_node); - +process_node: if (state->start > end) goto out; @@ -774,7 +772,7 @@ void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) break; if (!cond_resched_lock(&tree->lock)) { - node = rb_next(node); + state = next_state(state); goto process_node; } } @@ -818,15 +816,13 @@ find_first_extent_bit_state(struct extent_io_tree *tree, u64 start, u32 bits) node = tree_search(tree, start); if (!node) goto out; + state = rb_entry(node, struct extent_state, rb_node); - while (1) { - state = rb_entry(node, struct extent_state, rb_node); + while (state) { if (state->end >= start && (state->state & bits)) return state; - node = rb_next(node); - if (!node) - break; + state = next_state(state); } out: return NULL; @@ -942,8 +938,8 @@ bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, goto out; } - while (1) { - state = rb_entry(node, struct extent_state, rb_node); + state = rb_entry(node, struct extent_state, rb_node); + while (state) { if (found && (state->start != cur_start || (state->state & EXTENT_BOUNDARY))) { goto out; @@ -961,12 +957,10 @@ bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, found = true; *end = state->end; cur_start = state->end + 1; - node = rb_next(node); total_bytes += state->end - state->start + 1; if (total_bytes >= max_bytes) break; - if (!node) - break; + state = next_state(state); } out: spin_unlock(&tree->lock); @@ -1519,18 +1513,15 @@ void find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start, * Find the longest stretch from start until an entry which has the * bits set */ - while (1) { - state = rb_entry(node, struct extent_state, rb_node); + state = rb_entry(node, struct extent_state, rb_node); + while (state) { if (state->end >= start && !(state->state & bits)) { *end_ret = state->end; } else { *end_ret = state->start - 1; break; } - - node = rb_next(node); - if (!node) - break; + state = next_state(state); } out: spin_unlock(&tree->lock); @@ -1568,8 +1559,8 @@ u64 count_range_bits(struct extent_io_tree *tree, if (!node) goto out; - while (1) { - state = rb_entry(node, struct extent_state, rb_node); + state = rb_entry(node, struct extent_state, rb_node); + while (state) { if (state->start > search_end) break; if (contig && found && state->start > last + 1) @@ -1587,9 +1578,7 @@ u64 count_range_bits(struct extent_io_tree *tree, } else if (contig && found) { break; } - node = rb_next(node); - if (!node) - break; + state = next_state(state); } out: spin_unlock(&tree->lock); @@ -1615,9 +1604,11 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, node = &cached->rb_node; else node = tree_search(tree, start); - while (node && start <= end) { - state = rb_entry(node, struct extent_state, rb_node); + if (!node) + goto out; + state = rb_entry(node, struct extent_state, rb_node); + while (state && start <= end) { if (filled && state->start > start) { bitset = 0; break; @@ -1641,13 +1632,13 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, start = state->end + 1; if (start > end) break; - node = rb_next(node); - if (!node) { - if (filled) - bitset = 0; - break; - } + state = next_state(state); } + + /* We ran out of states and were still inside of our range. */ + if (filled && !state) + bitset = 0; +out: spin_unlock(&tree->lock); return bitset; } From patchwork Fri Sep 9 21:53:34 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972208 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 ECB28ECAAD3 for ; Fri, 9 Sep 2022 21:54:32 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231879AbiIIVya (ORCPT ); Fri, 9 Sep 2022 17:54:30 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58794 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231859AbiIIVy2 (ORCPT ); Fri, 9 Sep 2022 17:54:28 -0400 Received: from mail-qv1-xf2f.google.com (mail-qv1-xf2f.google.com [IPv6:2607:f8b0:4864:20::f2f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BCE70260 for ; Fri, 9 Sep 2022 14:54:22 -0700 (PDT) Received: by mail-qv1-xf2f.google.com with SMTP id ml1so2298323qvb.1 for ; Fri, 09 Sep 2022 14:54:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=LqAJ+9wD7xVuvVryKVLMmz/qAdDNUaoPbnnrJEhmQXI=; b=sCuzXkIOFLZ+eaI6yvOKWzOmjR9Ayl1qGQZKuhBVefXqEiCBiCfAQkRGPQWzs3opD5 ZCu1XMzr0h59xaaH8SWtNe55uq63FwXlxnk9oXKy74NaalbqBhnWyTFdZNvWdzJA1v4Q y3Dz8XBnWyqIWMUtODBdGWleRtzJmMagLcUuREp2ngguJt0NrfLy+XMF66AxdvWW02ag U73gXhcKXnsFDDsE3Fm1ClvoiU9knbWM8YgIHDnPwqSkSqHHXgeNYOSeHBk+CJEYuejY TDi7zB9xg6wEcuMMPkawAY9f4lGf0u7wjmXD2B5woxecSSLPJQvfeOdSp09qRV1RZOnn FYGg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=LqAJ+9wD7xVuvVryKVLMmz/qAdDNUaoPbnnrJEhmQXI=; b=chSk9QcUGTmOavDg65O1zdQocJAQRw7ODDMp5ccsUmEEhaKUbU3vYOTB8kqiftLj+u CP3dRh+EXmvZ3TNWQ0cadfLBaqf4r3B+j1Zwfuzn+ot5EK3HNKQOgysyXv3mpm/eHPWC 2Avai+HaZzp6IFPOYJJ4jUK1zIy9k0pBIKmqunDvbAQxhXRVSCO5TC76fsAyFhHufaFt nmw8l0M+Ene4r8CU96geQI7YEhdo8POuoUvEewa1a9e2lb+mi3YcWOu7LYZNht8SK/SD m92oEUlBKXQokFupVihJ+q5O4nHdCVd3mfWII8p7Yed3lL+pBFnoioz5sLlL6YRO2hhi 3GGA== X-Gm-Message-State: ACgBeo0W841sswBQApgskRJqlLRqbttgZhwZIUBrQ9qoV9H6+iiJKJnn Oz7bLbx6Q5ioT+I/O0+OKCxpG/l0UJTLaA== X-Google-Smtp-Source: AA6agR5/hx/zsbfsR8jQlBXB4FvUJAa4eK63Liy905xhkoNyWyD+xuV9PR4BkvRMkgmgZCXA38OfUQ== X-Received: by 2002:a05:6214:508f:b0:4aa:a63d:ad12 with SMTP id kk15-20020a056214508f00b004aaa63dad12mr14524347qvb.123.1662760461563; Fri, 09 Sep 2022 14:54:21 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id t137-20020a37aa8f000000b006b8e63dfffbsm1209317qke.58.2022.09.09.14.54.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:21 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 21/36] btrfs: make tree_search return struct extent_state Date: Fri, 9 Sep 2022 17:53:34 -0400 Message-Id: <2c3ba5eed29cea277db76d296623260756baf82e.1662760286.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 have a consistent pattern of n = tree_search(); if (!n) goto out; state = rb_entry(n, struct extent_state, rb_node); while (state) { /* do something. */ } which is a bit redundant. If we make tree_search return the state we can simply have state = tree_search(); while (state) { /* do something. */ } which cleans up the code quite a bit. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 51 +++++++++++---------------------------- 1 file changed, 14 insertions(+), 37 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index f3034524acdf..5cfe66941ade 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -315,9 +315,10 @@ static inline struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, /* * Inexact rb-tree search, return the next entry if @offset is not found */ -static inline struct rb_node *tree_search(struct extent_io_tree *tree, u64 offset) +static inline struct extent_state *tree_search(struct extent_io_tree *tree, u64 offset) { - return tree_search_for_insert(tree, offset, NULL, NULL); + struct rb_node *n = tree_search_for_insert(tree, offset, NULL, NULL); + return (n) ? rb_entry(n, struct extent_state, rb_node) : NULL; } static void extent_io_tree_panic(struct extent_io_tree *tree, int err) @@ -573,7 +574,6 @@ int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state *state; struct extent_state *cached; struct extent_state *prealloc = NULL; - struct rb_node *node; u64 last_end; int err; int clear = 0; @@ -624,10 +624,9 @@ int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, * this search will find the extents that end after * our range starts */ - node = tree_search(tree, start); - if (!node) + state = tree_search(tree, start); + if (!state) goto out; - state = rb_entry(node, struct extent_state, rb_node); hit_next: if (state->start > end) goto out; @@ -740,7 +739,6 @@ static void wait_on_state(struct extent_io_tree *tree, void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { struct extent_state *state; - struct rb_node *node; btrfs_debug_check_extent_io_range(tree, start, end); @@ -751,11 +749,10 @@ void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) * this search will find all the extents that end after * our range starts */ - node = tree_search(tree, start); - if (!node) - break; - state = rb_entry(node, struct extent_state, rb_node); + state = tree_search(tree, start); process_node: + if (!state) + break; if (state->start > end) goto out; @@ -806,25 +803,18 @@ static void cache_state(struct extent_state *state, static struct extent_state * find_first_extent_bit_state(struct extent_io_tree *tree, u64 start, u32 bits) { - struct rb_node *node; struct extent_state *state; /* * this search will find all the extents that end after * our range starts. */ - node = tree_search(tree, start); - if (!node) - goto out; - state = rb_entry(node, struct extent_state, rb_node); - + state = tree_search(tree, start); while (state) { if (state->end >= start && (state->state & bits)) return state; - state = next_state(state); } -out: return NULL; } @@ -920,7 +910,6 @@ bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, u64 *end, u64 max_bytes, struct extent_state **cached_state) { - struct rb_node *node; struct extent_state *state; u64 cur_start = *start; bool found = false; @@ -932,13 +921,12 @@ bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, * this search will find all the extents that end after * our range starts. */ - node = tree_search(tree, cur_start); - if (!node) { + state = tree_search(tree, cur_start); + if (!state) { *end = (u64)-1; goto out; } - state = rb_entry(node, struct extent_state, rb_node); while (state) { if (found && (state->start != cur_start || (state->state & EXTENT_BOUNDARY))) { @@ -1536,7 +1524,6 @@ u64 count_range_bits(struct extent_io_tree *tree, u64 *start, u64 search_end, u64 max_bytes, u32 bits, int contig) { - struct rb_node *node; struct extent_state *state; u64 cur_start = *start; u64 total_bytes = 0; @@ -1555,11 +1542,7 @@ u64 count_range_bits(struct extent_io_tree *tree, * this search will find all the extents that end after * our range starts. */ - node = tree_search(tree, cur_start); - if (!node) - goto out; - - state = rb_entry(node, struct extent_state, rb_node); + state = tree_search(tree, cur_start); while (state) { if (state->start > search_end) break; @@ -1595,19 +1578,14 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, int filled, struct extent_state *cached) { struct extent_state *state = NULL; - struct rb_node *node; int bitset = 0; spin_lock(&tree->lock); if (cached && extent_state_in_tree(cached) && cached->start <= start && cached->end > start) - node = &cached->rb_node; + state = cached; else - node = tree_search(tree, start); - if (!node) - goto out; - - state = rb_entry(node, struct extent_state, rb_node); + state = tree_search(tree, start); while (state && start <= end) { if (filled && state->start > start) { bitset = 0; @@ -1638,7 +1616,6 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, /* We ran out of states and were still inside of our range. */ if (filled && !state) bitset = 0; -out: spin_unlock(&tree->lock); return bitset; } From patchwork Fri Sep 9 21:53:35 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972209 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 B613FECAAA1 for ; Fri, 9 Sep 2022 21:54:34 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231890AbiIIVyc (ORCPT ); Fri, 9 Sep 2022 17:54:32 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58796 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231873AbiIIVy2 (ORCPT ); Fri, 9 Sep 2022 17:54:28 -0400 Received: from mail-qv1-xf30.google.com (mail-qv1-xf30.google.com [IPv6:2607:f8b0:4864:20::f30]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B70D3E25 for ; Fri, 9 Sep 2022 14:54:23 -0700 (PDT) Received: by mail-qv1-xf30.google.com with SMTP id m9so2283162qvv.7 for ; Fri, 09 Sep 2022 14:54:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=37ITjuqXN/bU0OZlQn3yRW7PPr3lMEK9VWCoUPZurx4=; b=XbmS2dfq5PczpPfvpvhskGv0u4Sc95ThWbq3aQyG6aDHps56duJQ6P7aQHzqUUranF WgNsSt4zUUkriPLzUpgQTi9+8I/bLRYxKrKCYJDLVj1Gcs8pdFhJsS9fm7pP/95PKh+p gCE/nWGjdJo/8m3kdG0/9hF0qfzWE+8pP79q2vyFB+qJlgqW+EL2TCUpDHwy/3HpIzYd eE0uPD2C8qgBw3ZqjWSivMlWTV/KasnyUDFyBN9e5MjSNzqLP+ymknEk8inTjYdvedvK lTX64Z/IxaDAhwV/snX1BBNwgaq/6Xrw2LP4CtZCEG4B6hE7wzERjfuxJxtMMv26Hvtd CQzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=37ITjuqXN/bU0OZlQn3yRW7PPr3lMEK9VWCoUPZurx4=; b=ALROapgpLsUH6HvuOpp2sOE7KmCP83uZex+ZxDFchCPcYajXHSy9fmek8lPR8GtfhM GvUaLu7ckX10wUTLPjWoiY4y+ZF/1tY5Aeic5RzgJ3y8ildgmJjcqQ3moseDmgYJY4MQ nFvE63jM6UTq068ln5n5Hi1G6QV7GavkW1KEOywUDC5FH+tbkbRs4TvqTl40B2C8w0J2 q1Ajh/rn3tTIqvAsxKs1noX0av+g7gc5TlB/gUwnqJCqOO557/4GgTPFLcLHScMuM1Ok wzKk5T/irjjQYpwTcyI6xIYnvk08laUjT5cxoeB4TjLIIv38tsRHyD5+R+zoZ2V1p6VO HuYA== X-Gm-Message-State: ACgBeo2Frqhvbi+JPICnEDQGEI52LXtcr2/0BBFre+ROYcULRbEIjqYw TRTdmTNYpfLBIzCDzFxSzHyJJO1/wzEhDA== X-Google-Smtp-Source: AA6agR64sX6Q0ALHzPP2mPoREw4hEywQEiWygVmlTnjUzYXTJyIbbSr2+5wvOulpuNiqEkmoRbyj2A== X-Received: by 2002:a05:6214:27c6:b0:4ac:94f9:c727 with SMTP id ge6-20020a05621427c600b004ac94f9c727mr1997243qvb.51.1662760462998; Fri, 09 Sep 2022 14:54:22 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id f8-20020a05620a408800b006bc192d277csm1643062qko.10.2022.09.09.14.54.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:22 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 22/36] btrfs: make tree_search_for_insert return extent_state Date: Fri, 9 Sep 2022 17:53:35 -0400 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 use this to search for an extent state, or return the nodes we need to insert a new extent state. This means we have the following pattern node = tree_search_for_insert(); if (!node) { /* alloc and insert. */ goto again; } state = rb_entry(node, struct extent_state, rb_node); we don't use the node for anything else. Making tree_search_for_insert() return the extent_state means we can drop the rb_node and clean this up by eliminating the rb_entry. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 43 +++++++++++++++------------------------ 1 file changed, 16 insertions(+), 27 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 5cfe66941ade..a1cfd690db18 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -220,15 +220,15 @@ static inline struct extent_state *next_state(struct extent_state *state) * If no such entry exists, return pointer to entry that ends before @offset * and fill parameters @node_ret and @parent_ret, ie. does not return NULL. */ -static inline struct rb_node *tree_search_for_insert(struct extent_io_tree *tree, - u64 offset, - struct rb_node ***node_ret, - struct rb_node **parent_ret) +static inline struct extent_state *tree_search_for_insert(struct extent_io_tree *tree, + u64 offset, + struct rb_node ***node_ret, + struct rb_node **parent_ret) { struct rb_root *root = &tree->state; struct rb_node **node = &root->rb_node; struct rb_node *prev = NULL; - struct extent_state *entry; + struct extent_state *entry = NULL; while (*node) { prev = *node; @@ -239,7 +239,7 @@ static inline struct rb_node *tree_search_for_insert(struct extent_io_tree *tree else if (offset > entry->end) node = &(*node)->rb_right; else - return *node; + return entry; } if (node_ret) @@ -248,12 +248,10 @@ static inline struct rb_node *tree_search_for_insert(struct extent_io_tree *tree *parent_ret = prev; /* Search neighbors until we find the first one past the end */ - while (prev && offset > entry->end) { - prev = rb_next(prev); - entry = rb_entry(prev, struct extent_state, rb_node); - } + while (entry && offset > entry->end) + entry = next_state(entry); - return prev; + return entry; } /** @@ -317,8 +315,7 @@ static inline struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, */ static inline struct extent_state *tree_search(struct extent_io_tree *tree, u64 offset) { - struct rb_node *n = tree_search_for_insert(tree, offset, NULL, NULL); - return (n) ? rb_entry(n, struct extent_state, rb_node) : NULL; + return tree_search_for_insert(tree, offset, NULL, NULL); } static void extent_io_tree_panic(struct extent_io_tree *tree, int err) @@ -972,7 +969,6 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, { struct extent_state *state; struct extent_state *prealloc = NULL; - struct rb_node *node; struct rb_node **p; struct rb_node *parent; int err = 0; @@ -1002,17 +998,15 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, if (cached_state && *cached_state) { state = *cached_state; if (state->start <= start && state->end > start && - extent_state_in_tree(state)) { - node = &state->rb_node; + extent_state_in_tree(state)) goto hit_next; - } } /* * this search will find all the extents that end after * our range starts. */ - node = tree_search_for_insert(tree, start, &p, &parent); - if (!node) { + state = tree_search_for_insert(tree, start, &p, &parent); + if (!state) { prealloc = alloc_extent_state_atomic(prealloc); BUG_ON(!prealloc); prealloc->start = start; @@ -1022,7 +1016,6 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, prealloc = NULL; goto out; } - state = rb_entry(node, struct extent_state, rb_node); hit_next: last_start = state->start; last_end = state->end; @@ -1208,7 +1201,6 @@ int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, { struct extent_state *state; struct extent_state *prealloc = NULL; - struct rb_node *node; struct rb_node **p; struct rb_node *parent; int err = 0; @@ -1238,18 +1230,16 @@ int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, if (cached_state && *cached_state) { state = *cached_state; if (state->start <= start && state->end > start && - extent_state_in_tree(state)) { - node = &state->rb_node; + extent_state_in_tree(state)) goto hit_next; - } } /* * this search will find all the extents that end after * our range starts. */ - node = tree_search_for_insert(tree, start, &p, &parent); - if (!node) { + state = tree_search_for_insert(tree, start, &p, &parent); + if (!state) { prealloc = alloc_extent_state_atomic(prealloc); if (!prealloc) { err = -ENOMEM; @@ -1262,7 +1252,6 @@ int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, prealloc = NULL; goto out; } - state = rb_entry(node, struct extent_state, rb_node); hit_next: last_start = state->start; last_end = state->end; From patchwork Fri Sep 9 21:53:36 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972211 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 3EB4AECAAD3 for ; Fri, 9 Sep 2022 21:54:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231911AbiIIVyg (ORCPT ); Fri, 9 Sep 2022 17:54:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58842 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231752AbiIIVy3 (ORCPT ); Fri, 9 Sep 2022 17:54:29 -0400 Received: from mail-qt1-x830.google.com (mail-qt1-x830.google.com [IPv6:2607:f8b0:4864:20::830]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B198BF56 for ; Fri, 9 Sep 2022 14:54:25 -0700 (PDT) Received: by mail-qt1-x830.google.com with SMTP id h22so2359442qtu.2 for ; Fri, 09 Sep 2022 14:54:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=EzXzUC4fBt366+YXHHUv28uiXyNRdIg1O9Ebkxa9GoY=; b=TIW5n1/Gf60natV+xQq19bj/9HW72CFZ5p4je1T+khf+uQGG7BAHP4CEOUE96DknNq qYlauZF09qTOrfNPnK87YshlE4I0vJKdsbKV7nJujCBvSVZ7BqIZNaLUW0AQlGhGAViz f6SFeS4Tfctt2DGC9Fz90iLsXiRc9UADbZypwacMw5/wmfmxO5QToh0CmwtohRQJU90E 0nZs4kkPszOqdWDAXgV99AgB0C1CfDgjGXWOcFYB+IepvEYKMy70xn2B7K2vwVFDvni3 +3nkVjuVytDIZIfWY4ttUEhAQm0xzcaWgoz+K0Dhx7spIQ8f8KKDXNpG/pQoRimvlB5k 4RSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=EzXzUC4fBt366+YXHHUv28uiXyNRdIg1O9Ebkxa9GoY=; b=kJBZ0y6+XrEMjxXX9zTQYjVJb9jHzUO4VR1v+hXsnITaYrbiQx8jrfzGykP/VtxaMK 7/DrdhIK6ixuUmJsu/v2Zf7pizRoiz21XoSr7tnPoRShKzJoTM0wmocthIFw02SEgsP1 B4pyXPbooCC2R5BErKeiVB2KCxlFnv0XyEnTu0zZ/3XQ/pAtc/GMjq3VnJ98hGe+QNsZ 1RDEqwEPIjtNH5kkiotI0jd9KgHc26BlbVVluqr6UnsqbroZaB/1rrsgxVGsmkkx9ljD D8d2EUoJpJsFVHU5DCfF+epBHEdFMbKEBF+3SfRttW5qsPDn6k2etrymB8gmT546N2Kw M52Q== X-Gm-Message-State: ACgBeo16glbOUEXNQpr66Rb80zqI7rnpaZsE4U3/A7/G+JYY7UbLN5cc GpFXFF7bRIjgdRQe/5z6sRKehhKEAx9w8A== X-Google-Smtp-Source: AA6agR4D4VfUikuvoupVa38wKpgXFYaDPMZXTLMzmuVz+Uvx2fPkaO687YABdWXEyOOmpWNGyPKh1Q== X-Received: by 2002:ac8:7dc4:0:b0:343:622d:5fda with SMTP id c4-20020ac87dc4000000b00343622d5fdamr13941343qte.197.1662760464496; Fri, 09 Sep 2022 14:54:24 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id y29-20020a37f61d000000b006cbd60c14c9sm1254012qkj.35.2022.09.09.14.54.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:24 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 23/36] btrfs: make tree_search_prev_next return extent_state's Date: Fri, 9 Sep 2022 17:53:36 -0400 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 Instead of doing the rb_entry again once we return from this function, simply return the actual states themselves, and then clean up the only user of this helper to handle states instead of nodes. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 80 +++++++++++++++++++-------------------- 1 file changed, 38 insertions(+), 42 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index a1cfd690db18..9b3380c353e7 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -203,6 +203,15 @@ static inline struct extent_state *next_state(struct extent_state *state) return NULL; } +static inline struct extent_state *prev_state(struct extent_state *state) +{ + struct rb_node *next = rb_prev(&state->rb_node); + if (next) + return rb_entry(next, struct extent_state, rb_node); + else + return NULL; +} + /** * Search @tree for an entry that contains @offset. Such entry would have * entry->start <= offset && entry->end >= offset. @@ -266,46 +275,39 @@ static inline struct extent_state *tree_search_for_insert(struct extent_io_tree * such entry exists, then return NULL and fill @prev_ret and @next_ret. * Otherwise return the found entry and other pointers are left untouched. */ -static inline struct rb_node *tree_search_prev_next(struct extent_io_tree *tree, - u64 offset, - struct rb_node **prev_ret, - struct rb_node **next_ret) +static struct extent_state *tree_search_prev_next(struct extent_io_tree *tree, + u64 offset, + struct extent_state **prev_ret, + struct extent_state **next_ret) { struct rb_root *root = &tree->state; struct rb_node **node = &root->rb_node; - struct rb_node *prev = NULL; - struct rb_node *orig_prev = NULL; - struct extent_state *entry; + struct extent_state *orig_prev; + struct extent_state *entry = NULL; ASSERT(prev_ret); ASSERT(next_ret); while (*node) { - prev = *node; - entry = rb_entry(prev, struct extent_state, rb_node); + entry = rb_entry(*node, struct extent_state, rb_node); if (offset < entry->start) node = &(*node)->rb_left; else if (offset > entry->end) node = &(*node)->rb_right; else - return *node; + return entry; } - orig_prev = prev; - while (prev && offset > entry->end) { - prev = rb_next(prev); - entry = rb_entry(prev, struct extent_state, rb_node); - } - *next_ret = prev; - prev = orig_prev; + orig_prev = entry; + while (entry && offset > entry->end) + entry = next_state(entry); + *next_ret = entry; + entry = orig_prev; - entry = rb_entry(prev, struct extent_state, rb_node); - while (prev && offset < entry->start) { - prev = rb_prev(prev); - entry = rb_entry(prev, struct extent_state, rb_node); - } - *prev_ret = prev; + while (entry && offset < entry->start) + entry = prev_state(entry); + *prev_ret = entry; return NULL; } @@ -1409,14 +1411,14 @@ void find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 *start_ret, u64 *end_ret, u32 bits) { struct extent_state *state; - struct rb_node *node, *prev = NULL, *next; + struct extent_state *prev = NULL, *next; spin_lock(&tree->lock); /* Find first extent with bits cleared */ while (1) { - node = tree_search_prev_next(tree, start, &prev, &next); - if (!node && !next && !prev) { + state = tree_search_prev_next(tree, start, &prev, &next); + if (!state && !next && !prev) { /* * Tree is completely empty, send full range and let * caller deal with it @@ -1424,24 +1426,22 @@ void find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start, *start_ret = 0; *end_ret = -1; goto out; - } else if (!node && !next) { + } else if (!state && !next) { /* * We are past the last allocated chunk, set start at * the end of the last extent. */ - state = rb_entry(prev, struct extent_state, rb_node); - *start_ret = state->end + 1; + *start_ret = prev->end + 1; *end_ret = -1; goto out; - } else if (!node) { - node = next; + } else if (!state) { + state = next; } + /* - * At this point 'node' either contains 'start' or start is - * before 'node' + * At this point 'state' either contains 'start' or start is + * before 'state' */ - state = rb_entry(node, struct extent_state, rb_node); - if (in_range(start, state->start, state->end - state->start + 1)) { if (state->state & bits) { /* @@ -1475,13 +1475,10 @@ void find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start, * 0 | * start */ - if (prev) { - state = rb_entry(prev, struct extent_state, - rb_node); - *start_ret = state->end + 1; - } else { + if (prev) + *start_ret = prev->end + 1; + else *start_ret = 0; - } break; } } @@ -1490,7 +1487,6 @@ void find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start, * Find the longest stretch from start until an entry which has the * bits set */ - state = rb_entry(node, struct extent_state, rb_node); while (state) { if (state->end >= start && !(state->state & bits)) { *end_ret = state->end; From patchwork Fri Sep 9 21:53:37 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972210 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 DBE07ECAAD3 for ; Fri, 9 Sep 2022 21:54:36 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231881AbiIIVye (ORCPT ); Fri, 9 Sep 2022 17:54:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58844 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231874AbiIIVy3 (ORCPT ); Fri, 9 Sep 2022 17:54:29 -0400 Received: from mail-qt1-x832.google.com (mail-qt1-x832.google.com [IPv6:2607:f8b0:4864:20::832]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B1AB310B6 for ; Fri, 9 Sep 2022 14:54:26 -0700 (PDT) Received: by mail-qt1-x832.google.com with SMTP id r20so1645724qtn.12 for ; Fri, 09 Sep 2022 14:54:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=E70UErGZdqyya/L8rohJV8oRz61o/sXy0aqwgAvzpFw=; b=YdUhTTlPa+8b5CtsJB2Mlf0PubsdYF6FpYIcApyUjZWptjsMAw/k+G6Fy+36UOk9T+ Jr4T3eRGW9x4lzlOZF2+mY1ASVlxQ6K7z9lmGTK4w16CNkKTCYBZ76LNHHGh3QYbUXaF cI0LbaccwaVjbgvaCgkHb/FoteIbmTzIfv8kJiYajMBOKKnDxFLTspF+MYcJHB+9yf5p 0o2A4hl7iP4yd4y9uEGXXG3xyu+WmFh7XfpCuF+LyMaK4xJOi9D+WLnEbX/ILuiiRhuN p0VEFWnyDsqM8rz0hQZbcnHFQa63l29GxkVwYLvJpJ+9TfGfMJU7SE/KTQgIFQ0U3jjG /uQQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=E70UErGZdqyya/L8rohJV8oRz61o/sXy0aqwgAvzpFw=; b=4oDmlY+MTgGpNYDnyvtBSfVPVufXpMlJt8YDZbMjm25PkK0Mtayq1+N6/GMT1bMdD5 wypLXluBlXTsoDNVK1WHUQj2p0X8okb0i9UNrjxCnA8t0phVGULqlBNllIDNLsv51RVe 7GP9QR15Y6EI+u5n9I/savOVoFm/jwPC29iakOL9LysO8kz9AUrHzfaNqG0zoPwqczjv eo4Dtae5JbRj/+uJ0AdtHoCHjRox1fqASgVeMEwKN8K7d/j9t89S6Y2DPsrIRg2w5D83 u+NyQlNGE9WVf0pH/FyDnFuEdhbl7pzC99FdTafT5spuxQtn8THXl1QwyXyHr3k6a1cr hiRw== X-Gm-Message-State: ACgBeo3Qz500PCA1u08G/0KS70dIpdTTOQXnci/1a9L/iIjL0dveOQ8i SLkqXdDdZie8A62szg9CEaiDYHwIBA5Qiw== X-Google-Smtp-Source: AA6agR47gzBV9pTIFQSd/hvrqVwN6A4IHaWJIZwT0Qgtoa2s4pCw7qXUOuVCxRxDXrnfd8T37PqNZQ== X-Received: by 2002:ac8:5987:0:b0:35a:703a:9bb9 with SMTP id e7-20020ac85987000000b0035a703a9bb9mr7423432qte.213.1662760465909; Fri, 09 Sep 2022 14:54:25 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id d23-20020ac85357000000b00343057845f7sm1135256qto.20.2022.09.09.14.54.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:25 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 24/36] btrfs: use next_state/prev_state in merge_state Date: Fri, 9 Sep 2022 17:53:37 -0400 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 use rb_next/rb_prev and then get the entry for the adjacent items in an extent io tree. We have helpers for this, so convert merge_state to use next_state/prev_state and simplify the code. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 49 ++++++++++++++++----------------------- 1 file changed, 20 insertions(+), 29 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 9b3380c353e7..6c734b6871f8 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -338,40 +338,31 @@ static void extent_io_tree_panic(struct extent_io_tree *tree, int err) static void merge_state(struct extent_io_tree *tree, struct extent_state *state) { struct extent_state *other; - struct rb_node *other_node; if (state->state & (EXTENT_LOCKED | EXTENT_BOUNDARY)) return; - other_node = rb_prev(&state->rb_node); - if (other_node) { - other = rb_entry(other_node, struct extent_state, rb_node); - if (other->end == state->start - 1 && - other->state == state->state) { - if (tree->private_data && - is_data_inode(tree->private_data)) - btrfs_merge_delalloc_extent(tree->private_data, - state, other); - state->start = other->start; - rb_erase(&other->rb_node, &tree->state); - RB_CLEAR_NODE(&other->rb_node); - free_extent_state(other); - } + other = prev_state(state); + if (other && other->end == state->start - 1 && + other->state == state->state) { + if (tree->private_data && is_data_inode(tree->private_data)) + btrfs_merge_delalloc_extent(tree->private_data, + state, other); + state->start = other->start; + rb_erase(&other->rb_node, &tree->state); + RB_CLEAR_NODE(&other->rb_node); + free_extent_state(other); } - other_node = rb_next(&state->rb_node); - if (other_node) { - other = rb_entry(other_node, struct extent_state, rb_node); - if (other->start == state->end + 1 && - other->state == state->state) { - if (tree->private_data && - is_data_inode(tree->private_data)) - btrfs_merge_delalloc_extent(tree->private_data, - state, other); - state->end = other->end; - rb_erase(&other->rb_node, &tree->state); - RB_CLEAR_NODE(&other->rb_node); - free_extent_state(other); - } + other = next_state(state); + if (other && other->start == state->end + 1 && + other->state == state->state) { + if (tree->private_data && is_data_inode(tree->private_data)) + btrfs_merge_delalloc_extent(tree->private_data, state, + other); + state->end = other->end; + rb_erase(&other->rb_node, &tree->state); + RB_CLEAR_NODE(&other->rb_node); + free_extent_state(other); } } From patchwork Fri Sep 9 21:53:38 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972212 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 15342ECAAA1 for ; Fri, 9 Sep 2022 21:54:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231907AbiIIVyj (ORCPT ); Fri, 9 Sep 2022 17:54:39 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58844 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231882AbiIIVya (ORCPT ); Fri, 9 Sep 2022 17:54:30 -0400 Received: from mail-qt1-x82c.google.com (mail-qt1-x82c.google.com [IPv6:2607:f8b0:4864:20::82c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A97B45F6D for ; Fri, 9 Sep 2022 14:54:28 -0700 (PDT) Received: by mail-qt1-x82c.google.com with SMTP id l5so2350503qtv.4 for ; Fri, 09 Sep 2022 14:54:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=20Yhsr54XoS92CwX/KkffhTXptoTrMLHY/7ZUT2KoZo=; b=4hiZMK3KbNO2BLeo8BI3cRIiI9ISzLHrgg+Ez+mu77N36UahPwS3JkfvWEHZTpiA9H UwBiqD0JoePw6hj80XF2e2PHpHFa7tasWwD34yznPF9szt3r+wd2dQn/Hz8k5dCaja7P s/DjJ8QmVfdrxzFwDNMOWh0PPy1THgn9tP+cRZvgzuSGz7dJvG0QdYky/Oq06kYxO8Xx 66I+i2l+i23c9qcGNCcFJMoHnI5AG2s9EBMgC7cNxE9LOxNg8/HZrM3hC6fTRTHEElSy B2e1NunriSisFW0Jvxk4coGYPBiY+E4tMxhedn+++62KWvme1RiavHwkOHjJ3FIpf3l5 jRJg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=20Yhsr54XoS92CwX/KkffhTXptoTrMLHY/7ZUT2KoZo=; b=QPqh84sTCeuSfIZuFcG6uvSmFwSxP4wjMFvRObozPN4QwL97iD+J44BM5D19oiSOkK WjVWxyZ29RrSBdOaftkbh99kQXO/+sPe2EJc2M0wM2outbX+FXPQ+SaEnKeUESmEhp2Q 6aNOFVvmX1AAKiz1Ol4bvkPuOHgqP0XdL/bZ+Jezl4XjIMKt2eNaseqfs6pqU4vKpf/m G4lsVrKTltUon0X42hZPC3zUEINduazq6I95DcqSqejivq/oVVH+9/RV4IzbtEDrtqhV 66PZFuDmHr9zd0t85AZjG9UNJdEfTFD9/6RQ8eGmq6sCWIN8Qdj0oFfvtQmIjO5Ney4b KYEg== X-Gm-Message-State: ACgBeo0zmJZWXto4mpwRpQgMDF3ENkycqwRcRq4BcW1yI2+jPGYU17/c zrGmbRpNIMV/GQz3fMuVsgVqG4Nj1FPFtQ== X-Google-Smtp-Source: AA6agR6b8WMfBrO8oGMOVBRq9Tlb7+/gEYiDCxEndf68Y4qlySrNJ9ZwY2KPieQ213v32W+zF7Zgow== X-Received: by 2002:a05:622a:1654:b0:35b:a47b:4935 with SMTP id y20-20020a05622a165400b0035ba47b4935mr2801571qtj.288.1662760467312; Fri, 09 Sep 2022 14:54:27 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id h17-20020ac85151000000b0033b30e8e7a5sm1140422qtn.58.2022.09.09.14.54.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:26 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 25/36] btrfs: move irrelevant prototypes to their appropriate header Date: Fri, 9 Sep 2022 17:53:38 -0400 Message-Id: <2d1d4e0926ec5547df8b8d8387c4d49521f2a6a6.1662760286.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 These prototypes have nothing to do with the extent_io_tree helpers, move them to their appropriate header. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.h | 8 -------- fs/btrfs/extent_io.h | 6 ++++++ 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 3b17cc33bcec..85acdd13d2c4 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -248,16 +248,8 @@ void find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 *start_ret, u64 *end_ret, u32 bits); int find_contiguous_extent_bit(struct extent_io_tree *tree, u64 start, u64 *start_ret, u64 *end_ret, u32 bits); -int extent_invalidate_folio(struct extent_io_tree *tree, - struct folio *folio, size_t offset); bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, u64 *end, u64 max_bytes, struct extent_state **cached_state); void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits); - -/* This should be reworked in the future and put elsewhere. */ -void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start, - u64 end); -int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, - struct page *page, unsigned int pg_offset); #endif /* BTRFS_EXTENT_IO_TREE_H */ diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h index 52e4dfea2164..ba331bced460 100644 --- a/fs/btrfs/extent_io.h +++ b/fs/btrfs/extent_io.h @@ -242,6 +242,8 @@ void extent_range_redirty_for_io(struct inode *inode, u64 start, u64 end); void extent_clear_unlock_delalloc(struct btrfs_inode *inode, u64 start, u64 end, struct page *locked_page, u32 bits_to_clear, unsigned long page_ops); +int extent_invalidate_folio(struct extent_io_tree *tree, + struct folio *folio, size_t offset); int btrfs_alloc_page_array(unsigned int nr_pages, struct page **page_array); @@ -272,6 +274,10 @@ struct io_failure_record { int btrfs_repair_one_sector(struct inode *inode, struct btrfs_bio *failed_bbio, u32 bio_offset, struct page *page, unsigned int pgoff, submit_bio_hook_t *submit_bio_hook); +void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start, + u64 end); +int btrfs_clean_io_failure(struct btrfs_inode *inode, u64 start, + struct page *page, unsigned int pg_offset); #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS bool find_lock_delalloc_range(struct inode *inode, From patchwork Fri Sep 9 21:53:39 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972213 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 DA3A8ECAAD5 for ; Fri, 9 Sep 2022 21:54:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231903AbiIIVyj (ORCPT ); Fri, 9 Sep 2022 17:54:39 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58890 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231886AbiIIVya (ORCPT ); Fri, 9 Sep 2022 17:54:30 -0400 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 9F4575FD8 for ; Fri, 9 Sep 2022 14:54:29 -0700 (PDT) Received: by mail-qk1-x734.google.com with SMTP id j6so2204628qkl.10 for ; Fri, 09 Sep 2022 14:54:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=LJDy91ir/xEcsnxtDi+XN8zsugFLRV+CqF0cZnUndrk=; b=YHXsId3CpFBVoBmoa6tkwsqF4lcg8ZA2dNygW44z1IamGqCW7JuMA4CJXTmyLL01Wl vL/H0OutuhpCVROBpZ/7+nvVWXTh7YvI1mo8mW5rIgE34D5b4X8jtm/m9EngwYXX3Jfv FUwgm2tzuj8jcr4eM8XCE22XX46iLq4FMip6poNdbCREZPIVEzv6efTgwctA1ZQBjBjl cad5MS31arxlOQHQ1S0B6PE6obcaHTKAJ2kBgOisirABFtZNomo3RvAkJh/wmqHF7NEE I/oHFXlV9n/5CjIa8GM/5my7RTUXQjRzGbJEcXmrFLc7TAuVhgrgw/uqmQzXldXTUqGw OE/Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=LJDy91ir/xEcsnxtDi+XN8zsugFLRV+CqF0cZnUndrk=; b=zbF8M5SAPvBgdLZH45zRgu9BqvH78/OxZ4/cmI+KBFBnB+K8fX4F7fertOQvU5sVW9 8VSLeZQr53l919ubaGlsh4epvMnjgr8DsJS5c3Xmvx88F7lLyYW4uI9Tt9EyQo46M/ya 7B0fCqNjGhda2p0ysryjY3Gbfq8ngDkq091nTUSeXFX00yWzr0GOoeusDPj7RvCWhRUG BtLtB7wDdJSL44LBClefiplW9tBqVJwltF7cSufFaWB+IxpYRwBwkron+kPuMySerQmB XnnH4Np9EEYetDgVPWS2UIanA1IaAn1JxgIhxlEowDsCHjGs4LQ1v7yIEJKHwTNAWnxG Uxzw== X-Gm-Message-State: ACgBeo2zLVTd2YkQui1uAhN5m2LkuZMTsHeBKCINqEAQoDdUd2OvMPBM RhN31ff5L6Q8KSsRD7KGbMzq8qNLKtDW0Q== X-Google-Smtp-Source: AA6agR6ofMIKaq0Hj4dwfFxqN5mp7a/xlMXkWyT1shkcUKd++zotqIx7eIa4tMZD77D1GGlUDKGuMQ== X-Received: by 2002:a05:620a:4005:b0:6be:971c:378f with SMTP id h5-20020a05620a400500b006be971c378fmr11315250qko.530.1662760468804; Fri, 09 Sep 2022 14:54:28 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id g21-20020ac84695000000b0035ba5db657esm660430qto.76.2022.09.09.14.54.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:28 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 26/36] btrfs: drop exclusive_bits from set_extent_bit Date: Fri, 9 Sep 2022 17:53:39 -0400 Message-Id: <2126d9685e12436d4736969cb84bedaa077b0f12.1662760286.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 only ever set if we have EXTENT_LOCKED set, so simply push this into the function itself and remove the function argument. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 15 ++++++++------- fs/btrfs/extent-io-tree.h | 20 ++++++++++---------- fs/btrfs/inode.c | 4 ++-- 3 files changed, 20 insertions(+), 19 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 6c734b6871f8..f67d9ee6f03e 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -955,8 +955,8 @@ bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, * * [start, end] is inclusive This takes the tree lock. */ -int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, - u32 exclusive_bits, u64 *failed_start, +int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, + u32 bits, u64 *failed_start, struct extent_state **cached_state, gfp_t mask, struct extent_changeset *changeset) { @@ -967,6 +967,7 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, int err = 0; u64 last_start; u64 last_end; + u32 exclusive_bits = bits & EXTENT_LOCKED; btrfs_debug_check_extent_io_range(tree, start, end); trace_btrfs_set_extent_bit(tree, start, end - start + 1, bits); @@ -1608,7 +1609,7 @@ int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, */ ASSERT(!(bits & EXTENT_LOCKED)); - return set_extent_bit(tree, start, end, bits, 0, NULL, NULL, GFP_NOFS, + return set_extent_bit(tree, start, end, bits, NULL, NULL, GFP_NOFS, changeset); } @@ -1630,8 +1631,8 @@ int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) int err; u64 failed_start; - err = set_extent_bit(tree, start, end, EXTENT_LOCKED, EXTENT_LOCKED, - &failed_start, NULL, GFP_NOFS, NULL); + err = set_extent_bit(tree, start, end, EXTENT_LOCKED, &failed_start, + NULL, GFP_NOFS, NULL); if (err == -EEXIST) { if (failed_start > start) clear_extent_bit(tree, start, failed_start - 1, @@ -1653,8 +1654,8 @@ int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, while (1) { err = set_extent_bit(tree, start, end, EXTENT_LOCKED, - EXTENT_LOCKED, &failed_start, - cached_state, GFP_NOFS, NULL); + &failed_start, cached_state, GFP_NOFS, + NULL); if (err == -EEXIST) { wait_extent_bit(tree, failed_start, end, EXTENT_LOCKED); start = failed_start; diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 85acdd13d2c4..fb6caef20373 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -166,21 +166,21 @@ static inline int clear_extent_bits(struct extent_io_tree *tree, u64 start, int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset); int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, unsigned exclusive_bits, u64 *failed_start, + u32 bits, u64 *failed_start, struct extent_state **cached_state, gfp_t mask, struct extent_changeset *changeset); static inline int set_extent_bits_nowait(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { - return set_extent_bit(tree, start, end, bits, 0, NULL, NULL, - GFP_NOWAIT, NULL); + return set_extent_bit(tree, start, end, bits, NULL, NULL, GFP_NOWAIT, + NULL); } static inline int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { - return set_extent_bit(tree, start, end, bits, 0, NULL, NULL, GFP_NOFS, + return set_extent_bit(tree, start, end, bits, NULL, NULL, GFP_NOFS, NULL); } @@ -194,8 +194,8 @@ static inline int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, static inline int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask) { - return set_extent_bit(tree, start, end, EXTENT_DIRTY, 0, NULL, NULL, - mask, NULL); + return set_extent_bit(tree, start, end, EXTENT_DIRTY, NULL, NULL, mask, + NULL); } static inline int clear_extent_dirty(struct extent_io_tree *tree, u64 start, @@ -216,7 +216,7 @@ static inline int set_extent_delalloc(struct extent_io_tree *tree, u64 start, { return set_extent_bit(tree, start, end, EXTENT_DELALLOC | extra_bits, - 0, NULL, cached_state, GFP_NOFS, NULL); + NULL, cached_state, GFP_NOFS, NULL); } static inline int set_extent_defrag(struct extent_io_tree *tree, u64 start, @@ -224,20 +224,20 @@ static inline int set_extent_defrag(struct extent_io_tree *tree, u64 start, { return set_extent_bit(tree, start, end, EXTENT_DELALLOC | EXTENT_DEFRAG, - 0, NULL, cached_state, GFP_NOFS, NULL); + NULL, cached_state, GFP_NOFS, NULL); } static inline int set_extent_new(struct extent_io_tree *tree, u64 start, u64 end) { - return set_extent_bit(tree, start, end, EXTENT_NEW, 0, NULL, NULL, + return set_extent_bit(tree, start, end, EXTENT_NEW, NULL, NULL, GFP_NOFS, NULL); } static inline int set_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state **cached_state, gfp_t mask) { - return set_extent_bit(tree, start, end, EXTENT_UPTODATE, 0, NULL, + return set_extent_bit(tree, start, end, EXTENT_UPTODATE, NULL, cached_state, mask, NULL); } diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 8def3a67adb7..538b6a3a88ad 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -2815,7 +2815,7 @@ static int btrfs_find_new_delalloc_bytes(struct btrfs_inode *inode, ret = set_extent_bit(&inode->io_tree, search_start, search_start + em_len - 1, - EXTENT_DELALLOC_NEW, 0, NULL, cached_state, + EXTENT_DELALLOC_NEW, NULL, cached_state, GFP_NOFS, NULL); next: search_start = extent_map_end(em); @@ -4963,7 +4963,7 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len, if (only_release_metadata) set_extent_bit(&inode->io_tree, block_start, block_end, - EXTENT_NORESERVE, 0, NULL, NULL, GFP_NOFS, NULL); + EXTENT_NORESERVE, NULL, NULL, GFP_NOFS, NULL); out_unlock: if (ret) { From patchwork Fri Sep 9 21:53:40 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972214 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 3FAE0C6FA89 for ; Fri, 9 Sep 2022 21:54:42 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231927AbiIIVyk (ORCPT ); Fri, 9 Sep 2022 17:54:40 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59136 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231908AbiIIVyf (ORCPT ); Fri, 9 Sep 2022 17:54:35 -0400 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 EAA9C6454 for ; Fri, 9 Sep 2022 14:54:31 -0700 (PDT) Received: by mail-qv1-xf29.google.com with SMTP id s13so2272883qvq.10 for ; Fri, 09 Sep 2022 14:54:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=ww5BR4RsRGLH3fMTOPXXTkslZr50cs9YVbc06M/oW6Y=; b=hPqllIlkAdM/06F2+mkePEBXhv2yEWTTW0lEK3k8Eccy5jpBRMYv9axBxR5GipALZe sFswgL/4VuNrEGJ7LDFWdeaYeQ/ojHVrMFjyIB1FB0CDxn+NZFOUEInyrw+pmpJMdvaM tmdzpEvkVKs9Q6+OGXS2WL0pSPzrh5LZzZxpldTd/N6+vuOxYEhz3+rwrtOwueIiVU6/ QOk6YkSkOeBozwPvp94AQ1v8/pN6vTnGncduqDiGUU7G09eHp1GSRNgurDR7HMRw1m2M 1reVr10xzHq+W/qqAsc7o5cqS3o0H04hUg6OQ4Wbo8xOz8q6czAxDd0zN5C8yKK4nlAH XUvg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=ww5BR4RsRGLH3fMTOPXXTkslZr50cs9YVbc06M/oW6Y=; b=GTaQa0uGC5AD1OB1yOb55LXmpV1st2/+mycUUwcJnf8zCFtTUqeVs0l6XjQVjMK06x 5Og7oQp/fNmPaT8WZxhwCgYA5gz4OKnoREyPH4Va8CLr0ctcti5H+/F8RlKprHJEzWNE XxfuOk7UFfiUYljMMkg9zBjFyEdwLuHUrufL0jewbvhMCj0ngE3ANP5BpI+nlt8lNMf3 3lyktOHapabqyamMvaB25jn8m1bgQKiHwn7LNTd+v3oAGjLSS6sTLuH5xJ/0+c1WzKEx iMxSkjxiV36M8smuByElxXX1CuwvNAsCOIxuuXNL0jvAXph6sbHsrBie9EN+tFvOjXTc UPbw== X-Gm-Message-State: ACgBeo1auOjUSjr1X9jeAIGLbzqH6uPmFkZm+ToVbcU8xbkJFGNNJo2G RML2adTulFIIHjBI/aq2dSTubUsiLFXxTw== X-Google-Smtp-Source: AA6agR5hs1ntxL6DBdsMkYCUyCwlWXxYndBueQf0EE35bTxW5Fcv9yzvb2afWF41rnOaQoK2VvLbxw== X-Received: by 2002:a05:6214:e62:b0:499:18d0:63d2 with SMTP id jz2-20020a0562140e6200b0049918d063d2mr13677581qvb.114.1662760470448; Fri, 09 Sep 2022 14:54:30 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id t7-20020a05620a450700b006cbca9886easm1610573qkp.36.2022.09.09.14.54.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:29 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 27/36] btrfs: remove the wake argument from clear_extent_bits Date: Fri, 9 Sep 2022 17:53:40 -0400 Message-Id: <5ea180371a3290cebf61df3c722e6fd97c37e465.1662760286.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 only used in the case that we are clearing EXTENT_LOCKED, so infer this value from the bits passed in instead of taking it as an argument. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 7 ++++--- fs/btrfs/extent-io-tree.h | 34 ++++++++++++++-------------------- fs/btrfs/extent_io.c | 4 ++-- fs/btrfs/extent_map.c | 2 +- fs/btrfs/file-item.c | 2 +- fs/btrfs/file.c | 2 +- fs/btrfs/free-space-cache.c | 6 +++--- fs/btrfs/inode.c | 17 ++++++++--------- fs/btrfs/ioctl.c | 2 +- fs/btrfs/reflink.c | 2 +- fs/btrfs/tests/inode-tests.c | 8 ++++---- fs/btrfs/transaction.c | 2 +- 12 files changed, 41 insertions(+), 47 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index f67d9ee6f03e..a870e74f9c6c 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -557,7 +557,7 @@ static struct extent_state *clear_state_bit(struct extent_io_tree *tree, * This takes the tree lock, and returns 0 on success and < 0 on error. */ int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, int wake, int delete, + u32 bits, int delete, struct extent_state **cached_state, gfp_t mask, struct extent_changeset *changeset) { @@ -567,6 +567,7 @@ int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u64 last_end; int err; int clear = 0; + int wake = (bits & EXTENT_LOCKED) ? 1 : 0; btrfs_debug_check_extent_io_range(tree, start, end); trace_btrfs_clear_extent_bit(tree, start, end - start + 1, bits); @@ -1622,7 +1623,7 @@ int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, */ ASSERT(!(bits & EXTENT_LOCKED)); - return __clear_extent_bit(tree, start, end, bits, 0, 0, NULL, GFP_NOFS, + return __clear_extent_bit(tree, start, end, bits, 0, NULL, GFP_NOFS, changeset); } @@ -1636,7 +1637,7 @@ int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) if (err == -EEXIST) { if (failed_start > start) clear_extent_bit(tree, start, failed_start - 1, - EXTENT_LOCKED, 1, 0, NULL); + EXTENT_LOCKED, 0, NULL); return 0; } return 1; diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index fb6caef20373..bd3c345a7530 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -121,46 +121,40 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset); int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, int wake, int delete, - struct extent_state **cached, gfp_t mask, - struct extent_changeset *changeset); + u32 bits, int delete, struct extent_state **cached, + gfp_t mask, struct extent_changeset *changeset); static inline int clear_extent_bit(struct extent_io_tree *tree, u64 start, - u64 end, u32 bits, int wake, int delete, + u64 end, u32 bits, int delete, struct extent_state **cached) { - return __clear_extent_bit(tree, start, end, bits, wake, delete, - cached, GFP_NOFS, NULL); + return __clear_extent_bit(tree, start, end, bits, delete, cached, + GFP_NOFS, NULL); } static inline int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end) { - return clear_extent_bit(tree, start, end, EXTENT_LOCKED, 1, 0, NULL); + return clear_extent_bit(tree, start, end, EXTENT_LOCKED, 0, NULL); } static inline int unlock_extent_cached(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state **cached) { - return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, 1, 0, cached, - GFP_NOFS, NULL); + return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, 0, cached, + GFP_NOFS, NULL); } static inline int unlock_extent_cached_atomic(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state **cached) { - return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, 1, 0, cached, - GFP_ATOMIC, NULL); + return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, 0, cached, + GFP_ATOMIC, NULL); } static inline int clear_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { - int wake = 0; - - if (bits & EXTENT_LOCKED) - wake = 1; - - return clear_extent_bit(tree, start, end, bits, wake, 0, NULL); + return clear_extent_bit(tree, start, end, bits, 0, NULL); } int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, @@ -187,8 +181,8 @@ static inline int set_extent_bits(struct extent_io_tree *tree, u64 start, static inline int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state **cached_state) { - return __clear_extent_bit(tree, start, end, EXTENT_UPTODATE, 0, 0, - cached_state, GFP_NOFS, NULL); + return __clear_extent_bit(tree, start, end, EXTENT_UPTODATE, 0, + cached_state, GFP_NOFS, NULL); } static inline int set_extent_dirty(struct extent_io_tree *tree, u64 start, @@ -203,7 +197,7 @@ static inline int clear_extent_dirty(struct extent_io_tree *tree, u64 start, { return clear_extent_bit(tree, start, end, EXTENT_DIRTY | EXTENT_DELALLOC | - EXTENT_DO_ACCOUNTING, 0, 0, cached); + EXTENT_DO_ACCOUNTING, 0, cached); } int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 8644072303df..59fe8f379433 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -487,7 +487,7 @@ void extent_clear_unlock_delalloc(struct btrfs_inode *inode, u64 start, u64 end, struct page *locked_page, u32 clear_bits, unsigned long page_ops) { - clear_extent_bit(&inode->io_tree, start, end, clear_bits, 1, 0, NULL); + clear_extent_bit(&inode->io_tree, start, end, clear_bits, 0, NULL); __process_pages_contig(inode->vfs_inode.i_mapping, locked_page, start, end, page_ops, NULL); @@ -3400,7 +3400,7 @@ static int try_release_extent_state(struct extent_io_tree *tree, */ ret = __clear_extent_bit(tree, start, end, ~(EXTENT_LOCKED | EXTENT_NODATASUM | EXTENT_DELALLOC_NEW), - 0, 0, NULL, mask, NULL); + 0, NULL, mask, NULL); /* if clear_extent_bit failed for enomem reasons, * we can't allow the release to continue. diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c index 6fee14ce2e6b..fae627c28d7c 100644 --- a/fs/btrfs/extent_map.c +++ b/fs/btrfs/extent_map.c @@ -382,7 +382,7 @@ static void extent_map_device_clear_bits(struct extent_map *em, unsigned bits) __clear_extent_bit(&device->alloc_state, stripe->physical, stripe->physical + stripe_size - 1, bits, - 0, 0, NULL, GFP_NOWAIT, NULL); + 0, NULL, GFP_NOWAIT, NULL); } } diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c index 29999686d234..d44e0d3c84cd 100644 --- a/fs/btrfs/file-item.c +++ b/fs/btrfs/file-item.c @@ -118,7 +118,7 @@ int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start, if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES)) return 0; return clear_extent_bit(&inode->file_extent_tree, start, - start + len - 1, EXTENT_DIRTY, 0, 0, NULL); + start + len - 1, EXTENT_DIRTY, 0, NULL); } static inline u32 max_ordered_sum_bytes(struct btrfs_fs_info *fs_info, diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c index 636b3ec46184..8ce01f69df3b 100644 --- a/fs/btrfs/file.c +++ b/fs/btrfs/file.c @@ -473,7 +473,7 @@ int btrfs_dirty_pages(struct btrfs_inode *inode, struct page **pages, */ clear_extent_bit(&inode->io_tree, start_pos, end_of_last_block, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, - 0, 0, cached); + 0, cached); err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block, extra_bits, cached); diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c index 0c94bbb5dcd7..0bd5b02966c0 100644 --- a/fs/btrfs/free-space-cache.c +++ b/fs/btrfs/free-space-cache.c @@ -1163,7 +1163,7 @@ update_cache_item(struct btrfs_trans_handle *trans, ret = btrfs_search_slot(trans, root, &key, path, 0, 1); if (ret < 0) { clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, inode->i_size - 1, - EXTENT_DELALLOC, 0, 0, NULL); + EXTENT_DELALLOC, 0, NULL); goto fail; } leaf = path->nodes[0]; @@ -1176,7 +1176,7 @@ update_cache_item(struct btrfs_trans_handle *trans, found_key.offset != offset) { clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, inode->i_size - 1, EXTENT_DELALLOC, 0, - 0, NULL); + NULL); btrfs_release_path(path); goto fail; } @@ -1272,7 +1272,7 @@ static int flush_dirty_cache(struct inode *inode) ret = btrfs_wait_ordered_range(inode, 0, (u64)-1); if (ret) clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, inode->i_size - 1, - EXTENT_DELALLOC, 0, 0, NULL); + EXTENT_DELALLOC, 0, NULL); return ret; } diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 538b6a3a88ad..77060eb7e848 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -1747,7 +1747,7 @@ static int fallback_to_cow(struct btrfs_inode *inode, struct page *locked_page, if (count > 0) clear_extent_bit(io_tree, start, end, EXTENT_NORESERVE, - 0, 0, NULL); + 0, NULL); } return cow_file_range(inode, locked_page, start, end, page_started, @@ -3324,7 +3324,7 @@ int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent) !test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) clear_extent_bit(&inode->io_tree, start, end, EXTENT_DELALLOC_NEW | EXTENT_ADD_INODE_BYTES, - 0, 0, &cached_state); + 0, &cached_state); btrfs_inode_safe_disk_i_size_write(inode, 0); ret = btrfs_update_inode_fallback(trans, root, inode); @@ -3334,8 +3334,7 @@ int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent) } ret = 0; out: - clear_extent_bit(&inode->io_tree, start, end, clear_bits, - (clear_bits & EXTENT_LOCKED) ? 1 : 0, 0, + clear_extent_bit(&inode->io_tree, start, end, clear_bits, 0, &cached_state); if (trans) @@ -4936,7 +4935,7 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len, clear_extent_bit(&inode->io_tree, block_start, block_end, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, - 0, 0, &cached_state); + 0, &cached_state); ret = btrfs_set_extent_delalloc(inode, block_start, block_end, 0, &cached_state); @@ -5352,7 +5351,7 @@ static void evict_inode_truncate_pages(struct inode *inode) clear_extent_bit(io_tree, start, end, EXTENT_LOCKED | EXTENT_DELALLOC | - EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, 1, + EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, &cached_state); cond_resched(); @@ -8333,7 +8332,7 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, clear_extent_bit(tree, cur, range_end, EXTENT_DELALLOC | EXTENT_LOCKED | EXTENT_DO_ACCOUNTING | - EXTENT_DEFRAG, 1, 0, &cached_state); + EXTENT_DEFRAG, 0, &cached_state); spin_lock_irq(&inode->ordered_tree.lock); set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags); @@ -8379,7 +8378,7 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, if (!inode_evicting) { clear_extent_bit(tree, cur, range_end, EXTENT_LOCKED | EXTENT_DELALLOC | EXTENT_UPTODATE | - EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, + EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, delete_states, &cached_state); } cur = range_end + 1; @@ -8515,7 +8514,7 @@ vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) */ clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | - EXTENT_DEFRAG, 0, 0, &cached_state); + EXTENT_DEFRAG, 0, &cached_state); ret2 = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0, &cached_state); diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c index fe0cc816b4eb..274ad3e23190 100644 --- a/fs/btrfs/ioctl.c +++ b/fs/btrfs/ioctl.c @@ -1616,7 +1616,7 @@ static int defrag_one_locked_target(struct btrfs_inode *inode, return ret; clear_extent_bit(&inode->io_tree, start, start + len - 1, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | - EXTENT_DEFRAG, 0, 0, cached_state); + EXTENT_DEFRAG, 0, cached_state); set_extent_defrag(&inode->io_tree, start, start + len - 1, cached_state); /* Update the page status */ diff --git a/fs/btrfs/reflink.c b/fs/btrfs/reflink.c index 9acf47b11fe6..39556ce1b551 100644 --- a/fs/btrfs/reflink.c +++ b/fs/btrfs/reflink.c @@ -92,7 +92,7 @@ static int copy_inline_to_page(struct btrfs_inode *inode, clear_extent_bit(&inode->io_tree, file_offset, range_end, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, - 0, 0, NULL); + 0, NULL); ret = btrfs_set_extent_delalloc(inode, file_offset, range_end, 0, NULL); if (ret) goto out_unlock; diff --git a/fs/btrfs/tests/inode-tests.c b/fs/btrfs/tests/inode-tests.c index cac89c388131..eeba3deb7714 100644 --- a/fs/btrfs/tests/inode-tests.c +++ b/fs/btrfs/tests/inode-tests.c @@ -975,7 +975,7 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) BTRFS_MAX_EXTENT_SIZE >> 1, (BTRFS_MAX_EXTENT_SIZE >> 1) + sectorsize - 1, EXTENT_DELALLOC | EXTENT_DELALLOC_NEW | - EXTENT_UPTODATE, 0, 0, NULL); + EXTENT_UPTODATE, 0, NULL); if (ret) { test_err("clear_extent_bit returned %d", ret); goto out; @@ -1043,7 +1043,7 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) BTRFS_MAX_EXTENT_SIZE + sectorsize, BTRFS_MAX_EXTENT_SIZE + 2 * sectorsize - 1, EXTENT_DELALLOC | EXTENT_DELALLOC_NEW | - EXTENT_UPTODATE, 0, 0, NULL); + EXTENT_UPTODATE, 0, NULL); if (ret) { test_err("clear_extent_bit returned %d", ret); goto out; @@ -1076,7 +1076,7 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) /* Empty */ ret = clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, (u64)-1, EXTENT_DELALLOC | EXTENT_DELALLOC_NEW | - EXTENT_UPTODATE, 0, 0, NULL); + EXTENT_UPTODATE, 0, NULL); if (ret) { test_err("clear_extent_bit returned %d", ret); goto out; @@ -1092,7 +1092,7 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) if (ret) clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, (u64)-1, EXTENT_DELALLOC | EXTENT_DELALLOC_NEW | - EXTENT_UPTODATE, 0, 0, NULL); + EXTENT_UPTODATE, 0, NULL); iput(inode); btrfs_free_dummy_root(root); btrfs_free_dummy_fs_info(fs_info); diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c index 9d7563df81a0..83f3d4b89faa 100644 --- a/fs/btrfs/transaction.c +++ b/fs/btrfs/transaction.c @@ -1116,7 +1116,7 @@ static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info, * it's safe to do it (through extent_io_tree_release()). */ err = clear_extent_bit(dirty_pages, start, end, - EXTENT_NEED_WAIT, 0, 0, &cached_state); + EXTENT_NEED_WAIT, 0, &cached_state); if (err == -ENOMEM) err = 0; if (!err) From patchwork Fri Sep 9 21:53:41 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972215 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 9480AECAAD3 for ; Fri, 9 Sep 2022 21:54:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231929AbiIIVyl (ORCPT ); Fri, 9 Sep 2022 17:54:41 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59190 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231919AbiIIVyh (ORCPT ); Fri, 9 Sep 2022 17:54:37 -0400 Received: from mail-qk1-x732.google.com (mail-qk1-x732.google.com [IPv6:2607:f8b0:4864:20::732]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7B5287663 for ; Fri, 9 Sep 2022 14:54:32 -0700 (PDT) Received: by mail-qk1-x732.google.com with SMTP id g16so2201305qkl.11 for ; Fri, 09 Sep 2022 14:54:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=GFsjkPZ3Nz8YdlrQS5atB1yyLBEvGBPP2exlMpzSuN0=; b=CFY4hi9+lQy0B4jrcDnCIA5XmG2xt78M6A4ejNkrvB2ky1LEfxJzKF/NK0wOpUxYY3 xcxDbjYqE6lhm+dsPFQM86W6hIsIeTVUzk1FSYEWO4ZcoO4TxNCgXN7k+hCz46wXZPwR 1tjLK/kV73H1/LDfqHMouaAt3h+T79n9hK6zuKU+FDZHY51FR4GUAhYuHPk28jpK8Snh ZhpFmM50vZaQpGv7os+FUfv+Ndi242aJhkibUeVl2mwEk3pY0mDuQ0K2Nq2/ouZlzv5M xBwg+O9szwmV694CmRqz209ifP6IHZc54hpFFbN6+0bY8E/Sq05IUCgIe40sRuTvgof6 wEUQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=GFsjkPZ3Nz8YdlrQS5atB1yyLBEvGBPP2exlMpzSuN0=; b=UHi8a2RATPUQvU13qaVombuSJqVAx974m/xjgtXV/5Be9wwcGkC9tTrGC2cKEhZN99 V45pfpA2cXHDBjMqhERSCncA0Qa+JXg6a7YnAohUY9HKKCz1c6x6JwGCCLJwSfXyAXLY zaxkAY7GMhFK1f+Oq/Lj3ViW3XrA1ITqleML4mujKRh9ODk4MJEOdqhrpXOySLyIuR2H cqtC4qecchcRw2NQK3/ePLWF2SznvkFuNIxHEGPJDdS01HT662Bux7jOM1AHO2xxE28X maFChe2YLp7JzLFjynmHKgNhU6DWUPD3cCzZMYpoWizh9QVN96VABgx3q2L4DKQbw5f2 ykPQ== X-Gm-Message-State: ACgBeo3wzJL32M64gVjfwNPrKh5A7S1dYGqBceENbpgG/uYa3Itj1OeR AgVWeFTWi7Ry5FzuldRYpcGzQlNH4as/1Q== X-Google-Smtp-Source: AA6agR5BP43afmZa2HpbUPkhUp0vg5sYap4hp+A3LIdw+WwfW/yI3/Dmm70wyhErtqY8lCNHNbw2+A== X-Received: by 2002:a05:620a:410e:b0:6bc:5cdc:88ec with SMTP id j14-20020a05620a410e00b006bc5cdc88ecmr11964771qko.734.1662760471784; Fri, 09 Sep 2022 14:54:31 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id z24-20020ac84558000000b0035ba4e53500sm999949qtn.56.2022.09.09.14.54.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:31 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 28/36] btrfs: remove failed_start argument from set_extent_bit Date: Fri, 9 Sep 2022 17:53:41 -0400 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 is only used for internal locking related helpers, everybody else just passes in NULL. I've changed set_extent_bit to __set_extent_bit and made it static, removed failed_start from set_extent_bit and have it call __set_extent_bit with a NULL failed_start, and I've moved some code down below the now static __set_extent_bit. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 30 +++++++++++++++++++----------- fs/btrfs/extent-io-tree.h | 22 +++++++++------------- fs/btrfs/inode.c | 4 ++-- 3 files changed, 30 insertions(+), 26 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index a870e74f9c6c..7d6e0e748238 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -956,10 +956,10 @@ bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start, * * [start, end] is inclusive This takes the tree lock. */ -int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, u64 *failed_start, - struct extent_state **cached_state, gfp_t mask, - struct extent_changeset *changeset) +static int __set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, + u32 bits, u64 *failed_start, + struct extent_state **cached_state, + struct extent_changeset *changeset, gfp_t mask) { struct extent_state *state; struct extent_state *prealloc = NULL; @@ -1172,6 +1172,14 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, } +int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, + u32 bits, struct extent_state **cached_state, gfp_t mask, + struct extent_changeset *changeset) +{ + return __set_extent_bit(tree, start, end, bits, NULL, cached_state, + changeset, mask); +} + /** * convert_extent_bit - convert all bits in a given range from one bit to * another @@ -1610,8 +1618,8 @@ int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, */ ASSERT(!(bits & EXTENT_LOCKED)); - return set_extent_bit(tree, start, end, bits, NULL, NULL, GFP_NOFS, - changeset); + return __set_extent_bit(tree, start, end, bits, NULL, NULL, changeset, + GFP_NOFS); } int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, @@ -1632,8 +1640,8 @@ int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) int err; u64 failed_start; - err = set_extent_bit(tree, start, end, EXTENT_LOCKED, &failed_start, - NULL, GFP_NOFS, NULL); + err = __set_extent_bit(tree, start, end, EXTENT_LOCKED, &failed_start, + NULL, NULL, GFP_NOFS); if (err == -EEXIST) { if (failed_start > start) clear_extent_bit(tree, start, failed_start - 1, @@ -1654,9 +1662,9 @@ int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u64 failed_start; while (1) { - err = set_extent_bit(tree, start, end, EXTENT_LOCKED, - &failed_start, cached_state, GFP_NOFS, - NULL); + err = __set_extent_bit(tree, start, end, EXTENT_LOCKED, + &failed_start, cached_state, NULL, + GFP_NOFS); if (err == -EEXIST) { wait_extent_bit(tree, failed_start, end, EXTENT_LOCKED); start = failed_start; diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index bd3c345a7530..991bfa3a8391 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -160,22 +160,19 @@ static inline int clear_extent_bits(struct extent_io_tree *tree, u64 start, int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset); int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, u64 *failed_start, - struct extent_state **cached_state, gfp_t mask, + u32 bits, struct extent_state **cached_state, gfp_t mask, struct extent_changeset *changeset); static inline int set_extent_bits_nowait(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { - return set_extent_bit(tree, start, end, bits, NULL, NULL, GFP_NOWAIT, - NULL); + return set_extent_bit(tree, start, end, bits, NULL, GFP_NOWAIT, NULL); } static inline int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { - return set_extent_bit(tree, start, end, bits, NULL, NULL, GFP_NOFS, - NULL); + return set_extent_bit(tree, start, end, bits, NULL, GFP_NOFS, NULL); } static inline int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, @@ -188,8 +185,7 @@ static inline int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, static inline int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask) { - return set_extent_bit(tree, start, end, EXTENT_DIRTY, NULL, NULL, mask, - NULL); + return set_extent_bit(tree, start, end, EXTENT_DIRTY, NULL, mask, NULL); } static inline int clear_extent_dirty(struct extent_io_tree *tree, u64 start, @@ -210,7 +206,7 @@ static inline int set_extent_delalloc(struct extent_io_tree *tree, u64 start, { return set_extent_bit(tree, start, end, EXTENT_DELALLOC | extra_bits, - NULL, cached_state, GFP_NOFS, NULL); + cached_state, GFP_NOFS, NULL); } static inline int set_extent_defrag(struct extent_io_tree *tree, u64 start, @@ -218,20 +214,20 @@ static inline int set_extent_defrag(struct extent_io_tree *tree, u64 start, { return set_extent_bit(tree, start, end, EXTENT_DELALLOC | EXTENT_DEFRAG, - NULL, cached_state, GFP_NOFS, NULL); + cached_state, GFP_NOFS, NULL); } static inline int set_extent_new(struct extent_io_tree *tree, u64 start, u64 end) { - return set_extent_bit(tree, start, end, EXTENT_NEW, NULL, NULL, - GFP_NOFS, NULL); + return set_extent_bit(tree, start, end, EXTENT_NEW, NULL, GFP_NOFS, + NULL); } static inline int set_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state **cached_state, gfp_t mask) { - return set_extent_bit(tree, start, end, EXTENT_UPTODATE, NULL, + return set_extent_bit(tree, start, end, EXTENT_UPTODATE, cached_state, mask, NULL); } diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 77060eb7e848..ff2eae4474e5 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -2815,7 +2815,7 @@ static int btrfs_find_new_delalloc_bytes(struct btrfs_inode *inode, ret = set_extent_bit(&inode->io_tree, search_start, search_start + em_len - 1, - EXTENT_DELALLOC_NEW, NULL, cached_state, + EXTENT_DELALLOC_NEW, cached_state, GFP_NOFS, NULL); next: search_start = extent_map_end(em); @@ -4962,7 +4962,7 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len, if (only_release_metadata) set_extent_bit(&inode->io_tree, block_start, block_end, - EXTENT_NORESERVE, NULL, NULL, GFP_NOFS, NULL); + EXTENT_NORESERVE, NULL, GFP_NOFS, NULL); out_unlock: if (ret) { From patchwork Fri Sep 9 21:53:42 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972216 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 3D1F9ECAAD5 for ; Fri, 9 Sep 2022 21:54:45 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231931AbiIIVyn (ORCPT ); Fri, 9 Sep 2022 17:54:43 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59194 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231922AbiIIVyh (ORCPT ); Fri, 9 Sep 2022 17:54:37 -0400 Received: from mail-qt1-x82a.google.com (mail-qt1-x82a.google.com [IPv6:2607:f8b0:4864:20::82a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7B2DFBE08 for ; Fri, 9 Sep 2022 14:54:34 -0700 (PDT) Received: by mail-qt1-x82a.google.com with SMTP id h21so2356946qta.3 for ; Fri, 09 Sep 2022 14:54:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=DpiMVNvlYtLPNTjvXUge7d748tI5+GHZp/+OkrCZSy4=; b=faWZ6/Wfi9xRnxZIeHfY3Bs0Wus7fc+pzIuhMHgESUBXZsu1+jQkDDe4Y6y7ilFV0U 6oYB3cjXbXaDiVVsv3UC3qxvAxrT31kF8NQd7x39mHyR7jDA0tHnaNF3SYJ6vODf0owA T2bNZXhni/AWGzvvFCsAIhwZQMFRqHcdh12QFNpqy6yNnH91NVXxHi1K3vEI1L68itzi vn4pAaNbYrUpkX5JaSVTl9kJ9RERR0Oaeaf4si1DnX3updV3N7mJ6Lfg6bEz4UPPmkwU kVqtM78vD93VY/QlPY1lM6pTObZBJHyd+54GWQR4CcWwFPiL3E8u3nZbDbsk9Ds+14i7 wEdA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=DpiMVNvlYtLPNTjvXUge7d748tI5+GHZp/+OkrCZSy4=; b=pQp4SGjVEy/4NAvasFL8h6vK/9Qd0V6R9n2oignKnrO74bq+H9qCgsSJWnlsRLIzqH f5ZmMq1Hey+N2//+CqLYwLrZa4EeTS6WZor1eah5pmI9F4VsmwKOgl8PthPeSw+Bc6vI WvbSBxU+EIsvFmS+CrFq5x3GqIiQEA89DhZeKOgkqzS+vma5m98xuI1/g4JzMLiUhqVW xWePcMKmkJ9NUmB/DHW0PUr6lrVmx9G4hlCZmw1//4UrwOqpanCTGuJU9Ei2j5nYaT4q nWeYJwhDNCoRETIUuM53YH+3uLHy26Tk/xZhunKLDAaLY3g4XRE1H4tYDDx5JhinZyGr yPNw== X-Gm-Message-State: ACgBeo0rHGCLYu0PCuLAhX9sRZHpyHsZLLgCT3US6CZYj+uXuhesgIRO FnkTqYiFtPDfHQOiwMdoJ9eyzhyqi4Xirg== X-Google-Smtp-Source: AA6agR4gNcitF1ijmtM50AfkpH65lqbEYWwV8l4eHGIQbSNVpCTLLckmmS6ZZrnfIMBllwWHBSz7DA== X-Received: by 2002:a05:622a:5d4:b0:344:98a8:8dae with SMTP id d20-20020a05622a05d400b0034498a88daemr14590623qtb.164.1662760473284; Fri, 09 Sep 2022 14:54:33 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id bs19-20020a05620a471300b006ba9b2167a2sm93151qkb.16.2022.09.09.14.54.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:32 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 29/36] btrfs: drop extent_changeset from set_extent_bit Date: Fri, 9 Sep 2022 17:53:42 -0400 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 only places that set extent_changeset is set_record_extent_bits, everywhere else sets it to NULL. Drop this argument from set_extent_bit. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 5 ++--- fs/btrfs/extent-io-tree.h | 18 ++++++++---------- fs/btrfs/inode.c | 4 ++-- 3 files changed, 12 insertions(+), 15 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 7d6e0e748238..10c8f40c35f6 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -1173,11 +1173,10 @@ static int __set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, } int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, struct extent_state **cached_state, gfp_t mask, - struct extent_changeset *changeset) + u32 bits, struct extent_state **cached_state, gfp_t mask) { return __set_extent_bit(tree, start, end, bits, NULL, cached_state, - changeset, mask); + NULL, mask); } /** diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 991bfa3a8391..113727a1c8d1 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -160,19 +160,18 @@ static inline int clear_extent_bits(struct extent_io_tree *tree, u64 start, int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset); int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, struct extent_state **cached_state, gfp_t mask, - struct extent_changeset *changeset); + u32 bits, struct extent_state **cached_state, gfp_t mask); static inline int set_extent_bits_nowait(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { - return set_extent_bit(tree, start, end, bits, NULL, GFP_NOWAIT, NULL); + return set_extent_bit(tree, start, end, bits, NULL, GFP_NOWAIT); } static inline int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { - return set_extent_bit(tree, start, end, bits, NULL, GFP_NOFS, NULL); + return set_extent_bit(tree, start, end, bits, NULL, GFP_NOFS); } static inline int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, @@ -185,7 +184,7 @@ static inline int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, static inline int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask) { - return set_extent_bit(tree, start, end, EXTENT_DIRTY, NULL, mask, NULL); + return set_extent_bit(tree, start, end, EXTENT_DIRTY, NULL, mask); } static inline int clear_extent_dirty(struct extent_io_tree *tree, u64 start, @@ -206,7 +205,7 @@ static inline int set_extent_delalloc(struct extent_io_tree *tree, u64 start, { return set_extent_bit(tree, start, end, EXTENT_DELALLOC | extra_bits, - cached_state, GFP_NOFS, NULL); + cached_state, GFP_NOFS); } static inline int set_extent_defrag(struct extent_io_tree *tree, u64 start, @@ -214,21 +213,20 @@ static inline int set_extent_defrag(struct extent_io_tree *tree, u64 start, { return set_extent_bit(tree, start, end, EXTENT_DELALLOC | EXTENT_DEFRAG, - cached_state, GFP_NOFS, NULL); + cached_state, GFP_NOFS); } static inline int set_extent_new(struct extent_io_tree *tree, u64 start, u64 end) { - return set_extent_bit(tree, start, end, EXTENT_NEW, NULL, GFP_NOFS, - NULL); + return set_extent_bit(tree, start, end, EXTENT_NEW, NULL, GFP_NOFS); } static inline int set_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state **cached_state, gfp_t mask) { return set_extent_bit(tree, start, end, EXTENT_UPTODATE, - cached_state, mask, NULL); + cached_state, mask); } int find_first_extent_bit(struct extent_io_tree *tree, u64 start, diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index ff2eae4474e5..ee0901944cbe 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -2816,7 +2816,7 @@ static int btrfs_find_new_delalloc_bytes(struct btrfs_inode *inode, ret = set_extent_bit(&inode->io_tree, search_start, search_start + em_len - 1, EXTENT_DELALLOC_NEW, cached_state, - GFP_NOFS, NULL); + GFP_NOFS); next: search_start = extent_map_end(em); free_extent_map(em); @@ -4962,7 +4962,7 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len, if (only_release_metadata) set_extent_bit(&inode->io_tree, block_start, block_end, - EXTENT_NORESERVE, NULL, GFP_NOFS, NULL); + EXTENT_NORESERVE, NULL, GFP_NOFS); out_unlock: if (ret) { From patchwork Fri Sep 9 21:53:43 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972220 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 5728FECAAA1 for ; Fri, 9 Sep 2022 21:54:49 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231944AbiIIVyr (ORCPT ); Fri, 9 Sep 2022 17:54:47 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59422 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231886AbiIIVyk (ORCPT ); Fri, 9 Sep 2022 17:54:40 -0400 Received: from mail-qt1-x82e.google.com (mail-qt1-x82e.google.com [IPv6:2607:f8b0:4864:20::82e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B87BFDE85 for ; Fri, 9 Sep 2022 14:54:36 -0700 (PDT) Received: by mail-qt1-x82e.google.com with SMTP id cb8so2379183qtb.0 for ; Fri, 09 Sep 2022 14:54:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=5AV8lNES8q04w0Nrq1zOOd7kLmlNyK1rz7UaOeWwM2A=; b=u2tgRX9dtvUIdROhIhztFM0CVvLEuKRzsaZo80aDihPdxOLSYlZbJvYu/hUBr2bqVb 2YlYGeTXwAo7kuOhJUFfmIc8q90pcOw+SpEtybYPU4+Nsq9ychG+UAlsEqdHxh8TIJaX xL7h1ALx+YxX4+vG4SzKjjOES07esTtzirhXnlYZw617po4L8Dj7sG0fgpcm3s+ev5ZI GRM7PlxE7dxIkIMQ4ILnJwsjIptVa9WLhb/qKERIB+geklHN/Y1Po18LGc+ZCNhbkVgp LGuylLKcEH8SUIfe1AwQCc5k1oGBPPT8s8vuomSiloVqJSsXLkyZxujteSXwbhYR1mpj d03w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=5AV8lNES8q04w0Nrq1zOOd7kLmlNyK1rz7UaOeWwM2A=; b=RXzkIBz2Sq6fkDplehHr6kPZjpz2XqL9ZgFBrClSEpRYyKTeDLVFXF6i9bwBQLO0rv 7nTGgwPvZ0Nbyw0DY8KLt2Nn+QrGRLSTy4E5KQlc7Rcn1XZVDBbp6MOm0jl/73LKIG9Y owafdzSMBijk2pD3ReIPltPk6baYYC67b5tkTMFldFR3znczcPjmoVzYqFVy2Dkhs4/R h8p6plYFRK20pPwuzVxgcxqI3xJz7QbI2rAQAxx7UqO+OED98PFn+MKuIIRj4ZZ0zJmM 0xbjnxYudPwZ/ue8wzA9pCyDh/MxJ/8mn2fne5rY1P1t3iAXESBeJe5pYKAjRyuTKDYo 7HVQ== X-Gm-Message-State: ACgBeo0aiI8Glie9mXqADIzlB3eIFF/rO7j0EUnEGZ/o7gDSmbpB5wp3 Oib+J8YzCjd0Afz0cX9kQi5+2py2hak6og== X-Google-Smtp-Source: AA6agR74wIyWt+IffYlkfA8nZNmphgCtRzk/nz3h9oyA9wP1crjFg8myemg1AHbmZxjgg+soB1MrEg== X-Received: by 2002:a05:622a:1803:b0:343:6cff:1186 with SMTP id t3-20020a05622a180300b003436cff1186mr14834003qtc.74.1662760475137; Fri, 09 Sep 2022 14:54:35 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id d16-20020ac800d0000000b0035a691cec8esm1271489qtg.29.2022.09.09.14.54.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:34 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 30/36] btrfs: unify the lock/unlock extent variants Date: Fri, 9 Sep 2022 17:53:43 -0400 Message-Id: <7b0f9f343937c82ab287282ec841d34bc457209a.1662760286.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 have two variants of lock/unlock extent, one set that takes a cached state, another that does not. This is slightly annoying, and generally speaking there are only a few places where we don't have a cached state. Simplify this by making lock_extent/unlock_extent the only variant and make it take a cached state, then convert all the callers appropriately. Signed-off-by: Josef Bacik --- fs/btrfs/compression.c | 6 +- fs/btrfs/disk-io.c | 7 +-- fs/btrfs/extent-io-tree.c | 4 +- fs/btrfs/extent-io-tree.h | 22 ++----- fs/btrfs/extent_io.c | 39 ++++++------- fs/btrfs/file.c | 46 +++++++-------- fs/btrfs/free-space-cache.c | 16 +++--- fs/btrfs/inode.c | 98 +++++++++++++++----------------- fs/btrfs/ioctl.c | 22 +++---- fs/btrfs/ordered-data.c | 4 +- fs/btrfs/reflink.c | 8 +-- fs/btrfs/relocation.c | 18 +++--- fs/btrfs/tests/extent-io-tests.c | 6 +- fs/btrfs/tree-log.c | 8 +-- 14 files changed, 142 insertions(+), 162 deletions(-) diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c index cac0eeceb815..54caa00a2245 100644 --- a/fs/btrfs/compression.c +++ b/fs/btrfs/compression.c @@ -588,7 +588,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, } page_end = (pg_index << PAGE_SHIFT) + PAGE_SIZE - 1; - lock_extent(tree, cur, page_end); + lock_extent(tree, cur, page_end, NULL); read_lock(&em_tree->lock); em = lookup_extent_mapping(em_tree, cur, page_end + 1 - cur); read_unlock(&em_tree->lock); @@ -602,7 +602,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, (cur + fs_info->sectorsize > extent_map_end(em)) || (em->block_start >> 9) != cb->orig_bio->bi_iter.bi_sector) { free_extent_map(em); - unlock_extent(tree, cur, page_end); + unlock_extent(tree, cur, page_end, NULL); unlock_page(page); put_page(page); break; @@ -622,7 +622,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, add_size = min(em->start + em->len, page_end + 1) - cur; ret = bio_add_page(cb->orig_bio, page, add_size, offset_in_page(cur)); if (ret != add_size) { - unlock_extent(tree, cur, page_end); + unlock_extent(tree, cur, page_end, NULL); unlock_page(page); put_page(page); break; diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c index f2b875b93ddf..0bb0c496a023 100644 --- a/fs/btrfs/disk-io.c +++ b/fs/btrfs/disk-io.c @@ -131,8 +131,7 @@ static int verify_parent_transid(struct extent_io_tree *io_tree, if (atomic) return -EAGAIN; - lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1, - &cached_state); + lock_extent(io_tree, eb->start, eb->start + eb->len - 1, &cached_state); if (extent_buffer_uptodate(eb) && btrfs_header_generation(eb) == parent_transid) { ret = 0; @@ -145,8 +144,8 @@ static int verify_parent_transid(struct extent_io_tree *io_tree, ret = 1; clear_extent_buffer_uptodate(eb); out: - unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1, - &cached_state); + unlock_extent(io_tree, eb->start, eb->start + eb->len - 1, + &cached_state); return ret; } diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 10c8f40c35f6..018fde078d78 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -1654,8 +1654,8 @@ int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) * either insert or lock state struct between start and end use mask to tell * us if waiting is desired. */ -int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, - struct extent_state **cached_state) +int lock_extent(struct extent_io_tree *tree, u64 start, u64 end, + struct extent_state **cached_state) { int err; u64 failed_start; diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 113727a1c8d1..aa0314f6802c 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -98,13 +98,8 @@ void extent_io_tree_init(struct btrfs_fs_info *fs_info, void *private_data); void extent_io_tree_release(struct extent_io_tree *tree); -int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, - struct extent_state **cached); - -static inline int lock_extent(struct extent_io_tree *tree, u64 start, u64 end) -{ - return lock_extent_bits(tree, start, end, NULL); -} +int lock_extent(struct extent_io_tree *tree, u64 start, u64 end, + struct extent_state **cached); int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end); @@ -132,20 +127,15 @@ static inline int clear_extent_bit(struct extent_io_tree *tree, u64 start, GFP_NOFS, NULL); } -static inline int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end) -{ - return clear_extent_bit(tree, start, end, EXTENT_LOCKED, 0, NULL); -} - -static inline int unlock_extent_cached(struct extent_io_tree *tree, u64 start, - u64 end, struct extent_state **cached) +static inline int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end, + struct extent_state **cached) { return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, 0, cached, GFP_NOFS, NULL); } -static inline int unlock_extent_cached_atomic(struct extent_io_tree *tree, - u64 start, u64 end, struct extent_state **cached) +static inline int unlock_extent_atomic(struct extent_io_tree *tree, u64 start, + u64 end, struct extent_state **cached) { return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, 0, cached, GFP_ATOMIC, NULL); diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 59fe8f379433..597b89826f53 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -463,14 +463,14 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode, } /* step three, lock the state bits for the whole range */ - lock_extent_bits(tree, delalloc_start, delalloc_end, &cached_state); + lock_extent(tree, delalloc_start, delalloc_end, &cached_state); /* then test to make sure it is all still delalloc */ ret = test_range_bit(tree, delalloc_start, delalloc_end, EXTENT_DELALLOC, 1, cached_state); if (!ret) { - unlock_extent_cached(tree, delalloc_start, delalloc_end, - &cached_state); + unlock_extent(tree, delalloc_start, delalloc_end, + &cached_state); __unlock_for_delalloc(inode, locked_page, delalloc_start, delalloc_end); cond_resched(); @@ -914,8 +914,8 @@ static void end_sector_io(struct page *page, u64 offset, bool uptodate) if (uptodate) set_extent_uptodate(&inode->io_tree, offset, offset + sectorsize - 1, &cached, GFP_ATOMIC); - unlock_extent_cached_atomic(&inode->io_tree, offset, - offset + sectorsize - 1, &cached); + unlock_extent_atomic(&inode->io_tree, offset, offset + sectorsize - 1, + &cached); } static void submit_data_read_repair(struct inode *inode, @@ -1119,8 +1119,7 @@ static void endio_readpage_release_extent(struct processed_extent *processed, * Now we don't have range contiguous to the processed range, release * the processed range now. */ - unlock_extent_cached_atomic(tree, processed->start, processed->end, - &cached); + unlock_extent_atomic(tree, processed->start, processed->end, &cached); update: /* Update processed to current range */ @@ -1762,7 +1761,7 @@ static int btrfs_do_readpage(struct page *page, struct extent_map **em_cached, ret = set_page_extent_mapped(page); if (ret < 0) { - unlock_extent(tree, start, end); + unlock_extent(tree, start, end, NULL); btrfs_page_set_error(fs_info, page, start, PAGE_SIZE); unlock_page(page); goto out; @@ -1790,15 +1789,14 @@ static int btrfs_do_readpage(struct page *page, struct extent_map **em_cached, memzero_page(page, pg_offset, iosize); set_extent_uptodate(tree, cur, cur + iosize - 1, &cached, GFP_NOFS); - unlock_extent_cached(tree, cur, - cur + iosize - 1, &cached); + unlock_extent(tree, cur, cur + iosize - 1, &cached); end_page_read(page, true, cur, iosize); break; } em = __get_extent_map(inode, page, pg_offset, cur, end - cur + 1, em_cached); if (IS_ERR(em)) { - unlock_extent(tree, cur, end); + unlock_extent(tree, cur, end, NULL); end_page_read(page, false, cur, end + 1 - cur); ret = PTR_ERR(em); break; @@ -1873,8 +1871,7 @@ static int btrfs_do_readpage(struct page *page, struct extent_map **em_cached, set_extent_uptodate(tree, cur, cur + iosize - 1, &cached, GFP_NOFS); - unlock_extent_cached(tree, cur, - cur + iosize - 1, &cached); + unlock_extent(tree, cur, cur + iosize - 1, &cached); end_page_read(page, true, cur, iosize); cur = cur + iosize; pg_offset += iosize; @@ -1882,7 +1879,7 @@ static int btrfs_do_readpage(struct page *page, struct extent_map **em_cached, } /* the get_extent function already copied into the page */ if (block_start == EXTENT_MAP_INLINE) { - unlock_extent(tree, cur, cur + iosize - 1); + unlock_extent(tree, cur, cur + iosize - 1, NULL); end_page_read(page, true, cur, iosize); cur = cur + iosize; pg_offset += iosize; @@ -1898,7 +1895,7 @@ static int btrfs_do_readpage(struct page *page, struct extent_map **em_cached, * We have to unlock the remaining range, or the page * will never be unlocked. */ - unlock_extent(tree, cur, end); + unlock_extent(tree, cur, end, NULL); end_page_read(page, false, cur, end + 1 - cur); goto out; } @@ -3365,7 +3362,7 @@ int extent_invalidate_folio(struct extent_io_tree *tree, if (start > end) return 0; - lock_extent_bits(tree, start, end, &cached_state); + lock_extent(tree, start, end, &cached_state); folio_wait_writeback(folio); /* @@ -3373,7 +3370,7 @@ int extent_invalidate_folio(struct extent_io_tree *tree, * so here we only need to unlock the extent range to free any * existing extent state. */ - unlock_extent_cached(tree, start, end, &cached_state); + unlock_extent(tree, start, end, &cached_state); return 0; } @@ -3942,7 +3939,7 @@ int extent_fiemap(struct btrfs_inode *inode, struct fiemap_extent_info *fieinfo, lockend = round_up(start + len, btrfs_inode_sectorsize(inode)); prev_extent_end = lockstart; - lock_extent_bits(&inode->io_tree, lockstart, lockend, &cached_state); + lock_extent(&inode->io_tree, lockstart, lockend, &cached_state); ret = fiemap_find_last_extent_offset(inode, path, &last_extent_end); if (ret < 0) @@ -4132,7 +4129,7 @@ int extent_fiemap(struct btrfs_inode *inode, struct fiemap_extent_info *fieinfo, ret = emit_last_fiemap_cache(fieinfo, &cache); out_unlock: - unlock_extent_cached(&inode->io_tree, lockstart, lockend, &cached_state); + unlock_extent(&inode->io_tree, lockstart, lockend, &cached_state); out: kfree(backref_cache); btrfs_free_path(path); @@ -4975,7 +4972,7 @@ static int read_extent_buffer_subpage(struct extent_buffer *eb, int wait, if (!try_lock_extent(io_tree, eb->start, eb->start + eb->len - 1)) return -EAGAIN; } else { - ret = lock_extent(io_tree, eb->start, eb->start + eb->len - 1); + ret = lock_extent(io_tree, eb->start, eb->start + eb->len - 1, NULL); if (ret < 0) return ret; } @@ -4985,7 +4982,7 @@ static int read_extent_buffer_subpage(struct extent_buffer *eb, int wait, PageUptodate(page) || btrfs_subpage_test_uptodate(fs_info, page, eb->start, eb->len)) { set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags); - unlock_extent(io_tree, eb->start, eb->start + eb->len - 1); + unlock_extent(io_tree, eb->start, eb->start + eb->len - 1, NULL); return ret; } diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c index 8ce01f69df3b..eb5579d9a3e0 100644 --- a/fs/btrfs/file.c +++ b/fs/btrfs/file.c @@ -1426,15 +1426,14 @@ lock_and_cleanup_extent_if_need(struct btrfs_inode *inode, struct page **pages, if (start_pos < inode->vfs_inode.i_size) { struct btrfs_ordered_extent *ordered; - lock_extent_bits(&inode->io_tree, start_pos, last_pos, - cached_state); + lock_extent(&inode->io_tree, start_pos, last_pos, cached_state); ordered = btrfs_lookup_ordered_range(inode, start_pos, last_pos - start_pos + 1); if (ordered && ordered->file_offset + ordered->num_bytes > start_pos && ordered->file_offset <= last_pos) { - unlock_extent_cached(&inode->io_tree, start_pos, - last_pos, cached_state); + unlock_extent(&inode->io_tree, start_pos, last_pos, + cached_state); for (i = 0; i < num_pages; i++) { unlock_page(pages[i]); put_page(pages[i]); @@ -1510,7 +1509,7 @@ int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos, *write_bytes = min_t(size_t, *write_bytes , num_bytes - pos + lockstart); } - unlock_extent(&inode->io_tree, lockstart, lockend); + unlock_extent(&inode->io_tree, lockstart, lockend, NULL); return ret; } @@ -1782,8 +1781,8 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, * possible cached extent state to avoid a memory leak. */ if (extents_locked) - unlock_extent_cached(&BTRFS_I(inode)->io_tree, - lockstart, lockend, &cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, + lockend, &cached_state); else free_extent_state(cached_state); @@ -2592,8 +2591,8 @@ static void btrfs_punch_hole_lock_range(struct inode *inode, while (1) { truncate_pagecache_range(inode, lockstart, lockend); - lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, - cached_state); + lock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, + cached_state); /* * We can't have ordered extents in the range, nor dirty/writeback * pages, because we have locked the inode's VFS lock in exclusive @@ -2608,8 +2607,8 @@ static void btrfs_punch_hole_lock_range(struct inode *inode, page_lockend)) break; - unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, - lockend, cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, + cached_state); } btrfs_assert_inode_range_clean(BTRFS_I(inode), lockstart, lockend); @@ -3109,8 +3108,8 @@ static int btrfs_punch_hole(struct file *file, loff_t offset, loff_t len) btrfs_end_transaction(trans); btrfs_btree_balance_dirty(fs_info); out: - unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend, - &cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, + &cached_state); out_only_mutex: if (!updated_inode && truncated_block && !ret) { /* @@ -3383,16 +3382,16 @@ static int btrfs_zero_range(struct inode *inode, ret = btrfs_qgroup_reserve_data(BTRFS_I(inode), &data_reserved, alloc_start, bytes_to_reserve); if (ret) { - unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, - lockend, &cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, + lockend, &cached_state); goto out; } ret = btrfs_prealloc_file_range(inode, mode, alloc_start, alloc_end - alloc_start, i_blocksize(inode), offset + len, &alloc_hint); - unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, - lockend, &cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, + &cached_state); /* btrfs_prealloc_file_range releases reserved space on error */ if (ret) { space_reserved = false; @@ -3503,8 +3502,8 @@ static long btrfs_fallocate(struct file *file, int mode, } locked_end = alloc_end - 1; - lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start, locked_end, - &cached_state); + lock_extent(&BTRFS_I(inode)->io_tree, alloc_start, locked_end, + &cached_state); btrfs_assert_inode_range_clean(BTRFS_I(inode), alloc_start, locked_end); @@ -3593,8 +3592,8 @@ static long btrfs_fallocate(struct file *file, int mode, */ ret = btrfs_fallocate_update_isize(inode, actual_end, mode); out_unlock: - unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end, - &cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, alloc_start, locked_end, + &cached_state); out: btrfs_inode_unlock(inode, BTRFS_ILOCK_MMAP); extent_changeset_free(data_reserved); @@ -3899,7 +3898,7 @@ static loff_t find_desired_extent(struct btrfs_inode *inode, loff_t offset, last_extent_end = lockstart; - lock_extent_bits(&inode->io_tree, lockstart, lockend, &cached_state); + lock_extent(&inode->io_tree, lockstart, lockend, &cached_state); ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); if (ret < 0) { @@ -4035,8 +4034,7 @@ static loff_t find_desired_extent(struct btrfs_inode *inode, loff_t offset, } out: - unlock_extent_cached(&inode->io_tree, lockstart, lockend, - &cached_state); + unlock_extent(&inode->io_tree, lockstart, lockend, &cached_state); btrfs_free_path(path); if (ret < 0) diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c index 0bd5b02966c0..ecef1ba816c3 100644 --- a/fs/btrfs/free-space-cache.c +++ b/fs/btrfs/free-space-cache.c @@ -348,7 +348,7 @@ int btrfs_truncate_free_space_cache(struct btrfs_trans_handle *trans, btrfs_i_size_write(inode, 0); truncate_pagecache(vfs_inode, 0); - lock_extent_bits(&inode->io_tree, 0, (u64)-1, &cached_state); + lock_extent(&inode->io_tree, 0, (u64)-1, &cached_state); btrfs_drop_extent_cache(inode, 0, (u64)-1, 0); /* @@ -360,7 +360,7 @@ int btrfs_truncate_free_space_cache(struct btrfs_trans_handle *trans, inode_sub_bytes(&inode->vfs_inode, control.sub_bytes); btrfs_inode_safe_disk_i_size_write(inode, control.last_size); - unlock_extent_cached(&inode->io_tree, 0, (u64)-1, &cached_state); + unlock_extent(&inode->io_tree, 0, (u64)-1, &cached_state); if (ret) goto fail; @@ -1292,8 +1292,8 @@ cleanup_write_cache_enospc(struct inode *inode, struct extent_state **cached_state) { io_ctl_drop_pages(io_ctl); - unlock_extent_cached(&BTRFS_I(inode)->io_tree, 0, - i_size_read(inode) - 1, cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, 0, i_size_read(inode) - 1, + cached_state); } static int __btrfs_wait_cache_io(struct btrfs_root *root, @@ -1418,8 +1418,8 @@ static int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode, if (ret) goto out_unlock; - lock_extent_bits(&BTRFS_I(inode)->io_tree, 0, i_size_read(inode) - 1, - &cached_state); + lock_extent(&BTRFS_I(inode)->io_tree, 0, i_size_read(inode) - 1, + &cached_state); io_ctl_set_generation(io_ctl, trans->transid); @@ -1474,8 +1474,8 @@ static int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode, io_ctl_drop_pages(io_ctl); io_ctl_free(io_ctl); - unlock_extent_cached(&BTRFS_I(inode)->io_tree, 0, - i_size_read(inode) - 1, &cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, 0, i_size_read(inode) - 1, + &cached_state); /* * at this point the pages are under IO and we're happy, diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index ee0901944cbe..7519233b922f 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -977,7 +977,7 @@ static int submit_one_async_extent(struct btrfs_inode *inode, if (!(start >= locked_page_end || end <= locked_page_start)) locked_page = async_chunk->locked_page; } - lock_extent(io_tree, start, end); + lock_extent(io_tree, start, end, NULL); /* We have fall back to uncompressed write */ if (!async_extent->pages) @@ -1524,7 +1524,7 @@ static int cow_file_range_async(struct btrfs_inode *inode, unsigned nofs_flag; const blk_opf_t write_flags = wbc_to_write_flags(wbc); - unlock_extent(&inode->io_tree, start, end); + unlock_extent(&inode->io_tree, start, end, NULL); if (inode->flags & BTRFS_INODE_NOCOMPRESS && !btrfs_test_opt(fs_info, FORCE_COMPRESS)) { @@ -2548,7 +2548,7 @@ static int split_zoned_em(struct btrfs_inode *inode, u64 start, u64 len, ASSERT(pre + post < len); - lock_extent(&inode->io_tree, start, start + len - 1); + lock_extent(&inode->io_tree, start, start + len - 1, NULL); write_lock(&em_tree->lock); em = lookup_extent_mapping(em_tree, start, len); if (!em) { @@ -2622,7 +2622,7 @@ static int split_zoned_em(struct btrfs_inode *inode, u64 start, u64 len, out_unlock: write_unlock(&em_tree->lock); - unlock_extent(&inode->io_tree, start, start + len - 1); + unlock_extent(&inode->io_tree, start, start + len - 1, NULL); out: free_extent_map(split_pre); free_extent_map(split_mid); @@ -2928,7 +2928,7 @@ static void btrfs_writepage_fixup_worker(struct btrfs_work *work) if (ret) goto out_page; - lock_extent_bits(&inode->io_tree, page_start, page_end, &cached_state); + lock_extent(&inode->io_tree, page_start, page_end, &cached_state); /* already ordered? We're done */ if (PageOrdered(page)) @@ -2936,8 +2936,8 @@ static void btrfs_writepage_fixup_worker(struct btrfs_work *work) ordered = btrfs_lookup_ordered_range(inode, page_start, PAGE_SIZE); if (ordered) { - unlock_extent_cached(&inode->io_tree, page_start, page_end, - &cached_state); + unlock_extent(&inode->io_tree, page_start, page_end, + &cached_state); unlock_page(page); btrfs_start_ordered_extent(ordered, 1); btrfs_put_ordered_extent(ordered); @@ -2963,8 +2963,7 @@ static void btrfs_writepage_fixup_worker(struct btrfs_work *work) if (free_delalloc_space) btrfs_delalloc_release_space(inode, data_reserved, page_start, PAGE_SIZE, true); - unlock_extent_cached(&inode->io_tree, page_start, page_end, - &cached_state); + unlock_extent(&inode->io_tree, page_start, page_end, &cached_state); out_page: if (ret) { /* @@ -3268,7 +3267,7 @@ int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent) } clear_bits |= EXTENT_LOCKED; - lock_extent_bits(io_tree, start, end, &cached_state); + lock_extent(io_tree, start, end, &cached_state); if (freespace_inode) trans = btrfs_join_transaction_spacecache(root); @@ -4920,12 +4919,11 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len, } wait_on_page_writeback(page); - lock_extent_bits(io_tree, block_start, block_end, &cached_state); + lock_extent(io_tree, block_start, block_end, &cached_state); ordered = btrfs_lookup_ordered_extent(inode, block_start); if (ordered) { - unlock_extent_cached(io_tree, block_start, block_end, - &cached_state); + unlock_extent(io_tree, block_start, block_end, &cached_state); unlock_page(page); put_page(page); btrfs_start_ordered_extent(ordered, 1); @@ -4940,8 +4938,7 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len, ret = btrfs_set_extent_delalloc(inode, block_start, block_end, 0, &cached_state); if (ret) { - unlock_extent_cached(io_tree, block_start, block_end, - &cached_state); + unlock_extent(io_tree, block_start, block_end, &cached_state); goto out_unlock; } @@ -4958,7 +4955,7 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len, btrfs_page_clear_checked(fs_info, page, block_start, block_end + 1 - block_start); btrfs_page_set_dirty(fs_info, page, block_start, block_end + 1 - block_start); - unlock_extent_cached(io_tree, block_start, block_end, &cached_state); + unlock_extent(io_tree, block_start, block_end, &cached_state); if (only_release_metadata) set_extent_bit(&inode->io_tree, block_start, block_end, @@ -5134,7 +5131,7 @@ int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size) break; } free_extent_map(em); - unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state); + unlock_extent(io_tree, hole_start, block_end - 1, &cached_state); return err; } @@ -5268,7 +5265,7 @@ static int btrfs_setattr(struct user_namespace *mnt_userns, struct dentry *dentr * While truncating the inode pages during eviction, we get the VFS * calling btrfs_invalidate_folio() against each folio of the inode. This * is slow because the calls to btrfs_invalidate_folio() result in a - * huge amount of calls to lock_extent_bits() and clear_extent_bit(), + * huge amount of calls to lock_extent() and clear_extent_bit(), * which keep merging and splitting extent_state structures over and over, * wasting lots of time. * @@ -5335,7 +5332,7 @@ static void evict_inode_truncate_pages(struct inode *inode) state_flags = state->state; spin_unlock(&io_tree->lock); - lock_extent_bits(io_tree, start, end, &cached_state); + lock_extent(io_tree, start, end, &cached_state); /* * If still has DELALLOC flag, the extent didn't reach disk, @@ -7271,7 +7268,7 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend, if (!try_lock_extent(io_tree, lockstart, lockend)) return -EAGAIN; } else { - lock_extent_bits(io_tree, lockstart, lockend, cached_state); + lock_extent(io_tree, lockstart, lockend, cached_state); } /* * We're concerned with the entire range that we're going to be @@ -7293,7 +7290,7 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend, lockstart, lockend))) break; - unlock_extent_cached(io_tree, lockstart, lockend, cached_state); + unlock_extent(io_tree, lockstart, lockend, cached_state); if (ordered) { if (nowait) { @@ -7751,8 +7748,8 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start, } if (unlock_extents) - unlock_extent_cached(&BTRFS_I(inode)->io_tree, - lockstart, lockend, &cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, + &cached_state); else free_extent_state(cached_state); @@ -7781,8 +7778,8 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start, return 0; unlock_err: - unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend, - &cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, + &cached_state); err: if (dio_data->data_space_reserved) { btrfs_free_reserved_data_space(BTRFS_I(inode), @@ -7805,7 +7802,8 @@ static int btrfs_dio_iomap_end(struct inode *inode, loff_t pos, loff_t length, if (!write && (iomap->type == IOMAP_HOLE)) { /* If reading from a hole, unlock and return */ - unlock_extent(&BTRFS_I(inode)->io_tree, pos, pos + length - 1); + unlock_extent(&BTRFS_I(inode)->io_tree, pos, pos + length - 1, + NULL); return 0; } @@ -7817,7 +7815,7 @@ static int btrfs_dio_iomap_end(struct inode *inode, loff_t pos, loff_t length, pos, length, false); else unlock_extent(&BTRFS_I(inode)->io_tree, pos, - pos + length - 1); + pos + length - 1, NULL); ret = -ENOTBLK; } @@ -7842,7 +7840,7 @@ static void btrfs_dio_private_put(struct btrfs_dio_private *dip) } else { unlock_extent(&BTRFS_I(dip->inode)->io_tree, dip->file_offset, - dip->file_offset + dip->bytes - 1); + dip->file_offset + dip->bytes - 1, NULL); } kfree(dip->csums); @@ -8272,7 +8270,7 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, } if (!inode_evicting) - lock_extent_bits(tree, page_start, page_end, &cached_state); + lock_extent(tree, page_start, page_end, &cached_state); cur = page_start; while (cur < page_end) { @@ -8470,11 +8468,11 @@ vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) } wait_on_page_writeback(page); - lock_extent_bits(io_tree, page_start, page_end, &cached_state); + lock_extent(io_tree, page_start, page_end, &cached_state); ret2 = set_page_extent_mapped(page); if (ret2 < 0) { ret = vmf_error(ret2); - unlock_extent_cached(io_tree, page_start, page_end, &cached_state); + unlock_extent(io_tree, page_start, page_end, &cached_state); goto out_unlock; } @@ -8485,8 +8483,7 @@ vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start, PAGE_SIZE); if (ordered) { - unlock_extent_cached(io_tree, page_start, page_end, - &cached_state); + unlock_extent(io_tree, page_start, page_end, &cached_state); unlock_page(page); up_read(&BTRFS_I(inode)->i_mmap_lock); btrfs_start_ordered_extent(ordered, 1); @@ -8519,8 +8516,7 @@ vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) ret2 = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0, &cached_state); if (ret2) { - unlock_extent_cached(io_tree, page_start, page_end, - &cached_state); + unlock_extent(io_tree, page_start, page_end, &cached_state); ret = VM_FAULT_SIGBUS; goto out_unlock; } @@ -8540,7 +8536,7 @@ vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) btrfs_set_inode_last_sub_trans(BTRFS_I(inode)); - unlock_extent_cached(io_tree, page_start, page_end, &cached_state); + unlock_extent(io_tree, page_start, page_end, &cached_state); up_read(&BTRFS_I(inode)->i_mmap_lock); btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE); @@ -8641,7 +8637,7 @@ static int btrfs_truncate(struct inode *inode, bool skip_writeback) const u64 lock_start = ALIGN_DOWN(new_size, fs_info->sectorsize); control.new_size = new_size; - lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1, + lock_extent(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1, &cached_state); /* * We want to drop from the next block forward in case this new @@ -8657,8 +8653,8 @@ static int btrfs_truncate(struct inode *inode, bool skip_writeback) inode_sub_bytes(inode, control.sub_bytes); btrfs_inode_safe_disk_i_size_write(BTRFS_I(inode), control.last_size); - unlock_extent_cached(&BTRFS_I(inode)->io_tree, lock_start, - (u64)-1, &cached_state); + unlock_extent(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1, + &cached_state); trans->block_rsv = &fs_info->trans_block_rsv; if (ret != -ENOSPC && ret != -EAGAIN) @@ -10237,7 +10233,7 @@ static ssize_t btrfs_encoded_read_inline( } read_extent_buffer(leaf, tmp, ptr, count); btrfs_release_path(path); - unlock_extent_cached(io_tree, start, lockend, cached_state); + unlock_extent(io_tree, start, lockend, cached_state); btrfs_inode_unlock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); *unlocked = true; @@ -10440,7 +10436,7 @@ static ssize_t btrfs_encoded_read_regular(struct kiocb *iocb, if (ret) goto out; - unlock_extent_cached(io_tree, start, lockend, cached_state); + unlock_extent(io_tree, start, lockend, cached_state); btrfs_inode_unlock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); *unlocked = true; @@ -10510,13 +10506,13 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter, lockend - start + 1); if (ret) goto out_unlock_inode; - lock_extent_bits(io_tree, start, lockend, &cached_state); + lock_extent(io_tree, start, lockend, &cached_state); ordered = btrfs_lookup_ordered_range(inode, start, lockend - start + 1); if (!ordered) break; btrfs_put_ordered_extent(ordered); - unlock_extent_cached(io_tree, start, lockend, &cached_state); + unlock_extent(io_tree, start, lockend, &cached_state); cond_resched(); } @@ -10590,7 +10586,7 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter, em = NULL; if (disk_bytenr == EXTENT_MAP_HOLE) { - unlock_extent_cached(io_tree, start, lockend, &cached_state); + unlock_extent(io_tree, start, lockend, &cached_state); btrfs_inode_unlock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); unlocked = true; ret = iov_iter_zero(count, iter); @@ -10611,7 +10607,7 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter, free_extent_map(em); out_unlock_extent: if (!unlocked) - unlock_extent_cached(io_tree, start, lockend, &cached_state); + unlock_extent(io_tree, start, lockend, &cached_state); out_unlock_inode: if (!unlocked) btrfs_inode_unlock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); @@ -10749,14 +10745,14 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from, end >> PAGE_SHIFT); if (ret) goto out_pages; - lock_extent_bits(io_tree, start, end, &cached_state); + lock_extent(io_tree, start, end, &cached_state); ordered = btrfs_lookup_ordered_range(inode, start, num_bytes); if (!ordered && !filemap_range_has_page(inode->vfs_inode.i_mapping, start, end)) break; if (ordered) btrfs_put_ordered_extent(ordered); - unlock_extent_cached(io_tree, start, end, &cached_state); + unlock_extent(io_tree, start, end, &cached_state); cond_resched(); } @@ -10818,7 +10814,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from, if (start + encoded->len > inode->vfs_inode.i_size) i_size_write(&inode->vfs_inode, start + encoded->len); - unlock_extent_cached(io_tree, start, end, &cached_state); + unlock_extent(io_tree, start, end, &cached_state); btrfs_delalloc_release_extents(inode, num_bytes); @@ -10849,7 +10845,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from, if (!extent_reserved) btrfs_free_reserved_data_space_noquota(fs_info, disk_num_bytes); out_unlock: - unlock_extent_cached(io_tree, start, end, &cached_state); + unlock_extent(io_tree, start, end, &cached_state); out_pages: for (i = 0; i < nr_pages; i++) { if (pages[i]) @@ -11090,7 +11086,7 @@ static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file, isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize); - lock_extent_bits(io_tree, 0, isize - 1, &cached_state); + lock_extent(io_tree, 0, isize - 1, &cached_state); start = 0; while (start < isize) { u64 logical_block_start, physical_block_start; @@ -11227,7 +11223,7 @@ static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file, if (!IS_ERR_OR_NULL(em)) free_extent_map(em); - unlock_extent_cached(io_tree, 0, isize - 1, &cached_state); + unlock_extent(io_tree, 0, isize - 1, &cached_state); if (ret) btrfs_swap_deactivate(file); diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c index 274ad3e23190..d59e1f1b762e 100644 --- a/fs/btrfs/ioctl.c +++ b/fs/btrfs/ioctl.c @@ -1218,10 +1218,10 @@ static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start, /* get the big lock and read metadata off disk */ if (!locked) - lock_extent_bits(io_tree, start, end, &cached); + lock_extent(io_tree, start, end, &cached); em = defrag_get_extent(BTRFS_I(inode), start, newer_than); if (!locked) - unlock_extent_cached(io_tree, start, end, &cached); + unlock_extent(io_tree, start, end, &cached); if (IS_ERR(em)) return NULL; @@ -1333,10 +1333,10 @@ static struct page *defrag_prepare_one_page(struct btrfs_inode *inode, while (1) { struct btrfs_ordered_extent *ordered; - lock_extent_bits(&inode->io_tree, page_start, page_end, &cached_state); + lock_extent(&inode->io_tree, page_start, page_end, &cached_state); ordered = btrfs_lookup_ordered_range(inode, page_start, PAGE_SIZE); - unlock_extent_cached(&inode->io_tree, page_start, page_end, - &cached_state); + unlock_extent(&inode->io_tree, page_start, page_end, + &cached_state); if (!ordered) break; @@ -1666,9 +1666,9 @@ static int defrag_one_range(struct btrfs_inode *inode, u64 start, u32 len, wait_on_page_writeback(pages[i]); /* Lock the pages range */ - lock_extent_bits(&inode->io_tree, start_index << PAGE_SHIFT, - (last_index << PAGE_SHIFT) + PAGE_SIZE - 1, - &cached_state); + lock_extent(&inode->io_tree, start_index << PAGE_SHIFT, + (last_index << PAGE_SHIFT) + PAGE_SIZE - 1, + &cached_state); /* * Now we have a consistent view about the extent map, re-check * which range really needs to be defragged. @@ -1694,9 +1694,9 @@ static int defrag_one_range(struct btrfs_inode *inode, u64 start, u32 len, kfree(entry); } unlock_extent: - unlock_extent_cached(&inode->io_tree, start_index << PAGE_SHIFT, - (last_index << PAGE_SHIFT) + PAGE_SIZE - 1, - &cached_state); + unlock_extent(&inode->io_tree, start_index << PAGE_SHIFT, + (last_index << PAGE_SHIFT) + PAGE_SIZE - 1, + &cached_state); free_pages: for (i = 0; i < nr_pages; i++) { if (pages[i]) { diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c index eb24a6d20ff8..40a364c11178 100644 --- a/fs/btrfs/ordered-data.c +++ b/fs/btrfs/ordered-data.c @@ -1043,7 +1043,7 @@ void btrfs_lock_and_flush_ordered_range(struct btrfs_inode *inode, u64 start, cachedp = cached_state; while (1) { - lock_extent_bits(&inode->io_tree, start, end, cachedp); + lock_extent(&inode->io_tree, start, end, cachedp); ordered = btrfs_lookup_ordered_range(inode, start, end - start + 1); if (!ordered) { @@ -1056,7 +1056,7 @@ void btrfs_lock_and_flush_ordered_range(struct btrfs_inode *inode, u64 start, refcount_dec(&cache->refs); break; } - unlock_extent_cached(&inode->io_tree, start, end, cachedp); + unlock_extent(&inode->io_tree, start, end, cachedp); btrfs_start_ordered_extent(ordered, 1); btrfs_put_ordered_extent(ordered); } diff --git a/fs/btrfs/reflink.c b/fs/btrfs/reflink.c index 39556ce1b551..7a0db71d683b 100644 --- a/fs/btrfs/reflink.c +++ b/fs/btrfs/reflink.c @@ -615,8 +615,8 @@ static int btrfs_clone(struct inode *src, struct inode *inode, static void btrfs_double_extent_unlock(struct inode *inode1, u64 loff1, struct inode *inode2, u64 loff2, u64 len) { - unlock_extent(&BTRFS_I(inode1)->io_tree, loff1, loff1 + len - 1); - unlock_extent(&BTRFS_I(inode2)->io_tree, loff2, loff2 + len - 1); + unlock_extent(&BTRFS_I(inode1)->io_tree, loff1, loff1 + len - 1, NULL); + unlock_extent(&BTRFS_I(inode2)->io_tree, loff2, loff2 + len - 1, NULL); } static void btrfs_double_extent_lock(struct inode *inode1, u64 loff1, @@ -634,8 +634,8 @@ static void btrfs_double_extent_lock(struct inode *inode1, u64 loff1, swap(range1_end, range2_end); } - lock_extent(&BTRFS_I(inode1)->io_tree, loff1, range1_end); - lock_extent(&BTRFS_I(inode2)->io_tree, loff2, range2_end); + lock_extent(&BTRFS_I(inode1)->io_tree, loff1, range1_end, NULL); + lock_extent(&BTRFS_I(inode2)->io_tree, loff2, range2_end, NULL); btrfs_assert_inode_range_clean(BTRFS_I(inode1), loff1, range1_end); btrfs_assert_inode_range_clean(BTRFS_I(inode2), loff2, range2_end); diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c index 45c02aba2492..d87020ae5810 100644 --- a/fs/btrfs/relocation.c +++ b/fs/btrfs/relocation.c @@ -1127,7 +1127,7 @@ int replace_file_extents(struct btrfs_trans_handle *trans, btrfs_drop_extent_cache(BTRFS_I(inode), key.offset, end, 1); unlock_extent(&BTRFS_I(inode)->io_tree, - key.offset, end); + key.offset, end, NULL); } } @@ -1566,9 +1566,9 @@ static int invalidate_extent_cache(struct btrfs_root *root, } /* the lock_extent waits for read_folio to complete */ - lock_extent(&BTRFS_I(inode)->io_tree, start, end); + lock_extent(&BTRFS_I(inode)->io_tree, start, end, NULL); btrfs_drop_extent_cache(BTRFS_I(inode), start, end, 1); - unlock_extent(&BTRFS_I(inode)->io_tree, start, end); + unlock_extent(&BTRFS_I(inode)->io_tree, start, end, NULL); } return 0; } @@ -2869,13 +2869,13 @@ static noinline_for_stack int prealloc_file_extent_cluster( else end = cluster->end - offset; - lock_extent(&inode->io_tree, start, end); + lock_extent(&inode->io_tree, start, end, NULL); num_bytes = end + 1 - start; ret = btrfs_prealloc_file_range(&inode->vfs_inode, 0, start, num_bytes, num_bytes, end + 1, &alloc_hint); cur_offset = end + 1; - unlock_extent(&inode->io_tree, start, end); + unlock_extent(&inode->io_tree, start, end, NULL); if (ret) break; } @@ -2904,7 +2904,7 @@ static noinline_for_stack int setup_relocation_extent_mapping(struct inode *inod em->block_start = block_start; set_bit(EXTENT_FLAG_PINNED, &em->flags); - lock_extent(&BTRFS_I(inode)->io_tree, start, end); + lock_extent(&BTRFS_I(inode)->io_tree, start, end, NULL); while (1) { write_lock(&em_tree->lock); ret = add_extent_mapping(em_tree, em, 0); @@ -2915,7 +2915,7 @@ static noinline_for_stack int setup_relocation_extent_mapping(struct inode *inod } btrfs_drop_extent_cache(BTRFS_I(inode), start, end, 0); } - unlock_extent(&BTRFS_I(inode)->io_tree, start, end); + unlock_extent(&BTRFS_I(inode)->io_tree, start, end, NULL); return ret; } @@ -3006,7 +3006,7 @@ static int relocate_one_page(struct inode *inode, struct file_ra_state *ra, goto release_page; /* Mark the range delalloc and dirty for later writeback */ - lock_extent(&BTRFS_I(inode)->io_tree, clamped_start, clamped_end); + lock_extent(&BTRFS_I(inode)->io_tree, clamped_start, clamped_end, NULL); ret = btrfs_set_extent_delalloc(BTRFS_I(inode), clamped_start, clamped_end, 0, NULL); if (ret) { @@ -3039,7 +3039,7 @@ static int relocate_one_page(struct inode *inode, struct file_ra_state *ra, boundary_start, boundary_end, EXTENT_BOUNDARY); } - unlock_extent(&BTRFS_I(inode)->io_tree, clamped_start, clamped_end); + unlock_extent(&BTRFS_I(inode)->io_tree, clamped_start, clamped_end, NULL); btrfs_delalloc_release_extents(BTRFS_I(inode), clamped_len); cur += clamped_len; diff --git a/fs/btrfs/tests/extent-io-tests.c b/fs/btrfs/tests/extent-io-tests.c index a232b15b8021..4c824b7f07dd 100644 --- a/fs/btrfs/tests/extent-io-tests.c +++ b/fs/btrfs/tests/extent-io-tests.c @@ -172,7 +172,7 @@ static int test_find_delalloc(u32 sectorsize) sectorsize - 1, start, end); goto out_bits; } - unlock_extent(tmp, start, end); + unlock_extent(tmp, start, end, NULL); unlock_page(locked_page); put_page(locked_page); @@ -208,7 +208,7 @@ static int test_find_delalloc(u32 sectorsize) test_err("there were unlocked pages in the range"); goto out_bits; } - unlock_extent(tmp, start, end); + unlock_extent(tmp, start, end, NULL); /* locked_page was unlocked above */ put_page(locked_page); @@ -263,7 +263,7 @@ static int test_find_delalloc(u32 sectorsize) test_err("pages in range were not all locked"); goto out_bits; } - unlock_extent(tmp, start, end); + unlock_extent(tmp, start, end, NULL); /* * Now to test where we run into a page that is no longer dirty in the diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c index 020e01ea44bc..b5018e42cf06 100644 --- a/fs/btrfs/tree-log.c +++ b/fs/btrfs/tree-log.c @@ -4271,8 +4271,8 @@ static int log_csums(struct btrfs_trans_handle *trans, * file which happens to refer to the same extent as well. Such races * can leave checksum items in the log with overlapping ranges. */ - ret = lock_extent_bits(&log_root->log_csum_range, sums->bytenr, - lock_end, &cached_state); + ret = lock_extent(&log_root->log_csum_range, sums->bytenr, lock_end, + &cached_state); if (ret) return ret; /* @@ -4288,8 +4288,8 @@ static int log_csums(struct btrfs_trans_handle *trans, if (!ret) ret = btrfs_csum_file_blocks(trans, log_root, sums); - unlock_extent_cached(&log_root->log_csum_range, sums->bytenr, lock_end, - &cached_state); + unlock_extent(&log_root->log_csum_range, sums->bytenr, lock_end, + &cached_state); return ret; } From patchwork Fri Sep 9 21:53:44 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972217 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 7ED44C6FA89 for ; Fri, 9 Sep 2022 21:54:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231937AbiIIVyp (ORCPT ); Fri, 9 Sep 2022 17:54:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59222 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231752AbiIIVyi (ORCPT ); Fri, 9 Sep 2022 17:54:38 -0400 Received: from mail-qk1-x732.google.com (mail-qk1-x732.google.com [IPv6:2607:f8b0:4864:20::732]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6B72DDF09 for ; Fri, 9 Sep 2022 14:54:37 -0700 (PDT) Received: by mail-qk1-x732.google.com with SMTP id g16so2201418qkl.11 for ; Fri, 09 Sep 2022 14:54:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=RTkD+qbae4uFlT0kEygAF/P6qE9mHsq/YnBnP/cR3tA=; b=k5cZayDbY2FINcOpKIteE2+wjOjO7HWGoatzWL44XiLwFZLUAWZgUMyA5UOWPrhUWd zt4g9vlZtCXt+heqDn1bi9NspZvOU8C4HpVpLnqEoShrsdc0roxbpUx2H4EaltGXt/dD OtWNC5eOM4Ds263WbUF/hbIHG7B4s7DnPwfi7C9cuUiSxWT/4N+sv2Imeq32vKwjyl33 Stv0Mru8RAUGfW96BFbnctSbG9ffAB/YRL2iLzGFssIZ1tV0kX5IhX2hx1kgXgpVwKdD STZh1pSWXr3L7cbqZTQf/lwC2RJh4IKRplO4gRD/vlbwh9gpXIrEERsaUnL+OW8wG0ie 361w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=RTkD+qbae4uFlT0kEygAF/P6qE9mHsq/YnBnP/cR3tA=; b=Q04XafilH4t2TxczL90a+Ivk28QCx/eaKGX+WKeLqReHmdZVy7ARBMTQn+M2EIBbFZ afsDWRZyve1ik/ZG3+NFm4DP74zxep3n85BA7x9nbkuxZmxrWe8QnBilUH8ry1uJCs6X VCXJA+88fAgdOSaz7959qRBnsjtMLNNXUZnVhTK0AfTKFEDFWCICzQ9FYVayCWAqN+nd GFpfu+kJrFJNAyXSWO4iqtV0bT/KPHCbzT/4w5cfkCQO6FUBZE84UHtaStMy/fO4ATKe GKuUIdfmjEPhGQ35SvtwbpgWrtYrhn99nveKmmOZibVt/GSOVH4La7+MGEaQgs9y+vNW 51ow== X-Gm-Message-State: ACgBeo3VF7mFIFJXjCX/wl7bb/q4Jz7KXY+tMRaglPXDf0BaxmLOP7xl KN5Z5McDKJTUxi0u3A8t+D9UCVMqx0Bf9g== X-Google-Smtp-Source: AA6agR4E67YIKDszHP4iqX3kr2QNS64OrsLJz5JChNuAYOE1y98gIzMj4rt4Kr7eSreKX525wwARog== X-Received: by 2002:a05:620a:2685:b0:6bc:374a:8f44 with SMTP id c5-20020a05620a268500b006bc374a8f44mr11734592qkp.165.1662760476606; Fri, 09 Sep 2022 14:54:36 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id w28-20020a05622a191c00b0034454aff529sm1127005qtc.80.2022.09.09.14.54.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:36 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 31/36] btrfs: remove extent_io_tree::track_uptodate Date: Fri, 9 Sep 2022 17:53:44 -0400 Message-Id: <3d4ea0d498f6389292fb435d5d461f4120579e84.1662760286.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 Since btrfs: remove unnecessary EXTENT_UPTODATE state in buffered I/O path we no longer check ->track_uptodate, remove it. Signed-off-by: Josef Bacik --- fs/btrfs/disk-io.c | 1 - fs/btrfs/extent-io-tree.h | 1 - fs/btrfs/inode.c | 1 - 3 files changed, 3 deletions(-) diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c index 0bb0c496a023..eedb39d89be5 100644 --- a/fs/btrfs/disk-io.c +++ b/fs/btrfs/disk-io.c @@ -2232,7 +2232,6 @@ static void btrfs_init_btree_inode(struct btrfs_fs_info *fs_info) RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node); extent_io_tree_init(fs_info, &BTRFS_I(inode)->io_tree, IO_TREE_BTREE_INODE_IO, inode); - BTRFS_I(inode)->io_tree.track_uptodate = false; extent_map_tree_init(&BTRFS_I(inode)->extent_tree); BTRFS_I(inode)->root = btrfs_grab_root(fs_info->tree_root); diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index aa0314f6802c..37543fb713bd 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -70,7 +70,6 @@ struct extent_io_tree { struct btrfs_fs_info *fs_info; void *private_data; u64 dirty_bytes; - bool track_uptodate; /* Who owns this io tree, should be one of IO_TREE_* */ u8 owner; diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 7519233b922f..c417bbc29986 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -8805,7 +8805,6 @@ struct inode *btrfs_alloc_inode(struct super_block *sb) extent_io_tree_init(fs_info, &ei->file_extent_tree, IO_TREE_INODE_FILE_EXTENT, inode); ei->io_failure_tree = RB_ROOT; - ei->io_tree.track_uptodate = true; atomic_set(&ei->sync_writers, 0); mutex_init(&ei->log_mutex); btrfs_ordered_inode_tree_init(&ei->ordered_tree); From patchwork Fri Sep 9 21:53:45 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972218 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 04782ECAAD3 for ; Fri, 9 Sep 2022 21:54:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231936AbiIIVyq (ORCPT ); Fri, 9 Sep 2022 17:54:46 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59424 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231912AbiIIVyk (ORCPT ); Fri, 9 Sep 2022 17:54:40 -0400 Received: from mail-qv1-xf30.google.com (mail-qv1-xf30.google.com [IPv6:2607:f8b0:4864:20::f30]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 93A8E63CF for ; Fri, 9 Sep 2022 14:54:38 -0700 (PDT) Received: by mail-qv1-xf30.google.com with SMTP id m9so2283518qvv.7 for ; Fri, 09 Sep 2022 14:54:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=kTGt01uXOuF+evZSs3NlXlqXZ3La1eFakwfpIx4UWQw=; b=4sECLwifBpMEhaSkYjm1jDbXSKhJS/ilyoXsEhiwFZJMhdbjR/cQR6mHFuspa2yr7f 398+n3NDdWwID/2w/vbXxyCefzn1s1Ppm0lScyzcOaWe5gDf2wZr6CGWhTPF0lsXcywL Nc4aNQTVwQDVFZnNO14ABK5+neuvOceK1lZwVRiBgnqbSD3x7fYUDBmjjGAFyoF1rMOh fLM50zULI3K3Cm4MZC7hvFKFMFHojDpPAPuxA+FCyH4VAb3dd2dl1DU/z31LPgXJqD05 miEVSRAwZJZojFa8kbemSI87WDgsrsn1IP8em6MwYans0pXlF/Kcstqv+JTHJsJU7egY Mn2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=kTGt01uXOuF+evZSs3NlXlqXZ3La1eFakwfpIx4UWQw=; b=d8Dh9hL098HTeUe37sPb4IXrqAOFQ4cKNMfXuav6/ulfYfUmmxb6mINJYu8g8v/faI QhmW8CQBPUEo7YnrD9/V3MChWHnmGkNgbnpPGAqfYj4UOUhMsxW+lu4/9B/yYzY1rkGU 5ESbhgNubBQVDDyt9Sy/M2r+5u890V0XwRsSn8wHgcV5WlBAvMB0zzOHhtOmMMprYaN7 tn7lt7vK07VOmXUKP13cx5dUT190qs4vhiidGT7/w250RhnkUTftVybk+w8Yab1jH//y OIU9BZ+gPGUDU2nK/A2hlFR9ahaUxMgYJHX4pNbQpVO8Tk38XGclNcbQMyfeJf9YfKQZ WI0g== X-Gm-Message-State: ACgBeo2RaPE0aWrpvU0LPY3TW8aLxW9IZz6YM+06CDwp2+Ys47PpqsQx 2HLB/FYSlD+JQvH4XEaLWxNPenBFffko1g== X-Google-Smtp-Source: AA6agR78bzZisfZ0drPv6ybrqcD5TITpM0fySyKxyJSbQhB1P/u3DOYDlFf6RMW89glsYcrN546k8g== X-Received: by 2002:a05:6214:570d:b0:49e:3c24:ee9a with SMTP id lt13-20020a056214570d00b0049e3c24ee9amr13738615qvb.105.1662760477959; Fri, 09 Sep 2022 14:54:37 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id i2-20020a05620a248200b006bba46e5eeasm1524775qkn.37.2022.09.09.14.54.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:37 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 32/36] btrfs: get rid of extent_io_tree::dirty_bytes Date: Fri, 9 Sep 2022 17:53:45 -0400 Message-Id: <75f665e32cdf1682ca3ee2925878b1096cc35fd5.1662760286.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 was used as an optimization for count_range_bits(EXTENT_DIRTY), which was used by the failed record code. However this was removed here btrfs: convert the io_failure_tree to a plain rb_tree which was the last user of this optimization. Remove the ->dirty_bytes as nobody cares anymore. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 17 +---------------- fs/btrfs/extent-io-tree.h | 1 - 2 files changed, 1 insertion(+), 17 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 018fde078d78..3a89d338ddc6 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -98,7 +98,6 @@ void extent_io_tree_init(struct btrfs_fs_info *fs_info, { tree->fs_info = fs_info; tree->state = RB_ROOT; - tree->dirty_bytes = 0; spin_lock_init(&tree->lock); tree->private_data = private_data; tree->owner = owner; @@ -376,10 +375,6 @@ static void set_state_bits(struct extent_io_tree *tree, if (tree->private_data && is_data_inode(tree->private_data)) btrfs_set_delalloc_extent(tree->private_data, state, bits); - if ((bits_to_set & EXTENT_DIRTY) && !(state->state & EXTENT_DIRTY)) { - u64 range = state->end - state->start + 1; - tree->dirty_bytes += range; - } ret = add_extent_changeset(state, bits_to_set, changeset, 1); BUG_ON(ret < 0); state->state |= bits_to_set; @@ -514,12 +509,6 @@ static struct extent_state *clear_state_bit(struct extent_io_tree *tree, u32 bits_to_clear = bits & ~EXTENT_CTLBITS; int ret; - if ((bits_to_clear & EXTENT_DIRTY) && (state->state & EXTENT_DIRTY)) { - u64 range = state->end - state->start + 1; - WARN_ON(range > tree->dirty_bytes); - tree->dirty_bytes -= range; - } - if (tree->private_data && is_data_inode(tree->private_data)) btrfs_clear_delalloc_extent(tree->private_data, state, bits); @@ -1519,10 +1508,7 @@ u64 count_range_bits(struct extent_io_tree *tree, return 0; spin_lock(&tree->lock); - if (cur_start == 0 && bits == EXTENT_DIRTY) { - total_bytes = tree->dirty_bytes; - goto out; - } + /* * this search will find all the extents that end after * our range starts. @@ -1548,7 +1534,6 @@ u64 count_range_bits(struct extent_io_tree *tree, } state = next_state(state); } -out: spin_unlock(&tree->lock); return total_bytes; } diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 37543fb713bd..94574062eabe 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -69,7 +69,6 @@ struct extent_io_tree { struct rb_root state; struct btrfs_fs_info *fs_info; void *private_data; - u64 dirty_bytes; /* Who owns this io tree, should be one of IO_TREE_* */ u8 owner; From patchwork Fri Sep 9 21:53:46 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972219 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 17362ECAAD3 for ; Fri, 9 Sep 2022 21:54:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231947AbiIIVyt (ORCPT ); Fri, 9 Sep 2022 17:54:49 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59608 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231928AbiIIVyl (ORCPT ); Fri, 9 Sep 2022 17:54:41 -0400 Received: from mail-qt1-x82f.google.com (mail-qt1-x82f.google.com [IPv6:2607:f8b0:4864:20::82f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8205B13D44 for ; Fri, 9 Sep 2022 14:54:40 -0700 (PDT) Received: by mail-qt1-x82f.google.com with SMTP id cr9so2321610qtb.13 for ; Fri, 09 Sep 2022 14:54:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=+cvKfWDiZhslKUZD7t/TWW47wwwZwgmnyjsI8JiDq1U=; b=pPBybdTIutMZ4pEnztnqjB7nPr9xJppmRlDSxaaezjDvvbgUqW62TP8nBdYwrd+yM+ UPh4/c2qtOkIie1hReZz9tIsiqKiC5+l8eYLmi57DQnbNMN97Mr54/V9cjtFWuZGDIVJ zjTrbN7K3/rOjCYy9jzIS6LEBYFoDa7ZLaCKLKheri18L4ShKc53CLy91pK2nts1yRpM DI3BV19NN0G5rnaDrEGs8czfUzsoAAyy8wnKEPDziLd6MyPFUTM359BvFD/8NBJrydOZ 1tiBqGfjLF8vp7eB+jkImi5M/LSIx1r0TLicCY3JNeZp9oUkns/deue9SJtW11CSSFQr Vw1A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=+cvKfWDiZhslKUZD7t/TWW47wwwZwgmnyjsI8JiDq1U=; b=R5q3SO8OOLk8cgPdWLo0iSjabb0ieIkYay3yBXQ8Dqgy6ZtVSR5cyuBwM4ZU5bigkS NK7n8SKPTTubj299rDhxs+nGc6aULKBxG+pk/1iIZbXCfZwtkAJkvrSVkmRDBbjnXPgO nzh/LnE2FNeeLtjwH0mdeqmvEmJgF1djTHxs65d3rOaDA8kk4JZsCLbYULY2l77amyEd +Ckl8K2YzSSHIIsPonzxpp8oIUFJny8a9oym111DeCxY1fkjA7wmWUgqil8WK3kt1s1+ DZRuFInrITfwF4N0X9ffymzTH/u59AjQ51ZpumdHQNMJyXtQN4jro6rgx3UrQxksbirl sMEw== X-Gm-Message-State: ACgBeo1jNQBxiCjsrY0APNRqRyKrT3GMjcuF+tplrxB60REYdBxSO4ql 4ChII9mFQuzTDcvjAWhN0voRJlzWIhMl1Q== X-Google-Smtp-Source: AA6agR4TneYxtF+Ik8FndlxHY+m19nk9xfZe5U7cjsIxAyBWgp8LP848alzGifCECNFRiQdtyOTnwg== X-Received: by 2002:a05:622a:1743:b0:35b:a8d6:ff6e with SMTP id l3-20020a05622a174300b0035ba8d6ff6emr35988qtk.269.1662760479361; Fri, 09 Sep 2022 14:54:39 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id t2-20020ac865c2000000b00342f6c31da7sm1113949qto.94.2022.09.09.14.54.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:38 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 33/36] btrfs: don't clear CTL bits when trying to release extent state Date: Fri, 9 Sep 2022 17:53:46 -0400 Message-Id: <54da6f3356933057b122b7fa7f16008d8b57cd70.1662760286.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 When trying to release the extent states due to memory pressure we'll set all the bits except LOCKED, NODATASUM, and DELALLOC_NEW. This includes some of the CTL bits, which isn't really a problem but isn't correct either. Exclude the CTL bits from this clearing. Signed-off-by: Josef Bacik --- fs/btrfs/extent_io.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 597b89826f53..d69d9213da6a 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -3389,15 +3389,17 @@ static int try_release_extent_state(struct extent_io_tree *tree, if (test_range_bit(tree, start, end, EXTENT_LOCKED, 0, NULL)) { ret = 0; } else { + u32 clear_bits = ~(EXTENT_LOCKED | EXTENT_NODATASUM | + EXTENT_DELALLOC_NEW | EXTENT_CTLBITS); + /* * At this point we can safely clear everything except the * locked bit, the nodatasum bit and the delalloc new bit. * The delalloc new bit will be cleared by ordered extent * completion. */ - ret = __clear_extent_bit(tree, start, end, - ~(EXTENT_LOCKED | EXTENT_NODATASUM | EXTENT_DELALLOC_NEW), - 0, NULL, mask, NULL); + ret = __clear_extent_bit(tree, start, end, clear_bits, 0, NULL, + mask, NULL); /* if clear_extent_bit failed for enomem reasons, * we can't allow the release to continue. From patchwork Fri Sep 9 21:53:47 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972221 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 DC632C6FA89 for ; Fri, 9 Sep 2022 21:54:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231949AbiIIVyu (ORCPT ); Fri, 9 Sep 2022 17:54:50 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59764 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231932AbiIIVyn (ORCPT ); Fri, 9 Sep 2022 17:54:43 -0400 Received: from mail-qt1-x829.google.com (mail-qt1-x829.google.com [IPv6:2607:f8b0:4864:20::829]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1D8006312 for ; Fri, 9 Sep 2022 14:54:42 -0700 (PDT) Received: by mail-qt1-x829.google.com with SMTP id c11so2340425qtw.8 for ; Fri, 09 Sep 2022 14:54:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=HOB5AH3mO8rmv3k14eACviC/x0Vp/V0aiEyr0xOui3c=; b=3F+vdYK+1/UaRSIUf07OFwyWZAi9aZzV5B0xfW7+xH1WmeWdKPa21JoMzid0ODuVYI 5079VUhZYVqWq/wV86UTO8ti+VSUiHAhNiQt+4OTpDJgY4FUUYwwuAJhBgP6HyFfzlgX Y9r3hjcOJ0hrQrfMhXr9GorEwwv0E21L7H406+zht0NluLhXLaCJtKPFKic4I+RPlUQ1 5D7c1kp+6RZKCTjytKpVnUGHCob3dGW5B8B4bs7yMbL1YYjT4wPBXxS03dla3OBNgKHp /RXARW7sk+WVkZdy+2JENPf1gOUcpYzCthO5jQggNdG48H2gMlwKiefLKo7pD1awTqHI UW7Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=HOB5AH3mO8rmv3k14eACviC/x0Vp/V0aiEyr0xOui3c=; b=iditO7aFU7NRBX/0cHZuwR/abCt6e+JJv43faKRI/fHTmRuPsaFATceBs1rQfJU295 haHVDa9gpP1AMPgpn6LZUOr/pG557MKToB1noKhu67f0qm5vsoJHGvqNpDjpYhzGKKNH PK0CUK+YTnr3CwncIvz77qs+NxYLfb5fYi2va84kzQKINSTiT7jz/2yFEn7yPHalxGO/ JjLqunc1x8AtHeJAQah3cR5iV2wkfZcas2yOTwKhGp76RzGjYa7EfliwrWqoMUqVLCNJ f3tQldvJmmXnwvkHdN1XKlWdJ9R6dl+dCbxsoTjH8EzUmNlCcuGWUcFgRZVbuTriNVrx Dqbg== X-Gm-Message-State: ACgBeo1PXA0l1J5eqFEgQTzIjybrqHBmjNcYATl0UawzRo+H/pZWvAQ3 IJ+MQzbQcO3wu5LZp70JwrWys/E/qIEDOQ== X-Google-Smtp-Source: AA6agR7VrWeZK6Q0MuwUUpHRg8kK24zsK6J4HS/4pT+d/NDNTjPEvo+p1vwVzZhbzd/2WCkb3SgKkg== X-Received: by 2002:ac8:5853:0:b0:343:7b95:96ff with SMTP id h19-20020ac85853000000b003437b9596ffmr14726800qth.386.1662760480819; Fri, 09 Sep 2022 14:54:40 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id j4-20020a05620a0a4400b006b8e049cf08sm1272461qka.2.2022.09.09.14.54.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:40 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 34/36] btrfs: replace delete argument with EXTENT_CLEAR_ALL_BITS Date: Fri, 9 Sep 2022 17:53:47 -0400 Message-Id: <4cdff16fc22bc856920471ab599030d46864f182.1662760286.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 Instead of taking up a whole argument to indicate we're clearing everything in a range, simply add another EXTENT bit to control this, and then update all the callers to drop this argument from the clear_extent_bit variants. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 17 ++++++++------- fs/btrfs/extent-io-tree.h | 28 +++++++++++++++--------- fs/btrfs/extent_io.c | 4 ++-- fs/btrfs/extent_map.c | 2 +- fs/btrfs/file-item.c | 2 +- fs/btrfs/file.c | 2 +- fs/btrfs/free-space-cache.c | 6 +++--- fs/btrfs/inode.c | 41 +++++++++++++++++------------------- fs/btrfs/ioctl.c | 2 +- fs/btrfs/reflink.c | 2 +- fs/btrfs/tests/inode-tests.c | 8 +++---- fs/btrfs/transaction.c | 2 +- 12 files changed, 61 insertions(+), 55 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 3a89d338ddc6..482b6acc76a8 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -546,8 +546,7 @@ static struct extent_state *clear_state_bit(struct extent_io_tree *tree, * This takes the tree lock, and returns 0 on success and < 0 on error. */ int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, int delete, - struct extent_state **cached_state, + u32 bits, struct extent_state **cached_state, gfp_t mask, struct extent_changeset *changeset) { struct extent_state *state; @@ -556,17 +555,19 @@ int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u64 last_end; int err; int clear = 0; - int wake = (bits & EXTENT_LOCKED) ? 1 : 0; + int wake; + int delete = bits & EXTENT_CLEAR_ALL_BITS; btrfs_debug_check_extent_io_range(tree, start, end); trace_btrfs_clear_extent_bit(tree, start, end - start + 1, bits); - if (bits & EXTENT_DELALLOC) - bits |= EXTENT_NORESERVE; - if (delete) bits |= ~EXTENT_CTLBITS; + if (bits & EXTENT_DELALLOC) + bits |= EXTENT_NORESERVE; + + wake = (bits & EXTENT_LOCKED) ? 1 : 0; if (bits & (EXTENT_LOCKED | EXTENT_BOUNDARY)) clear = 1; again: @@ -1615,7 +1616,7 @@ int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, */ ASSERT(!(bits & EXTENT_LOCKED)); - return __clear_extent_bit(tree, start, end, bits, 0, NULL, GFP_NOFS, + return __clear_extent_bit(tree, start, end, bits, NULL, GFP_NOFS, changeset); } @@ -1629,7 +1630,7 @@ int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) if (err == -EEXIST) { if (failed_start > start) clear_extent_bit(tree, start, failed_start - 1, - EXTENT_LOCKED, 0, NULL); + EXTENT_LOCKED, NULL); return 0; } return 1; diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h index 94574062eabe..a8671116b59f 100644 --- a/fs/btrfs/extent-io-tree.h +++ b/fs/btrfs/extent-io-tree.h @@ -35,10 +35,18 @@ struct io_failure_record; * delalloc bytes decremented, in an atomic way to prevent races with stat(2). */ #define EXTENT_ADD_INODE_BYTES (1U << 15) + +/* + * Set during truncate when we're clearing an entire range and we just want the + * extent states to go away. + */ +#define EXTENT_CLEAR_ALL_BITS (1U << 16) + #define EXTENT_DO_ACCOUNTING (EXTENT_CLEAR_META_RESV | \ EXTENT_CLEAR_DATA_RESV) #define EXTENT_CTLBITS (EXTENT_DO_ACCOUNTING | \ - EXTENT_ADD_INODE_BYTES) + EXTENT_ADD_INODE_BYTES | \ + EXTENT_CLEAR_ALL_BITS) /* * Redefined bits above which are used only in the device allocation tree, @@ -114,35 +122,35 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, struct extent_changeset *changeset); int __clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, - u32 bits, int delete, struct extent_state **cached, - gfp_t mask, struct extent_changeset *changeset); + u32 bits, struct extent_state **cached, gfp_t mask, + struct extent_changeset *changeset); static inline int clear_extent_bit(struct extent_io_tree *tree, u64 start, - u64 end, u32 bits, int delete, + u64 end, u32 bits, struct extent_state **cached) { - return __clear_extent_bit(tree, start, end, bits, delete, cached, + return __clear_extent_bit(tree, start, end, bits, cached, GFP_NOFS, NULL); } static inline int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state **cached) { - return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, 0, cached, + return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, cached, GFP_NOFS, NULL); } static inline int unlock_extent_atomic(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state **cached) { - return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, 0, cached, + return __clear_extent_bit(tree, start, end, EXTENT_LOCKED, cached, GFP_ATOMIC, NULL); } static inline int clear_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits) { - return clear_extent_bit(tree, start, end, bits, 0, NULL); + return clear_extent_bit(tree, start, end, bits, NULL); } int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, @@ -165,7 +173,7 @@ static inline int set_extent_bits(struct extent_io_tree *tree, u64 start, static inline int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end, struct extent_state **cached_state) { - return __clear_extent_bit(tree, start, end, EXTENT_UPTODATE, 0, + return __clear_extent_bit(tree, start, end, EXTENT_UPTODATE, cached_state, GFP_NOFS, NULL); } @@ -180,7 +188,7 @@ static inline int clear_extent_dirty(struct extent_io_tree *tree, u64 start, { return clear_extent_bit(tree, start, end, EXTENT_DIRTY | EXTENT_DELALLOC | - EXTENT_DO_ACCOUNTING, 0, cached); + EXTENT_DO_ACCOUNTING, cached); } int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index d69d9213da6a..3bd4a6b065e9 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c @@ -487,7 +487,7 @@ void extent_clear_unlock_delalloc(struct btrfs_inode *inode, u64 start, u64 end, struct page *locked_page, u32 clear_bits, unsigned long page_ops) { - clear_extent_bit(&inode->io_tree, start, end, clear_bits, 0, NULL); + clear_extent_bit(&inode->io_tree, start, end, clear_bits, NULL); __process_pages_contig(inode->vfs_inode.i_mapping, locked_page, start, end, page_ops, NULL); @@ -3398,7 +3398,7 @@ static int try_release_extent_state(struct extent_io_tree *tree, * The delalloc new bit will be cleared by ordered extent * completion. */ - ret = __clear_extent_bit(tree, start, end, clear_bits, 0, NULL, + ret = __clear_extent_bit(tree, start, end, clear_bits, NULL, mask, NULL); /* if clear_extent_bit failed for enomem reasons, diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c index fae627c28d7c..d5640e695e6b 100644 --- a/fs/btrfs/extent_map.c +++ b/fs/btrfs/extent_map.c @@ -382,7 +382,7 @@ static void extent_map_device_clear_bits(struct extent_map *em, unsigned bits) __clear_extent_bit(&device->alloc_state, stripe->physical, stripe->physical + stripe_size - 1, bits, - 0, NULL, GFP_NOWAIT, NULL); + NULL, GFP_NOWAIT, NULL); } } diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c index d44e0d3c84cd..45949261c699 100644 --- a/fs/btrfs/file-item.c +++ b/fs/btrfs/file-item.c @@ -118,7 +118,7 @@ int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start, if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES)) return 0; return clear_extent_bit(&inode->file_extent_tree, start, - start + len - 1, EXTENT_DIRTY, 0, NULL); + start + len - 1, EXTENT_DIRTY, NULL); } static inline u32 max_ordered_sum_bytes(struct btrfs_fs_info *fs_info, diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c index eb5579d9a3e0..fea508a35900 100644 --- a/fs/btrfs/file.c +++ b/fs/btrfs/file.c @@ -473,7 +473,7 @@ int btrfs_dirty_pages(struct btrfs_inode *inode, struct page **pages, */ clear_extent_bit(&inode->io_tree, start_pos, end_of_last_block, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, - 0, cached); + cached); err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block, extra_bits, cached); diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c index ecef1ba816c3..7859eeca484c 100644 --- a/fs/btrfs/free-space-cache.c +++ b/fs/btrfs/free-space-cache.c @@ -1163,7 +1163,7 @@ update_cache_item(struct btrfs_trans_handle *trans, ret = btrfs_search_slot(trans, root, &key, path, 0, 1); if (ret < 0) { clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, inode->i_size - 1, - EXTENT_DELALLOC, 0, NULL); + EXTENT_DELALLOC, NULL); goto fail; } leaf = path->nodes[0]; @@ -1175,7 +1175,7 @@ update_cache_item(struct btrfs_trans_handle *trans, if (found_key.objectid != BTRFS_FREE_SPACE_OBJECTID || found_key.offset != offset) { clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, - inode->i_size - 1, EXTENT_DELALLOC, 0, + inode->i_size - 1, EXTENT_DELALLOC, NULL); btrfs_release_path(path); goto fail; @@ -1272,7 +1272,7 @@ static int flush_dirty_cache(struct inode *inode) ret = btrfs_wait_ordered_range(inode, 0, (u64)-1); if (ret) clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, inode->i_size - 1, - EXTENT_DELALLOC, 0, NULL); + EXTENT_DELALLOC, NULL); return ret; } diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index c417bbc29986..39f00b68b3a8 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -1747,7 +1747,7 @@ static int fallback_to_cow(struct btrfs_inode *inode, struct page *locked_page, if (count > 0) clear_extent_bit(io_tree, start, end, EXTENT_NORESERVE, - 0, NULL); + NULL); } return cow_file_range(inode, locked_page, start, end, page_started, @@ -3323,7 +3323,7 @@ int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent) !test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) clear_extent_bit(&inode->io_tree, start, end, EXTENT_DELALLOC_NEW | EXTENT_ADD_INODE_BYTES, - 0, &cached_state); + &cached_state); btrfs_inode_safe_disk_i_size_write(inode, 0); ret = btrfs_update_inode_fallback(trans, root, inode); @@ -3333,7 +3333,7 @@ int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent) } ret = 0; out: - clear_extent_bit(&inode->io_tree, start, end, clear_bits, 0, + clear_extent_bit(&inode->io_tree, start, end, clear_bits, &cached_state); if (trans) @@ -4933,7 +4933,7 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len, clear_extent_bit(&inode->io_tree, block_start, block_end, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, - 0, &cached_state); + &cached_state); ret = btrfs_set_extent_delalloc(inode, block_start, block_end, 0, &cached_state); @@ -5347,8 +5347,7 @@ static void evict_inode_truncate_pages(struct inode *inode) end - start + 1); clear_extent_bit(io_tree, start, end, - EXTENT_LOCKED | EXTENT_DELALLOC | - EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, + EXTENT_CLEAR_ALL_BITS | EXTENT_DO_ACCOUNTING, &cached_state); cond_resched(); @@ -8275,9 +8274,9 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, cur = page_start; while (cur < page_end) { struct btrfs_ordered_extent *ordered; - bool delete_states; u64 range_end; u32 range_len; + u32 extra_flags = 0; ordered = btrfs_lookup_first_ordered_range(inode, cur, page_end + 1 - cur); @@ -8287,7 +8286,7 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, * No ordered extent covering this range, we are safe * to delete all extent states in the range. */ - delete_states = true; + extra_flags = EXTENT_CLEAR_ALL_BITS; goto next; } if (ordered->file_offset > cur) { @@ -8298,7 +8297,7 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, * the ordered extent in the next iteration. */ range_end = ordered->file_offset - 1; - delete_states = true; + extra_flags = EXTENT_CLEAR_ALL_BITS; goto next; } @@ -8313,7 +8312,6 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, * We can't delete the extent states as * btrfs_finish_ordered_io() may still use some of them. */ - delete_states = false; goto next; } btrfs_page_clear_ordered(fs_info, &folio->page, cur, range_len); @@ -8330,7 +8328,7 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, clear_extent_bit(tree, cur, range_end, EXTENT_DELALLOC | EXTENT_LOCKED | EXTENT_DO_ACCOUNTING | - EXTENT_DEFRAG, 0, &cached_state); + EXTENT_DEFRAG, &cached_state); spin_lock_irq(&inode->ordered_tree.lock); set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags); @@ -8338,6 +8336,12 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, cur - ordered->file_offset); spin_unlock_irq(&inode->ordered_tree.lock); + /* + * If the ordered extent has finished, we're safe to delete all + * the extent states of the range, otherwise + * btrfs_finish_ordered_io() will get executed by endio for + * other pages, so we can't delete extent states. + */ if (btrfs_dec_test_ordered_pending(inode, &ordered, cur, range_end + 1 - cur)) { btrfs_finish_ordered_io(ordered); @@ -8345,14 +8349,7 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, * The ordered extent has finished, now we're again * safe to delete all extent states of the range. */ - delete_states = true; - } else { - /* - * btrfs_finish_ordered_io() will get executed by endio - * of other pages, thus we can't delete extent states - * anymore - */ - delete_states = false; + extra_flags = EXTENT_CLEAR_ALL_BITS; } next: if (ordered) @@ -8376,8 +8373,8 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset, if (!inode_evicting) { clear_extent_bit(tree, cur, range_end, EXTENT_LOCKED | EXTENT_DELALLOC | EXTENT_UPTODATE | - EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, - delete_states, &cached_state); + EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG | + extra_flags, &cached_state); } cur = range_end + 1; } @@ -8511,7 +8508,7 @@ vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) */ clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | - EXTENT_DEFRAG, 0, &cached_state); + EXTENT_DEFRAG, &cached_state); ret2 = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0, &cached_state); diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c index d59e1f1b762e..d5dd8bed1488 100644 --- a/fs/btrfs/ioctl.c +++ b/fs/btrfs/ioctl.c @@ -1616,7 +1616,7 @@ static int defrag_one_locked_target(struct btrfs_inode *inode, return ret; clear_extent_bit(&inode->io_tree, start, start + len - 1, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | - EXTENT_DEFRAG, 0, cached_state); + EXTENT_DEFRAG, cached_state); set_extent_defrag(&inode->io_tree, start, start + len - 1, cached_state); /* Update the page status */ diff --git a/fs/btrfs/reflink.c b/fs/btrfs/reflink.c index 7a0db71d683b..f50586ff85c8 100644 --- a/fs/btrfs/reflink.c +++ b/fs/btrfs/reflink.c @@ -92,7 +92,7 @@ static int copy_inline_to_page(struct btrfs_inode *inode, clear_extent_bit(&inode->io_tree, file_offset, range_end, EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, - 0, NULL); + NULL); ret = btrfs_set_extent_delalloc(inode, file_offset, range_end, 0, NULL); if (ret) goto out_unlock; diff --git a/fs/btrfs/tests/inode-tests.c b/fs/btrfs/tests/inode-tests.c index eeba3deb7714..b1c88dd187cb 100644 --- a/fs/btrfs/tests/inode-tests.c +++ b/fs/btrfs/tests/inode-tests.c @@ -975,7 +975,7 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) BTRFS_MAX_EXTENT_SIZE >> 1, (BTRFS_MAX_EXTENT_SIZE >> 1) + sectorsize - 1, EXTENT_DELALLOC | EXTENT_DELALLOC_NEW | - EXTENT_UPTODATE, 0, NULL); + EXTENT_UPTODATE, NULL); if (ret) { test_err("clear_extent_bit returned %d", ret); goto out; @@ -1043,7 +1043,7 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) BTRFS_MAX_EXTENT_SIZE + sectorsize, BTRFS_MAX_EXTENT_SIZE + 2 * sectorsize - 1, EXTENT_DELALLOC | EXTENT_DELALLOC_NEW | - EXTENT_UPTODATE, 0, NULL); + EXTENT_UPTODATE, NULL); if (ret) { test_err("clear_extent_bit returned %d", ret); goto out; @@ -1076,7 +1076,7 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) /* Empty */ ret = clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, (u64)-1, EXTENT_DELALLOC | EXTENT_DELALLOC_NEW | - EXTENT_UPTODATE, 0, NULL); + EXTENT_UPTODATE, NULL); if (ret) { test_err("clear_extent_bit returned %d", ret); goto out; @@ -1092,7 +1092,7 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) if (ret) clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, (u64)-1, EXTENT_DELALLOC | EXTENT_DELALLOC_NEW | - EXTENT_UPTODATE, 0, NULL); + EXTENT_UPTODATE, NULL); iput(inode); btrfs_free_dummy_root(root); btrfs_free_dummy_fs_info(fs_info); diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c index 83f3d4b89faa..d9d770a9b1a3 100644 --- a/fs/btrfs/transaction.c +++ b/fs/btrfs/transaction.c @@ -1116,7 +1116,7 @@ static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info, * it's safe to do it (through extent_io_tree_release()). */ err = clear_extent_bit(dirty_pages, start, end, - EXTENT_NEED_WAIT, 0, &cached_state); + EXTENT_NEED_WAIT, &cached_state); if (err == -ENOMEM) err = 0; if (!err) From patchwork Fri Sep 9 21:53:48 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972222 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 A348EECAAD3 for ; Fri, 9 Sep 2022 21:54:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231965AbiIIVyv (ORCPT ); Fri, 9 Sep 2022 17:54:51 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59766 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231935AbiIIVyn (ORCPT ); Fri, 9 Sep 2022 17:54:43 -0400 Received: from mail-qt1-x832.google.com (mail-qt1-x832.google.com [IPv6:2607:f8b0:4864:20::832]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id ED79564D9 for ; Fri, 9 Sep 2022 14:54:42 -0700 (PDT) Received: by mail-qt1-x832.google.com with SMTP id r20so1646086qtn.12 for ; Fri, 09 Sep 2022 14:54:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=R6sSghnkFEtwnvrI7PXxc4RCmgEq1lnqxgHI5XM24Zk=; b=wrgw1oEowKgJdOsqUBlL/YGqan0tO/yxepaHisWxfcoF6AhDPqlTsBPSJalmIvze3r 1Q1Tz5o5VD6CEID4U7J38jAC6wjCUEizltb7syO8RBzSGlsSW4oC/4D4yJ+JIiApCdG2 t10kRcRTtPKkiLHmyjv1QHRKE+ImCSPOrZfjlfOIizv5Jt939mIGiIgjr5oi0fwg3SZM y3jcisBWec5JtqGiwdDSwSsVAnaK+RCAZd9L5qpimX2yL8amck7a8fX8g9XUDsFP2TXC FNEvQ/3LFXeuuTTYBbdGDB3hj8oTTZsSBJb+HQCmliroWEvZJyRfpBd+VymPhVOJACRF IZzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=R6sSghnkFEtwnvrI7PXxc4RCmgEq1lnqxgHI5XM24Zk=; b=xjfsUdRMGrAEJSELL1QzC59MiSJ9bGjgjwsT5E5KbSwMpFtBjQiafCEitvITNA/DUq wfsZrb6VR70PXYnkpdNXmXGTrajjnMs0Hgb1jsmQ/Winr7so68y/ZrhtjBwBodA6ErLs YCGj7THo4J0/nBNuGEAgp9fRkhTlm0vqezumUV7m74ZG99fC3uhgfDiYmfstQI9wMcMD drKzGD4p9U2MALrmkssBKNskDUKlYPsXhU2idn1bdaMHuFadhLMYDro384wVMZ9b6mjO H8PFAFcZh7jLqaEjnZW9010nDcRsI6DW/t84gMH4MCUEhUdQjzlnzpxRBYJ/fTv3i/h5 uJEw== X-Gm-Message-State: ACgBeo01YW5dTKpZSdk58hBToQsR3AOUTcvbCOBvBWtLNH8zE434bjgt WDRGcoNLbyKL1D4wIuEthJ9TSAM59OOSLQ== X-Google-Smtp-Source: AA6agR5AHnPnwKJm1lr7ZaDSO5Jzmp+/DuqpGBizlqrRodyELTNULcOzAI45SifgOWZSbXParsJFqg== X-Received: by 2002:ac8:5a11:0:b0:35b:a2ec:2b73 with SMTP id n17-20020ac85a11000000b0035ba2ec2b73mr3539979qta.364.1662760482298; Fri, 09 Sep 2022 14:54:42 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id r4-20020a05620a298400b006b5e50057basm1502671qkp.95.2022.09.09.14.54.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:41 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 35/36] btrfs: don't init io tree with private data for non inodes Date: Fri, 9 Sep 2022 17:53:48 -0400 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 only use this for normal inodes, so don't set it if we're not a normal inode. Signed-off-by: Josef Bacik --- fs/btrfs/disk-io.c | 2 +- fs/btrfs/inode.c | 2 +- fs/btrfs/transaction.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c index eedb39d89be5..db8212cc1d2e 100644 --- a/fs/btrfs/disk-io.c +++ b/fs/btrfs/disk-io.c @@ -2231,7 +2231,7 @@ static void btrfs_init_btree_inode(struct btrfs_fs_info *fs_info) RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node); extent_io_tree_init(fs_info, &BTRFS_I(inode)->io_tree, - IO_TREE_BTREE_INODE_IO, inode); + IO_TREE_BTREE_INODE_IO, NULL); extent_map_tree_init(&BTRFS_I(inode)->extent_tree); BTRFS_I(inode)->root = btrfs_grab_root(fs_info->tree_root); diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 39f00b68b3a8..6fde13f62c1d 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -8800,7 +8800,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb) extent_map_tree_init(&ei->extent_tree); extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO, inode); extent_io_tree_init(fs_info, &ei->file_extent_tree, - IO_TREE_INODE_FILE_EXTENT, inode); + IO_TREE_INODE_FILE_EXTENT, NULL); ei->io_failure_tree = RB_ROOT; atomic_set(&ei->sync_writers, 0); mutex_init(&ei->log_mutex); diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c index d9d770a9b1a3..d1f1da6820fb 100644 --- a/fs/btrfs/transaction.c +++ b/fs/btrfs/transaction.c @@ -365,7 +365,7 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info, spin_lock_init(&cur_trans->releasing_ebs_lock); list_add_tail(&cur_trans->list, &fs_info->trans_list); extent_io_tree_init(fs_info, &cur_trans->dirty_pages, - IO_TREE_TRANS_DIRTY_PAGES, fs_info->btree_inode); + IO_TREE_TRANS_DIRTY_PAGES, NULL); extent_io_tree_init(fs_info, &cur_trans->pinned_extents, IO_TREE_FS_PINNED_EXTENTS, NULL); fs_info->generation++; From patchwork Fri Sep 9 21:53:49 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Josef Bacik X-Patchwork-Id: 12972223 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 2628CECAAA1 for ; Fri, 9 Sep 2022 21:54:54 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231950AbiIIVyw (ORCPT ); Fri, 9 Sep 2022 17:54:52 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59948 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231942AbiIIVyq (ORCPT ); Fri, 9 Sep 2022 17:54:46 -0400 Received: from mail-qk1-x732.google.com (mail-qk1-x732.google.com [IPv6:2607:f8b0:4864:20::732]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 376892655C for ; Fri, 9 Sep 2022 14:54:45 -0700 (PDT) Received: by mail-qk1-x732.google.com with SMTP id b2so2199763qkh.12 for ; Fri, 09 Sep 2022 14:54:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=toxicpanda-com.20210112.gappssmtp.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:from:to:cc:subject:date; bh=6OwoWh+JnOQuT26jqTAkgxqtvtXcwjDBgHhYvJ6LX9E=; b=Kwb50TdzC5lIxSqqA1qiGRhYZ6t/Br8q3Z577h4rt3OURdE3IFfTqF/kX5z3oxeom6 cf0rEY+6lIvipBd2ZJ0SleaOZIY0Ks3JkeHy2Kcs7nLRiEE3RiYq/Wf4I/b4XtK68D/4 eueYApCQ3eX7m7zDVzt/6qYORexnmmnE7PCZontxd8GmnRNWfPZaJixLq/80G/u5c92Z 3TYMWvat74O994i+KxVQ/MQfhei85PBZOxJcjNHAOXF8uscYV8Lx69F3tWC+1+hlQ0zb QlALdPVUvhM7VQIBZNvlLU4K3XuNBwDUOBDxLMh2fL/b8MM71MMaUXjaPdWfDJGRdLm0 gXMQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date; bh=6OwoWh+JnOQuT26jqTAkgxqtvtXcwjDBgHhYvJ6LX9E=; b=R1E53hd4UEuVUM/86TcAKu5Y+uYwifpKjV98tM0UA9ZDlm9cZIkirdXaX/5I6aR6hm AOirvMIgChhWoZtBlOsAG8JoXRAGTGh9KQAwBqX/25444aVU1rqxVuPdD4AtHDaA0ShX HIb+7DrkmuBc/ECK2/7/Qd8WewOxtzwxmhXyQt0qBVHgT1bYTf8pso0dQdv/a8aPW3Rh xSeItlab9mfLJRsd75gxYMQXH5vwrI4qlEy3y8Ocq8wEV0okRQXRaQk+Xw+wslTQAQYe y7ewjuRNMt/A31NHk5xIzRJt13PZVzjcsnaiVmE7sOXvr9znVuz5PD9OgVJyugV8tio5 JeKQ== X-Gm-Message-State: ACgBeo2rtRWctkaQ85XztOFE+OQJx2KiL98D5V7SwDAUGpwEJMAxFbXC 0beQtHFv9m7zvMYM3ElkPkBnavWKJ7Lyyg== X-Google-Smtp-Source: AA6agR7cTV+7zAGkjybf7fALFVyLKbjlo2QXgsFY4xLixvemCIrEsOY5ygqjaiLJJmmEpnyxnCe4+Q== X-Received: by 2002:a05:620a:2408:b0:6c5:df5a:124 with SMTP id d8-20020a05620a240800b006c5df5a0124mr11862374qkn.753.1662760483992; Fri, 09 Sep 2022 14:54:43 -0700 (PDT) Received: from localhost (cpe-174-109-172-136.nc.res.rr.com. [174.109.172.136]) by smtp.gmail.com with ESMTPSA id y12-20020a05620a44cc00b006b942f4ffe3sm1482215qkp.18.2022.09.09.14.54.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Sep 2022 14:54:43 -0700 (PDT) From: Josef Bacik To: linux-btrfs@vger.kernel.org, kernel-team@fb.com Subject: [PATCH v2 36/36] btrfs: remove is_data_inode() checks in extent-io-tree.c Date: Fri, 9 Sep 2022 17:53:49 -0400 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're only init'ing extent_io_tree's with a private data if we're a normal inode, so we don't need this extra check. Signed-off-by: Josef Bacik --- fs/btrfs/extent-io-tree.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c index 482b6acc76a8..500ee1f12db6 100644 --- a/fs/btrfs/extent-io-tree.c +++ b/fs/btrfs/extent-io-tree.c @@ -60,7 +60,7 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller, struct inode *inode = tree->private_data; u64 isize; - if (!inode || !is_data_inode(inode)) + if (!inode) return; isize = i_size_read(inode); @@ -344,7 +344,7 @@ static void merge_state(struct extent_io_tree *tree, struct extent_state *state) other = prev_state(state); if (other && other->end == state->start - 1 && other->state == state->state) { - if (tree->private_data && is_data_inode(tree->private_data)) + if (tree->private_data) btrfs_merge_delalloc_extent(tree->private_data, state, other); state->start = other->start; @@ -355,7 +355,7 @@ static void merge_state(struct extent_io_tree *tree, struct extent_state *state) other = next_state(state); if (other && other->start == state->end + 1 && other->state == state->state) { - if (tree->private_data && is_data_inode(tree->private_data)) + if (tree->private_data) btrfs_merge_delalloc_extent(tree->private_data, state, other); state->end = other->end; @@ -372,7 +372,7 @@ static void set_state_bits(struct extent_io_tree *tree, u32 bits_to_set = bits & ~EXTENT_CTLBITS; int ret; - if (tree->private_data && is_data_inode(tree->private_data)) + if (tree->private_data) btrfs_set_delalloc_extent(tree->private_data, state, bits); ret = add_extent_changeset(state, bits_to_set, changeset, 1); @@ -460,7 +460,7 @@ static int split_state(struct extent_io_tree *tree, struct extent_state *orig, struct rb_node *parent = NULL; struct rb_node **node; - if (tree->private_data && is_data_inode(tree->private_data)) + if (tree->private_data) btrfs_split_delalloc_extent(tree->private_data, orig, split); prealloc->start = orig->start; @@ -509,7 +509,7 @@ static struct extent_state *clear_state_bit(struct extent_io_tree *tree, u32 bits_to_clear = bits & ~EXTENT_CTLBITS; int ret; - if (tree->private_data && is_data_inode(tree->private_data)) + if (tree->private_data) btrfs_clear_delalloc_extent(tree->private_data, state, bits); ret = add_extent_changeset(state, bits_to_clear, changeset, 0);