From nobody Thu Apr 16 10:43:13 2026 Received: from sender4-of-o54.zoho.com (sender4-of-o54.zoho.com [136.143.188.54]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AB111421EE9; Sat, 28 Feb 2026 12:24:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=136.143.188.54 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772281469; cv=pass; b=W+jcgw1WMFDFdGfZpfz3WB0y6lNhwUBqf+jC6j9AGLaj0XkowjOjr1AXfp7yI/g6tLxcY6uM55X/l9smQjp9hoHrBPFfy0Q9AFFSYFSlgctXi4EFOT4l5qE5EQ6xwVUWlKSZT3Uk82z4hr+g1vgLl56Xaf3gJF47DtOYXiAHDt8= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772281469; c=relaxed/simple; bh=QlpfaqnfiAJKueVBPMFM59rsH19GQ7nBBUP21TBB7Kg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=HOb93HAX61SYCVsN/ze51E+XMKVKhanDSYRHavqvGEnMF7bASDT6yrmXC5MNtJGYTWypSH9eAQhV1m/JBMTmmUyPns9dEWHhEmtOHo7TeRZhSqFR9AAocyVA9yJ5CjTBvBwErND78jSItYllcq62CsdOtR9e+XlBctPXPy2BR1k= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mpiricsoftware.com; spf=pass smtp.mailfrom=mpiricsoftware.com; dkim=pass (1024-bit key) header.d=mpiricsoftware.com header.i=shardul.b@mpiricsoftware.com header.b=i6w27UYa; arc=pass smtp.client-ip=136.143.188.54 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mpiricsoftware.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=mpiricsoftware.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=mpiricsoftware.com header.i=shardul.b@mpiricsoftware.com header.b="i6w27UYa" ARC-Seal: i=1; a=rsa-sha256; t=1772281399; cv=none; d=zohomail.com; s=zohoarc; b=I7BddgN+KE4XsTKRCflWvxrNxayyhlWBn8XBtDwArs01hX12yuVHWm7rY73Qf6fJ67wc0nWrNPVc3enI2LWCq70b9vfVamTeVxSphmcKvnEB3Ox9EOW2tCoGb0d3R2CsrZ2dCggQ/6MpD0lmQd+nIFr4GYE9QlpiymvbAjBEONE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1772281399; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=wYt2H6kHY1UF1JYY5uKYhQ/9LANzexon3qFvyMq2Q0w=; b=azzPS666WxljPehMJgiw0T5vH5cF/C9qf8Fh8NfSvfCaUlo6//13Z5OQgc6ov71DBjcxkaZLdutvnc9RMKG/K/XPgF+eGe0Z14QdOsblUPv5cQk9wfevW1h1hR1U85ixtfVqZik6QF+CRd2AcrHQnBz+9d7HqlVogZdKGGG9jQo= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=mpiricsoftware.com; spf=pass smtp.mailfrom=shardul.b@mpiricsoftware.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1772281399; s=mpiric; d=mpiricsoftware.com; i=shardul.b@mpiricsoftware.com; h=From:From:To:To:Cc:Cc:Subject:Subject:Date:Date:Message-Id:Message-Id:In-Reply-To:References:MIME-Version:Content-Transfer-Encoding:Reply-To; bh=wYt2H6kHY1UF1JYY5uKYhQ/9LANzexon3qFvyMq2Q0w=; b=i6w27UYa+eMDNL2SfvWzvGkvPOfgvzec/q4EN0p3eUhYwqv44JPEPAhbl7HOWQ5c ukT+yuZJUxx7c9xq1ClVEC2YOf5rSclN3TjDIQVI0EH76gSDRYqHzbKDmmFnr9ZhGU3 +LHtXB3eNosYc/sPpkMCYyGUJTbMgRXZu5oeoVmY= Received: by mx.zohomail.com with SMTPS id 1772281397042429.53615914485624; Sat, 28 Feb 2026 04:23:17 -0800 (PST) From: Shardul Bankar To: slava@dubeyko.com, glaubitz@physik.fu-berlin.de, frank.li@vivo.com, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org Cc: janak@mpiricsoftware.com, janak@mpiric.us, shardulsb08@gmail.com, Shardul Bankar Subject: [PATCH v5 1/2] hfsplus: refactor b-tree map page access and add node-type validation Date: Sat, 28 Feb 2026 17:53:04 +0530 Message-Id: <20260228122305.1406308-2-shardul.b@mpiricsoftware.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260228122305.1406308-1-shardul.b@mpiricsoftware.com> References: <20260228122305.1406308-1-shardul.b@mpiricsoftware.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-ZohoMailClient: External Content-Type: text/plain; charset="utf-8" In HFS+ b-trees, the node allocation bitmap is stored across multiple records. The first chunk resides in the b-tree Header Node at record index 2, while all subsequent chunks are stored in dedicated Map Nodes at record index 0. This structural quirk forces callers like hfs_bmap_alloc() and hfs_bmap_free() to duplicate boilerplate code to validate offsets, correct lengths, and map the underlying pages via kmap_local_page(). There is also currently no strict node-type validation before reading these records, leaving the allocator vulnerable if a corrupted image points a map linkage to an Index or Leaf node. Introduce a unified bit-level API to encapsulate the map record access: 1. A new 'struct hfs_bmap_ctx' to cleanly pass state and safely handle page math across all architectures. 2. 'hfs_bmap_get_map_page()': Automatically validates node types (HFS_NODE_HEADER vs HFS_NODE_MAP), infers the correct record index, and handles page-boundary math for records that span multiple pages. 3. 'hfs_bmap_test_bit()' and 'hfs_bmap_clear_bit()': Clean wrappers that internally handle page mapping/unmapping for single-bit operations. Refactor hfs_bmap_alloc() and hfs_bmap_free() to utilize this new API. This deduplicates the allocator logic, hardens the map traversal against fuzzed images, and provides the exact abstractions needed for upcoming mount-time validation checks. Signed-off-by: Shardul Bankar --- fs/hfsplus/btree.c | 186 +++++++++++++++++++++++++++---------- include/linux/hfs_common.h | 2 + 2 files changed, 141 insertions(+), 47 deletions(-) diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c index 1220a2f22737..87650e23cd65 100644 --- a/fs/hfsplus/btree.c +++ b/fs/hfsplus/btree.c @@ -129,6 +129,116 @@ u32 hfsplus_calc_btree_clump_size(u32 block_size, u32= node_size, return clump_size; } =20 +/* Context for iterating b-tree map pages */ +struct hfs_bmap_ctx { + unsigned int page_idx; + unsigned int off; + u16 len; +}; + +/* + * Maps the specific page containing the requested byte offset within the = map + * record. + * Automatically handles the difference between header and map nodes. + * Returns the mapped data pointer, or an ERR_PTR on failure. + * Note: The caller is responsible for calling kunmap_local(data). + */ +static u8 *hfs_bmap_get_map_page(struct hfs_bnode *node, struct hfs_bmap_c= tx *ctx, + u32 byte_offset) +{ + u16 rec_idx, off16; + unsigned int page_off; /* 32-bit math prevents LKP overflow warnings */ + + if (node->this =3D=3D HFSPLUS_TREE_HEAD) { + if (node->type !=3D HFS_NODE_HEADER) { + pr_err("hfsplus: invalid btree header node\n"); + return ERR_PTR(-EIO); + } + rec_idx =3D HFSPLUS_BTREE_HDR_MAP_REC_INDEX; + } else { + if (node->type !=3D HFS_NODE_MAP) { + pr_err("hfsplus: invalid btree map node\n"); + return ERR_PTR(-EIO); + } + rec_idx =3D HFSPLUS_BTREE_MAP_NODE_REC_INDEX; + } + + ctx->len =3D hfs_brec_lenoff(node, rec_idx, &off16); + if (!ctx->len) + return ERR_PTR(-ENOENT); + + if (!is_bnode_offset_valid(node, off16)) + return ERR_PTR(-EIO); + + ctx->len =3D check_and_correct_requested_length(node, off16, ctx->len); + + if (byte_offset >=3D ctx->len) + return ERR_PTR(-EINVAL); + + page_off =3D off16 + node->page_offset + byte_offset; + ctx->page_idx =3D page_off >> PAGE_SHIFT; + ctx->off =3D page_off & ~PAGE_MASK; + + return kmap_local_page(node->page[ctx->page_idx]); +} + +/** + * hfs_bmap_test_bit - test a bit in the b-tree map + * @node: the b-tree node containing the map record + * @bit_idx: the bit index relative to the start of the map record + * + * Returns 1 if set, 0 if clear, or a negative error code on failure. + */ +static int hfs_bmap_test_bit(struct hfs_bnode *node, u32 bit_idx) +{ + struct hfs_bmap_ctx ctx; + u8 *data, byte, m; + int res; + + data =3D hfs_bmap_get_map_page(node, &ctx, bit_idx / 8); + if (IS_ERR(data)) + return PTR_ERR(data); + + byte =3D data[ctx.off]; + kunmap_local(data); + + /* In HFS+ bitmaps, bit 0 is the MSB (0x80) */ + m =3D 1 << (~bit_idx & 7); + res =3D (byte & m) ? 1 : 0; + + return res; +} + +/** + * hfs_bmap_clear_bit - clear a bit in the b-tree map + * @node: the b-tree node containing the map record + * @bit_idx: the bit index relative to the start of the map record + * + * Returns 0 on success, -EALREADY if already clear, or negative error cod= e. + */ +static int hfs_bmap_clear_bit(struct hfs_bnode *node, u32 bit_idx) +{ + struct hfs_bmap_ctx ctx; + u8 *data, m; + + data =3D hfs_bmap_get_map_page(node, &ctx, bit_idx / 8); + if (IS_ERR(data)) + return PTR_ERR(data); + + m =3D 1 << (~bit_idx & 7); + + if (!(data[ctx.off] & m)) { + kunmap_local(data); + return -EALREADY; + } + + data[ctx.off] &=3D ~m; + set_page_dirty(node->page[ctx.page_idx]); + kunmap_local(data); + + return 0; +} + /* Get a reference to a B*Tree and do some initial checks */ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id) { @@ -374,11 +484,8 @@ int hfs_bmap_reserve(struct hfs_btree *tree, u32 rsvd_= nodes) struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree) { struct hfs_bnode *node, *next_node; - struct page **pagep; + struct hfs_bmap_ctx ctx; u32 nidx, idx; - unsigned off; - u16 off16; - u16 len; u8 *data, byte, m; int i, res; =20 @@ -390,30 +497,25 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tr= ee) node =3D hfs_bnode_find(tree, nidx); if (IS_ERR(node)) return node; - len =3D hfs_brec_lenoff(node, 2, &off16); - off =3D off16; =20 - if (!is_bnode_offset_valid(node, off)) { + data =3D hfs_bmap_get_map_page(node, &ctx, 0); + if (IS_ERR(data)) { + res =3D PTR_ERR(data); hfs_bnode_put(node); - return ERR_PTR(-EIO); + return ERR_PTR(res); } - len =3D check_and_correct_requested_length(node, off, len); =20 - off +=3D node->page_offset; - pagep =3D node->page + (off >> PAGE_SHIFT); - data =3D kmap_local_page(*pagep); - off &=3D ~PAGE_MASK; idx =3D 0; =20 for (;;) { - while (len) { - byte =3D data[off]; + while (ctx.len) { + byte =3D data[ctx.off]; if (byte !=3D 0xff) { for (m =3D 0x80, i =3D 0; i < 8; m >>=3D 1, i++) { if (!(byte & m)) { idx +=3D i; - data[off] |=3D m; - set_page_dirty(*pagep); + data[ctx.off] |=3D m; + set_page_dirty(node->page[ctx.page_idx]); kunmap_local(data); tree->free_nodes--; mark_inode_dirty(tree->inode); @@ -423,13 +525,13 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tr= ee) } } } - if (++off >=3D PAGE_SIZE) { + if (++ctx.off >=3D PAGE_SIZE) { kunmap_local(data); - data =3D kmap_local_page(*++pagep); - off =3D 0; + data =3D kmap_local_page(node->page[++ctx.page_idx]); + ctx.off =3D 0; } idx +=3D 8; - len--; + ctx.len--; } kunmap_local(data); nidx =3D node->next; @@ -443,22 +545,21 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tr= ee) return next_node; node =3D next_node; =20 - len =3D hfs_brec_lenoff(node, 0, &off16); - off =3D off16; - off +=3D node->page_offset; - pagep =3D node->page + (off >> PAGE_SHIFT); - data =3D kmap_local_page(*pagep); - off &=3D ~PAGE_MASK; + data =3D hfs_bmap_get_map_page(node, &ctx, 0); + if (IS_ERR(data)) { + res =3D PTR_ERR(data); + hfs_bnode_put(node); + return ERR_PTR(res); + } } } =20 void hfs_bmap_free(struct hfs_bnode *node) { struct hfs_btree *tree; - struct page *page; u16 off, len; u32 nidx; - u8 *data, byte, m; + int res; =20 hfs_dbg("node %u\n", node->this); BUG_ON(!node->this); @@ -495,24 +596,15 @@ void hfs_bmap_free(struct hfs_bnode *node) } len =3D hfs_brec_lenoff(node, 0, &off); } - off +=3D node->page_offset + nidx / 8; - page =3D node->page[off >> PAGE_SHIFT]; - data =3D kmap_local_page(page); - off &=3D ~PAGE_MASK; - m =3D 1 << (~nidx & 7); - byte =3D data[off]; - if (!(byte & m)) { - pr_crit("trying to free free bnode " - "%u(%d)\n", - node->this, node->type); - kunmap_local(data); - hfs_bnode_put(node); - return; + + res =3D hfs_bmap_clear_bit(node, nidx); + if (res =3D=3D -EALREADY) { + pr_crit("trying to free free bnode %u(%d)\n", + node->this, node->type); + } else if (!res) { + tree->free_nodes++; + mark_inode_dirty(tree->inode); } - data[off] =3D byte & ~m; - set_page_dirty(page); - kunmap_local(data); + hfs_bnode_put(node); - tree->free_nodes++; - mark_inode_dirty(tree->inode); } diff --git a/include/linux/hfs_common.h b/include/linux/hfs_common.h index dadb5e0aa8a3..be24c687858e 100644 --- a/include/linux/hfs_common.h +++ b/include/linux/hfs_common.h @@ -510,6 +510,8 @@ struct hfs_btree_header_rec { #define HFSPLUS_NODE_MXSZ 32768 #define HFSPLUS_ATTR_TREE_NODE_SIZE 8192 #define HFSPLUS_BTREE_HDR_NODE_RECS_COUNT 3 +#define HFSPLUS_BTREE_HDR_MAP_REC_INDEX 2 /* Map (bitmap) record in Heade= r node */ +#define HFSPLUS_BTREE_MAP_NODE_REC_INDEX 0 /* Map record in Map Node */ #define HFSPLUS_BTREE_HDR_USER_BYTES 128 =20 /* btree key type */ --=20 2.34.1 From nobody Thu Apr 16 10:43:13 2026 Received: from sender4-of-o54.zoho.com (sender4-of-o54.zoho.com [136.143.188.54]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EE9A6423141; Sat, 28 Feb 2026 12:24:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=136.143.188.54 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772281486; cv=pass; b=lZMId6c0yOsSKjdCOZH+J4V4BkiQ4rC+NfWCCny/Dr8vDmlXftWmrKfjfmvbsBjHcbCzR0pdS6iKhYcydB2GAkjcTsUE+1lWRiQz7A9oPd8qgXqjMHWo/lslfQc0OA/tt42VNaNL0TdpyW3LiY/T0nN8IuuFlxeJWvVhOuVrTqA= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772281486; c=relaxed/simple; bh=D8IQ/dSgkS8q4qDP/WHoXvMPzPsf0DvQXi4zEMgXOh4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=G6XEUqrjP8nTO/m8y8QVvps2JVgT7edLjGnrS4CsPRPVvQTB4zHpSduZu8Sz3l0PJz2ItggK08Ebo979dOzeenCq9Rp4pcl1rc+8gOw5XN6EWaiu2+p8IkWUtmD4H901epYQLb14bTxVladfqBaLNSmQvGtIhymOyCWlMGhywww= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mpiricsoftware.com; spf=pass smtp.mailfrom=mpiricsoftware.com; dkim=pass (1024-bit key) header.d=mpiricsoftware.com header.i=shardul.b@mpiricsoftware.com header.b=VVGWNGjT; arc=pass smtp.client-ip=136.143.188.54 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mpiricsoftware.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=mpiricsoftware.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=mpiricsoftware.com header.i=shardul.b@mpiricsoftware.com header.b="VVGWNGjT" ARC-Seal: i=1; a=rsa-sha256; t=1772281403; cv=none; d=zohomail.com; s=zohoarc; b=EHKeQ/g28D3PcojRPEv626YXrTDhIbJ2/copoExbyLCwp9nF+dfbLVP4Ep2iGniW5ypV+uxd+pDhHePVIkYfpLklVAw4iNDKPx+KrYj1iDFo5GIx8wMHZkxsNuwKHnYXfb0cfRJRp31aLvQQXyvGnO5kFdcpviBTzCxwb/ZKeRo= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1772281403; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=pn9CST5OW722hXNukxq5ItUixPhC81Qjbu1Drjb5oJY=; b=DXPBHn9bM3n9njs53eyJNmIuLKDYCovgr+otc6ZVMO+fNa/+XhA9KHoOjlo4pj69rF0nwG3mYdrfntMZWEQBO9NzkIi3pjQyqyNzL97BWdfgqEwZ9jnKzAHn4JIowiGS4ylLSUHrfKQfJlXmW7qAs7w+sIp9nLVgk1TcZfj2aOU= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=mpiricsoftware.com; spf=pass smtp.mailfrom=shardul.b@mpiricsoftware.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1772281403; s=mpiric; d=mpiricsoftware.com; i=shardul.b@mpiricsoftware.com; h=From:From:To:To:Cc:Cc:Subject:Subject:Date:Date:Message-Id:Message-Id:In-Reply-To:References:MIME-Version:Content-Transfer-Encoding:Reply-To; bh=pn9CST5OW722hXNukxq5ItUixPhC81Qjbu1Drjb5oJY=; b=VVGWNGjT1y/4T2VEg9vscuMT52Z+RRhT8UqZRZlqHlDfe+EfRgmkc03itd3/a8nG wWMhRQ37uJMZCtD1DPMz1+U8cU1EW1A1xhIN4OYrPCzBydrW1aQc6RLzRTGzKbw99M7 xxcBGmRwSqKTLmaO/mWy1Cy88x6PDIWd8O4axB4I= Received: by mx.zohomail.com with SMTPS id 1772281401429696.177219428546; Sat, 28 Feb 2026 04:23:21 -0800 (PST) From: Shardul Bankar To: slava@dubeyko.com, glaubitz@physik.fu-berlin.de, frank.li@vivo.com, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org Cc: janak@mpiricsoftware.com, janak@mpiric.us, shardulsb08@gmail.com, Shardul Bankar , syzbot+1c8ff72d0cd8a50dfeaa@syzkaller.appspotmail.com Subject: [PATCH v5 2/2] hfsplus: validate b-tree node 0 bitmap at mount time Date: Sat, 28 Feb 2026 17:53:05 +0530 Message-Id: <20260228122305.1406308-3-shardul.b@mpiricsoftware.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260228122305.1406308-1-shardul.b@mpiricsoftware.com> References: <20260228122305.1406308-1-shardul.b@mpiricsoftware.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-ZohoMailClient: External Content-Type: text/plain; charset="utf-8" Syzkaller reported an issue with corrupted HFS+ images where the b-tree allocation bitmap indicates that the header node (Node 0) is free. Node 0 must always be allocated as it contains the b-tree header record and the allocation bitmap itself. Violating this invariant leads to allocator corruption, which cascades into kernel panics or undefined behavior when the filesystem attempts to allocate blocks. Prevent trusting a corrupted allocator state by adding a validation check during hfs_btree_open(). Using the newly introduced hfs_bmap_test_bit() helper, verify that the MSB of the first bitmap byte (representing Node 0) is marked as allocated. If corruption is detected (either structurally invalid map records or an illegally cleared bit), print a warning identifying the specific corrupted tree and force the filesystem to mount read-only (SB_RDONLY). This prevents kernel panics from corrupted images while enabling data recovery. Reported-by: syzbot+1c8ff72d0cd8a50dfeaa@syzkaller.appspotmail.com Link: https://syzkaller.appspot.com/bug?extid=3D1c8ff72d0cd8a50dfeaa Link: https://lore.kernel.org/all/54dc9336b514fb10547e27c7d6e1b8b967ee2eda.= camel@ibm.com/ Signed-off-by: Shardul Bankar --- fs/hfsplus/btree.c | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c index 87650e23cd65..ee1edb03a38e 100644 --- a/fs/hfsplus/btree.c +++ b/fs/hfsplus/btree.c @@ -239,15 +239,31 @@ static int hfs_bmap_clear_bit(struct hfs_bnode *node,= u32 bit_idx) return 0; } =20 +static const char *hfs_btree_name(u32 cnid) +{ + static const char * const tree_names[] =3D { + [HFSPLUS_EXT_CNID] =3D "Extents", + [HFSPLUS_CAT_CNID] =3D "Catalog", + [HFSPLUS_ATTR_CNID] =3D "Attributes", + }; + + if (cnid < ARRAY_SIZE(tree_names) && tree_names[cnid]) + return tree_names[cnid]; + + return "Unknown"; +} + /* Get a reference to a B*Tree and do some initial checks */ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id) { struct hfs_btree *tree; struct hfs_btree_header_rec *head; struct address_space *mapping; + struct hfs_bnode *node; struct inode *inode; struct page *page; unsigned int size; + int res; =20 tree =3D kzalloc_obj(*tree); if (!tree) @@ -352,6 +368,26 @@ struct hfs_btree *hfs_btree_open(struct super_block *s= b, u32 id) =20 kunmap_local(head); put_page(page); + + node =3D hfs_bnode_find(tree, HFSPLUS_TREE_HEAD); + if (IS_ERR(node)) + goto free_inode; + + res =3D hfs_bmap_test_bit(node, 0); + if (res < 0) { + pr_warn("(%s): %s Btree (cnid 0x%x) map record invalid/corrupted, forcin= g read-only.\n", + sb->s_id, hfs_btree_name(id), id); + pr_warn("Run fsck.hfsplus to repair.\n"); + sb->s_flags |=3D SB_RDONLY; + } else if (res =3D=3D 0) { + pr_warn("(%s): %s Btree (cnid 0x%x) bitmap corruption detected, forcing = read-only.\n", + sb->s_id, hfs_btree_name(id), id); + pr_warn("Run fsck.hfsplus to repair.\n"); + sb->s_flags |=3D SB_RDONLY; + } + + hfs_bnode_put(node); + return tree; =20 fail_page: --=20 2.34.1