From patchwork Mon Jul 4 07:06:50 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651788 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=hHrp1FTU; dkim-atps=neutral Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4LbxhD6yHdz9s5V for ; Mon, 4 Jul 2022 17:07:24 +1000 (AEST) Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxhD6H5Lz4xLX for ; Mon, 4 Jul 2022 17:07:24 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4LbxhD6DzGz4xTq; Mon, 4 Jul 2022 17:07:24 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=hHrp1FTU; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxhD69wBz4xLX for ; Mon, 4 Jul 2022 17:07:24 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231432AbiGDHHY (ORCPT ); Mon, 4 Jul 2022 03:07:24 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37146 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229693AbiGDHHW (ORCPT ); Mon, 4 Jul 2022 03:07:22 -0400 Received: from mail-pl1-x62c.google.com (mail-pl1-x62c.google.com [IPv6:2607:f8b0:4864:20::62c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D6F0DBD7 for ; Mon, 4 Jul 2022 00:07:21 -0700 (PDT) Received: by mail-pl1-x62c.google.com with SMTP id o18so7817067plg.2 for ; Mon, 04 Jul 2022 00:07:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=RYM4b6lt8jh5/3brBWmnUhsaWASumVZ8o9hRWq/JLgg=; b=hHrp1FTUtlaRKLKOWvaxvyzLaj7/iDF9Jma+T3CbR3wfJdPdHtKpAlIosL77te+LIv 9xvw8nO3mEM7KBtv5EUZ4c/7hlRsVYjJLqt+Oob55U/2QIPWFAPSqS5DktYi5/cckVA1 epLs2GVN26TfLgSxTTqk1gADHKTySr3CKx9hswYh1PVE5BduBPFKs5sxJOveRflLe/M6 /ycGCLQLpVyl9VPO8oa50PmmPVWyn6agC2xoJ9F6CN4lRiNy2zyU/Q6KeA0E+chazZjo EAb7zKAQCt/Oh75sGIQdKrtWhSZZrH+kLWT6v8JzB9Ax53tKyNScXJ8tH7Ao03+kWTmL ZD3w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=RYM4b6lt8jh5/3brBWmnUhsaWASumVZ8o9hRWq/JLgg=; b=0i6GJhLcdAuuCE9ieqystfTR/j9ENAIOPddM1qaEHW4qztFHioBc0tXgGbhiN8XE5r 6aotNztFXiVeFN/k5aSYVNMeu5jHENSx1WjLsuyNRcDB5U88qpmABzDKpK0GfqezLtsf aUCbfEXjYxgym3qYeQwK1O/IMSViEUmgp7oWHTCVSH12KmHog0jY1OzZTV9L959faH0r JyV5Qtai4WgRDpXQLzw6H7ptQqm/1xEtFZYS1NrYQQZNuXhgur94SAwy/AF8Zf+SdIb9 ks5fH2WkPQ5gGhT8fT8i9WpIyI0n+AwKQZmSPZv6tyE9pExrNLfUbAfgo2/1QFuwQUnQ B9AA== X-Gm-Message-State: AJIora/uR3gsxQGz2A4+u0f5k4UXaft/Du50Ugb2IT7T1NR8y+iJ9A6B qv198p+7Edl0Gwh78M0oVgLX9WGEtak= X-Google-Smtp-Source: AGRyM1vCzNkrEoZlfhDjsbkJA0KP1CeemWzdKNUaGUbVXQ0tJ2Htz9wdOs3cZGMGu/axcV67obuclg== X-Received: by 2002:a17:90a:66c1:b0:1e8:43ae:f7c0 with SMTP id z1-20020a17090a66c100b001e843aef7c0mr32464061pjl.245.1656918441382; Mon, 04 Jul 2022 00:07:21 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id n10-20020a170902e54a00b0016191b843e2sm20346532plf.235.2022.07.04.00.07.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:07:21 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Ritesh Harjani Subject: [RFC 01/13] gen_bitmaps: Fix ext2fs_compare_generic_bmap/bitmap logic Date: Mon, 4 Jul 2022 12:36:50 +0530 Message-Id: <39eb8ba0a5a0adb7250a595e33460b16d6c5066f.1656912918.git.ritesh.list@gmail.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org Currently this function was not correctly comparing against the right length of the bitmap. Also when we compare bitarray v/s rbtree bitmap the value returned by ext2fs_test_generic_bmap() could be different in these two implementations. Hence only check against boolean value. Signed-off-by: Ritesh Harjani --- lib/ext2fs/gen_bitmap.c | 9 ++++++--- lib/ext2fs/gen_bitmap64.c | 10 +++++++--- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/lib/ext2fs/gen_bitmap.c b/lib/ext2fs/gen_bitmap.c index 1536d4b3..f7764fca 100644 --- a/lib/ext2fs/gen_bitmap.c +++ b/lib/ext2fs/gen_bitmap.c @@ -385,10 +385,13 @@ errcode_t ext2fs_compare_generic_bitmap(errcode_t magic, errcode_t neq, (size_t) (bm1->end - bm1->start)/8))) return neq; - for (i = bm1->end - ((bm1->end - bm1->start) % 8); i <= bm1->end; i++) - if (ext2fs_fast_test_block_bitmap(gen_bm1, i) != - ext2fs_fast_test_block_bitmap(gen_bm2, i)) + for (i = bm1->start; i <= bm1->end; i++) { + int ret1, ret2; + ret1 = !!ext2fs_fast_test_block_bitmap(gen_bm1, i); + ret2 = !!ext2fs_fast_test_block_bitmap(gen_bm2, i); + if (ret1 != ret2) return neq; + } return 0; } diff --git a/lib/ext2fs/gen_bitmap64.c b/lib/ext2fs/gen_bitmap64.c index d9809084..90c700ca 100644 --- a/lib/ext2fs/gen_bitmap64.c +++ b/lib/ext2fs/gen_bitmap64.c @@ -629,10 +629,14 @@ errcode_t ext2fs_compare_generic_bmap(errcode_t neq, (bm1->end != bm2->end)) return neq; - for (i = bm1->end - ((bm1->end - bm1->start) % 8); i <= bm1->end; i++) - if (ext2fs_test_generic_bmap(gen_bm1, i) != - ext2fs_test_generic_bmap(gen_bm2, i)) + for (i = bm1->start; i < bm1->end; i++) { + int ret1, ret2; + ret1 = !!ext2fs_test_generic_bmap(gen_bm1, i); + ret2 = !!ext2fs_test_generic_bmap(gen_bm2, i); + if (ret1 != ret2) { return neq; + } + } return 0; } From patchwork Mon Jul 4 07:06:51 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651789 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=TyECdMOw; dkim-atps=neutral Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4LbxhP4HVsz9s5V for ; Mon, 4 Jul 2022 17:07:33 +1000 (AEST) Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxhP3b7jz4xLX for ; Mon, 4 Jul 2022 17:07:33 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4LbxhP3Xk8z4xTq; Mon, 4 Jul 2022 17:07:33 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=TyECdMOw; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxhP3TGvz4xLX for ; Mon, 4 Jul 2022 17:07:33 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231490AbiGDHH2 (ORCPT ); Mon, 4 Jul 2022 03:07:28 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37186 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229693AbiGDHH1 (ORCPT ); Mon, 4 Jul 2022 03:07:27 -0400 Received: from mail-pf1-x42e.google.com (mail-pf1-x42e.google.com [IPv6:2607:f8b0:4864:20::42e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C6052E59 for ; Mon, 4 Jul 2022 00:07:26 -0700 (PDT) Received: by mail-pf1-x42e.google.com with SMTP id y141so8144723pfb.7 for ; Mon, 04 Jul 2022 00:07:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ClUzsN3Fm289Jwfth+qW4A+dENSlWPnbU1nlePrBKkU=; b=TyECdMOwayp+9bygjrMGlQ4isEHZaodr5yuKGIwvsmymiDabqq8mm88DZgqBV2rdKB zxma78Kl4AiX26eQ1TzdSW9JFXpO+0i1UXdhU3hhYKtgpUJVYQjhAbWm6rGAq8KPeKUh wJ6mwQeDtCkaIqcxOztkEPUBQ2TgtQv00Uprj3ljNkR32k2TptLf9sRnwvsbCxVSVLTe B61ygId8unC/0VsskMkdA3jh42tvirqFjBsRexC2ihvVKAiohCbl1ED49qD6c4cSQ9UO HehICoBT0NvK/PI/vX2WY9m2SDDiMMzMFlEp+05OBgXQ0M9Smtpm2GRQFbSgyA+B6lpU T6XQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ClUzsN3Fm289Jwfth+qW4A+dENSlWPnbU1nlePrBKkU=; b=ALW6E3TNU51pa8pJ4Xz6uTMc9p/Zi///9e59pClOtf0NZ0/5a4r0G4spkowG9po99y 4iKvb+bW4o1uZBJnKh98phtObZ6YEoi1ZW/ET422HV1faaSOB/zkluHqVAeLPeCFx9UE pw2OGYNXerCQPFa1U1HKCrQbzFL9+87hC5i19HC60v3Dl/WE2jIsYi+UIJxLNgjSVQ8M 7JAYrADK51Z2h8wnmqSDO/IyyLSUPz+hx7FadRRFrtDsC6gNEVOIR+HvUC47tNenHmt+ Mpv6buSjfDl15EraZB4+kbvVCidRaR/G6yNvQhNOwjq+KDjsQL+Pv/1WLeVMt3NZq1H7 Hu+g== X-Gm-Message-State: AJIora9KZgnq+N6P4UjFt6gEYVkRMvjahiCnANk3V1W+OcSyTYIEltcg Sq1uZJJgjCK5yINkFJHXzR0= X-Google-Smtp-Source: AGRyM1vu8VZpwb3iueEEcW+4Pv74wj3VtnOMoeYrmUQgQjM5FDxJMmMkasJ5fz+kkhagWw5YK+NZww== X-Received: by 2002:a05:6a00:13a5:b0:525:1da8:4af4 with SMTP id t37-20020a056a0013a500b005251da84af4mr34847905pfg.43.1656918446295; Mon, 04 Jul 2022 00:07:26 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id b7-20020a62cf07000000b0051835ccc008sm20297797pfg.115.2022.07.04.00.07.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:07:26 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Ritesh Harjani Subject: [RFC 02/13] badblocks: Remove unused badblocks_flags Date: Mon, 4 Jul 2022 12:36:51 +0530 Message-Id: <49dc04a33aa0432b3ca512dbb0bd7509cb0cd1c3.1656912918.git.ritesh.list@gmail.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org badblocks_flags is not used anywhere. So just remove it. Signed-off-by: Ritesh Harjani --- lib/ext2fs/badblocks.c | 6 +----- lib/ext2fs/ext2fsP.h | 1 - 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/lib/ext2fs/badblocks.c b/lib/ext2fs/badblocks.c index 0f23983b..0570b131 100644 --- a/lib/ext2fs/badblocks.c +++ b/lib/ext2fs/badblocks.c @@ -81,11 +81,7 @@ errcode_t ext2fs_u32_copy(ext2_u32_list src, ext2_u32_list *dest) { errcode_t retval; - retval = make_u32_list(src->size, src->num, src->list, dest); - if (retval) - return retval; - (*dest)->badblocks_flags = src->badblocks_flags; - return 0; + return make_u32_list(src->size, src->num, src->list, dest); } errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src, diff --git a/lib/ext2fs/ext2fsP.h b/lib/ext2fs/ext2fsP.h index a20a0502..d2045af8 100644 --- a/lib/ext2fs/ext2fsP.h +++ b/lib/ext2fs/ext2fsP.h @@ -34,7 +34,6 @@ struct ext2_struct_u32_list { int num; int size; __u32 *list; - int badblocks_flags; }; struct ext2_struct_u32_iterate { From patchwork Mon Jul 4 07:06:52 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651790 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=nKKV59eq; dkim-atps=neutral Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4LbxhQ1zFwz9sFr for ; Mon, 4 Jul 2022 17:07:34 +1000 (AEST) Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxhQ1Gk5z4xLX for ; Mon, 4 Jul 2022 17:07:34 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4LbxhQ1D3Zz4xTq; Mon, 4 Jul 2022 17:07:34 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=nKKV59eq; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxhQ17Ffz4xLX for ; Mon, 4 Jul 2022 17:07:34 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232611AbiGDHHd (ORCPT ); Mon, 4 Jul 2022 03:07:33 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37212 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232546AbiGDHHc (ORCPT ); Mon, 4 Jul 2022 03:07:32 -0400 Received: from mail-pf1-x42f.google.com (mail-pf1-x42f.google.com [IPv6:2607:f8b0:4864:20::42f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6F104E66 for ; Mon, 4 Jul 2022 00:07:31 -0700 (PDT) Received: by mail-pf1-x42f.google.com with SMTP id d17so8139859pfq.9 for ; Mon, 04 Jul 2022 00:07:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=9W3gRWmGUweo497W/5hFRRz/NYJ+5R4fTtzWnF2at2E=; b=nKKV59eqrRGyihZiPUos1JCkNwWlbj4nSA4W3XfrejIVu48f7af7Iv/6RrX2YPoOiz FUTg69Bed8gQYhkRm/EytrzpAXUo1JNJ7j9uwoUwX4Jf6l76ev7INsw0m3m8oE7qMTP3 zeGpeSB93C1BVIWy1AxUmGQi7xgv3MNEZqQEDOuMxO3x8jJUswCyXFzKnwPv+3lFKflI wTi55zWvn1OZkru297UXm7U2GQmvtdVuS4LpErKr7F67D81m2DgVVn2Xt46/jsBRABbQ R+Ss8tW+SxqszH4+J3eu1O7b+8FArwEc+b9MwyVF4xVraRF98XPdTFdx7lCFkGhZjT7S XdkA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=9W3gRWmGUweo497W/5hFRRz/NYJ+5R4fTtzWnF2at2E=; b=avmJ6Bm19HYQ/Z6ThIK3WljOUkzCkd898kxfXdRCXO7NXGSrg5jj5xMPdEEvEt3vHB a4PpJlJExovZNgljSoDmqwj5eIxrpqmkbnkzb2BCMyWRn/Vffw6gvZ7daSt3Pkh5e5Ce cczi+k/wVwSa/PL5Ti18fHD2kDhL5KotQXnASzfJQojqu+wFcaCV1NAdBFvy+gpdT1Vf mWj36t8AHnQgQ5H5OZHQHsU52O5RsR+iStcKmI7vT/jSW0Mbp+MdTjswJGOsjf2xXEbN 6UX3o1ueKTtzlyZQp4EfwEpTNAYHXm8jIsojUfEYID8fnvVfbOyDrigiwXZRbUEy8SN+ 9LxQ== X-Gm-Message-State: AJIora9/VA3bLZbc41hCufDjXRnEjat7mI7Nv90Jlha79C8ZGSdmo8+h cg3wZSah9MDLQfJXrrO/Y7F4BafCSPI= X-Google-Smtp-Source: AGRyM1vqlzxmTJ/wyfrKcIyV27A65YcXK7dkFb+RHboMZE3nrRG0Kib1ilRc3LsBMiPyo4ob5rcqLA== X-Received: by 2002:a05:6a00:2407:b0:528:5bbc:aa0d with SMTP id z7-20020a056a00240700b005285bbcaa0dmr7514549pfh.40.1656918451143; Mon, 04 Jul 2022 00:07:31 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id e7-20020a170902784700b0015eab1b097dsm20317725pln.22.2022.07.04.00.07.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:07:30 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Ritesh Harjani Subject: [RFC 03/13] blkmap64_ba: Add common helper for bits size calculation Date: Mon, 4 Jul 2022 12:36:52 +0530 Message-Id: <2418fae44393d8696cc848b682a24e58d334e1a2.1656912918.git.ritesh.list@gmail.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org Just a quick common helper for bits size calculation. Signed-off-by: Ritesh Harjani --- lib/ext2fs/blkmap64_ba.c | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/lib/ext2fs/blkmap64_ba.c b/lib/ext2fs/blkmap64_ba.c index 5d8f1548..4e7007f0 100644 --- a/lib/ext2fs/blkmap64_ba.c +++ b/lib/ext2fs/blkmap64_ba.c @@ -40,6 +40,13 @@ struct ext2fs_ba_private_struct { typedef struct ext2fs_ba_private_struct *ext2fs_ba_private; +#define ba_bits_size(start, end) ((((end) - (start)) / 8 + 1)) + +static size_t ba_bitmap_size(ext2fs_generic_bitmap_64 bitmap) +{ + return (size_t) ba_bits_size(bitmap->start, bitmap->real_end); +} + static errcode_t ba_alloc_private_data (ext2fs_generic_bitmap_64 bitmap) { ext2fs_ba_private bp; @@ -56,7 +63,7 @@ static errcode_t ba_alloc_private_data (ext2fs_generic_bitmap_64 bitmap) if (retval) return retval; - size = (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1); + size = ba_bitmap_size(bitmap); retval = ext2fs_get_mem(size, &bp->bitarray); if (retval) { @@ -80,7 +87,7 @@ static errcode_t ba_new_bmap(ext2_filsys fs EXT2FS_ATTR((unused)), return retval; bp = (ext2fs_ba_private) bitmap->private; - size = (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1); + size = ba_bitmap_size(bitmap); memset(bp->bitarray, 0, size); return 0; @@ -115,7 +122,7 @@ static errcode_t ba_copy_bmap(ext2fs_generic_bitmap_64 src, dest_bp = (ext2fs_ba_private) dest->private; - size = (size_t) (((src->real_end - src->start) / 8) + 1); + size = ba_bitmap_size(src); memcpy (dest_bp->bitarray, src_bp->bitarray, size); return 0; @@ -145,8 +152,8 @@ static errcode_t ba_resize_bmap(ext2fs_generic_bitmap_64 bmap, return 0; } - size = ((bmap->real_end - bmap->start) / 8) + 1; - new_size = ((new_real_end - bmap->start) / 8) + 1; + size = ba_bitmap_size(bmap); + new_size = ba_bits_size(new_real_end, bmap->start); if (size != new_size) { retval = ext2fs_resize_mem(size, new_size, &bp->bitarray); @@ -306,8 +313,7 @@ static void ba_clear_bmap(ext2fs_generic_bitmap_64 bitmap) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; - memset(bp->bitarray, 0, - (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1)); + memset(bp->bitarray, 0, ba_bitmap_size(bitmap)); } #ifdef ENABLE_BMAP_STATS From patchwork Mon Jul 4 07:06:53 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651791 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=OudxUgU4; dkim-atps=neutral Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4LbxhX5JMnz9s5V for ; Mon, 4 Jul 2022 17:07:40 +1000 (AEST) Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxhX4bfXz4xLX for ; Mon, 4 Jul 2022 17:07:40 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4LbxhX4Y36z4xTq; Mon, 4 Jul 2022 17:07:40 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=OudxUgU4; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxhX4SKBz4xLX for ; Mon, 4 Jul 2022 17:07:40 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232691AbiGDHHk (ORCPT ); Mon, 4 Jul 2022 03:07:40 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37254 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232620AbiGDHHi (ORCPT ); Mon, 4 Jul 2022 03:07:38 -0400 Received: from mail-pg1-x52e.google.com (mail-pg1-x52e.google.com [IPv6:2607:f8b0:4864:20::52e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 69E4E26FD for ; Mon, 4 Jul 2022 00:07:36 -0700 (PDT) Received: by mail-pg1-x52e.google.com with SMTP id e132so8152975pgc.5 for ; Mon, 04 Jul 2022 00:07:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=AkxvBqKQryD8JuZC09E0gSv5R5ME0HZkZNSHZol3Gyw=; b=OudxUgU4+dChHPE/OeNxppyDLFVHLUVQpYPQafV9bftjyZGETFSqyxPo5rSEHKtIsC qFnkCPsQeAjz3Ll9KLIWJzFBDt8Khyauwavir+95dvI/9kO0m0kblNQJej/yc9LKm1vq RL7SgfmqvNzoWc4fmf55Oi7mFvPrIiXyOdouZw63k52rDrhs9z5A3Sl7Rwk6rISon3Bg 5V3syutxd0EXFBLraHplddKb0J0BX5gtGXKnuKvHRsBDW8t7/Y886ytNj8OHuOaZWYVg 9ss0yMLxSfz6oQyAGkYM5of2GcRuiFRijg05mSZkQP95Ms0b6oqp2eI6bgIuTztLtTzl irzw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=AkxvBqKQryD8JuZC09E0gSv5R5ME0HZkZNSHZol3Gyw=; b=TUUR6om0xln6pfVfqq/B+q5JOv9Vklw8IoDT70EB5ELaZPl1ivY0WUJEZmSjSnaYyM gm5u5+y2P5O5zxEIszq83Fj84G4uTMgPxNo6Vi576PE6C9QdVvUuK8yoqNotfV3c9N57 nD0LAhp+i220VEsdzoltt/bn80PcJcPyf7a90O63wbCABBeHFaDoSfXxVfpgxjaAX3c/ wcstY1Ic0E9R0BCQ2RkSL/6OkhHnXx373BghbHYD/gd8YuzgspWBsM7WnDviwBbFaJov 5KB9nrKZAwG82dctti4iUVDweHRV3eNee1oU6YfG0OgXJfJKYafNcJytfYrQNR4EfOU0 pASA== X-Gm-Message-State: AJIora/fAuY5KpLAwuS7gIYnL4zUrfFYuXZffFl4aufNbkhCbyfFcYG7 937S4AmOD/6UWFGTNSlj09OcpUcyVNc= X-Google-Smtp-Source: AGRyM1uPQQ4LLW/fdXFhasJ+5LdK5d/sjS86Th2wlpIpSkamnBun6YG3Q5RtUBJ7UGtUOuxtOYW/tg== X-Received: by 2002:a63:8b43:0:b0:40d:1d04:bd7e with SMTP id j64-20020a638b43000000b0040d1d04bd7emr24500101pge.573.1656918455981; Mon, 04 Jul 2022 00:07:35 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id x19-20020a056a00189300b0051b4e53c487sm20426432pfh.45.2022.07.04.00.07.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:07:35 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Wang Shilong , Ritesh Harjani Subject: [RFC 04/13] ext2fs/bitmaps: Add merge bitmaps library abstraction changes Date: Mon, 4 Jul 2022 12:36:53 +0530 Message-Id: <0a6548f624347a8b9898150f9e5505031fe5a6ab.1656912918.git.ritesh.list@gmail.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org From: Wang Shilong Add merge bitmaps library abstraction changes. Signed-off-by: Wang Shilong Signed-off-by: Ritesh Harjani --- lib/ext2fs/bitmaps.c | 9 +++++++++ lib/ext2fs/bmap64.h | 5 +++++ lib/ext2fs/ext2fs.h | 8 ++++++++ lib/ext2fs/gen_bitmap64.c | 29 +++++++++++++++++++++++++++++ 4 files changed, 51 insertions(+) diff --git a/lib/ext2fs/bitmaps.c b/lib/ext2fs/bitmaps.c index 834a3962..23072a11 100644 --- a/lib/ext2fs/bitmaps.c +++ b/lib/ext2fs/bitmaps.c @@ -45,6 +45,15 @@ errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src, { return (ext2fs_copy_generic_bmap(src, dest)); } + +errcode_t ext2fs_merge_bitmap(ext2fs_generic_bitmap src, + ext2fs_generic_bitmap dst, + ext2fs_generic_bitmap dup, + ext2fs_generic_bitmap dup_allowed) +{ + return ext2fs_merge_generic_bmap(src, dst, dup, dup_allowed); +} + void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map) { ext2fs_set_generic_bmap_padding(map); diff --git a/lib/ext2fs/bmap64.h b/lib/ext2fs/bmap64.h index de334548..4c254892 100644 --- a/lib/ext2fs/bmap64.h +++ b/lib/ext2fs/bmap64.h @@ -100,6 +100,11 @@ struct ext2_bitmap_ops { * May be NULL, in which case a generic function is used. */ errcode_t (*find_first_set)(ext2fs_generic_bitmap_64 bitmap, __u64 start, __u64 end, __u64 *out); + + errcode_t (*merge_bmap)(ext2fs_generic_bitmap_64 src, + ext2fs_generic_bitmap_64 dest, + ext2fs_generic_bitmap_64 dup, + ext2fs_generic_bitmap_64 dup_allowed); }; extern struct ext2_bitmap_ops ext2fs_blkmap64_bitarray; diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h index 68f9c1fe..c18849d7 100644 --- a/lib/ext2fs/ext2fs.h +++ b/lib/ext2fs/ext2fs.h @@ -867,6 +867,10 @@ extern void ext2fs_free_block_bitmap(ext2fs_block_bitmap bitmap); extern void ext2fs_free_inode_bitmap(ext2fs_inode_bitmap bitmap); extern errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src, ext2fs_generic_bitmap *dest); +extern errcode_t ext2fs_merge_bitmap(ext2fs_generic_bitmap src, + ext2fs_generic_bitmap dst, + ext2fs_generic_bitmap dup, + ext2fs_generic_bitmap dup_allowed); extern errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs, const char *descr, ext2fs_block_bitmap *ret); @@ -1455,6 +1459,10 @@ errcode_t ext2fs_alloc_generic_bmap(ext2_filsys fs, errcode_t magic, ext2fs_generic_bitmap *ret); errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap src, ext2fs_generic_bitmap *dest); +extern errcode_t ext2fs_merge_generic_bmap(ext2fs_generic_bitmap gen_src, + ext2fs_generic_bitmap gen_dst, + ext2fs_generic_bitmap gen_dup, + ext2fs_generic_bitmap gen_dup_allowed); void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap); errcode_t ext2fs_fudge_generic_bmap_end(ext2fs_generic_bitmap bitmap, errcode_t neq, diff --git a/lib/ext2fs/gen_bitmap64.c b/lib/ext2fs/gen_bitmap64.c index 90c700ca..eea100b0 100644 --- a/lib/ext2fs/gen_bitmap64.c +++ b/lib/ext2fs/gen_bitmap64.c @@ -346,6 +346,35 @@ errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap gen_src, return 0; } +errcode_t ext2fs_merge_generic_bmap(ext2fs_generic_bitmap gen_src, + ext2fs_generic_bitmap gen_dst, + ext2fs_generic_bitmap gen_dup, + ext2fs_generic_bitmap gen_dup_allowed) +{ + ext2fs_generic_bitmap_64 src = (ext2fs_generic_bitmap_64) gen_src; + ext2fs_generic_bitmap_64 dst = (ext2fs_generic_bitmap_64) gen_dst; + ext2fs_generic_bitmap_64 dup = (ext2fs_generic_bitmap_64) gen_dup; + ext2fs_generic_bitmap_64 dup_allowed = (ext2fs_generic_bitmap_64) gen_dup_allowed; + + if (!src || !dst) + return EINVAL; + + if (!EXT2FS_IS_64_BITMAP(src) || !EXT2FS_IS_64_BITMAP(dst) || + (dup && !EXT2FS_IS_64_BITMAP(dup)) || + (dup_allowed && !EXT2FS_IS_64_BITMAP(dup_allowed))) + return EINVAL; + + if (src->bitmap_ops != dst->bitmap_ops || + (dup && dup->bitmap_ops != src->bitmap_ops) || + (dup_allowed && dup_allowed->bitmap_ops != src->bitmap_ops)) + return EINVAL; + + if (!src->bitmap_ops->merge_bmap) + return EOPNOTSUPP; + + return src->bitmap_ops->merge_bmap(src, dst, dup, dup_allowed); +} + errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap gen_bmap, __u64 new_end, __u64 new_real_end) From patchwork Mon Jul 4 07:06:54 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651792 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=HcJOUjDI; dkim-atps=neutral Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4Lbxhg6lvjz9s5V for ; Mon, 4 Jul 2022 17:07:47 +1000 (AEST) Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxhg61Pbz4xLX for ; Mon, 4 Jul 2022 17:07:47 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4Lbxhg5wXvz4xYN; Mon, 4 Jul 2022 17:07:47 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=HcJOUjDI; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxhg5pjRz4xLX for ; Mon, 4 Jul 2022 17:07:47 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232831AbiGDHHp (ORCPT ); Mon, 4 Jul 2022 03:07:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37302 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232698AbiGDHHm (ORCPT ); Mon, 4 Jul 2022 03:07:42 -0400 Received: from mail-pj1-x1029.google.com (mail-pj1-x1029.google.com [IPv6:2607:f8b0:4864:20::1029]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 78176271E for ; Mon, 4 Jul 2022 00:07:41 -0700 (PDT) Received: by mail-pj1-x1029.google.com with SMTP id a15so1720541pjs.0 for ; Mon, 04 Jul 2022 00:07:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=rHjB8NkCalfqthCh/ZcteQS9lRQhjIFdpZj41bFLeZk=; b=HcJOUjDIroufAspILNCRTxIyN4Lan8Qc8rRE5KGArGP9t1s1hiXUA0uIT0JVbELf2g rKFuMVuNiar1WKkDlZbl+nPxXkEQ5kWBcpIFJApmbUv2mtDf7k0wdcHKpHkp1vAOT9vb G30BDAk/83KkiTu9m4DY23nm6CDsFxV1ksoAtqoByEmR8OGUy9ll/jQP4LurYxdTaG7j IkktWiymTrbky30XsAy5ScwJZWmolL7C0m3cdhX9D+hnR9YoWj0pqZoLTjOFjGz54r00 W+g8QIXy9Vl6+fTR1ygIquu+4CC+XREtVBzKZ6zQiVgHBcP5uPg+0g1FkkbseQ8gMqXA /zMQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=rHjB8NkCalfqthCh/ZcteQS9lRQhjIFdpZj41bFLeZk=; b=pO3jyKFxikzBGNIad9+75uHWipTgI6sv8nggE3zi53Se8MjvlKC+RF10ay/hSEaj2C G4oGNmQR4Q9HmHbd2kmUbpkgSNDFFbq8pEcYwicfmYT6iThvjCewJXyICO6ZJtb43Zti YC7xGdZ/TY8FHG1wewoZ45A72QkCHTrLTwTi7oDU0E/1Ze4ugZ3Q0PRd+o1vCaEwS4/2 Ejd0aJpzGVRLmoWtFFme62WhLfYl+xLH23O2Qsdqsa3CxvNMlBRYEbGAm6x24KX7ERl/ vQlyWGEFfGaEM148aML+hgn3Z8445ZkA9nqIghP42t2OMs6X7yKVXXXTfkohYKy3tVIh zXrQ== X-Gm-Message-State: AJIora/ysCUYdyTyWlbuUk+Nogp8uwDwAIGZbvH6xUFhoaoBI2xzJPhx 67cVAVODQDrQsv5jpgNwgYA= X-Google-Smtp-Source: AGRyM1sFPdbvEzg/74AE40Q9As7UeN1HKsf358bazHPlwLQXYI8kkt2lsfxfBoA5jVTZb71yWgYdyQ== X-Received: by 2002:a17:902:ef4f:b0:16b:8744:6c5f with SMTP id e15-20020a170902ef4f00b0016b87446c5fmr32582664plx.60.1656918460863; Mon, 04 Jul 2022 00:07:40 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id a3-20020a1709027e4300b0016bb24f5d19sm8024619pln.209.2022.07.04.00.07.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:07:40 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Wang Shilong , Ritesh Harjani Subject: [RFC 05/13] libext2fs: blkmap64_rb: Add rbtree bmap merge logic changes Date: Mon, 4 Jul 2022 12:36:54 +0530 Message-Id: X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org From: Wang Shilong Add rbtree bmap merge logic changes. Signed-off-by: Ritesh Harjani Signed-off-by: Wang Shilong --- lib/ext2fs/blkmap64_rb.c | 65 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/lib/ext2fs/blkmap64_rb.c b/lib/ext2fs/blkmap64_rb.c index 0df58dc7..d7c88aef 100644 --- a/lib/ext2fs/blkmap64_rb.c +++ b/lib/ext2fs/blkmap64_rb.c @@ -977,11 +977,76 @@ static void rb_print_stats(ext2fs_generic_bitmap_64 bitmap EXT2FS_ATTR((unused)) } #endif +static errcode_t rb_merge_bmap(ext2fs_generic_bitmap_64 src, + ext2fs_generic_bitmap_64 dest, + ext2fs_generic_bitmap_64 dup, + ext2fs_generic_bitmap_64 dup_allowed) +{ + struct ext2fs_rb_private *src_bp, *dest_bp, *dup_bp = NULL; + struct bmap_rb_extent *src_ext; + struct rb_node *src_node; + errcode_t retval = 0; + int dup_found = 0; + __u64 i; + + src_bp = (struct ext2fs_rb_private *) src->private; + dest_bp = (struct ext2fs_rb_private *) dest->private; + if (dup) + dup_bp = (struct ext2fs_rb_private *)dup->private; + src_bp->rcursor = NULL; + dest_bp->rcursor = NULL; + + src_node = ext2fs_rb_first(&src_bp->root); + while (src_node) { + src_ext = node_to_extent(src_node); + retval = rb_test_clear_bmap_extent(dest, + src_ext->start + src->start, + src_ext->count); + if (retval) { + rb_insert_extent(src_ext->start, src_ext->count, + dest_bp); + goto next; + } + + /* unlikely case, do it one by one block */ + for (i = src_ext->start; + i < src_ext->start + src_ext->count; i++) { + retval = rb_test_clear_bmap_extent(dest, i + src->start, 1); + if (retval) { + rb_insert_extent(i, 1, dest_bp); + continue; + } + if (dup_allowed) { + retval = rb_test_clear_bmap_extent(dup_allowed, + i + src->start, 1); + /* not existed in dup_allowed */ + if (retval) { + dup_found = 1; + if (dup_bp) + rb_insert_extent(i, 1, dup_bp); + } /* else we conside it not duplicated */ + } else { + if (dup_bp) + rb_insert_extent(i, 1, dup_bp); + dup_found = 1; + } + } +next: + src_node = ext2fs_rb_next(src_node); + } + + if (dup_found && dup) + return EEXIST; + + return 0; +} + struct ext2_bitmap_ops ext2fs_blkmap64_rbtree = { .type = EXT2FS_BMAP64_RBTREE, .new_bmap = rb_new_bmap, .free_bmap = rb_free_bmap, .copy_bmap = rb_copy_bmap, + .merge_bmap = rb_merge_bmap, .resize_bmap = rb_resize_bmap, .mark_bmap = rb_mark_bmap, .unmark_bmap = rb_unmark_bmap, From patchwork Mon Jul 4 07:06:55 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651793 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=VEw9guES; dkim-atps=neutral Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4Lbxj257kJz9s5V for ; Mon, 4 Jul 2022 17:08:06 +1000 (AEST) Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxj24M3Rz4xTq for ; Mon, 4 Jul 2022 17:08:06 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4Lbxj24K8Dz4xYN; Mon, 4 Jul 2022 17:08:06 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=VEw9guES; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxj24Dqvz4xTq for ; Mon, 4 Jul 2022 17:08:06 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233157AbiGDHIF (ORCPT ); Mon, 4 Jul 2022 03:08:05 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37576 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232982AbiGDHHy (ORCPT ); Mon, 4 Jul 2022 03:07:54 -0400 Received: from mail-pg1-x530.google.com (mail-pg1-x530.google.com [IPv6:2607:f8b0:4864:20::530]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 454902717 for ; Mon, 4 Jul 2022 00:07:46 -0700 (PDT) Received: by mail-pg1-x530.google.com with SMTP id 9so8146503pgd.7 for ; Mon, 04 Jul 2022 00:07:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=z3TRSOORGF8URDv+X6mjTTIhwkPiRvkTKLI2OWvxJts=; b=VEw9guESA3cJWUKDv318cg9ZdMA2Q0rYs+cP5zHCYRVS4ZqDOICfipDWPV+gO2Zi9M xoHTWsim84hBpN/SRfM4KbklAocpDfnb/2kxeS52hIJYVJYx2aWoC/JDaW3I2cW3iOlc nTdL0xOXbHzoV+UzxaXkoMhVcEchhQTHwoM51TR3qMUbHgdhV4owDgmMnQhQ4rtx9G1e ogDxfBKtiCyXlfWN9sDbZ7NcHjfSyARjOv5Q4LjmbT+lycmU5KmRL8R0O/1RgC7QdAS/ RhCWh9ClYchDpzWmbKDHJYg4NBCrvctewLyou2uerh3mEs82BB+tOu1oFCmH/Ro14NuF pGCw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=z3TRSOORGF8URDv+X6mjTTIhwkPiRvkTKLI2OWvxJts=; b=Z3tw/6F/P/hqHUpst9yw9lZ43fnZx+LXtzaXVm+AFrVz8aoZje4su5Cw+8lU2rPKy5 yx84+EjNb9R2xVas4snOaCFXYA7QjHIR/R37GZqVVfb09K2QB0sTqpb/LknNcAtpS0rA JA7Pd7WM2EgeO0PGnp1AE6rMhqxb4IC+4mLDnVbyI74Cqm/3p7/E6bqEz5X01QIwqIZj 7ASAMFVsLGiZ4X+WHqC9GMfua5xcmOfPun5USaZV9pQAGjDHtIDE9A4oRNjbR0QLf4GW f+GgwO52P7Ts3XV5XbYM3zQeTFcE+kxu7Jy28cj1171fpyhd7awaKe5DDz9eATn4dbh+ VcBg== X-Gm-Message-State: AJIora+mkpVvm+9oIoWYpytXEg2pCzs6JTokoVSgC+vT6RKeRtKgeZ6P HgnNudOFiN42KjmTgyOY1Jc= X-Google-Smtp-Source: AGRyM1tZqAYyMAc8StymAKcDVAQo7Mx50z9CE8w3wsrzIP1rZeaJ1Rg6/5uXxbXPxftHEvgCxrOZdQ== X-Received: by 2002:a63:84c8:0:b0:40c:7d4a:ac66 with SMTP id k191-20020a6384c8000000b0040c7d4aac66mr23632680pgd.424.1656918465768; Mon, 04 Jul 2022 00:07:45 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id r20-20020a170902be1400b0016b68cf6ae5sm15764160pls.226.2022.07.04.00.07.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:07:45 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Ritesh Harjani Subject: [RFC 06/13] blkmap64_ba: Implement initial implementation of merge bitmaps Date: Mon, 4 Jul 2022 12:36:55 +0530 Message-Id: <2cd087afb18522029158f537edad49cb3f435e88.1656912918.git.ritesh.list@gmail.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org DO NOT MERGE Adding a basic merge implementation of bitarray for later adding/supporting test cases w.r.t. libext2fs merge/clone API. Signed-off-by: Ritesh Harjani --- lib/ext2fs/blkmap64_ba.c | 53 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 52 insertions(+), 1 deletion(-) diff --git a/lib/ext2fs/blkmap64_ba.c b/lib/ext2fs/blkmap64_ba.c index 4e7007f0..9a9f6563 100644 --- a/lib/ext2fs/blkmap64_ba.c +++ b/lib/ext2fs/blkmap64_ba.c @@ -12,6 +12,7 @@ #include "config.h" #include #include +#include #if HAVE_UNISTD_H #include #endif @@ -476,6 +477,55 @@ static errcode_t ba_find_first_set(ext2fs_generic_bitmap_64 bitmap, return ENOENT; } +errcode_t ba_merge_bmap(ext2fs_generic_bitmap_64 src, + ext2fs_generic_bitmap_64 dst, + ext2fs_generic_bitmap_64 dup, + ext2fs_generic_bitmap_64 dup_allowed) +{ + ext2fs_ba_private src_bp = (ext2fs_ba_private) src->private; + ext2fs_ba_private dst_bp = (ext2fs_ba_private) dst->private; + + const unsigned char *src_pos = src_bp->bitarray; + const unsigned char *dst_pos = dst_bp->bitarray; + unsigned long count = src->real_end - src->start + 1; + unsigned long bitpos = src->start; + + assert(src->start == dst->start); + assert(src->end == dst->end); + assert(src->real_end == dst->real_end); + + // TODO add full support + // For now assuming the pos is aligned addr + assert(!(((uintptr_t)src_pos) & 0x07)); + + // 8-byte blocks compare + while (count >= 64) { + const __u64 src_val = *(const __u64 *)src_pos; + const __u64 dst_val = *(const __u64 *)dst_pos; + const __u64 sd_val = src_val & dst_val; + + // TODO: Not implemented case to handle duplicates/dup_allowed case of EA + if (dup || dup_allowed) + assert(sd_val == 0); + + *(__u64 *)dst_pos |= src_val; + + src_pos += 8; + dst_pos += 8; + count -= 64; + bitpos += 64; + } + + while (count-- > 0) { + // TODO: dup case not implemented yet. + if (ext2fs_test_bit64(bitpos, src_bp->bitarray)) + assert(ext2fs_set_bit64(bitpos, dst_bp->bitarray) == 0); + bitpos++; + } + + return 0; +} + struct ext2_bitmap_ops ext2fs_blkmap64_bitarray = { .type = EXT2FS_BMAP64_BITARRAY, @@ -494,5 +544,6 @@ struct ext2_bitmap_ops ext2fs_blkmap64_bitarray = { .clear_bmap = ba_clear_bmap, .print_stats = ba_print_stats, .find_first_zero = ba_find_first_zero, - .find_first_set = ba_find_first_set + .find_first_set = ba_find_first_set, + .merge_bmap = ba_merge_bmap, }; From patchwork Mon Jul 4 07:06:56 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651794 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=GXE3a8D0; dkim-atps=neutral Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4Lbxj34WJkz9s5V for ; Mon, 4 Jul 2022 17:08:07 +1000 (AEST) Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxj33pK1z4xTq for ; Mon, 4 Jul 2022 17:08:07 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4Lbxj33mCyz4xYN; Mon, 4 Jul 2022 17:08:07 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=GXE3a8D0; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxj33hRBz4xTq for ; Mon, 4 Jul 2022 17:08:07 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233125AbiGDHIG (ORCPT ); Mon, 4 Jul 2022 03:08:06 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37622 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232989AbiGDHHz (ORCPT ); Mon, 4 Jul 2022 03:07:55 -0400 Received: from mail-pl1-x62c.google.com (mail-pl1-x62c.google.com [IPv6:2607:f8b0:4864:20::62c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 362247663 for ; Mon, 4 Jul 2022 00:07:51 -0700 (PDT) Received: by mail-pl1-x62c.google.com with SMTP id m14so7802034plg.5 for ; Mon, 04 Jul 2022 00:07:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=D7hsX2DsmXYOz9s9ls3nii2cmhk82eZNYmUg1ZliQuI=; b=GXE3a8D0BhLnN3q5lzqEJMXBbRNlzuUwuV9Xb1Ctd4YeDHjaDrRuvWffzL3SpGGxxp yMLSo3mGjvKzn0U/h22RDwfzOLqYVzAGjQst0YjO+eGdQwPnR1fk7ctzTMM1r8bL99yy QtxA9Xc2zrjBlEIx7xgMM0+y/2tYoSITxOjAzO70woCZEJNYIu9ikOG5fMXyM1ql9mkh PGk8DvTRnPYZDFx/VaRFBP7I2epVlCtcommIic3hZVVN5HaaHLPTFTdPRUOmpqIfVEL+ N0pyBSQZJkgwDAuWQ6ePW+gFdqt+vua9lxAheJ+8pxBoY3XgOcRDyjUYYh7euWfP7U+n I55g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=D7hsX2DsmXYOz9s9ls3nii2cmhk82eZNYmUg1ZliQuI=; b=mm2tA1zpn949nsGBoh/yZqZRKKcWLGFiGfc+FJzk1ydtt1T0XPGSBjWtomwr/fyFN+ 2Wicn1UgAM6I99uBoKG0V333v9eIvWJeax+fQfXJ+gShJ4w0PYplDCdSTjGHzlk+RHLz SZO2NJA8XGOb1IPTPGKMV1XWDRqpzCq4Zr2dIU2FLBscv2rjGUFv21U58r02NPLVy6t9 CPKLtTaFXbojGbwy2hSLGUMGhZFr2Co18HoU0E6FkDqbaz51fLS5tM6usim7a4gkcXpU D5en5SkTEqiCDY+qeoK0lxVtjy/YhzjY/Xsy5uICwZted14ImpswB7e1NpkxQknfQtE2 a2oQ== X-Gm-Message-State: AJIora+3wTilg67T2lLvQof0qgwCS4KJksqT4EaaMl4UVXLO9lj3b1Xf gv923jzGKeHasJiYBoTSx+Q= X-Google-Smtp-Source: AGRyM1t4wWZUWZl4ZzDI02YMbzbYhLcc110BvMnFNo6esN6l5lwzXvGGw6yF+NpMA5NqSS8zTLBs2g== X-Received: by 2002:a17:903:2444:b0:16b:917e:3b04 with SMTP id l4-20020a170903244400b0016b917e3b04mr32392331pls.145.1656918470618; Mon, 04 Jul 2022 00:07:50 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id lp11-20020a17090b4a8b00b001ef82d23125sm2429778pjb.25.2022.07.04.00.07.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:07:50 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Ritesh Harjani Subject: [RFC 07/13] tst_bitmaps_standalone: Add copy and merge bitmaps test Date: Mon, 4 Jul 2022 12:36:56 +0530 Message-Id: <6abd6d01ab11f862b2ff5b31664292718a77d8e8.1656912918.git.ritesh.list@gmail.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org This adds a basic copy and merge api test for both bitmap types (i.e. rbtree and bitarray) Signed-off-by: Ritesh Harjani --- lib/ext2fs/Makefile.in | 25 +++- lib/ext2fs/tst_bitmaps_standalone.c | 173 ++++++++++++++++++++++++++++ 2 files changed, 192 insertions(+), 6 deletions(-) create mode 100644 lib/ext2fs/tst_bitmaps_standalone.c diff --git a/lib/ext2fs/Makefile.in b/lib/ext2fs/Makefile.in index f6a050a2..1692500e 100644 --- a/lib/ext2fs/Makefile.in +++ b/lib/ext2fs/Makefile.in @@ -227,6 +227,7 @@ SRCS= ext2_err.c \ $(srcdir)/write_bb_file.c \ $(srcdir)/rbtree.c \ $(srcdir)/tst_libext2fs.c \ + $(srcdir)/tst_bitmaps_standalone.c \ $(DEBUG_SRCS) HFILES= bitops.h ext2fs.h ext2_io.h ext2_fs.h ext2_ext_attr.h ext3_extents.h \ @@ -328,9 +329,9 @@ tst_getsectsize: tst_getsectsize.o getsectsize.o $(STATIC_LIBEXT2FS) \ $(ALL_LDFLAGS) $(STATIC_LIBEXT2FS) $(STATIC_LIBCOM_ERR) \ $(SYSLIBS) -tst_types.o: $(srcdir)/tst_types.c ext2_types.h +tst_types.o: $(srcdir)/tst_types.c ext2_types.h -tst_types: tst_types.o ext2_types.h +tst_types: tst_types.o ext2_types.h $(E) " LD $@" $(Q) $(CC) -o tst_types tst_types.o $(ALL_LDFLAGS) $(SYSLIBS) @@ -362,6 +363,11 @@ tst_sha512: $(srcdir)/sha512.c $(srcdir)/ext2_fs.h $(Q) $(CC) $(ALL_LDFLAGS) $(ALL_CFLAGS) -o tst_sha512 \ $(srcdir)/sha512.c -DUNITTEST $(SYSLIBS) +tst_bitmaps_standalone: tst_bitmaps_standalone.o $(STATIC_LIBEXT2FS) $(DEPSTATIC_LIBCOM_ERR) + $(E) " LD $@" + $(Q) $(CC) -o tst_bitmaps_standalone tst_bitmaps_standalone.o $(ALL_LDFLAGS) \ + $(STATIC_LIBEXT2FS) $(STATIC_LIBCOM_ERR) $(SYSLIBS) + ext2_tdbtool: tdbtool.o $(E) " LD $@" $(Q) $(CC) -o ext2_tdbtool tdbtool.o tdb.o $(ALL_LDFLAGS) $(SYSLIBS) @@ -533,7 +539,7 @@ mkjournal: mkjournal.c $(STATIC_LIBEXT2FS) $(DEPLIBCOM_ERR) fullcheck check:: tst_bitops tst_badblocks tst_iscan tst_types tst_icount \ tst_super_size tst_types tst_inode_size tst_csum tst_crc32c tst_bitmaps \ tst_inline tst_inline_data tst_libext2fs tst_sha256 tst_sha512 \ - tst_digest_encode tst_getsize tst_getsectsize + tst_digest_encode tst_getsize tst_getsectsize tst_bitmaps_standalone $(TESTENV) ./tst_bitops $(TESTENV) ./tst_badblocks $(TESTENV) ./tst_iscan @@ -556,6 +562,7 @@ fullcheck check:: tst_bitops tst_badblocks tst_iscan tst_types tst_icount \ $(TESTENV) ./tst_bitmaps -l -f $(srcdir)/tst_bitmaps_cmds > tst_bitmaps_out diff $(srcdir)/tst_bitmaps_exp tst_bitmaps_out $(TESTENV) ./tst_digest_encode + $(TESTENV) ./tst_bitmaps_standalone installdirs:: $(E) " MKDIR_P $(libdir) $(includedir)/ext2fs" @@ -581,7 +588,7 @@ install:: all $(HFILES) $(HFILES_IN) installdirs ext2fs.pc uninstall:: $(RM) -f $(DESTDIR)$(libdir)/libext2fs.a \ $(DESTDIR)$(pkgconfigdir)/ext2fs.pc - $(RM) -rf $(DESTDIR)$(includedir)/ext2fs + $(RM) -rf $(DESTDIR)$(includedir)/ext2fs clean:: $(RM) -f \#* *.s *.o *.a *~ *.bak core profiled/* \ @@ -590,7 +597,7 @@ clean:: tst_bitops tst_types tst_icount tst_super_size tst_csum \ tst_bitmaps tst_bitmaps_out tst_extents tst_inline \ tst_inline_data tst_inode_size tst_bitmaps_cmd.c \ - tst_digest_encode tst_sha256 tst_sha512 \ + tst_digest_encode tst_sha256 tst_sha512 tst_bitmaps_standalone \ ext2_tdbtool mkjournal debug_cmds.c tst_cmds.c extent_cmds.c \ ../libext2fs.a ../libext2fs_p.a ../libext2fs_chk.a \ crc32c_table.h gen_crc32ctable tst_crc32c tst_libext2fs \ @@ -646,7 +653,7 @@ windows_io.o: $(srcdir)/windows_io.c $(top_builddir)/lib/config.h \ $(srcdir)/ext2_ext_attr.h $(srcdir)/bitops.h $(srcdir)/ext2fsP.h # +++ Dependency line eater +++ -# +# # Makefile dependencies follow. This must be the last section in # the Makefile.in file # @@ -1156,6 +1163,12 @@ tst_iscan.o: $(srcdir)/tst_iscan.c $(top_builddir)/lib/config.h \ $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ $(srcdir)/ext2_ext_attr.h $(srcdir)/hashmap.h $(srcdir)/bitops.h +tst_bitmaps_standalone.o: $(srcdir)/tst_bitmaps_standalone.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/ext2_fs.h \ + $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ + $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ + $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(srcdir)/ext2_ext_attr.h $(srcdir)/hashmap.h $(srcdir)/bitops.h undo_io.o: $(srcdir)/undo_io.c $(top_builddir)/lib/config.h \ $(top_builddir)/lib/dirpaths.h $(srcdir)/ext2_fs.h \ $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ diff --git a/lib/ext2fs/tst_bitmaps_standalone.c b/lib/ext2fs/tst_bitmaps_standalone.c new file mode 100644 index 00000000..325398f8 --- /dev/null +++ b/lib/ext2fs/tst_bitmaps_standalone.c @@ -0,0 +1,173 @@ +#include "config.h" +#include +#include +#include +#if HAVE_UNISTD_H +#include +#endif +#include +#include +#include +#include +#if HAVE_ERRNO_H +#include +#endif + +#include "ext2_fs.h" +#include "ext2fs.h" +#include "bmap64.h" + +ext2_filsys test_fs; +ext2fs_block_bitmap block_map_1; +ext2fs_block_bitmap block_map_2; +ext2fs_block_bitmap block_map; + +static int test_fail = 0; + +void dump_bitmap(ext2fs_generic_bitmap bmap, unsigned int start, unsigned num) +{ + unsigned char *buf; + errcode_t retval; + int i, len = (num - start + 7) / 8; + + buf = malloc(len); + if (!buf) { + com_err("dump_bitmap", 0, "couldn't allocate buffer"); + return; + } + memset(buf, 0, len); + retval = ext2fs_get_generic_bmap_range(bmap, (__u64) start, num, buf); + if (retval) { + com_err("dump_bitmap", retval, + "while calling ext2fs_generic_bmap_range"); + free(buf); + return; + } + for (i=len-1; i >= 0; i--) + printf("%02x ", buf[i]); + printf("\n"); + printf("bits set: %u\n", ext2fs_bitcount(buf, len)); + free(buf); +} + +static void test_copy_run() +{ + int blocks[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 21, 23, 26, 29, 33, 37, 38}; + errcode_t ret; + char *buf_map = NULL; + char *buf_copy_map = NULL; + + assert(ext2fs_allocate_block_bitmap(test_fs, "block bitmap", &block_map_1) == 0); + + for (int i = 0; i < sizeof(blocks)/sizeof(blocks[0]); i++) { + ext2fs_mark_block_bitmap2(block_map_1, blocks[i]); + } + + assert(ext2fs_copy_bitmap(block_map_1, &block_map) == 0); + + if (ext2fs_compare_block_bitmap(block_map_1, block_map) != 0) { + printf("block bitmap copy test failed\n"); + test_fail++; + + dump_bitmap(block_map_1, test_fs->super->s_first_data_block, + test_fs->super->s_blocks_count); + + dump_bitmap(block_map, test_fs->super->s_first_data_block, + test_fs->super->s_blocks_count); + } + + ext2fs_free_block_bitmap(block_map_1); + ext2fs_free_block_bitmap(block_map); +} + +void test_merge_run() +{ + int blocks_odd[] = {1, 3, 5, 7, 9, 21, 23, 29, 33, 37}; + int blocks_even[] = {2, 4, 6, 8, 10, 26, 38}; + ext2fs_generic_bitmap_64 tmp_map; + + assert(ext2fs_allocate_block_bitmap(test_fs, "block bitmap 1", &block_map_1) == 0); + assert(ext2fs_allocate_block_bitmap(test_fs, "block bitmap 2", &block_map_2) == 0); + assert(ext2fs_allocate_block_bitmap(test_fs, "block bitmap 2", &block_map) == 0); + + for (int i = 0; i < sizeof(blocks_odd) / sizeof(blocks_odd[0]); i++) { + ext2fs_mark_block_bitmap2(block_map_1, blocks_odd[i]); + ext2fs_mark_block_bitmap2(block_map, blocks_odd[i]); + } + + for (int i = 0; i < sizeof(blocks_even) / sizeof(blocks_even[0]); i++) { + ext2fs_mark_block_bitmap2(block_map_2, blocks_even[i]); + ext2fs_mark_block_bitmap2(block_map, blocks_even[i]); + } + + assert(ext2fs_merge_bitmap(block_map_2, block_map_1, NULL, NULL) == 0); + if (ext2fs_compare_block_bitmap(block_map_1, block_map) != 0) { + printf("block bitmap merge test failed\n"); + test_fail++; + + dump_bitmap(block_map_1, test_fs->super->s_first_data_block, + test_fs->super->s_blocks_count); + + dump_bitmap(block_map, test_fs->super->s_first_data_block, + test_fs->super->s_blocks_count); + } + + ext2fs_free_block_bitmap(block_map_1); + ext2fs_free_block_bitmap(block_map_2); + ext2fs_free_block_bitmap(block_map); +} + +static void setup_filesystem(const char *name, unsigned int blocks, + unsigned int inodes, unsigned int type, + unsigned int flags) +{ + struct ext2_super_block param; + errcode_t ret; + + memset(¶m, 0, sizeof(param)); + ext2fs_blocks_count_set(¶m, blocks); + param.s_inodes_count = inodes; + + ret = ext2fs_initialize(name, flags, ¶m, test_io_manager, + &test_fs); + if (ret) { + com_err(name, ret, "while initializing filesystem"); + return; + } + + test_fs->default_bitmap_type = type; + + ext2fs_free_block_bitmap(test_fs->block_map); + ext2fs_free_block_bitmap(test_fs->inode_map); + + return; +errout: + ext2fs_close_free(&test_fs); +} + +int main(int argc, char **argv) +{ + unsigned int blocks = 127; + unsigned int inodes = 0; + unsigned int type = EXT2FS_BMAP64_RBTREE; + unsigned int flags = EXT2_FLAG_64BITS; + char *buf = NULL; + + setup_filesystem(argv[0], blocks, inodes, type, flags); + + /* test for EXT2FS_BMAP64_RBTREE */ + test_copy_run(); + test_merge_run(); + + /* test for EXT2FS_BMAP64_BITARRAY */ + test_fs->default_bitmap_type = EXT2FS_BMAP64_BITARRAY; + test_copy_run(); + test_merge_run(); + + if (test_fail) + printf("%s: Test copy & merge bitmaps -- NOT OK\n", argv[0]); + else + printf("%s: Test copy & merge bitmaps -- OK\n", argv[0]); + + return test_fail; +} From patchwork Mon Jul 4 07:06:57 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651795 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=XBtZowNJ; dkim-atps=neutral Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4LbxjR6sghz9sFr for ; Mon, 4 Jul 2022 17:08:27 +1000 (AEST) Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxjR69T1z4xTq for ; Mon, 4 Jul 2022 17:08:27 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4LbxjR66ySz4xYN; Mon, 4 Jul 2022 17:08:27 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=XBtZowNJ; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxjR50pkz4xTq for ; Mon, 4 Jul 2022 17:08:27 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233256AbiGDHI0 (ORCPT ); Mon, 4 Jul 2022 03:08:26 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37542 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233122AbiGDHIG (ORCPT ); Mon, 4 Jul 2022 03:08:06 -0400 Received: from mail-pl1-x62a.google.com (mail-pl1-x62a.google.com [IPv6:2607:f8b0:4864:20::62a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0146895A2 for ; Mon, 4 Jul 2022 00:07:56 -0700 (PDT) Received: by mail-pl1-x62a.google.com with SMTP id b2so7789712plx.7 for ; Mon, 04 Jul 2022 00:07:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=1QPlUiufE0YRDSo8ONY+aF6dkqDI+TIG/2Soo6iTm7c=; b=XBtZowNJx83BS+IFupUH2cFkTLbMlQ3g7ts++STl+8DxR2tzYfZ0aebaZbPOBuVx7y nhhbWyqyf0uywpzhojPg2xjar1gk6T51hEZ4XJas3fjo5cO725Z0ng6Iv2TN4iJbRs2S +/XHVIv5io9h98llNeh+1oB5rQ+hL1qnITmxBjkw9ZlsPwN99SXu/uQfWuNCBXQ/0UJf 4toD3runmcKQ59xCX+EbqS+nJSgCCDHZ4dc8VpBGYXsPweWvrSTFFUEWxietb7UBcQhz lnjJE+EWPcLPc1JnL0v77SOJmVSd458tEtINYg0MGt+5lV3Fm/+PKzBFyR+/4XCKPnI7 iuqw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=1QPlUiufE0YRDSo8ONY+aF6dkqDI+TIG/2Soo6iTm7c=; b=3R476obG+446NhFoYcM8bcyREmUqEOiZJczNtWIj7BS8V7gqFweebsmIQ90r2+X9OC OG5FHBX246eg8XAbQmmqcdATjj0jvgFUu6MXq9Tj21XRRoEn9JvLYz51yBxdB2W3V49u HZ6N+FGzk9//soSIqeBZMZvkaBtS38xV0losxTtc79Pamh+1CdEMBG2U93p2VlnRzdzQ xA5YAKRrRpmNvpgn1w7c3KBa+OHuSCm3aBTg3ZtjDLiTGLz9KAeCkFIJIaXIPkgh3jwd rNdeT30viATrVxnN6B90Bi79nrepE1iJu7bsj+qaZBgfKcwnuyFtcRbInGeHn9r4mJnJ wtsw== X-Gm-Message-State: AJIora+KiuEseVRimYeXbFhchN32wTGlrbrd7+Nct9OqCaYHFm4XXMIn gZvhApHd0sawV+kn3QaiVfB9sd/Dg7g= X-Google-Smtp-Source: AGRyM1vPrIsmNnJzKJtr5+SiaNnehCVG7XWbuqD/Q4xgVmntde8RT5yBy+RkGayYmPYYaQ3+htzNrw== X-Received: by 2002:a17:90b:3784:b0:1ef:6b06:c4 with SMTP id mz4-20020a17090b378400b001ef6b0600c4mr14575655pjb.187.1656918475480; Mon, 04 Jul 2022 00:07:55 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id j11-20020a170902da8b00b0016be153af2bsm1711766plx.36.2022.07.04.00.07.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:07:55 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Ritesh Harjani Subject: [RFC 08/13] tst_bitmaps_pthread: Add merge bitmaps test using pthreads Date: Mon, 4 Jul 2022 12:36:57 +0530 Message-Id: <89a325295a3e2916ca41af249911d5c91c33c2c6.1656912918.git.ritesh.list@gmail.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org This patch adds a test to verify the core bitmaps merge APIs for both bitarray and rbtree type. Signed-off-by: Ritesh Harjani --- lib/ext2fs/Makefile.in | 17 ++- lib/ext2fs/tst_bitmaps_pthread.c | 247 +++++++++++++++++++++++++++++++ 2 files changed, 263 insertions(+), 1 deletion(-) create mode 100644 lib/ext2fs/tst_bitmaps_pthread.c diff --git a/lib/ext2fs/Makefile.in b/lib/ext2fs/Makefile.in index 1692500e..c0694175 100644 --- a/lib/ext2fs/Makefile.in +++ b/lib/ext2fs/Makefile.in @@ -228,6 +228,7 @@ SRCS= ext2_err.c \ $(srcdir)/rbtree.c \ $(srcdir)/tst_libext2fs.c \ $(srcdir)/tst_bitmaps_standalone.c \ + $(srcdir)/tst_bitmaps_pthread.c \ $(DEBUG_SRCS) HFILES= bitops.h ext2fs.h ext2_io.h ext2_fs.h ext2_ext_attr.h ext3_extents.h \ @@ -368,6 +369,11 @@ tst_bitmaps_standalone: tst_bitmaps_standalone.o $(STATIC_LIBEXT2FS) $(DEPSTATIC $(Q) $(CC) -o tst_bitmaps_standalone tst_bitmaps_standalone.o $(ALL_LDFLAGS) \ $(STATIC_LIBEXT2FS) $(STATIC_LIBCOM_ERR) $(SYSLIBS) +tst_bitmaps_pthread: tst_bitmaps_pthread.o $(STATIC_LIBEXT2FS) $(DEPSTATIC_LIBCOM_ERR) + $(E) " LD $@" + $(Q) $(CC) -o tst_bitmaps_pthread tst_bitmaps_pthread.o $(ALL_LDFLAGS) \ + $(STATIC_LIBEXT2FS) $(STATIC_LIBCOM_ERR) $(SYSLIBS) + ext2_tdbtool: tdbtool.o $(E) " LD $@" $(Q) $(CC) -o ext2_tdbtool tdbtool.o tdb.o $(ALL_LDFLAGS) $(SYSLIBS) @@ -539,7 +545,8 @@ mkjournal: mkjournal.c $(STATIC_LIBEXT2FS) $(DEPLIBCOM_ERR) fullcheck check:: tst_bitops tst_badblocks tst_iscan tst_types tst_icount \ tst_super_size tst_types tst_inode_size tst_csum tst_crc32c tst_bitmaps \ tst_inline tst_inline_data tst_libext2fs tst_sha256 tst_sha512 \ - tst_digest_encode tst_getsize tst_getsectsize tst_bitmaps_standalone + tst_digest_encode tst_getsize tst_getsectsize tst_bitmaps_standalone \ + tst_bitmaps_pthread $(TESTENV) ./tst_bitops $(TESTENV) ./tst_badblocks $(TESTENV) ./tst_iscan @@ -563,6 +570,7 @@ fullcheck check:: tst_bitops tst_badblocks tst_iscan tst_types tst_icount \ diff $(srcdir)/tst_bitmaps_exp tst_bitmaps_out $(TESTENV) ./tst_digest_encode $(TESTENV) ./tst_bitmaps_standalone + $(TESTENV) ./tst_bitmaps_pthread installdirs:: $(E) " MKDIR_P $(libdir) $(includedir)/ext2fs" @@ -598,6 +606,7 @@ clean:: tst_bitmaps tst_bitmaps_out tst_extents tst_inline \ tst_inline_data tst_inode_size tst_bitmaps_cmd.c \ tst_digest_encode tst_sha256 tst_sha512 tst_bitmaps_standalone \ + tst_bitmaps_pthread \ ext2_tdbtool mkjournal debug_cmds.c tst_cmds.c extent_cmds.c \ ../libext2fs.a ../libext2fs_p.a ../libext2fs_chk.a \ crc32c_table.h gen_crc32ctable tst_crc32c tst_libext2fs \ @@ -1169,6 +1178,12 @@ tst_bitmaps_standalone.o: $(srcdir)/tst_bitmaps_standalone.c $(top_builddir)/lib $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ $(srcdir)/ext2_ext_attr.h $(srcdir)/hashmap.h $(srcdir)/bitops.h +tst_bitmaps_pthread.o: $(srcdir)/tst_bitmaps_pthread.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/ext2_fs.h \ + $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ + $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ + $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(srcdir)/ext2_ext_attr.h $(srcdir)/hashmap.h $(srcdir)/bitops.h undo_io.o: $(srcdir)/undo_io.c $(top_builddir)/lib/config.h \ $(top_builddir)/lib/dirpaths.h $(srcdir)/ext2_fs.h \ $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ diff --git a/lib/ext2fs/tst_bitmaps_pthread.c b/lib/ext2fs/tst_bitmaps_pthread.c new file mode 100644 index 00000000..2ce389b0 --- /dev/null +++ b/lib/ext2fs/tst_bitmaps_pthread.c @@ -0,0 +1,247 @@ +#include "config.h" +#include +#include +#include +#if HAVE_UNISTD_H +#include +#endif +#include +#include +#include +#include +#if HAVE_ERRNO_H +#include +#endif +#if HAVE_PTHREAD +#include +#endif + +#include "ext2_fs.h" +#include "ext2fs.h" + +/* + * In this test we first setup used_bitmap by setting some random bits. + * This used_bitmap is then scanned in parallel by two threads, each scanning + * upto nr_bits/2 and setting their respective child_bitmap. + * Then once both threads finishes, we merge the child_bitmap_1/2 into + * parent_bitmap which then is used to compare against used_bitmap. + * In the end used_bitmap bits should match with parent_bitmap. + * + * Note we use EXT2FS_BMAP64_BITARRAY always for used_bitmap, this is because + * EXT2FS_BMAP64_RBTREE does not support parallel scan due to rcursor + * optimization. + */ + +int test_fail = 0; +ext2fs_generic_bitmap child_bitmap1, child_bitmap2, parent_bitmap; +ext2fs_generic_bitmap used_bitmap; +pthread_t pthread_infos[2]; + +#define nr_bits 8192 +int nr_threads = 2; +int bitmap_type[2] = {EXT2FS_BMAP64_BITARRAY, EXT2FS_BMAP64_RBTREE}; + +void dump_bitmap(ext2fs_generic_bitmap bmap, unsigned int start, unsigned num) +{ + unsigned char *buf; + errcode_t retval; + int i, len = (num - start + 7) / 8; + + buf = malloc(len); + if (!buf) { + com_err("dump_bitmap", 0, "couldn't allocate buffer"); + return; + } + memset(buf, 0, len); + retval = ext2fs_get_generic_bmap_range(bmap, (__u64) start, num, buf); + if (retval) { + com_err("dump_bitmap", retval, + "while calling ext2fs_generic_bmap_range"); + free(buf); + return; + } + for (i=len-1; i >= 0; i--) + printf("%02x ", buf[i]); + printf("\n"); + printf("bits set: %u\n", ext2fs_bitcount(buf, len)); + free(buf); +} + +int should_mark_bit() +{ + return rand() % 2 == 0; +} + +void alloc_bitmaps(int type) +{ + errcode_t retval; + + retval = ext2fs_alloc_generic_bmap(NULL, EXT2_ET_MAGIC_GENERIC_BITMAP64, + type, 0, nr_bits, nr_bits, + "child bitmap1", &child_bitmap1); + if (retval) + goto out; + + retval = ext2fs_alloc_generic_bmap(NULL, EXT2_ET_MAGIC_GENERIC_BITMAP64, + type, 0, nr_bits, nr_bits, + "child bitmap2", &child_bitmap2); + if (retval) + goto out; + + retval = ext2fs_alloc_generic_bmap(NULL, EXT2_ET_MAGIC_GENERIC_BITMAP64, + type, 0, nr_bits, nr_bits, + "parent bitmap", &parent_bitmap); + if (retval) + goto out; + + /* + * Note that EXT2FS_BMAP64_RBTREE doesn't support parallel read. + * this is due to a optimization of maintaining a read cursor within + * rbtree bitmap implementation. + */ + retval = ext2fs_alloc_generic_bmap(NULL, EXT2_ET_MAGIC_GENERIC_BITMAP64, + EXT2FS_BMAP64_BITARRAY, 0, nr_bits, nr_bits, + "used bitmap", &used_bitmap); + if (retval) + goto out; + + return; +out: + com_err("alloc_bitmaps", retval, "while allocating bitmaps\n"); + exit(1); +} + +void setup_bitmaps() +{ + int i = 0; + errcode_t retval; + + /* + * Note we cannot setup used_bitmap in parallel w/o locking. + * Hence setting up the used_bitmap (random bits) here before + * starting pthreads. + */ + for (i = 0; i < nr_bits; i++) { + if (should_mark_bit()) + ext2fs_mark_generic_bmap(used_bitmap, i); + } +} + +static void *run_pthread(void *arg) +{ + int i = 0, j = 0, start, end; + ext2fs_generic_bitmap test_bitmap; + errcode_t retval = 0; + pthread_t id = pthread_self(); + + if (pthread_equal(pthread_infos[0], id)) { + start = 0; + end = nr_bits/2; + test_bitmap = child_bitmap1; + } else { + start = nr_bits / 2 + 1;; + end = nr_bits - 1; + test_bitmap = child_bitmap2; + } + + for (i = start; i <= end; i++) { + if (ext2fs_test_generic_bmap(used_bitmap, i)) { + retval = ext2fs_mark_generic_bmap(test_bitmap, i); + if (retval) { + com_err("run_pthread", retval, "while marking child bitmaps %d\n", i); + test_fail++; + pthread_exit(&retval); + } + } + } + return NULL; +} + +void run_pthreads() +{ + errcode_t retval; + void *retp[2]; + int i; + + for (i = 0; i < nr_threads; i++) { + printf("Starting thread (%d)\n", i); + retval = pthread_create(&pthread_infos[i], NULL, &run_pthread, NULL); + if (retval) { + com_err("run_pthreads", retval, "while pthread_create"); + exit(1); + } + } + + for (i = 0; i < nr_threads; i++) { + void *status; + int ret; + retval = pthread_join(pthread_infos[i], &status); + if (retval) { + com_err("run_pthreads", retval, "while joining pthreads"); + exit(1); + + } + ret = status == NULL ? 0 : *(int*)status; + if (ret) { + com_err("run_pthreads", ret, "pthread returned error"); + test_fail++; + } + + printf("Closing thread (%d), ret(%d)\n", i, ret); + } + + assert(ext2fs_merge_bitmap(child_bitmap1, parent_bitmap, NULL, NULL) == 0); + assert(ext2fs_merge_bitmap(child_bitmap2, parent_bitmap, NULL, NULL) == 0); +} + +void test_bitmaps(int type) +{ + errcode_t retval; + retval = ext2fs_compare_generic_bmap(EXT2_ET_NEQ_BLOCK_BITMAP, parent_bitmap, + used_bitmap); + if (retval) { + test_fail++; + printf("Bitmaps compare failed for bitmap type %d err %ld\n", type, retval); + dump_bitmap(parent_bitmap, 0, nr_bits); + dump_bitmap(used_bitmap, 0, nr_bits); + } +} + +void free_bitmaps() +{ + ext2fs_free_generic_bmap(child_bitmap1); + ext2fs_free_generic_bmap(child_bitmap2); + ext2fs_free_generic_bmap(parent_bitmap); + ext2fs_free_generic_bmap(used_bitmap); +} + +int main(int argc, char *argv[]) +{ + int i; + int ret = 0; + +#ifndef HAVE_PTHREAD + printf("No PTHREAD support, exiting...\n"); + return ret; +#endif + + srand(time(0)); + + /* loop to test for both bitmap types */ + for (i = 0; i < 2; i++) { + test_fail = 0; + alloc_bitmaps(i); + setup_bitmaps(); + run_pthreads(); + test_bitmaps(i); + free_bitmaps(); + + if (test_fail) + printf("%s: Test with bitmap (%d) NOT OK!!\n", argv[0], bitmap_type[i]); + else + printf("%s: Test with bitmap (%d) OK!!\n", argv[0], bitmap_type[i]); + ret |= test_fail; + } + + return ret; +} From patchwork Mon Jul 4 07:06:58 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651796 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=nQ7nVDFX; dkim-atps=neutral Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4Lbxjf6H53z9s5V for ; Mon, 4 Jul 2022 17:08:38 +1000 (AEST) Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxjf5Wpdz4xYN for ; Mon, 4 Jul 2022 17:08:38 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4Lbxjf5Tdsz4xYV; Mon, 4 Jul 2022 17:08:38 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=nQ7nVDFX; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxjf5PMhz4xYN for ; Mon, 4 Jul 2022 17:08:38 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232878AbiGDHIi (ORCPT ); Mon, 4 Jul 2022 03:08:38 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37576 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233139AbiGDHIQ (ORCPT ); Mon, 4 Jul 2022 03:08:16 -0400 Received: from mail-pl1-x62a.google.com (mail-pl1-x62a.google.com [IPv6:2607:f8b0:4864:20::62a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B564B95BF for ; Mon, 4 Jul 2022 00:08:00 -0700 (PDT) Received: by mail-pl1-x62a.google.com with SMTP id b2so7789834plx.7 for ; Mon, 04 Jul 2022 00:08:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=osN1zLxDu8E/B6/6OijtO4BtJe1tGgZdZcrNyYXTrSg=; b=nQ7nVDFXzmU8ucbxuY2FsQFraO+zWATtR4+hQTsHYiKWBVvSsX5U36hlDQiNtslWtj ppjiiRbAifyp8jLAwIKIKfZYKbn8OG+IC1k+mwEHdpaCVGz54HFRS8JfR9euB+tCoq9t Uj+NkFGmkXTESsHPIkrViWLZN+oUWrOXmH+OaE6yT2ZrZRHqLk+VqDT4Ni+AkJtIZ/Yl hmS+BJg9Wnn0OjFQIlqpxvQHnWkshsH/+0IFU019TNkjgVjjUwh4da8GbuzJ7vkyCBmH PcEDq54X0ySidU6QVCTdvtaHtkafxFPLo2D0CHWWvFyB25Wg3anyzKsOVuW5szkIylo4 aIAg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=osN1zLxDu8E/B6/6OijtO4BtJe1tGgZdZcrNyYXTrSg=; b=7ZKxXsQsnCKtO1QHAXhtN0denBS/RFGra6tJhZh5zJFNt+DyjikP4OS5Ovwnhde7cf BdLNnvAjfvmZs4SI3MNK+jP+OGJkZOB2bu9OsVRbzslhcBbl4WF+rOFYMXXE4wjK7AQz iMM9OXSAffMysXiXHMlWH6tG/cjLzJInZYrUlD+RrfTeLFPjtA50tFeUGN+h41OstCBg KKe+BbccL/QpJF+kogaSDhgJWgrDNU6PQw/ksXZv9bA6NBsXZzXWydPH7IZcUf5E0o0i 60GJMuZPEk4yycEMYlYagqxO9l8c5E7TkHnWjxMM56xBiYHTAreXbgUzt6f8n1ttn+/B wnzQ== X-Gm-Message-State: AJIora/K3WjVi80up38gc02d0vMOj4UNo4ft0y9hrTPAm+NYlP5PukdS +ZMgoBucE2nFSXc2FoUt9KLuR2W8noU= X-Google-Smtp-Source: AGRyM1vOPv+Ld95o8aujKwDbP/JhEyr/qN59DIN4g+HAUN5Kwe/tK5bVDINYOjblSOzGcC72RUZZxg== X-Received: by 2002:a17:902:c94b:b0:16a:6427:ae5d with SMTP id i11-20020a170902c94b00b0016a6427ae5dmr34244375pla.127.1656918480427; Mon, 04 Jul 2022 00:08:00 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id x124-20020a626382000000b00525231e15ccsm20252107pfb.113.2022.07.04.00.07.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:08:00 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Wang Shilong , Ritesh Harjani Subject: [RFC 09/13] badblocks: Add badblocks merge logic Date: Mon, 4 Jul 2022 12:36:58 +0530 Message-Id: X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org From: Wang Shilong Add badblocks merge logic Signed-off-by: Wang Shilong Signed-off-by: Ritesh Harjani --- lib/ext2fs/badblocks.c | 75 ++++++++++++++++++++++++++++++++++++++++++ lib/ext2fs/ext2fs.h | 2 ++ 2 files changed, 77 insertions(+) diff --git a/lib/ext2fs/badblocks.c b/lib/ext2fs/badblocks.c index 0570b131..48968adc 100644 --- a/lib/ext2fs/badblocks.c +++ b/lib/ext2fs/badblocks.c @@ -56,6 +56,74 @@ static errcode_t make_u32_list(int size, int num, __u32 *list, return 0; } +static inline int insert_ok(blk_t *array, int cnt, blk_t new) +{ + return (cnt == 0 || array[cnt - 1] != new); +} + +/* + * Merge list from src to dest + */ +static errcode_t merge_u32_list(ext2_u32_list src, ext2_u32_list dest) +{ + errcode_t retval; + int src_count = src->num; + int dest_count = dest->num; + int size = src_count + dest_count; + int size_entry = sizeof(blk_t); + blk_t *array; + blk_t *src_array = src->list; + blk_t *dest_array = dest->list; + int src_index = 0; + int dest_index = 0; + int uniq_cnt = 0; + + if (src->num == 0) + return 0; + + retval = ext2fs_get_array(size, size_entry, &array); + if (retval) + return retval; + + /* + * It is possible that src list and dest list could be + * duplicated when merging badblocks. + */ + while (src_index < src_count || dest_index < dest_count) { + if (src_index >= src_count) { + for (; dest_index < dest_count; dest_index++) + if (insert_ok(array, uniq_cnt, dest_array[dest_index])) + array[uniq_cnt++] = dest_array[dest_index]; + break; + } + if (dest_index >= dest_count) { + for (; src_index < src_count; src_index++) + if (insert_ok(array, uniq_cnt, src_array[src_index])) + array[uniq_cnt++] = src_array[src_index]; + break; + } + if (src_array[src_index] < dest_array[dest_index]) { + if (insert_ok(array, uniq_cnt, src_array[src_index])) + array[uniq_cnt++] = src_array[src_index]; + src_index++; + } else if (src_array[src_index] > dest_array[dest_index]) { + if (insert_ok(array, uniq_cnt, dest_array[dest_index])) + array[uniq_cnt++] = dest_array[dest_index]; + dest_index++; + } else { + if (insert_ok(array, uniq_cnt, dest_array[dest_index])) + array[uniq_cnt++] = dest_array[dest_index]; + src_index++; + dest_index++; + } + } + + ext2fs_free_mem(&dest->list); + dest->list = array; + dest->num = uniq_cnt; + dest->size = size; + return 0; +} /* * This procedure creates an empty u32 list. @@ -91,6 +159,13 @@ errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src, (ext2_u32_list *) dest); } +errcode_t ext2fs_badblocks_merge(ext2_badblocks_list src, + ext2_badblocks_list dest) +{ + return merge_u32_list((ext2_u32_list) src, + (ext2_u32_list) dest); +} + /* * This procedure frees a badblocks list. * diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h index c18849d7..13404f3d 100644 --- a/lib/ext2fs/ext2fs.h +++ b/lib/ext2fs/ext2fs.h @@ -844,6 +844,8 @@ extern int ext2fs_badblocks_list_iterate(ext2_badblocks_iterate iter, extern void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter); extern errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src, ext2_badblocks_list *dest); +extern errcode_t ext2fs_badblocks_merge(ext2_badblocks_list src, + ext2_badblocks_list dest); extern int ext2fs_badblocks_equal(ext2_badblocks_list bb1, ext2_badblocks_list bb2); extern int ext2fs_u32_list_count(ext2_u32_list bb); From patchwork Mon Jul 4 07:06:59 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651797 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=B7h7eERj; dkim-atps=neutral Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4Lbxk15pLrz9s5V for ; Mon, 4 Jul 2022 17:08:57 +1000 (AEST) Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxk1547bz4xLX for ; Mon, 4 Jul 2022 17:08:57 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4Lbxk1510Sz4xTq; Mon, 4 Jul 2022 17:08:57 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=B7h7eERj; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxk14tKkz4xLX for ; Mon, 4 Jul 2022 17:08:57 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233327AbiGDHI4 (ORCPT ); Mon, 4 Jul 2022 03:08:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37680 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232631AbiGDHIY (ORCPT ); Mon, 4 Jul 2022 03:08:24 -0400 Received: from mail-pf1-x430.google.com (mail-pf1-x430.google.com [IPv6:2607:f8b0:4864:20::430]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C2FE8764A for ; Mon, 4 Jul 2022 00:08:05 -0700 (PDT) Received: by mail-pf1-x430.google.com with SMTP id d17so8140962pfq.9 for ; Mon, 04 Jul 2022 00:08:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=zMrOHCrGDXxXx4NXrcEuArp+ayo87mwIW1zD8gmhVr4=; b=B7h7eERjREtbWs+Uc1tB0yD35B3KdfmH3hs+lRpaOG2BO43lxf5d9gDvEqoVrwO79x xVEgI8mIU293+OEZhs2bc8lRbZ330fpsMpdojKMzsWIHlI3jlaaRQ7YsMZjdB/1WbRYV 1eyD22OpuS8Zd90Zc1QVUWoP4xsiRf0ZGpZLk2xuT5v8dfl2yrjDl9OcloBO/TdvAH6+ rOET2/b3yz3/YB8Cx/C5bRaqWG8VGBRewNiKRhfP7msWEDX8are5jOFmRB0n425dDaLV eQYfylMc9lZqVfdrwK4P+3rlAB30g63J2TOInE/sIDJwXIVHiakeiRmH57FZuIssHXuJ ciOw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=zMrOHCrGDXxXx4NXrcEuArp+ayo87mwIW1zD8gmhVr4=; b=RqskcaQUIeO1jnD9FnFZAiZApd3RPU92cly16jKvMHpCfOOtLstF2lPVz7G2S5jprL y4JGQ9tf0+C52Z/Sp5p0fYq6ZecN0GJSakle5SPGAu34Vq1bS0yznLE+qG1Ua8xyyNLO ZhH2EyRKp7Kd+w8VqxchLBfSzdeK4HlirtelHtaryZy2n4azmGC3TYiMx61Fd7K3QfUT 1MOiFiXbVlhLlLfU3XDZv1lOEZaV55pyDiYGX4PmakXKFykxcOxDeC50sXZ185oMyTIG hMZ3zfHz0w4FYcM3CFKowC2/74JoxkCdVgeLgPyNe1rNRXm3cAhT5Ky6YuP1k+KsCH3L NnKA== X-Gm-Message-State: AJIora+7VFByxNrpSqt+2MMYKTVtyfdwd28LnryUPhcM99ZNaQgQG+tQ 1uq2DGBHCe3aE2rdTO3TP/s= X-Google-Smtp-Source: AGRyM1sp4DGXDtWRV1HG7nHaunpgNyp5vVbmo+1omdkKeCFfelHNaGNwb8Urdt5VfqYCYZ03p1cB4A== X-Received: by 2002:a63:6f01:0:b0:412:35fa:62dc with SMTP id k1-20020a636f01000000b0041235fa62dcmr4790432pgc.490.1656918485303; Mon, 04 Jul 2022 00:08:05 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id z2-20020a170903018200b0016bea74d11esm255596plg.267.2022.07.04.00.08.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:08:05 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Ritesh Harjani Subject: [RFC 10/13] tst_badblocks: Add unit test to verify badblocks list merge api Date: Mon, 4 Jul 2022 12:36:59 +0530 Message-Id: X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org Add unit test to verify badblocks list merge api i.e. ext2fs_badblocks_merge() Signed-off-by: Ritesh Harjani --- lib/ext2fs/tst_badblocks.c | 61 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 59 insertions(+), 2 deletions(-) diff --git a/lib/ext2fs/tst_badblocks.c b/lib/ext2fs/tst_badblocks.c index b6e766ab..946de0ae 100644 --- a/lib/ext2fs/tst_badblocks.c +++ b/lib/ext2fs/tst_badblocks.c @@ -119,6 +119,40 @@ static void print_list(badblocks_list bb, int verify) } } +static void do_list_merge_verify(badblocks_list bb, badblocks_list bbm, int verify) +{ + errcode_t retval; + badblocks_iterate iter; + blk_t blk; + int i, ok; + + retval = ext2fs_badblocks_merge(bb, bbm); + if (retval) { + com_err("do_list_merge_verify", retval, "while doing list merge"); + return; + } + + if (!verify) + return; + + retval = ext2fs_badblocks_list_iterate_begin(bb, &iter); + if (retval) { + com_err("do_list_merge_verify", retval, "while setting up iterator"); + return; + } + + while (ext2fs_badblocks_list_iterate(iter, &blk)) { + retval = ext2fs_badblocks_list_test(bbm, blk); + if (retval == 0) { + printf(" --- NOT OK\n"); + test_fail++; + return; + } + } + ext2fs_badblocks_list_iterate_end(iter); + printf(" --- OK\n"); +} + static void validate_test_seq(badblocks_list bb, blk_t *vec) { int i, match, ok; @@ -275,13 +309,13 @@ out: int main(int argc, char **argv) { - badblocks_list bb1, bb2, bb3, bb4, bb5; + badblocks_list bb1, bb2, bb3, bb4, bb5, bbm; int equal; errcode_t retval; add_error_table(&et_ext2_error_table); - bb1 = bb2 = bb3 = bb4 = bb5 = 0; + bb1 = bb2 = bb3 = bb4 = bb5 = bbm = 0; printf("test1: "); retval = create_test_list(test1, &bb1); @@ -346,6 +380,27 @@ int main(int argc, char **argv) printf("\n"); } + printf("Create merge bb list\n"); + retval = ext2fs_badblocks_list_create(&bbm, 5); + if (retval) { + com_err("ext2fs_badblocks_list_create", retval, "while creating list"); + test_fail++; + } + + printf("Merge & Verify all bb{1..5} into bbm\n"); + if (bb1 && bb2 && bb3 && bb4 && bb5 && bbm) { + printf("Merge bb1 into bbm"); + do_list_merge_verify(bb1, bbm, 1); + printf("Merge bb2 into bbm"); + do_list_merge_verify(bb2, bbm, 1); + printf("Merge bb3 into bbm"); + do_list_merge_verify(bb3, bbm, 1); + printf("Merge bb4 into bbm"); + do_list_merge_verify(bb4, bbm, 1); + printf("Merge bb5 into bbm"); + do_list_merge_verify(bb5, bbm, 1); + } + file_test(bb4); file_test_invalid(bb4); @@ -363,6 +418,8 @@ int main(int argc, char **argv) ext2fs_badblocks_list_free(bb4); if (bb5) ext2fs_badblocks_list_free(bb5); + if (bbm) + ext2fs_badblocks_list_free(bbm); return test_fail; From patchwork Mon Jul 4 07:07:00 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651798 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=TXiw0LZq; dkim-atps=neutral Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4Lbxk63FtJz9s5V for ; Mon, 4 Jul 2022 17:09:02 +1000 (AEST) Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxk62W08z4xLX for ; Mon, 4 Jul 2022 17:09:02 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4Lbxk62Stwz4xTq; Mon, 4 Jul 2022 17:09:02 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=TXiw0LZq; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4Lbxk62NdHz4xLX for ; Mon, 4 Jul 2022 17:09:02 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232757AbiGDHJA (ORCPT ); Mon, 4 Jul 2022 03:09:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38378 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233185AbiGDHI0 (ORCPT ); Mon, 4 Jul 2022 03:08:26 -0400 Received: from mail-pg1-x534.google.com (mail-pg1-x534.google.com [IPv6:2607:f8b0:4864:20::534]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8D5A7767E for ; Mon, 4 Jul 2022 00:08:10 -0700 (PDT) Received: by mail-pg1-x534.google.com with SMTP id q82so973603pgq.6 for ; Mon, 04 Jul 2022 00:08:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=61QF0rV6HZH/llIqxkdA82tHg1T06f5jzZhwYMeFmUM=; b=TXiw0LZqjFYLpgewN43Yk3pF+fp5dRlA10fKCmYDdnzEaTyVmbDDktN6PES1plqtv5 yQHpfHrgkVuEDjAmEnffnRhxkP6PxbNFbIHXOrd0bw6RqECeKZpflYhZw/2bUoQl8lml NeGk1Ietu0m55x6in8/qvG9uHEaUtHomy3kOFN/H3qG5uFmtKWkO/Bs/V90nyIn7UO/2 TFmumAXGi+DHAMea3FnG/xB/I1u/AWosLjG0FdAwV0fCU7/FiG/hlKNiwiPVaXAveuRS eVX50b6hfFaOWy5ijpC1+04Ymaeb4qoIc1KTgRqzTdzOZ2Doyjr5HpNyRynZQitraUEB UF9A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=61QF0rV6HZH/llIqxkdA82tHg1T06f5jzZhwYMeFmUM=; b=gbHuVa6h6TflC3I6foB+DTrPddHmeAbGSL4Up8n97oBoG6CD2lfMUr45Wy74Oixq3D t2HJAFKd/FQILlbjDf7ALi74m8xmAR+VPfkXxgq5112IqcySHxTGsJlD6pIahQGUCVy7 RPmOfyLLN5ECE0K5JG//XcbHsKAy/q0a/fog7FiX6LSMm0Yp2jiiGrfAEmXUA+ftn0o3 N8YX792CrPTpfvMuhcHrUX/xDBmGdPIcEsCXuj7eK058TdFZVajsdpqOhEhHcXY/q4e4 r8XaYolxiqGFXWIqpIUC9jKaiug/Zk1hoBRMqvadfGbsuILxPtMIZnbiqaOkczuny0Nw VPKA== X-Gm-Message-State: AJIora8O/K46a2AkO5Mj8rOqzchIQcTggFrOzHBqHpxWhVH9rndy+ybE U0y6hiXsOFPQkGfYu++8o8o= X-Google-Smtp-Source: AGRyM1tKtLeAdJQNjATP/lmK1MsxXij9mJ0MFiwDuGqstOpIx9fuGFyf3x92dvzjvLJRYhq9wB8miw== X-Received: by 2002:a63:8b42:0:b0:40d:a82d:49da with SMTP id j63-20020a638b42000000b0040da82d49damr23171138pge.186.1656918490119; Mon, 04 Jul 2022 00:08:10 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id lp11-20020a17090b4a8b00b001ef82d23125sm2430879pjb.25.2022.07.04.00.08.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:08:09 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Li Xi , Ritesh Harjani Subject: [RFC 11/13] dblist: add dblist merge logic Date: Mon, 4 Jul 2022 12:37:00 +0530 Message-Id: <6150cdbeaeb1bb94a8cda5f138b6206362958d94.1656912918.git.ritesh.list@gmail.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org From: Li Xi This adds dblist merge logic. TODO: Add a unit test for core operations of dblist. Currently there is no such test for this. Signed-off-by: Li Xi Signed-off-by: Ritesh Harjani --- lib/ext2fs/dblist.c | 36 ++++++++++++++++++++++++++++++++++++ lib/ext2fs/ext2fs.h | 1 + 2 files changed, 37 insertions(+) diff --git a/lib/ext2fs/dblist.c b/lib/ext2fs/dblist.c index bbdb221d..5568b8ec 100644 --- a/lib/ext2fs/dblist.c +++ b/lib/ext2fs/dblist.c @@ -119,6 +119,42 @@ errcode_t ext2fs_copy_dblist(ext2_dblist src, ext2_dblist *dest) return 0; } +/* + * Merge a directory block list @src to @dest + */ +errcode_t ext2fs_merge_dblist(ext2_dblist src, ext2_dblist dest) +{ + unsigned long long src_count = src->count; + unsigned long long dest_count = dest->count; + unsigned long long size = src_count + dest_count; + size_t size_entry = sizeof(struct ext2_db_entry2); + struct ext2_db_entry2 *array, *array2; + errcode_t retval; + + if (src_count == 0) + return 0; + + if (src->sorted || (dest->sorted && dest_count != 0)) + return EINVAL; + + retval = ext2fs_get_array(size, size_entry, &array); + if (retval) + return retval; + + array2 = array; + memcpy(array, src->list, src_count * size_entry); + array += src_count; + memcpy(array, dest->list, dest_count * size_entry); + ext2fs_free_mem(&dest->list); + + dest->list = array2; + dest->count = src_count + dest_count; + dest->size = size; + dest->sorted = 0; + + return 0; +} + /* * Close a directory block list * diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h index 13404f3d..29e7be9f 100644 --- a/lib/ext2fs/ext2fs.h +++ b/lib/ext2fs/ext2fs.h @@ -1146,6 +1146,7 @@ extern errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ext2_ino_t ino, blk_t blk, int blockcnt); extern errcode_t ext2fs_add_dir_block2(ext2_dblist dblist, ext2_ino_t ino, blk64_t blk, e2_blkcnt_t blockcnt); +extern errcode_t ext2fs_merge_dblist(ext2_dblist src, ext2_dblist dest); extern void ext2fs_dblist_sort(ext2_dblist dblist, EXT2_QSORT_TYPE (*sortfunc)(const void *, const void *)); From patchwork Mon Jul 4 07:07:01 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651799 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=QZzBsBPh; dkim-atps=neutral Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4LbxkH5JhPz9s5V for ; Mon, 4 Jul 2022 17:09:11 +1000 (AEST) Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxkH4cGGz4xTq for ; Mon, 4 Jul 2022 17:09:11 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4LbxkH4Ykvz4xYN; Mon, 4 Jul 2022 17:09:11 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=QZzBsBPh; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxkH4Tkbz4xTq for ; Mon, 4 Jul 2022 17:09:11 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233360AbiGDHJJ (ORCPT ); Mon, 4 Jul 2022 03:09:09 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37576 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233285AbiGDHIh (ORCPT ); Mon, 4 Jul 2022 03:08:37 -0400 Received: from mail-pl1-x633.google.com (mail-pl1-x633.google.com [IPv6:2607:f8b0:4864:20::633]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 899A7A1B3 for ; Mon, 4 Jul 2022 00:08:15 -0700 (PDT) Received: by mail-pl1-x633.google.com with SMTP id r1so7782544plo.10 for ; Mon, 04 Jul 2022 00:08:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0OdDJ8Ll6jnmyqNdDp5R05dgXG5b+P+Hxpz6eY0JP2E=; b=QZzBsBPhjVTooozwl9TsDpu7iDyYLqXm5MvOhdVfDF23/oAcC+DUn+CxKtaVvBbez9 UHWH1f6Ci9ZhXwaDDxJZrRtSOL+Ynmxq9o8hLbvA6e3zVI+QI7JraTIXk8e4HTroZVRt BeMYL/nFLz3mb2w6CoqJw1iTNJRWJ7LGUDSyNEIZNfZTxnXB0hSamzTyvOU7Gy35NQBa 8hKj4+l+WqK5hYhEGSvJCoBNyVK4o4TdVlJURTOT7M2GkyTdwGyYd7M2Yb1ynTW99mAx VAq/xqNV5ZLu70gF+0Yx0fJw6fURaFyJUekK4IoY73o1okybSJXNuV1SecaTWtV2DkrZ U00Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0OdDJ8Ll6jnmyqNdDp5R05dgXG5b+P+Hxpz6eY0JP2E=; b=70NFfBH8jze3Q4GYQRDSNnNdiI5ndz8ogJ0xMLKfOwWCpTViLNdyX5n1vkuCWwNJEE /kDYPRYdqYWc7cF2Sb2EjpvcSOVofymlvZjkG76FEjNGfz/0PznLXq2lPkfLZk/rbOOy o1pCB1v81Rj2GvZArFYXtxInhxFCe8Mt1iKF6n8SB8s9q+8OTTWlzCNSJhlhGcgGuEgV 00e9SNZqsi2NS+tNA+JRL37A4N2onWfI8+nqGNHLhOqnRutFKDHQNAvUXZG2MqEpcXGY PK30Z9JpfYopglw343yPEMEDVdwJQTD87g6P/xoktSrI+oFkWsAn5BQYnNasOFozKgKX HMLQ== X-Gm-Message-State: AJIora8OuPHghmABXSZ6AYe3lFmAnUVWiIg/rrC+aWvuf9PN9BELyg3c 7/oLzzFnuUNSpeisDdF7/6c= X-Google-Smtp-Source: AGRyM1ubtYwureZopdoXNzbrt1EixJssNE62Y4nAWqmKSo5HgghcNda5qCmE/pTkKjLx7A2DMT8Cxw== X-Received: by 2002:a17:90b:4ac3:b0:1ef:66b4:9e with SMTP id mh3-20020a17090b4ac300b001ef66b4009emr15264673pjb.92.1656918495042; Mon, 04 Jul 2022 00:08:15 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id x10-20020a1709027c0a00b0016a6caacaefsm19770124pll.103.2022.07.04.00.08.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:08:14 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Saranya Muruganandam , Ritesh Harjani Subject: [RFC 12/13] libext2fs: dupfs: Add fs clone & merge api Date: Mon, 4 Jul 2022 12:37:01 +0530 Message-Id: X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org From: Saranya Muruganandam This patch mainly adds "parent" & "clone_flags" member in ext2_filsys struct for enabling multi-threading. Based on what CLONE flags will be passed from the client of libext2fs down to ext2fs_clone_fs(), those structures/bitmaps will be cloned (thread-aware child copy) and rest will be shared with the parent fs. The same flags will also help to merge those cloned bitmap structures back into the parent bitmaps when ext2fs_merge_fs() will be called with childfs struct. Review couple of todos within the patch. 1. I think we don't need refcount here. 2. For io_channel_close(), I think that might be required here (even though earlier I thought it should be done by the caller), before freeing childfs. Signed-off-by: Saranya Muruganandam [added todos, modified naming, used #ifdef HAVE_PTHREAD, small bug fix in calling io_channel_close(), later added a test case against this patch] Signed-off-by: Ritesh Harjani --- lib/ext2fs/dupfs.c | 149 ++++++++++++++++++++++++++++++++++++++++++++ lib/ext2fs/ext2fs.h | 24 +++++++ 2 files changed, 173 insertions(+) -- 2.35.3 diff --git a/lib/ext2fs/dupfs.c b/lib/ext2fs/dupfs.c index 02721e1a..8500a82c 100644 --- a/lib/ext2fs/dupfs.c +++ b/lib/ext2fs/dupfs.c @@ -14,8 +14,12 @@ #if HAVE_UNISTD_H #include #endif +#if HAVE_PTHREAD_H +#include +#endif #include #include +#include #include "ext2_fs.h" #include "ext2fsP.h" @@ -120,3 +124,148 @@ errout: } +#ifdef HAVE_PTHREAD +errcode_t ext2fs_clone_fs(ext2_filsys fs, ext2_filsys *dest, unsigned int flags) +{ + errcode_t retval; + ext2_filsys childfs; + + EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); + + retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &childfs); + if (retval) + return retval; + + /* make an exact copy implying lists and memory structures are shared */ + memcpy(childfs, fs, sizeof(struct struct_ext2_filsys)); + childfs->inode_map = NULL; + childfs->block_map = NULL; + childfs->badblocks = NULL; + childfs->dblist = NULL; + + pthread_mutex_lock(&fs->refcount_mutex); + fs->refcount++; + pthread_mutex_unlock(&fs->refcount_mutex); + + if ((flags & EXT2FS_CLONE_INODE) && fs->inode_map) { + retval = ext2fs_copy_bitmap(fs->inode_map, &childfs->inode_map); + if (retval) + return retval; + childfs->inode_map->fs = childfs; + } + + if ((flags & EXT2FS_CLONE_BLOCK) && fs->block_map) { + retval = ext2fs_copy_bitmap(fs->block_map, &childfs->block_map); + if (retval) + return retval; + childfs->block_map->fs = childfs; + } + + if ((flags & EXT2FS_CLONE_BADBLOCKS) && fs->badblocks) { + retval = ext2fs_badblocks_copy(fs->badblocks, &childfs->badblocks); + if (retval) + return retval; + } + + if ((flags & EXT2FS_CLONE_DBLIST) && fs->dblist) { + retval = ext2fs_copy_dblist(fs->dblist, &childfs->dblist); + if (retval) + return retval; + childfs->dblist->fs = childfs; + } + + /* icache when NULL will be rebuilt if needed */ + childfs->icache = NULL; + + childfs->clone_flags = flags; + childfs->parent = fs; + *dest = childfs; + + return 0; +} + +errcode_t ext2fs_merge_fs(ext2_filsys fs) +{ + errcode_t retval = 0; + ext2_filsys dest = fs->parent; + ext2_filsys src = fs; + unsigned int flags = fs->clone_flags; + + pthread_mutex_lock(&fs->refcount_mutex); + fs->refcount--; + assert(fs->refcount >= 0); + pthread_mutex_unlock(&fs->refcount_mutex); + + if ((flags & EXT2FS_CLONE_INODE) && src->inode_map) { + if (dest->inode_map == NULL) { + dest->inode_map = src->inode_map; + src->inode_map = NULL; + } else { + retval = ext2fs_merge_bitmap(src->inode_map, dest->inode_map, NULL, NULL); + if (retval) + goto out; + } + dest->inode_map->fs = dest; + } + + if ((flags & EXT2FS_CLONE_BLOCK) && src->block_map) { + if (dest->block_map == NULL) { + dest->block_map = src->block_map; + src->block_map = NULL; + } else { + retval = ext2fs_merge_bitmap(src->block_map, dest->block_map, NULL, NULL); + if (retval) + goto out; + } + dest->block_map->fs = dest; + } + + if ((flags & EXT2FS_CLONE_BADBLOCKS) && src->badblocks) { + if (dest->badblocks == NULL) + retval = ext2fs_badblocks_copy(src->badblocks, &dest->badblocks); + else + retval = ext2fs_badblocks_merge(src->badblocks, dest->badblocks); + if (retval) + goto out; + } + + if ((flags & EXT2FS_CLONE_DBLIST) && src->dblist) { + if (dest->dblist == NULL) { + dest->dblist = src->dblist; + src->dblist = NULL; + } else { + retval = ext2fs_merge_dblist(src->dblist, dest->dblist); + if (retval) + goto out; + } + dest->dblist->fs = dest; + } + + dest->flags |= src->flags; + if (!(dest->flags & EXT2_FLAG_VALID)) + ext2fs_unmark_valid(dest); + + if (src->icache) { + ext2fs_free_inode_cache(src->icache); + src->icache = NULL; + } + +out: + /* TODO check if io_channel_close is called correctly here? */ + if (src->io) + io_channel_close(src->io); + + if ((flags & EXT2FS_CLONE_INODE) && src->inode_map) + ext2fs_free_generic_bmap(src->inode_map); + if ((flags & EXT2FS_CLONE_BLOCK) && src->block_map) + ext2fs_free_generic_bmap(src->block_map); + if ((flags & EXT2FS_CLONE_BADBLOCKS) && src->badblocks) + ext2fs_badblocks_list_free(src->badblocks); + if ((flags & EXT2FS_CLONE_DBLIST) && src->dblist) + ext2fs_free_dblist(src->dblist); + + ext2fs_free_mem(&src); + + return retval; +} +#endif diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h index 29e7be9f..6daa7832 100644 --- a/lib/ext2fs/ext2fs.h +++ b/lib/ext2fs/ext2fs.h @@ -12,6 +12,10 @@ #ifndef _EXT2FS_EXT2FS_H #define _EXT2FS_EXT2FS_H +#ifdef HAVE_PTHREAD_H +#include +#endif + #ifdef __GNUC__ #define EXT2FS_ATTR(x) __attribute__(x) #else @@ -330,6 +334,14 @@ struct struct_ext2_filsys { struct ext2fs_hashmap* block_sha_map; const struct ext2fs_nls_table *encoding; + +#ifdef HAVE_PTHREAD + struct struct_ext2_filsys *parent; + /* TODO do we need refcount? */ + size_t refcount; + pthread_mutex_t refcount_mutex; + unsigned int clone_flags; +#endif }; #if EXT2_FLAT_INCLUDES @@ -1056,6 +1068,18 @@ extern errcode_t ext2fs_move_blocks(ext2_filsys fs, /* check_desc.c */ extern errcode_t ext2fs_check_desc(ext2_filsys fs); +#ifdef HAVE_PTHREAD +/* flags for ext2fs_clone_fs */ +#define EXT2FS_CLONE_BLOCK 0x0001 +#define EXT2FS_CLONE_INODE 0x0002 +#define EXT2FS_CLONE_BADBLOCKS 0x0004 +#define EXT2FS_CLONE_DBLIST 0x0008 + +extern errcode_t ext2fs_clone_fs(ext2_filsys fs, ext2_filsys *dest, + unsigned int flags); +extern errcode_t ext2fs_merge_fs(ext2_filsys fs); +#endif + /* closefs.c */ extern errcode_t ext2fs_close(ext2_filsys fs); extern errcode_t ext2fs_close2(ext2_filsys fs, int flags); From patchwork Mon Jul 4 07:07:02 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ritesh Harjani (IBM)" X-Patchwork-Id: 1651800 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=oAsnHSyk; dkim-atps=neutral Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4LbxkJ4bYnz9s5V for ; Mon, 4 Jul 2022 17:09:12 +1000 (AEST) Received: from gandalf.ozlabs.org (mail.ozlabs.org [IPv6:2404:9400:2221:ea00::3]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxkJ3wWcz4xTq for ; Mon, 4 Jul 2022 17:09:12 +1000 (AEST) Received: by gandalf.ozlabs.org (Postfix) id 4LbxkJ3sJfz4xYN; Mon, 4 Jul 2022 17:09:12 +1000 (AEST) Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: gandalf.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: gandalf.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=oAsnHSyk; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4LbxkJ2lTSz4xTq for ; Mon, 4 Jul 2022 17:09:12 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233365AbiGDHJL (ORCPT ); Mon, 4 Jul 2022 03:09:11 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37838 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233139AbiGDHIw (ORCPT ); Mon, 4 Jul 2022 03:08:52 -0400 Received: from mail-pg1-x530.google.com (mail-pg1-x530.google.com [IPv6:2607:f8b0:4864:20::530]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 87E98334 for ; Mon, 4 Jul 2022 00:08:20 -0700 (PDT) Received: by mail-pg1-x530.google.com with SMTP id v126so8130954pgv.11 for ; Mon, 04 Jul 2022 00:08:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=RZgOEi4NpROOamHbjmumfavu3nkycozTSLXnJaf/zfw=; b=oAsnHSyk2BRDWAxWZfczzNzyryBpKOLgx0gkat6F/KD28bIvPaRPpnNBbFr+2OnQzD zJ2LFu2mjrz4ifQ4GICANp+rEUz4YGckJhGrYel/4JzVqDnCbRq3fMd2qTtlONduuuiY 3LRkUISHJ/9laltxjXXP24hkQPIfw2DvY9DfIsXBB9IwVMpytpZm5W6UD0sCLX5RzNU0 QQDaAf0fqDiUuNbG2KHH7LnWzpEapDFxmdhO3AU8M/ITIRzgms6ffWF2MW6z2gqIqoQF 2lxjq5TQ6/7kFyFn+ziYd4QJQ77kiyC/7mBSPRn5KK9yZCCMitvq47iYPCbT/2GqoFcP pbaA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=RZgOEi4NpROOamHbjmumfavu3nkycozTSLXnJaf/zfw=; b=b4TGstbQyHsUnMJuUB+ri2pj/xGkVeXzpyRLonuTVr7WVMH+uue0EN1bhJoGO3KXaK FJlYCizwWarOUm/7jbiDYibev+GizLm0JmbUz9kZQ1kCE6VaHriNPcBsIhgQsjxC28ZT HgqlFA4ZanpPlPNhDEb9DThY6VKVXE3BqEUPLZZvfCvM4fUYXu5BSxqAR0hClK8t078O l9Dp6ixA7XtnpB4/m7Hu82AcZ3UmMwSq5IzewB0BTUhgJkNLbqer+unSDa302WZFKjxO /A/b/bx2hcjqCEreCbPGGmQEaPI0go2InbAD0HPsc2RRzp9qsv00kPv8zqGYHNopphGl Eo1A== X-Gm-Message-State: AJIora/CnsghGQK7njp2wvJ3T+Nn2Q344YhUNN6QvjzTjstpUtoPWYjq 0YlUlH7y78YYqRw2qVQHdmc= X-Google-Smtp-Source: AGRyM1sqYQ2m6bXeF5/p2eIJA+DvsmegXgF4/NNU73dTfRkuzlMPH8UNS5X8ZMsH/PG2Uws9CHbYTg== X-Received: by 2002:a63:551a:0:b0:412:24ed:33f1 with SMTP id j26-20020a63551a000000b0041224ed33f1mr7195229pgb.147.1656918500018; Mon, 04 Jul 2022 00:08:20 -0700 (PDT) Received: from localhost ([2406:7400:63:cb1d:811:33e9:9bc2:d40]) by smtp.gmail.com with ESMTPSA id v14-20020aa7808e000000b00518e1251197sm20961776pff.148.2022.07.04.00.08.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 04 Jul 2022 00:08:19 -0700 (PDT) From: Ritesh Harjani To: Theodore Ts'o Cc: Harshad Shirwadkar , Andreas Dilger , linux-ext4 , Ritesh Harjani Subject: [RFC 13/13] tst_libext2fs_pthread: Add libext2fs merge/clone unit tests Date: Mon, 4 Jul 2022 12:37:02 +0530 Message-Id: X-Mailer: git-send-email 2.35.3 In-Reply-To: References: MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org This adds a unit tests for libext2fs merge/clone apis and uses pthreads to test the functionality correctly. TODO: We can also add EXT2FS_CLONE_BADBLOCKS and EXT2FS_CLONE_DBLIST test as well into it. Signed-off-by: Ritesh Harjani --- lib/ext2fs/Makefile.in | 17 +- lib/ext2fs/tst_libext2fs_pthread.c | 322 +++++++++++++++++++++++++++++ 2 files changed, 337 insertions(+), 2 deletions(-) create mode 100644 lib/ext2fs/tst_libext2fs_pthread.c diff --git a/lib/ext2fs/Makefile.in b/lib/ext2fs/Makefile.in index c0694175..5fde9900 100644 --- a/lib/ext2fs/Makefile.in +++ b/lib/ext2fs/Makefile.in @@ -229,6 +229,7 @@ SRCS= ext2_err.c \ $(srcdir)/tst_libext2fs.c \ $(srcdir)/tst_bitmaps_standalone.c \ $(srcdir)/tst_bitmaps_pthread.c \ + $(srcdir)/tst_libext2fs_pthread.c \ $(DEBUG_SRCS) HFILES= bitops.h ext2fs.h ext2_io.h ext2_fs.h ext2_ext_attr.h ext3_extents.h \ @@ -374,6 +375,11 @@ tst_bitmaps_pthread: tst_bitmaps_pthread.o $(STATIC_LIBEXT2FS) $(DEPSTATIC_LIBCO $(Q) $(CC) -o tst_bitmaps_pthread tst_bitmaps_pthread.o $(ALL_LDFLAGS) \ $(STATIC_LIBEXT2FS) $(STATIC_LIBCOM_ERR) $(SYSLIBS) +tst_libext2fs_pthread: tst_libext2fs_pthread.o $(STATIC_LIBEXT2FS) $(DEPSTATIC_LIBCOM_ERR) + $(E) " LD $@" + $(Q) $(CC) -o tst_libext2fs_pthread tst_libext2fs_pthread.o $(ALL_LDFLAGS) \ + $(STATIC_LIBEXT2FS) $(STATIC_LIBCOM_ERR) $(SYSLIBS) + ext2_tdbtool: tdbtool.o $(E) " LD $@" $(Q) $(CC) -o ext2_tdbtool tdbtool.o tdb.o $(ALL_LDFLAGS) $(SYSLIBS) @@ -546,7 +552,7 @@ fullcheck check:: tst_bitops tst_badblocks tst_iscan tst_types tst_icount \ tst_super_size tst_types tst_inode_size tst_csum tst_crc32c tst_bitmaps \ tst_inline tst_inline_data tst_libext2fs tst_sha256 tst_sha512 \ tst_digest_encode tst_getsize tst_getsectsize tst_bitmaps_standalone \ - tst_bitmaps_pthread + tst_bitmaps_pthread tst_libext2fs_pthread $(TESTENV) ./tst_bitops $(TESTENV) ./tst_badblocks $(TESTENV) ./tst_iscan @@ -571,6 +577,7 @@ fullcheck check:: tst_bitops tst_badblocks tst_iscan tst_types tst_icount \ $(TESTENV) ./tst_digest_encode $(TESTENV) ./tst_bitmaps_standalone $(TESTENV) ./tst_bitmaps_pthread + $(TESTENV) ./tst_libext2fs_pthread installdirs:: $(E) " MKDIR_P $(libdir) $(includedir)/ext2fs" @@ -606,7 +613,7 @@ clean:: tst_bitmaps tst_bitmaps_out tst_extents tst_inline \ tst_inline_data tst_inode_size tst_bitmaps_cmd.c \ tst_digest_encode tst_sha256 tst_sha512 tst_bitmaps_standalone \ - tst_bitmaps_pthread \ + tst_bitmaps_pthread tst_libext2fs_pthread \ ext2_tdbtool mkjournal debug_cmds.c tst_cmds.c extent_cmds.c \ ../libext2fs.a ../libext2fs_p.a ../libext2fs_chk.a \ crc32c_table.h gen_crc32ctable tst_crc32c tst_libext2fs \ @@ -1184,6 +1191,12 @@ tst_bitmaps_pthread.o: $(srcdir)/tst_bitmaps_pthread.c $(top_builddir)/lib/confi $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ $(srcdir)/ext2_ext_attr.h $(srcdir)/hashmap.h $(srcdir)/bitops.h +tst_libext2fs_pthread.o: $(srcdir)/tst_libext2fs_pthread.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/ext2_fs.h \ + $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ + $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ + $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(srcdir)/ext2_ext_attr.h $(srcdir)/hashmap.h $(srcdir)/bitops.h undo_io.o: $(srcdir)/undo_io.c $(top_builddir)/lib/config.h \ $(top_builddir)/lib/dirpaths.h $(srcdir)/ext2_fs.h \ $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ diff --git a/lib/ext2fs/tst_libext2fs_pthread.c b/lib/ext2fs/tst_libext2fs_pthread.c new file mode 100644 index 00000000..f13bf611 --- /dev/null +++ b/lib/ext2fs/tst_libext2fs_pthread.c @@ -0,0 +1,322 @@ +#include "config.h" +#include +#include +#include +#if HAVE_UNISTD_H +#include +#endif +#include +#include +#include +#include +#if HAVE_ERRNO_H +#include +#endif +#if HAVE_PTHREAD +#include +#endif + +#include "ext2_fs.h" +#include "ext2fs.h" + +int test_fail = 0; +ext2_filsys testfs; +ext2fs_inode_bitmap inode_used_map; +ext2fs_block_bitmap block_used_map; +ext2_filsys childfs[2]; +pthread_t pthread_infos[2]; + +#define nr_bits 16384 +int nr_threads = 2; + +int should_mark_bit() +{ + return rand() % 2 == 0; +} + +void setupfs() +{ + errcode_t retval; + struct ext2_super_block param; + + initialize_ext2_error_table(); + + memset(¶m, 0, sizeof(param)); + ext2fs_blocks_count_set(¶m, nr_bits); + retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, ¶m, + test_io_manager, &testfs); + if (retval) { + com_err("setup", retval, "while initializing filesystem"); + exit(1); + } + + retval = ext2fs_allocate_tables(testfs); + if (retval) { + com_err("setup", retval, "while allocating tables for testfs"); + exit(1); + } +} + +void setup_used_bitmaps() +{ + int saved_type = testfs->default_bitmap_type; + ext2_inode_scan scan; + struct ext2_inode inode; + ext2_ino_t ino; + errcode_t retval; + int i; + + testfs->default_bitmap_type = EXT2FS_BMAP64_BITARRAY; + + /* allocate block and inode used bitmaps */ + retval = ext2fs_allocate_block_bitmap(testfs, "block used map", &block_used_map); + if (retval) + goto out; + + retval = ext2fs_allocate_inode_bitmap(testfs, "inode used map", &inode_used_map); + if (retval) + goto out; + + /* setup block and inode used bitmaps */ + for (i = 1; i < nr_bits; i++) { + /* + * we check for testfs->block_map as well since there could be some + * blocks already set as part of the FS metadata. + */ + if (should_mark_bit() || ext2fs_test_block_bitmap2(testfs->block_map, i)) { + ext2fs_mark_block_bitmap2(block_used_map, i); + } + } + + retval = ext2fs_open_inode_scan(testfs, 8, &scan); + if (retval) { + com_err("setup_inode_map", retval, "while open inode scan"); + exit(1); + } + + retval = ext2fs_get_next_inode(scan, &ino, &inode); + if (retval) { + com_err("setup_inode_map", retval, "while getting next inode"); + exit(1); + } + + while (ino) { + if (should_mark_bit()) + ext2fs_mark_inode_bitmap2(inode_used_map, ino); + + retval = ext2fs_get_next_inode(scan, &ino, &inode); + if (retval) { + com_err("setup_inode_map", retval, "while getting next inode"); + exit(1); + } + } + ext2fs_close_inode_scan(scan); + + testfs->default_bitmap_type = saved_type; + return; +out: + com_err("setup_used_bitmaps", retval, "while setting up bitmaps\n"); + exit(1); +} + +void setup_childfs() +{ + errcode_t retval; + int i; + + for (i = 0; i < nr_threads; i++) { + retval = ext2fs_clone_fs(testfs, &childfs[i], EXT2FS_CLONE_INODE | EXT2FS_CLONE_BLOCK); + if (retval) { + com_err("setup_childfs", retval, "while clone testfs for childfs"); + exit(1); + } + + retval = childfs[i]->io->manager->open(childfs[i]->device_name, + IO_FLAG_THREADS | IO_FLAG_NOCACHE, &childfs[i]->io); + if (retval) { + com_err("setup_pthread", retval, "while opening childfs"); + exit(1); + } + assert(childfs[i]->parent == testfs); + } +} + +void free_childfs() +{ + int i; + + for (i = 0; i < nr_threads; i++){ + ext2fs_free(childfs[i]); + } +} + + +static errcode_t scan_callback(ext2_filsys fs, + ext2_inode_scan scan EXT2FS_ATTR((unused)), + dgrp_t group, void *priv_data) +{ + pthread_t id = *((pthread_t *)priv_data); + + printf("%s: Called for group %d via thread %d\n", __func__, group, + pthread_equal(pthread_infos[1], id)); + if (pthread_equal(pthread_infos[0], id)) { + if (group >= fs->group_desc_count / 2 - 1) + return 1; + } + return 0; +} + +static void *run_pthread(void *arg) +{ + errcode_t retval = 0; + int i = 0, start, end; + ext2fs_block_bitmap test_block_bitmap; + ext2fs_inode_bitmap test_inode_bitmap; + ext2_inode_scan scan; + struct ext2_inode inode; + ext2_ino_t ino; + pthread_t id = pthread_self(); + + if (pthread_equal(pthread_infos[0], id)) { + start = 1; + end = nr_bits/2; + test_block_bitmap = childfs[0]->block_map; + test_inode_bitmap = childfs[0]->inode_map; + + retval = ext2fs_open_inode_scan(childfs[0], 8, &scan); + if (retval) { + com_err("setup_inode_map", retval, "while open inode scan"); + exit(1); + } + + } else { + start = nr_bits / 2 + 1;; + end = nr_bits - 1; + test_block_bitmap = childfs[1]->block_map; + test_inode_bitmap = childfs[1]->inode_map; + + retval = ext2fs_open_inode_scan(childfs[1], 8, &scan); + if (retval) { + com_err("setup_inode_map", retval, "while open inode scan"); + exit(1); + } + ext2fs_inode_scan_goto_blockgroup(scan, testfs->group_desc_count/2); + } + + ext2fs_set_inode_callback(scan, scan_callback, &id); + + /* blocks scan */ + for (i = start; i <= end; i++) { + if (ext2fs_test_block_bitmap2(block_used_map, i)) { + ext2fs_mark_block_bitmap2(test_block_bitmap, i); + } + } + + /* inodes scan */ + retval = ext2fs_get_next_inode(scan, &ino, &inode); + if (retval) { + com_err("setup_inode_map", retval, "while getting next inode"); + exit(1); + } + + while (ino) { + if (ext2fs_test_inode_bitmap2(inode_used_map, ino)) { + ext2fs_mark_inode_bitmap2(test_inode_bitmap, ino); + } + + retval = ext2fs_get_next_inode(scan, &ino, &inode); + if (retval) + break; + } + ext2fs_close_inode_scan(scan); + return NULL; +} + +void run_pthreads() +{ + errcode_t retval; + int i; + + for (i = 0; i < nr_threads; i++) { + printf("Starting thread (%d)\n", i); + retval = pthread_create(&pthread_infos[i], NULL, &run_pthread, NULL); + if (retval) { + com_err("run_pthreads", retval, "while pthread_create"); + exit(1); + } + } + + for (i = 0; i < nr_threads; i++) { + void *status; + int ret; + retval = pthread_join(pthread_infos[i], &status); + if (retval) { + com_err("run_pthreads", retval, "while joining pthreads"); + exit(1); + + } + ret = status == NULL ? 0 : *(int*)status; + if (ret) { + com_err("run_pthreads", ret, "pthread returned error"); + test_fail++; + } + + printf("Closing thread (%d), ret(%d)\n", i, ret); + } + + assert(ext2fs_merge_fs(childfs[0]) == 0); + assert(ext2fs_merge_fs(childfs[1]) == 0); +} + +void test_bitmaps() +{ + errcode_t retval; + retval = ext2fs_compare_block_bitmap(testfs->block_map, block_used_map); + if (retval) { + printf("Block bitmap compare -- NOT OK!! (%ld)\n", retval); + test_fail++; + } + + printf("Block compare bitmap -- OK!!\n"); + retval = ext2fs_compare_inode_bitmap(testfs->inode_map, inode_used_map); + if (retval) { + printf("Inode bitmap compare -- NOT OK!! (%ld)\n", retval); + test_fail++; + } + printf("Inode compare bitmap -- OK!!\n"); +} + +void free_used_bitmaps() +{ + ext2fs_free_block_bitmap(block_used_map); + ext2fs_free_inode_bitmap(inode_used_map); +} + +int main(int argc, char *argv[]) +{ + int i; + +#ifndef HAVE_PTHREAD + printf("No PTHREAD support, exiting...\n"); + return 0; +#endif + + srand(time(0)); + + setupfs(); + setup_used_bitmaps(); + + setup_childfs(); + run_pthreads(); + test_bitmaps(i); + + if (test_fail) + printf("%s: Test libext2fs clone/merge with pthreads NOT OK!!\n", argv[0]); + else + printf("%s: Test libext2fs clone/merge with pthreads OK!!\n", argv[0]); + free_used_bitmaps(); + free_childfs(); + ext2fs_free(testfs); + + return test_fail; +}