From patchwork Thu Aug 9 02:42:15 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Theodore Ts'o X-Patchwork-Id: 955305 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=mit.edu Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=thunk.org header.i=@thunk.org header.b="okx2cz0J"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mCGB4Zb4z9s4Z for ; Thu, 9 Aug 2018 12:42:26 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727626AbeHIFEz (ORCPT ); Thu, 9 Aug 2018 01:04:55 -0400 Received: from imap.thunk.org ([74.207.234.97]:52958 "EHLO imap.thunk.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725779AbeHIFEz (ORCPT ); Thu, 9 Aug 2018 01:04:55 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=thunk.org; s=ef5046eb; h=Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: MIME-Version:Content-Type:Content-Transfer-Encoding:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:In-Reply-To:References:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=WQaoIyxJUhdIVWyL4aL7pyOgeT/Cu+VzoKtNLqrZOHg=; b=okx2cz0JSDEHet+Se+21D/dpKY MW1r0Z3XTtx7PuF1Xwo+LcuxSSJZExL569aCvfK8DhGl3be0MQ7ATLhvwRj1E/MB9OtvYEJENaoKA DB1eQPgdAG5d1zLn/tiuzXfP+Q/mPo0NkGjF7Q7PA2bEIormLrhaJ90kuoX1CX6d3Mec=; Received: from root (helo=callcc.thunk.org) by imap.thunk.org with local-esmtp (Exim 4.89) (envelope-from ) id 1fnau6-0000a6-NT; Thu, 09 Aug 2018 02:42:22 +0000 Received: by callcc.thunk.org (Postfix, from userid 15806) id B31ED7A6513; Wed, 8 Aug 2018 22:42:21 -0400 (EDT) From: Theodore Ts'o To: Ext4 Developers List Cc: Theodore Ts'o Subject: [PATCH 1/5] libext2fs: revamp bitmap types to fix LTO warnings Date: Wed, 8 Aug 2018 22:42:15 -0400 Message-Id: <20180809024219.15696-1-tytso@mit.edu> X-Mailer: git-send-email 2.18.0.rc0 X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: tytso@thunk.org X-SA-Exim-Scanned: No (on imap.thunk.org); SAEximRunCond expanded to false Sender: linux-ext4-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org We play games with pointers to incomplete types to handle subclassing using the C language, use the first four bytes (the magic number) field to disambiguate between different subclasses. The way we were doing it before, we relied defining the structure differently depending on the C file implementing different backend subclasses. This triggers LTO warnings, since it appears (and in fact, we are) using functions defined with different types than how they were defined by calling C file. Fix the LTO warnings by using an explicit base bitmap structure, and then casting it to the 32-bit or 64-bit variant as needed. Signed-off-by: Theodore Ts'o --- lib/ext2fs/bitmaps.c | 6 +- lib/ext2fs/blkmap64_ba.c | 38 ++++---- lib/ext2fs/blkmap64_rb.c | 38 ++++---- lib/ext2fs/bmap64.h | 38 ++++---- lib/ext2fs/ext2fs.h | 11 ++- lib/ext2fs/gen_bitmap.c | 113 +++++++++++++++-------- lib/ext2fs/gen_bitmap64.c | 185 ++++++++++++++++++++++---------------- 7 files changed, 256 insertions(+), 173 deletions(-) diff --git a/lib/ext2fs/bitmaps.c b/lib/ext2fs/bitmaps.c index 840219172..e25db2c66 100644 --- a/lib/ext2fs/bitmaps.c +++ b/lib/ext2fs/bitmaps.c @@ -125,6 +125,7 @@ errcode_t ext2fs_allocate_subcluster_bitmap(ext2_filsys fs, { __u64 start, end, real_end; ext2fs_generic_bitmap bmap; + ext2fs_generic_bitmap_64 bmap64; errcode_t retval; EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); @@ -147,14 +148,15 @@ errcode_t ext2fs_allocate_subcluster_bitmap(ext2_filsys fs, end, real_end, descr, &bmap); if (retval) return retval; - bmap->cluster_bits = 0; + bmap64 = (ext2fs_generic_bitmap_64) bmap; + bmap64->cluster_bits = 0; *ret = bmap; return 0; } int ext2fs_get_bitmap_granularity(ext2fs_block_bitmap bitmap) { - ext2fs_generic_bitmap bmap = bitmap; + ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64) bitmap; if (!EXT2FS_IS_64_BITMAP(bmap)) return 0; diff --git a/lib/ext2fs/blkmap64_ba.c b/lib/ext2fs/blkmap64_ba.c index 3707a61eb..85cb38d26 100644 --- a/lib/ext2fs/blkmap64_ba.c +++ b/lib/ext2fs/blkmap64_ba.c @@ -40,7 +40,7 @@ struct ext2fs_ba_private_struct { typedef struct ext2fs_ba_private_struct *ext2fs_ba_private; -static errcode_t ba_alloc_private_data (ext2fs_generic_bitmap bitmap) +static errcode_t ba_alloc_private_data (ext2fs_generic_bitmap_64 bitmap) { ext2fs_ba_private bp; errcode_t retval; @@ -69,7 +69,7 @@ static errcode_t ba_alloc_private_data (ext2fs_generic_bitmap bitmap) } static errcode_t ba_new_bmap(ext2_filsys fs EXT2FS_ATTR((unused)), - ext2fs_generic_bitmap bitmap) + ext2fs_generic_bitmap_64 bitmap) { ext2fs_ba_private bp; errcode_t retval; @@ -86,7 +86,7 @@ static errcode_t ba_new_bmap(ext2_filsys fs EXT2FS_ATTR((unused)), return 0; } -static void ba_free_bmap(ext2fs_generic_bitmap bitmap) +static void ba_free_bmap(ext2fs_generic_bitmap_64 bitmap) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; @@ -101,8 +101,8 @@ static void ba_free_bmap(ext2fs_generic_bitmap bitmap) bp = 0; } -static errcode_t ba_copy_bmap(ext2fs_generic_bitmap src, - ext2fs_generic_bitmap dest) +static errcode_t ba_copy_bmap(ext2fs_generic_bitmap_64 src, + ext2fs_generic_bitmap_64 dest) { ext2fs_ba_private src_bp = (ext2fs_ba_private) src->private; ext2fs_ba_private dest_bp; @@ -121,7 +121,7 @@ static errcode_t ba_copy_bmap(ext2fs_generic_bitmap src, return 0; } -static errcode_t ba_resize_bmap(ext2fs_generic_bitmap bmap, +static errcode_t ba_resize_bmap(ext2fs_generic_bitmap_64 bmap, __u64 new_end, __u64 new_real_end) { ext2fs_ba_private bp = (ext2fs_ba_private) bmap->private; @@ -162,7 +162,7 @@ static errcode_t ba_resize_bmap(ext2fs_generic_bitmap bmap, } -static int ba_mark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) +static int ba_mark_bmap(ext2fs_generic_bitmap_64 bitmap, __u64 arg) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; blk64_t bitno = (blk64_t) arg; @@ -170,7 +170,7 @@ static int ba_mark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) return ext2fs_set_bit64(bitno - bitmap->start, bp->bitarray); } -static int ba_unmark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) +static int ba_unmark_bmap(ext2fs_generic_bitmap_64 bitmap, __u64 arg) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; blk64_t bitno = (blk64_t) arg; @@ -178,7 +178,7 @@ static int ba_unmark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) return ext2fs_clear_bit64(bitno - bitmap->start, bp->bitarray); } -static int ba_test_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) +static int ba_test_bmap(ext2fs_generic_bitmap_64 bitmap, __u64 arg) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; blk64_t bitno = (blk64_t) arg; @@ -186,7 +186,7 @@ static int ba_test_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) return ext2fs_test_bit64(bitno - bitmap->start, bp->bitarray); } -static void ba_mark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg, +static void ba_mark_bmap_extent(ext2fs_generic_bitmap_64 bitmap, __u64 arg, unsigned int num) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; @@ -197,7 +197,7 @@ static void ba_mark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg, ext2fs_fast_set_bit64(bitno + i - bitmap->start, bp->bitarray); } -static void ba_unmark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg, +static void ba_unmark_bmap_extent(ext2fs_generic_bitmap_64 bitmap, __u64 arg, unsigned int num) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; @@ -208,7 +208,7 @@ static void ba_unmark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg, ext2fs_fast_clear_bit64(bitno + i - bitmap->start, bp->bitarray); } -static int ba_test_clear_bmap_extent(ext2fs_generic_bitmap bitmap, +static int ba_test_clear_bmap_extent(ext2fs_generic_bitmap_64 bitmap, __u64 start, unsigned int len) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; @@ -282,7 +282,7 @@ static int ba_test_clear_bmap_extent(ext2fs_generic_bitmap bitmap, } -static errcode_t ba_set_bmap_range(ext2fs_generic_bitmap bitmap, +static errcode_t ba_set_bmap_range(ext2fs_generic_bitmap_64 bitmap, __u64 start, size_t num, void *in) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; @@ -292,7 +292,7 @@ static errcode_t ba_set_bmap_range(ext2fs_generic_bitmap bitmap, return 0; } -static errcode_t ba_get_bmap_range(ext2fs_generic_bitmap bitmap, +static errcode_t ba_get_bmap_range(ext2fs_generic_bitmap_64 bitmap, __u64 start, size_t num, void *out) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; @@ -302,7 +302,7 @@ static errcode_t ba_get_bmap_range(ext2fs_generic_bitmap bitmap, return 0; } -static void ba_clear_bmap(ext2fs_generic_bitmap bitmap) +static void ba_clear_bmap(ext2fs_generic_bitmap_64 bitmap) { ext2fs_ba_private bp = (ext2fs_ba_private) bitmap->private; @@ -311,20 +311,20 @@ static void ba_clear_bmap(ext2fs_generic_bitmap bitmap) } #ifdef ENABLE_BMAP_STATS -static void ba_print_stats(ext2fs_generic_bitmap bitmap) +static void ba_print_stats(ext2fs_generic_bitmap_64 bitmap) { fprintf(stderr, "%16llu Bytes used by bitarray\n", ((bitmap->real_end - bitmap->start) >> 3) + 1 + sizeof(struct ext2fs_ba_private_struct)); } #else -static void ba_print_stats(ext2fs_generic_bitmap bitmap EXT2FS_ATTR((unused))) +static void ba_print_stats(ext2fs_generic_bitmap_64 bitmap EXT2FS_ATTR((unused))) { } #endif /* Find the first zero bit between start and end, inclusive. */ -static errcode_t ba_find_first_zero(ext2fs_generic_bitmap bitmap, +static errcode_t ba_find_first_zero(ext2fs_generic_bitmap_64 bitmap, __u64 start, __u64 end, __u64 *out) { ext2fs_ba_private bp = (ext2fs_ba_private)bitmap->private; @@ -398,7 +398,7 @@ static errcode_t ba_find_first_zero(ext2fs_generic_bitmap bitmap, } /* Find the first one bit between start and end, inclusive. */ -static errcode_t ba_find_first_set(ext2fs_generic_bitmap bitmap, +static errcode_t ba_find_first_set(ext2fs_generic_bitmap_64 bitmap, __u64 start, __u64 end, __u64 *out) { ext2fs_ba_private bp = (ext2fs_ba_private)bitmap->private; diff --git a/lib/ext2fs/blkmap64_rb.c b/lib/ext2fs/blkmap64_rb.c index 4cbfb1ed3..1fd552745 100644 --- a/lib/ext2fs/blkmap64_rb.c +++ b/lib/ext2fs/blkmap64_rb.c @@ -177,7 +177,7 @@ static void rb_free_extent(struct ext2fs_rb_private *bp, ext2fs_free_mem(&ext); } -static errcode_t rb_alloc_private_data (ext2fs_generic_bitmap bitmap) +static errcode_t rb_alloc_private_data (ext2fs_generic_bitmap_64 bitmap) { struct ext2fs_rb_private *bp; errcode_t retval; @@ -201,7 +201,7 @@ static errcode_t rb_alloc_private_data (ext2fs_generic_bitmap bitmap) } static errcode_t rb_new_bmap(ext2_filsys fs EXT2FS_ATTR((unused)), - ext2fs_generic_bitmap bitmap) + ext2fs_generic_bitmap_64 bitmap) { errcode_t retval; @@ -225,7 +225,7 @@ static void rb_free_tree(struct rb_root *root) } } -static void rb_free_bmap(ext2fs_generic_bitmap bitmap) +static void rb_free_bmap(ext2fs_generic_bitmap_64 bitmap) { struct ext2fs_rb_private *bp; @@ -236,8 +236,8 @@ static void rb_free_bmap(ext2fs_generic_bitmap bitmap) bp = 0; } -static errcode_t rb_copy_bmap(ext2fs_generic_bitmap src, - ext2fs_generic_bitmap dest) +static errcode_t rb_copy_bmap(ext2fs_generic_bitmap_64 src, + ext2fs_generic_bitmap_64 dest) { struct ext2fs_rb_private *src_bp, *dest_bp; struct bmap_rb_extent *src_ext, *dest_ext; @@ -302,7 +302,7 @@ static void rb_truncate(__u64 new_max, struct rb_root *root) } } -static errcode_t rb_resize_bmap(ext2fs_generic_bitmap bmap, +static errcode_t rb_resize_bmap(ext2fs_generic_bitmap_64 bmap, __u64 new_end, __u64 new_real_end) { struct ext2fs_rb_private *bp; @@ -575,7 +575,7 @@ static int rb_remove_extent(__u64 start, __u64 count, return retval; } -static int rb_mark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) +static int rb_mark_bmap(ext2fs_generic_bitmap_64 bitmap, __u64 arg) { struct ext2fs_rb_private *bp; int retval; @@ -588,7 +588,7 @@ static int rb_mark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) return retval; } -static int rb_unmark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) +static int rb_unmark_bmap(ext2fs_generic_bitmap_64 bitmap, __u64 arg) { struct ext2fs_rb_private *bp; int retval; @@ -603,7 +603,7 @@ static int rb_unmark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) } inline -static int rb_test_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) +static int rb_test_bmap(ext2fs_generic_bitmap_64 bitmap, __u64 arg) { struct ext2fs_rb_private *bp; @@ -613,7 +613,7 @@ static int rb_test_bmap(ext2fs_generic_bitmap bitmap, __u64 arg) return rb_test_bit(bp, arg); } -static void rb_mark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg, +static void rb_mark_bmap_extent(ext2fs_generic_bitmap_64 bitmap, __u64 arg, unsigned int num) { struct ext2fs_rb_private *bp; @@ -625,7 +625,7 @@ static void rb_mark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg, check_tree(&bp->root, __func__); } -static void rb_unmark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg, +static void rb_unmark_bmap_extent(ext2fs_generic_bitmap_64 bitmap, __u64 arg, unsigned int num) { struct ext2fs_rb_private *bp; @@ -637,7 +637,7 @@ static void rb_unmark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg, check_tree(&bp->root, __func__); } -static int rb_test_clear_bmap_extent(ext2fs_generic_bitmap bitmap, +static int rb_test_clear_bmap_extent(ext2fs_generic_bitmap_64 bitmap, __u64 start, unsigned int len) { struct rb_node *parent = NULL, **n; @@ -693,7 +693,7 @@ static int rb_test_clear_bmap_extent(ext2fs_generic_bitmap bitmap, return retval; } -static errcode_t rb_set_bmap_range(ext2fs_generic_bitmap bitmap, +static errcode_t rb_set_bmap_range(ext2fs_generic_bitmap_64 bitmap, __u64 start, size_t num, void *in) { struct ext2fs_rb_private *bp; @@ -739,7 +739,7 @@ static errcode_t rb_set_bmap_range(ext2fs_generic_bitmap bitmap, return 0; } -static errcode_t rb_get_bmap_range(ext2fs_generic_bitmap bitmap, +static errcode_t rb_get_bmap_range(ext2fs_generic_bitmap_64 bitmap, __u64 start, size_t num, void *out) { @@ -804,7 +804,7 @@ static errcode_t rb_get_bmap_range(ext2fs_generic_bitmap bitmap, return 0; } -static void rb_clear_bmap(ext2fs_generic_bitmap bitmap) +static void rb_clear_bmap(ext2fs_generic_bitmap_64 bitmap) { struct ext2fs_rb_private *bp; @@ -817,7 +817,7 @@ static void rb_clear_bmap(ext2fs_generic_bitmap bitmap) check_tree(&bp->root, __func__); } -static errcode_t rb_find_first_zero(ext2fs_generic_bitmap bitmap, +static errcode_t rb_find_first_zero(ext2fs_generic_bitmap_64 bitmap, __u64 start, __u64 end, __u64 *out) { struct rb_node *parent = NULL, **n; @@ -853,7 +853,7 @@ static errcode_t rb_find_first_zero(ext2fs_generic_bitmap bitmap, return 0; } -static errcode_t rb_find_first_set(ext2fs_generic_bitmap bitmap, +static errcode_t rb_find_first_set(ext2fs_generic_bitmap_64 bitmap, __u64 start, __u64 end, __u64 *out) { struct rb_node *parent = NULL, **n; @@ -902,7 +902,7 @@ static errcode_t rb_find_first_set(ext2fs_generic_bitmap bitmap, } #ifdef ENABLE_BMAP_STATS -static void rb_print_stats(ext2fs_generic_bitmap bitmap) +static void rb_print_stats(ext2fs_generic_bitmap_64 bitmap) { struct ext2fs_rb_private *bp; struct rb_node *node = NULL; @@ -963,7 +963,7 @@ static void rb_print_stats(ext2fs_generic_bitmap bitmap) eff); } #else -static void rb_print_stats(ext2fs_generic_bitmap bitmap EXT2FS_ATTR((unused))) +static void rb_print_stats(ext2fs_generic_bitmap_64 bitmap EXT2FS_ATTR((unused))) { } #endif diff --git a/lib/ext2fs/bmap64.h b/lib/ext2fs/bmap64.h index d8c7a3c38..de3345481 100644 --- a/lib/ext2fs/bmap64.h +++ b/lib/ext2fs/bmap64.h @@ -37,7 +37,7 @@ struct ext2_bmap_statistics { }; -struct ext2fs_struct_generic_bitmap { +struct ext2fs_struct_generic_bitmap_64 { errcode_t magic; ext2_filsys fs; struct ext2_bitmap_ops *bitmap_ops; @@ -53,6 +53,8 @@ struct ext2fs_struct_generic_bitmap { #endif }; +typedef struct ext2fs_struct_generic_bitmap_64 *ext2fs_generic_bitmap_64; + #define EXT2FS_IS_32_BITMAP(bmap) \ (((bmap)->magic == EXT2_ET_MAGIC_GENERIC_BITMAP) || \ ((bmap)->magic == EXT2_ET_MAGIC_BLOCK_BITMAP) || \ @@ -66,37 +68,37 @@ struct ext2fs_struct_generic_bitmap { struct ext2_bitmap_ops { int type; /* Generic bmap operators */ - errcode_t (*new_bmap)(ext2_filsys fs, ext2fs_generic_bitmap bmap); - void (*free_bmap)(ext2fs_generic_bitmap bitmap); - errcode_t (*copy_bmap)(ext2fs_generic_bitmap src, - ext2fs_generic_bitmap dest); - errcode_t (*resize_bmap)(ext2fs_generic_bitmap bitmap, + errcode_t (*new_bmap)(ext2_filsys fs, ext2fs_generic_bitmap_64 bmap); + void (*free_bmap)(ext2fs_generic_bitmap_64 bitmap); + errcode_t (*copy_bmap)(ext2fs_generic_bitmap_64 src, + ext2fs_generic_bitmap_64 dest); + errcode_t (*resize_bmap)(ext2fs_generic_bitmap_64 bitmap, __u64 new_end, __u64 new_real_end); /* bit set/test operators */ - int (*mark_bmap)(ext2fs_generic_bitmap bitmap, __u64 arg); - int (*unmark_bmap)(ext2fs_generic_bitmap bitmap, __u64 arg); - int (*test_bmap)(ext2fs_generic_bitmap bitmap, __u64 arg); - void (*mark_bmap_extent)(ext2fs_generic_bitmap bitmap, __u64 arg, + int (*mark_bmap)(ext2fs_generic_bitmap_64 bitmap, __u64 arg); + int (*unmark_bmap)(ext2fs_generic_bitmap_64 bitmap, __u64 arg); + int (*test_bmap)(ext2fs_generic_bitmap_64 bitmap, __u64 arg); + void (*mark_bmap_extent)(ext2fs_generic_bitmap_64 bitmap, __u64 arg, unsigned int num); - void (*unmark_bmap_extent)(ext2fs_generic_bitmap bitmap, __u64 arg, + void (*unmark_bmap_extent)(ext2fs_generic_bitmap_64 bitmap, __u64 arg, unsigned int num); - int (*test_clear_bmap_extent)(ext2fs_generic_bitmap bitmap, + int (*test_clear_bmap_extent)(ext2fs_generic_bitmap_64 bitmap, __u64 arg, unsigned int num); - errcode_t (*set_bmap_range)(ext2fs_generic_bitmap bitmap, + errcode_t (*set_bmap_range)(ext2fs_generic_bitmap_64 bitmap, __u64 start, size_t num, void *in); - errcode_t (*get_bmap_range)(ext2fs_generic_bitmap bitmap, + errcode_t (*get_bmap_range)(ext2fs_generic_bitmap_64 bitmap, __u64 start, size_t num, void *out); - void (*clear_bmap)(ext2fs_generic_bitmap bitmap); - void (*print_stats)(ext2fs_generic_bitmap); + void (*clear_bmap)(ext2fs_generic_bitmap_64 bitmap); + void (*print_stats)(ext2fs_generic_bitmap_64); /* Find the first zero bit between start and end, inclusive. * May be NULL, in which case a generic function is used. */ - errcode_t (*find_first_zero)(ext2fs_generic_bitmap bitmap, + errcode_t (*find_first_zero)(ext2fs_generic_bitmap_64 bitmap, __u64 start, __u64 end, __u64 *out); /* Find the first set bit between start and end, inclusive. * May be NULL, in which case a generic function is used. */ - errcode_t (*find_first_set)(ext2fs_generic_bitmap bitmap, + errcode_t (*find_first_set)(ext2fs_generic_bitmap_64 bitmap, __u64 start, __u64 end, __u64 *out); }; diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h index 3d4afac4b..c4a4ef019 100644 --- a/lib/ext2fs/ext2fs.h +++ b/lib/ext2fs/ext2fs.h @@ -111,9 +111,14 @@ typedef struct struct_ext2_filsys *ext2_filsys; #define EXT2FS_UNMARK_ERROR 1 #define EXT2FS_TEST_ERROR 2 -typedef struct ext2fs_struct_generic_bitmap *ext2fs_generic_bitmap; -typedef struct ext2fs_struct_generic_bitmap *ext2fs_inode_bitmap; -typedef struct ext2fs_struct_generic_bitmap *ext2fs_block_bitmap; +struct ext2fs_struct_generic_bitmap_base { + errcode_t magic; + ext2_filsys fs; +}; + +typedef struct ext2fs_struct_generic_bitmap_base *ext2fs_generic_bitmap; +typedef struct ext2fs_struct_generic_bitmap_base *ext2fs_inode_bitmap; +typedef struct ext2fs_struct_generic_bitmap_base *ext2fs_block_bitmap; #define EXT2_FIRST_INODE(s) EXT2_FIRST_INO(s) diff --git a/lib/ext2fs/gen_bitmap.c b/lib/ext2fs/gen_bitmap.c index d0061b822..181371c8c 100644 --- a/lib/ext2fs/gen_bitmap.c +++ b/lib/ext2fs/gen_bitmap.c @@ -28,7 +28,7 @@ #include "ext2_fs.h" #include "ext2fsP.h" -struct ext2fs_struct_generic_bitmap { +struct ext2fs_struct_generic_bitmap_32 { errcode_t magic; ext2_filsys fs; __u32 start, end; @@ -39,6 +39,8 @@ struct ext2fs_struct_generic_bitmap { __u32 reserved[7]; }; +typedef struct ext2fs_struct_generic_bitmap_32 *ext2fs_generic_bitmap_32; + #define EXT2FS_IS_32_BITMAP(bmap) \ (((bmap)->magic == EXT2_ET_MAGIC_GENERIC_BITMAP) || \ ((bmap)->magic == EXT2_ET_MAGIC_BLOCK_BITMAP) || \ @@ -53,9 +55,11 @@ struct ext2fs_struct_generic_bitmap { * Used by previously inlined function, so we have to export this and * not change the function signature */ -void ext2fs_warn_bitmap2(ext2fs_generic_bitmap bitmap, +void ext2fs_warn_bitmap2(ext2fs_generic_bitmap gen_bitmap, int code, unsigned long arg) { + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; + #ifndef OMIT_COM_ERR if (bitmap->description) com_err(0, bitmap->base_error_code+code, @@ -79,11 +83,11 @@ errcode_t ext2fs_make_generic_bitmap(errcode_t magic, ext2_filsys fs, const char *descr, char *init_map, ext2fs_generic_bitmap *ret) { - ext2fs_generic_bitmap bitmap; + ext2fs_generic_bitmap_32 bitmap; errcode_t retval; size_t size; - retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap), + retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap_32), &bitmap); if (retval) return retval; @@ -127,7 +131,7 @@ errcode_t ext2fs_make_generic_bitmap(errcode_t magic, ext2_filsys fs, memcpy(bitmap->bitmap, init_map, size); else memset(bitmap->bitmap, 0, size); - *ret = bitmap; + *ret = (ext2fs_generic_bitmap) bitmap; return 0; } @@ -141,9 +145,11 @@ errcode_t ext2fs_allocate_generic_bitmap(__u32 start, start, end, real_end, descr, 0, ret); } -errcode_t ext2fs_copy_generic_bitmap(ext2fs_generic_bitmap src, +errcode_t ext2fs_copy_generic_bitmap(ext2fs_generic_bitmap gen_src, ext2fs_generic_bitmap *dest) { + ext2fs_generic_bitmap_32 src = (ext2fs_generic_bitmap_32) gen_src; + return (ext2fs_make_generic_bitmap(src->magic, src->fs, src->start, src->end, src->real_end, @@ -151,9 +157,11 @@ errcode_t ext2fs_copy_generic_bitmap(ext2fs_generic_bitmap src, dest)); } -void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap) +void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap gen_bitmap) { - if (check_magic(bitmap)) + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; + + if (check_magic(gen_bitmap)) return; bitmap->magic = 0; @@ -171,6 +179,8 @@ void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap) int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap, blk_t bitno) { + ext2fs_generic_bitmap_32 bitmap32 = (ext2fs_generic_bitmap_32) bitmap; + if (!EXT2FS_IS_32_BITMAP(bitmap)) { if (EXT2FS_IS_64_BITMAP(bitmap)) { ext2fs_warn_bitmap32(bitmap, __func__); @@ -183,16 +193,18 @@ int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap, return 0; } - if ((bitno < bitmap->start) || (bitno > bitmap->end)) { + if ((bitno < bitmap32->start) || (bitno > bitmap32->end)) { ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, bitno); return 0; } - return ext2fs_test_bit(bitno - bitmap->start, bitmap->bitmap); + return ext2fs_test_bit(bitno - bitmap32->start, bitmap32->bitmap); } int ext2fs_mark_generic_bitmap(ext2fs_generic_bitmap bitmap, __u32 bitno) { + ext2fs_generic_bitmap_32 bitmap32 = (ext2fs_generic_bitmap_32) bitmap; + if (!EXT2FS_IS_32_BITMAP(bitmap)) { if (EXT2FS_IS_64_BITMAP(bitmap)) { ext2fs_warn_bitmap32(bitmap, __func__); @@ -205,16 +217,18 @@ int ext2fs_mark_generic_bitmap(ext2fs_generic_bitmap bitmap, return 0; } - if ((bitno < bitmap->start) || (bitno > bitmap->end)) { + if ((bitno < bitmap32->start) || (bitno > bitmap32->end)) { ext2fs_warn_bitmap2(bitmap, EXT2FS_MARK_ERROR, bitno); return 0; } - return ext2fs_set_bit(bitno - bitmap->start, bitmap->bitmap); + return ext2fs_set_bit(bitno - bitmap32->start, bitmap32->bitmap); } int ext2fs_unmark_generic_bitmap(ext2fs_generic_bitmap bitmap, blk_t bitno) { + ext2fs_generic_bitmap_32 bitmap32 = (ext2fs_generic_bitmap_32) bitmap; + if (!EXT2FS_IS_32_BITMAP(bitmap)) { if (EXT2FS_IS_64_BITMAP(bitmap)) { ext2fs_warn_bitmap32(bitmap, __func__); @@ -227,15 +241,17 @@ int ext2fs_unmark_generic_bitmap(ext2fs_generic_bitmap bitmap, return 0; } - if ((bitno < bitmap->start) || (bitno > bitmap->end)) { + if ((bitno < bitmap32->start) || (bitno > bitmap32->end)) { ext2fs_warn_bitmap2(bitmap, EXT2FS_UNMARK_ERROR, bitno); return 0; } - return ext2fs_clear_bit(bitno - bitmap->start, bitmap->bitmap); + return ext2fs_clear_bit(bitno - bitmap32->start, bitmap32->bitmap); } __u32 ext2fs_get_generic_bitmap_start(ext2fs_generic_bitmap bitmap) { + ext2fs_generic_bitmap_32 bitmap32 = (ext2fs_generic_bitmap_32) bitmap; + if (!EXT2FS_IS_32_BITMAP(bitmap)) { if (EXT2FS_IS_64_BITMAP(bitmap)) { ext2fs_warn_bitmap32(bitmap, __func__); @@ -248,11 +264,13 @@ __u32 ext2fs_get_generic_bitmap_start(ext2fs_generic_bitmap bitmap) return 0; } - return bitmap->start; + return bitmap32->start; } __u32 ext2fs_get_generic_bitmap_end(ext2fs_generic_bitmap bitmap) { + ext2fs_generic_bitmap_32 bitmap32 = (ext2fs_generic_bitmap_32) bitmap; + if (!EXT2FS_IS_32_BITMAP(bitmap)) { if (EXT2FS_IS_64_BITMAP(bitmap)) { ext2fs_warn_bitmap32(bitmap, __func__); @@ -264,11 +282,13 @@ __u32 ext2fs_get_generic_bitmap_end(ext2fs_generic_bitmap bitmap) #endif return 0; } - return bitmap->end; + return bitmap32->end; } void ext2fs_clear_generic_bitmap(ext2fs_generic_bitmap bitmap) { + ext2fs_generic_bitmap_32 bitmap32 = (ext2fs_generic_bitmap_32) bitmap; + if (!EXT2FS_IS_32_BITMAP(bitmap)) { if (EXT2FS_IS_64_BITMAP(bitmap)) { ext2fs_warn_bitmap32(bitmap, __func__); @@ -282,14 +302,16 @@ void ext2fs_clear_generic_bitmap(ext2fs_generic_bitmap bitmap) return; } - memset(bitmap->bitmap, 0, - (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1)); + memset(bitmap32->bitmap, 0, + (size_t) (((bitmap32->real_end - bitmap32->start) / 8) + 1)); } -errcode_t ext2fs_fudge_generic_bitmap_end(ext2fs_inode_bitmap bitmap, +errcode_t ext2fs_fudge_generic_bitmap_end(ext2fs_inode_bitmap gen_bitmap, errcode_t magic, errcode_t neq, ext2_ino_t end, ext2_ino_t *oend) { + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; + EXT2_CHECK_MAGIC(bitmap, magic); if (end > bitmap->real_end) @@ -302,8 +324,9 @@ errcode_t ext2fs_fudge_generic_bitmap_end(ext2fs_inode_bitmap bitmap, errcode_t ext2fs_resize_generic_bitmap(errcode_t magic, __u32 new_end, __u32 new_real_end, - ext2fs_generic_bitmap bmap) + ext2fs_generic_bitmap gen_bmap) { + ext2fs_generic_bitmap_32 bmap = (ext2fs_generic_bitmap_32) gen_bmap; errcode_t retval; size_t size, new_size; __u32 bitno; @@ -344,9 +367,11 @@ errcode_t ext2fs_resize_generic_bitmap(errcode_t magic, } errcode_t ext2fs_compare_generic_bitmap(errcode_t magic, errcode_t neq, - ext2fs_generic_bitmap bm1, - ext2fs_generic_bitmap bm2) + ext2fs_generic_bitmap gen_bm1, + ext2fs_generic_bitmap gen_bm2) { + ext2fs_generic_bitmap_32 bm1 = (ext2fs_generic_bitmap_32) gen_bm1; + ext2fs_generic_bitmap_32 bm2 = (ext2fs_generic_bitmap_32) gen_bm2; blk_t i; if (!bm1 || bm1->magic != magic) @@ -361,15 +386,16 @@ errcode_t ext2fs_compare_generic_bitmap(errcode_t magic, errcode_t neq, return neq; for (i = bm1->end - ((bm1->end - bm1->start) % 8); i <= bm1->end; i++) - if (ext2fs_fast_test_block_bitmap(bm1, i) != - ext2fs_fast_test_block_bitmap(bm2, i)) + if (ext2fs_fast_test_block_bitmap(gen_bm1, i) != + ext2fs_fast_test_block_bitmap(gen_bm2, i)) return neq; return 0; } -void ext2fs_set_generic_bitmap_padding(ext2fs_generic_bitmap map) +void ext2fs_set_generic_bitmap_padding(ext2fs_generic_bitmap gen_map) { + ext2fs_generic_bitmap_32 map = (ext2fs_generic_bitmap_32) gen_map; __u32 i, j; /* Protect loop from wrap-around if map->real_end is maxed */ @@ -379,11 +405,13 @@ void ext2fs_set_generic_bitmap_padding(ext2fs_generic_bitmap map) ext2fs_set_bit(j, map->bitmap); } -errcode_t ext2fs_get_generic_bitmap_range(ext2fs_generic_bitmap bmap, +errcode_t ext2fs_get_generic_bitmap_range(ext2fs_generic_bitmap gen_bmap, errcode_t magic, __u32 start, __u32 num, void *out) { + ext2fs_generic_bitmap_32 bmap = (ext2fs_generic_bitmap_32) gen_bmap; + if (!bmap || (bmap->magic != magic)) return magic; @@ -394,11 +422,13 @@ errcode_t ext2fs_get_generic_bitmap_range(ext2fs_generic_bitmap bmap, return 0; } -errcode_t ext2fs_set_generic_bitmap_range(ext2fs_generic_bitmap bmap, +errcode_t ext2fs_set_generic_bitmap_range(ext2fs_generic_bitmap gen_bmap, errcode_t magic, __u32 start, __u32 num, void *in) { + ext2fs_generic_bitmap_32 bmap = (ext2fs_generic_bitmap_32) gen_bmap; + if (!bmap || (bmap->magic != magic)) return magic; @@ -432,10 +462,11 @@ int ext2fs_mem_is_zero(const char *mem, size_t len) /* * Return true if all of the bits in a specified range are clear */ -static int ext2fs_test_clear_generic_bitmap_range(ext2fs_generic_bitmap bitmap, +static int ext2fs_test_clear_generic_bitmap_range(ext2fs_generic_bitmap gen_bitmap, unsigned int start, unsigned int len) { + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; size_t start_byte, len_byte = len >> 3; unsigned int start_bit, len_bit = len % 8; int first_bit = 0; @@ -504,14 +535,15 @@ static int ext2fs_test_clear_generic_bitmap_range(ext2fs_generic_bitmap bitmap, return ext2fs_mem_is_zero(ADDR + start_byte, len_byte); } -errcode_t ext2fs_find_first_zero_generic_bitmap(ext2fs_generic_bitmap bitmap, +errcode_t ext2fs_find_first_zero_generic_bitmap(ext2fs_generic_bitmap gen_bitmap, __u32 start, __u32 end, __u32 *out) { + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; blk_t b; if (start < bitmap->start || end > bitmap->end || start > end) { - ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, start); + ext2fs_warn_bitmap2(gen_bitmap, EXT2FS_TEST_ERROR, start); return EINVAL; } @@ -527,14 +559,15 @@ errcode_t ext2fs_find_first_zero_generic_bitmap(ext2fs_generic_bitmap bitmap, return ENOENT; } -errcode_t ext2fs_find_first_set_generic_bitmap(ext2fs_generic_bitmap bitmap, +errcode_t ext2fs_find_first_set_generic_bitmap(ext2fs_generic_bitmap gen_bitmap, __u32 start, __u32 end, __u32 *out) { + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; blk_t b; if (start < bitmap->start || end > bitmap->end || start > end) { - ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, start); + ext2fs_warn_bitmap2(gen_bitmap, EXT2FS_TEST_ERROR, start); return EINVAL; } @@ -550,9 +583,11 @@ errcode_t ext2fs_find_first_set_generic_bitmap(ext2fs_generic_bitmap bitmap, return ENOENT; } -int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap, +int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap gen_bitmap, blk_t block, int num) { + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; + EXT2_CHECK_MAGIC(bitmap, EXT2_ET_MAGIC_BLOCK_BITMAP); if ((block < bitmap->start) || (block+num-1 > bitmap->real_end)) { ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST, @@ -563,9 +598,11 @@ int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap, bitmap, block, num); } -int ext2fs_test_inode_bitmap_range(ext2fs_inode_bitmap bitmap, +int ext2fs_test_inode_bitmap_range(ext2fs_inode_bitmap gen_bitmap, ext2_ino_t inode, int num) { + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; + EXT2_CHECK_MAGIC(bitmap, EXT2_ET_MAGIC_INODE_BITMAP); if ((inode < bitmap->start) || (inode+num-1 > bitmap->real_end)) { ext2fs_warn_bitmap(EXT2_ET_BAD_INODE_TEST, @@ -576,9 +613,10 @@ int ext2fs_test_inode_bitmap_range(ext2fs_inode_bitmap bitmap, bitmap, inode, num); } -void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, +void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap gen_bitmap, blk_t block, int num) { + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; int i; if ((block < bitmap->start) || (block+num-1 > bitmap->end)) { @@ -590,9 +628,10 @@ void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, ext2fs_fast_set_bit(block + i - bitmap->start, bitmap->bitmap); } -void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, - blk_t block, int num) +void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap gen_bitmap, + blk_t block, int num) { + ext2fs_generic_bitmap_32 bitmap = (ext2fs_generic_bitmap_32) gen_bitmap; int i; if ((block < bitmap->start) || (block+num-1 > bitmap->end)) { diff --git a/lib/ext2fs/gen_bitmap64.c b/lib/ext2fs/gen_bitmap64.c index 3fc734981..d6f3ac12c 100644 --- a/lib/ext2fs/gen_bitmap64.c +++ b/lib/ext2fs/gen_bitmap64.c @@ -68,7 +68,7 @@ * e2fsck can request an encoding which is optimized for that. */ -static void warn_bitmap(ext2fs_generic_bitmap bitmap, +static void warn_bitmap(ext2fs_generic_bitmap_64 bitmap, int code, __u64 arg) { #ifndef OMIT_COM_ERR @@ -93,7 +93,7 @@ errcode_t ext2fs_alloc_generic_bmap(ext2_filsys fs, errcode_t magic, const char *descr, ext2fs_generic_bitmap *ret) { - ext2fs_generic_bitmap bitmap; + ext2fs_generic_bitmap_64 bitmap; struct ext2_bitmap_ops *ops; ext2_ino_t num_dirs; errcode_t retval; @@ -119,7 +119,7 @@ errcode_t ext2fs_alloc_generic_bmap(ext2_filsys fs, errcode_t magic, return EINVAL; } - retval = ext2fs_get_memzero(sizeof(struct ext2fs_struct_generic_bitmap), + retval = ext2fs_get_memzero(sizeof(struct ext2fs_struct_generic_bitmap_64), &bitmap); if (retval) return retval; @@ -170,12 +170,12 @@ errcode_t ext2fs_alloc_generic_bmap(ext2_filsys fs, errcode_t magic, return retval; } - *ret = bitmap; + *ret = (ext2fs_generic_bitmap) bitmap; return 0; } #ifdef ENABLE_BMAP_STATS -static void ext2fs_print_bmap_statistics(ext2fs_generic_bitmap bitmap) +static void ext2fs_print_bmap_statistics(ext2fs_generic_bitmap_64 bitmap) { struct ext2_bmap_statistics *stats = &bitmap->stats; #ifdef ENABLE_BMAP_STATS_OPS @@ -241,13 +241,15 @@ static void ext2fs_print_bmap_statistics(ext2fs_generic_bitmap bitmap) } #endif -void ext2fs_free_generic_bmap(ext2fs_generic_bitmap bmap) +void ext2fs_free_generic_bmap(ext2fs_generic_bitmap gen_bmap) { + ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64) gen_bmap; + if (!bmap) return; if (EXT2FS_IS_32_BITMAP(bmap)) { - ext2fs_free_generic_bitmap(bmap); + ext2fs_free_generic_bitmap(gen_bmap); return; } @@ -271,24 +273,25 @@ void ext2fs_free_generic_bmap(ext2fs_generic_bitmap bmap) ext2fs_free_mem(&bmap); } -errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap src, +errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap gen_src, ext2fs_generic_bitmap *dest) { + ext2fs_generic_bitmap_64 src = (ext2fs_generic_bitmap_64) gen_src; char *descr, *new_descr; - ext2fs_generic_bitmap new_bmap; + ext2fs_generic_bitmap_64 new_bmap; errcode_t retval; if (!src) return EINVAL; if (EXT2FS_IS_32_BITMAP(src)) - return ext2fs_copy_generic_bitmap(src, dest); + return ext2fs_copy_generic_bitmap(gen_src, dest); if (!EXT2FS_IS_64_BITMAP(src)) return EINVAL; /* Allocate a new bitmap struct */ - retval = ext2fs_get_memzero(sizeof(struct ext2fs_struct_generic_bitmap), + retval = ext2fs_get_memzero(sizeof(struct ext2fs_struct_generic_bitmap_64), &new_bmap); if (retval) return retval; @@ -336,21 +339,23 @@ errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap src, return retval; } - *dest = new_bmap; + *dest = (ext2fs_generic_bitmap) new_bmap; return 0; } -errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap bmap, +errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap gen_bmap, __u64 new_end, __u64 new_real_end) { + ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64) gen_bmap; + if (!bmap) return EINVAL; if (EXT2FS_IS_32_BITMAP(bmap)) - return ext2fs_resize_generic_bitmap(bmap->magic, new_end, - new_real_end, bmap); + return ext2fs_resize_generic_bitmap(gen_bmap->magic, new_end, + new_real_end, gen_bmap); if (!EXT2FS_IS_64_BITMAP(bmap)) return EINVAL; @@ -360,10 +365,12 @@ errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap bmap, return bmap->bitmap_ops->resize_bmap(bmap, new_end, new_real_end); } -errcode_t ext2fs_fudge_generic_bmap_end(ext2fs_generic_bitmap bitmap, +errcode_t ext2fs_fudge_generic_bmap_end(ext2fs_generic_bitmap gen_bitmap, errcode_t neq, __u64 end, __u64 *oend) { + ext2fs_generic_bitmap_64 bitmap = (ext2fs_generic_bitmap_64) gen_bitmap; + if (!bitmap) return EINVAL; @@ -371,7 +378,8 @@ errcode_t ext2fs_fudge_generic_bmap_end(ext2fs_generic_bitmap bitmap, ext2_ino_t tmp_oend; int retval; - retval = ext2fs_fudge_generic_bitmap_end(bitmap, bitmap->magic, + retval = ext2fs_fudge_generic_bitmap_end(gen_bitmap, + bitmap->magic, neq, end, &tmp_oend); if (oend) *oend = tmp_oend; @@ -389,13 +397,15 @@ errcode_t ext2fs_fudge_generic_bmap_end(ext2fs_generic_bitmap bitmap, return 0; } -__u64 ext2fs_get_generic_bmap_start(ext2fs_generic_bitmap bitmap) +__u64 ext2fs_get_generic_bmap_start(ext2fs_generic_bitmap gen_bitmap) { + ext2fs_generic_bitmap_64 bitmap = (ext2fs_generic_bitmap_64) gen_bitmap; + if (!bitmap) return EINVAL; if (EXT2FS_IS_32_BITMAP(bitmap)) - return ext2fs_get_generic_bitmap_start(bitmap); + return ext2fs_get_generic_bitmap_start(gen_bitmap); if (!EXT2FS_IS_64_BITMAP(bitmap)) return EINVAL; @@ -403,13 +413,15 @@ __u64 ext2fs_get_generic_bmap_start(ext2fs_generic_bitmap bitmap) return bitmap->start; } -__u64 ext2fs_get_generic_bmap_end(ext2fs_generic_bitmap bitmap) +__u64 ext2fs_get_generic_bmap_end(ext2fs_generic_bitmap gen_bitmap) { + ext2fs_generic_bitmap_64 bitmap = (ext2fs_generic_bitmap_64) gen_bitmap; + if (!bitmap) return EINVAL; if (EXT2FS_IS_32_BITMAP(bitmap)) - return ext2fs_get_generic_bitmap_end(bitmap); + return ext2fs_get_generic_bitmap_end(gen_bitmap); if (!EXT2FS_IS_64_BITMAP(bitmap)) return EINVAL; @@ -417,27 +429,31 @@ __u64 ext2fs_get_generic_bmap_end(ext2fs_generic_bitmap bitmap) return bitmap->end; } -void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap) +void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap gen_bitmap) { + ext2fs_generic_bitmap_64 bitmap = (ext2fs_generic_bitmap_64) gen_bitmap; + if (EXT2FS_IS_32_BITMAP(bitmap)) - ext2fs_clear_generic_bitmap(bitmap); + ext2fs_clear_generic_bitmap(gen_bitmap); else - bitmap->bitmap_ops->clear_bmap (bitmap); + bitmap->bitmap_ops->clear_bmap(bitmap); } -int ext2fs_mark_generic_bmap(ext2fs_generic_bitmap bitmap, +int ext2fs_mark_generic_bmap(ext2fs_generic_bitmap gen_bitmap, __u64 arg) { + ext2fs_generic_bitmap_64 bitmap = (ext2fs_generic_bitmap_64) gen_bitmap; + if (!bitmap) return 0; if (EXT2FS_IS_32_BITMAP(bitmap)) { if (arg & ~0xffffffffULL) { - ext2fs_warn_bitmap2(bitmap, + ext2fs_warn_bitmap2(gen_bitmap, EXT2FS_MARK_ERROR, 0xffffffff); return 0; } - return ext2fs_mark_generic_bitmap(bitmap, arg); + return ext2fs_mark_generic_bitmap(gen_bitmap, arg); } if (!EXT2FS_IS_64_BITMAP(bitmap)) @@ -462,19 +478,21 @@ int ext2fs_mark_generic_bmap(ext2fs_generic_bitmap bitmap, return bitmap->bitmap_ops->mark_bmap(bitmap, arg); } -int ext2fs_unmark_generic_bmap(ext2fs_generic_bitmap bitmap, +int ext2fs_unmark_generic_bmap(ext2fs_generic_bitmap gen_bitmap, __u64 arg) { + ext2fs_generic_bitmap_64 bitmap = (ext2fs_generic_bitmap_64) gen_bitmap; + if (!bitmap) return 0; if (EXT2FS_IS_32_BITMAP(bitmap)) { if (arg & ~0xffffffffULL) { - ext2fs_warn_bitmap2(bitmap, EXT2FS_UNMARK_ERROR, + ext2fs_warn_bitmap2(gen_bitmap, EXT2FS_UNMARK_ERROR, 0xffffffff); return 0; } - return ext2fs_unmark_generic_bitmap(bitmap, arg); + return ext2fs_unmark_generic_bitmap(gen_bitmap, arg); } if (!EXT2FS_IS_64_BITMAP(bitmap)) @@ -492,19 +510,20 @@ int ext2fs_unmark_generic_bmap(ext2fs_generic_bitmap bitmap, return bitmap->bitmap_ops->unmark_bmap(bitmap, arg); } -int ext2fs_test_generic_bmap(ext2fs_generic_bitmap bitmap, +int ext2fs_test_generic_bmap(ext2fs_generic_bitmap gen_bitmap, __u64 arg) { + ext2fs_generic_bitmap_64 bitmap = (ext2fs_generic_bitmap_64) gen_bitmap; if (!bitmap) return 0; if (EXT2FS_IS_32_BITMAP(bitmap)) { if (arg & ~0xffffffffULL) { - ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, + ext2fs_warn_bitmap2(gen_bitmap, EXT2FS_TEST_ERROR, 0xffffffff); return 0; } - return ext2fs_test_generic_bitmap(bitmap, arg); + return ext2fs_test_generic_bitmap(gen_bitmap, arg); } if (!EXT2FS_IS_64_BITMAP(bitmap)) @@ -529,20 +548,22 @@ int ext2fs_test_generic_bmap(ext2fs_generic_bitmap bitmap, return bitmap->bitmap_ops->test_bmap(bitmap, arg); } -errcode_t ext2fs_set_generic_bmap_range(ext2fs_generic_bitmap bmap, +errcode_t ext2fs_set_generic_bmap_range(ext2fs_generic_bitmap gen_bmap, __u64 start, unsigned int num, void *in) { + ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64) gen_bmap; + if (!bmap) return EINVAL; if (EXT2FS_IS_32_BITMAP(bmap)) { if ((start+num-1) & ~0xffffffffULL) { - ext2fs_warn_bitmap2(bmap, EXT2FS_UNMARK_ERROR, + ext2fs_warn_bitmap2(gen_bmap, EXT2FS_UNMARK_ERROR, 0xffffffff); return EINVAL; } - return ext2fs_set_generic_bitmap_range(bmap, bmap->magic, + return ext2fs_set_generic_bitmap_range(gen_bmap, bmap->magic, start, num, in); } @@ -554,20 +575,22 @@ errcode_t ext2fs_set_generic_bmap_range(ext2fs_generic_bitmap bmap, return bmap->bitmap_ops->set_bmap_range(bmap, start, num, in); } -errcode_t ext2fs_get_generic_bmap_range(ext2fs_generic_bitmap bmap, +errcode_t ext2fs_get_generic_bmap_range(ext2fs_generic_bitmap gen_bmap, __u64 start, unsigned int num, void *out) { + ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64) gen_bmap; + if (!bmap) return EINVAL; if (EXT2FS_IS_32_BITMAP(bmap)) { if ((start+num-1) & ~0xffffffffULL) { - ext2fs_warn_bitmap2(bmap, + ext2fs_warn_bitmap2(gen_bmap, EXT2FS_UNMARK_ERROR, 0xffffffff); return EINVAL; } - return ext2fs_get_generic_bitmap_range(bmap, bmap->magic, + return ext2fs_get_generic_bitmap_range(gen_bmap, bmap->magic, start, num, out); } @@ -580,9 +603,11 @@ errcode_t ext2fs_get_generic_bmap_range(ext2fs_generic_bitmap bmap, } errcode_t ext2fs_compare_generic_bmap(errcode_t neq, - ext2fs_generic_bitmap bm1, - ext2fs_generic_bitmap bm2) + ext2fs_generic_bitmap gen_bm1, + ext2fs_generic_bitmap gen_bm2) { + ext2fs_generic_bitmap_64 bm1 = (ext2fs_generic_bitmap_64) gen_bm1; + ext2fs_generic_bitmap_64 bm2 = (ext2fs_generic_bitmap_64) gen_bm2; blk64_t i; if (!bm1 || !bm2) @@ -592,7 +617,8 @@ errcode_t ext2fs_compare_generic_bmap(errcode_t neq, /* Now we know both bitmaps have the same magic */ if (EXT2FS_IS_32_BITMAP(bm1)) - return ext2fs_compare_generic_bitmap(bm1->magic, neq, bm1, bm2); + return ext2fs_compare_generic_bitmap(bm1->magic, neq, + gen_bm1, gen_bm2); if (!EXT2FS_IS_64_BITMAP(bm1)) return EINVAL; @@ -602,19 +628,20 @@ errcode_t ext2fs_compare_generic_bmap(errcode_t neq, return neq; for (i = bm1->end - ((bm1->end - bm1->start) % 8); i <= bm1->end; i++) - if (ext2fs_test_generic_bmap(bm1, i) != - ext2fs_test_generic_bmap(bm2, i)) + if (ext2fs_test_generic_bmap(gen_bm1, i) != + ext2fs_test_generic_bmap(gen_bm2, i)) return neq; return 0; } -void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap) +void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap gen_bmap) { + ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64) gen_bmap; __u64 start, num; if (EXT2FS_IS_32_BITMAP(bmap)) { - ext2fs_set_generic_bitmap_padding(bmap); + ext2fs_set_generic_bitmap_padding(gen_bmap); return; } @@ -624,9 +651,10 @@ void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap) /* XXX ought to warn on error */ } -int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bmap, +int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap gen_bmap, blk64_t block, unsigned int num) { + ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64) gen_bmap; __u64 end = block + num; if (!bmap) @@ -666,9 +694,10 @@ int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bmap, return bmap->bitmap_ops->test_clear_bmap_extent(bmap, block, num); } -void ext2fs_mark_block_bitmap_range2(ext2fs_block_bitmap bmap, +void ext2fs_mark_block_bitmap_range2(ext2fs_block_bitmap gen_bmap, blk64_t block, unsigned int num) { + ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64) gen_bmap; __u64 end = block + num; if (!bmap) @@ -704,9 +733,10 @@ void ext2fs_mark_block_bitmap_range2(ext2fs_block_bitmap bmap, bmap->bitmap_ops->mark_bmap_extent(bmap, block, num); } -void ext2fs_unmark_block_bitmap_range2(ext2fs_block_bitmap bmap, +void ext2fs_unmark_block_bitmap_range2(ext2fs_block_bitmap gen_bmap, blk64_t block, unsigned int num) { + ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64) gen_bmap; __u64 end = block + num; if (!bmap) @@ -742,8 +772,10 @@ void ext2fs_unmark_block_bitmap_range2(ext2fs_block_bitmap bmap, bmap->bitmap_ops->unmark_bmap_extent(bmap, block, num); } -void ext2fs_warn_bitmap32(ext2fs_generic_bitmap bitmap, const char *func) +void ext2fs_warn_bitmap32(ext2fs_generic_bitmap gen_bitmap, const char *func) { + ext2fs_generic_bitmap_64 bitmap = (ext2fs_generic_bitmap_64) gen_bitmap; + #ifndef OMIT_COM_ERR if (bitmap && bitmap->description) com_err(0, EXT2_ET_MAGIC_GENERIC_BITMAP, @@ -758,21 +790,22 @@ void ext2fs_warn_bitmap32(ext2fs_generic_bitmap bitmap, const char *func) errcode_t ext2fs_convert_subcluster_bitmap(ext2_filsys fs, ext2fs_block_bitmap *bitmap) { - ext2fs_block_bitmap cmap, bmap; + ext2fs_generic_bitmap_64 bmap, cmap; + ext2fs_block_bitmap gen_bmap = *bitmap, gen_cmap; errcode_t retval; blk64_t i, b_end, c_end; int n, ratio; - bmap = *bitmap; - - if (fs->cluster_ratio_bits == ext2fs_get_bitmap_granularity(bmap)) + bmap = (ext2fs_generic_bitmap_64) gen_bmap; + if (fs->cluster_ratio_bits == ext2fs_get_bitmap_granularity(gen_bmap)) return 0; /* Nothing to do */ retval = ext2fs_allocate_block_bitmap(fs, "converted cluster bitmap", - &cmap); + &gen_cmap); if (retval) return retval; + cmap = (ext2fs_generic_bitmap_64) gen_cmap; i = bmap->start; b_end = bmap->end; bmap->end = bmap->real_end; @@ -781,8 +814,8 @@ errcode_t ext2fs_convert_subcluster_bitmap(ext2_filsys fs, n = 0; ratio = 1 << fs->cluster_ratio_bits; while (i < bmap->real_end) { - if (ext2fs_test_block_bitmap2(bmap, i)) { - ext2fs_mark_block_bitmap2(cmap, i); + if (ext2fs_test_block_bitmap2(gen_bmap, i)) { + ext2fs_mark_block_bitmap2(gen_cmap, i); i += ratio - n; n = 0; continue; @@ -793,14 +826,15 @@ errcode_t ext2fs_convert_subcluster_bitmap(ext2_filsys fs, } bmap->end = b_end; cmap->end = c_end; - ext2fs_free_block_bitmap(bmap); - *bitmap = cmap; + ext2fs_free_block_bitmap(gen_bmap); + *bitmap = (ext2fs_block_bitmap) cmap; return 0; } errcode_t ext2fs_find_first_zero_generic_bmap(ext2fs_generic_bitmap bitmap, __u64 start, __u64 end, __u64 *out) { + ext2fs_generic_bitmap_64 bmap64 = (ext2fs_generic_bitmap_64) bitmap; __u64 cstart, cend, cout; errcode_t retval; @@ -826,27 +860,27 @@ errcode_t ext2fs_find_first_zero_generic_bmap(ext2fs_generic_bitmap bitmap, if (!EXT2FS_IS_64_BITMAP(bitmap)) return EINVAL; - cstart = start >> bitmap->cluster_bits; - cend = end >> bitmap->cluster_bits; + cstart = start >> bmap64->cluster_bits; + cend = end >> bmap64->cluster_bits; - if (cstart < bitmap->start || cend > bitmap->end || start > end) { - warn_bitmap(bitmap, EXT2FS_TEST_ERROR, start); + if (cstart < bmap64->start || cend > bmap64->end || start > end) { + warn_bitmap(bmap64, EXT2FS_TEST_ERROR, start); return EINVAL; } - if (bitmap->bitmap_ops->find_first_zero) { - retval = bitmap->bitmap_ops->find_first_zero(bitmap, cstart, + if (bmap64->bitmap_ops->find_first_zero) { + retval = bmap64->bitmap_ops->find_first_zero(bmap64, cstart, cend, &cout); if (retval) return retval; found: - cout <<= bitmap->cluster_bits; + cout <<= bmap64->cluster_bits; *out = (cout >= start) ? cout : start; return 0; } for (cout = cstart; cout <= cend; cout++) - if (!bitmap->bitmap_ops->test_bmap(bitmap, cout)) + if (!bmap64->bitmap_ops->test_bmap(bmap64, cout)) goto found; return ENOENT; @@ -855,6 +889,7 @@ errcode_t ext2fs_find_first_zero_generic_bmap(ext2fs_generic_bitmap bitmap, errcode_t ext2fs_find_first_set_generic_bmap(ext2fs_generic_bitmap bitmap, __u64 start, __u64 end, __u64 *out) { + ext2fs_generic_bitmap_64 bmap64 = (ext2fs_generic_bitmap_64) bitmap; __u64 cstart, cend, cout; errcode_t retval; @@ -880,27 +915,27 @@ errcode_t ext2fs_find_first_set_generic_bmap(ext2fs_generic_bitmap bitmap, if (!EXT2FS_IS_64_BITMAP(bitmap)) return EINVAL; - cstart = start >> bitmap->cluster_bits; - cend = end >> bitmap->cluster_bits; + cstart = start >> bmap64->cluster_bits; + cend = end >> bmap64->cluster_bits; - if (cstart < bitmap->start || cend > bitmap->end || start > end) { - warn_bitmap(bitmap, EXT2FS_TEST_ERROR, start); + if (cstart < bmap64->start || cend > bmap64->end || start > end) { + warn_bitmap(bmap64, EXT2FS_TEST_ERROR, start); return EINVAL; } - if (bitmap->bitmap_ops->find_first_set) { - retval = bitmap->bitmap_ops->find_first_set(bitmap, cstart, + if (bmap64->bitmap_ops->find_first_set) { + retval = bmap64->bitmap_ops->find_first_set(bmap64, cstart, cend, &cout); if (retval) return retval; found: - cout <<= bitmap->cluster_bits; + cout <<= bmap64->cluster_bits; *out = (cout >= start) ? cout : start; return 0; } for (cout = cstart; cout <= cend; cout++) - if (bitmap->bitmap_ops->test_bmap(bitmap, cout)) + if (bmap64->bitmap_ops->test_bmap(bmap64, cout)) goto found; return ENOENT; From patchwork Thu Aug 9 02:42:16 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Theodore Ts'o X-Patchwork-Id: 955306 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=mit.edu Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=thunk.org header.i=@thunk.org header.b="p8kRh+ju"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mCGC68Rzz9s89 for ; Thu, 9 Aug 2018 12:42:27 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727774AbeHIFEz (ORCPT ); Thu, 9 Aug 2018 01:04:55 -0400 Received: from imap.thunk.org ([74.207.234.97]:52972 "EHLO imap.thunk.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727310AbeHIFEz (ORCPT ); Thu, 9 Aug 2018 01:04:55 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=thunk.org; s=ef5046eb; h=References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From: Sender:Reply-To:MIME-Version:Content-Type:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=xwJbHv1TI2ylurALKykjnMASM7UtlWba9TXDkmyNBHY=; b=p8kRh+juszDXSaXISXjRa05FZq J9EN/cJz8j9GCYoyQOAdT6wuqIfgJZv8H0VQ9D11dLr6tcHNT6mkjNLwEggHFz3Mr5/pKepGMbj2i +JIi+VUHBmCljzVKKQ+kfLYJxMsaHkHqr/LjOWH075lEyT+BFnHH2Fs8vfOdOo8YvPT4=; Received: from root (helo=callcc.thunk.org) by imap.thunk.org with local-esmtp (Exim 4.89) (envelope-from ) id 1fnau6-0000aE-UO; Thu, 09 Aug 2018 02:42:23 +0000 Received: by callcc.thunk.org (Postfix, from userid 15806) id B80A07A6514; Wed, 8 Aug 2018 22:42:21 -0400 (EDT) From: Theodore Ts'o To: Ext4 Developers List Cc: Theodore Ts'o Subject: [PATCH 2/5] Fix function declarations for ss commands to fix LTO warnings Date: Wed, 8 Aug 2018 22:42:16 -0400 Message-Id: <20180809024219.15696-2-tytso@mit.edu> X-Mailer: git-send-email 2.18.0.rc0 In-Reply-To: <20180809024219.15696-1-tytso@mit.edu> References: <20180809024219.15696-1-tytso@mit.edu> X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: tytso@thunk.org X-SA-Exim-Scanned: No (on imap.thunk.org); SAEximRunCond expanded to false Sender: linux-ext4-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org Signed-off-by: Theodore Ts'o --- debugfs/debugfs.c | 174 +++++++++++++++++++++----------- debugfs/debugfs.h | 202 ++++++++++++++++++------------------- debugfs/do_journal.c | 14 ++- debugfs/dump.c | 9 +- debugfs/extent_inode.c | 72 ++++++++----- debugfs/filefrag.c | 3 +- debugfs/htree.c | 9 +- debugfs/icheck.c | 3 +- debugfs/logdump.c | 3 +- debugfs/ls.c | 3 +- debugfs/lsdel.c | 3 +- debugfs/ncheck.c | 3 +- debugfs/quota.c | 6 +- debugfs/set_fields.c | 17 +++- debugfs/unused.c | 4 +- debugfs/xattrs.c | 12 ++- debugfs/zap.c | 6 +- lib/ext2fs/tst_bitmaps.c | 50 ++++++--- lib/ext2fs/tst_libext2fs.c | 3 +- misc/e2freefrag.c | 3 +- tests/progs/test_icount.c | 27 +++-- tests/progs/test_icount.h | 18 ++-- 22 files changed, 394 insertions(+), 250 deletions(-) diff --git a/debugfs/debugfs.c b/debugfs/debugfs.c index 0b04508ef..e03519c42 100644 --- a/debugfs/debugfs.c +++ b/debugfs/debugfs.c @@ -50,7 +50,7 @@ int journal_enable_debug = -1; ss_request_table *extra_cmds; const char *debug_prog_name; -int sci_idx; +int ss_sci_idx; ext2_filsys current_fs; quota_ctx_t current_qctx; @@ -218,7 +218,8 @@ errout: com_err(device, retval, "while trying to close filesystem"); } -void do_open_filesys(int argc, char **argv) +void do_open_filesys(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int c, err; int catastrophic = 0; @@ -294,7 +295,8 @@ print_usage: "\n", argv[0]); } -void do_lcd(int argc, char **argv) +void do_lcd(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (argc != 2) { com_err(argv[0], 0, "Usage: %s %s", argv[0], ""); @@ -331,7 +333,8 @@ static void close_filesystem(NOARGS) return; } -void do_close_filesys(int argc, char **argv) +void do_close_filesys(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int c; @@ -359,7 +362,8 @@ void do_close_filesys(int argc, char **argv) } #ifndef READ_ONLY -void do_init_filesys(int argc, char **argv) +void do_init_filesys(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct ext2_super_block param; errcode_t retval; @@ -419,7 +423,9 @@ static void print_bg_opts(ext2_filsys fs, dgrp_t group, int mask, } } -void do_show_super_stats(int argc, char *argv[]) +void do_show_super_stats(int argc, char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *units ="block"; dgrp_t i; @@ -514,7 +520,9 @@ print_usage: #ifndef READ_ONLY void do_dirty_filesys(int argc EXT2FS_ATTR((unused)), - char **argv EXT2FS_ATTR((unused))) + char **argv EXT2FS_ATTR((unused)), + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (check_fs_open(argv[0])) return; @@ -965,7 +973,8 @@ static void dump_inode(ext2_ino_t inode_num, struct ext2_inode *inode) close_pager(out); } -void do_stat(int argc, char *argv[]) +void do_stat(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; struct ext2_inode * inode_buf; @@ -996,7 +1005,8 @@ void do_stat(int argc, char *argv[]) return; } -void do_dump_extents(int argc, char **argv) +void do_dump_extents(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct ext2_inode inode; ext2_ino_t ino; @@ -1067,7 +1077,8 @@ static int print_blocks_proc(ext2_filsys fs EXT2FS_ATTR((unused)), return 0; } -void do_blocks(int argc, char *argv[]) +void do_blocks(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; @@ -1084,7 +1095,8 @@ void do_blocks(int argc, char *argv[]) return; } -void do_chroot(int argc, char *argv[]) +void do_chroot(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; int retval; @@ -1101,7 +1113,8 @@ void do_chroot(int argc, char *argv[]) } #ifndef READ_ONLY -void do_clri(int argc, char *argv[]) +void do_clri(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; struct ext2_inode inode_buf; @@ -1116,7 +1129,8 @@ void do_clri(int argc, char *argv[]) return; } -void do_freei(int argc, char *argv[]) +void do_freei(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int len = 1; int err = 0; @@ -1146,7 +1160,8 @@ void do_freei(int argc, char *argv[]) ext2fs_mark_ib_dirty(current_fs); } -void do_seti(int argc, char *argv[]) +void do_seti(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int len = 1; int err = 0; @@ -1177,7 +1192,8 @@ void do_seti(int argc, char *argv[]) } #endif /* READ_ONLY */ -void do_testi(int argc, char *argv[]) +void do_testi(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; @@ -1191,7 +1207,8 @@ void do_testi(int argc, char *argv[]) } #ifndef READ_ONLY -void do_freeb(int argc, char *argv[]) +void do_freeb(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { blk64_t block; blk64_t count = 1; @@ -1210,7 +1227,8 @@ void do_freeb(int argc, char *argv[]) ext2fs_mark_bb_dirty(current_fs); } -void do_setb(int argc, char *argv[]) +void do_setb(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { blk64_t block; blk64_t count = 1; @@ -1230,7 +1248,8 @@ void do_setb(int argc, char *argv[]) } #endif /* READ_ONLY */ -void do_testb(int argc, char *argv[]) +void do_testb(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { blk64_t block; blk64_t count = 1; @@ -1314,7 +1333,8 @@ static void modify_u32(char *com, const char *prompt, } -void do_modify_inode(int argc, char *argv[]) +void do_modify_inode(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct ext2_inode inode; ext2_ino_t inode_num; @@ -1391,7 +1411,9 @@ void do_modify_inode(int argc, char *argv[]) } #endif /* READ_ONLY */ -void do_change_working_dir(int argc, char *argv[]) +void do_change_working_dir(int argc, char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; int retval; @@ -1408,7 +1430,9 @@ void do_change_working_dir(int argc, char *argv[]) return; } -void do_print_working_directory(int argc, char *argv[]) +void do_print_working_directory(int argc, char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int retval; char *pathname = NULL; @@ -1497,7 +1521,8 @@ static void make_link(char *sourcename, char *destname) } -void do_link(int argc, char *argv[]) +void do_link(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (common_args_process(argc, argv, 3, 3, "link", " ", CHECK_FS_RW)) @@ -1519,7 +1544,8 @@ static int mark_blocks_proc(ext2_filsys fs, blk64_t *blocknr, return 0; } -void do_undel(int argc, char *argv[]) +void do_undel(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; struct ext2_inode inode; @@ -1582,7 +1608,8 @@ static void unlink_file_by_name(char *filename) return; } -void do_unlink(int argc, char *argv[]) +void do_unlink(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (common_args_process(argc, argv, 2, 2, "link", "", CHECK_FS_RW)) @@ -1591,7 +1618,8 @@ void do_unlink(int argc, char *argv[]) unlink_file_by_name(argv[1]); } -void do_copy_inode(int argc, char *argv[]) +void do_copy_inode(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t src_ino, dest_ino; unsigned char buf[4096]; @@ -1619,7 +1647,9 @@ void do_copy_inode(int argc, char *argv[]) #endif /* READ_ONLY */ -void do_find_free_block(int argc, char *argv[]) +void do_find_free_block(int argc, char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { blk64_t free_blk, goal, first_free = 0; int count; @@ -1671,7 +1701,9 @@ void do_find_free_block(int argc, char *argv[]) printf("\n"); } -void do_find_free_inode(int argc, char *argv[]) +void do_find_free_inode(int argc, char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t free_inode, dir; int mode; @@ -1711,7 +1743,8 @@ void do_find_free_inode(int argc, char *argv[]) } #ifndef READ_ONLY -void do_write(int argc, char *argv[]) +void do_write(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { errcode_t retval; @@ -1724,7 +1757,8 @@ void do_write(int argc, char *argv[]) com_err(argv[0], retval, 0); } -void do_mknod(int argc, char *argv[]) +void do_mknod(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned long major, minor; errcode_t retval; @@ -1774,7 +1808,8 @@ void do_mknod(int argc, char *argv[]) com_err(argv[0], retval, 0); } -void do_mkdir(int argc, char *argv[]) +void do_mkdir(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { errcode_t retval; @@ -1827,7 +1862,8 @@ static void kill_file_by_inode(ext2_ino_t inode) } -void do_kill_file(int argc, char *argv[]) +void do_kill_file(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode_num; @@ -1837,7 +1873,8 @@ void do_kill_file(int argc, char *argv[]) kill_file_by_inode(inode_num); } -void do_rm(int argc, char *argv[]) +void do_rm(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int retval; ext2_ino_t inode_num; @@ -1898,7 +1935,8 @@ static int rmdir_proc(ext2_ino_t dir EXT2FS_ATTR((unused)), return 0; } -void do_rmdir(int argc, char *argv[]) +void do_rmdir(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int retval; ext2_ino_t inode_num; @@ -1956,7 +1994,9 @@ void do_rmdir(int argc, char *argv[]) #endif /* READ_ONLY */ void do_show_debugfs_params(int argc EXT2FS_ATTR((unused)), - char *argv[] EXT2FS_ATTR((unused))) + char *argv[] EXT2FS_ATTR((unused)), + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (current_fs) printf("Open mode: read-%s\n", @@ -1966,7 +2006,8 @@ void do_show_debugfs_params(int argc EXT2FS_ATTR((unused)), } #ifndef READ_ONLY -void do_expand_dir(int argc, char *argv[]) +void do_expand_dir(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; int retval; @@ -1980,7 +2021,8 @@ void do_expand_dir(int argc, char *argv[]) return; } -void do_features(int argc, char *argv[]) +void do_features(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int i; @@ -2001,7 +2043,8 @@ void do_features(int argc, char *argv[]) } #endif /* READ_ONLY */ -void do_bmap(int argc, char *argv[]) +void do_bmap(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; blk64_t blk, pblk = 0; @@ -2064,7 +2107,8 @@ void do_bmap(int argc, char *argv[]) fputc('\n', stdout); } -void do_imap(int argc, char *argv[]) +void do_imap(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; unsigned long group, block, block_nr, offset; @@ -2095,7 +2139,8 @@ void do_imap(int argc, char *argv[]) } -void do_idump(int argc, char *argv[]) +void do_idump(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct ext2_inode_large *inode; ext2_ino_t ino; @@ -2165,7 +2210,9 @@ err: } #ifndef READ_ONLY -void do_set_current_time(int argc, char *argv[]) +void do_set_current_time(int argc, char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { __s64 now; @@ -2224,7 +2271,9 @@ static int find_supp_feature(__u32 *supp, int feature_type, char *name) return 0; } -void do_supported_features(int argc, char *argv[]) +void do_supported_features(int argc, char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int ret; __u32 supp[3] = { EXT2_LIB_FEATURE_COMPAT_SUPP, @@ -2252,7 +2301,8 @@ void do_supported_features(int argc, char *argv[]) } #ifndef READ_ONLY -void do_punch(int argc, char *argv[]) +void do_punch(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; blk64_t start, end; @@ -2287,7 +2337,8 @@ void do_punch(int argc, char *argv[]) } } -void do_fallocate(int argc, char *argv[]) +void do_fallocate(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; blk64_t start, end; @@ -2324,7 +2375,8 @@ void do_fallocate(int argc, char *argv[]) } #endif /* READ_ONLY */ -void do_symlink(int argc, char *argv[]) +void do_symlink(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { errcode_t retval; @@ -2339,7 +2391,9 @@ void do_symlink(int argc, char *argv[]) } #if CONFIG_MMP -void do_dump_mmp(int argc EXT2FS_ATTR((unused)), char *argv[]) +void do_dump_mmp(int argc EXT2FS_ATTR((unused)), char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct mmp_struct *mmp_s; unsigned long long mmp_block; @@ -2399,7 +2453,9 @@ void do_dump_mmp(int argc EXT2FS_ATTR((unused)), char *argv[]) } #else void do_dump_mmp(int argc EXT2FS_ATTR((unused)), - char *argv[] EXT2FS_ATTR((unused))) + char *argv[] EXT2FS_ATTR((unused)), + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { fprintf(stdout, "MMP is unsupported, please recompile with " "--enable-mmp\n"); @@ -2557,39 +2613,39 @@ int main(int argc, char **argv) superblock, blocksize, catastrophic, data_filename, undo_file); - sci_idx = ss_create_invocation(debug_prog_name, "0.0", (char *) NULL, - &debug_cmds, &retval); + ss_sci_idx = ss_create_invocation(debug_prog_name, "0.0", (char *) NULL, + &debug_cmds, &retval); if (retval) { - ss_perror(sci_idx, retval, "creating invocation"); + ss_perror(ss_sci_idx, retval, "creating invocation"); exit(1); } - ss_get_readline(sci_idx); + ss_get_readline(ss_sci_idx); - (void) ss_add_request_table (sci_idx, &ss_std_requests, 1, &retval); + (void) ss_add_request_table(ss_sci_idx, &ss_std_requests, 1, &retval); if (retval) { - ss_perror(sci_idx, retval, "adding standard requests"); + ss_perror(ss_sci_idx, retval, "adding standard requests"); exit (1); } if (extra_cmds) - ss_add_request_table (sci_idx, extra_cmds, 1, &retval); + ss_add_request_table(ss_sci_idx, extra_cmds, 1, &retval); if (retval) { - ss_perror(sci_idx, retval, "adding extra requests"); + ss_perror(ss_sci_idx, retval, "adding extra requests"); exit (1); } if (request) { retval = 0; - retval = ss_execute_line(sci_idx, request); + retval = ss_execute_line(ss_sci_idx, request); if (retval) { - ss_perror(sci_idx, retval, request); + ss_perror(ss_sci_idx, retval, request); exit_status++; } } else if (cmd_file) { - exit_status = source_file(cmd_file, sci_idx); + exit_status = source_file(cmd_file, ss_sci_idx); } else { - ss_listen(sci_idx); + ss_listen(ss_sci_idx); } - ss_delete_invocation(sci_idx); + ss_delete_invocation(ss_sci_idx); if (current_fs) close_filesystem(); diff --git a/debugfs/debugfs.h b/debugfs/debugfs.h index 93f036dec..449740be8 100644 --- a/debugfs/debugfs.h +++ b/debugfs/debugfs.h @@ -67,127 +67,127 @@ extern int ext2_file_type(unsigned int mode); /* ss command functions */ /* dump.c */ -extern void do_dump(int argc, char **argv); -extern void do_cat(int argc, char **argv); -extern void do_rdump(int argc, char **argv); +extern void do_dump(int argc, char **argv, int sci_idx, void *infop); +extern void do_cat(int argc, char **argv, int sci_idx, void *infop); +extern void do_rdump(int argc, char **argv, int sci_idx, void *infop); /* extent_inode.c */ -extern void do_extent_open(int argc, char **argv); -extern void do_extent_close(int argc, char **argv); -extern void do_current_node(int argc, char **argv); -extern void do_root_node(int argc, char **argv); -extern void do_last_leaf(int argc, char **argv); -extern void do_first_sib(int argc, char **argv); -extern void do_last_sib(int argc, char **argv); -extern void do_next_sib(int argc, char **argv); -extern void do_prev_sib(int argc, char **argv); -extern void do_next_leaf(int argc, char **argv); -extern void do_prev_leaf(int argc, char **argv); -extern void do_next(int argc, char **argv); -extern void do_prev(int argc, char **argv); -extern void do_up(int argc, char **argv); -extern void do_down(int argc, char **argv); -extern void do_delete_node(int argc, char **argv); -extern void do_replace_node(int argc, char **argv); -extern void do_split_node(int argc, char **argv); -extern void do_insert_node(int argc, char **argv); -extern void do_set_bmap(int argc, char **argv); -extern void do_print_all(int argc, char **argv); -extern void do_fix_parents(int argc, char **argv); -extern void do_info(int argc, char **argv); -extern void do_goto_block(int argc, char **argv); +extern void do_extent_open(int argc, char **argv, int sci_idx, void *infop); +extern void do_extent_close(int argc, char **argv, int sci_idx, void *infop); +extern void do_current_node(int argc, char **argv, int sci_idx, void *infop); +extern void do_root_node(int argc, char **argv, int sci_idx, void *infop); +extern void do_last_leaf(int argc, char **argv, int sci_idx, void *infop); +extern void do_first_sib(int argc, char **argv, int sci_idx, void *infop); +extern void do_last_sib(int argc, char **argv, int sci_idx, void *infop); +extern void do_next_sib(int argc, char **argv, int sci_idx, void *infop); +extern void do_prev_sib(int argc, char **argv, int sci_idx, void *infop); +extern void do_next_leaf(int argc, char **argv, int sci_idx, void *infop); +extern void do_prev_leaf(int argc, char **argv, int sci_idx, void *infop); +extern void do_next(int argc, char **argv, int sci_idx, void *infop); +extern void do_prev(int argc, char **argv, int sci_idx, void *infop); +extern void do_up(int argc, char **argv, int sci_idx, void *infop); +extern void do_down(int argc, char **argv, int sci_idx, void *infop); +extern void do_delete_node(int argc, char **argv, int sci_idx, void *infop); +extern void do_replace_node(int argc, char **argv, int sci_idx, void *infop); +extern void do_split_node(int argc, char **argv, int sci_idx, void *infop); +extern void do_insert_node(int argc, char **argv, int sci_idx, void *infop); +extern void do_set_bmap(int argc, char **argv, int sci_idx, void *infop); +extern void do_print_all(int argc, char **argv, int sci_idx, void *infop); +extern void do_fix_parents(int argc, char **argv, int sci_idx, void *infop); +extern void do_info(int argc, char **argv, int sci_idx, void *infop); +extern void do_goto_block(int argc, char **argv, int sci_idx, void *infop); /* htree.c */ -extern void do_htree_dump(int argc, char **argv); -extern void do_dx_hash(int argc, char **argv); -extern void do_dirsearch(int argc, char **argv); +extern void do_htree_dump(int argc, char **argv, int sci_idx, void *infop); +extern void do_dx_hash(int argc, char **argv, int sci_idx, void *infop); +extern void do_dirsearch(int argc, char **argv, int sci_idx, void *infop); /* logdump.c */ -extern void do_logdump(int argc, char **argv); +extern void do_logdump(int argc, char **argv, int sci_idx, void *infop); /* lsdel.c */ -extern void do_lsdel(int argc, char **argv); +extern void do_lsdel(int argc, char **argv, int sci_idx, void *infop); /* icheck.c */ -extern void do_icheck(int argc, char **argv); +extern void do_icheck(int argc, char **argv, int sci_idx, void *infop); /* ncheck.c */ -extern void do_ncheck(int argc, char **argv); +extern void do_ncheck(int argc, char **argv, int sci_idx, void *infop); /* set_fields.c */ -extern void do_set_super(int argc, char **); -extern void do_set_inode(int argc, char **); -extern void do_set_block_group_descriptor(int argc, char **); +extern void do_set_super(int argc, char **, int sci_idx, void *infop); +extern void do_set_inode(int argc, char **, int sci_idx, void *infop); +extern void do_set_block_group_descriptor(int argc, char **, int sci_idx, void *infop); /* unused.c */ -extern void do_dump_unused(int argc, char **argv); +extern void do_dump_unused(int argc, char **argv, int sci_idx, void *infop); /* debugfs.c */ extern void internal_dump_inode(FILE *, const char *, ext2_ino_t, struct ext2_inode *, int); -extern void do_dirty_filesys(int argc, char **argv); -extern void do_open_filesys(int argc, char **argv); -extern void do_close_filesys(int argc, char **argv); -extern void do_lcd(int argc, char **argv); -extern void do_init_filesys(int argc, char **argv); -extern void do_show_super_stats(int argc, char **argv); -extern void do_kill_file(int argc, char **argv); -extern void do_rm(int argc, char **argv); -extern void do_link(int argc, char **argv); -extern void do_undel(int argc, char **argv); -extern void do_unlink(int argc, char **argv); -extern void do_copy_inode(int argc, char *argv[]); -extern void do_find_free_block(int argc, char **argv); -extern void do_find_free_inode(int argc, char **argv); -extern void do_stat(int argc, char **argv); -extern void do_dump_extents(int argc, char **argv); -extern void do_blocks(int argc, char *argv[]); - -extern void do_chroot(int argc, char **argv); -extern void do_clri(int argc, char **argv); -extern void do_freei(int argc, char **argv); -extern void do_seti(int argc, char **argv); -extern void do_testi(int argc, char **argv); -extern void do_freeb(int argc, char **argv); -extern void do_setb(int argc, char **argv); -extern void do_testb(int argc, char **argv); -extern void do_modify_inode(int argc, char **argv); -extern void do_list_dir(int argc, char **argv); -extern void do_change_working_dir(int argc, char **argv); -extern void do_print_working_directory(int argc, char **argv); -extern void do_write(int argc, char **argv); -extern void do_mknod(int argc, char **argv); -extern void do_mkdir(int argc, char **argv); -extern void do_rmdir(int argc, char **argv); -extern void do_show_debugfs_params(int argc, char **argv); -extern void do_expand_dir(int argc, char **argv); -extern void do_features(int argc, char **argv); -extern void do_bmap(int argc, char **argv); -extern void do_imap(int argc, char **argv); -extern void do_idump(int argc, char *argv[]); -extern void do_set_current_time(int argc, char **argv); -extern void do_supported_features(int argc, char **argv); -extern void do_punch(int argc, char **argv); -extern void do_fallocate(int argc, char **argv); -extern void do_symlink(int argc, char **argv); - -extern void do_dump_mmp(int argc, char **argv); -extern void do_set_mmp_value(int argc, char **argv); - -extern void do_freefrag(int argc, char **argv); -extern void do_filefrag(int argc, char *argv[]); +extern void do_dirty_filesys(int argc, char **argv, int sci_idx, void *infop); +extern void do_open_filesys(int argc, char **argv, int sci_idx, void *infop); +extern void do_close_filesys(int argc, char **argv, int sci_idx, void *infop); +extern void do_lcd(int argc, char **argv, int sci_idx, void *infop); +extern void do_init_filesys(int argc, char **argv, int sci_idx, void *infop); +extern void do_show_super_stats(int argc, char **argv, int sci_idx, void *infop); +extern void do_kill_file(int argc, char **argv, int sci_idx, void *infop); +extern void do_rm(int argc, char **argv, int sci_idx, void *infop); +extern void do_link(int argc, char **argv, int sci_idx, void *infop); +extern void do_undel(int argc, char **argv, int sci_idx, void *infop); +extern void do_unlink(int argc, char **argv, int sci_idx, void *infop); +extern void do_copy_inode(int argc, char *argv[], int sci_idx, void *infop); +extern void do_find_free_block(int argc, char **argv, int sci_idx, void *infop); +extern void do_find_free_inode(int argc, char **argv, int sci_idx, void *infop); +extern void do_stat(int argc, char **argv, int sci_idx, void *infop); +extern void do_dump_extents(int argc, char **argv, int sci_idx, void *infop); +extern void do_blocks(int argc, char *argv[], int sci_idx, void *infop); + +extern void do_chroot(int argc, char **argv, int sci_idx, void *infop); +extern void do_clri(int argc, char **argv, int sci_idx, void *infop); +extern void do_freei(int argc, char **argv, int sci_idx, void *infop); +extern void do_seti(int argc, char **argv, int sci_idx, void *infop); +extern void do_testi(int argc, char **argv, int sci_idx, void *infop); +extern void do_freeb(int argc, char **argv, int sci_idx, void *infop); +extern void do_setb(int argc, char **argv, int sci_idx, void *infop); +extern void do_testb(int argc, char **argv, int sci_idx, void *infop); +extern void do_modify_inode(int argc, char **argv, int sci_idx, void *infop); +extern void do_list_dir(int argc, char **argv, int sci_idx, void *infop); +extern void do_change_working_dir(int argc, char **argv, int sci_idx, void *infop); +extern void do_print_working_directory(int argc, char **argv, int sci_idx, void *infop); +extern void do_write(int argc, char **argv, int sci_idx, void *infop); +extern void do_mknod(int argc, char **argv, int sci_idx, void *infop); +extern void do_mkdir(int argc, char **argv, int sci_idx, void *infop); +extern void do_rmdir(int argc, char **argv, int sci_idx, void *infop); +extern void do_show_debugfs_params(int argc, char **argv, int sci_idx, void *infop); +extern void do_expand_dir(int argc, char **argv, int sci_idx, void *infop); +extern void do_features(int argc, char **argv, int sci_idx, void *infop); +extern void do_bmap(int argc, char **argv, int sci_idx, void *infop); +extern void do_imap(int argc, char **argv, int sci_idx, void *infop); +extern void do_idump(int argc, char *argv[], int sci_idx, void *infop); +extern void do_set_current_time(int argc, char **argv, int sci_idx, void *infop); +extern void do_supported_features(int argc, char **argv, int sci_idx, void *infop); +extern void do_punch(int argc, char **argv, int sci_idx, void *infop); +extern void do_fallocate(int argc, char **argv, int sci_idx, void *infop); +extern void do_symlink(int argc, char **argv, int sci_idx, void *infop); + +extern void do_dump_mmp(int argc, char **argv, int sci_idx, void *infop); +extern void do_set_mmp_value(int argc, char **argv, int sci_idx, void *infop); + +extern void do_freefrag(int argc, char **argv, int sci_idx, void *infop); +extern void do_filefrag(int argc, char *argv[], int sci_idx, void *infop); /* do_journal.c */ -extern void do_journal_write(int argc, char *argv[]); -extern void do_journal_open(int argc, char *argv[]); -extern void do_journal_close(int argc, char *argv[]); -extern void do_journal_run(int argc, char *argv[]); +extern void do_journal_write(int argc, char *argv[], int sci_idx, void *infop); +extern void do_journal_open(int argc, char *argv[], int sci_idx, void *infop); +extern void do_journal_close(int argc, char *argv[], int sci_idx, void *infop); +extern void do_journal_run(int argc, char *argv[], int sci_idx, void *infop); /* quota.c */ -extern void do_list_quota(int argc, char *argv[]); -extern void do_get_quota(int argc, char *argv[]); +extern void do_list_quota(int argc, char *argv[], int sci_idx, void *infop); +extern void do_get_quota(int argc, char *argv[], int sci_idx, void *infop); /* util.c */ extern __s64 string_to_time(const char *arg); @@ -195,14 +195,14 @@ errcode_t read_list(char *str, blk64_t **list, size_t *len); /* xattrs.c */ void dump_inode_attributes(FILE *out, ext2_ino_t ino); -void do_get_xattr(int argc, char **argv); -void do_set_xattr(int argc, char **argv); -void do_rm_xattr(int argc, char **argv); -void do_list_xattr(int argc, char **argv); +void do_get_xattr(int argc, char **argv, int sci_idx, void *infop); +void do_set_xattr(int argc, char **argv, int sci_idx, void *infop); +void do_rm_xattr(int argc, char **argv, int sci_idx, void *infop); +void do_list_xattr(int argc, char **argv, int sci_idx, void *infop); void raw_inode_xattr_dump(FILE *f, unsigned char *buf, unsigned int len); void block_xattr_dump(FILE *f, unsigned char *buf, unsigned int len); /* zap.c */ -extern void do_zap_block(int argc, char **argv); -extern void do_block_dump(int argc, char **argv); +extern void do_zap_block(int argc, char **argv, int sci_idx, void *infop); +extern void do_block_dump(int argc, char **argv, int sci_idx, void *infop); extern void do_byte_hexdump(FILE *fp, unsigned char *buf, size_t bufsize); diff --git a/debugfs/do_journal.c b/debugfs/do_journal.c index d7ab91615..eeb363eb4 100644 --- a/debugfs/do_journal.c +++ b/debugfs/do_journal.c @@ -534,7 +534,8 @@ error: return err; } -void do_journal_write(int argc, char *argv[]) +void do_journal_write(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { blk64_t *blist = NULL, *rlist = NULL; size_t bn = 0, rn = 0; @@ -856,7 +857,8 @@ static void update_64bit_flag(journal_t *journal) jfs_set_feature_64bit(journal); } -void do_journal_open(int argc, char *argv[]) +void do_journal_open(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int opt, enable_csum = 0, csum_ver = 3; journal_t *journal; @@ -926,7 +928,9 @@ void do_journal_open(int argc, char *argv[]) } void do_journal_close(int argc EXT2FS_ATTR((unused)), - char *argv[] EXT2FS_ATTR((unused))) + char *argv[] EXT2FS_ATTR((unused)), + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (current_journal == NULL) { printf("Journal not open.\n"); @@ -936,7 +940,9 @@ void do_journal_close(int argc EXT2FS_ATTR((unused)), ext2fs_close_journal(current_fs, ¤t_journal); } -void do_journal_run(int argc EXT2FS_ATTR((unused)), char *argv[]) +void do_journal_run(int argc EXT2FS_ATTR((unused)), char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { errcode_t err; diff --git a/debugfs/dump.c b/debugfs/dump.c index 4d5daf0ac..fdd66198e 100644 --- a/debugfs/dump.c +++ b/debugfs/dump.c @@ -144,7 +144,8 @@ static void dump_file(const char *cmdname, ext2_ino_t ino, int fd, return; } -void do_dump(int argc, char **argv) +void do_dump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; int fd; @@ -322,7 +323,8 @@ static int rdump_dirent(struct ext2_dir_entry *dirent, return 0; } -void do_rdump(int argc, char **argv) +void do_rdump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct stat st; char *dest_dir; @@ -366,7 +368,8 @@ void do_rdump(int argc, char **argv) } } -void do_cat(int argc, char **argv) +void do_cat(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; diff --git a/debugfs/extent_inode.c b/debugfs/extent_inode.c index c7a92a763..ada130869 100644 --- a/debugfs/extent_inode.c +++ b/debugfs/extent_inode.c @@ -64,7 +64,8 @@ static int common_extent_args_process(int argc, char *argv[], int min_argc, static char *orig_prompt, *extent_prompt; -void do_extent_open(int argc, char *argv[]) +void do_extent_open(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; int ret; @@ -113,7 +114,8 @@ void do_extent_open(int argc, char *argv[]) return; } -void do_extent_close(int argc, char *argv[]) +void do_extent_close(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int ret; @@ -158,72 +160,86 @@ static void generic_goto_node(const char *my_name, int argc, dbg_print_extent(0, &extent); } -void do_current_node(int argc, char *argv[]) +void do_current_node(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("current_node", argc, argv, EXT2_EXTENT_CURRENT); } -void do_root_node(int argc, char *argv[]) +void do_root_node(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("root_node", argc, argv, EXT2_EXTENT_ROOT); } -void do_last_leaf(int argc, char *argv[]) +void do_last_leaf(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("last_leaf", argc, argv, EXT2_EXTENT_LAST_LEAF); } -void do_first_sib(int argc, char *argv[]) +void do_first_sib(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("first_sib", argc, argv, EXT2_EXTENT_FIRST_SIB); } -void do_last_sib(int argc, char *argv[]) +void do_last_sib(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("next_sib", argc, argv, EXT2_EXTENT_LAST_SIB); } -void do_next_sib(int argc, char *argv[]) +void do_next_sib(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("next_sib", argc, argv, EXT2_EXTENT_NEXT_SIB); } -void do_prev_sib(int argc, char *argv[]) +void do_prev_sib(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("prev_sib", argc, argv, EXT2_EXTENT_PREV_SIB); } -void do_next_leaf(int argc, char *argv[]) +void do_next_leaf(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("next_leaf", argc, argv, EXT2_EXTENT_NEXT_LEAF); } -void do_prev_leaf(int argc, char *argv[]) +void do_prev_leaf(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("prev_leaf", argc, argv, EXT2_EXTENT_PREV_LEAF); } -void do_next(int argc, char *argv[]) +void do_next(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("next", argc, argv, EXT2_EXTENT_NEXT); } -void do_prev(int argc, char *argv[]) +void do_prev(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("prev", argc, argv, EXT2_EXTENT_PREV); } -void do_up(int argc, char *argv[]) +void do_up(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("up", argc, argv, EXT2_EXTENT_UP); } -void do_down(int argc, char *argv[]) +void do_down(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { generic_goto_node("down", argc, argv, EXT2_EXTENT_DOWN); } -void do_delete_node(int argc, char *argv[]) +void do_delete_node(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct ext2fs_extent extent; errcode_t retval; @@ -245,7 +261,8 @@ void do_delete_node(int argc, char *argv[]) dbg_print_extent(0, &extent); } -void do_replace_node(int argc, char *argv[]) +void do_replace_node(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *usage = "[--uninit] "; errcode_t retval; @@ -289,7 +306,8 @@ void do_replace_node(int argc, char *argv[]) generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT); } -void do_split_node(int argc, char *argv[]) +void do_split_node(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { errcode_t retval; @@ -305,7 +323,8 @@ void do_split_node(int argc, char *argv[]) generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT); } -void do_insert_node(int argc, char *argv[]) +void do_insert_node(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *usage = "[--after] [--uninit] "; errcode_t retval; @@ -363,7 +382,8 @@ void do_insert_node(int argc, char *argv[]) generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT); } -void do_set_bmap(int argc, char **argv) +void do_set_bmap(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *usage = "[--uninit] "; struct ext2fs_extent extent; @@ -411,7 +431,8 @@ void do_set_bmap(int argc, char **argv) dbg_print_extent(0, &extent); } -void do_print_all(int argc, char **argv) +void do_print_all(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *usage = "[--leaf-only|--reverse|--reverse-leaf]"; struct ext2fs_extent extent; @@ -462,7 +483,8 @@ void do_print_all(int argc, char **argv) } } -void do_fix_parents(int argc, char **argv) +void do_fix_parents(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { errcode_t retval; @@ -477,7 +499,8 @@ void do_fix_parents(int argc, char **argv) } } -void do_info(int argc, char **argv) +void do_info(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct ext2fs_extent extent; struct ext2_extent_info info; @@ -510,7 +533,8 @@ void do_info(int argc, char **argv) info.max_uninit_len); } -void do_goto_block(int argc, char **argv) +void do_goto_block(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { errcode_t retval; blk64_t blk; diff --git a/debugfs/filefrag.c b/debugfs/filefrag.c index 128598b0b..961b69623 100644 --- a/debugfs/filefrag.c +++ b/debugfs/filefrag.c @@ -260,7 +260,8 @@ static void dir_iterate(ext2_ino_t ino, struct filefrag_struct *fs) } } -void do_filefrag(int argc, char *argv[]) +void do_filefrag(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct filefrag_struct fs; struct ext2_inode inode; diff --git a/debugfs/htree.c b/debugfs/htree.c index cf7d78aa6..0c6a38523 100644 --- a/debugfs/htree.c +++ b/debugfs/htree.c @@ -227,7 +227,8 @@ errout: -void do_htree_dump(int argc, char *argv[]) +void do_htree_dump(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; struct ext2_inode inode; @@ -302,7 +303,8 @@ errout: /* * This function prints the hash of a given file. */ -void do_dx_hash(int argc, char *argv[]) +void do_dx_hash(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_dirhash_t hash, minor_hash; errcode_t err; @@ -362,7 +364,8 @@ static int search_dir_block(ext2_filsys fs, blk64_t *blocknr, e2_blkcnt_t blockcnt, blk64_t ref_blk, int ref_offset, void *priv_data); -void do_dirsearch(int argc, char *argv[]) +void do_dirsearch(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t inode; struct process_block_struct pb; diff --git a/debugfs/icheck.c b/debugfs/icheck.c index 3b9bd145b..71164cf74 100644 --- a/debugfs/icheck.c +++ b/debugfs/icheck.c @@ -53,7 +53,8 @@ static int icheck_proc(ext2_filsys fs EXT2FS_ATTR((unused)), return 0; } -void do_icheck(int argc, char **argv) +void do_icheck(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct block_walk_struct bw; struct block_info *binfo; diff --git a/debugfs/logdump.c b/debugfs/logdump.c index 03edb44b7..e286ae83b 100644 --- a/debugfs/logdump.c +++ b/debugfs/logdump.c @@ -72,7 +72,8 @@ static void do_hexdump (FILE *, char *, int); blocknr -= (be32_to_cpu((jsb)->s_maxlen) - \ be32_to_cpu((jsb)->s_first)); -void do_logdump(int argc, char **argv) +void do_logdump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int c; int retval; diff --git a/debugfs/ls.c b/debugfs/ls.c index bfc28cb68..a1e8f4e92 100644 --- a/debugfs/ls.c +++ b/debugfs/ls.c @@ -189,7 +189,8 @@ static int list_dir_proc(ext2_ino_t dir EXT2FS_ATTR((unused)), return 0; } -void do_list_dir(int argc, char *argv[]) +void do_list_dir(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct ext2_inode inode; ext2_ino_t ino; diff --git a/debugfs/lsdel.c b/debugfs/lsdel.c index 946b26867..c0d589007 100644 --- a/debugfs/lsdel.c +++ b/debugfs/lsdel.c @@ -71,7 +71,8 @@ static int lsdel_proc(ext2_filsys fs, return 0; } -void do_lsdel(int argc, char **argv) +void do_lsdel(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct lsdel_struct lsd; struct deleted_info *delarray; diff --git a/debugfs/ncheck.c b/debugfs/ncheck.c index 158e86586..011f26deb 100644 --- a/debugfs/ncheck.c +++ b/debugfs/ncheck.c @@ -90,7 +90,8 @@ static int ncheck_proc(struct ext2_dir_entry *dirent, return 0; } -void do_ncheck(int argc, char **argv) +void do_ncheck(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { struct inode_walk_struct iw; int c, i; diff --git a/debugfs/quota.c b/debugfs/quota.c index 0b7c2eee8..f792bd738 100644 --- a/debugfs/quota.c +++ b/debugfs/quota.c @@ -102,7 +102,8 @@ static int list_quota_callback(struct dquot *dq, return 0; } -void do_list_quota(int argc, char *argv[]) +void do_list_quota(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { errcode_t retval; int type; @@ -131,7 +132,8 @@ void do_list_quota(int argc, char *argv[]) } } -void do_get_quota(int argc, char *argv[]) +void do_get_quota(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int err, type; struct quota_handle *qh; diff --git a/debugfs/set_fields.c b/debugfs/set_fields.c index e1e23a5df..e23776153 100644 --- a/debugfs/set_fields.c +++ b/debugfs/set_fields.c @@ -723,7 +723,8 @@ static void print_possible_fields(struct field_set_info *fields) } -void do_set_super(int argc, char *argv[]) +void do_set_super(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *usage = " \n" "\t\"set_super_value -l\" will list the names of " @@ -750,7 +751,8 @@ void do_set_super(int argc, char *argv[]) } } -void do_set_inode(int argc, char *argv[]) +void do_set_inode(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *usage = " \n" "\t\"set_inode_field -l\" will list the names of " @@ -788,7 +790,9 @@ void do_set_inode(int argc, char *argv[]) } } -void do_set_block_group_descriptor(int argc, char *argv[]) +void do_set_block_group_descriptor(int argc, char *argv[], + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *usage = " \n" "\t\"set_block_group -l\" will list the names of " @@ -866,7 +870,8 @@ static errcode_t parse_mmp_clear(struct field_set_info *info, } #ifdef CONFIG_MMP -void do_set_mmp_value(int argc, char *argv[]) +void do_set_mmp_value(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *usage = " \n" "\t\"set_mmp_value -l\" will list the names of " @@ -925,7 +930,9 @@ void do_set_mmp_value(int argc, char *argv[]) } #else void do_set_mmp_value(int argc EXT2FS_ATTR((unused)), - char *argv[] EXT2FS_ATTR((unused))) + char *argv[] EXT2FS_ATTR((unused)), + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { fprintf(stdout, "MMP is unsupported, please recompile with " "--enable-mmp\n"); diff --git a/debugfs/unused.c b/debugfs/unused.c index 4cb11918c..a6b44b5eb 100644 --- a/debugfs/unused.c +++ b/debugfs/unused.c @@ -25,7 +25,9 @@ extern char *optarg; #include "debugfs.h" -void do_dump_unused(int argc EXT2FS_ATTR((unused)), char **argv) +void do_dump_unused(int argc EXT2FS_ATTR((unused)), char **argv, + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { blk64_t blk; unsigned char buf[EXT2_MAX_BLOCK_SIZE]; diff --git a/debugfs/xattrs.c b/debugfs/xattrs.c index c29761ec9..8bbaaeddb 100644 --- a/debugfs/xattrs.c +++ b/debugfs/xattrs.c @@ -117,7 +117,8 @@ out: err = ext2fs_xattrs_close(&h); } -void do_list_xattr(int argc, char **argv) +void do_list_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; @@ -137,7 +138,8 @@ void do_list_xattr(int argc, char **argv) dump_inode_attributes(stdout, ino); } -void do_get_xattr(int argc, char **argv) +void do_get_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; struct ext2_xattr_handle *h; @@ -234,7 +236,8 @@ out2: fclose(fp); } -void do_set_xattr(int argc, char **argv) +void do_set_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; struct ext2_xattr_handle *h; @@ -317,7 +320,8 @@ out2: } } -void do_rm_xattr(int argc, char **argv) +void do_rm_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { ext2_ino_t ino; struct ext2_xattr_handle *h; diff --git a/debugfs/zap.c b/debugfs/zap.c index a849b90b4..c7996b229 100644 --- a/debugfs/zap.c +++ b/debugfs/zap.c @@ -25,7 +25,8 @@ extern char *optarg; #include "debugfs.h" -void do_zap_block(int argc, char *argv[]) +void do_zap_block(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned long pattern = 0; unsigned char *buf; @@ -167,7 +168,8 @@ errout: return; } -void do_block_dump(int argc, char *argv[]) +void do_block_dump(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned char *buf; ext2_ino_t inode; diff --git a/lib/ext2fs/tst_bitmaps.c b/lib/ext2fs/tst_bitmaps.c index 574fb7a7f..f6196b315 100644 --- a/lib/ext2fs/tst_bitmaps.c +++ b/lib/ext2fs/tst_bitmaps.c @@ -190,7 +190,8 @@ errout: ext2fs_close_free(&test_fs); } -void setup_cmd(int argc, char **argv) +void setup_cmd(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { int c, err; unsigned int blocks = 128; @@ -234,7 +235,8 @@ void setup_cmd(int argc, char **argv) setup_filesystem(argv[0], blocks, inodes, type, flags); } -void close_cmd(int argc, char **argv) +void close_cmd(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (check_fs_open(argv[0])) return; @@ -269,7 +271,9 @@ void dump_bitmap(ext2fs_generic_bitmap bmap, unsigned int start, unsigned num) free(buf); } -void dump_inode_bitmap_cmd(int argc, char **argv) +void dump_inode_bitmap_cmd(int argc, char **argv, + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (check_fs_open(argv[0])) return; @@ -278,7 +282,9 @@ void dump_inode_bitmap_cmd(int argc, char **argv) dump_bitmap(test_fs->inode_map, 1, test_fs->super->s_inodes_count); } -void dump_block_bitmap_cmd(int argc, char **argv) +void dump_block_bitmap_cmd(int argc, char **argv, + int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (check_fs_open(argv[0])) return; @@ -288,7 +294,8 @@ void dump_block_bitmap_cmd(int argc, char **argv) test_fs->super->s_blocks_count); } -void do_setb(int argc, char *argv[]) +void do_setb(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int block, num; int err; @@ -326,7 +333,8 @@ void do_setb(int argc, char *argv[]) test_result, op_result); } -void do_clearb(int argc, char *argv[]) +void do_clearb(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int block, num; int err; @@ -364,7 +372,8 @@ void do_clearb(int argc, char *argv[]) test_result, op_result); } -void do_testb(int argc, char *argv[]) +void do_testb(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int block, num; int err; @@ -399,7 +408,8 @@ void do_testb(int argc, char *argv[]) printf("Block %u is %s\n", block, test_result ? "set" : "clear"); } -void do_ffzb(int argc, char *argv[]) +void do_ffzb(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int start, end; int err; @@ -432,7 +442,8 @@ void do_ffzb(int argc, char *argv[]) printf("First unmarked block is %llu\n", out); } -void do_ffsb(int argc, char *argv[]) +void do_ffsb(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int start, end; int err; @@ -466,7 +477,8 @@ void do_ffsb(int argc, char *argv[]) } -void do_zerob(int argc, char *argv[]) +void do_zerob(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (check_fs_open(argv[0])) return; @@ -475,7 +487,8 @@ void do_zerob(int argc, char *argv[]) ext2fs_clear_block_bitmap(test_fs->block_map); } -void do_seti(int argc, char *argv[]) +void do_seti(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int inode; int err; @@ -504,7 +517,8 @@ void do_seti(int argc, char *argv[]) } } -void do_cleari(int argc, char *argv[]) +void do_cleari(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int inode; int err; @@ -533,7 +547,8 @@ void do_cleari(int argc, char *argv[]) } } -void do_testi(int argc, char *argv[]) +void do_testi(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int inode; int err; @@ -555,7 +570,8 @@ void do_testi(int argc, char *argv[]) printf("Inode %u is %s\n", inode, test_result ? "set" : "clear"); } -void do_ffzi(int argc, char *argv[]) +void do_ffzi(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int start, end; int err; @@ -588,7 +604,8 @@ void do_ffzi(int argc, char *argv[]) printf("First unmarked inode is %u\n", out); } -void do_ffsi(int argc, char *argv[]) +void do_ffsi(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { unsigned int start, end; int err; @@ -621,7 +638,8 @@ void do_ffsi(int argc, char *argv[]) printf("First marked inode is %u\n", out); } -void do_zeroi(int argc, char *argv[]) +void do_zeroi(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { if (check_fs_open(argv[0])) return; diff --git a/lib/ext2fs/tst_libext2fs.c b/lib/ext2fs/tst_libext2fs.c index a90bff220..3e7497cd8 100644 --- a/lib/ext2fs/tst_libext2fs.c +++ b/lib/ext2fs/tst_libext2fs.c @@ -43,7 +43,8 @@ static int print_blocks_proc(ext2_filsys fs EXT2FS_ATTR((unused)), } -void do_block_iterate(int argc, char **argv) +void do_block_iterate(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + void *infop EXT2FS_ATTR((unused))) { const char *usage = "block_iterate X-Patchwork-Id: 955303 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=mit.edu Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=thunk.org header.i=@thunk.org header.b="Dji60DkQ"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mCG90kwSz9s8W for ; Thu, 9 Aug 2018 12:42:25 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727503AbeHIFEy (ORCPT ); Thu, 9 Aug 2018 01:04:54 -0400 Received: from imap.thunk.org ([74.207.234.97]:52960 "EHLO imap.thunk.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727158AbeHIFEx (ORCPT ); Thu, 9 Aug 2018 01:04:53 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=thunk.org; s=ef5046eb; h=References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From: Sender:Reply-To:MIME-Version:Content-Type:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=fp3xvWyJzkOOD8TkymB9PRr9+hshIQiV2lTZ5jUe6dQ=; b=Dji60DkQ9V9IW4rtQdhz0gxFD/ il7f4YhxA9JZ6w2qPIFK1DjLnYrtCI7g1L0fFeX1+xq+eQE2SQMDYWhkQEIycE+A18LZ3P0mp8AEa EKDpJPdff4wItXL7U65+GSNb3mUdvqI4SnB6a644BMUBzwtgNAzd9aX6qXrLaUnpobew=; Received: from root (helo=callcc.thunk.org) by imap.thunk.org with local-esmtp (Exim 4.89) (envelope-from ) id 1fnau6-0000aA-Rk; Thu, 09 Aug 2018 02:42:22 +0000 Received: by callcc.thunk.org (Postfix, from userid 15806) id BCB0F7A6515; Wed, 8 Aug 2018 22:42:21 -0400 (EDT) From: Theodore Ts'o To: Ext4 Developers List Cc: Theodore Ts'o Subject: [PATCH 3/5] e2fsck: fix LTO type warnings Date: Wed, 8 Aug 2018 22:42:17 -0400 Message-Id: <20180809024219.15696-3-tytso@mit.edu> X-Mailer: git-send-email 2.18.0.rc0 In-Reply-To: <20180809024219.15696-1-tytso@mit.edu> References: <20180809024219.15696-1-tytso@mit.edu> X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: tytso@thunk.org X-SA-Exim-Scanned: No (on imap.thunk.org); SAEximRunCond expanded to false Sender: linux-ext4-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org The jfs_user.h, which is used by the journal functions didn't include config.h before including e2fsck.h. This caused the e2fsck structure to be different compared how it's compiled for the other e2fsck source files. Signed-off-by: Theodore Ts'o --- e2fsck/jfs_user.h | 1 + 1 file changed, 1 insertion(+) diff --git a/e2fsck/jfs_user.h b/e2fsck/jfs_user.h index 828979514..a1c6951cb 100644 --- a/e2fsck/jfs_user.h +++ b/e2fsck/jfs_user.h @@ -27,6 +27,7 @@ /* * Pull in the definition of the e2fsck context structure */ +#include "config.h" #include "e2fsck.h" #endif From patchwork Thu Aug 9 02:42:18 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Theodore Ts'o X-Patchwork-Id: 955302 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=mit.edu Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=thunk.org header.i=@thunk.org header.b="pqUe0mFr"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mCG80hhWz9s4Z for ; Thu, 9 Aug 2018 12:42:24 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727393AbeHIFEx (ORCPT ); Thu, 9 Aug 2018 01:04:53 -0400 Received: from imap.thunk.org ([74.207.234.97]:52966 "EHLO imap.thunk.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727237AbeHIFEx (ORCPT ); Thu, 9 Aug 2018 01:04:53 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=thunk.org; s=ef5046eb; h=References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From: Sender:Reply-To:MIME-Version:Content-Type:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=kqYhvLnYWKFqzL03fn8I4d67bx/nXBnnqAfIiUhZvIA=; b=pqUe0mFriSLHtLeE+fRmFXbO8X ZTB0/sOyYE0eXMa8VWVVNS+KvKsJ3saAWGDTqeAH9bbsGt8fH6mPhp+KNKxTgDQR3EZLOw0QntaCb bB6S+iyVIJDUWphf2KBE6AmfDH3Unb42UvRrezbVILvFWNGUXZpUdZKHrrzMG7lCOPGE=; Received: from root (helo=callcc.thunk.org) by imap.thunk.org with local-esmtp (Exim 4.89) (envelope-from ) id 1fnau6-0000a8-SY; Thu, 09 Aug 2018 02:42:22 +0000 Received: by callcc.thunk.org (Postfix, from userid 15806) id C13BA7A6516; Wed, 8 Aug 2018 22:42:21 -0400 (EDT) From: Theodore Ts'o To: Ext4 Developers List Cc: Theodore Ts'o Subject: [PATCH 4/5] MCONFIG: move SANITIZER_CFLAGS out of CLFAGS Date: Wed, 8 Aug 2018 22:42:18 -0400 Message-Id: <20180809024219.15696-4-tytso@mit.edu> X-Mailer: git-send-email 2.18.0.rc0 In-Reply-To: <20180809024219.15696-1-tytso@mit.edu> References: <20180809024219.15696-1-tytso@mit.edu> X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: tytso@thunk.org X-SA-Exim-Scanned: No (on imap.thunk.org); SAEximRunCond expanded to false Sender: linux-ext4-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org CFLAGS is supposed to be something that can be overridden by the developer. So extra stuff like $(SANITIZER_CFLAGS) should not be defined there, but rather in ALL_CFLAGS. Signed-off-by: Theodore Ts'o --- MCONFIG.in | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/MCONFIG.in b/MCONFIG.in index c3b3740e5..ce0692ec5 100644 --- a/MCONFIG.in +++ b/MCONFIG.in @@ -86,13 +86,13 @@ SANITIZER_LDFLAGS = @lto_ldflags@ @ubsan_ldflags@ @addrsan_ldflags@ @threadsan_l CC = @CC@ BUILD_CC = @BUILD_CC@ -CFLAGS = $(SANITIZER_CFLAGS) @CFLAGS@ -CFLAGS_SHLIB = $(SANITIZER_CFLAGS) @CFLAGS_SHLIB@ -CFLAGS_STLIB = $(SANITIZER_CFLAGS) @CFLAGS_STLIB@ +CFLAGS = @CFLAGS@ +CFLAGS_SHLIB = @CFLAGS_SHLIB@ +CFLAGS_STLIB = @CFLAGS_STLIB@ CPPFLAGS = @INCLUDES@ -ALL_CFLAGS = $(CPPFLAGS) $(CFLAGS) $(CFLAGS_WARN) @DEFS@ $(LOCAL_CFLAGS) -ALL_CFLAGS_SHLIB = $(CPPFLAGS) $(CFLAGS_SHLIB) $(CFLAGS_WARN) @DEFS@ $(LOCAL_CFLAGS) -ALL_CFLAGS_STLIB = $(CPPFLAGS) $(CFLAGS_STLIB) $(CFLAGS_WARN) @DEFS@ $(LOCAL_CFLAGS) +ALL_CFLAGS = $(CPPFLAGS) $(SANITIZER_CFLAGS) $(CFLAGS) $(CFLAGS_WARN) @DEFS@ $(LOCAL_CFLAGS) +ALL_CFLAGS_SHLIB = $(CPPFLAGS) $(SANITIZER_CFLAGS) $(CFLAGS_SHLIB) $(CFLAGS_WARN) @DEFS@ $(LOCAL_CFLAGS) +ALL_CFLAGS_STLIB = $(CPPFLAGS) $(SANITIZER_CFLAGS) $(CFLAGS_STLIB) $(CFLAGS_WARN) @DEFS@ $(LOCAL_CFLAGS) LDFLAGS = $(SANITIZER_LDFLAGS) @LDFLAGS@ LDFLAGS_SHLIB = $(SANITIZER_LDFLAGS) @LDFLAGS_SHLIB@ ALL_LDFLAGS = $(LDFLAGS) @LDFLAG_DYNAMIC@ From patchwork Thu Aug 9 02:42:19 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Theodore Ts'o X-Patchwork-Id: 955304 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-ext4-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=mit.edu Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=thunk.org header.i=@thunk.org header.b="cjNSXAGL"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41mCG965R9z9sBJ for ; Thu, 9 Aug 2018 12:42:25 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727395AbeHIFEy (ORCPT ); Thu, 9 Aug 2018 01:04:54 -0400 Received: from imap.thunk.org ([74.207.234.97]:52968 "EHLO imap.thunk.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727371AbeHIFEx (ORCPT ); Thu, 9 Aug 2018 01:04:53 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=thunk.org; s=ef5046eb; h=References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From: Sender:Reply-To:MIME-Version:Content-Type:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=8WZqB5+T483lurnEbKYC8sLH3dp5aB1xV30Tbm5HA5s=; b=cjNSXAGLM0cGzVeuSt2a1pO0+P tpqlotyKtf24j4tI7enmzQmxNZqP+lOu7Wq045uBeUKwu03k7ThRQHRs84Yd9tp01U830MItd/Ptz KEpOWvFGDBG+bKldhp2v4gPApLyv9otcEBL/9QRJnrlPJIGPbS+x7U1J6Eq31FGKQQgI=; Received: from root (helo=callcc.thunk.org) by imap.thunk.org with local-esmtp (Exim 4.89) (envelope-from ) id 1fnau6-0000aB-Ta; Thu, 09 Aug 2018 02:42:22 +0000 Received: by callcc.thunk.org (Postfix, from userid 15806) id C5F9A7A6517; Wed, 8 Aug 2018 22:42:21 -0400 (EDT) From: Theodore Ts'o To: Ext4 Developers List Cc: Theodore Ts'o Subject: [PATCH 5/5] Fix LTO builds so debugging information is preserved Date: Wed, 8 Aug 2018 22:42:19 -0400 Message-Id: <20180809024219.15696-5-tytso@mit.edu> X-Mailer: git-send-email 2.18.0.rc0 In-Reply-To: <20180809024219.15696-1-tytso@mit.edu> References: <20180809024219.15696-1-tytso@mit.edu> X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: tytso@thunk.org X-SA-Exim-Scanned: No (on imap.thunk.org); SAEximRunCond expanded to false Sender: linux-ext4-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org Signed-off-by: Theodore Ts'o --- configure | 2 +- configure.ac | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/configure b/configure index 1493e1527..f5092e3b6 100755 --- a/configure +++ b/configure @@ -13763,7 +13763,7 @@ if test "$enable_lto" = "yes" || test "$enable_lto" = "probe"; then $as_echo_n "checking if C compiler supports LTO... " >&6; } OLD_CFLAGS="$CFLAGS" OLD_LDFLAGS="$LDFLAGS" - LTO_FLAGS="-flto -ffat-lto-objects" + LTO_FLAGS="-g -flto -ffat-lto-objects" CFLAGS="$CFLAGS $LTO_FLAGS" LDFLAGS="$LDFLAGS $LTO_FLAGS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext diff --git a/configure.ac b/configure.ac index fe717d090..54bd1fe1a 100644 --- a/configure.ac +++ b/configure.ac @@ -1305,7 +1305,7 @@ if test "$enable_lto" = "yes" || test "$enable_lto" = "probe"; then AC_MSG_CHECKING([if C compiler supports LTO]) OLD_CFLAGS="$CFLAGS" OLD_LDFLAGS="$LDFLAGS" - LTO_FLAGS="-flto -ffat-lto-objects" + LTO_FLAGS="-g -flto -ffat-lto-objects" CFLAGS="$CFLAGS $LTO_FLAGS" LDFLAGS="$LDFLAGS $LTO_FLAGS" AC_LINK_IFELSE([AC_LANG_PROGRAM([])],